Changeset 1896

Show
Ignore:
Timestamp:
Fri Feb 3 19:17:08 2006
Author:
fgerlits
Message:

changed the storage methods to accept const UniqueId? parameters
(this should be done everywhere, and not only with UniqueId? -- later)

Files:

Legend:

Unmodified
Added
Removed
Modified

  • trunk/livesupport/src/products/gLiveSupport/src/ScratchpadWindow.h

    r1895 r1896  
    350 350          */  
    351 351         void  
    352           addItem(Ptr<UniqueId>::Ref    id)                       throw ();  
      352         addItem(Ptr<const UniqueId>::Ref    id)                 throw ();  
    352 352  
    353 353         /**  

  • trunk/livesupport/src/products/gLiveSupport/src/GLiveSupport.cxx

    r1895 r1896  
    667 667 Ptr<AudioClip>::Ref  
    668 668 LiveSupport :: GLiveSupport ::  
    669   GLiveSupport :: getAudioClip(Ptr<UniqueId>::Ref  id)  
      669 GLiveSupport :: getAudioClip(Ptr<const UniqueId>::Ref  id)  
    669 669                                                         throw (XmlRpcException)  
    670 670 {  
    …… 
    688 688 Ptr<AudioClip>::Ref  
    689 689 LiveSupport :: GLiveSupport ::  
    690   GLiveSupport :: acquireAudioClip(Ptr<UniqueId>::Ref  id)  
      690 GLiveSupport :: acquireAudioClip(Ptr<const UniqueId>::Ref  id)  
    690 690                                                         throw (XmlRpcException)  
    691 691 {  
    …… 
    709 709 Ptr<Playlist>::Ref  
    710 710 LiveSupport :: GLiveSupport ::  
    711   GLiveSupport :: getPlaylist(Ptr<UniqueId>::Ref  id)  
      711 GLiveSupport :: getPlaylist(Ptr<const UniqueId>::Ref  id)  
    711 711                                                         throw (XmlRpcException)  
    712 712 {  
    …… 
    730 730 Ptr<Playlist>::Ref  
    731 731 LiveSupport :: GLiveSupport ::  
    732   GLiveSupport :: acquirePlaylist(Ptr<UniqueId>::Ref  id)  
      732 GLiveSupport :: acquirePlaylist(Ptr<const UniqueId>::Ref  id)  
    732 732                                                         throw (XmlRpcException)  
    733 733 {  
    …… 
    750 750 Ptr<Playable>::Ref  
    751 751 LiveSupport :: GLiveSupport ::  
    752   GLiveSupport :: acquirePlayable(Ptr<UniqueId>::Ref  id)  
      752 GLiveSupport :: acquirePlayable(Ptr<const UniqueId>::Ref  id)  
    752 752                                                         throw (XmlRpcException)  
    753 753 {  
    …… 
    771 771 void  
    772 772 LiveSupport :: GLiveSupport ::  
    773   GLiveSupport :: uncachePlaylist(Ptr<UniqueId>::Ref  id)     throw ()  
      773 GLiveSupport :: uncachePlaylist(Ptr<const UniqueId>::Ref  id)  
      774                                                         throw ()  
    774 775 {  
    775 776     Ptr<Playlist>::Ref      playlist;  
    …… 
    875 876 void  
    876 877 LiveSupport :: GLiveSupport ::  
    877   GLiveSupport :: addToLiveMode(Ptr<Playable>::Ref  playable)  
      878 GLiveSupport :: addToLiveMode(Ptr<Playable>::Ref    playable)  
    877 878                                                             throw ()  
    878 879 {  
    …… 
    899 900 Ptr<Playlist>::Ref  
    900 901 LiveSupport :: GLiveSupport ::  
    901   GLiveSupport :: openPlaylistForEditing(Ptr<UniqueId>::Ref  playlistId)  
      902 GLiveSupport :: openPlaylistForEditing(Ptr<const UniqueId>::Ref   playlistId)  
    901 902                                                     throw (XmlRpcException)  
    902 903 {  
    …… 
    974 975     }  
    975 976  
    976       // for some weird reason, the storage functions won't accept  
    977       // Ptr<const UniqueId>::Ref, just a non-const version  
    978       Ptr<UniqueId>::Ref  uid(new UniqueId(id->getId()));  
    979    
    980 977     // append the appropriate playable object to the end of the playlist  
    981       if (existsPlaylist(uid)) {  
    982           Ptr<Playlist>::Ref      playlist = getPlaylist(uid);  
      978     if (existsPlaylist(id)) {  
      979         Ptr<Playlist>::Ref      playlist = getPlaylist(id);  
    983 980         editedPlaylist->addPlaylist(playlist, editedPlaylist->getPlaylength());  
    984       } else if (existsAudioClip(uid)) {  
    985           Ptr<AudioClip>::Ref clip = getAudioClip(uid);  
      981     } else if (existsAudioClip(id)) {  
      982         Ptr<AudioClip>::Ref clip = getAudioClip(id);  
    986 983         editedPlaylist->addAudioClip(clip, editedPlaylist->getPlaylength());  
    987 984     }  
    1042 1039 void  
    1043 1040 LiveSupport :: GLiveSupport ::  
    1044   GLiveSupport :: removeFromSchedule(Ptr<UniqueId>::Ref   scheduleEntryId)  
      1041 GLiveSupport :: removeFromSchedule(Ptr<const UniqueId>::Ref   scheduleEntryId)  
    1044 1041                                                     throw (XmlRpcException)  
    1045 1042 {  
    1046       scheduler->removeFromSchedule(sessionId, scheduleEntryId);  
      1043     // for some weird reason, the schedule functions won't accept  
      1044     // Ptr<const UniqueId>::Ref, just a non-const version  
      1045     Ptr<UniqueId>::Ref  seid(new UniqueId(scheduleEntryId->getId()));  
      1046  
      1047     scheduler->removeFromSchedule(sessionId, seid);  
    1047 1048 }  
    1048 1049  

  • trunk/livesupport/src/products/gLiveSupport/src/SchedulerWindow.cxx

    r1869 r1896  
    285 285         Gtk::TreeModel::iterator iter = refSelection->get_selected();  
    286 286         if (iter) {  
    287               Ptr<const UniqueId>::Ref uid = (*iter)[entryColumns->idColumn];  
    288               Ptr<UniqueId>::Ref       entryId(new UniqueId(uid->getId()));  
      287             Ptr<const UniqueId>::Ref entryId = (*iter)[entryColumns->idColumn];  
    289 288  
    290 289             try {  

  • trunk/livesupport/src/products/gLiveSupport/src/GLiveSupport.h

    r1895 r1896  
    286 286          */  
    287 287         void  
    288           uncachePlaylist(Ptr<UniqueId>::Ref  id)                 throw ();  
      288         uncachePlaylist(Ptr<const UniqueId>::Ref  id)           throw ();  
    288 288          
    289 289         /**  
    …… 
    567 567          */  
    568 568         bool  
    569           existsAudioClip(Ptr<UniqueId>::Ref   id)     throw (XmlRpcException)  
      569         existsAudioClip(Ptr<const UniqueId>::Ref   id)  throw (XmlRpcException)  
    569 569         {  
    570 570             return storage->existsAudioClip(sessionId, id);  
    …… 
    583 583          */  
    584 584         Ptr<AudioClip>::Ref  
    585           getAudioClip(Ptr<UniqueId>::Ref  id)  
      585         getAudioClip(Ptr<const UniqueId>::Ref  id)  
    585 585                                                     throw (XmlRpcException);  
    586 586  
    …… 
    600 600          */  
    601 601         Ptr<AudioClip>::Ref  
    602           acquireAudioClip(Ptr<UniqueId>::Ref  id)  
      602         acquireAudioClip(Ptr<const UniqueId>::Ref  id)  
    602 602                                                     throw (XmlRpcException);  
    603 603  
    …… 
    624 624          */  
    625 625         bool  
    626           existsPlaylist(Ptr<UniqueId>::Ref   id)     throw (XmlRpcException)  
      626         existsPlaylist(Ptr<const UniqueId>::Ref   id)   throw (XmlRpcException)  
    626 626         {  
    627 627             return storage->existsPlaylist(sessionId, id);  
    …… 
    640 640          */  
    641 641         Ptr<Playlist>::Ref  
    642           getPlaylist(Ptr<UniqueId>::Ref  id)  
      642         getPlaylist(Ptr<const UniqueId>::Ref  id)  
    642 642                                                     throw (XmlRpcException);  
    643 643  
    …… 
    657 657          */  
    658 658         Ptr<Playlist>::Ref  
    659           acquirePlaylist(Ptr<UniqueId>::Ref  id)  
      659         acquirePlaylist(Ptr<const UniqueId>::Ref  id)  
    659 659                                                     throw (XmlRpcException);  
    660 660  
    …… 
    673 673          */  
    674 674         Ptr<Playable>::Ref  
    675           acquirePlayable(Ptr<UniqueId>::Ref  id)  
      675         acquirePlayable(Ptr<const UniqueId>::Ref  id)  
    675 675                                                     throw (XmlRpcException);  
    676 676  
    …… 
    723 723         Ptr<Playlist>::Ref  
    724 724         openPlaylistForEditing(  
    725                       Ptr<UniqueId>::Ref playlistId = Ptr<UniqueId>::Ref())  
      725                     Ptr<const UniqueId>::Ref    playlistId  
      726                                                 = Ptr<const UniqueId>::Ref())  
    726 727                                                       throw (XmlRpcException);  
    727 728  
    803 804          */  
    804 805         virtual void  
    805           removeFromSchedule(Ptr<UniqueId>::Ref   scheduleEntryId)  
      806         removeFromSchedule(Ptr<const UniqueId>::Ref   scheduleEntryId)  
    805 806                                                     throw (XmlRpcException);  
    806 807  

  • trunk/livesupport/src/products/gLiveSupport/src/ScratchpadWindow.cxx

    r1895 r1896  
    594 594  *----------------------------------------------------------------------------*/  
    595 595 void  
    596   ScratchpadWindow :: addItem(Ptr<UniqueId>::Ref    id)  
      596 ScratchpadWindow :: addItem(Ptr<const UniqueId>::Ref    id)  
    596 596                                                                 throw ()  
    597 597 {  
    …… 
    638 638     while (!contentsStream.eof()) {  
    639 639         UniqueId::IdType            idValue;  
    640           Ptr<UniqueId>::Ref          id;  
      640         Ptr<const UniqueId>::Ref    id;  
    640 640  
    641 641         contentsStream >> idValue;  
    644 644             break;  
    645 645         } else {  
    646               id.reset(new UniqueId(idValue));  
      646             id.reset(new const UniqueId(idValue));  
    646 646             addItem(id);  
    647 647         }  

  • trunk/livesupport/src/modules/storageClient/include/LiveSupport/Storage/StorageClientInterface.h

    r1852 r1896  
    108 108          *                             call.  
    109 109          */  
    110           virtual const bool  
    111           existsPlaylist(Ptr<SessionId>::Ref  sessionId,  
    112                          Ptr<UniqueId>::Ref   id) const  
      110         virtual bool  
      111         existsPlaylist(Ptr<SessionId>::Ref          sessionId,  
      112                        Ptr<const UniqueId>::Ref     id) const  
    113 113                                                 throw (XmlRpcException)  
    114 114                                                                         = 0;  
    …… 
    131 131          */  
    132 132         virtual Ptr<Playlist>::Ref  
    133           getPlaylist(Ptr<SessionId>::Ref sessionId,  
    134                       Ptr<UniqueId>::Ref  id) const  
      133         getPlaylist(Ptr<SessionId>::Ref       sessionId,  
      134                     Ptr<const UniqueId>::Ref  id) const  
    135 135                                                 throw (XmlRpcException)  
    136 136                                                                         = 0;  
    …… 
    153 153          */  
    154 154         virtual Ptr<Playlist>::Ref  
    155           editPlaylist(Ptr<SessionId>::Ref sessionId,  
    156                        Ptr<UniqueId>::Ref  id)  
      155         editPlaylist(Ptr<SessionId>::Ref      sessionId,  
      156                      Ptr<const UniqueId>::Ref id)  
    157 157                                                 throw (XmlRpcException)  
    158 158                                                                         = 0;  
    …… 
    215 215          */  
    216 216         virtual Ptr<Playlist>::Ref  
    217           acquirePlaylist(Ptr<SessionId>::Ref sessionId,  
    218                           Ptr<UniqueId>::Ref  id) const  
      217         acquirePlaylist(Ptr<SessionId>::Ref         sessionId,  
      218                         Ptr<const UniqueId>::Ref    id) const  
    219 219                                             throw (XmlRpcException)  
    220 220                                                                         = 0;  
    …… 
    249 249          *                             call.  
    250 250          */  
    251           virtual const bool  
    252           existsAudioClip(Ptr<SessionId>::Ref sessionId,  
    253                           Ptr<UniqueId>::Ref  id) const  
      251         virtual bool  
      252         existsAudioClip(Ptr<SessionId>::Ref         sessionId,  
      253                         Ptr<const UniqueId>::Ref    id) const  
    254 254                                                 throw (XmlRpcException)  
    255 255                                                                         = 0;  
    …… 
    269 269          */  
    270 270         virtual Ptr<AudioClip>::Ref  
    271           getAudioClip(Ptr<SessionId>::Ref    sessionId,  
    272                        Ptr<UniqueId>::Ref     id) const  
      271         getAudioClip(Ptr<SessionId>::Ref      sessionId,  
      272                      Ptr<const UniqueId>::Ref id) const  
    273 273                                                 throw (XmlRpcException)  
    274 274                                                                         = 0;  
    …… 
    320 320          */  
    321 321         virtual Ptr<AudioClip>::Ref  
    322           acquireAudioClip(Ptr<SessionId>::Ref  sessionId,  
    323                            Ptr<UniqueId>::Ref   id) const  
      322         acquireAudioClip(Ptr<SessionId>::Ref        sessionId,  
      323                          Ptr<const UniqueId>::Ref   id) const  
    324 324                                                 throw (XmlRpcException)  
    325 325                                                                         = 0;  
    …… 
    428 428         virtual Ptr<std::vector<Ptr<Playlist>::Ref> >::Ref  
    429 429         getAllPlaylists(Ptr<SessionId>::Ref sessionId,  
    430                           const int limit = 0, const int offset = 0)  
      430                         int                 limit  = 0,  
      431                         int                 offset = 0)  
    431 432                                                 throw (XmlRpcException)  
    432 433                                                                         = 0;  
    445 446          */  
    446 447         virtual Ptr<std::vector<Ptr<AudioClip>::Ref> >::Ref  
    447           getAllAudioClips(Ptr<SessionId>::Ref sessionId,  
    448                           const int limit = 0, const int offset = 0)  
      448         getAllAudioClips(Ptr<SessionId>::Ref  sessionId,  
      449                          int                  limit  = 0,  
      450                          int                  offset = 0)  
    449 451                                                 throw (XmlRpcException)  
    450 452                                                                         = 0;  

  • trunk/livesupport/src/modules/storageClient/src/WebStorageClient.cxx

    r1870 r1896  
    863 863  *  Tell if a playlist exists.  
    864 864  *----------------------------------------------------------------------------*/  
    865   const bool  
    866   WebStorageClient :: existsPlaylist(Ptr<SessionId>::Ref sessionId,  
    867                                      Ptr<UniqueId>::Ref  id) const  
      865 bool  
      866 WebStorageClient :: existsPlaylist(Ptr<SessionId>::Ref          sessionId,  
      867                                    Ptr<const UniqueId>::Ref     id) const  
    868 868                                                 throw (Core::XmlRpcException)  
    869 869 {  
    …… 
    919 919  *----------------------------------------------------------------------------*/  
    920 920 Ptr<Playlist>::Ref  
    921   WebStorageClient :: getPlaylist(Ptr<SessionId>::Ref     sessionId,  
    922                                   Ptr<UniqueId>::Ref      id) const  
      921 WebStorageClient :: getPlaylist(Ptr<SessionId>::Ref          sessionId,  
      922                                 Ptr<const UniqueId>::Ref    id) const  
    923 923                                                 throw (Core::XmlRpcException)  
    924 924 {  
    …… 
    986 986     const std::string   url     = result[getPlaylistUrlParamName];  
    987 987  
    988       Ptr<Playlist>::Ref  playlist(new Playlist(id));  
      988     Ptr<UniqueId>::Ref  idNotConst(new UniqueId(id->getId()));  
      989     Ptr<Playlist>::Ref  playlist(new Playlist(idNotConst));  
    989 990     try {  
    990 991         Ptr<xmlpp::DomParser>::Ref  parser(new xmlpp::DomParser());  
    …… 
    1014 1015  *----------------------------------------------------------------------------*/  
    1015 1016 Ptr<Playlist>::Ref  
    1016   WebStorageClient :: editPlaylist(Ptr<SessionId>::Ref sessionId,  
    1017                                    Ptr<UniqueId>::Ref  id)  
      1017 WebStorageClient :: editPlaylist(Ptr<SessionId>::Ref        sessionId,  
      1018                                  Ptr<const UniqueId>::Ref   id)  
    1018 1019                                                 throw (Core::XmlRpcException)  
    1019 1020 {  
    …… 
    1027 1028     editPlaylistGetUrl(sessionId, id, url, editToken);  
    1028 1029  
    1029       Ptr<Playlist>::Ref              playlist(new Playlist(id));  
      1030     Ptr<UniqueId>::Ref              idNotConst(new UniqueId(id->getId()));  
      1031     Ptr<Playlist>::Ref              playlist(new Playlist(idNotConst));  
    1030 1032     try {  
    1031 1033         Ptr<xmlpp::DomParser>::Ref  parser(new xmlpp::DomParser());  
    …… 
    1055 1057  *----------------------------------------------------------------------------*/  
    1056 1058 void  
    1057   WebStorageClient :: editPlaylistGetUrl(Ptr<SessionId>::Ref sessionId,  
    1058                                          Ptr<UniqueId>::Ref  id,  
      1059 WebStorageClient :: editPlaylistGetUrl(Ptr<SessionId>::Ref          sessionId,  
      1060                                        Ptr<const UniqueId>::Ref     id,  
    1059 1061                                        Ptr<const std::string>::Ref& url,  
    1060 1062                                        Ptr<const std::string>::Ref& editToken)  
    …… 
    1246 1248  *----------------------------------------------------------------------------*/  
    1247 1249 Ptr<Playlist>::Ref  
    1248   WebStorageClient :: acquirePlaylist(Ptr<SessionId>::Ref     sessionId,  
    1249                                       Ptr<UniqueId>::Ref      id) const  
      1250 WebStorageClient :: acquirePlaylist(Ptr<SessionId>::Ref         sessionId,  
      1251                                     Ptr<const UniqueId>::Ref    id) const  
    1250 1252                                                 throw (Core::XmlRpcException)  
    1251 1253 {  
    …… 
    1304 1306  *----------------------------------------------------------------------------*/  
    1305 1307 Ptr<Playlist>::Ref  
    1306   WebStorageClient :: acquirePlaylist(Ptr<UniqueId>::Ref  id,  
    1307                                       XmlRpcValue &       content) const  
      1308 WebStorageClient :: acquirePlaylist(Ptr<const UniqueId>::Ref    id,  
      1309                                     XmlRpcValue &               content) const  
    1308 1310                                                 throw (Core::XmlRpcException)  
    1309 1311 {  
    …… 
    1321 1323     const std::string   url     = content[getPlaylistUrlParamName];  
    1322 1324  
    1323       Ptr<Playlist>::Ref  playlist(new Playlist(id));  
      1325     Ptr<UniqueId>::Ref  idNotConst(new UniqueId(id->getId()));  
      1326     Ptr<Playlist>::Ref  playlist(new Playlist(idNotConst));  
    1324 1327     try {  
    1325 1328         Ptr<xmlpp::DomParser>::Ref  parser(new xmlpp::DomParser());  
    …… 
    1628 1631  *  Tell if an audio clip exists.  
    1629 1632  *----------------------------------------------------------------------------*/  
    1630   const bool  
    1631   WebStorageClient :: existsAudioClip(Ptr<SessionId>::Ref sessionId,  
    1632                                       Ptr<UniqueId>::Ref  id) const  
      1633 bool  
      1634 WebStorageClient :: existsAudioClip(Ptr<SessionId>::Ref         sessionId,  
      1635                                     Ptr<const UniqueId>::Ref    id) const  
    1633 1636                                                 throw (Core::XmlRpcException)  
    1634 1637 {  
    …… 
    1684 1687  *----------------------------------------------------------------------------*/  
    1685 1688 Ptr<AudioClip>::Ref  
    1686   WebStorageClient :: getAudioClip(Ptr<SessionId>::Ref sessionId,  
    1687                                    Ptr<UniqueId>::Ref  id) const  
      1689 WebStorageClient :: getAudioClip(Ptr<SessionId>::Ref        sessionId,  
      1690                                  Ptr<const UniqueId>::Ref   id) const  
    1688 1691                                                 throw (Core::XmlRpcException)  
    1689 1692 {  
    …… 
    1736 1739     const std::string   token   = result[getAudioClipTokenParamName];  
    1737 1740  
    1738       Ptr<AudioClip>::Ref audioClip(new AudioClip(id));  
      1741     Ptr<UniqueId>::Ref  idNotConst(new UniqueId(id->getId()));  
      1742     Ptr<AudioClip>::Ref audioClip(new AudioClip(idNotConst));  
    1739 1743  
    1740 1744     try {  
    …… 
    1965 1969  *----------------------------------------------------------------------------*/  
    1966 1970 Ptr<AudioClip>::Ref  
    1967   WebStorageClient :: acquireAudioClip(Ptr<SessionId>::Ref sessionId,  
    1968                                        Ptr<UniqueId>::Ref  id) const  
      1971 WebStorageClient :: acquireAudioClip(Ptr<SessionId>::Ref        sessionId,  
      1972                                      Ptr<const UniqueId>::Ref   id) const  
    1969 1973                                                 throw (Core::XmlRpcException)  
    1970 1974 {  
    …… 
    2365 2369 Ptr<std::vector<Ptr<Playlist>::Ref> >::Ref  
    2366 2370 WebStorageClient :: getAllPlaylists(Ptr<SessionId>::Ref sessionId,  
    2367                                       const int limit, const int offset)  
      2371                                     int                 limit,  
      2372                                     int                 offset)  
    2368 2373                                                 throw (XmlRpcException)  
    2369 2374 {  
    2392 2397  *----------------------------------------------------------------------------*/  
    2393 2398 Ptr<std::vector<Ptr<AudioClip>::Ref> >::Ref  
    2394   WebStorageClient :: getAllAudioClips(Ptr<SessionId>::Ref sessionId,  
    2395                                        const int limit, const int offset)  
      2399 WebStorageClient :: getAllAudioClips(Ptr<SessionId>::Ref    sessionId,  
      2400                                      int                    limit,  
      2401                                      int                    offset)  
    2396 2402                                                 throw (XmlRpcException)  
    2397 2403 {  

  • trunk/livesupport/src/modules/storageClient/src/TestStorageClient.cxx

    r1870 r1896  
    317 317  *  Tell if a playlist exists.  
    318 318  *----------------------------------------------------------------------------*/  
    319   const bool  
    320   TestStorageClient :: existsPlaylist(Ptr<SessionId>::Ref sessionId,  
    321                                       Ptr<UniqueId>::Ref  id) const  
      319 bool  
      320 TestStorageClient :: existsPlaylist(Ptr<SessionId>::Ref         sessionId,  
      321                                     Ptr<const UniqueId>::Ref    id) const  
    322 322                                                 throw (XmlRpcException)  
    323 323 {  
    …… 
    334 334  *----------------------------------------------------------------------------*/  
    335 335 Ptr<Playlist>::Ref  
    336   TestStorageClient :: getPlaylist(Ptr<SessionId>::Ref sessionId,  
    337                                    Ptr<UniqueId>::Ref  id) const  
      336 TestStorageClient :: getPlaylist(Ptr<SessionId>::Ref        sessionId,  
      337                                  Ptr<const UniqueId>::Ref   id) const  
    338 338                                                 throw (XmlRpcException)  
    339 339 {  
    …… 
    366 366  *----------------------------------------------------------------------------*/  
    367 367 Ptr<Playlist>::Ref  
    368   TestStorageClient :: editPlaylist(Ptr<SessionId>::Ref sessionId,  
    369                                     Ptr<UniqueId>::Ref  id)  
      368 TestStorageClient :: editPlaylist(Ptr<SessionId>::Ref       sessionId,  
      369                                   Ptr<const UniqueId>::Ref  id)  
    370 370                                                 throw (XmlRpcException)  
    371 371 {  
    …… 
    447 447  *----------------------------------------------------------------------------*/  
    448 448 Ptr<Playlist>::Ref  
    449   TestStorageClient :: acquirePlaylist(Ptr<SessionId>::Ref sessionId,  
    450                                        Ptr<UniqueId>::Ref  id) const  
      449 TestStorageClient :: acquirePlaylist(Ptr<SessionId>::Ref        sessionId,  
      450                                      Ptr<const UniqueId>::Ref   id) const  
    451 451                                                 throw (XmlRpcException)  
    452 452 {  
    …… 
    660 660  *  Tell if an audio clip exists.  
    661 661  *----------------------------------------------------------------------------*/  
    662   const bool  
    663   TestStorageClient :: existsAudioClip(Ptr<SessionId>::Ref sessionId,  
    664                                        Ptr<UniqueId>::Ref  id) const  
      662 bool  
      663 TestStorageClient :: existsAudioClip(Ptr<SessionId>::Ref        sessionId,  
      664                                      Ptr<const UniqueId>::Ref   id) const  
    665 665                                                 throw (XmlRpcException)  
    666 666 {  
    …… 
    677 677  *----------------------------------------------------------------------------*/  
    678 678 Ptr<AudioClip>::Ref  
    679   TestStorageClient :: getAudioClip(Ptr<SessionId>::Ref sessionId,  
    680                                     Ptr<UniqueId>::Ref  id) const  
      679 TestStorageClient :: getAudioClip(Ptr<SessionId>::Ref       sessionId,  
      680                                   Ptr<const UniqueId>::Ref  id) const  
    681 681                                                 throw (XmlRpcException)  
    682 682 {  
    …… 
    731 731  *----------------------------------------------------------------------------*/  
    732 732 Ptr<AudioClip>::Ref  
    733   TestStorageClient :: acquireAudioClip(Ptr<SessionId>::Ref sessionId,  
    734                                         Ptr<UniqueId>::Ref  id) const  
      733 TestStorageClient :: acquireAudioClip(Ptr<SessionId>::Ref       sessionId,  
      734                                       Ptr<const UniqueId>::Ref  id) const  
    735 735                                                 throw (XmlRpcException)  
    736 736 {  
    …… 
    937 937  *----------------------------------------------------------------------------*/  
    938 938 Ptr<std::vector<Ptr<Playlist>::Ref> >::Ref  
    939   TestStorageClient :: getAllPlaylists(Ptr<SessionId>::Ref sessionId,  
    940                                        const int limit, const int offset)  
      939 TestStorageClient :: getAllPlaylists(Ptr<SessionId>::Ref    sessionId,  
      940                                      int                    limit,  
      941                                      int                    offset)  
    941 942                                                 throw (XmlRpcException)  
    942 943 {  
    965 966  *----------------------------------------------------------------------------*/  
    966 967 Ptr<std::vector<Ptr<AudioClip>::Ref> >::Ref  
    967   TestStorageClient :: getAllAudioClips(Ptr<SessionId>::Ref sessionId,  
    968                                         const int limit, const int offset)  
      968 TestStorageClient :: getAllAudioClips(Ptr<SessionId>::Ref   sessionId,  
      969                                       int                   limit,  
      970                                       int                   offset)  
    969 971                                                 throw (XmlRpcException)  
    970 972 {  

  • trunk/livesupport/src/modules/storageClient/src/WebStorageClient.h

    r1612 r1896  
    171 171          */  
    172 172         void  
    173           editPlaylistGetUrl(Ptr<SessionId>::Ref sessionId,  
    174                              Ptr<UniqueId>::Ref  id,  
      173         editPlaylistGetUrl(Ptr<SessionId>::Ref          sessionId,  
      174                            Ptr<const UniqueId>::Ref     id,  
    175 175                            Ptr<const std::string>::Ref& url,  
    176 176                            Ptr<const std::string>::Ref& editToken)  
    …… 
    189 189          */  
    190 190         Ptr<Playlist>::Ref  
    191           acquirePlaylist(Ptr<UniqueId>::Ref  id,  
    192                           XmlRpcValue &       content) const  
      191         acquirePlaylist(Ptr<const UniqueId>::Ref    id,  
      192                         XmlRpcValue &               content) const  
    193 193                                                 throw (XmlRpcException);  
    194 194  
    …… 
    293 293          *                             call.  
    294 294          */  
    295           virtual const bool  
    296           existsPlaylist(Ptr<SessionId>::Ref  sessionId,  
    297                          Ptr<UniqueId>::Ref   id) const  
      295         virtual bool  
      296         existsPlaylist(Ptr<SessionId>::Ref          sessionId,  
      297                        Ptr<const UniqueId>::Ref     id) const  
    298 298                                                 throw (XmlRpcException);  
    299 299  
    …… 
    316 316          */  
    317 317         virtual Ptr<Playlist>::Ref  
    318           getPlaylist(Ptr<SessionId>::Ref sessionId,  
    319                       Ptr<UniqueId>::Ref  id) const  
      318         getPlaylist(Ptr<SessionId>::Ref       sessionId,  
      319                     Ptr<const UniqueId>::Ref  id) const  
    320 320                                                 throw (XmlRpcException);  
    321 321  
    …… 
    337 337          */  
    338 338         virtual Ptr<Playlist>::Ref  
    339           editPlaylist(Ptr<SessionId>::Ref sessionId,  
    340                        Ptr<UniqueId>::Ref  id)  
      339         editPlaylist(Ptr<SessionId>::Ref            sessionId,  
      340                      Ptr<const UniqueId>::Ref       id)  
    341 341                                                 throw (XmlRpcException);  
    342 342  
    …… 
    401 401          */  
    402 402         virtual Ptr<Playlist>::Ref  
    403           acquirePlaylist(Ptr<SessionId>::Ref sessionId,  
    404                           Ptr<UniqueId>::Ref  id) const  
      403         acquirePlaylist(Ptr<SessionId>::Ref         sessionId,  
      404                         Ptr<const UniqueId>::Ref    id) const  
    405 405                                             throw (XmlRpcException);  
    406 406  
    …… 
    433 433          *                             call.  
    434 434          */  
    435           virtual const bool  
    436           existsAudioClip(Ptr<SessionId>::Ref sessionId,  
    437                           Ptr<UniqueId>::Ref  id) const  
      435         virtual bool  
      436         existsAudioClip(Ptr<SessionId>::Ref         sessionId,  
      437                         Ptr<const UniqueId>::Ref    id) const  
    438 438                                                 throw (XmlRpcException);  
    439 439  
    …… 
    453 453          */  
    454 454         virtual Ptr<AudioClip>::Ref  
    455           getAudioClip(Ptr<SessionId>::Ref    sessionId,  
    456                        Ptr<UniqueId>::Ref     id) const  
      455         getAudioClip(Ptr<SessionId>::Ref      sessionId,  
      456                      Ptr<const UniqueId>::Ref id) const  
    457 457                                                 throw (XmlRpcException);  
    458 458  
    …… 
    506 506          */  
    507 507         virtual Ptr<AudioClip>::Ref  
    508           acquireAudioClip(Ptr<SessionId>::Ref  sessionId,  
    509                            Ptr<UniqueId>::Ref   id) const  
      508         acquireAudioClip(Ptr<SessionId>::Ref        sessionId,  
      509                          Ptr<const UniqueId>::Ref   id) const  
    510 510                                                 throw (XmlRpcException);  
    511 511  
    …… 
    615 615         virtual Ptr<std::vector<Ptr<Playlist>::Ref> >::Ref  
    616 616         getAllPlaylists(Ptr<SessionId>::Ref sessionId,  
    617                           const int limit = 0, const int offset = 0)  
      617                         int                 limit  = 0,  
      618                         int                 offset = 0)  
    618 619                                                 throw (XmlRpcException);  
    619 620  
    632 633          */  
    633 634         virtual Ptr<std::vector<Ptr<AudioClip>::Ref> >::Ref  
    634           getAllAudioClips(Ptr<SessionId>::Ref sessionId,  
    635                           const int limit = 0, const int offset = 0)  
      635         getAllAudioClips(Ptr<SessionId>::Ref  sessionId,  
      636                          int                  limit  = 0,  
      637                          int                  offset = 0)  
    636 638                                                 throw (XmlRpcException);  
    637 639 };  

  • trunk/livesupport/src/modules/storageClient/src/TestStorageClient.h

    r1612 r1896  
    252 252          *          false otherwise.  
    253 253          */  
    254           virtual const bool  
    255           existsPlaylist(Ptr<SessionId>::Ref  sessionId,  
    256                          Ptr<UniqueId>::Ref   id) const  
      254         virtual bool  
      255         existsPlaylist(Ptr<SessionId>::Ref          sessionId,  
      256                        Ptr<const UniqueId>::Ref     id) const  
    257 257                                                 throw (XmlRpcException);  
    258 258  
    …… 
    274 274          */  
    275 275         virtual Ptr<Playlist>::Ref  
    276           getPlaylist(Ptr<SessionId>::Ref sessionId,  
    277                       Ptr<UniqueId>::Ref  id) const  
      276         getPlaylist(Ptr<SessionId>::Ref       sessionId,  
      277                     Ptr<const UniqueId>::Ref  id) const  
    278 278                                                 throw (XmlRpcException);  
    279 279  
    …… 
    295 295          */  
    296 296         virtual Ptr<Playlist>::Ref  
    297           editPlaylist(Ptr<SessionId>::Ref sessionId,  
    298                        Ptr<UniqueId>::Ref  id)  
      297         editPlaylist(Ptr<SessionId>::Ref      sessionId,  
      298                      Ptr<const UniqueId>::Ref id)  
    299 299                                                 throw (XmlRpcException);  
    300 300  
    …… 
    356 356          */  
    357 357         virtual Ptr<Playlist>::Ref  
    358           acquirePlaylist(Ptr<SessionId>::Ref sessionId,  
    359                           Ptr<UniqueId>::Ref  id) const  
      358         acquirePlaylist(Ptr<SessionId>::Ref         sessionId,  
      359                         Ptr<const UniqueId>::Ref    id) const  
    360 360                                             throw (XmlRpcException);  
    361 361  
    …… 
    386 386          *          false otherwise.  
    387 387          */  
    388           virtual const bool  
    389           existsAudioClip(Ptr<SessionId>::Ref sessionId,  
    390                           Ptr<UniqueId>::Ref  id) const  
      388         virtual bool  
      389         existsAudioClip(Ptr<SessionId>::Ref         sessionId,  
      390                         Ptr<const UniqueId>::Ref    id) const  
    391 391                                                 throw (XmlRpcException);  
    392 392  
    …… 
    404 404          */  
    405 405         virtual Ptr<AudioClip>::Ref  
    406           getAudioClip(Ptr<SessionId>::Ref    sessionId,  
    407                        Ptr<UniqueId>::Ref     id) const  
      406         getAudioClip(Ptr<SessionId>::Ref      sessionId,  
      407                      Ptr<const UniqueId>::Ref id) const  
    408 408                                                 throw (XmlRpcException);  
    409 409  
    …… 
    451 451          */  
    452 452         virtual Ptr<AudioClip>::Ref  
    453           acquireAudioClip(Ptr<SessionId>::Ref  sessionId,  
    454                            Ptr<UniqueId>::Ref   id) const  
      453         acquireAudioClip(Ptr<SessionId>::Ref        sessionId,  
      454                          Ptr<const UniqueId>::Ref   id) const  
    455 455                                                 throw (XmlRpcException);  
    456 456  
    …… 
    571 571         virtual Ptr<std::vector<Ptr<Playlist>::Ref> >::Ref  
    572 572         getAllPlaylists(Ptr<SessionId>::Ref sessionId,  
    573                           const int limit = 0, const int offset = 0)  
      573                         int                 limit  = 0,  
      574                         int                 offset = 0)  
    574 575                                                 throw (XmlRpcException);  
    575 576  
    588 589          */  
    589 590         virtual Ptr<std::vector<Ptr<AudioClip>::Ref> >::Ref  
    590           getAllAudioClips(Ptr<SessionId>::Ref sessionId,  
    591                           const int limit = 0, const int offset = 0)  
      591         getAllAudioClips(Ptr<SessionId>::Ref  sessionId,  
      592                          int                  limit  = 0,  
      593                          int                  offset = 0)  
    592 594                                                 throw (XmlRpcException);  
    593 595 };