- Main Page
- Related Pages
- Classes
- Files
- Examples

- File List
- File Members

# sidg_Skyperefs.hpp

Go to the documentation of this file.

    00001 #ifndef __SIDG_SKYPEREFSHPP_INCLUDED__
    00002 #define __SIDG_SKYPEREFSHPP_INCLUDED__
    00003
    00004 #include "SidPlatform.hpp"
    00005
    00006 #include "skype-object.h"
    00007
    00008 #ifdef SE_USE_NAMESPACE
    00009 namespace Skype {
    00010 #endif
    00011
    00012         class ContactGroup;
    00013         class Contact;
    00014         class ContactSearch;
    00015         class Participant;
    00016         class Conversation;
    00017         class Message;
    00018         class Video;
    00019         class Voicemail;
    00020         class Sms;
    00021         class Transfer;
    00022         class Account;
    00023
    00024         /*! \class ContactGroupRef
    00025          * \brief Reference to an ContactGroup class instance, equivalent to ContactGroup::Ref
    00026          */
    00027         class ContactGroupRef : public SEReference
    00028         {
    00029         public:
    00030                 ContactGroupRef(const unsigned int& oid = 0);
    00031                 ContactGroup* operator->() const;
    00032         protected:
    00033                 ContactGroupRef(const SEReference& ref) : SEReference(ref) {}
    00034                 friend class ContactGroupRefs;
    00035         };
    00036
    00037         /*! \class ContactGroupRefs
    00038          * \brief list of references to ContactGroup class instances, equivalent to ContactGroup::Refs
    00039          */
    00040         class ContactGroupRefs : public List_ref
    00041         {
    00042         public:
    00043                 /** Appends a ref at the end of the list. */
    00044                 void push_back(const ContactGroupRef & ref) {
    00045                         List_ref::append(ref);
    00046                 }
    00047                 /** Appends a ref at the end of the list. */
    00048                 ContactGroupRefs& append(const ContactGroupRef & ref) {
    00049                         List_ref::append(ref);
    00050                         return *this;
    00051                 }
    00052                 /** Returns a ref specified by its index. */
    00053                 ContactGroupRef& operator[](size_t n) const {
    00054                         return (ContactGroupRef&) List_ref::operator[](n);
    00055                 }
    00056                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00057                  * This is very fast because the list isn't actually copied.
    00058                  */
    00059                 ContactGroupRefs& operator=(const ContactGroupRefs& sl) {
    00060                         List_ref::operator=(sl);
    00061                         return *this;
    00062                 }
    00063         };
    00064
    00065         /*! \class ContactRef
    00066          * \brief Reference to an Contact class instance, equivalent to Contact::Ref
    00067          */
    00068         class ContactRef : public SEReference
    00069         {
    00070         public:
    00071                 ContactRef(const unsigned int& oid = 0);
    00072                 Contact* operator->() const;
    00073         protected:
    00074                 ContactRef(const SEReference& ref) : SEReference(ref) {}
    00075                 friend class ContactRefs;
    00076         };
    00077
    00078         /*! \class ContactRefs
    00079          * \brief list of references to Contact class instances, equivalent to Contact::Refs
    00080          */
    00081         class ContactRefs : public List_ref
    00082         {
    00083         public:
    00084                 /** Appends a ref at the end of the list. */
    00085                 void push_back(const ContactRef & ref) {
    00086                         List_ref::append(ref);
    00087                 }
    00088                 /** Appends a ref at the end of the list. */
    00089                 ContactRefs& append(const ContactRef & ref) {
    00090                         List_ref::append(ref);
    00091                         return *this;
    00092                 }
    00093                 /** Returns a ref specified by its index. */
    00094                 ContactRef& operator[](size_t n) const {
    00095                         return (ContactRef&) List_ref::operator[](n);
    00096                 }
    00097                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00098                  * This is very fast because the list isn't actually copied.
    00099                  */
    00100                 ContactRefs& operator=(const ContactRefs& sl) {
    00101                         List_ref::operator=(sl);
    00102                         return *this;
    00103                 }
    00104         };
    00105
    00106         /*! \class ContactSearchRef
    00107          * \brief Reference to an ContactSearch class instance, equivalent to ContactSearch::Ref
    00108          */
    00109         class ContactSearchRef : public SEReference
    00110         {
    00111         public:
    00112                 ContactSearchRef(const unsigned int& oid = 0);
    00113                 ContactSearch* operator->() const;
    00114         protected:
    00115                 ContactSearchRef(const SEReference& ref) : SEReference(ref) {}
    00116                 friend class ContactSearchRefs;
    00117         };
    00118
    00119         /*! \class ContactSearchRefs
    00120          * \brief list of references to ContactSearch class instances, equivalent to ContactSearch::Refs
    00121          */
    00122         class ContactSearchRefs : public List_ref
    00123         {
    00124         public:
    00125                 /** Appends a ref at the end of the list. */
    00126                 void push_back(const ContactSearchRef & ref) {
    00127                         List_ref::append(ref);
    00128                 }
    00129                 /** Appends a ref at the end of the list. */
    00130                 ContactSearchRefs& append(const ContactSearchRef & ref) {
    00131                         List_ref::append(ref);
    00132                         return *this;
    00133                 }
    00134                 /** Returns a ref specified by its index. */
    00135                 ContactSearchRef& operator[](size_t n) const {
    00136                         return (ContactSearchRef&) List_ref::operator[](n);
    00137                 }
    00138                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00139                  * This is very fast because the list isn't actually copied.
    00140                  */
    00141                 ContactSearchRefs& operator=(const ContactSearchRefs& sl) {
    00142                         List_ref::operator=(sl);
    00143                         return *this;
    00144                 }
    00145         };
    00146
    00147         /*! \class ParticipantRef
    00148          * \brief Reference to an Participant class instance, equivalent to Participant::Ref
    00149          */
    00150         class ParticipantRef : public SEReference
    00151         {
    00152         public:
    00153                 ParticipantRef(const unsigned int& oid = 0);
    00154                 Participant* operator->() const;
    00155         protected:
    00156                 ParticipantRef(const SEReference& ref) : SEReference(ref) {}
    00157                 friend class ParticipantRefs;
    00158         };
    00159
    00160         /*! \class ParticipantRefs
    00161          * \brief list of references to Participant class instances, equivalent to Participant::Refs
    00162          */
    00163         class ParticipantRefs : public List_ref
    00164         {
    00165         public:
    00166                 /** Appends a ref at the end of the list. */
    00167                 void push_back(const ParticipantRef & ref) {
    00168                         List_ref::append(ref);
    00169                 }
    00170                 /** Appends a ref at the end of the list. */
    00171                 ParticipantRefs& append(const ParticipantRef & ref) {
    00172                         List_ref::append(ref);
    00173                         return *this;
    00174                 }
    00175                 /** Returns a ref specified by its index. */
    00176                 ParticipantRef& operator[](size_t n) const {
    00177                         return (ParticipantRef&) List_ref::operator[](n);
    00178                 }
    00179                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00180                  * This is very fast because the list isn't actually copied.
    00181                  */
    00182                 ParticipantRefs& operator=(const ParticipantRefs& sl) {
    00183                         List_ref::operator=(sl);
    00184                         return *this;
    00185                 }
    00186         };
    00187
    00188         /*! \class ConversationRef
    00189          * \brief Reference to an Conversation class instance, equivalent to Conversation::Ref
    00190          */
    00191         class ConversationRef : public SEReference
    00192         {
    00193         public:
    00194                 ConversationRef(const unsigned int& oid = 0);
    00195                 Conversation* operator->() const;
    00196         protected:
    00197                 ConversationRef(const SEReference& ref) : SEReference(ref) {}
    00198                 friend class ConversationRefs;
    00199         };
    00200
    00201         /*! \class ConversationRefs
    00202          * \brief list of references to Conversation class instances, equivalent to Conversation::Refs
    00203          */
    00204         class ConversationRefs : public List_ref
    00205         {
    00206         public:
    00207                 /** Appends a ref at the end of the list. */
    00208                 void push_back(const ConversationRef & ref) {
    00209                         List_ref::append(ref);
    00210                 }
    00211                 /** Appends a ref at the end of the list. */
    00212                 ConversationRefs& append(const ConversationRef & ref) {
    00213                         List_ref::append(ref);
    00214                         return *this;
    00215                 }
    00216                 /** Returns a ref specified by its index. */
    00217                 ConversationRef& operator[](size_t n) const {                         return (ConversationRef&) List_ref::operator[](n);
    00218                 }
    00219                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00220                  * This is very fast because the list isn't actually copied.
    00221                  */
    00222                 ConversationRefs& operator=(const ConversationRefs& sl) {
    00223                         List_ref::operator=(sl);
    00224                         return *this;
    00225                 }
    00226         };
    00227
    00228         /*! \class MessageRef
    00229          * \brief Reference to an Message class instance, equivalent to Message::Ref
    00230          */
    00231         class MessageRef : public SEReference
    00232         {
    00233         public:
    00234                 MessageRef(const unsigned int& oid = 0);
    00235                 Message* operator->() const;
    00236         protected:
    00237                 MessageRef(const SEReference& ref) : SEReference(ref) {}
    00238                 friend class MessageRefs;
    00239         };
    00240
    00241         /*! \class MessageRefs
    00242          * \brief list of references to Message class instances, equivalent to Message::Refs
    00243          */
    00244         class MessageRefs : public List_ref
    00245         {
    00246         public:
    00247                 /** Appends a ref at the end of the list. */
    00248                 void push_back(const MessageRef & ref) {
    00249                         List_ref::append(ref);
    00250                 }
    00251                 /** Appends a ref at the end of the list. */
    00252                 MessageRefs& append(const MessageRef & ref) {
    00253                         List_ref::append(ref);
    00254                         return *this;
    00255                 }
    00256                 /** Returns a ref specified by its index. */
    00257                 MessageRef& operator[](size_t n) const {
    00258                         return (MessageRef&) List_ref::operator[](n);
    00259                 }
    00260                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00261                  * This is very fast because the list isn't actually copied.
    00262                  */
    00263                 MessageRefs& operator=(const MessageRefs& sl) {
    00264                         List_ref::operator=(sl);
    00265                         return *this;
    00266                 }
    00267         };
    00268
    00269         /*! \class VideoRef
    00270          * \brief Reference to an Video class instance, equivalent to Video::Ref
    00271          */
    00272         class VideoRef : public SEReference
    00273         {
    00274         public:
    00275                 VideoRef(const unsigned int& oid = 0);
    00276                 Video* operator->() const;
    00277         protected:
    00278                 VideoRef(const SEReference& ref) : SEReference(ref) {}
    00279                 friend class VideoRefs;
    00280         };
    00281
    00282         /*! \class VideoRefs
    00283          * \brief list of references to Video class instances, equivalent to Video::Refs
    00284          */
    00285         class VideoRefs : public List_ref
    00286         {
    00287         public:
    00288                 /** Appends a ref at the end of the list. */
    00289                 void push_back(const VideoRef & ref) {
    00290                         List_ref::append(ref);
    00291                 }
    00292                 /** Appends a ref at the end of the list. */
    00293                 VideoRefs& append(const VideoRef & ref) {
    00294                         List_ref::append(ref);
    00295                         return *this;
    00296                 }
    00297                 /** Returns a ref specified by its index. */
    00298                 VideoRef& operator[](size_t n) const {
    00299                         return (VideoRef&) List_ref::operator[](n);
    00300                 }
    00301                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00302                  * This is very fast because the list isn't actually copied.
    00303                  */
    00304                 VideoRefs& operator=(const VideoRefs& sl) {
    00305                         List_ref::operator=(sl);
    00306                         return *this;
    00307                 }
    00308         };
    00309
    00310         /*! \class VoicemailRef
    00311          * \brief Reference to an Voicemail class instance, equivalent to Voicemail::Ref
    00312          */
    00313         class VoicemailRef : public SEReference
    00314         {
    00315         public:
    00316                 VoicemailRef(const unsigned int& oid = 0);
    00317                 Voicemail* operator->() const;
    00318         protected:
    00319                 VoicemailRef(const SEReference& ref) : SEReference(ref) {}
    00320                 friend class VoicemailRefs;
    00321         };
    00322
    00323         /*! \class VoicemailRefs
    00324          * \brief list of references to Voicemail class instances, equivalent to Voicemail::Refs
    00325          */
    00326         class VoicemailRefs : public List_ref
    00327         {
    00328         public:
    00329                 /** Appends a ref at the end of the list. */
    00330                 void push_back(const VoicemailRef & ref) {
    00331                         List_ref::append(ref);
    00332                 }
    00333                 /** Appends a ref at the end of the list. */
    00334                 VoicemailRefs& append(const VoicemailRef & ref) {
    00335                         List_ref::append(ref);
    00336                         return *this;
    00337                 }
    00338                 /** Returns a ref specified by its index. */
    00339                 VoicemailRef& operator[](size_t n) const {
    00340                         return (VoicemailRef&) List_ref::operator[](n);
    00341                 }
    00342                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00343                  * This is very fast because the list isn't actually copied.
    00344                  */
    00345                 VoicemailRefs& operator=(const VoicemailRefs& sl) {
    00346                         List_ref::operator=(sl);
    00347                         return *this;
    00348                 }
    00349         };
    00350
    00351         /*! \class SmsRef
    00352          * \brief Reference to an Sms class instance, equivalent to Sms::Ref
    00353          */
    00354         class SmsRef : public SEReference
    00355         {
    00356         public:
    00357                 SmsRef(const unsigned int& oid = 0);
    00358                 Sms* operator->() const;
    00359         protected:
    00360                 SmsRef(const SEReference& ref) : SEReference(ref) {}
    00361                 friend class SmsRefs;
    00362         };
    00363
    00364         /*! \class SmsRefs
    00365          * \brief list of references to Sms class instances, equivalent to Sms::Refs
    00366          */
    00367         class SmsRefs : public List_ref
    00368         {
    00369         public:
    00370                 /** Appends a ref at the end of the list. */
    00371                 void push_back(const SmsRef & ref) {
    00372                         List_ref::append(ref);
    00373                 }
    00374                 /** Appends a ref at the end of the list. */
    00375                 SmsRefs& append(const SmsRef & ref) {
    00376                         List_ref::append(ref);
    00377                         return *this;
    00378                 }
    00379                 /** Returns a ref specified by its index. */
    00380                 SmsRef& operator[](size_t n) const {
    00381                         return (SmsRef&) List_ref::operator[](n);
    00382                 }
    00383                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00384                  * This is very fast because the list isn't actually copied.
    00385                  */
    00386                 SmsRefs& operator=(const SmsRefs& sl) {
    00387                         List_ref::operator=(sl);
    00388                         return *this;
    00389                 }
    00390         };
    00391
    00392         /*! \class TransferRef
    00393          * \brief Reference to an Transfer class instance, equivalent to Transfer::Ref
    00394          */
    00395         class TransferRef : public SEReference
    00396         {
    00397         public:
    00398                 TransferRef(const unsigned int& oid = 0);
    00399                 Transfer* operator->() const;
    00400         protected:
    00401                 TransferRef(const SEReference& ref) : SEReference(ref) {}
    00402                 friend class TransferRefs;
    00403         };
    00404
    00405         /*! \class TransferRefs
    00406          * \brief list of references to Transfer class instances, equivalent to Transfer::Refs
    00407          */
    00408         class TransferRefs : public List_ref
    00409         {
    00410         public:
    00411                 /** Appends a ref at the end of the list. */
    00412                 void push_back(const TransferRef & ref) {
    00413                         List_ref::append(ref);
    00414                 }
    00415                 /** Appends a ref at the end of the list. */
    00416                 TransferRefs& append(const TransferRef & ref) {
    00417                         List_ref::append(ref);
    00418                         return *this;
    00419                 }
    00420                 /** Returns a ref specified by its index. */                TransferRef& operator[](size_t n) const {
    00421                         return (TransferRef&) List_ref::operator[](n);
    00422                 }
    00423                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00424                  * This is very fast because the list isn't actually copied.
    00425                  */
    00426                 TransferRefs& operator=(const TransferRefs& sl) {
    00427                         List_ref::operator=(sl);
    00428                         return *this;
    00429                 }
    00430         };
    00431
    00432         /*! \class AccountRef
    00433          * \brief Reference to an Account class instance, equivalent to Account::Ref
    00434          */
    00435         class AccountRef : public SEReference
    00436         {
    00437         public:
    00438                 AccountRef(const unsigned int& oid = 0);
    00439                 Account* operator->() const;
    00440         protected:
    00441                 AccountRef(const SEReference& ref) : SEReference(ref) {}
    00442                 friend class AccountRefs;
    00443         };
    00444
    00445         /*! \class AccountRefs
    00446          * \brief list of references to Account class instances, equivalent to Account::Refs
    00447          */
    00448         class AccountRefs : public List_ref
    00449         {
    00450         public:
    00451                 /** Appends a ref at the end of the list. */
    00452                 void push_back(const AccountRef & ref) {
    00453                         List_ref::append(ref);
    00454                 }
    00455                 /** Appends a ref at the end of the list. */
    00456                 AccountRefs& append(const AccountRef & ref) {
    00457                         List_ref::append(ref);
    00458                         return *this;
    00459                 }
    00460                 /** Returns a ref specified by its index. */
    00461                 AccountRef& operator[](size_t n) const {
    00462                         return (AccountRef&) List_ref::operator[](n);
    00463                 }
    00464                 /** Assigns a shallow copy of sl to this list and returns a reference to it.
    00465                  * This is very fast because the list isn't actually copied.
    00466                  */
    00467                 AccountRefs& operator=(const AccountRefs& sl) {
    00468                         List_ref::operator=(sl);
    00469                         return *this;
    00470                 }
    00471         };
    00472 #ifdef SE_USE_NAMESPACE
    00473 } // Skype
    00474 #endif
    00475
    00476 #endif // __SIDG_SKYPEREFSHPP_INCLUDED____

All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

(c) Skype Technologies S.A. Confidential/Proprietary

Last updated: Fri Mar 16 2012