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____
(c) Skype Technologies S.A. Confidential/Proprietary
Last updated: Fri Mar 16 2012