Changeset 376

Show
Ignore:
Timestamp:
01/20/07 10:25:59 (16 years ago)
Author:
wagi
Message:

De/Serialize function added to subunit
Give AvDevice? reference to all deserialize functions (instead of
several arguments like config rom etc)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libfreebob/src/bebob/bebob_avdevice.cpp

    r375 r376  
    552552        switch( subunit_type ) { 
    553553        case AVCCommand::eST_Audio: 
    554             subunit = new AvDeviceSubunitAudio( *this, subunitId, 
     554            subunit = new AvDeviceSubunitAudio( *this, 
     555                                                subunitId, 
    555556                                                m_verboseLevel ); 
    556557            if ( !subunit ) { 
    …… 
    564565            break; 
    565566        case AVCCommand::eST_Music: 
    566             subunit = new AvDeviceSubunitMusic( *this, subunitId, 
     567            subunit = new AvDeviceSubunitMusic( *this, 
     568                                                subunitId, 
    567569                                                m_verboseLevel ); 
    568570            if ( !subunit ) { 
    …… 
    12481250template <typename T, typename VT> bool deserializeVector( Glib::ustring path, 
    12491251                                                           Util::IODeserialize& deser, 
    1250                                                            Ieee1394Service& ieee1394Service, 
    1251                                                            ConfigRom& configRom, 
    1252                                                            AvPlugManager& plugManager, 
     1252                                                           AvDevice& avDevice, 
    12531253                                                           VT& vec ) 
    12541254{ 
    …… 
    12601260        T* ptr = T::deserialize( strstrm.str() + "/", 
    12611261                                 deser, 
    1262                                  ieee1394Service, 
    1263                                  configRom, 
    1264                                  plugManager ); 
     1262                                 avDevice ); 
    12651263        if ( ptr ) { 
    12661264            vec.push_back( ptr ); 
    …… 
    13251323        bool result; 
    13261324        result  = deser.read( basePath + "m_verboseLevel", pDev->m_verboseLevel ); 
    1327         pDev->m_pPlugManager = AvPlugManager::deserialize( basePath + "AvPlug", deser, ieee1394Service, *pDev->m_pConfigRom.get() ); 
     1325        pDev->m_pPlugManager = AvPlugManager::deserialize( basePath + "AvPlug", deser, *pDev ); 
    13281326        if ( !pDev->m_pPlugManager ) { 
    13291327            delete pDev; 
    …… 
    13321330        result &= deserializeAvPlugUpdateConnections( basePath + "AvPlug", deser, pDev->m_pcrPlugs ); 
    13331331        result &= deserializeAvPlugUpdateConnections( basePath + "AvPlug", deser, pDev->m_externalPlugs ); 
    1334         result &= deserializeVector<AvPlugConnection>( basePath + "PlugConnnection", deser, ieee1394Service, *pDev->m_pConfigRom.get(), *pDev->m_pPlugManager, pDev->m_plugConnections ); 
    1335         result &= deserializeVector<AvDeviceSubunit>( basePath + "Subunit",  deser, ieee1394Service, *pDev->m_pConfigRom.get(), *pDev->m_pPlugManager, pDev->m_subunits ); 
     1332        result &= deserializeVector<AvPlugConnection>( basePath + "PlugConnnection", deser, *pDev, pDev->m_plugConnections ); 
     1333        result &= deserializeVector<AvDeviceSubunit>( basePath + "Subunit",  deser, *pDev, pDev->m_subunits ); 
    13361334 
    13371335        // XXX ... 

  • trunk/libfreebob/src/bebob/bebob_avdevice_subunit.cpp

    r375 r376  
    11/* bebob_avdevice_subunit.cpp 
    2  * Copyright (C) 2005,06 by Daniel Wagner 
     2 * Copyright (C) 2005,06,07 by Daniel Wagner 
    33 * 
    44 * This file is part of FreeBoB. 
    …… 
    2929#include "libfreebobavc/avc_serialize.h" 
    3030 
    31 namespace BeBoB { 
    32  
    33 IMPL_DEBUG_MODULE( AvDeviceSubunit, AvDeviceSubunit, DEBUG_LEVEL_VERBOSE ); 
     31#include <sstream> 
     32 
     33IMPL_DEBUG_MODULE( BeBoB::AvDeviceSubunit, BeBoB::AvDeviceSubunit, DEBUG_LEVEL_VERBOSE ); 
    3434 
    3535//////////////////////////////////////////// 
    3636 
    37 AvDeviceSubunit::AvDeviceSubunit( AvDevice& avDevice, 
    38                                   AVCCommand::ESubunitType type, 
    39                                   subunit_t id, 
    40                                   int verboseLevel ) 
     37BeBoB::AvDeviceSubunit::AvDeviceSubunit( AvDevice& avDevice, 
     38                                         AVCCommand::ESubunitType type, 
     39                                         subunit_t id, 
     40                                         int verboseLevel ) 
    4141    : m_avDevice( &avDevice ) 
    4242    , m_sbType( type ) 
    …… 
    4747} 
    4848 
    49 AvDeviceSubunit::~AvDeviceSubunit() 
     49BeBoB::AvDeviceSubunit::AvDeviceSubunit() 
     50{ 
     51} 
     52 
     53BeBoB::AvDeviceSubunit::~AvDeviceSubunit() 
    5054{ 
    5155    for ( AvPlugVector::iterator it = m_plugs.begin(); 
    …… 
    5862 
    5963bool 
    60 AvDeviceSubunit::discover() 
     64BeBoB::AvDeviceSubunit::discover() 
    6165{ 
    6266    if ( !discoverPlugs() ) { 
    …… 
    6973 
    7074bool 
    71 AvDeviceSubunit::discoverPlugs() 
     75BeBoB::AvDeviceSubunit::discoverPlugs() 
    7276{ 
    7377    PlugInfoCmd plugInfoCmd( m_avDevice->get1394Service(), 
    …… 
    107111 
    108112bool 
    109 AvDeviceSubunit::discoverConnections() 
     113BeBoB::AvDeviceSubunit::discoverConnections() 
    110114{ 
    111115    for ( AvPlugVector::iterator it = m_plugs.begin(); 
    …… 
    125129 
    126130bool 
    127 AvDeviceSubunit::discoverPlugs(AvPlug::EAvPlugDirection plugDirection, 
    128                                plug_id_t plugMaxId ) 
     131BeBoB::AvDeviceSubunit::discoverPlugs(AvPlug::EAvPlugDirection plugDirection, 
     132                                      plug_id_t plugMaxId ) 
    129133{ 
    130134    for ( int plugIdx = 0; 
    …… 
    158162 
    159163bool 
    160 AvDeviceSubunit::addPlug( AvPlug& plug ) 
     164BeBoB::AvDeviceSubunit::addPlug( AvPlug& plug ) 
    161165{ 
    162166    m_plugs.push_back( &plug ); 
    …… 
    165169 
    166170 
    167 AvPlug* 
    168 AvDeviceSubunit::getPlug(AvPlug::EAvPlugDirection direction, plug_id_t plugId) 
     171BeBoB::AvPlug* 
     172BeBoB::AvDeviceSubunit::getPlug(AvPlug::EAvPlugDirection direction, plug_id_t plugId) 
    169173{ 
    170174    for ( AvPlugVector::iterator it = m_plugs.begin(); 
    …… 
    184188 
    185189bool 
    186 AvDeviceSubunit::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const 
    187 { 
    188     return true; 
    189 } 
    190  
    191 AvDeviceSubunit* 
    192 AvDeviceSubunit::deserialize( Glib::ustring basePath, 
    193                               Util::IODeserialize& deser, 
    194                               Ieee1394Service& ieee1394Service, 
    195                               ConfigRom& configRom, 
    196                               AvPlugManager& plugManager ) 
    197 { 
    198     return 0; 
     190BeBoB::AvDeviceSubunit::serialize( Glib::ustring basePath, 
     191                                   Util::IOSerialize& ser ) const 
     192{ 
     193    bool result; 
     194 
     195    result  = ser.write( basePath + "m_sbType", m_sbType ); 
     196    result &= ser.write( basePath + "m_sbId", m_sbId ); 
     197    result &= ser.write( basePath + "m_verboseLevel", m_verboseLevel ); 
     198    result &= serializeChild( basePath, ser ); 
     199 
     200    return result; 
     201} 
     202 
     203BeBoB::AvDeviceSubunit* 
     204BeBoB::AvDeviceSubunit::deserialize( Glib::ustring basePath, 
     205                                     Util::IODeserialize& deser, 
     206                                     AvDevice& avDevice ) 
     207{ 
     208    bool result; 
     209    AVCCommand::ESubunitType sbType; 
     210    result  = deser.read( basePath + "m_sbType", sbType ); 
     211 
     212    AvDeviceSubunit* pSubunit = 0; 
     213    switch( sbType ) { 
     214    case AVCCommand::eST_Audio: 
     215        pSubunit = new AvDeviceSubunitAudio; 
     216        break; 
     217    case AVCCommand::eST_Music: 
     218        pSubunit = new AvDeviceSubunitMusic; 
     219        break; 
     220    default: 
     221        pSubunit = 0; 
     222    } 
     223 
     224    if ( !pSubunit ) { 
     225        return 0; 
     226    } 
     227 
     228    pSubunit->m_avDevice = &avDevice; 
     229    pSubunit->m_sbType = sbType; 
     230    result &= deser.read( basePath + "m_sbId", pSubunit->m_sbId ); 
     231    result &= deser.read( basePath + "m_verboseLevel", pSubunit->m_verboseLevel ); 
     232    result &= pSubunit->deserializeChild( basePath, deser, avDevice ); 
     233 
     234    if ( !result ) { 
     235        delete pSubunit; 
     236        return 0; 
     237    } 
     238 
     239    return pSubunit; 
    199240} 
    200241 
    201242//////////////////////////////////////////// 
    202243 
    203 AvDeviceSubunitAudio::AvDeviceSubunitAudio( AvDevice& avDevice, 
    204                                             subunit_t id, 
    205                                             int verboseLevel ) 
     244BeBoB::AvDeviceSubunitAudio::AvDeviceSubunitAudio( AvDevice& avDevice, 
     245                                                   subunit_t id, 
     246                                                   int verboseLevel ) 
    206247    : AvDeviceSubunit( avDevice, AVCCommand::eST_Audio, id, verboseLevel ) 
    207248{ 
    208249} 
    209250 
    210 AvDeviceSubunitAudio::~AvDeviceSubunitAudio() 
     251BeBoB::AvDeviceSubunitAudio::AvDeviceSubunitAudio() 
     252    : AvDeviceSubunit() 
     253{ 
     254} 
     255 
     256BeBoB::AvDeviceSubunitAudio::~AvDeviceSubunitAudio() 
    211257{ 
    212258    for ( FunctionBlockVector::iterator it = m_functions.begin(); 
    …… 
    219265 
    220266bool 
    221 AvDeviceSubunitAudio::discover() 
     267BeBoB::AvDeviceSubunitAudio::discover() 
    222268{ 
    223269    if ( !AvDeviceSubunit::discover() ) { 
    …… 
    234280 
    235281bool 
    236 AvDeviceSubunitAudio::discoverConnections() 
     282BeBoB::AvDeviceSubunitAudio::discoverConnections() 
    237283{ 
    238284    if ( !AvDeviceSubunit::discoverConnections() ) { 
    …… 
    256302 
    257303const char* 
    258 AvDeviceSubunitAudio::getName() 
     304BeBoB::AvDeviceSubunitAudio::getName() 
    259305{ 
    260306    return "AudioSubunit"; 
    …… 
    262308 
    263309bool 
    264 AvDeviceSubunitAudio::discoverFunctionBlocks() 
     310BeBoB::AvDeviceSubunitAudio::discoverFunctionBlocks() 
    265311{ 
    266312    if ( !discoverFunctionBlocksDo( 
    …… 
    293339 
    294340bool 
    295 AvDeviceSubunitAudio::discoverFunctionBlocksDo( 
     341BeBoB::AvDeviceSubunitAudio::discoverFunctionBlocksDo( 
    296342    ExtendedSubunitInfoCmd::EFunctionBlockType fbType ) 
    297343{ 
    …… 
    341387 
    342388bool 
    343 AvDeviceSubunitAudio::createFunctionBlock( 
     389BeBoB::AvDeviceSubunitAudio::createFunctionBlock( 
    344390    ExtendedSubunitInfoCmd::EFunctionBlockType fbType, 
    345391    ExtendedSubunitInfoPageData& data ) 
    …… 
    436482} 
    437483 
    438 FunctionBlock::ESpecialPurpose 
    439 AvDeviceSubunitAudio::convertSpecialPurpose( 
     484BeBoB::FunctionBlock::ESpecialPurpose 
     485BeBoB::AvDeviceSubunitAudio::convertSpecialPurpose( 
    440486    function_block_special_purpose_t specialPurpose ) 
    441487{ 
    …… 
    454500} 
    455501 
     502bool 
     503BeBoB::AvDeviceSubunitAudio::serializeChild( Glib::ustring basePath, 
     504                                             Util::IOSerialize& ser ) const 
     505{ 
     506    bool result = true; 
     507    int i = 0; 
     508 
     509    for ( FunctionBlockVector::const_iterator it = m_functions.begin(); 
     510          it != m_functions.end(); 
     511          ++it ) 
     512    { 
     513        FunctionBlock* pFB = *it; 
     514        std::ostringstream strstrm; 
     515        strstrm << basePath << "FunctionBlock" << i << "/"; 
     516 
     517        result &= pFB->serialize( strstrm.str() , ser ); 
     518 
     519        i++; 
     520    } 
     521 
     522    return result; 
     523} 
     524 
     525bool 
     526BeBoB::AvDeviceSubunitAudio::deserializeChild( Glib::ustring basePath, 
     527                                               Util::IODeserialize& deser, 
     528                                               AvDevice& avDevice ) 
     529{ 
     530    int i = 0; 
     531    bool bFinished = false; 
     532    do { 
     533        std::ostringstream strstrm; 
     534        strstrm << basePath << "FunctionBlock" << i << "/"; 
     535        FunctionBlock* pFB = FunctionBlock::deserialize( strstrm.str(), 
     536                                                         deser, 
     537                                                         avDevice ); 
     538        if ( pFB ) { 
     539            m_functions.push_back( pFB ); 
     540            i++; 
     541        } else { 
     542            bFinished = true; 
     543        } 
     544    } while ( !bFinished ); 
     545 
     546    return true; 
     547} 
    456548 
    457549//////////////////////////////////////////// 
    458550 
    459 AvDeviceSubunitMusic::AvDeviceSubunitMusic( AvDevice& avDevice, 
    460                                             subunit_t id, 
    461                                             int verboseLevel ) 
     551BeBoB::AvDeviceSubunitMusic::AvDeviceSubunitMusic( AvDevice& avDevice, 
     552                                                   subunit_t id, 
     553                                                   int verboseLevel ) 
    462554    : AvDeviceSubunit( avDevice, AVCCommand::eST_Music, id, verboseLevel ) 
    463555{ 
    464556} 
    465557 
    466 AvDeviceSubunitMusic::~AvDeviceSubunitMusic() 
     558BeBoB::AvDeviceSubunitMusic::AvDeviceSubunitMusic() 
     559    : AvDeviceSubunit() 
     560{ 
     561} 
     562 
     563BeBoB::AvDeviceSubunitMusic::~AvDeviceSubunitMusic() 
    467564{ 
    468565} 
    469566 
    470567const char* 
    471 AvDeviceSubunitMusic::getName() 
     568BeBoB::AvDeviceSubunitMusic::getName() 
    472569{ 
    473570    return "MusicSubunit"; 
    474571} 
    475572 
    476 } 
     573bool 
     574BeBoB::AvDeviceSubunitMusic::serializeChild( Glib::ustring basePath, 
     575                                             Util::IOSerialize& ser ) const 
     576{ 
     577    return true; 
     578} 
     579 
     580bool 
     581BeBoB::AvDeviceSubunitMusic::deserializeChild( Glib::ustring basePath, 
     582                                               Util::IODeserialize& deser, 
     583                                               AvDevice& avDevice ) 
     584{ 
     585    return true; 
     586} 

  • trunk/libfreebob/src/bebob/bebob_avdevice_subunit.h

    r375 r376  
    6767    static AvDeviceSubunit* deserialize( Glib::ustring basePath, 
    6868                                         Util::IODeserialize& deser, 
    69                                          Ieee1394Service& ieee1394Service, 
    70                                          ConfigRom& configRom, 
    71                                          AvPlugManager& plugManager ); 
     69                                         AvDevice& avDevice ); 
    7270 protected: 
     71    AvDeviceSubunit(); 
     72 
    7373    bool discoverPlugs(); 
    7474    bool discoverPlugs(AvPlug::EAvPlugDirection plugDirection, 
    7575                       plug_id_t plugMaxId ); 
     76 
     77    virtual bool serializeChild( Glib::ustring basePath, 
     78                                 Util::IOSerialize& ser ) const = 0; 
     79    virtual bool deserializeChild( Glib::ustring basePath, 
     80                                   Util::IODeserialize& deser, 
     81                                   AvDevice& avDevice ) = 0; 
    7682 
    7783 protected: 
    …… 
    95101                          subunit_t id, 
    96102                          int verboseLevel ); 
     103    AvDeviceSubunitAudio(); 
    97104    virtual ~AvDeviceSubunitAudio(); 
    98105 
    …… 
    114121        function_block_special_purpose_t specialPurpose ); 
    115122 
     123    virtual bool serializeChild( Glib::ustring basePath, 
     124                                 Util::IOSerialize& ser ) const; 
     125    virtual bool deserializeChild( Glib::ustring basePath, 
     126                                   Util::IODeserialize& deser, 
     127                                   AvDevice& avDevice ); 
     128 
    116129protected: 
    117130    FunctionBlockVector m_functions; 
    …… 
    125138                          subunit_t id, 
    126139                          int verboseLevel ); 
     140    AvDeviceSubunitMusic(); 
    127141    virtual ~AvDeviceSubunitMusic(); 
    128142 
    129143    virtual const char* getName(); 
     144 
     145protected: 
     146    virtual bool serializeChild( Glib::ustring basePath, 
     147                                 Util::IOSerialize& ser ) const; 
     148    virtual bool deserializeChild( Glib::ustring basePath, 
     149                                   Util::IODeserialize& deser, 
     150                                   AvDevice& avDevice ); 
    130151}; 
    131152 

  • trunk/libfreebob/src/bebob/bebob_avplug.cpp

    r375 r376  
    2020 
    2121#include "bebob/bebob_avplug.h" 
     22#include "bebob/bebob_avdevice.h" 
    2223#include "configrom.h" 
    2324 
    …… 
    119120AvPlug::~AvPlug() 
    120121{ 
    121     m_plugManager->remPlug( *this ); 
     122    if ( m_plugManager ) { 
     123        m_plugManager->remPlug( *this ); 
     124    } 
    122125} 
    123126 
    …… 
    17041707AvPlug::deserialize( Glib::ustring basePath, 
    17051708                     Util::IODeserialize& deser, 
    1706                      Ieee1394Service& ieee1394Service, 
    1707                      ConfigRom& configRom, 
     1709                     AvDevice& avDevice, 
    17081710                     AvPlugManager& plugManager ) 
    17091711{ 
    …… 
    17131715    } 
    17141716 
    1715     pPlug->m_p1394Service = &ieee1394Service; 
    1716     pPlug->m_pConfigRom = &configRom; 
    1717     pPlug->m_plugManager = &plugManager; 
     1717    pPlug->m_p1394Service = &avDevice.get1394Service(); 
     1718    pPlug->m_pConfigRom   = &avDevice.getConfigRom(); 
     1719    pPlug->m_plugManager = &plugManager; 
    17181720    bool result; 
    17191721    result  = deser.read( basePath + "m_subunitType", pPlug->m_subunitType ); 
    …… 
    21302132AvPlugManager::deserialize( Glib::ustring basePath, 
    21312133                            Util::IODeserialize& deser, 
    2132                             Ieee1394Service& ieee1394Service, 
    2133                             ConfigRom& configRom ) 
     2134                            AvDevice& avDevice ) 
     2135 
    21342136{ 
    21352137    AvPlugManager* pMgr = new AvPlugManager; 
    …… 
    21442146        std::ostringstream strstrm; 
    21452147        strstrm << basePath << i; 
     2148        // avDevice still holds a null pointer for the plug manager 
     2149        // therefore we have to *this as additional argument 
    21462150        AvPlug* pPlug = AvPlug::deserialize( strstrm.str() + "/", 
    21472151                                             deser, 
    2148                                              ieee1394Service, 
    2149                                              configRom, 
     2152                                             avDevice, 
    21502153                                             *pMgr ); 
    21512154        if ( pPlug ) { 
    …… 
    21872190AvPlugConnection::deserialize( Glib::ustring basePath, 
    21882191                               Util::IODeserialize& deser, 
    2189                                Ieee1394Service& /* ieee1394Service */, 
    2190                                ConfigRom& /* configRom */, 
    2191                                AvPlugManager& plugManager ) 
     2192                               AvDevice& avDevice ) 
    21922193{ 
    21932194    AvPlugConnection* pConnection = new AvPlugConnection; 
    …… 
    22072208    } 
    22082209 
    2209     pConnection->m_srcPlug  = plugManager.getPlug( iSrcPlugId ); 
    2210     pConnection->m_destPlug = plugManager.getPlug( iDestPlugId ); 
     2210    pConnection->m_srcPlug  = avDevice.getPlugManager().getPlug( iSrcPlugId ); 
     2211    pConnection->m_destPlug = avDevice.getPlugManager().getPlug( iDestPlugId ); 
    22112212 
    22122213    if ( !pConnection->m_srcPlug || !pConnection->m_destPlug ) { 

  • trunk/libfreebob/src/bebob/bebob_avplug.h

    r375 r376  
    4141namespace BeBoB { 
    4242 
     43class AvDevice; 
    4344class AvPlugManager; 
    4445class AvPlug; 
    …… 
    141142    static AvPlug* deserialize( Glib::ustring basePath, 
    142143                                Util::IODeserialize& deser, 
    143                                 Ieee1394Service& ieee1394Service, 
    144                                 ConfigRom& configRom, 
     144                                AvDevice& avDevice, 
    145145                                AvPlugManager& plugManager ); 
     146 
    146147    bool deserializeUpdate( Glib::ustring basePath, 
    147148                            Util::IODeserialize& deser ); 
    …… 
    317318    static  AvPlugManager* deserialize( Glib::ustring basePath, 
    318319                                        Util::IODeserialize& deser, 
    319                                         Ieee1394Service& ieee1394Service, 
    320                                         ConfigRom& configRom ); 
     320                                        AvDevice& avDevice ); 
     321 
    321322private: 
    322323    AvPlugManager(); 
    …… 
    340341    static AvPlugConnection* deserialize( Glib::ustring basePath, 
    341342                                          Util::IODeserialize& deser, 
    342                                           Ieee1394Service& ieee1394Service, 
    343                                           ConfigRom& configRom, 
    344                                           AvPlugManager& plugManager ); 
     343                                          AvDevice& avDevice ); 
    345344private: 
    346345    AvPlugConnection(); 

  • trunk/libfreebob/src/bebob/bebob_functionblock.cpp

    r375 r376  
    147147} 
    148148 
     149bool 
     150FunctionBlock::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const 
     151{ 
     152    int dummy = 42; 
     153    return ser.write( basePath + "dummy", dummy ); 
     154} 
     155 
     156FunctionBlock* 
     157FunctionBlock::deserialize( Glib::ustring basePath, 
     158                            Util::IODeserialize& deser, 
     159                            AvDevice& avDevice ) 
     160{ 
     161    return 0; 
     162} 
     163 
    149164/////////////////////// 
    150165 

  • trunk/libfreebob/src/bebob/bebob_functionblock.h

    r341 r376  
    6262    virtual const char* getName() = 0; 
    6363 
     64    bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const; 
     65    static FunctionBlock* deserialize( Glib::ustring basePath, 
     66                                       Util::IODeserialize& deser, 
     67                                       AvDevice& avDevice ); 
    6468protected: 
    6569    bool discoverPlugs( AvPlug::EAvPlugDirection plugDirection,