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

- File List
- File Members

# skype-embedded_2.cpp

Go to the documentation of this file.

    00001 #include "skype-embedded_2.h"
    00002 Skype::Skype(int num_threads) : SERootObject(num_threads, SkypeFields) {}
    00003 Skype::~Skype() {}
    00004
    00005 const unsigned int Skype::moduleID() const
    00006 {
    00007         return 0;
    00008 }
    00009
    00010
    00011 /** class ContactGroup **********************/
    00012
    00013 ContactGroup::ContactGroup(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    00014 ContactGroup::~ContactGroup() {  }
    00015 void ContactGroup::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgcontactContactGroup*>(cache);  }
    00016 unsigned int ContactGroup::moduleID() const
    00017 {
    00018         return MODULE_ID;
    00019 }
    00020 String ContactGroup::getNamespace() const
    00021 {
    00022         return __EA(CONTACTGROUP);
    00023 }
    00024
    00025 extern const PMAP CONTACTGROUP_PROPERTY_MAP[] = {
    00026         {__EA(TYPE), ContactGroup::P_TYPE},
    00027         {__EA(CUSTOM_GROUP_ID), ContactGroup::P_CUSTOM_GROUP_ID},
    00028         {__EA(GIVEN_DISPLAYNAME), ContactGroup::P_GIVEN_DISPLAYNAME},
    00029         {__EA(NROFCONTACTS), ContactGroup::P_NROFCONTACTS},
    00030         {__EA(NROFCONTACTS_ONLINE), ContactGroup::P_NROFCONTACTS_ONLINE},
    00031         {0, 0}
    00032 };
    00033
    00034 extern const PMAP CONTACTGROUP_TYPE_MAP[] = {
    00035         {__EA(ALL_KNOWN_CONTACTS), ContactGroup::ALL_KNOWN_CONTACTS},
    00036         {__EA(ALL_BUDDIES), ContactGroup::ALL_BUDDIES},
    00037         {__EA(SKYPE_BUDDIES), ContactGroup::SKYPE_BUDDIES},
    00038         {__EA(SKYPEOUT_BUDDIES), ContactGroup::SKYPEOUT_BUDDIES},
    00039         {__EA(ONLINE_BUDDIES), ContactGroup::ONLINE_BUDDIES},
    00040         {__EA(UNKNOWN_OR_PENDINGAUTH_BUDDIES), ContactGroup::UNKNOWN_OR_PENDINGAUTH_BUDDIES},
    00041         {__EA(RECENTLY_CONTACTED_CONTACTS), ContactGroup::RECENTLY_CONTACTED_CONTACTS},
    00042         {__EA(CONTACTS_WAITING_MY_AUTHORIZATION), ContactGroup::CONTACTS_WAITING_MY_AUTHORIZATION},
    00043         {__EA(CONTACTS_AUTHORIZED_BY_ME), ContactGroup::CONTACTS_AUTHORIZED_BY_ME},
    00044         {__EA(CONTACTS_BLOCKED_BY_ME), ContactGroup::CONTACTS_BLOCKED_BY_ME},
    00045         {__EA(UNGROUPED_BUDDIES), ContactGroup::UNGROUPED_BUDDIES},
    00046         {__EA(CUSTOM_GROUP), ContactGroup::CUSTOM_GROUP},
    00047         {__EA(PROPOSED_SHARED_GROUP), ContactGroup::PROPOSED_SHARED_GROUP},
    00048         {__EA(SHARED_GROUP), ContactGroup::SHARED_GROUP},
    00049         {__EA(EXTERNAL_CONTACTS), ContactGroup::EXTERNAL_CONTACTS},
    00050         {0, 0}
    00051 };
    00052
    00053 namespace Sid {
    00054         template<> Sid::String tostring(const ContactGroup::TYPE& v)
    00055         {
    00056                 return enumtostring("ContactGroup::TYPE",CONTACTGROUP_TYPE_MAP,v);
    00057         }
    00058 }
    00059
    00060 void ContactGroup::OnChangeConversation(
    00061         __se_unused const ConversationRef& /*conversation*/
    00062 ) {}
    00063
    00064 void ContactGroup::OnChange(
    00065         __se_unused const ContactRef& /*contact*/
    00066 ) {}
    00067
    00068 extern const EMAP CONTACTGROUP_EMAP[] = {
    00069         {ContactGroup::P_TYPE, CONTACTGROUP_TYPE_MAP},
    00070         {0, 0}
    00071 };
    00072 const EMAP* ContactGroup::getEMap() const
    00073 {
    00074         return CONTACTGROUP_EMAP;
    00075 }
    00076 const PMAP* ContactGroup::getPMap() const
    00077 {
    00078         return CONTACTGROUP_PROPERTY_MAP;
    00079 }
    00080
    00081
    00082 /** class Contact **********************/
    00083
    00084 Contact::Contact(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    00085 Contact::~Contact() {  }
    00086 void Contact::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgcontactContact*>(cache);  }
    00087 unsigned int Contact::moduleID() const
    00088 {
    00089         return MODULE_ID;
    00090 }
    00091 String Contact::getNamespace() const
    00092 {
    00093         return __EA(CONTACT);
    00094 }
    00095
    00096 extern const PMAP CONTACT_PROPERTY_MAP[] = {
    00097         {__EA(TYPE), Contact::P_TYPE},
    00098         {__EA(SKYPENAME), Contact::P_SKYPENAME},
    00099         {__EA(PSTNNUMBER), Contact::P_PSTNNUMBER},
    00100         {__EA(FULLNAME), Contact::P_FULLNAME},
    00101         {__EA(BIRTHDAY), Contact::P_BIRTHDAY},
    00102         {__EA(GENDER), Contact::P_GENDER},
    00103         {__EA(LANGUAGES), Contact::P_LANGUAGES},
    00104         {__EA(COUNTRY), Contact::P_COUNTRY},
    00105         {__EA(PROVINCE), Contact::P_PROVINCE},
    00106         {__EA(CITY), Contact::P_CITY},
    00107         {__EA(PHONE_HOME), Contact::P_PHONE_HOME},
    00108         {__EA(PHONE_OFFICE), Contact::P_PHONE_OFFICE},
    00109         {__EA(PHONE_MOBILE), Contact::P_PHONE_MOBILE},
    00110         {__EA(EMAILS), Contact::P_EMAILS},
    00111         {__EA(HOMEPAGE), Contact::P_HOMEPAGE},
    00112         {__EA(ABOUT), Contact::P_ABOUT},
    00113         {__EA(AVATAR_IMAGE), Contact::P_AVATAR_IMAGE},
    00114         {__EA(MOOD_TEXT), Contact::P_MOOD_TEXT},
    00115         {__EA(RICH_MOOD_TEXT), Contact::P_RICH_MOOD_TEXT},
    00116         {__EA(TIMEZONE), Contact::P_TIMEZONE},
    00117         {__EA(CAPABILITIES), Contact::P_CAPABILITIES},
    00118         {__EA(PROFILE_TIMESTAMP), Contact::P_PROFILE_TIMESTAMP},
    00119         {__EA(NROF_AUTHED_BUDDIES), Contact::P_NROF_AUTHED_BUDDIES},
    00120         {__EA(IPCOUNTRY), Contact::P_IPCOUNTRY},
    00121         {__EA(AVATAR_TIMESTAMP), Contact::P_AVATAR_TIMESTAMP},
    00122         {__EA(MOOD_TIMESTAMP), Contact::P_MOOD_TIMESTAMP},
    00123         {__EA(RECEIVED_AUTHREQUEST), Contact::P_RECEIVED_AUTHREQUEST},
    00124         {__EA(AUTHREQ_TIMESTAMP), Contact::P_AUTHREQ_TIMESTAMP},
    00125         {__EA(LASTONLINE_TIMESTAMP), Contact::P_LASTONLINE_TIMESTAMP},
    00126         {__EA(AVAILABILITY), Contact::P_AVAILABILITY},
    00127         {__EA(DISPLAYNAME), Contact::P_DISPLAYNAME},
    00128         {__EA(REFRESHING), Contact::P_REFRESHING},
    00129         {__EA(GIVEN_AUTHLEVEL), Contact::P_GIVEN_AUTHLEVEL},
    00130         {__EA(GIVEN_DISPLAYNAME), Contact::P_GIVEN_DISPLAYNAME},
    00131         {__EA(ASSIGNED_COMMENT), Contact::P_ASSIGNED_COMMENT},
    00132         {__EA(LASTUSED_TIMESTAMP), Contact::P_LASTUSED_TIMESTAMP},
    00133         {__EA(AUTHREQUEST_COUNT), Contact::P_AUTHREQUEST_COUNT},
    00134         {__EA(ASSIGNED_PHONE1), Contact::P_ASSIGNED_PHONE1},
    00135         {__EA(ASSIGNED_PHONE1_LABEL), Contact::P_ASSIGNED_PHONE1_LABEL},
    00136         {__EA(ASSIGNED_PHONE2), Contact::P_ASSIGNED_PHONE2},
    00137         {__EA(ASSIGNED_PHONE2_LABEL), Contact::P_ASSIGNED_PHONE2_LABEL},
    00138         {__EA(ASSIGNED_PHONE3), Contact::P_ASSIGNED_PHONE3},
    00139         {__EA(ASSIGNED_PHONE3_LABEL), Contact::P_ASSIGNED_PHONE3_LABEL},
    00140         {__EA(POPULARITY_ORD), Contact::P_POPULARITY_ORD},
    00141         {0, 0}
    00142 };
    00143
    00144 extern const PMAP CONTACT_TYPE_MAP[] = {
    00145         {__EA(UNRECOGNIZED), Contact::UNRECOGNIZED},
    00146         {__EA(SKYPE), Contact::SKYPE},
    00147         {__EA(PSTN), Contact::PSTN},
    00148         {__EA(EMERGENCY_PSTN), Contact::EMERGENCY_PSTN},
    00149         {__EA(FREE_PSTN), Contact::FREE_PSTN},
    00150         {__EA(UNDISCLOSED_PSTN), Contact::UNDISCLOSED_PSTN},
    00151         {__EA(EXTERNAL), Contact::EXTERNAL},
    00152         {0, 0}
    00153 };
    00154
    00155 namespace Sid {
    00156         template<> Sid::String tostring(const Contact::TYPE& v)
    00157         {
    00158                 return enumtostring("Contact::TYPE",CONTACT_TYPE_MAP,v);
    00159         }
    00160 }
    00161
    00162 extern const PMAP CONTACT_AUTHLEVEL_MAP[] = {
    00163         {__EA(NONE), Contact::NONE},
    00164         {__EA(AUTHORIZED_BY_ME), Contact::AUTHORIZED_BY_ME},
    00165         {__EA(BLOCKED_BY_ME), Contact::BLOCKED_BY_ME},
    00166         {0, 0}
    00167 };
    00168
    00169 namespace Sid {
    00170         template<> Sid::String tostring(const Contact::AUTHLEVEL& v)
    00171         {
    00172                 return enumtostring("Contact::AUTHLEVEL",CONTACT_AUTHLEVEL_MAP,v);
    00173         }
    00174 }
    00175
    00176 extern const PMAP CONTACT_AVAILABILITY_MAP[] = {
    00177         {__EA(UNKNOWN), Contact::UNKNOWN},
    00178         {__EA(PENDINGAUTH), Contact::PENDINGAUTH},
    00179         {__EA(BLOCKED), Contact::BLOCKED},
    00180         {__EA(BLOCKED_SKYPEOUT), Contact::BLOCKED_SKYPEOUT},
    00181         {__EA(SKYPEOUT), Contact::SKYPEOUT},
    00182         {__EA(OFFLINE), Contact::OFFLINE},
    00183         {__EA(OFFLINE_BUT_VM_ABLE), Contact::OFFLINE_BUT_VM_ABLE},
    00184         {__EA(OFFLINE_BUT_CF_ABLE), Contact::OFFLINE_BUT_CF_ABLE},
    00185         {__EA(ONLINE), Contact::ONLINE},
    00186         {__EA(AWAY), Contact::AWAY},
    00187         {__EA(NOT_AVAILABLE), Contact::NOT_AVAILABLE},
    00188         {__EA(DO_NOT_DISTURB), Contact::DO_NOT_DISTURB},
    00189         {__EA(SKYPE_ME), Contact::SKYPE_ME},
    00190         {__EA(INVISIBLE), Contact::INVISIBLE},
    00191         {__EA(CONNECTING), Contact::CONNECTING},
    00192         {__EA(ONLINE_FROM_MOBILE), Contact::ONLINE_FROM_MOBILE},
    00193         {__EA(AWAY_FROM_MOBILE), Contact::AWAY_FROM_MOBILE},
    00194         {__EA(NOT_AVAILABLE_FROM_MOBILE), Contact::NOT_AVAILABLE_FROM_MOBILE},
    00195         {__EA(DO_NOT_DISTURB_FROM_MOBILE), Contact::DO_NOT_DISTURB_FROM_MOBILE},
    00196         {__EA(SKYPE_ME_FROM_MOBILE), Contact::SKYPE_ME_FROM_MOBILE},
    00197         {0, 0}
    00198 };
    00199
    00200 namespace Sid {
    00201         template<> Sid::String tostring(const Contact::AVAILABILITY& v)
    00202         {
    00203                 return enumtostring("Contact::AVAILABILITY",CONTACT_AVAILABILITY_MAP,v);
    00204         }
    00205 }
    00206
    00207 extern const PMAP CONTACT_EXTRA_AUTHREQ_FIELDS_MAP[] = {
    00208         {__EA(SEND_VERIFIED_EMAIL), Contact::SEND_VERIFIED_EMAIL},
    00209         {__EA(SEND_VERIFIED_COMPANY), Contact::SEND_VERIFIED_COMPANY},
    00210         {0, 0}
    00211 };
    00212
    00213 namespace Sid {
    00214         template<> Sid::String tostring(const Contact::EXTRA_AUTHREQ_FIELDS& v)
    00215         {
    00216                 return enumtostring("Contact::EXTRA_AUTHREQ_FIELDS",CONTACT_EXTRA_AUTHREQ_FIELDS_MAP,v);
    00217         }
    00218 }
    00219
    00220 extern const PMAP CONTACT_CAPABILITY_MAP[] = {
    00221         {__EA(CAPABILITY_VOICEMAIL), Contact::CAPABILITY_VOICEMAIL},
    00222         {__EA(CAPABILITY_SKYPEOUT), Contact::CAPABILITY_SKYPEOUT},
    00223         {__EA(CAPABILITY_SKYPEIN), Contact::CAPABILITY_SKYPEIN},
    00224         {__EA(CAPABILITY_CAN_BE_SENT_VM), Contact::CAPABILITY_CAN_BE_SENT_VM},
    00225         {__EA(CAPABILITY_CALL_FORWARD), Contact::CAPABILITY_CALL_FORWARD},
    00226         {__EA(CAPABILITY_VIDEO), Contact::CAPABILITY_VIDEO},
    00227         {__EA(CAPABILITY_TEXT), Contact::CAPABILITY_TEXT},
    00228         {__EA(CAPABILITY_SERVICE_PROVIDER), Contact::CAPABILITY_SERVICE_PROVIDER},
    00229         {__EA(CAPABILITY_LARGE_CONFERENCE), Contact::CAPABILITY_LARGE_CONFERENCE},
    00230         {__EA(CAPABILITY_COMMERCIAL_CONTACT), Contact::CAPABILITY_COMMERCIAL_CONTACT},
    00231         {__EA(CAPABILITY_PSTN_TRANSFER), Contact::CAPABILITY_PSTN_TRANSFER},
    00232         {__EA(CAPABILITY_TEXT_EVER), Contact::CAPABILITY_TEXT_EVER},
    00233         {__EA(CAPABILITY_VOICE_EVER), Contact::CAPABILITY_VOICE_EVER},
    00234         {__EA(CAPABILITY_MOBILE_DEVICE), Contact::CAPABILITY_MOBILE_DEVICE},
    00235         {__EA(CAPABILITY_PUBLIC_CONTACT), Contact::CAPABILITY_PUBLIC_CONTACT},
    00236         {0, 0}
    00237 };
    00238
    00239 namespace Sid {
    00240         template<> Sid::String tostring(const Contact::CAPABILITY& v)
    00241         {
    00242                 return enumtostring("Contact::CAPABILITY",CONTACT_CAPABILITY_MAP,v);
    00243         }
    00244 }
    00245
    00246 extern const PMAP CONTACT_CAPABILITYSTATUS_MAP[] = {
    00247         {__EA(NO_CAPABILITY), Contact::NO_CAPABILITY},
    00248         {__EA(CAPABILITY_MIXED), Contact::CAPABILITY_MIXED},
    00249         {__EA(CAPABILITY_EXISTS), Contact::CAPABILITY_EXISTS},
    00250         {0, 0}
    00251 };
    00252
    00253 namespace Sid {
    00254         template<> Sid::String tostring(const Contact::CAPABILITYSTATUS& v)
    00255         {
    00256                 return enumtostring("Contact::CAPABILITYSTATUS",CONTACT_CAPABILITYSTATUS_MAP,v);
    00257         }
    00258 }
    00259
    00260 extern const EMAP CONTACT_EMAP[] = {
    00261         {Contact::P_TYPE, CONTACT_TYPE_MAP},
    00262         {Contact::P_AVAILABILITY, CONTACT_AVAILABILITY_MAP},
    00263         {Contact::P_GIVEN_AUTHLEVEL, CONTACT_AUTHLEVEL_MAP},
    00264         {0, 0}
    00265 };
    00266 const EMAP* Contact::getEMap() const
    00267 {
    00268         return CONTACT_EMAP;
    00269 }
    00270 const PMAP* Contact::getPMap() const
    00271 {
    00272         return CONTACT_PROPERTY_MAP;
    00273 }
    00274
    00275
    00276 /** class ContactSearch **********************/
    00277
    00278 ContactSearch::ContactSearch(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    00279 ContactSearch::~ContactSearch() {  }
    00280 void ContactSearch::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgcontactsearchContactSearch*>(cache);  }
    00281 unsigned int ContactSearch::moduleID() const
    00282 {
    00283         return MODULE_ID;
    00284 }
    00285 String ContactSearch::getNamespace() const
    00286 {
    00287         return __EA(CONTACTSEARCH);
    00288 }
    00289
    00290 extern const PMAP CONTACTSEARCH_PROPERTY_MAP[] = {
    00291         {__EA(CONTACT_SEARCH_STATUS), ContactSearch::P_CONTACT_SEARCH_STATUS},
    00292         {0, 0}
    00293 };
    00294
    00295 extern const PMAP CONTACTSEARCH_STATUS_MAP[] = {
    00296         {__EA(CONSTRUCTION), ContactSearch::CONSTRUCTION},
    00297         {__EA(PENDING), ContactSearch::PENDING},
    00298         {__EA(EXTENDABLE), ContactSearch::EXTENDABLE},
    00299         {__EA(FINISHED), ContactSearch::FINISHED},
    00300         {__EA(FAILED), ContactSearch::FAILED},
    00301         {0, 0}
    00302 };
    00303
    00304 namespace Sid {
    00305         template<> Sid::String tostring(const ContactSearch::STATUS& v)
    00306         {
    00307                 return enumtostring("ContactSearch::STATUS",CONTACTSEARCH_STATUS_MAP,v);
    00308         }
    00309 }
    00310
    00311 extern const PMAP CONTACTSEARCH_CONDITION_MAP[] = {
    00312         {__EA(EQ), ContactSearch::EQ},
    00313         {__EA(GT), ContactSearch::GT},
    00314         {__EA(GE), ContactSearch::GE},
    00315         {__EA(LT), ContactSearch::LT},
    00316         {__EA(LE), ContactSearch::LE},
    00317         {__EA(PREFIX_EQ), ContactSearch::PREFIX_EQ},
    00318         {__EA(PREFIX_GE), ContactSearch::PREFIX_GE},
    00319         {__EA(PREFIX_LE), ContactSearch::PREFIX_LE},
    00320         {__EA(CONTAINS_WORDS), ContactSearch::CONTAINS_WORDS},
    00321         {__EA(CONTAINS_WORD_PREFIXES), ContactSearch::CONTAINS_WORD_PREFIXES},
    00322         {0, 0}
    00323 };
    00324
    00325 namespace Sid {
    00326         template<> Sid::String tostring(const ContactSearch::CONDITION& v)
    00327         {
    00328                 return enumtostring("ContactSearch::CONDITION",CONTACTSEARCH_CONDITION_MAP,v);
    00329         }
    00330 }
    00331
    00332 void ContactSearch::OnNewResult(
    00333         __se_unused const ContactRef& /*contact*/,
    00334         __se_unused const uint& /*rankValue*/
    00335 ) {}
    00336
    00337 extern const EMAP CONTACTSEARCH_EMAP[] = {
    00338         {ContactSearch::P_CONTACT_SEARCH_STATUS, CONTACTSEARCH_STATUS_MAP},
    00339         {0, 0}
    00340 };
    00341 const EMAP* ContactSearch::getEMap() const
    00342 {
    00343         return CONTACTSEARCH_EMAP;
    00344 }
    00345 const PMAP* ContactSearch::getPMap() const
    00346 {
    00347         return CONTACTSEARCH_PROPERTY_MAP;
    00348 }
    00349
    00350 extern const PMAP TRANSFER_SENDFILE_ERROR_MAP[] = {
    00351         {__EA(TRANSFER_OPEN_SUCCESS), TRANSFER_OPEN_SUCCESS},
    00352         {__EA(TRANSFER_BAD_FILENAME), TRANSFER_BAD_FILENAME},
    00353         {__EA(TRANSFER_OPEN_FAILED), TRANSFER_OPEN_FAILED},
    00354         {__EA(TRANSFER_TOO_MANY_PARALLEL), TRANSFER_TOO_MANY_PARALLEL},
    00355         {0, 0}
    00356 };
    00357
    00358 namespace Sid {
    00359         template<> Sid::String tostring(const TRANSFER_SENDFILE_ERROR& v)
    00360         {
    00361                 return enumtostring("TRANSFER_SENDFILE_ERROR",TRANSFER_SENDFILE_ERROR_MAP,v);
    00362         }
    00363 }
    00364
    00365 extern const PMAP LEAVE_REASON_MAP[] = {
    00366         {__EA(LEAVE_REASON_NONE), LEAVE_REASON_NONE},
    00367         {__EA(RETIRED_USER_INCAPABLE), RETIRED_USER_INCAPABLE},
    00368         {__EA(RETIRED_ADDER_MUST_BE_FRIEND), RETIRED_ADDER_MUST_BE_FRIEND},
    00369         {__EA(RETIRED_ADDER_MUST_BE_AUTHORIZED), RETIRED_ADDER_MUST_BE_AUTHORIZED},
    00370         {__EA(RETIRED_DECLINE_ADD), RETIRED_DECLINE_ADD},
    00371         {__EA(RETIRED_UNSUBSCRIBE), RETIRED_UNSUBSCRIBE},
    00372         {__EA(LIVE_NO_ANSWER), LIVE_NO_ANSWER},
    00373         {__EA(LIVE_MANUAL), LIVE_MANUAL},
    00374         {__EA(LIVE_BUSY), LIVE_BUSY},
    00375         {__EA(LIVE_CONNECTION_DROPPED), LIVE_CONNECTION_DROPPED},
    00376         {__EA(LIVE_NO_SKYPEOUT_SUBSCRIPTION), LIVE_NO_SKYPEOUT_SUBSCRIPTION},
    00377         {__EA(LIVE_INSUFFICIENT_FUNDS), LIVE_INSUFFICIENT_FUNDS},
    00378         {__EA(LIVE_INTERNET_CONNECTION_LOST), LIVE_INTERNET_CONNECTION_LOST},
    00379         {__EA(LIVE_SKYPEOUT_ACCOUNT_BLOCKED), LIVE_SKYPEOUT_ACCOUNT_BLOCKED},
    00380         {__EA(LIVE_PSTN_COULD_NOT_CONNECT_TO_SKYPE_PROXY), LIVE_PSTN_COULD_NOT_CONNECT_TO_SKYPE_PROXY},
    00381         {__EA(LIVE_PSTN_INVALID_NUMBER), LIVE_PSTN_INVALID_NUMBER},
    00382         {__EA(LIVE_PSTN_NUMBER_FORBIDDEN), LIVE_PSTN_NUMBER_FORBIDDEN},
    00383         {__EA(LIVE_PSTN_CALL_TIMED_OUT), LIVE_PSTN_CALL_TIMED_OUT},
    00384         {__EA(LIVE_PSTN_BUSY), LIVE_PSTN_BUSY},
    00385         {__EA(LIVE_PSTN_CALL_TERMINATED), LIVE_PSTN_CALL_TERMINATED},
    00386         {__EA(LIVE_PSTN_NETWORK_ERROR), LIVE_PSTN_NETWORK_ERROR},
    00387         {__EA(LIVE_NUMBER_UNAVAILABLE), LIVE_NUMBER_UNAVAILABLE},
    00388         {__EA(LIVE_PSTN_CALL_REJECTED), LIVE_PSTN_CALL_REJECTED},
    00389         {__EA(LIVE_PSTN_MISC_ERROR), LIVE_PSTN_MISC_ERROR},
    00390         {__EA(LIVE_INTERNAL_ERROR), LIVE_INTERNAL_ERROR},
    00391         {__EA(LIVE_UNABLE_TO_CONNECT), LIVE_UNABLE_TO_CONNECT},
    00392         {__EA(LIVE_RECORDING_FAILED), LIVE_RECORDING_FAILED},
    00393         {__EA(LIVE_PLAYBACK_ERROR), LIVE_PLAYBACK_ERROR},
    00394         {__EA(LIVE_LEGACY_ERROR), LIVE_LEGACY_ERROR},
    00395         {__EA(LIVE_BLOCKED_BY_PRIVACY_SETTINGS), LIVE_BLOCKED_BY_PRIVACY_SETTINGS},
    00396         {__EA(LIVE_ERROR), LIVE_ERROR},
    00397         {__EA(LIVE_TRANSFER_FAILED), LIVE_TRANSFER_FAILED},
    00398         {__EA(LIVE_TRANSFER_INSUFFICIENT_FUNDS), LIVE_TRANSFER_INSUFFICIENT_FUNDS},
    00399         {__EA(LIVE_BLOCKED_BY_US), LIVE_BLOCKED_BY_US},
    00400         {__EA(LIVE_EMERGENCY_CALL_DENIED), LIVE_EMERGENCY_CALL_DENIED},
    00401         {0, 0}
    00402 };
    00403
    00404 namespace Sid {
    00405         template<> Sid::String tostring(const LEAVE_REASON& v)
    00406         {
    00407                 return enumtostring("LEAVE_REASON",LEAVE_REASON_MAP,v);
    00408         }
    00409 }
    00410
    00411
    00412 /** class Participant **********************/
    00413
    00414 Participant::Participant(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    00415 Participant::~Participant() {  }
    00416 void Participant::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgconversationParticipant*>(cache);  }
    00417 unsigned int Participant::moduleID() const
    00418 {
    00419         return MODULE_ID;
    00420 }
    00421 String Participant::getNamespace() const
    00422 {
    00423         return __EA(PARTICIPANT);
    00424 }
    00425
    00426 extern const PMAP PARTICIPANT_PROPERTY_MAP[] = {
    00427         {__EA(CONVO_ID), Participant::P_CONVO_ID},
    00428         {__EA(IDENTITY), Participant::P_IDENTITY},
    00429         {__EA(RANK), Participant::P_RANK},
    00430         {__EA(REQUESTED_RANK), Participant::P_REQUESTED_RANK},
    00431         {__EA(TEXT_STATUS), Participant::P_TEXT_STATUS},
    00432         {__EA(VOICE_STATUS), Participant::P_VOICE_STATUS},
    00433         {__EA(VIDEO_STATUS), Participant::P_VIDEO_STATUS},
    00434         {__EA(LIVE_IDENTITY), Participant::P_LIVE_IDENTITY},
    00435         {__EA(LIVE_PRICE_FOR_ME), Participant::P_LIVE_PRICE_FOR_ME},
    00436         {__EA(LIVE_FWD_IDENTITIES), Participant::P_LIVE_FWD_IDENTITIES},
    00437         {__EA(LIVE_START_TIMESTAMP), Participant::P_LIVE_START_TIMESTAMP},
    00438         {__EA(SOUND_LEVEL), Participant::P_SOUND_LEVEL},
    00439         {__EA(DEBUGINFO), Participant::P_DEBUGINFO},
    00440         {__EA(LAST_VOICE_ERROR), Participant::P_LAST_VOICE_ERROR},
    00441         {__EA(QUALITY_PROBLEMS), Participant::P_QUALITY_PROBLEMS},
    00442         {__EA(LIVE_TYPE), Participant::P_LIVE_TYPE},
    00443         {__EA(LIVE_COUNTRY), Participant::P_LIVE_COUNTRY},
    00444         {__EA(TRANSFERRED_BY), Participant::P_TRANSFERRED_BY},
    00445         {__EA(TRANSFERRED_TO), Participant::P_TRANSFERRED_TO},
    00446         {__EA(ADDER), Participant::P_ADDER},
    00447         {__EA(LAST_LEAVEREASON), Participant::P_LAST_LEAVEREASON},
    00448         {0, 0}
    00449 };
    00450
    00451 extern const PMAP PARTICIPANT_RANK_MAP[] = {
    00452         {__EA(CREATOR), Participant::CREATOR},
    00453         {__EA(ADMIN), Participant::ADMIN},
    00454         {__EA(SPEAKER), Participant::SPEAKER},
    00455         {__EA(WRITER), Participant::WRITER},
    00456         {__EA(SPECTATOR), Participant::SPECTATOR},
    00457         {__EA(APPLICANT), Participant::APPLICANT},
    00458         {__EA(RETIRED), Participant::RETIRED},
    00459         {__EA(OUTLAW), Participant::OUTLAW},
    00460         {0, 0}
    00461 };
    00462
    00463 namespace Sid {
    00464         template<> Sid::String tostring(const Participant::RANK& v)
    00465         {
    00466                 return enumtostring("Participant::RANK",PARTICIPANT_RANK_MAP,v);
    00467         }
    00468 }
    00469
    00470 extern const PMAP PARTICIPANT_TEXT_STATUS_MAP[] = {
    00471         {__EA(TEXT_UNKNOWN), Participant::TEXT_UNKNOWN},
    00472         {__EA(TEXT_NA), Participant::TEXT_NA},
    00473         {__EA(READING), Participant::READING},
    00474         {__EA(WRITING), Participant::WRITING},
    00475         {__EA(WRITING_AS_ANGRY), Participant::WRITING_AS_ANGRY},
    00476         {__EA(WRITING_AS_CAT), Participant::WRITING_AS_CAT},
    00477         {0, 0}
    00478 };
    00479
    00480 namespace Sid {
    00481         template<> Sid::String tostring(const Participant::TEXT_STATUS& v)
    00482         {
    00483                 return enumtostring("Participant::TEXT_STATUS",PARTICIPANT_TEXT_STATUS_MAP,v);
    00484         }
    00485 }
    00486
    00487 extern const PMAP PARTICIPANT_VOICE_STATUS_MAP[] = {
    00488         {__EA(VOICE_UNKNOWN), Participant::VOICE_UNKNOWN},
    00489         {__EA(VOICE_NA), Participant::VOICE_NA},
    00490         {__EA(VOICE_AVAILABLE), Participant::VOICE_AVAILABLE},
    00491         {__EA(VOICE_CONNECTING), Participant::VOICE_CONNECTING},
    00492         {__EA(RINGING), Participant::RINGING},
    00493         {__EA(EARLY_MEDIA), Participant::EARLY_MEDIA},
    00494         {__EA(LISTENING), Participant::LISTENING},
    00495         {__EA(SPEAKING), Participant::SPEAKING},
    00496         {__EA(VOICE_ON_HOLD), Participant::VOICE_ON_HOLD},
    00497         {__EA(VOICE_STOPPED), Participant::VOICE_STOPPED},
    00498         {0, 0}
    00499 };
    00500
    00501 namespace Sid {
    00502         template<> Sid::String tostring(const Participant::VOICE_STATUS& v)
    00503         {
    00504                 return enumtostring("Participant::VOICE_STATUS",PARTICIPANT_VOICE_STATUS_MAP,v);
    00505         }
    00506 }
    00507
    00508 extern const PMAP PARTICIPANT_VIDEO_STATUS_MAP[] = {
    00509         {__EA(VIDEO_UNKNOWN), Participant::VIDEO_UNKNOWN},
    00510         {__EA(VIDEO_NA), Participant::VIDEO_NA},
    00511         {__EA(VIDEO_AVAILABLE), Participant::VIDEO_AVAILABLE},
    00512         {__EA(VIDEO_CONNECTING), Participant::VIDEO_CONNECTING},
    00513         {__EA(STREAMING), Participant::STREAMING},
    00514         {__EA(VIDEO_ON_HOLD), Participant::VIDEO_ON_HOLD},
    00515         {0, 0}
    00516 };
    00517
    00518 namespace Sid {
    00519         template<> Sid::String tostring(const Participant::VIDEO_STATUS& v)
    00520         {
    00521                 return enumtostring("Participant::VIDEO_STATUS",PARTICIPANT_VIDEO_STATUS_MAP,v);
    00522         }
    00523 }
    00524
    00525 extern const PMAP PARTICIPANT_DTMF_MAP[] = {
    00526         {__EA(DTMF_0), Participant::DTMF_0},
    00527         {__EA(DTMF_1), Participant::DTMF_1},
    00528         {__EA(DTMF_2), Participant::DTMF_2},
    00529         {__EA(DTMF_3), Participant::DTMF_3},
    00530         {__EA(DTMF_4), Participant::DTMF_4},
    00531         {__EA(DTMF_5), Participant::DTMF_5},
    00532         {__EA(DTMF_6), Participant::DTMF_6},
    00533         {__EA(DTMF_7), Participant::DTMF_7},
    00534         {__EA(DTMF_8), Participant::DTMF_8},
    00535         {__EA(DTMF_9), Participant::DTMF_9},
    00536         {__EA(DTMF_STAR), Participant::DTMF_STAR},
    00537         {__EA(DTMF_POUND), Participant::DTMF_POUND},
    00538         {0, 0}
    00539 };
    00540
    00541 namespace Sid {
    00542         template<> Sid::String tostring(const Participant::DTMF& v)
    00543         {
    00544                 return enumtostring("Participant::DTMF",PARTICIPANT_DTMF_MAP,v);
    00545         }
    00546 }
    00547
    00548 void Participant::OnIncomingDTMF(
    00549         __se_unused const DTMF& /*dtmf*/
    00550 ) {}
    00551
    00552 extern const EMAP PARTICIPANT_EMAP[] = {
    00553         {Participant::P_RANK, PARTICIPANT_RANK_MAP},
    00554         {Participant::P_REQUESTED_RANK, PARTICIPANT_RANK_MAP},
    00555         {Participant::P_TEXT_STATUS, PARTICIPANT_TEXT_STATUS_MAP},
    00556         {Participant::P_VOICE_STATUS, PARTICIPANT_VOICE_STATUS_MAP},
    00557         {Participant::P_VIDEO_STATUS, PARTICIPANT_VIDEO_STATUS_MAP},
    00558         {0, 0}
    00559 };
    00560 const EMAP* Participant::getEMap() const
    00561 {
    00562         return PARTICIPANT_EMAP;
    00563 }
    00564 const PMAP* Participant::getPMap() const
    00565 {
    00566         return PARTICIPANT_PROPERTY_MAP;
    00567 }
    00568
    00569
    00570 /** class Conversation **********************/
    00571
    00572 Conversation::Conversation(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    00573 Conversation::~Conversation() {  }
    00574 void Conversation::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgconversationConversation*>(cache);  }
    00575 unsigned int Conversation::moduleID() const
    00576 {
    00577         return MODULE_ID;
    00578 }
    00579 String Conversation::getNamespace() const
    00580 {
    00581         return __EA(CONVERSATION);
    00582 }
    00583
    00584 extern const PMAP CONVERSATION_PROPERTY_MAP[] = {
    00585         {__EA(IDENTITY), Conversation::P_IDENTITY},
    00586         {__EA(TYPE), Conversation::P_TYPE},
    00587         {__EA(LIVE_HOST), Conversation::P_LIVE_HOST},
    00588         {__EA(LIVE_START_TIMESTAMP), Conversation::P_LIVE_START_TIMESTAMP},
    00589         {__EA(LIVE_IS_MUTED), Conversation::P_LIVE_IS_MUTED},
    00590         {__EA(ALERT_STRING), Conversation::P_ALERT_STRING},
    00591         {__EA(IS_BOOKMARKED), Conversation::P_IS_BOOKMARKED},
    00592         {__EA(GIVEN_DISPLAYNAME), Conversation::P_GIVEN_DISPLAYNAME},
    00593         {__EA(DISPLAYNAME), Conversation::P_DISPLAYNAME},
    00594         {__EA(LOCAL_LIVESTATUS), Conversation::P_LOCAL_LIVESTATUS},
    00595         {__EA(INBOX_TIMESTAMP), Conversation::P_INBOX_TIMESTAMP},
    00596         {__EA(INBOX_MESSAGE_ID), Conversation::P_INBOX_MESSAGE_ID},
    00597         {__EA(UNCONSUMED_SUPPRESSED_MESSAGES), Conversation::P_UNCONSUMED_SUPPRESSED_MESSAGES},
    00598         {__EA(UNCONSUMED_NORMAL_MESSAGES), Conversation::P_UNCONSUMED_NORMAL_MESSAGES},
    00599         {__EA(UNCONSUMED_ELEVATED_MESSAGES), Conversation::P_UNCONSUMED_ELEVATED_MESSAGES},
    00600         {__EA(UNCONSUMED_MESSAGES_VOICE), Conversation::P_UNCONSUMED_MESSAGES_VOICE},
    00601         {__EA(ACTIVE_VM_ID), Conversation::P_ACTIVE_VM_ID},
    00602         {__EA(CONSUMPTION_HORIZON), Conversation::P_CONSUMPTION_HORIZON},
    00603         {__EA(LAST_ACTIVITY_TIMESTAMP), Conversation::P_LAST_ACTIVITY_TIMESTAMP},
    00604         {__EA(SPAWNED_FROM_CONVO_ID), Conversation::P_SPAWNED_FROM_CONVO_ID},
    00605         {__EA(CREATOR), Conversation::P_CREATOR},
    00606         {__EA(CREATION_TIMESTAMP), Conversation::P_CREATION_TIMESTAMP},
    00607         {__EA(MY_STATUS), Conversation::P_MY_STATUS},
    00608         {__EA(OPT_JOINING_ENABLED), Conversation::P_OPT_JOINING_ENABLED},
    00609         {__EA(OPT_ENTRY_LEVEL_RANK), Conversation::P_OPT_ENTRY_LEVEL_RANK},
    00610         {__EA(OPT_DISCLOSE_HISTORY), Conversation::P_OPT_DISCLOSE_HISTORY},
    00611         {__EA(OPT_ADMIN_ONLY_ACTIVITIES), Conversation::P_OPT_ADMIN_ONLY_ACTIVITIES},
    00612         {__EA(PASSWORDHINT), Conversation::P_PASSWORDHINT},
    00613         {__EA(META_NAME), Conversation::P_META_NAME},
    00614         {__EA(META_TOPIC), Conversation::P_META_TOPIC},
    00615         {__EA(META_GUIDELINES), Conversation::P_META_GUIDELINES},
    00616         {__EA(META_PICTURE), Conversation::P_META_PICTURE},
    00617         {0, 0}
    00618 };
    00619
    00620 extern const PMAP CONVERSATION_TYPE_MAP[] = {
    00621         {__EA(DIALOG), Conversation::DIALOG},
    00622         {__EA(CONFERENCE), Conversation::CONFERENCE},
    00623         {__EA(TERMINATED_CONFERENCE), Conversation::TERMINATED_CONFERENCE},
    00624         {__EA(LEGACY_VOICE_CONFERENCE), Conversation::LEGACY_VOICE_CONFERENCE},
    00625         {__EA(LEGACY_SHAREDGROUP), Conversation::LEGACY_SHAREDGROUP},
    00626         {0, 0}
    00627 };
    00628
    00629 namespace Sid {
    00630         template<> Sid::String tostring(const Conversation::TYPE& v)
    00631         {
    00632                 return enumtostring("Conversation::TYPE",CONVERSATION_TYPE_MAP,v);
    00633         }
    00634 }
    00635
    00636 extern const PMAP CONVERSATION_MY_STATUS_MAP[] = {
    00637         {__EA(CONNECTING), Conversation::CONNECTING},
    00638         {__EA(RETRY_CONNECTING), Conversation::RETRY_CONNECTING},
    00639         {__EA(DOWNLOADING_MESSAGES), Conversation::DOWNLOADING_MESSAGES},
    00640         {__EA(QUEUED_TO_ENTER), Conversation::QUEUED_TO_ENTER},
    00641         {__EA(APPLICANT), Conversation::APPLICANT},
    00642         {__EA(APPLICATION_DENIED), Conversation::APPLICATION_DENIED},
    00643         {__EA(INVALID_ACCESS_TOKEN), Conversation::INVALID_ACCESS_TOKEN},
    00644         {__EA(CONSUMER), Conversation::CONSUMER},
    00645         {__EA(RETIRED_FORCEFULLY), Conversation::RETIRED_FORCEFULLY},
    00646         {__EA(RETIRED_VOLUNTARILY), Conversation::RETIRED_VOLUNTARILY},
    00647         {0, 0}
    00648 };
    00649
    00650 namespace Sid {
    00651         template<> Sid::String tostring(const Conversation::MY_STATUS& v)
    00652         {
    00653                 return enumtostring("Conversation::MY_STATUS",CONVERSATION_MY_STATUS_MAP,v);
    00654         }
    00655 }
    00656
    00657 extern const PMAP CONVERSATION_LOCAL_LIVESTATUS_MAP[] = {
    00658         {__EA(NONE), Conversation::NONE},
    00659         {__EA(STARTING), Conversation::STARTING},
    00660         {__EA(RINGING_FOR_ME), Conversation::RINGING_FOR_ME},
    00661         {__EA(IM_LIVE), Conversation::IM_LIVE},
    00662         {__EA(ON_HOLD_LOCALLY), Conversation::ON_HOLD_LOCALLY},
    00663         {__EA(ON_HOLD_REMOTELY), Conversation::ON_HOLD_REMOTELY},
    00664         {__EA(OTHERS_ARE_LIVE), Conversation::OTHERS_ARE_LIVE},
    00665         {__EA(OTHERS_ARE_LIVE_FULL), Conversation::OTHERS_ARE_LIVE_FULL},
    00666         {__EA(PLAYING_VOICE_MESSAGE), Conversation::PLAYING_VOICE_MESSAGE},
    00667         {__EA(RECORDING_VOICE_MESSAGE), Conversation::RECORDING_VOICE_MESSAGE},
    00668         {__EA(RECENTLY_LIVE), Conversation::RECENTLY_LIVE},
    00669         {__EA(TRANSFERRING), Conversation::TRANSFERRING},
    00670         {0, 0}
    00671 };
    00672
    00673 namespace Sid {
    00674         template<> Sid::String tostring(const Conversation::LOCAL_LIVESTATUS& v)
    00675         {
    00676                 return enumtostring("Conversation::LOCAL_LIVESTATUS",CONVERSATION_LOCAL_LIVESTATUS_MAP,v);
    00677         }
    00678 }
    00679
    00680 extern const PMAP CONVERSATION_ALLOWED_ACTIVITY_MAP[] = {
    00681         {__EA(SET_META), Conversation::SET_META},
    00682         {__EA(ADD_CONSUMERS), Conversation::ADD_CONSUMERS},
    00683         {__EA(SPEAK), Conversation::SPEAK},
    00684         {__EA(SPEAK_AND_WRITE), Conversation::SPEAK_AND_WRITE},
    00685         {0, 0}
    00686 };
    00687
    00688 namespace Sid {
    00689         template<> Sid::String tostring(const Conversation::ALLOWED_ACTIVITY& v)
    00690         {
    00691                 return enumtostring("Conversation::ALLOWED_ACTIVITY",CONVERSATION_ALLOWED_ACTIVITY_MAP,v);
    00692         }
    00693 }
    00694
    00695 extern const PMAP CONVERSATION_PARTICIPANTFILTER_MAP[] = {
    00696         {__EA(ALL), Conversation::ALL},
    00697         {__EA(CONSUMERS), Conversation::CONSUMERS},
    00698         {__EA(APPLICANTS), Conversation::APPLICANTS},
    00699         {__EA(CONSUMERS_AND_APPLICANTS), Conversation::CONSUMERS_AND_APPLICANTS},
    00700         {__EA(MYSELF), Conversation::MYSELF},
    00701         {__EA(OTHER_CONSUMERS), Conversation::OTHER_CONSUMERS},
    00702         {0, 0}
    00703 };
    00704
    00705 namespace Sid {
    00706         template<> Sid::String tostring(const Conversation::PARTICIPANTFILTER& v)
    00707         {
    00708                 return enumtostring("Conversation::PARTICIPANTFILTER",CONVERSATION_PARTICIPANTFILTER_MAP,v);
    00709         }
    00710 }
    00711
    00712 extern const PMAP CONVERSATION_LIST_TYPE_MAP[] = {
    00713         {__EA(ALL_CONVERSATIONS), Conversation::ALL_CONVERSATIONS},
    00714         {__EA(INBOX_CONVERSATIONS), Conversation::INBOX_CONVERSATIONS},
    00715         {__EA(BOOKMARKED_CONVERSATIONS), Conversation::BOOKMARKED_CONVERSATIONS},
    00716         {__EA(LIVE_CONVERSATIONS), Conversation::LIVE_CONVERSATIONS},
    00717         {__EA(REALLY_ALL_CONVERSATIONS), Conversation::REALLY_ALL_CONVERSATIONS},
    00718         {0, 0}
    00719 };
    00720
    00721 namespace Sid {
    00722         template<> Sid::String tostring(const Conversation::LIST_TYPE& v)
    00723         {
    00724                 return enumtostring("Conversation::LIST_TYPE",CONVERSATION_LIST_TYPE_MAP,v);
    00725         }
    00726 }
    00727
    00728 void Conversation::OnParticipantListChange(
    00729 ) {}
    00730
    00731 void Conversation::OnMessage(
    00732         __se_unused const MessageRef& /*message*/
    00733 ) {}
    00734
    00735 void Conversation::OnSpawnConference(
    00736         __se_unused const ConversationRef& /*spawned*/
    00737 ) {}
    00738
    00739 extern const EMAP CONVERSATION_EMAP[] = {
    00740         {Conversation::P_TYPE, CONVERSATION_TYPE_MAP},
    00741         {Conversation::P_LOCAL_LIVESTATUS, CONVERSATION_LOCAL_LIVESTATUS_MAP},
    00742         {Conversation::P_MY_STATUS, CONVERSATION_MY_STATUS_MAP},
    00743         {Conversation::P_OPT_ENTRY_LEVEL_RANK, PARTICIPANT_RANK_MAP},
    00744         {Conversation::P_OPT_ADMIN_ONLY_ACTIVITIES, CONVERSATION_ALLOWED_ACTIVITY_MAP},
    00745         {0, 0}
    00746 };
    00747 const EMAP* Conversation::getEMap() const
    00748 {
    00749         return CONVERSATION_EMAP;
    00750 }
    00751 const PMAP* Conversation::getPMap() const
    00752 {
    00753         return CONVERSATION_PROPERTY_MAP;
    00754 }
    00755
    00756
    00757 /** class Message **********************/
    00758
    00759 Message::Message(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    00760 Message::~Message() {  }
    00761 void Message::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgconversationMessage*>(cache);  }
    00762 unsigned int Message::moduleID() const
    00763 {
    00764         return MODULE_ID;
    00765 }
    00766 String Message::getNamespace() const
    00767 {
    00768         return __EA(MESSAGE);
    00769 }
    00770
    00771 extern const PMAP MESSAGE_PROPERTY_MAP[] = {
    00772         {__EA(CONVO_ID), Message::P_CONVO_ID},
    00773         {__EA(CONVO_GUID), Message::P_CONVO_GUID},
    00774         {__EA(AUTHOR), Message::P_AUTHOR},
    00775         {__EA(AUTHOR_DISPLAYNAME), Message::P_AUTHOR_DISPLAYNAME},
    00776         {__EA(GUID), Message::P_GUID},
    00777         {__EA(ORIGINALLY_MEANT_FOR), Message::P_ORIGINALLY_MEANT_FOR},
    00778         {__EA(TIMESTAMP), Message::P_TIMESTAMP},
    00779         {__EA(TYPE), Message::P_TYPE},
    00780         {__EA(SENDING_STATUS), Message::P_SENDING_STATUS},
    00781         {__EA(CONSUMPTION_STATUS), Message::P_CONSUMPTION_STATUS},
    00782         {__EA(EDITED_BY), Message::P_EDITED_BY},
    00783         {__EA(EDIT_TIMESTAMP), Message::P_EDIT_TIMESTAMP},
    00784         {__EA(PARAM_KEY), Message::P_PARAM_KEY},
    00785         {__EA(PARAM_VALUE), Message::P_PARAM_VALUE},
    00786         {__EA(BODY_XML), Message::P_BODY_XML},
    00787         {__EA(IDENTITIES), Message::P_IDENTITIES},
    00788         {__EA(REASON), Message::P_REASON},
    00789         {__EA(LEAVEREASON), Message::P_LEAVEREASON},
    00790         {__EA(PARTICIPANT_COUNT), Message::P_PARTICIPANT_COUNT},
    00791         {0, 0}
    00792 };
    00793
    00794 extern const PMAP MESSAGE_TYPE_MAP[] = {
    00795         {__EA(SET_METADATA), Message::SET_METADATA},
    00796         {__EA(SPAWNED_CONFERENCE), Message::SPAWNED_CONFERENCE},
    00797         {__EA(ADDED_CONSUMERS), Message::ADDED_CONSUMERS},
    00798         {__EA(ADDED_APPLICANTS), Message::ADDED_APPLICANTS},
    00799         {__EA(RETIRED_OTHERS), Message::RETIRED_OTHERS},
    00800         {__EA(RETIRED), Message::RETIRED},
    00801         {__EA(SET_RANK), Message::SET_RANK},
    00802         {__EA(STARTED_LIVESESSION), Message::STARTED_LIVESESSION},
    00803         {__EA(ENDED_LIVESESSION), Message::ENDED_LIVESESSION},
    00804         {__EA(REQUESTED_AUTH), Message::REQUESTED_AUTH},
    00805         {__EA(GRANTED_AUTH), Message::GRANTED_AUTH},
    00806         {__EA(BLOCKED), Message::BLOCKED},
    00807         {__EA(POSTED_TEXT), Message::POSTED_TEXT},
    00808         {__EA(POSTED_EMOTE), Message::POSTED_EMOTE},
    00809         {__EA(POSTED_CONTACTS), Message::POSTED_CONTACTS},
    00810         {__EA(POSTED_SMS), Message::POSTED_SMS},
    00811         {__EA(POSTED_ALERT), Message::POSTED_ALERT},
    00812         {__EA(POSTED_VOICE_MESSAGE), Message::POSTED_VOICE_MESSAGE},
    00813         {__EA(POSTED_FILES), Message::POSTED_FILES},
    00814         {__EA(POSTED_INVOICE), Message::POSTED_INVOICE},
    00815         {__EA(HAS_BIRTHDAY), Message::HAS_BIRTHDAY},
    00816         {0, 0}
    00817 };
    00818
    00819 namespace Sid {
    00820         template<> Sid::String tostring(const Message::TYPE& v)
    00821         {
    00822                 return enumtostring("Message::TYPE",MESSAGE_TYPE_MAP,v);
    00823         }
    00824 }
    00825
    00826 extern const PMAP MESSAGE_SENDING_STATUS_MAP[] = {
    00827         {__EA(SENDING), Message::SENDING},
    00828         {__EA(SENT), Message::SENT},
    00829         {__EA(FAILED_TO_SEND), Message::FAILED_TO_SEND},
    00830         {0, 0}
    00831 };
    00832
    00833 namespace Sid {
    00834         template<> Sid::String tostring(const Message::SENDING_STATUS& v)
    00835         {
    00836                 return enumtostring("Message::SENDING_STATUS",MESSAGE_SENDING_STATUS_MAP,v);
    00837         }
    00838 }
    00839
    00840 extern const PMAP MESSAGE_CONSUMPTION_STATUS_MAP[] = {
    00841         {__EA(CONSUMED), Message::CONSUMED},
    00842         {__EA(UNCONSUMED_SUPPRESSED), Message::UNCONSUMED_SUPPRESSED},
    00843         {__EA(UNCONSUMED_NORMAL), Message::UNCONSUMED_NORMAL},
    00844         {__EA(UNCONSUMED_ELEVATED), Message::UNCONSUMED_ELEVATED},
    00845         {0, 0}
    00846 };
    00847
    00848 namespace Sid {
    00849         template<> Sid::String tostring(const Message::CONSUMPTION_STATUS& v)
    00850         {
    00851                 return enumtostring("Message::CONSUMPTION_STATUS",MESSAGE_CONSUMPTION_STATUS_MAP,v);
    00852         }
    00853 }
    00854
    00855 extern const PMAP MESSAGE_SET_METADATA_KEY_MAP[] = {
    00856         {__EA(SET_META_NAME), Message::SET_META_NAME},
    00857         {__EA(SET_META_TOPIC), Message::SET_META_TOPIC},
    00858         {__EA(SET_META_GUIDELINES), Message::SET_META_GUIDELINES},
    00859         {__EA(SET_META_PICTURE), Message::SET_META_PICTURE},
    00860         {0, 0}
    00861 };
    00862
    00863 namespace Sid {
    00864         template<> Sid::String tostring(const Message::SET_METADATA_KEY& v)
    00865         {
    00866                 return enumtostring("Message::SET_METADATA_KEY",MESSAGE_SET_METADATA_KEY_MAP,v);
    00867         }
    00868 }
    00869
    00870 extern const PMAP MESSAGE_LEAVEREASON_MAP[] = {
    00871         {__EA(USER_INCAPABLE), Message::USER_INCAPABLE},
    00872         {__EA(ADDER_MUST_BE_FRIEND), Message::ADDER_MUST_BE_FRIEND},
    00873         {__EA(ADDER_MUST_BE_AUTHORIZED), Message::ADDER_MUST_BE_AUTHORIZED},
    00874         {__EA(DECLINE_ADD), Message::DECLINE_ADD},
    00875         {__EA(UNSUBSCRIBE), Message::UNSUBSCRIBE},
    00876         {0, 0}
    00877 };
    00878
    00879 namespace Sid {
    00880         template<> Sid::String tostring(const Message::LEAVEREASON& v)
    00881         {
    00882                 return enumtostring("Message::LEAVEREASON",MESSAGE_LEAVEREASON_MAP,v);
    00883         }
    00884 }
    00885
    00886 extern const EMAP MESSAGE_EMAP[] = {
    00887         {Message::P_TYPE, MESSAGE_TYPE_MAP},
    00888         {Message::P_SENDING_STATUS, MESSAGE_SENDING_STATUS_MAP},
    00889         {Message::P_CONSUMPTION_STATUS, MESSAGE_CONSUMPTION_STATUS_MAP},
    00890         {0, 0}
    00891 };
    00892 const EMAP* Message::getEMap() const
    00893 {
    00894         return MESSAGE_EMAP;
    00895 }
    00896 const PMAP* Message::getPMap() const
    00897 {
    00898         return MESSAGE_PROPERTY_MAP;
    00899 }
    00900
    00901
    00902 /** class Video **********************/
    00903
    00904 Video::Video(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    00905 Video::~Video() {  }
    00906 void Video::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgvideoVideo*>(cache);  }
    00907 unsigned int Video::moduleID() const
    00908 {
    00909         return MODULE_ID;
    00910 }
    00911 String Video::getNamespace() const
    00912 {
    00913         return __EA(VIDEO);
    00914 }
    00915
    00916 extern const PMAP VIDEO_PROPERTY_MAP[] = {
    00917         {__EA(STATUS), Video::P_STATUS},
    00918         {__EA(ERROR), Video::P_ERROR},
    00919         {__EA(DEBUGINFO), Video::P_DEBUGINFO},
    00920         {__EA(DIMENSIONS), Video::P_DIMENSIONS},
    00921         {__EA(MEDIA_TYPE), Video::P_MEDIA_TYPE},
    00922         {__EA(CONVO_ID), Video::P_CONVO_ID},
    00923         {__EA(DEVICE_PATH), Video::P_DEVICE_PATH},
    00924         {0, 0}
    00925 };
    00926
    00927 extern const PMAP VIDEO_STATUS_MAP[] = {
    00928         {__EA(NOT_AVAILABLE), Video::NOT_AVAILABLE},
    00929         {__EA(AVAILABLE), Video::AVAILABLE},
    00930         {__EA(STARTING), Video::STARTING},
    00931         {__EA(REJECTED), Video::REJECTED},
    00932         {__EA(RUNNING), Video::RUNNING},
    00933         {__EA(STOPPING), Video::STOPPING},
    00934         {__EA(PAUSED), Video::PAUSED},
    00935         {__EA(NOT_STARTED), Video::NOT_STARTED},
    00936         {__EA(HINT_IS_VIDEOCALL_RECEIVED), Video::HINT_IS_VIDEOCALL_RECEIVED},
    00937         {__EA(UNKNOWN), Video::UNKNOWN},
    00938         {__EA(RENDERING), Video::RENDERING},
    00939         {__EA(CHECKING_SUBSCRIPTION), Video::CHECKING_SUBSCRIPTION},
    00940         {__EA(SWITCHING_DEVICE), Video::SWITCHING_DEVICE},
    00941         {0, 0}
    00942 };
    00943
    00944 namespace Sid {
    00945         template<> Sid::String tostring(const Video::STATUS& v)
    00946         {
    00947                 return enumtostring("Video::STATUS",VIDEO_STATUS_MAP,v);
    00948         }
    00949 }
    00950
    00951 extern const PMAP VIDEO_MEDIATYPE_MAP[] = {
    00952         {__EA(MEDIA_SCREENSHARING), Video::MEDIA_SCREENSHARING},
    00953         {__EA(MEDIA_VIDEO), Video::MEDIA_VIDEO},
    00954         {0, 0}
    00955 };
    00956
    00957 namespace Sid {
    00958         template<> Sid::String tostring(const Video::MEDIATYPE& v)
    00959         {
    00960                 return enumtostring("Video::MEDIATYPE",VIDEO_MEDIATYPE_MAP,v);
    00961         }
    00962 }
    00963
    00964 extern const PMAP VIDEO_VIDEO_DEVICE_CAPABILITY_MAP[] = {
    00965         {__EA(VIDEOCAP_HQ_CAPABLE), Video::VIDEOCAP_HQ_CAPABLE},
    00966         {__EA(VIDEOCAP_HQ_CERTIFIED), Video::VIDEOCAP_HQ_CERTIFIED},
    00967         {__EA(VIDEOCAP_REQ_DRIVERUPDATE), Video::VIDEOCAP_REQ_DRIVERUPDATE},
    00968         {__EA(VIDEOCAP_USB_HIGHSPEED), Video::VIDEOCAP_USB_HIGHSPEED},
    00969         {0, 0}
    00970 };
    00971
    00972 namespace Sid {
    00973         template<> Sid::String tostring(const Video::VIDEO_DEVICE_CAPABILITY& v)
    00974         {
    00975                 return enumtostring("Video::VIDEO_DEVICE_CAPABILITY",VIDEO_VIDEO_DEVICE_CAPABILITY_MAP,v);
    00976         }
    00977 }
    00978
    00979 void Video::OnCaptureRequestCompleted(
    00980         __se_unused const uint& /*requestId*/,
    00981         __se_unused const bool& /*isSuccessful*/,
    00982         __se_unused const Sid::Binary& /*image*/,
    00983         __se_unused const int& /*width*/,
    00984         __se_unused const int& /*height*/
    00985 ) {}
    00986
    00987 extern const EMAP VIDEO_EMAP[] = {
    00988         {Video::P_STATUS, VIDEO_STATUS_MAP},
    00989         {Video::P_MEDIA_TYPE, VIDEO_MEDIATYPE_MAP},
    00990         {0, 0}
    00991 };
    00992 const EMAP* Video::getEMap() const
    00993 {
    00994         return VIDEO_EMAP;
    00995 }
    00996 const PMAP* Video::getPMap() const
    00997 {
    00998         return VIDEO_PROPERTY_MAP;
    00999 }
    01000
    01001
    01002 /** class Voicemail **********************/
    01003
    01004 Voicemail::Voicemail(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    01005 Voicemail::~Voicemail() {  }
    01006 void Voicemail::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgvmVoicemail*>(cache);  }
    01007 unsigned int Voicemail::moduleID() const
    01008 {
    01009         return MODULE_ID;
    01010 }
    01011 String Voicemail::getNamespace() const
    01012 {
    01013         return __EA(VOICEMAIL);
    01014 }
    01015
    01016 extern const PMAP VOICEMAIL_PROPERTY_MAP[] = {
    01017         {__EA(TYPE), Voicemail::P_TYPE},
    01018         {__EA(PARTNER_HANDLE), Voicemail::P_PARTNER_HANDLE},
    01019         {__EA(PARTNER_DISPNAME), Voicemail::P_PARTNER_DISPNAME},
    01020         {__EA(STATUS), Voicemail::P_STATUS},
    01021         {__EA(FAILUREREASON), Voicemail::P_FAILUREREASON},
    01022         {__EA(SUBJECT), Voicemail::P_SUBJECT},
    01023         {__EA(TIMESTAMP), Voicemail::P_TIMESTAMP},
    01024         {__EA(DURATION), Voicemail::P_DURATION},
    01025         {__EA(ALLOWED_DURATION), Voicemail::P_ALLOWED_DURATION},
    01026         {__EA(PLAYBACK_PROGRESS), Voicemail::P_PLAYBACK_PROGRESS},
    01027         {__EA(CONVO_ID), Voicemail::P_CONVO_ID},
    01028         {__EA(CHATMSG_GUID), Voicemail::P_CHATMSG_GUID},
    01029         {0, 0}
    01030 };
    01031
    01032 extern const PMAP VOICEMAIL_TYPE_MAP[] = {
    01033         {__EA(INCOMING), Voicemail::INCOMING},
    01034         {__EA(DEFAULT_GREETING), Voicemail::DEFAULT_GREETING},
    01035         {__EA(CUSTOM_GREETING), Voicemail::CUSTOM_GREETING},
    01036         {__EA(OUTGOING), Voicemail::OUTGOING},
    01037         {0, 0}
    01038 };
    01039
    01040 namespace Sid {
    01041         template<> Sid::String tostring(const Voicemail::TYPE& v)
    01042         {
    01043                 return enumtostring("Voicemail::TYPE",VOICEMAIL_TYPE_MAP,v);
    01044         }
    01045 }
    01046
    01047 extern const PMAP VOICEMAIL_STATUS_MAP[] = {
    01048         {__EA(NOTDOWNLOADED), Voicemail::NOTDOWNLOADED},
    01049         {__EA(DOWNLOADING), Voicemail::DOWNLOADING},
    01050         {__EA(UNPLAYED), Voicemail::UNPLAYED},
    01051         {__EA(BUFFERING), Voicemail::BUFFERING},
    01052         {__EA(PLAYING), Voicemail::PLAYING},
    01053         {__EA(PLAYED), Voicemail::PLAYED},
    01054         {__EA(BLANK), Voicemail::BLANK},
    01055         {__EA(RECORDING), Voicemail::RECORDING},
    01056         {__EA(RECORDED), Voicemail::RECORDED},
    01057         {__EA(UPLOADING), Voicemail::UPLOADING},
    01058         {__EA(UPLOADED), Voicemail::UPLOADED},
    01059         {__EA(DELETING), Voicemail::DELETING},
    01060         {__EA(FAILED), Voicemail::FAILED},
    01061         {__EA(DELETING_FAILED), Voicemail::DELETING_FAILED},
    01062         {__EA(CHECKING), Voicemail::CHECKING},
    01063         {__EA(CANCELLED), Voicemail::CANCELLED},
    01064         {0, 0}
    01065 };
    01066
    01067 namespace Sid {
    01068         template<> Sid::String tostring(const Voicemail::STATUS& v)
    01069         {
    01070                 return enumtostring("Voicemail::STATUS",VOICEMAIL_STATUS_MAP,v);
    01071         }
    01072 }
    01073
    01074 extern const PMAP VOICEMAIL_FAILUREREASON_MAP[] = {
    01075         {__EA(MISC_ERROR), Voicemail::MISC_ERROR},
    01076         {__EA(CONNECT_ERROR), Voicemail::CONNECT_ERROR},
    01077         {__EA(NO_VOICEMAIL_CAPABILITY), Voicemail::NO_VOICEMAIL_CAPABILITY},
    01078         {__EA(NO_SUCH_VOICEMAIL), Voicemail::NO_SUCH_VOICEMAIL},
    01079         {__EA(FILE_READ_ERROR), Voicemail::FILE_READ_ERROR},
    01080         {__EA(FILE_WRITE_ERROR), Voicemail::FILE_WRITE_ERROR},
    01081         {__EA(RECORDING_ERROR), Voicemail::RECORDING_ERROR},
    01082         {__EA(PLAYBACK_ERROR), Voicemail::PLAYBACK_ERROR},
    01083         {__EA(NO_PERMISSION), Voicemail::NO_PERMISSION},
    01084         {__EA(RECEIVER_DISABLED_VOICEMAIL), Voicemail::RECEIVER_DISABLED_VOICEMAIL},
    01085         {__EA(SENDER_NOT_AUTHORIZED), Voicemail::SENDER_NOT_AUTHORIZED},
    01086         {__EA(SENDER_BLOCKED), Voicemail::SENDER_BLOCKED},
    01087         {0, 0}
    01088 };
    01089
    01090 namespace Sid {
    01091         template<> Sid::String tostring(const Voicemail::FAILUREREASON& v)
    01092         {
    01093                 return enumtostring("Voicemail::FAILUREREASON",VOICEMAIL_FAILUREREASON_MAP,v);
    01094         }
    01095 }
    01096
    01097 extern const EMAP VOICEMAIL_EMAP[] = {
    01098         {Voicemail::P_TYPE, VOICEMAIL_TYPE_MAP},
    01099         {Voicemail::P_STATUS, VOICEMAIL_STATUS_MAP},
    01100         {Voicemail::P_FAILUREREASON, VOICEMAIL_FAILUREREASON_MAP},
    01101         {0, 0}
    01102 };
    01103 const EMAP* Voicemail::getEMap() const
    01104 {
    01105         return VOICEMAIL_EMAP;
    01106 }
    01107 const PMAP* Voicemail::getPMap() const
    01108 {
    01109         return VOICEMAIL_PROPERTY_MAP;
    01110 }
    01111
    01112
    01113 /** class Sms **********************/
    01114
    01115 Sms::Sms(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    01116 Sms::~Sms() {  }
    01117 void Sms::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgsmsSms*>(cache);  }
    01118 unsigned int Sms::moduleID() const
    01119 {
    01120         return MODULE_ID;
    01121 }
    01122 String Sms::getNamespace() const
    01123 {
    01124         return __EA(SMS);
    01125 }
    01126
    01127 extern const PMAP SMS_PROPERTY_MAP[] = {
    01128         {__EA(TYPE), Sms::P_TYPE},
    01129         {__EA(STATUS), Sms::P_STATUS},
    01130         {__EA(FAILUREREASON), Sms::P_FAILUREREASON},
    01131         {__EA(IS_FAILED_UNSEEN), Sms::P_IS_FAILED_UNSEEN},
    01132         {__EA(TIMESTAMP), Sms::P_TIMESTAMP},
    01133         {__EA(PRICE), Sms::P_PRICE},
    01134         {__EA(PRICE_PRECISION), Sms::P_PRICE_PRECISION},
    01135         {__EA(PRICE_CURRENCY), Sms::P_PRICE_CURRENCY},
    01136         {__EA(REPLY_TO_NUMBER), Sms::P_REPLY_TO_NUMBER},
    01137         {__EA(TARGET_NUMBERS), Sms::P_TARGET_NUMBERS},
    01138         {__EA(TARGET_STATUSES), Sms::P_TARGET_STATUSES},
    01139         {__EA(BODY), Sms::P_BODY},
    01140         {__EA(CHATMSG_ID), Sms::P_CHATMSG_ID},
    01141         {0, 0}
    01142 };
    01143
    01144 extern const PMAP SMS_TYPE_MAP[] = {
    01145         {__EA(OUTGOING), Sms::OUTGOING},
    01146         {__EA(CONFIRMATION_CODE_REQUEST), Sms::CONFIRMATION_CODE_REQUEST},
    01147         {__EA(CONFIRMATION_CODE_SUBMIT), Sms::CONFIRMATION_CODE_SUBMIT},
    01148         {0, 0}
    01149 };
    01150
    01151 namespace Sid {
    01152         template<> Sid::String tostring(const Sms::TYPE& v)
    01153         {
    01154                 return enumtostring("Sms::TYPE",SMS_TYPE_MAP,v);
    01155         }
    01156 }
    01157
    01158 extern const PMAP SMS_STATUS_MAP[] = {
    01159         {__EA(COMPOSING), Sms::COMPOSING},
    01160         {__EA(SENDING_TO_SERVER), Sms::SENDING_TO_SERVER},
    01161         {__EA(SENT_TO_SERVER), Sms::SENT_TO_SERVER},
    01162         {__EA(DELIVERED), Sms::DELIVERED},
    01163         {__EA(SOME_TARGETS_FAILED), Sms::SOME_TARGETS_FAILED},
    01164         {__EA(FAILED), Sms::FAILED},
    01165         {0, 0}
    01166 };
    01167
    01168 namespace Sid {
    01169         template<> Sid::String tostring(const Sms::STATUS& v)
    01170         {
    01171                 return enumtostring("Sms::STATUS",SMS_STATUS_MAP,v);
    01172         }
    01173 }
    01174
    01175 extern const PMAP SMS_FAILUREREASON_MAP[] = {
    01176         {__EA(MISC_ERROR), Sms::MISC_ERROR},
    01177         {__EA(SERVER_CONNECT_FAILED), Sms::SERVER_CONNECT_FAILED},
    01178         {__EA(NO_SMS_CAPABILITY), Sms::NO_SMS_CAPABILITY},
    01179         {__EA(INSUFFICIENT_FUNDS), Sms::INSUFFICIENT_FUNDS},
    01180         {__EA(INVALID_CONFIRMATION_CODE), Sms::INVALID_CONFIRMATION_CODE},
    01181         {__EA(USER_BLOCKED), Sms::USER_BLOCKED},
    01182         {__EA(IP_BLOCKED), Sms::IP_BLOCKED},
    01183         {__EA(NODE_BLOCKED), Sms::NODE_BLOCKED},
    01184         {__EA(NO_SENDERID_CAPABILITY), Sms::NO_SENDERID_CAPABILITY},
    01185         {0, 0}
    01186 };
    01187
    01188 namespace Sid {
    01189         template<> Sid::String tostring(const Sms::FAILUREREASON& v)
    01190         {
    01191                 return enumtostring("Sms::FAILUREREASON",SMS_FAILUREREASON_MAP,v);
    01192         }
    01193 }
    01194
    01195 extern const PMAP SMS_TARGETSTATUS_MAP[] = {
    01196         {__EA(TARGET_ANALYZING), Sms::TARGET_ANALYZING},
    01197         {__EA(TARGET_UNDEFINED), Sms::TARGET_UNDEFINED},
    01198         {__EA(TARGET_ACCEPTABLE), Sms::TARGET_ACCEPTABLE},
    01199         {__EA(TARGET_NOT_ROUTABLE), Sms::TARGET_NOT_ROUTABLE},
    01200         {__EA(TARGET_DELIVERY_PENDING), Sms::TARGET_DELIVERY_PENDING},
    01201         {__EA(TARGET_DELIVERY_SUCCESSFUL), Sms::TARGET_DELIVERY_SUCCESSFUL},
    01202         {__EA(TARGET_DELIVERY_FAILED), Sms::TARGET_DELIVERY_FAILED},
    01203         {0, 0}
    01204 };
    01205
    01206 namespace Sid {
    01207         template<> Sid::String tostring(const Sms::TARGETSTATUS& v)
    01208         {
    01209                 return enumtostring("Sms::TARGETSTATUS",SMS_TARGETSTATUS_MAP,v);
    01210         }
    01211 }
    01212
    01213 extern const PMAP SMS_SETBODYRESULT_MAP[] = {
    01214         {__EA(BODY_INVALID), Sms::BODY_INVALID},
    01215         {__EA(BODY_TRUNCATED), Sms::BODY_TRUNCATED},
    01216         {__EA(BODY_OK), Sms::BODY_OK},
    01217         {__EA(BODY_LASTCHAR_IGNORED), Sms::BODY_LASTCHAR_IGNORED},
    01218         {0, 0}
    01219 };
    01220
    01221 namespace Sid {
    01222         template<> Sid::String tostring(const Sms::SETBODYRESULT& v)
    01223         {
    01224                 return enumtostring("Sms::SETBODYRESULT",SMS_SETBODYRESULT_MAP,v);
    01225         }
    01226 }
    01227
    01228 extern const PMAP SMS_CONFIRM_TYPE_MAP[] = {
    01229         {__EA(ID_SMS), Sms::ID_SMS},
    01230         {__EA(ID_MOBILE), Sms::ID_MOBILE},
    01231         {__EA(ID_SKYPEIN), Sms::ID_SKYPEIN},
    01232         {0, 0}
    01233 };
    01234
    01235 namespace Sid {
    01236         template<> Sid::String tostring(const Sms::CONFIRM_TYPE& v)
    01237         {
    01238                 return enumtostring("Sms::CONFIRM_TYPE",SMS_CONFIRM_TYPE_MAP,v);
    01239         }
    01240 }
    01241
    01242 extern const EMAP SMS_EMAP[] = {
    01243         {Sms::P_TYPE, SMS_TYPE_MAP},
    01244         {Sms::P_STATUS, SMS_STATUS_MAP},
    01245         {Sms::P_FAILUREREASON, SMS_FAILUREREASON_MAP},
    01246         {0, 0}
    01247 };
    01248 const EMAP* Sms::getEMap() const
    01249 {
    01250         return SMS_EMAP;
    01251 }
    01252 const PMAP* Sms::getPMap() const
    01253 {
    01254         return SMS_PROPERTY_MAP;
    01255 }
    01256
    01257
    01258 /** class Transfer **********************/
    01259
    01260 Transfer::Transfer(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    01261 Transfer::~Transfer() {  }
    01262 void Transfer::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgftTransfer*>(cache);  }
    01263 unsigned int Transfer::moduleID() const
    01264 {
    01265         return MODULE_ID;
    01266 }
    01267 String Transfer::getNamespace() const
    01268 {
    01269         return __EA(TRANSFER);
    01270 }
    01271
    01272 extern const PMAP TRANSFER_PROPERTY_MAP[] = {
    01273         {__EA(TYPE), Transfer::P_TYPE},
    01274         {__EA(PARTNER_HANDLE), Transfer::P_PARTNER_HANDLE},
    01275         {__EA(PARTNER_DISPNAME), Transfer::P_PARTNER_DISPNAME},
    01276         {__EA(STATUS), Transfer::P_STATUS},
    01277         {__EA(FAILUREREASON), Transfer::P_FAILUREREASON},
    01278         {__EA(STARTTIME), Transfer::P_STARTTIME},
    01279         {__EA(FINISHTIME), Transfer::P_FINISHTIME},
    01280         {__EA(FILEPATH), Transfer::P_FILEPATH},
    01281         {__EA(FILENAME), Transfer::P_FILENAME},
    01282         {__EA(FILESIZE), Transfer::P_FILESIZE},
    01283         {__EA(BYTESTRANSFERRED), Transfer::P_BYTESTRANSFERRED},
    01284         {__EA(BYTESPERSECOND), Transfer::P_BYTESPERSECOND},
    01285         {__EA(CHATMSG_GUID), Transfer::P_CHATMSG_GUID},
    01286         {__EA(CHATMSG_INDEX), Transfer::P_CHATMSG_INDEX},
    01287         {__EA(CONVO_ID), Transfer::P_CONVO_ID},
    01288         {0, 0}
    01289 };
    01290
    01291 extern const PMAP TRANSFER_TYPE_MAP[] = {
    01292         {__EA(INCOMING), Transfer::INCOMING},
    01293         {__EA(OUTGOING), Transfer::OUTGOING},
    01294         {0, 0}
    01295 };
    01296
    01297 namespace Sid {
    01298         template<> Sid::String tostring(const Transfer::TYPE& v)
    01299         {
    01300                 return enumtostring("Transfer::TYPE",TRANSFER_TYPE_MAP,v);
    01301         }
    01302 }
    01303
    01304 extern const PMAP TRANSFER_STATUS_MAP[] = {
    01305         {__EA(NEW), Transfer::NEW},
    01306         {__EA(CONNECTING), Transfer::CONNECTING},
    01307         {__EA(WAITING_FOR_ACCEPT), Transfer::WAITING_FOR_ACCEPT},
    01308         {__EA(TRANSFERRING), Transfer::TRANSFERRING},
    01309         {__EA(TRANSFERRING_OVER_RELAY), Transfer::TRANSFERRING_OVER_RELAY},
    01310         {__EA(PAUSED), Transfer::PAUSED},
    01311         {__EA(REMOTELY_PAUSED), Transfer::REMOTELY_PAUSED},
    01312         {__EA(CANCELLED), Transfer::CANCELLED},
    01313         {__EA(COMPLETED), Transfer::COMPLETED},
    01314         {__EA(FAILED), Transfer::FAILED},
    01315         {__EA(PLACEHOLDER), Transfer::PLACEHOLDER},
    01316         {__EA(OFFER_FROM_OTHER_INSTANCE), Transfer::OFFER_FROM_OTHER_INSTANCE},
    01317         {__EA(CANCELLED_BY_REMOTE), Transfer::CANCELLED_BY_REMOTE},
    01318         {0, 0}
    01319 };
    01320
    01321 namespace Sid {
    01322         template<> Sid::String tostring(const Transfer::STATUS& v)
    01323         {
    01324                 return enumtostring("Transfer::STATUS",TRANSFER_STATUS_MAP,v);
    01325         }
    01326 }
    01327
    01328 extern const PMAP TRANSFER_FAILUREREASON_MAP[] = {
    01329         {__EA(SENDER_NOT_AUTHORISED), Transfer::SENDER_NOT_AUTHORISED},
    01330         {__EA(REMOTELY_CANCELLED), Transfer::REMOTELY_CANCELLED},
    01331         {__EA(FAILED_READ), Transfer::FAILED_READ},
    01332         {__EA(FAILED_REMOTE_READ), Transfer::FAILED_REMOTE_READ},
    01333         {__EA(FAILED_WRITE), Transfer::FAILED_WRITE},
    01334         {__EA(FAILED_REMOTE_WRITE), Transfer::FAILED_REMOTE_WRITE},
    01335         {__EA(REMOTE_DOES_NOT_SUPPORT_FT), Transfer::REMOTE_DOES_NOT_SUPPORT_FT},
    01336         {__EA(REMOTE_OFFLINE_FOR_TOO_LONG), Transfer::REMOTE_OFFLINE_FOR_TOO_LONG},
    01337         {__EA(TOO_MANY_PARALLEL), Transfer::TOO_MANY_PARALLEL},
    01338         {__EA(PLACEHOLDER_TIMEOUT), Transfer::PLACEHOLDER_TIMEOUT},
    01339         {0, 0}
    01340 };
    01341
    01342 namespace Sid {
    01343         template<> Sid::String tostring(const Transfer::FAILUREREASON& v)
    01344         {
    01345                 return enumtostring("Transfer::FAILUREREASON",TRANSFER_FAILUREREASON_MAP,v);
    01346         }
    01347 }
    01348
    01349 extern const EMAP TRANSFER_EMAP[] = {
    01350         {Transfer::P_TYPE, TRANSFER_TYPE_MAP},
    01351         {Transfer::P_STATUS, TRANSFER_STATUS_MAP},
    01352         {Transfer::P_FAILUREREASON, TRANSFER_FAILUREREASON_MAP},
    01353         {0, 0}
    01354 };
    01355 const EMAP* Transfer::getEMap() const
    01356 {
    01357         return TRANSFER_EMAP;
    01358 }
    01359 const PMAP* Transfer::getPMap() const
    01360 {
    01361         return TRANSFER_PROPERTY_MAP;
    01362 }
    01363
    01364
    01365 /** class Account **********************/
    01366
    01367 Account::Account(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {}
    01368 Account::~Account() {  }
    01369 void Account::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgaccountAccount*>(cache);  }
    01370 unsigned int Account::moduleID() const
    01371 {
    01372         return MODULE_ID;
    01373 }
    01374 String Account::getNamespace() const
    01375 {
    01376         return __EA(ACCOUNT);
    01377 }
    01378
    01379 extern const PMAP ACCOUNT_PROPERTY_MAP[] = {
    01380         {__EA(STATUS), Account::P_STATUS},
    01381         {__EA(PWDCHANGESTATUS), Account::P_PWDCHANGESTATUS},
    01382         {__EA(LOGOUTREASON), Account::P_LOGOUTREASON},
    01383         {__EA(COMMITSTATUS), Account::P_COMMITSTATUS},
    01384         {__EA(SUGGESTED_SKYPENAME), Account::P_SUGGESTED_SKYPENAME},
    01385         {__EA(SKYPEOUT_BALANCE_CURRENCY), Account::P_SKYPEOUT_BALANCE_CURRENCY},
    01386         {__EA(SKYPEOUT_BALANCE), Account::P_SKYPEOUT_BALANCE},
    01387         {__EA(SKYPEOUT_PRECISION), Account::P_SKYPEOUT_PRECISION},
    01388         {__EA(SKYPEIN_NUMBERS), Account::P_SKYPEIN_NUMBERS},
    01389         {__EA(CBLSYNCSTATUS), Account::P_CBLSYNCSTATUS},
    01390         {__EA(OFFLINE_CALLFORWARD), Account::P_OFFLINE_CALLFORWARD},
    01391         {__EA(CHAT_POLICY), Account::P_CHAT_POLICY},
    01392         {__EA(SKYPE_CALL_POLICY), Account::P_SKYPE_CALL_POLICY},
    01393         {__EA(PSTN_CALL_POLICY), Account::P_PSTN_CALL_POLICY},
    01394         {__EA(AVATAR_POLICY), Account::P_AVATAR_POLICY},
    01395         {__EA(BUDDYCOUNT_POLICY), Account::P_BUDDYCOUNT_POLICY},
    01396         {__EA(TIMEZONE_POLICY), Account::P_TIMEZONE_POLICY},
    01397         {__EA(WEBPRESENCE_POLICY), Account::P_WEBPRESENCE_POLICY},
    01398         {__EA(PHONENUMBERS_POLICY), Account::P_PHONENUMBERS_POLICY},
    01399         {__EA(VOICEMAIL_POLICY), Account::P_VOICEMAIL_POLICY},
    01400         {__EA(PARTNER_OPTEDOUT), Account::P_PARTNER_OPTEDOUT},
    01401         {__EA(SERVICE_PROVIDER_INFO), Account::P_SERVICE_PROVIDER_INFO},
    01402         {__EA(REGISTRATION_TIMESTAMP), Account::P_REGISTRATION_TIMESTAMP},
    01403         {__EA(NR_OF_OTHER_INSTANCES), Account::P_NR_OF_OTHER_INSTANCES},
    01404         {__EA(SKYPENAME), Account::P_SKYPENAME},
    01405         {__EA(FULLNAME), Account::P_FULLNAME},
    01406         {__EA(BIRTHDAY), Account::P_BIRTHDAY},
    01407         {__EA(GENDER), Account::P_GENDER},
    01408         {__EA(LANGUAGES), Account::P_LANGUAGES},
    01409         {__EA(COUNTRY), Account::P_COUNTRY},
    01410         {__EA(PROVINCE), Account::P_PROVINCE},
    01411         {__EA(CITY), Account::P_CITY},
    01412         {__EA(PHONE_HOME), Account::P_PHONE_HOME},
    01413         {__EA(PHONE_OFFICE), Account::P_PHONE_OFFICE},
    01414         {__EA(PHONE_MOBILE), Account::P_PHONE_MOBILE},
    01415         {__EA(EMAILS), Account::P_EMAILS},
    01416         {__EA(HOMEPAGE), Account::P_HOMEPAGE},
    01417         {__EA(ABOUT), Account::P_ABOUT},
    01418         {__EA(PROFILE_TIMESTAMP), Account::P_PROFILE_TIMESTAMP},
    01419         {__EA(MOOD_TEXT), Account::P_MOOD_TEXT},
    01420         {__EA(TIMEZONE), Account::P_TIMEZONE},
    01421         {__EA(NROF_AUTHED_BUDDIES), Account::P_NROF_AUTHED_BUDDIES},
    01422         {__EA(AVAILABILITY), Account::P_AVAILABILITY},
    01423         {__EA(AVATAR_IMAGE), Account::P_AVATAR_IMAGE},
    01424         {__EA(AVATAR_TIMESTAMP), Account::P_AVATAR_TIMESTAMP},
    01425         {__EA(MOOD_TIMESTAMP), Account::P_MOOD_TIMESTAMP},
    01426         {__EA(RICH_MOOD_TEXT), Account::P_RICH_MOOD_TEXT},
    01427         {0, 0}
    01428 };
    01429
    01430 extern const PMAP ACCOUNT_STATUS_MAP[] = {
    01431         {__EA(LOGGED_OUT), Account::LOGGED_OUT},
    01432         {__EA(LOGGED_OUT_AND_PWD_SAVED), Account::LOGGED_OUT_AND_PWD_SAVED},
    01433         {__EA(CONNECTING_TO_P2P), Account::CONNECTING_TO_P2P},
    01434         {__EA(CONNECTING_TO_SERVER), Account::CONNECTING_TO_SERVER},
    01435         {__EA(LOGGING_IN), Account::LOGGING_IN},
    01436         {__EA(INITIALIZING), Account::INITIALIZING},
    01437         {__EA(LOGGED_IN), Account::LOGGED_IN},
    01438         {__EA(LOGGING_OUT), Account::LOGGING_OUT},
    01439         {0, 0}
    01440 };
    01441
    01442 namespace Sid {
    01443         template<> Sid::String tostring(const Account::STATUS& v)
    01444         {
    01445                 return enumtostring("Account::STATUS",ACCOUNT_STATUS_MAP,v);
    01446         }
    01447 }
    01448
    01449 extern const PMAP ACCOUNT_CBLSYNCSTATUS_MAP[] = {
    01450         {__EA(CBL_INITIALIZING), Account::CBL_INITIALIZING},
    01451         {__EA(CBL_INITIAL_SYNC_PENDING), Account::CBL_INITIAL_SYNC_PENDING},
    01452         {__EA(CBL_SYNC_PENDING), Account::CBL_SYNC_PENDING},
    01453         {__EA(CBL_SYNC_IN_PROGRESS), Account::CBL_SYNC_IN_PROGRESS},
    01454         {__EA(CBL_IN_SYNC), Account::CBL_IN_SYNC},
    01455         {__EA(CBL_SYNC_FAILED), Account::CBL_SYNC_FAILED},
    01456         {__EA(CBL_REMOTE_SYNC_PENDING), Account::CBL_REMOTE_SYNC_PENDING},
    01457         {0, 0}
    01458 };
    01459
    01460 namespace Sid {
    01461         template<> Sid::String tostring(const Account::CBLSYNCSTATUS& v)
    01462         {
    01463                 return enumtostring("Account::CBLSYNCSTATUS",ACCOUNT_CBLSYNCSTATUS_MAP,v);
    01464         }
    01465 }
    01466
    01467 extern const PMAP ACCOUNT_LOGOUTREASON_MAP[] = {
    01468         {__EA(LOGOUT_CALLED), Account::LOGOUT_CALLED},
    01469         {__EA(HTTPS_PROXY_AUTH_FAILED), Account::HTTPS_PROXY_AUTH_FAILED},
    01470         {__EA(SOCKS_PROXY_AUTH_FAILED), Account::SOCKS_PROXY_AUTH_FAILED},
    01471         {__EA(P2P_CONNECT_FAILED), Account::P2P_CONNECT_FAILED},
    01472         {__EA(SERVER_CONNECT_FAILED), Account::SERVER_CONNECT_FAILED},
    01473         {__EA(SERVER_OVERLOADED), Account::SERVER_OVERLOADED},
    01474         {__EA(DB_IN_USE), Account::DB_IN_USE},
    01475         {__EA(INVALID_SKYPENAME), Account::INVALID_SKYPENAME},
    01476         {__EA(INVALID_EMAIL), Account::INVALID_EMAIL},
    01477         {__EA(UNACCEPTABLE_PASSWORD), Account::UNACCEPTABLE_PASSWORD},
    01478         {__EA(SKYPENAME_TAKEN), Account::SKYPENAME_TAKEN},
    01479         {__EA(REJECTED_AS_UNDERAGE), Account::REJECTED_AS_UNDERAGE},
    01480         {__EA(NO_SUCH_IDENTITY), Account::NO_SUCH_IDENTITY},
    01481         {__EA(INCORRECT_PASSWORD), Account::INCORRECT_PASSWORD},
    01482         {__EA(TOO_MANY_LOGIN_ATTEMPTS), Account::TOO_MANY_LOGIN_ATTEMPTS},
    01483         {__EA(PASSWORD_HAS_CHANGED), Account::PASSWORD_HAS_CHANGED},
    01484         {__EA(PERIODIC_UIC_UPDATE_FAILED), Account::PERIODIC_UIC_UPDATE_FAILED},
    01485         {__EA(DB_DISK_FULL), Account::DB_DISK_FULL},
    01486         {__EA(DB_IO_ERROR), Account::DB_IO_ERROR},
    01487         {__EA(DB_CORRUPT), Account::DB_CORRUPT},
    01488         {__EA(DB_FAILURE), Account::DB_FAILURE},
    01489         {__EA(INVALID_APP_ID), Account::INVALID_APP_ID},
    01490         {__EA(APP_ID_FAILURE), Account::APP_ID_FAILURE},
    01491         {__EA(UNSUPPORTED_VERSION), Account::UNSUPPORTED_VERSION},
    01492         {0, 0}
    01493 };
    01494
    01495 namespace Sid {
    01496         template<> Sid::String tostring(const Account::LOGOUTREASON& v)
    01497         {
    01498                 return enumtostring("Account::LOGOUTREASON",ACCOUNT_LOGOUTREASON_MAP,v);
    01499         }
    01500 }
    01501
    01502 extern const PMAP ACCOUNT_PWDCHANGESTATUS_MAP[] = {
    01503         {__EA(PWD_OK), Account::PWD_OK},
    01504         {__EA(PWD_CHANGING), Account::PWD_CHANGING},
    01505         {__EA(PWD_INVALID_OLD_PASSWORD), Account::PWD_INVALID_OLD_PASSWORD},
    01506         {__EA(PWD_SERVER_CONNECT_FAILED), Account::PWD_SERVER_CONNECT_FAILED},
    01507         {__EA(PWD_OK_BUT_CHANGE_SUGGESTED), Account::PWD_OK_BUT_CHANGE_SUGGESTED},
    01508         {__EA(PWD_MUST_DIFFER_FROM_OLD), Account::PWD_MUST_DIFFER_FROM_OLD},
    01509         {__EA(PWD_INVALID_NEW_PWD), Account::PWD_INVALID_NEW_PWD},
    01510         {__EA(PWD_MUST_LOG_IN_TO_CHANGE), Account::PWD_MUST_LOG_IN_TO_CHANGE},
    01511         {0, 0}
    01512 };
    01513
    01514 namespace Sid {
    01515         template<> Sid::String tostring(const Account::PWDCHANGESTATUS& v)
    01516         {
    01517                 return enumtostring("Account::PWDCHANGESTATUS",ACCOUNT_PWDCHANGESTATUS_MAP,v);
    01518         }
    01519 }
    01520
    01521 extern const PMAP ACCOUNT_COMMITSTATUS_MAP[] = {
    01522         {__EA(COMMITTED), Account::COMMITTED},
    01523         {__EA(COMMITTING_TO_SERVER), Account::COMMITTING_TO_SERVER},
    01524         {__EA(COMMIT_FAILED), Account::COMMIT_FAILED},
    01525         {0, 0}
    01526 };
    01527
    01528 namespace Sid {
    01529         template<> Sid::String tostring(const Account::COMMITSTATUS& v)
    01530         {
    01531                 return enumtostring("Account::COMMITSTATUS",ACCOUNT_COMMITSTATUS_MAP,v);
    01532         }
    01533 }
    01534
    01535 extern const PMAP ACCOUNT_CHATPOLICY_MAP[] = {
    01536         {__EA(EVERYONE_CAN_ADD), Account::EVERYONE_CAN_ADD},
    01537         {__EA(BUDDIES_OR_AUTHORIZED_CAN_ADD), Account::BUDDIES_OR_AUTHORIZED_CAN_ADD},
    01538         {0, 0}
    01539 };
    01540
    01541 namespace Sid {
    01542         template<> Sid::String tostring(const Account::CHATPOLICY& v)
    01543         {
    01544                 return enumtostring("Account::CHATPOLICY",ACCOUNT_CHATPOLICY_MAP,v);
    01545         }
    01546 }
    01547
    01548 extern const PMAP ACCOUNT_SKYPECALLPOLICY_MAP[] = {
    01549         {__EA(EVERYONE_CAN_CALL), Account::EVERYONE_CAN_CALL},
    01550         {__EA(BUDDIES_OR_AUTHORIZED_CAN_CALL), Account::BUDDIES_OR_AUTHORIZED_CAN_CALL},
    01551         {0, 0}
    01552 };
    01553
    01554 namespace Sid {
    01555         template<> Sid::String tostring(const Account::SKYPECALLPOLICY& v)
    01556         {
    01557                 return enumtostring("Account::SKYPECALLPOLICY",ACCOUNT_SKYPECALLPOLICY_MAP,v);
    01558         }
    01559 }
    01560
    01561 extern const PMAP ACCOUNT_PSTNCALLPOLICY_MAP[] = {
    01562         {__EA(ALL_NUMBERS_CAN_CALL), Account::ALL_NUMBERS_CAN_CALL},
    01563         {__EA(DISCLOSED_NUMBERS_CAN_CALL), Account::DISCLOSED_NUMBERS_CAN_CALL},
    01564         {__EA(BUDDY_NUMBERS_CAN_CALL), Account::BUDDY_NUMBERS_CAN_CALL},
    01565         {0, 0}
    01566 };
    01567
    01568 namespace Sid {
    01569         template<> Sid::String tostring(const Account::PSTNCALLPOLICY& v)
    01570         {
    01571                 return enumtostring("Account::PSTNCALLPOLICY",ACCOUNT_PSTNCALLPOLICY_MAP,v);
    01572         }
    01573 }
    01574
    01575 extern const PMAP ACCOUNT_AVATARPOLICY_MAP[] = {
    01576         {__EA(BUDDIES_OR_AUTHORIZED_CAN_SEE), Account::BUDDIES_OR_AUTHORIZED_CAN_SEE},
    01577         {__EA(EVERYONE_CAN_SEE), Account::EVERYONE_CAN_SEE},
    01578         {0, 0}
    01579 };
    01580
    01581 namespace Sid {
    01582         template<> Sid::String tostring(const Account::AVATARPOLICY& v)
    01583         {
    01584                 return enumtostring("Account::AVATARPOLICY",ACCOUNT_AVATARPOLICY_MAP,v);
    01585         }
    01586 }
    01587
    01588 extern const PMAP ACCOUNT_BUDDYCOUNTPOLICY_MAP[] = {
    01589         {__EA(DISCLOSE_TO_AUTHORIZED), Account::DISCLOSE_TO_AUTHORIZED},
    01590         {__EA(DISCLOSE_TO_NOONE), Account::DISCLOSE_TO_NOONE},
    01591         {0, 0}
    01592 };
    01593
    01594 namespace Sid {
    01595         template<> Sid::String tostring(const Account::BUDDYCOUNTPOLICY& v)
    01596         {
    01597                 return enumtostring("Account::BUDDYCOUNTPOLICY",ACCOUNT_BUDDYCOUNTPOLICY_MAP,v);
    01598         }
    01599 }
    01600
    01601 extern const PMAP ACCOUNT_TIMEZONEPOLICY_MAP[] = {
    01602         {__EA(TZ_AUTOMATIC), Account::TZ_AUTOMATIC},
    01603         {__EA(TZ_MANUAL), Account::TZ_MANUAL},
    01604         {__EA(TZ_UNDISCLOSED), Account::TZ_UNDISCLOSED},
    01605         {0, 0}
    01606 };
    01607
    01608 namespace Sid {
    01609         template<> Sid::String tostring(const Account::TIMEZONEPOLICY& v)
    01610         {
    01611                 return enumtostring("Account::TIMEZONEPOLICY",ACCOUNT_TIMEZONEPOLICY_MAP,v);
    01612         }
    01613 }
    01614
    01615 extern const PMAP ACCOUNT_WEBPRESENCEPOLICY_MAP[] = {
    01616         {__EA(WEBPRESENCE_DISABLED), Account::WEBPRESENCE_DISABLED},
    01617         {__EA(WEBPRESENCE_ENABLED), Account::WEBPRESENCE_ENABLED},
    01618         {0, 0}
    01619 };
    01620
    01621 namespace Sid {
    01622         template<> Sid::String tostring(const Account::WEBPRESENCEPOLICY& v)
    01623         {
    01624                 return enumtostring("Account::WEBPRESENCEPOLICY",ACCOUNT_WEBPRESENCEPOLICY_MAP,v);
    01625         }
    01626 }
    01627
    01628 extern const PMAP ACCOUNT_PHONENUMBERSPOLICY_MAP[] = {
    01629         {__EA(PHONENUMBERS_VISIBLE_FOR_BUDDIES), Account::PHONENUMBERS_VISIBLE_FOR_BUDDIES},
    01630         {__EA(PHONENUMBERS_VISIBLE_FOR_EVERYONE), Account::PHONENUMBERS_VISIBLE_FOR_EVERYONE},
    01631         {0, 0}
    01632 };
    01633
    01634 namespace Sid {
    01635         template<> Sid::String tostring(const Account::PHONENUMBERSPOLICY& v)
    01636         {
    01637                 return enumtostring("Account::PHONENUMBERSPOLICY",ACCOUNT_PHONENUMBERSPOLICY_MAP,v);
    01638         }
    01639 }
    01640
    01641 extern const PMAP ACCOUNT_VOICEMAILPOLICY_MAP[] = {
    01642         {__EA(VOICEMAIL_ENABLED), Account::VOICEMAIL_ENABLED},
    01643         {__EA(VOICEMAIL_DISABLED), Account::VOICEMAIL_DISABLED},
    01644         {0, 0}
    01645 };
    01646
    01647 namespace Sid {
    01648         template<> Sid::String tostring(const Account::VOICEMAILPOLICY& v)
    01649         {
    01650                 return enumtostring("Account::VOICEMAILPOLICY",ACCOUNT_VOICEMAILPOLICY_MAP,v);
    01651         }
    01652 }
    01653
    01654 extern const PMAP ACCOUNT_CAPABILITYSTATUS_MAP[] = {
    01655         {__EA(NO_CAPABILITY), Account::NO_CAPABILITY},
    01656         {__EA(CAPABILITY_EXISTS), Account::CAPABILITY_EXISTS},
    01657         {__EA(FIRST_EXPIRY_WARNING), Account::FIRST_EXPIRY_WARNING},
    01658         {__EA(SECOND_EXPIRY_WARNING), Account::SECOND_EXPIRY_WARNING},
    01659         {__EA(FINAL_EXPIRY_WARNING), Account::FINAL_EXPIRY_WARNING},
    01660         {0, 0}
    01661 };
    01662
    01663 namespace Sid {
    01664         template<> Sid::String tostring(const Account::CAPABILITYSTATUS& v)
    01665         {
    01666                 return enumtostring("Account::CAPABILITYSTATUS",ACCOUNT_CAPABILITYSTATUS_MAP,v);
    01667         }
    01668 }
    01669
    01670 extern const EMAP ACCOUNT_EMAP[] = {
    01671         {Account::P_STATUS, ACCOUNT_STATUS_MAP},
    01672         {Account::P_PWDCHANGESTATUS, ACCOUNT_PWDCHANGESTATUS_MAP},
    01673         {Account::P_LOGOUTREASON, ACCOUNT_LOGOUTREASON_MAP},
    01674         {Account::P_COMMITSTATUS, ACCOUNT_COMMITSTATUS_MAP},
    01675         {Account::P_CBLSYNCSTATUS, ACCOUNT_CBLSYNCSTATUS_MAP},
    01676         {Account::P_CHAT_POLICY, ACCOUNT_CHATPOLICY_MAP},
    01677         {Account::P_SKYPE_CALL_POLICY, ACCOUNT_SKYPECALLPOLICY_MAP},
    01678         {Account::P_PSTN_CALL_POLICY, ACCOUNT_PSTNCALLPOLICY_MAP},
    01679         {Account::P_AVATAR_POLICY, ACCOUNT_AVATARPOLICY_MAP},
    01680         {Account::P_BUDDYCOUNT_POLICY, ACCOUNT_BUDDYCOUNTPOLICY_MAP},
    01681         {Account::P_TIMEZONE_POLICY, ACCOUNT_TIMEZONEPOLICY_MAP},
    01682         {Account::P_WEBPRESENCE_POLICY, ACCOUNT_WEBPRESENCEPOLICY_MAP},
    01683         {Account::P_PHONENUMBERS_POLICY, ACCOUNT_PHONENUMBERSPOLICY_MAP},
    01684         {Account::P_VOICEMAIL_POLICY, ACCOUNT_VOICEMAILPOLICY_MAP},
    01685         {Account::P_AVAILABILITY, CONTACT_AVAILABILITY_MAP},
    01686         {0, 0}
    01687 };
    01688 const EMAP* Account::getEMap() const
    01689 {
    01690         return ACCOUNT_EMAP;
    01691 }
    01692 const PMAP* Account::getPMap() const
    01693 {
    01694         return ACCOUNT_PROPERTY_MAP;
    01695 }
    01696
    01697 void Skype::OnNewCustomContactGroup(
    01698         __se_unused const ContactGroupRef& /*group*/
    01699 ) {}
    01700
    01701 extern const PMAP SKYPE_IDENTITYTYPE_MAP[] = {
    01702         {__EA(UNRECOGNIZED), Skype::UNRECOGNIZED},
    01703         {__EA(SKYPE), Skype::SKYPE},
    01704         {__EA(SKYPE_MYSELF), Skype::SKYPE_MYSELF},
    01705         {__EA(SKYPE_UNDISCLOSED), Skype::SKYPE_UNDISCLOSED},
    01706         {__EA(PSTN), Skype::PSTN},
    01707         {__EA(PSTN_EMERGENCY), Skype::PSTN_EMERGENCY},
    01708         {__EA(PSTN_FREE), Skype::PSTN_FREE},
    01709         {__EA(PSTN_UNDISCLOSED), Skype::PSTN_UNDISCLOSED},
    01710         {__EA(CONFERENCE), Skype::CONFERENCE},
    01711         {__EA(EXTERNAL), Skype::EXTERNAL},
    01712         {0, 0}
    01713 };
    01714
    01715 namespace Sid {
    01716         template<> Sid::String tostring(const Skype::IDENTITYTYPE& v)
    01717         {
    01718                 return enumtostring("Skype::IDENTITYTYPE",SKYPE_IDENTITYTYPE_MAP,v);
    01719         }
    01720 }
    01721
    01722 extern const PMAP SKYPE_NORMALIZERESULT_MAP[] = {
    01723         {__EA(IDENTITY_OK), Skype::IDENTITY_OK},
    01724         {__EA(IDENTITY_EMPTY), Skype::IDENTITY_EMPTY},
    01725         {__EA(IDENTITY_TOO_LONG), Skype::IDENTITY_TOO_LONG},
    01726         {__EA(IDENTITY_CONTAINS_INVALID_CHAR), Skype::IDENTITY_CONTAINS_INVALID_CHAR},
    01727         {__EA(PSTN_NUMBER_TOO_SHORT), Skype::PSTN_NUMBER_TOO_SHORT},
    01728         {__EA(PSTN_NUMBER_HAS_INVALID_PREFIX), Skype::PSTN_NUMBER_HAS_INVALID_PREFIX},
    01729         {__EA(SKYPENAME_STARTS_WITH_NONALPHA), Skype::SKYPENAME_STARTS_WITH_NONALPHA},
    01730         {__EA(SKYPENAME_SHORTER_THAN_6_CHARS), Skype::SKYPENAME_SHORTER_THAN_6_CHARS},
    01731         {0, 0}
    01732 };
    01733
    01734 namespace Sid {
    01735         template<> Sid::String tostring(const Skype::NORMALIZERESULT& v)
    01736         {
    01737                 return enumtostring("Skype::NORMALIZERESULT",SKYPE_NORMALIZERESULT_MAP,v);
    01738         }
    01739 }
    01740
    01741 void Skype::OnContactOnlineAppearance(
    01742         __se_unused const ContactRef& /*contact*/
    01743 ) {}
    01744
    01745 void Skype::OnContactGoneOffline(
    01746         __se_unused const ContactRef& /*contact*/
    01747 ) {}
    01748
    01749 void Skype::OnConversationListChange(
    01750         __se_unused const ConversationRef& /*conversation*/,
    01751         __se_unused const Conversation::LIST_TYPE& /*type*/,
    01752         __se_unused const bool& /*added*/
    01753 ) {}
    01754
    01755 void Skype::OnMessage(
    01756         __se_unused const MessageRef& /*message*/,
    01757         __se_unused const bool& /*changesInboxTimestamp*/,
    01758         __se_unused const MessageRef& /*supersedesHistoryMessage*/,
    01759         __se_unused const ConversationRef& /*conversation*/
    01760 ) {}
    01761
    01762 void Skype::OnAvailableVideoDeviceListChange(
    01763 ) {}
    01764
    01765 void Skype::OnH264Activated(
    01766 ) {}
    01767
    01768 extern const PMAP SKYPE_QUALITYTESTTYPE_MAP[] = {
    01769         {__EA(QTT_AUDIO_IN), Skype::QTT_AUDIO_IN},
    01770         {__EA(QTT_AUDIO_OUT), Skype::QTT_AUDIO_OUT},
    01771         {__EA(QTT_VIDEO_OUT), Skype::QTT_VIDEO_OUT},
    01772         {__EA(QTT_CPU), Skype::QTT_CPU},
    01773         {__EA(QTT_NETWORK), Skype::QTT_NETWORK},
    01774         {__EA(QTT_VIDEO_IN), Skype::QTT_VIDEO_IN},
    01775         {0, 0}
    01776 };
    01777
    01778 namespace Sid {
    01779         template<> Sid::String tostring(const Skype::QUALITYTESTTYPE& v)
    01780         {
    01781                 return enumtostring("Skype::QUALITYTESTTYPE",SKYPE_QUALITYTESTTYPE_MAP,v);
    01782         }
    01783 }
    01784
    01785 extern const PMAP SKYPE_QUALITYTESTRESULT_MAP[] = {
    01786         {__EA(QTR_UNDEFINED), Skype::QTR_UNDEFINED},
    01787         {__EA(QTR_CRITICAL), Skype::QTR_CRITICAL},
    01788         {__EA(QTR_POOR), Skype::QTR_POOR},
    01789         {__EA(QTR_AVERAGE), Skype::QTR_AVERAGE},
    01790         {__EA(QTR_GOOD), Skype::QTR_GOOD},
    01791         {__EA(QTR_EXCELLENT), Skype::QTR_EXCELLENT},
    01792         {0, 0}
    01793 };
    01794
    01795 namespace Sid {
    01796         template<> Sid::String tostring(const Skype::QUALITYTESTRESULT& v)
    01797         {
    01798                 return enumtostring("Skype::QUALITYTESTRESULT",SKYPE_QUALITYTESTRESULT_MAP,v);
    01799         }
    01800 }
    01801
    01802 void Skype::OnQualityTestResult(
    01803         __se_unused const QUALITYTESTTYPE& /*testType*/,
    01804         __se_unused const QUALITYTESTRESULT& /*testResult*/,
    01805         __se_unused const Sid::String& /*withUser*/,
    01806         __se_unused const Sid::String& /*details*/,
    01807         __se_unused const Sid::String& /*xmlDetails*/
    01808 ) {}
    01809
    01810 extern const PMAP SKYPE_PREPARESOUNDRESULT_MAP[] = {
    01811         {__EA(PREPARESOUND_SUCCESS), Skype::PREPARESOUND_SUCCESS},
    01812         {__EA(PREPARESOUND_MISC_ERROR), Skype::PREPARESOUND_MISC_ERROR},
    01813         {__EA(PREPARESOUND_FILE_NOT_FOUND), Skype::PREPARESOUND_FILE_NOT_FOUND},
    01814         {__EA(PREPARESOUND_FILE_TOO_BIG), Skype::PREPARESOUND_FILE_TOO_BIG},
    01815         {__EA(PREPARESOUND_FILE_READ_ERROR), Skype::PREPARESOUND_FILE_READ_ERROR},
    01816         {__EA(PREPARESOUND_UNSUPPORTED_FILE_FORMAT), Skype::PREPARESOUND_UNSUPPORTED_FILE_FORMAT},
    01817         {__EA(PREPARESOUND_PLAYBACK_NOT_SUPPORTED), Skype::PREPARESOUND_PLAYBACK_NOT_SUPPORTED},
    01818         {0, 0}
    01819 };
    01820
    01821 namespace Sid {
    01822         template<> Sid::String tostring(const Skype::PREPARESOUNDRESULT& v)
    01823         {
    01824                 return enumtostring("Skype::PREPARESOUNDRESULT",SKYPE_PREPARESOUNDRESULT_MAP,v);
    01825         }
    01826 }
    01827
    01828 extern const PMAP SKYPE_AUDIODEVICE_CAPABILITIES_MAP[] = {
    01829         {__EA(HAS_VIDEO_CAPTURE), Skype::HAS_VIDEO_CAPTURE},
    01830         {__EA(HAS_USB_INTERFACE), Skype::HAS_USB_INTERFACE},
    01831         {__EA(POSSIBLY_HEADSET), Skype::POSSIBLY_HEADSET},
    01832         {__EA(HAS_AUDIO_CAPTURE), Skype::HAS_AUDIO_CAPTURE},
    01833         {__EA(HAS_AUDIO_RENDERING), Skype::HAS_AUDIO_RENDERING},
    01834         {__EA(HAS_LOWBANDWIDTH_CAPTURE), Skype::HAS_LOWBANDWIDTH_CAPTURE},
    01835         {__EA(IS_WEBCAM), Skype::IS_WEBCAM},
    01836         {__EA(IS_HEADSET), Skype::IS_HEADSET},
    01837         {__EA(POSSIBLY_WEBCAM), Skype::POSSIBLY_WEBCAM},
    01838         {__EA(HAS_VIDEO_RENDERING), Skype::HAS_VIDEO_RENDERING},
    01839         {__EA(HAS_BLUETOOTH_INTERFACE), Skype::HAS_BLUETOOTH_INTERFACE},
    01840         {0, 0}
    01841 };
    01842
    01843 namespace Sid {
    01844         template<> Sid::String tostring(const Skype::AUDIODEVICE_CAPABILITIES& v)
    01845         {
    01846                 return enumtostring("Skype::AUDIODEVICE_CAPABILITIES",SKYPE_AUDIODEVICE_CAPABILITIES_MAP,v);
    01847         }
    01848 }
    01849
    01850 void Skype::OnAvailableDeviceListChange(
    01851 ) {}
    01852
    01853 void Skype::OnNrgLevelsChange(
    01854 ) {}
    01855
    01856 extern const PMAP SKYPE_OPERATING_MEDIA_MAP[] = {
    01857         {__EA(OM_UNKNOWN), Skype::OM_UNKNOWN},
    01858         {__EA(OM_FREE), Skype::OM_FREE},
    01859         {__EA(OM_FREE_WIRELESS), Skype::OM_FREE_WIRELESS},
    01860         {__EA(OM_3G), Skype::OM_3G},
    01861         {__EA(OM_4G), Skype::OM_4G},
    01862         {0, 0}
    01863 };
    01864
    01865 namespace Sid {
    01866         template<> Sid::String tostring(const Skype::OPERATING_MEDIA& v)
    01867         {
    01868                 return enumtostring("Skype::OPERATING_MEDIA",SKYPE_OPERATING_MEDIA_MAP,v);
    01869         }
    01870 }
    01871
    01872 extern const PMAP SKYPE_VALIDATERESULT_MAP[] = {
    01873         {__EA(NOT_VALIDATED), Skype::NOT_VALIDATED},
    01874         {__EA(VALIDATED_OK), Skype::VALIDATED_OK},
    01875         {__EA(TOO_SHORT), Skype::TOO_SHORT},
    01876         {__EA(TOO_LONG), Skype::TOO_LONG},
    01877         {__EA(CONTAINS_INVALID_CHAR), Skype::CONTAINS_INVALID_CHAR},
    01878         {__EA(CONTAINS_SPACE), Skype::CONTAINS_SPACE},
    01879         {__EA(SAME_AS_USERNAME), Skype::SAME_AS_USERNAME},
    01880         {__EA(INVALID_FORMAT), Skype::INVALID_FORMAT},
    01881         {__EA(CONTAINS_INVALID_WORD), Skype::CONTAINS_INVALID_WORD},
    01882         {__EA(TOO_SIMPLE), Skype::TOO_SIMPLE},
    01883         {__EA(STARTS_WITH_INVALID_CHAR), Skype::STARTS_WITH_INVALID_CHAR},
    01884         {0, 0}
    01885 };
    01886
    01887 namespace Sid {
    01888         template<> Sid::String tostring(const Skype::VALIDATERESULT& v)
    01889         {
    01890                 return enumtostring("Skype::VALIDATERESULT",SKYPE_VALIDATERESULT_MAP,v);
    01891         }
    01892 }
    01893
    01894 extern const PMAP SKYPE_PROXYTYPE_MAP[] = {
    01895         {__EA(HTTPS_PROXY), Skype::HTTPS_PROXY},
    01896         {__EA(SOCKS_PROXY), Skype::SOCKS_PROXY},
    01897         {0, 0}
    01898 };
    01899
    01900 namespace Sid {
    01901         template<> Sid::String tostring(const Skype::PROXYTYPE& v)
    01902         {
    01903                 return enumtostring("Skype::PROXYTYPE",SKYPE_PROXYTYPE_MAP,v);
    01904         }
    01905 }
    01906
    01907 void Skype::OnProxyAuthFailure(
    01908         __se_unused const PROXYTYPE& /*type*/
    01909 ) {}
    01910
    01911 extern const PMAP SKYPE_APP2APP_STREAMS_MAP[] = {
    01912         {__EA(ALL_STREAMS), Skype::ALL_STREAMS},
    01913         {__EA(SENDING_STREAMS), Skype::SENDING_STREAMS},
    01914         {__EA(RECEIVED_STREAMS), Skype::RECEIVED_STREAMS},
    01915         {0, 0}
    01916 };
    01917
    01918 namespace Sid {
    01919         template<> Sid::String tostring(const Skype::APP2APP_STREAMS& v)
    01920         {
    01921                 return enumtostring("Skype::APP2APP_STREAMS",SKYPE_APP2APP_STREAMS_MAP,v);
    01922         }
    01923 }
    01924
    01925 void Skype::OnApp2AppDatagram(
    01926         __se_unused const Sid::String& /*appname*/,
    01927         __se_unused const Sid::String& /*stream*/,
    01928         __se_unused const Sid::Binary& /*data*/
    01929 ) {}
    01930
    01931 void Skype::OnApp2AppStreamListChange(
    01932         __se_unused const Sid::String& /*appname*/,
    01933         __se_unused const APP2APP_STREAMS& /*listType*/,
    01934         __se_unused const Sid::List_String& /*streams*/,
    01935         __se_unused const Sid::List_uint& /*receivedSizes*/
    01936 ) {}
    01937
    01938
    01939 ContactGroup * Skype::newContactGroup(int oid)
    01940 {
    01941         return new ContactGroup(oid, this);
    01942 }
    01943
    01944 Contact * Skype::newContact(int oid)
    01945 {
    01946         return new Contact(oid, this);
    01947 }
    01948
    01949 ContactSearch * Skype::newContactSearch(int oid)
    01950 {
    01951         return new ContactSearch(oid, this);
    01952 }
    01953
    01954 Participant * Skype::newParticipant(int oid)
    01955 {
    01956         return new Participant(oid, this);
    01957 }
    01958
    01959 Conversation * Skype::newConversation(int oid)
    01960 {
    01961         return new Conversation(oid, this);
    01962 }
    01963
    01964 Message * Skype::newMessage(int oid)
    01965 {
    01966         return new Message(oid, this);
    01967 }
    01968
    01969 Video * Skype::newVideo(int oid)
    01970 {
    01971         return new Video(oid, this);
    01972 }
    01973
    01974 Voicemail * Skype::newVoicemail(int oid)
    01975 {
    01976         return new Voicemail(oid, this);
    01977 }
    01978
    01979 Sms * Skype::newSms(int oid)
    01980 {
    01981         return new Sms(oid, this);
    01982 }
    01983
    01984 Transfer * Skype::newTransfer(int oid)
    01985 {
    01986         return new Transfer(oid, this);
    01987 }
    01988
    01989 Account * Skype::newAccount(int oid)
    01990 {
    01991         return new Account(oid, this);
    01992 }
    01993
    01994 SEObject* Skype::factory(const uint& oid, const uint& modid){
    01995         SEObject* o = 0;
    01996         switch (modid) {
    01997         case ContactGroup::MODULE_ID:
    01998                 o = newContactGroup(oid);
    01999                 break;
    02000         case Contact::MODULE_ID:
    02001                 o = newContact(oid);
    02002                 break;
    02003         case ContactSearch::MODULE_ID:
    02004                 o = newContactSearch(oid);
    02005                 break;
    02006         case Participant::MODULE_ID:
    02007                 o = newParticipant(oid);
    02008                 break;
    02009         case Conversation::MODULE_ID:
    02010                 o = newConversation(oid);
    02011                 break;
    02012         case Message::MODULE_ID:
    02013                 o = newMessage(oid);
    02014                 break;
    02015         case Video::MODULE_ID:
    02016                 o = newVideo(oid);
    02017                 break;
    02018         case Voicemail::MODULE_ID:
    02019                 o = newVoicemail(oid);
    02020                 break;
    02021         case Sms::MODULE_ID:
    02022                 o = newSms(oid);
    02023                 break;
    02024         case Transfer::MODULE_ID:
    02025                 o = newTransfer(oid);
    02026                 break;
    02027         case Account::MODULE_ID:
    02028                 o = newAccount(oid);
    02029                 break;
    02030         default:
    02031                 break;
    02032         }
    02033         return o;
    02034 }
    02035
    02036 Sid::List_uint* Skype::prop_cached_list(void* propstruct, const uint& moduleid)
    02037 {
    02038         switch (moduleid) {
    02039         case ContactGroup::MODULE_ID:
    02040                 return &reinterpret_cast<MsgcontactContactGroup*>(propstruct)->cachedProps;
    02041         case Contact::MODULE_ID:
    02042                 return &reinterpret_cast<MsgcontactContact*>(propstruct)->cachedProps;
    02043         case ContactSearch::MODULE_ID:
    02044                 return &reinterpret_cast<MsgcontactsearchContactSearch*>(propstruct)->cachedProps;
    02045         case Participant::MODULE_ID:
    02046                 return &reinterpret_cast<MsgconversationParticipant*>(propstruct)->cachedProps;
    02047         case Conversation::MODULE_ID:
    02048                 return &reinterpret_cast<MsgconversationConversation*>(propstruct)->cachedProps;
    02049         case Message::MODULE_ID:
    02050                 return &reinterpret_cast<MsgconversationMessage*>(propstruct)->cachedProps;
    02051         case Video::MODULE_ID:
    02052                 return &reinterpret_cast<MsgvideoVideo*>(propstruct)->cachedProps;
    02053         case Voicemail::MODULE_ID:
    02054                 return &reinterpret_cast<MsgvmVoicemail*>(propstruct)->cachedProps;
    02055         case Sms::MODULE_ID:
    02056                 return &reinterpret_cast<MsgsmsSms*>(propstruct)->cachedProps;
    02057         case Transfer::MODULE_ID:
    02058                 return &reinterpret_cast<MsgftTransfer*>(propstruct)->cachedProps;
    02059         case Account::MODULE_ID:
    02060                 return &reinterpret_cast<MsgaccountAccount*>(propstruct)->cachedProps;
    02061         default:
    02062                 break;
    02063         }
    02064         return 0;
    02065 }
    02066
    02067 void* Skype::prop_factory(const uint& moduleid)
    02068 {
    02069         switch (moduleid) {
    02070         case ContactGroup::MODULE_ID:
    02071                 return new MsgcontactContactGroup();
    02072         case Contact::MODULE_ID:
    02073                 return new MsgcontactContact();
    02074         case ContactSearch::MODULE_ID:
    02075                 return new MsgcontactsearchContactSearch();
    02076         case Participant::MODULE_ID:
    02077                 return new MsgconversationParticipant();
    02078         case Conversation::MODULE_ID:
    02079                 return new MsgconversationConversation();
    02080         case Message::MODULE_ID:
    02081                 return new MsgconversationMessage();
    02082         case Video::MODULE_ID:
    02083                 return new MsgvideoVideo();
    02084         case Voicemail::MODULE_ID:
    02085                 return new MsgvmVoicemail();
    02086         case Sms::MODULE_ID:
    02087                 return new MsgsmsSms();
    02088         case Transfer::MODULE_ID:
    02089                 return new MsgftTransfer();
    02090         case Account::MODULE_ID:
    02091                 return new MsgaccountAccount();
    02092         default:
    02093                 break;
    02094         }
    02095         return 0;
    02096 }
    02097 bool Skype::start() { bool r; if (!Start(r) || !r) { stop(); return false; } return true; }

All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

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

Last updated: Fri Jan 27 2012