00001 #include "skype-embedded_2.h" 00002 Skype::Skype(int num_threads) : SERootObject(num_threads) {} 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 00366 /** class Participant **********************/ 00367 00368 Participant::Participant(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 00369 Participant::~Participant() { } 00370 void Participant::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgconversationParticipant*>(cache); } 00371 unsigned int Participant::moduleID() const 00372 { 00373 return MODULE_ID; 00374 } 00375 String Participant::getNamespace() const 00376 { 00377 return __EA(PARTICIPANT); 00378 } 00379 00380 extern const PMAP PARTICIPANT_PROPERTY_MAP[] = { 00381 {__EA(CONVO_ID), Participant::P_CONVO_ID}, 00382 {__EA(IDENTITY), Participant::P_IDENTITY}, 00383 {__EA(RANK), Participant::P_RANK}, 00384 {__EA(REQUESTED_RANK), Participant::P_REQUESTED_RANK}, 00385 {__EA(TEXT_STATUS), Participant::P_TEXT_STATUS}, 00386 {__EA(VOICE_STATUS), Participant::P_VOICE_STATUS}, 00387 {__EA(VIDEO_STATUS), Participant::P_VIDEO_STATUS}, 00388 {__EA(LIVE_IDENTITY), Participant::P_LIVE_IDENTITY}, 00389 {__EA(LIVE_PRICE_FOR_ME), Participant::P_LIVE_PRICE_FOR_ME}, 00390 {__EA(LIVE_FWD_IDENTITIES), Participant::P_LIVE_FWD_IDENTITIES}, 00391 {__EA(LIVE_START_TIMESTAMP), Participant::P_LIVE_START_TIMESTAMP}, 00392 {__EA(SOUND_LEVEL), Participant::P_SOUND_LEVEL}, 00393 {__EA(DEBUGINFO), Participant::P_DEBUGINFO}, 00394 {__EA(LAST_VOICE_ERROR), Participant::P_LAST_VOICE_ERROR}, 00395 {__EA(QUALITY_PROBLEMS), Participant::P_QUALITY_PROBLEMS}, 00396 {__EA(LIVE_TYPE), Participant::P_LIVE_TYPE}, 00397 {__EA(LIVE_COUNTRY), Participant::P_LIVE_COUNTRY}, 00398 {__EA(TRANSFERRED_BY), Participant::P_TRANSFERRED_BY}, 00399 {__EA(TRANSFERRED_TO), Participant::P_TRANSFERRED_TO}, 00400 {__EA(ADDER), Participant::P_ADDER}, 00401 {0, 0} 00402 }; 00403 00404 extern const PMAP PARTICIPANT_RANK_MAP[] = { 00405 {__EA(CREATOR), Participant::CREATOR}, 00406 {__EA(ADMIN), Participant::ADMIN}, 00407 {__EA(SPEAKER), Participant::SPEAKER}, 00408 {__EA(WRITER), Participant::WRITER}, 00409 {__EA(SPECTATOR), Participant::SPECTATOR}, 00410 {__EA(APPLICANT), Participant::APPLICANT}, 00411 {__EA(RETIRED), Participant::RETIRED}, 00412 {__EA(OUTLAW), Participant::OUTLAW}, 00413 {0, 0} 00414 }; 00415 00416 namespace Sid { 00417 template<> Sid::String tostring(const Participant::RANK& v) 00418 { 00419 return enumtostring("Participant::RANK",PARTICIPANT_RANK_MAP,v); 00420 } 00421 } 00422 00423 extern const PMAP PARTICIPANT_TEXT_STATUS_MAP[] = { 00424 {__EA(TEXT_UNKNOWN), Participant::TEXT_UNKNOWN}, 00425 {__EA(TEXT_NA), Participant::TEXT_NA}, 00426 {__EA(READING), Participant::READING}, 00427 {__EA(WRITING), Participant::WRITING}, 00428 {__EA(WRITING_AS_ANGRY), Participant::WRITING_AS_ANGRY}, 00429 {__EA(WRITING_AS_CAT), Participant::WRITING_AS_CAT}, 00430 {0, 0} 00431 }; 00432 00433 namespace Sid { 00434 template<> Sid::String tostring(const Participant::TEXT_STATUS& v) 00435 { 00436 return enumtostring("Participant::TEXT_STATUS",PARTICIPANT_TEXT_STATUS_MAP,v); 00437 } 00438 } 00439 00440 extern const PMAP PARTICIPANT_VOICE_STATUS_MAP[] = { 00441 {__EA(VOICE_UNKNOWN), Participant::VOICE_UNKNOWN}, 00442 {__EA(VOICE_NA), Participant::VOICE_NA}, 00443 {__EA(VOICE_AVAILABLE), Participant::VOICE_AVAILABLE}, 00444 {__EA(VOICE_CONNECTING), Participant::VOICE_CONNECTING}, 00445 {__EA(RINGING), Participant::RINGING}, 00446 {__EA(EARLY_MEDIA), Participant::EARLY_MEDIA}, 00447 {__EA(LISTENING), Participant::LISTENING}, 00448 {__EA(SPEAKING), Participant::SPEAKING}, 00449 {__EA(VOICE_ON_HOLD), Participant::VOICE_ON_HOLD}, 00450 {__EA(VOICE_STOPPED), Participant::VOICE_STOPPED}, 00451 {0, 0} 00452 }; 00453 00454 namespace Sid { 00455 template<> Sid::String tostring(const Participant::VOICE_STATUS& v) 00456 { 00457 return enumtostring("Participant::VOICE_STATUS",PARTICIPANT_VOICE_STATUS_MAP,v); 00458 } 00459 } 00460 00461 extern const PMAP PARTICIPANT_VIDEO_STATUS_MAP[] = { 00462 {__EA(VIDEO_UNKNOWN), Participant::VIDEO_UNKNOWN}, 00463 {__EA(VIDEO_NA), Participant::VIDEO_NA}, 00464 {__EA(VIDEO_AVAILABLE), Participant::VIDEO_AVAILABLE}, 00465 {__EA(VIDEO_CONNECTING), Participant::VIDEO_CONNECTING}, 00466 {__EA(STREAMING), Participant::STREAMING}, 00467 {__EA(VIDEO_ON_HOLD), Participant::VIDEO_ON_HOLD}, 00468 {0, 0} 00469 }; 00470 00471 namespace Sid { 00472 template<> Sid::String tostring(const Participant::VIDEO_STATUS& v) 00473 { 00474 return enumtostring("Participant::VIDEO_STATUS",PARTICIPANT_VIDEO_STATUS_MAP,v); 00475 } 00476 } 00477 00478 extern const PMAP PARTICIPANT_DTMF_MAP[] = { 00479 {__EA(DTMF_0), Participant::DTMF_0}, 00480 {__EA(DTMF_1), Participant::DTMF_1}, 00481 {__EA(DTMF_2), Participant::DTMF_2}, 00482 {__EA(DTMF_3), Participant::DTMF_3}, 00483 {__EA(DTMF_4), Participant::DTMF_4}, 00484 {__EA(DTMF_5), Participant::DTMF_5}, 00485 {__EA(DTMF_6), Participant::DTMF_6}, 00486 {__EA(DTMF_7), Participant::DTMF_7}, 00487 {__EA(DTMF_8), Participant::DTMF_8}, 00488 {__EA(DTMF_9), Participant::DTMF_9}, 00489 {__EA(DTMF_STAR), Participant::DTMF_STAR}, 00490 {__EA(DTMF_POUND), Participant::DTMF_POUND}, 00491 {0, 0} 00492 }; 00493 00494 namespace Sid { 00495 template<> Sid::String tostring(const Participant::DTMF& v) 00496 { 00497 return enumtostring("Participant::DTMF",PARTICIPANT_DTMF_MAP,v); 00498 } 00499 } 00500 00501 void Participant::OnIncomingDTMF( 00502 __se_unused const DTMF& /*dtmf*/ 00503 ) {} 00504 00505 extern const EMAP PARTICIPANT_EMAP[] = { 00506 {Participant::P_RANK, PARTICIPANT_RANK_MAP}, 00507 {Participant::P_REQUESTED_RANK, PARTICIPANT_RANK_MAP}, 00508 {Participant::P_TEXT_STATUS, PARTICIPANT_TEXT_STATUS_MAP}, 00509 {Participant::P_VOICE_STATUS, PARTICIPANT_VOICE_STATUS_MAP}, 00510 {Participant::P_VIDEO_STATUS, PARTICIPANT_VIDEO_STATUS_MAP}, 00511 {0, 0} 00512 }; 00513 const EMAP* Participant::getEMap() const 00514 { 00515 return PARTICIPANT_EMAP; 00516 } 00517 const PMAP* Participant::getPMap() const 00518 { 00519 return PARTICIPANT_PROPERTY_MAP; 00520 } 00521 00522 00523 /** class Conversation **********************/ 00524 00525 Conversation::Conversation(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 00526 Conversation::~Conversation() { } 00527 void Conversation::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgconversationConversation*>(cache); } 00528 unsigned int Conversation::moduleID() const 00529 { 00530 return MODULE_ID; 00531 } 00532 String Conversation::getNamespace() const 00533 { 00534 return __EA(CONVERSATION); 00535 } 00536 00537 extern const PMAP CONVERSATION_PROPERTY_MAP[] = { 00538 {__EA(IDENTITY), Conversation::P_IDENTITY}, 00539 {__EA(TYPE), Conversation::P_TYPE}, 00540 {__EA(LIVE_HOST), Conversation::P_LIVE_HOST}, 00541 {__EA(LIVE_START_TIMESTAMP), Conversation::P_LIVE_START_TIMESTAMP}, 00542 {__EA(LIVE_IS_MUTED), Conversation::P_LIVE_IS_MUTED}, 00543 {__EA(ALERT_STRING), Conversation::P_ALERT_STRING}, 00544 {__EA(IS_BOOKMARKED), Conversation::P_IS_BOOKMARKED}, 00545 {__EA(GIVEN_DISPLAYNAME), Conversation::P_GIVEN_DISPLAYNAME}, 00546 {__EA(DISPLAYNAME), Conversation::P_DISPLAYNAME}, 00547 {__EA(LOCAL_LIVESTATUS), Conversation::P_LOCAL_LIVESTATUS}, 00548 {__EA(INBOX_TIMESTAMP), Conversation::P_INBOX_TIMESTAMP}, 00549 {__EA(INBOX_MESSAGE_ID), Conversation::P_INBOX_MESSAGE_ID}, 00550 {__EA(UNCONSUMED_SUPPRESSED_MESSAGES), Conversation::P_UNCONSUMED_SUPPRESSED_MESSAGES}, 00551 {__EA(UNCONSUMED_NORMAL_MESSAGES), Conversation::P_UNCONSUMED_NORMAL_MESSAGES}, 00552 {__EA(UNCONSUMED_ELEVATED_MESSAGES), Conversation::P_UNCONSUMED_ELEVATED_MESSAGES}, 00553 {__EA(UNCONSUMED_MESSAGES_VOICE), Conversation::P_UNCONSUMED_MESSAGES_VOICE}, 00554 {__EA(ACTIVE_VM_ID), Conversation::P_ACTIVE_VM_ID}, 00555 {__EA(CONSUMPTION_HORIZON), Conversation::P_CONSUMPTION_HORIZON}, 00556 {__EA(LAST_ACTIVITY_TIMESTAMP), Conversation::P_LAST_ACTIVITY_TIMESTAMP}, 00557 {__EA(SPAWNED_FROM_CONVO_ID), Conversation::P_SPAWNED_FROM_CONVO_ID}, 00558 {__EA(CREATOR), Conversation::P_CREATOR}, 00559 {__EA(CREATION_TIMESTAMP), Conversation::P_CREATION_TIMESTAMP}, 00560 {__EA(MY_STATUS), Conversation::P_MY_STATUS}, 00561 {__EA(OPT_JOINING_ENABLED), Conversation::P_OPT_JOINING_ENABLED}, 00562 {__EA(OPT_ENTRY_LEVEL_RANK), Conversation::P_OPT_ENTRY_LEVEL_RANK}, 00563 {__EA(OPT_DISCLOSE_HISTORY), Conversation::P_OPT_DISCLOSE_HISTORY}, 00564 {__EA(OPT_ADMIN_ONLY_ACTIVITIES), Conversation::P_OPT_ADMIN_ONLY_ACTIVITIES}, 00565 {__EA(PASSWORDHINT), Conversation::P_PASSWORDHINT}, 00566 {__EA(META_NAME), Conversation::P_META_NAME}, 00567 {__EA(META_TOPIC), Conversation::P_META_TOPIC}, 00568 {__EA(META_GUIDELINES), Conversation::P_META_GUIDELINES}, 00569 {__EA(META_PICTURE), Conversation::P_META_PICTURE}, 00570 {0, 0} 00571 }; 00572 00573 extern const PMAP CONVERSATION_TYPE_MAP[] = { 00574 {__EA(DIALOG), Conversation::DIALOG}, 00575 {__EA(CONFERENCE), Conversation::CONFERENCE}, 00576 {__EA(TERMINATED_CONFERENCE), Conversation::TERMINATED_CONFERENCE}, 00577 {__EA(LEGACY_VOICE_CONFERENCE), Conversation::LEGACY_VOICE_CONFERENCE}, 00578 {__EA(LEGACY_SHAREDGROUP), Conversation::LEGACY_SHAREDGROUP}, 00579 {0, 0} 00580 }; 00581 00582 namespace Sid { 00583 template<> Sid::String tostring(const Conversation::TYPE& v) 00584 { 00585 return enumtostring("Conversation::TYPE",CONVERSATION_TYPE_MAP,v); 00586 } 00587 } 00588 00589 extern const PMAP CONVERSATION_MY_STATUS_MAP[] = { 00590 {__EA(CONNECTING), Conversation::CONNECTING}, 00591 {__EA(RETRY_CONNECTING), Conversation::RETRY_CONNECTING}, 00592 {__EA(DOWNLOADING_MESSAGES), Conversation::DOWNLOADING_MESSAGES}, 00593 {__EA(QUEUED_TO_ENTER), Conversation::QUEUED_TO_ENTER}, 00594 {__EA(APPLICANT), Conversation::APPLICANT}, 00595 {__EA(APPLICATION_DENIED), Conversation::APPLICATION_DENIED}, 00596 {__EA(INVALID_ACCESS_TOKEN), Conversation::INVALID_ACCESS_TOKEN}, 00597 {__EA(CONSUMER), Conversation::CONSUMER}, 00598 {__EA(RETIRED_FORCEFULLY), Conversation::RETIRED_FORCEFULLY}, 00599 {__EA(RETIRED_VOLUNTARILY), Conversation::RETIRED_VOLUNTARILY}, 00600 {0, 0} 00601 }; 00602 00603 namespace Sid { 00604 template<> Sid::String tostring(const Conversation::MY_STATUS& v) 00605 { 00606 return enumtostring("Conversation::MY_STATUS",CONVERSATION_MY_STATUS_MAP,v); 00607 } 00608 } 00609 00610 extern const PMAP CONVERSATION_LOCAL_LIVESTATUS_MAP[] = { 00611 {__EA(NONE), Conversation::NONE}, 00612 {__EA(STARTING), Conversation::STARTING}, 00613 {__EA(RINGING_FOR_ME), Conversation::RINGING_FOR_ME}, 00614 {__EA(IM_LIVE), Conversation::IM_LIVE}, 00615 {__EA(ON_HOLD_LOCALLY), Conversation::ON_HOLD_LOCALLY}, 00616 {__EA(ON_HOLD_REMOTELY), Conversation::ON_HOLD_REMOTELY}, 00617 {__EA(OTHERS_ARE_LIVE), Conversation::OTHERS_ARE_LIVE}, 00618 {__EA(OTHERS_ARE_LIVE_FULL), Conversation::OTHERS_ARE_LIVE_FULL}, 00619 {__EA(PLAYING_VOICE_MESSAGE), Conversation::PLAYING_VOICE_MESSAGE}, 00620 {__EA(RECORDING_VOICE_MESSAGE), Conversation::RECORDING_VOICE_MESSAGE}, 00621 {__EA(RECENTLY_LIVE), Conversation::RECENTLY_LIVE}, 00622 {__EA(TRANSFERRING), Conversation::TRANSFERRING}, 00623 {0, 0} 00624 }; 00625 00626 namespace Sid { 00627 template<> Sid::String tostring(const Conversation::LOCAL_LIVESTATUS& v) 00628 { 00629 return enumtostring("Conversation::LOCAL_LIVESTATUS",CONVERSATION_LOCAL_LIVESTATUS_MAP,v); 00630 } 00631 } 00632 00633 extern const PMAP CONVERSATION_ALLOWED_ACTIVITY_MAP[] = { 00634 {__EA(SET_META), Conversation::SET_META}, 00635 {__EA(ADD_CONSUMERS), Conversation::ADD_CONSUMERS}, 00636 {__EA(SPEAK), Conversation::SPEAK}, 00637 {__EA(SPEAK_AND_WRITE), Conversation::SPEAK_AND_WRITE}, 00638 {0, 0} 00639 }; 00640 00641 namespace Sid { 00642 template<> Sid::String tostring(const Conversation::ALLOWED_ACTIVITY& v) 00643 { 00644 return enumtostring("Conversation::ALLOWED_ACTIVITY",CONVERSATION_ALLOWED_ACTIVITY_MAP,v); 00645 } 00646 } 00647 00648 extern const PMAP CONVERSATION_PARTICIPANTFILTER_MAP[] = { 00649 {__EA(ALL), Conversation::ALL}, 00650 {__EA(CONSUMERS), Conversation::CONSUMERS}, 00651 {__EA(APPLICANTS), Conversation::APPLICANTS}, 00652 {__EA(CONSUMERS_AND_APPLICANTS), Conversation::CONSUMERS_AND_APPLICANTS}, 00653 {__EA(MYSELF), Conversation::MYSELF}, 00654 {__EA(OTHER_CONSUMERS), Conversation::OTHER_CONSUMERS}, 00655 {0, 0} 00656 }; 00657 00658 namespace Sid { 00659 template<> Sid::String tostring(const Conversation::PARTICIPANTFILTER& v) 00660 { 00661 return enumtostring("Conversation::PARTICIPANTFILTER",CONVERSATION_PARTICIPANTFILTER_MAP,v); 00662 } 00663 } 00664 00665 extern const PMAP CONVERSATION_LIST_TYPE_MAP[] = { 00666 {__EA(ALL_CONVERSATIONS), Conversation::ALL_CONVERSATIONS}, 00667 {__EA(INBOX_CONVERSATIONS), Conversation::INBOX_CONVERSATIONS}, 00668 {__EA(BOOKMARKED_CONVERSATIONS), Conversation::BOOKMARKED_CONVERSATIONS}, 00669 {__EA(LIVE_CONVERSATIONS), Conversation::LIVE_CONVERSATIONS}, 00670 {__EA(REALLY_ALL_CONVERSATIONS), Conversation::REALLY_ALL_CONVERSATIONS}, 00671 {0, 0} 00672 }; 00673 00674 namespace Sid { 00675 template<> Sid::String tostring(const Conversation::LIST_TYPE& v) 00676 { 00677 return enumtostring("Conversation::LIST_TYPE",CONVERSATION_LIST_TYPE_MAP,v); 00678 } 00679 } 00680 00681 void Conversation::OnParticipantListChange( 00682 ) {} 00683 00684 void Conversation::OnMessage( 00685 __se_unused const MessageRef& /*message*/ 00686 ) {} 00687 00688 void Conversation::OnSpawnConference( 00689 __se_unused const ConversationRef& /*spawned*/ 00690 ) {} 00691 00692 extern const EMAP CONVERSATION_EMAP[] = { 00693 {Conversation::P_TYPE, CONVERSATION_TYPE_MAP}, 00694 {Conversation::P_LOCAL_LIVESTATUS, CONVERSATION_LOCAL_LIVESTATUS_MAP}, 00695 {Conversation::P_MY_STATUS, CONVERSATION_MY_STATUS_MAP}, 00696 {Conversation::P_OPT_ENTRY_LEVEL_RANK, PARTICIPANT_RANK_MAP}, 00697 {Conversation::P_OPT_ADMIN_ONLY_ACTIVITIES, CONVERSATION_ALLOWED_ACTIVITY_MAP}, 00698 {0, 0} 00699 }; 00700 const EMAP* Conversation::getEMap() const 00701 { 00702 return CONVERSATION_EMAP; 00703 } 00704 const PMAP* Conversation::getPMap() const 00705 { 00706 return CONVERSATION_PROPERTY_MAP; 00707 } 00708 00709 00710 /** class Message **********************/ 00711 00712 Message::Message(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 00713 Message::~Message() { } 00714 void Message::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgconversationMessage*>(cache); } 00715 unsigned int Message::moduleID() const 00716 { 00717 return MODULE_ID; 00718 } 00719 String Message::getNamespace() const 00720 { 00721 return __EA(MESSAGE); 00722 } 00723 00724 extern const PMAP MESSAGE_PROPERTY_MAP[] = { 00725 {__EA(CONVO_ID), Message::P_CONVO_ID}, 00726 {__EA(CONVO_GUID), Message::P_CONVO_GUID}, 00727 {__EA(AUTHOR), Message::P_AUTHOR}, 00728 {__EA(AUTHOR_DISPLAYNAME), Message::P_AUTHOR_DISPLAYNAME}, 00729 {__EA(GUID), Message::P_GUID}, 00730 {__EA(ORIGINALLY_MEANT_FOR), Message::P_ORIGINALLY_MEANT_FOR}, 00731 {__EA(TIMESTAMP), Message::P_TIMESTAMP}, 00732 {__EA(TYPE), Message::P_TYPE}, 00733 {__EA(SENDING_STATUS), Message::P_SENDING_STATUS}, 00734 {__EA(CONSUMPTION_STATUS), Message::P_CONSUMPTION_STATUS}, 00735 {__EA(EDITED_BY), Message::P_EDITED_BY}, 00736 {__EA(EDIT_TIMESTAMP), Message::P_EDIT_TIMESTAMP}, 00737 {__EA(PARAM_KEY), Message::P_PARAM_KEY}, 00738 {__EA(PARAM_VALUE), Message::P_PARAM_VALUE}, 00739 {__EA(BODY_XML), Message::P_BODY_XML}, 00740 {__EA(IDENTITIES), Message::P_IDENTITIES}, 00741 {__EA(REASON), Message::P_REASON}, 00742 {__EA(LEAVEREASON), Message::P_LEAVEREASON}, 00743 {__EA(PARTICIPANT_COUNT), Message::P_PARTICIPANT_COUNT}, 00744 {0, 0} 00745 }; 00746 00747 extern const PMAP MESSAGE_TYPE_MAP[] = { 00748 {__EA(SET_METADATA), Message::SET_METADATA}, 00749 {__EA(SPAWNED_CONFERENCE), Message::SPAWNED_CONFERENCE}, 00750 {__EA(ADDED_CONSUMERS), Message::ADDED_CONSUMERS}, 00751 {__EA(ADDED_APPLICANTS), Message::ADDED_APPLICANTS}, 00752 {__EA(RETIRED_OTHERS), Message::RETIRED_OTHERS}, 00753 {__EA(RETIRED), Message::RETIRED}, 00754 {__EA(SET_RANK), Message::SET_RANK}, 00755 {__EA(STARTED_LIVESESSION), Message::STARTED_LIVESESSION}, 00756 {__EA(ENDED_LIVESESSION), Message::ENDED_LIVESESSION}, 00757 {__EA(REQUESTED_AUTH), Message::REQUESTED_AUTH}, 00758 {__EA(GRANTED_AUTH), Message::GRANTED_AUTH}, 00759 {__EA(BLOCKED), Message::BLOCKED}, 00760 {__EA(POSTED_TEXT), Message::POSTED_TEXT}, 00761 {__EA(POSTED_EMOTE), Message::POSTED_EMOTE}, 00762 {__EA(POSTED_CONTACTS), Message::POSTED_CONTACTS}, 00763 {__EA(POSTED_SMS), Message::POSTED_SMS}, 00764 {__EA(POSTED_ALERT), Message::POSTED_ALERT}, 00765 {__EA(POSTED_VOICE_MESSAGE), Message::POSTED_VOICE_MESSAGE}, 00766 {__EA(POSTED_FILES), Message::POSTED_FILES}, 00767 {__EA(POSTED_INVOICE), Message::POSTED_INVOICE}, 00768 {__EA(HAS_BIRTHDAY), Message::HAS_BIRTHDAY}, 00769 {0, 0} 00770 }; 00771 00772 namespace Sid { 00773 template<> Sid::String tostring(const Message::TYPE& v) 00774 { 00775 return enumtostring("Message::TYPE",MESSAGE_TYPE_MAP,v); 00776 } 00777 } 00778 00779 extern const PMAP MESSAGE_SENDING_STATUS_MAP[] = { 00780 {__EA(SENDING), Message::SENDING}, 00781 {__EA(SENT), Message::SENT}, 00782 {__EA(FAILED_TO_SEND), Message::FAILED_TO_SEND}, 00783 {0, 0} 00784 }; 00785 00786 namespace Sid { 00787 template<> Sid::String tostring(const Message::SENDING_STATUS& v) 00788 { 00789 return enumtostring("Message::SENDING_STATUS",MESSAGE_SENDING_STATUS_MAP,v); 00790 } 00791 } 00792 00793 extern const PMAP MESSAGE_CONSUMPTION_STATUS_MAP[] = { 00794 {__EA(CONSUMED), Message::CONSUMED}, 00795 {__EA(UNCONSUMED_SUPPRESSED), Message::UNCONSUMED_SUPPRESSED}, 00796 {__EA(UNCONSUMED_NORMAL), Message::UNCONSUMED_NORMAL}, 00797 {__EA(UNCONSUMED_ELEVATED), Message::UNCONSUMED_ELEVATED}, 00798 {0, 0} 00799 }; 00800 00801 namespace Sid { 00802 template<> Sid::String tostring(const Message::CONSUMPTION_STATUS& v) 00803 { 00804 return enumtostring("Message::CONSUMPTION_STATUS",MESSAGE_CONSUMPTION_STATUS_MAP,v); 00805 } 00806 } 00807 00808 extern const PMAP MESSAGE_SET_METADATA_KEY_MAP[] = { 00809 {__EA(SET_META_NAME), Message::SET_META_NAME}, 00810 {__EA(SET_META_TOPIC), Message::SET_META_TOPIC}, 00811 {__EA(SET_META_GUIDELINES), Message::SET_META_GUIDELINES}, 00812 {__EA(SET_META_PICTURE), Message::SET_META_PICTURE}, 00813 {0, 0} 00814 }; 00815 00816 namespace Sid { 00817 template<> Sid::String tostring(const Message::SET_METADATA_KEY& v) 00818 { 00819 return enumtostring("Message::SET_METADATA_KEY",MESSAGE_SET_METADATA_KEY_MAP,v); 00820 } 00821 } 00822 00823 extern const PMAP MESSAGE_LEAVEREASON_MAP[] = { 00824 {__EA(USER_INCAPABLE), Message::USER_INCAPABLE}, 00825 {__EA(ADDER_MUST_BE_FRIEND), Message::ADDER_MUST_BE_FRIEND}, 00826 {__EA(ADDER_MUST_BE_AUTHORIZED), Message::ADDER_MUST_BE_AUTHORIZED}, 00827 {__EA(DECLINE_ADD), Message::DECLINE_ADD}, 00828 {__EA(UNSUBSCRIBE), Message::UNSUBSCRIBE}, 00829 {0, 0} 00830 }; 00831 00832 namespace Sid { 00833 template<> Sid::String tostring(const Message::LEAVEREASON& v) 00834 { 00835 return enumtostring("Message::LEAVEREASON",MESSAGE_LEAVEREASON_MAP,v); 00836 } 00837 } 00838 00839 extern const EMAP MESSAGE_EMAP[] = { 00840 {Message::P_TYPE, MESSAGE_TYPE_MAP}, 00841 {Message::P_SENDING_STATUS, MESSAGE_SENDING_STATUS_MAP}, 00842 {Message::P_CONSUMPTION_STATUS, MESSAGE_CONSUMPTION_STATUS_MAP}, 00843 {Message::P_LEAVEREASON, MESSAGE_LEAVEREASON_MAP}, 00844 {0, 0} 00845 }; 00846 const EMAP* Message::getEMap() const 00847 { 00848 return MESSAGE_EMAP; 00849 } 00850 const PMAP* Message::getPMap() const 00851 { 00852 return MESSAGE_PROPERTY_MAP; 00853 } 00854 00855 00856 /** class Video **********************/ 00857 00858 Video::Video(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 00859 Video::~Video() { } 00860 void Video::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgvideoVideo*>(cache); } 00861 unsigned int Video::moduleID() const 00862 { 00863 return MODULE_ID; 00864 } 00865 String Video::getNamespace() const 00866 { 00867 return __EA(VIDEO); 00868 } 00869 00870 extern const PMAP VIDEO_PROPERTY_MAP[] = { 00871 {__EA(STATUS), Video::P_STATUS}, 00872 {__EA(ERROR), Video::P_ERROR}, 00873 {__EA(DEBUGINFO), Video::P_DEBUGINFO}, 00874 {__EA(DIMENSIONS), Video::P_DIMENSIONS}, 00875 {__EA(MEDIA_TYPE), Video::P_MEDIA_TYPE}, 00876 {__EA(CONVO_ID), Video::P_CONVO_ID}, 00877 {__EA(DEVICE_PATH), Video::P_DEVICE_PATH}, 00878 {0, 0} 00879 }; 00880 00881 extern const PMAP VIDEO_STATUS_MAP[] = { 00882 {__EA(NOT_AVAILABLE), Video::NOT_AVAILABLE}, 00883 {__EA(AVAILABLE), Video::AVAILABLE}, 00884 {__EA(STARTING), Video::STARTING}, 00885 {__EA(REJECTED), Video::REJECTED}, 00886 {__EA(RUNNING), Video::RUNNING}, 00887 {__EA(STOPPING), Video::STOPPING}, 00888 {__EA(PAUSED), Video::PAUSED}, 00889 {__EA(NOT_STARTED), Video::NOT_STARTED}, 00890 {__EA(HINT_IS_VIDEOCALL_RECEIVED), Video::HINT_IS_VIDEOCALL_RECEIVED}, 00891 {__EA(UNKNOWN), Video::UNKNOWN}, 00892 {__EA(RENDERING), Video::RENDERING}, 00893 {__EA(CHECKING_SUBSCRIPTION), Video::CHECKING_SUBSCRIPTION}, 00894 {__EA(SWITCHING_DEVICE), Video::SWITCHING_DEVICE}, 00895 {0, 0} 00896 }; 00897 00898 namespace Sid { 00899 template<> Sid::String tostring(const Video::STATUS& v) 00900 { 00901 return enumtostring("Video::STATUS",VIDEO_STATUS_MAP,v); 00902 } 00903 } 00904 00905 extern const PMAP VIDEO_MEDIATYPE_MAP[] = { 00906 {__EA(MEDIA_SCREENSHARING), Video::MEDIA_SCREENSHARING}, 00907 {__EA(MEDIA_VIDEO), Video::MEDIA_VIDEO}, 00908 {0, 0} 00909 }; 00910 00911 namespace Sid { 00912 template<> Sid::String tostring(const Video::MEDIATYPE& v) 00913 { 00914 return enumtostring("Video::MEDIATYPE",VIDEO_MEDIATYPE_MAP,v); 00915 } 00916 } 00917 00918 extern const PMAP VIDEO_VIDEO_DEVICE_CAPABILITY_MAP[] = { 00919 {__EA(VIDEOCAP_HQ_CAPABLE), Video::VIDEOCAP_HQ_CAPABLE}, 00920 {__EA(VIDEOCAP_HQ_CERTIFIED), Video::VIDEOCAP_HQ_CERTIFIED}, 00921 {__EA(VIDEOCAP_REQ_DRIVERUPDATE), Video::VIDEOCAP_REQ_DRIVERUPDATE}, 00922 {__EA(VIDEOCAP_USB_HIGHSPEED), Video::VIDEOCAP_USB_HIGHSPEED}, 00923 {0, 0} 00924 }; 00925 00926 namespace Sid { 00927 template<> Sid::String tostring(const Video::VIDEO_DEVICE_CAPABILITY& v) 00928 { 00929 return enumtostring("Video::VIDEO_DEVICE_CAPABILITY",VIDEO_VIDEO_DEVICE_CAPABILITY_MAP,v); 00930 } 00931 } 00932 00933 void Video::OnCaptureRequestCompleted( 00934 __se_unused const uint& /*requestId*/, 00935 __se_unused const bool& /*isSuccessful*/, 00936 __se_unused const Sid::Binary& /*image*/, 00937 __se_unused const int& /*width*/, 00938 __se_unused const int& /*height*/ 00939 ) {} 00940 00941 void Video::OnLastFrameCapture( 00942 __se_unused const Sid::Binary& /*image*/, 00943 __se_unused const uint& /*width*/, 00944 __se_unused const uint& /*height*/ 00945 ) {} 00946 00947 extern const EMAP VIDEO_EMAP[] = { 00948 {Video::P_STATUS, VIDEO_STATUS_MAP}, 00949 {Video::P_MEDIA_TYPE, VIDEO_MEDIATYPE_MAP}, 00950 {0, 0} 00951 }; 00952 const EMAP* Video::getEMap() const 00953 { 00954 return VIDEO_EMAP; 00955 } 00956 const PMAP* Video::getPMap() const 00957 { 00958 return VIDEO_PROPERTY_MAP; 00959 } 00960 00961 00962 /** class Voicemail **********************/ 00963 00964 Voicemail::Voicemail(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 00965 Voicemail::~Voicemail() { } 00966 void Voicemail::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgvmVoicemail*>(cache); } 00967 unsigned int Voicemail::moduleID() const 00968 { 00969 return MODULE_ID; 00970 } 00971 String Voicemail::getNamespace() const 00972 { 00973 return __EA(VOICEMAIL); 00974 } 00975 00976 extern const PMAP VOICEMAIL_PROPERTY_MAP[] = { 00977 {__EA(TYPE), Voicemail::P_TYPE}, 00978 {__EA(PARTNER_HANDLE), Voicemail::P_PARTNER_HANDLE}, 00979 {__EA(PARTNER_DISPNAME), Voicemail::P_PARTNER_DISPNAME}, 00980 {__EA(STATUS), Voicemail::P_STATUS}, 00981 {__EA(FAILUREREASON), Voicemail::P_FAILUREREASON}, 00982 {__EA(SUBJECT), Voicemail::P_SUBJECT}, 00983 {__EA(TIMESTAMP), Voicemail::P_TIMESTAMP}, 00984 {__EA(DURATION), Voicemail::P_DURATION}, 00985 {__EA(ALLOWED_DURATION), Voicemail::P_ALLOWED_DURATION}, 00986 {__EA(PLAYBACK_PROGRESS), Voicemail::P_PLAYBACK_PROGRESS}, 00987 {__EA(CONVO_ID), Voicemail::P_CONVO_ID}, 00988 {__EA(CHATMSG_GUID), Voicemail::P_CHATMSG_GUID}, 00989 {0, 0} 00990 }; 00991 00992 extern const PMAP VOICEMAIL_TYPE_MAP[] = { 00993 {__EA(INCOMING), Voicemail::INCOMING}, 00994 {__EA(DEFAULT_GREETING), Voicemail::DEFAULT_GREETING}, 00995 {__EA(CUSTOM_GREETING), Voicemail::CUSTOM_GREETING}, 00996 {__EA(OUTGOING), Voicemail::OUTGOING}, 00997 {0, 0} 00998 }; 00999 01000 namespace Sid { 01001 template<> Sid::String tostring(const Voicemail::TYPE& v) 01002 { 01003 return enumtostring("Voicemail::TYPE",VOICEMAIL_TYPE_MAP,v); 01004 } 01005 } 01006 01007 extern const PMAP VOICEMAIL_STATUS_MAP[] = { 01008 {__EA(NOTDOWNLOADED), Voicemail::NOTDOWNLOADED}, 01009 {__EA(DOWNLOADING), Voicemail::DOWNLOADING}, 01010 {__EA(UNPLAYED), Voicemail::UNPLAYED}, 01011 {__EA(BUFFERING), Voicemail::BUFFERING}, 01012 {__EA(PLAYING), Voicemail::PLAYING}, 01013 {__EA(PLAYED), Voicemail::PLAYED}, 01014 {__EA(BLANK), Voicemail::BLANK}, 01015 {__EA(RECORDING), Voicemail::RECORDING}, 01016 {__EA(RECORDED), Voicemail::RECORDED}, 01017 {__EA(UPLOADING), Voicemail::UPLOADING}, 01018 {__EA(UPLOADED), Voicemail::UPLOADED}, 01019 {__EA(DELETING), Voicemail::DELETING}, 01020 {__EA(FAILED), Voicemail::FAILED}, 01021 {__EA(DELETING_FAILED), Voicemail::DELETING_FAILED}, 01022 {__EA(CHECKING), Voicemail::CHECKING}, 01023 {__EA(CANCELLED), Voicemail::CANCELLED}, 01024 {0, 0} 01025 }; 01026 01027 namespace Sid { 01028 template<> Sid::String tostring(const Voicemail::STATUS& v) 01029 { 01030 return enumtostring("Voicemail::STATUS",VOICEMAIL_STATUS_MAP,v); 01031 } 01032 } 01033 01034 extern const PMAP VOICEMAIL_FAILUREREASON_MAP[] = { 01035 {__EA(MISC_ERROR), Voicemail::MISC_ERROR}, 01036 {__EA(CONNECT_ERROR), Voicemail::CONNECT_ERROR}, 01037 {__EA(NO_VOICEMAIL_CAPABILITY), Voicemail::NO_VOICEMAIL_CAPABILITY}, 01038 {__EA(NO_SUCH_VOICEMAIL), Voicemail::NO_SUCH_VOICEMAIL}, 01039 {__EA(FILE_READ_ERROR), Voicemail::FILE_READ_ERROR}, 01040 {__EA(FILE_WRITE_ERROR), Voicemail::FILE_WRITE_ERROR}, 01041 {__EA(RECORDING_ERROR), Voicemail::RECORDING_ERROR}, 01042 {__EA(PLAYBACK_ERROR), Voicemail::PLAYBACK_ERROR}, 01043 {__EA(NO_PERMISSION), Voicemail::NO_PERMISSION}, 01044 {__EA(RECEIVER_DISABLED_VOICEMAIL), Voicemail::RECEIVER_DISABLED_VOICEMAIL}, 01045 {__EA(SENDER_NOT_AUTHORIZED), Voicemail::SENDER_NOT_AUTHORIZED}, 01046 {__EA(SENDER_BLOCKED), Voicemail::SENDER_BLOCKED}, 01047 {0, 0} 01048 }; 01049 01050 namespace Sid { 01051 template<> Sid::String tostring(const Voicemail::FAILUREREASON& v) 01052 { 01053 return enumtostring("Voicemail::FAILUREREASON",VOICEMAIL_FAILUREREASON_MAP,v); 01054 } 01055 } 01056 01057 extern const EMAP VOICEMAIL_EMAP[] = { 01058 {Voicemail::P_TYPE, VOICEMAIL_TYPE_MAP}, 01059 {Voicemail::P_STATUS, VOICEMAIL_STATUS_MAP}, 01060 {Voicemail::P_FAILUREREASON, VOICEMAIL_FAILUREREASON_MAP}, 01061 {0, 0} 01062 }; 01063 const EMAP* Voicemail::getEMap() const 01064 { 01065 return VOICEMAIL_EMAP; 01066 } 01067 const PMAP* Voicemail::getPMap() const 01068 { 01069 return VOICEMAIL_PROPERTY_MAP; 01070 } 01071 01072 01073 /** class Sms **********************/ 01074 01075 Sms::Sms(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 01076 Sms::~Sms() { } 01077 void Sms::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgsmsSms*>(cache); } 01078 unsigned int Sms::moduleID() const 01079 { 01080 return MODULE_ID; 01081 } 01082 String Sms::getNamespace() const 01083 { 01084 return __EA(SMS); 01085 } 01086 01087 extern const PMAP SMS_PROPERTY_MAP[] = { 01088 {__EA(TYPE), Sms::P_TYPE}, 01089 {__EA(STATUS), Sms::P_STATUS}, 01090 {__EA(FAILUREREASON), Sms::P_FAILUREREASON}, 01091 {__EA(IS_FAILED_UNSEEN), Sms::P_IS_FAILED_UNSEEN}, 01092 {__EA(TIMESTAMP), Sms::P_TIMESTAMP}, 01093 {__EA(PRICE), Sms::P_PRICE}, 01094 {__EA(PRICE_PRECISION), Sms::P_PRICE_PRECISION}, 01095 {__EA(PRICE_CURRENCY), Sms::P_PRICE_CURRENCY}, 01096 {__EA(REPLY_TO_NUMBER), Sms::P_REPLY_TO_NUMBER}, 01097 {__EA(TARGET_NUMBERS), Sms::P_TARGET_NUMBERS}, 01098 {__EA(TARGET_STATUSES), Sms::P_TARGET_STATUSES}, 01099 {__EA(BODY), Sms::P_BODY}, 01100 {__EA(CHATMSG_ID), Sms::P_CHATMSG_ID}, 01101 {0, 0} 01102 }; 01103 01104 extern const PMAP SMS_TYPE_MAP[] = { 01105 {__EA(OUTGOING), Sms::OUTGOING}, 01106 {__EA(CONFIRMATION_CODE_REQUEST), Sms::CONFIRMATION_CODE_REQUEST}, 01107 {__EA(CONFIRMATION_CODE_SUBMIT), Sms::CONFIRMATION_CODE_SUBMIT}, 01108 {0, 0} 01109 }; 01110 01111 namespace Sid { 01112 template<> Sid::String tostring(const Sms::TYPE& v) 01113 { 01114 return enumtostring("Sms::TYPE",SMS_TYPE_MAP,v); 01115 } 01116 } 01117 01118 extern const PMAP SMS_STATUS_MAP[] = { 01119 {__EA(COMPOSING), Sms::COMPOSING}, 01120 {__EA(SENDING_TO_SERVER), Sms::SENDING_TO_SERVER}, 01121 {__EA(SENT_TO_SERVER), Sms::SENT_TO_SERVER}, 01122 {__EA(DELIVERED), Sms::DELIVERED}, 01123 {__EA(SOME_TARGETS_FAILED), Sms::SOME_TARGETS_FAILED}, 01124 {__EA(FAILED), Sms::FAILED}, 01125 {0, 0} 01126 }; 01127 01128 namespace Sid { 01129 template<> Sid::String tostring(const Sms::STATUS& v) 01130 { 01131 return enumtostring("Sms::STATUS",SMS_STATUS_MAP,v); 01132 } 01133 } 01134 01135 extern const PMAP SMS_FAILUREREASON_MAP[] = { 01136 {__EA(MISC_ERROR), Sms::MISC_ERROR}, 01137 {__EA(SERVER_CONNECT_FAILED), Sms::SERVER_CONNECT_FAILED}, 01138 {__EA(NO_SMS_CAPABILITY), Sms::NO_SMS_CAPABILITY}, 01139 {__EA(INSUFFICIENT_FUNDS), Sms::INSUFFICIENT_FUNDS}, 01140 {__EA(INVALID_CONFIRMATION_CODE), Sms::INVALID_CONFIRMATION_CODE}, 01141 {__EA(USER_BLOCKED), Sms::USER_BLOCKED}, 01142 {__EA(IP_BLOCKED), Sms::IP_BLOCKED}, 01143 {__EA(NODE_BLOCKED), Sms::NODE_BLOCKED}, 01144 {__EA(NO_SENDERID_CAPABILITY), Sms::NO_SENDERID_CAPABILITY}, 01145 {0, 0} 01146 }; 01147 01148 namespace Sid { 01149 template<> Sid::String tostring(const Sms::FAILUREREASON& v) 01150 { 01151 return enumtostring("Sms::FAILUREREASON",SMS_FAILUREREASON_MAP,v); 01152 } 01153 } 01154 01155 extern const PMAP SMS_TARGETSTATUS_MAP[] = { 01156 {__EA(TARGET_ANALYZING), Sms::TARGET_ANALYZING}, 01157 {__EA(TARGET_UNDEFINED), Sms::TARGET_UNDEFINED}, 01158 {__EA(TARGET_ACCEPTABLE), Sms::TARGET_ACCEPTABLE}, 01159 {__EA(TARGET_NOT_ROUTABLE), Sms::TARGET_NOT_ROUTABLE}, 01160 {__EA(TARGET_DELIVERY_PENDING), Sms::TARGET_DELIVERY_PENDING}, 01161 {__EA(TARGET_DELIVERY_SUCCESSFUL), Sms::TARGET_DELIVERY_SUCCESSFUL}, 01162 {__EA(TARGET_DELIVERY_FAILED), Sms::TARGET_DELIVERY_FAILED}, 01163 {0, 0} 01164 }; 01165 01166 namespace Sid { 01167 template<> Sid::String tostring(const Sms::TARGETSTATUS& v) 01168 { 01169 return enumtostring("Sms::TARGETSTATUS",SMS_TARGETSTATUS_MAP,v); 01170 } 01171 } 01172 01173 extern const PMAP SMS_SETBODYRESULT_MAP[] = { 01174 {__EA(BODY_INVALID), Sms::BODY_INVALID}, 01175 {__EA(BODY_TRUNCATED), Sms::BODY_TRUNCATED}, 01176 {__EA(BODY_OK), Sms::BODY_OK}, 01177 {__EA(BODY_LASTCHAR_IGNORED), Sms::BODY_LASTCHAR_IGNORED}, 01178 {0, 0} 01179 }; 01180 01181 namespace Sid { 01182 template<> Sid::String tostring(const Sms::SETBODYRESULT& v) 01183 { 01184 return enumtostring("Sms::SETBODYRESULT",SMS_SETBODYRESULT_MAP,v); 01185 } 01186 } 01187 01188 extern const PMAP SMS_CONFIRM_TYPE_MAP[] = { 01189 {__EA(ID_SMS), Sms::ID_SMS}, 01190 {__EA(ID_MOBILE), Sms::ID_MOBILE}, 01191 {__EA(ID_SKYPEIN), Sms::ID_SKYPEIN}, 01192 {0, 0} 01193 }; 01194 01195 namespace Sid { 01196 template<> Sid::String tostring(const Sms::CONFIRM_TYPE& v) 01197 { 01198 return enumtostring("Sms::CONFIRM_TYPE",SMS_CONFIRM_TYPE_MAP,v); 01199 } 01200 } 01201 01202 extern const EMAP SMS_EMAP[] = { 01203 {Sms::P_TYPE, SMS_TYPE_MAP}, 01204 {Sms::P_STATUS, SMS_STATUS_MAP}, 01205 {Sms::P_FAILUREREASON, SMS_FAILUREREASON_MAP}, 01206 {0, 0} 01207 }; 01208 const EMAP* Sms::getEMap() const 01209 { 01210 return SMS_EMAP; 01211 } 01212 const PMAP* Sms::getPMap() const 01213 { 01214 return SMS_PROPERTY_MAP; 01215 } 01216 01217 01218 /** class Transfer **********************/ 01219 01220 Transfer::Transfer(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 01221 Transfer::~Transfer() { } 01222 void Transfer::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgftTransfer*>(cache); } 01223 unsigned int Transfer::moduleID() const 01224 { 01225 return MODULE_ID; 01226 } 01227 String Transfer::getNamespace() const 01228 { 01229 return __EA(TRANSFER); 01230 } 01231 01232 extern const PMAP TRANSFER_PROPERTY_MAP[] = { 01233 {__EA(TYPE), Transfer::P_TYPE}, 01234 {__EA(PARTNER_HANDLE), Transfer::P_PARTNER_HANDLE}, 01235 {__EA(PARTNER_DISPNAME), Transfer::P_PARTNER_DISPNAME}, 01236 {__EA(STATUS), Transfer::P_STATUS}, 01237 {__EA(FAILUREREASON), Transfer::P_FAILUREREASON}, 01238 {__EA(STARTTIME), Transfer::P_STARTTIME}, 01239 {__EA(FINISHTIME), Transfer::P_FINISHTIME}, 01240 {__EA(FILEPATH), Transfer::P_FILEPATH}, 01241 {__EA(FILENAME), Transfer::P_FILENAME}, 01242 {__EA(FILESIZE), Transfer::P_FILESIZE}, 01243 {__EA(BYTESTRANSFERRED), Transfer::P_BYTESTRANSFERRED}, 01244 {__EA(BYTESPERSECOND), Transfer::P_BYTESPERSECOND}, 01245 {__EA(CHATMSG_GUID), Transfer::P_CHATMSG_GUID}, 01246 {__EA(CHATMSG_INDEX), Transfer::P_CHATMSG_INDEX}, 01247 {__EA(CONVO_ID), Transfer::P_CONVO_ID}, 01248 {0, 0} 01249 }; 01250 01251 extern const PMAP TRANSFER_TYPE_MAP[] = { 01252 {__EA(INCOMING), Transfer::INCOMING}, 01253 {__EA(OUTGOING), Transfer::OUTGOING}, 01254 {0, 0} 01255 }; 01256 01257 namespace Sid { 01258 template<> Sid::String tostring(const Transfer::TYPE& v) 01259 { 01260 return enumtostring("Transfer::TYPE",TRANSFER_TYPE_MAP,v); 01261 } 01262 } 01263 01264 extern const PMAP TRANSFER_STATUS_MAP[] = { 01265 {__EA(NEW), Transfer::NEW}, 01266 {__EA(CONNECTING), Transfer::CONNECTING}, 01267 {__EA(WAITING_FOR_ACCEPT), Transfer::WAITING_FOR_ACCEPT}, 01268 {__EA(TRANSFERRING), Transfer::TRANSFERRING}, 01269 {__EA(TRANSFERRING_OVER_RELAY), Transfer::TRANSFERRING_OVER_RELAY}, 01270 {__EA(PAUSED), Transfer::PAUSED}, 01271 {__EA(REMOTELY_PAUSED), Transfer::REMOTELY_PAUSED}, 01272 {__EA(CANCELLED), Transfer::CANCELLED}, 01273 {__EA(COMPLETED), Transfer::COMPLETED}, 01274 {__EA(FAILED), Transfer::FAILED}, 01275 {__EA(PLACEHOLDER), Transfer::PLACEHOLDER}, 01276 {__EA(OFFER_FROM_OTHER_INSTANCE), Transfer::OFFER_FROM_OTHER_INSTANCE}, 01277 {__EA(CANCELLED_BY_REMOTE), Transfer::CANCELLED_BY_REMOTE}, 01278 {0, 0} 01279 }; 01280 01281 namespace Sid { 01282 template<> Sid::String tostring(const Transfer::STATUS& v) 01283 { 01284 return enumtostring("Transfer::STATUS",TRANSFER_STATUS_MAP,v); 01285 } 01286 } 01287 01288 extern const PMAP TRANSFER_FAILUREREASON_MAP[] = { 01289 {__EA(SENDER_NOT_AUTHORISED), Transfer::SENDER_NOT_AUTHORISED}, 01290 {__EA(REMOTELY_CANCELLED), Transfer::REMOTELY_CANCELLED}, 01291 {__EA(FAILED_READ), Transfer::FAILED_READ}, 01292 {__EA(FAILED_REMOTE_READ), Transfer::FAILED_REMOTE_READ}, 01293 {__EA(FAILED_WRITE), Transfer::FAILED_WRITE}, 01294 {__EA(FAILED_REMOTE_WRITE), Transfer::FAILED_REMOTE_WRITE}, 01295 {__EA(REMOTE_DOES_NOT_SUPPORT_FT), Transfer::REMOTE_DOES_NOT_SUPPORT_FT}, 01296 {__EA(REMOTE_OFFLINE_FOR_TOO_LONG), Transfer::REMOTE_OFFLINE_FOR_TOO_LONG}, 01297 {__EA(TOO_MANY_PARALLEL), Transfer::TOO_MANY_PARALLEL}, 01298 {__EA(PLACEHOLDER_TIMEOUT), Transfer::PLACEHOLDER_TIMEOUT}, 01299 {0, 0} 01300 }; 01301 01302 namespace Sid { 01303 template<> Sid::String tostring(const Transfer::FAILUREREASON& v) 01304 { 01305 return enumtostring("Transfer::FAILUREREASON",TRANSFER_FAILUREREASON_MAP,v); 01306 } 01307 } 01308 01309 extern const EMAP TRANSFER_EMAP[] = { 01310 {Transfer::P_TYPE, TRANSFER_TYPE_MAP}, 01311 {Transfer::P_STATUS, TRANSFER_STATUS_MAP}, 01312 {Transfer::P_FAILUREREASON, TRANSFER_FAILUREREASON_MAP}, 01313 {0, 0} 01314 }; 01315 const EMAP* Transfer::getEMap() const 01316 { 01317 return TRANSFER_EMAP; 01318 } 01319 const PMAP* Transfer::getPMap() const 01320 { 01321 return TRANSFER_PROPERTY_MAP; 01322 } 01323 01324 01325 /** class Account **********************/ 01326 01327 Account::Account(unsigned int oid, SERootObject* root_obj) :SEObject(oid, root_obj) {} 01328 Account::~Account() { } 01329 void Account::__clear_cache(void* cache) { if (cache) delete reinterpret_cast<MsgaccountAccount*>(cache); } 01330 unsigned int Account::moduleID() const 01331 { 01332 return MODULE_ID; 01333 } 01334 String Account::getNamespace() const 01335 { 01336 return __EA(ACCOUNT); 01337 } 01338 01339 extern const PMAP ACCOUNT_PROPERTY_MAP[] = { 01340 {__EA(STATUS), Account::P_STATUS}, 01341 {__EA(PWDCHANGESTATUS), Account::P_PWDCHANGESTATUS}, 01342 {__EA(LOGOUTREASON), Account::P_LOGOUTREASON}, 01343 {__EA(COMMITSTATUS), Account::P_COMMITSTATUS}, 01344 {__EA(SUGGESTED_SKYPENAME), Account::P_SUGGESTED_SKYPENAME}, 01345 {__EA(SKYPEOUT_BALANCE_CURRENCY), Account::P_SKYPEOUT_BALANCE_CURRENCY}, 01346 {__EA(SKYPEOUT_BALANCE), Account::P_SKYPEOUT_BALANCE}, 01347 {__EA(SKYPEOUT_PRECISION), Account::P_SKYPEOUT_PRECISION}, 01348 {__EA(SKYPEIN_NUMBERS), Account::P_SKYPEIN_NUMBERS}, 01349 {__EA(CBLSYNCSTATUS), Account::P_CBLSYNCSTATUS}, 01350 {__EA(OFFLINE_CALLFORWARD), Account::P_OFFLINE_CALLFORWARD}, 01351 {__EA(CHAT_POLICY), Account::P_CHAT_POLICY}, 01352 {__EA(SKYPE_CALL_POLICY), Account::P_SKYPE_CALL_POLICY}, 01353 {__EA(PSTN_CALL_POLICY), Account::P_PSTN_CALL_POLICY}, 01354 {__EA(AVATAR_POLICY), Account::P_AVATAR_POLICY}, 01355 {__EA(BUDDYCOUNT_POLICY), Account::P_BUDDYCOUNT_POLICY}, 01356 {__EA(TIMEZONE_POLICY), Account::P_TIMEZONE_POLICY}, 01357 {__EA(WEBPRESENCE_POLICY), Account::P_WEBPRESENCE_POLICY}, 01358 {__EA(PHONENUMBERS_POLICY), Account::P_PHONENUMBERS_POLICY}, 01359 {__EA(VOICEMAIL_POLICY), Account::P_VOICEMAIL_POLICY}, 01360 {__EA(PARTNER_OPTEDOUT), Account::P_PARTNER_OPTEDOUT}, 01361 {__EA(SERVICE_PROVIDER_INFO), Account::P_SERVICE_PROVIDER_INFO}, 01362 {__EA(REGISTRATION_TIMESTAMP), Account::P_REGISTRATION_TIMESTAMP}, 01363 {__EA(NR_OF_OTHER_INSTANCES), Account::P_NR_OF_OTHER_INSTANCES}, 01364 {__EA(SKYPENAME), Account::P_SKYPENAME}, 01365 {__EA(FULLNAME), Account::P_FULLNAME}, 01366 {__EA(BIRTHDAY), Account::P_BIRTHDAY}, 01367 {__EA(GENDER), Account::P_GENDER}, 01368 {__EA(LANGUAGES), Account::P_LANGUAGES}, 01369 {__EA(COUNTRY), Account::P_COUNTRY}, 01370 {__EA(PROVINCE), Account::P_PROVINCE}, 01371 {__EA(CITY), Account::P_CITY}, 01372 {__EA(PHONE_HOME), Account::P_PHONE_HOME}, 01373 {__EA(PHONE_OFFICE), Account::P_PHONE_OFFICE}, 01374 {__EA(PHONE_MOBILE), Account::P_PHONE_MOBILE}, 01375 {__EA(EMAILS), Account::P_EMAILS}, 01376 {__EA(HOMEPAGE), Account::P_HOMEPAGE}, 01377 {__EA(ABOUT), Account::P_ABOUT}, 01378 {__EA(PROFILE_TIMESTAMP), Account::P_PROFILE_TIMESTAMP}, 01379 {__EA(MOOD_TEXT), Account::P_MOOD_TEXT}, 01380 {__EA(TIMEZONE), Account::P_TIMEZONE}, 01381 {__EA(NROF_AUTHED_BUDDIES), Account::P_NROF_AUTHED_BUDDIES}, 01382 {__EA(AVAILABILITY), Account::P_AVAILABILITY}, 01383 {__EA(AVATAR_IMAGE), Account::P_AVATAR_IMAGE}, 01384 {__EA(AVATAR_TIMESTAMP), Account::P_AVATAR_TIMESTAMP}, 01385 {__EA(MOOD_TIMESTAMP), Account::P_MOOD_TIMESTAMP}, 01386 {__EA(RICH_MOOD_TEXT), Account::P_RICH_MOOD_TEXT}, 01387 {0, 0} 01388 }; 01389 01390 extern const PMAP ACCOUNT_STATUS_MAP[] = { 01391 {__EA(LOGGED_OUT), Account::LOGGED_OUT}, 01392 {__EA(LOGGED_OUT_AND_PWD_SAVED), Account::LOGGED_OUT_AND_PWD_SAVED}, 01393 {__EA(CONNECTING_TO_P2P), Account::CONNECTING_TO_P2P}, 01394 {__EA(CONNECTING_TO_SERVER), Account::CONNECTING_TO_SERVER}, 01395 {__EA(LOGGING_IN), Account::LOGGING_IN}, 01396 {__EA(INITIALIZING), Account::INITIALIZING}, 01397 {__EA(LOGGED_IN), Account::LOGGED_IN}, 01398 {__EA(LOGGING_OUT), Account::LOGGING_OUT}, 01399 {0, 0} 01400 }; 01401 01402 namespace Sid { 01403 template<> Sid::String tostring(const Account::STATUS& v) 01404 { 01405 return enumtostring("Account::STATUS",ACCOUNT_STATUS_MAP,v); 01406 } 01407 } 01408 01409 extern const PMAP ACCOUNT_CBLSYNCSTATUS_MAP[] = { 01410 {__EA(CBL_INITIALIZING), Account::CBL_INITIALIZING}, 01411 {__EA(CBL_INITIAL_SYNC_PENDING), Account::CBL_INITIAL_SYNC_PENDING}, 01412 {__EA(CBL_SYNC_PENDING), Account::CBL_SYNC_PENDING}, 01413 {__EA(CBL_SYNC_IN_PROGRESS), Account::CBL_SYNC_IN_PROGRESS}, 01414 {__EA(CBL_IN_SYNC), Account::CBL_IN_SYNC}, 01415 {__EA(CBL_SYNC_FAILED), Account::CBL_SYNC_FAILED}, 01416 {__EA(CBL_REMOTE_SYNC_PENDING), Account::CBL_REMOTE_SYNC_PENDING}, 01417 {0, 0} 01418 }; 01419 01420 namespace Sid { 01421 template<> Sid::String tostring(const Account::CBLSYNCSTATUS& v) 01422 { 01423 return enumtostring("Account::CBLSYNCSTATUS",ACCOUNT_CBLSYNCSTATUS_MAP,v); 01424 } 01425 } 01426 01427 extern const PMAP ACCOUNT_LOGOUTREASON_MAP[] = { 01428 {__EA(LOGOUT_CALLED), Account::LOGOUT_CALLED}, 01429 {__EA(HTTPS_PROXY_AUTH_FAILED), Account::HTTPS_PROXY_AUTH_FAILED}, 01430 {__EA(SOCKS_PROXY_AUTH_FAILED), Account::SOCKS_PROXY_AUTH_FAILED}, 01431 {__EA(P2P_CONNECT_FAILED), Account::P2P_CONNECT_FAILED}, 01432 {__EA(SERVER_CONNECT_FAILED), Account::SERVER_CONNECT_FAILED}, 01433 {__EA(SERVER_OVERLOADED), Account::SERVER_OVERLOADED}, 01434 {__EA(DB_IN_USE), Account::DB_IN_USE}, 01435 {__EA(INVALID_SKYPENAME), Account::INVALID_SKYPENAME}, 01436 {__EA(INVALID_EMAIL), Account::INVALID_EMAIL}, 01437 {__EA(UNACCEPTABLE_PASSWORD), Account::UNACCEPTABLE_PASSWORD}, 01438 {__EA(SKYPENAME_TAKEN), Account::SKYPENAME_TAKEN}, 01439 {__EA(REJECTED_AS_UNDERAGE), Account::REJECTED_AS_UNDERAGE}, 01440 {__EA(NO_SUCH_IDENTITY), Account::NO_SUCH_IDENTITY}, 01441 {__EA(INCORRECT_PASSWORD), Account::INCORRECT_PASSWORD}, 01442 {__EA(TOO_MANY_LOGIN_ATTEMPTS), Account::TOO_MANY_LOGIN_ATTEMPTS}, 01443 {__EA(PASSWORD_HAS_CHANGED), Account::PASSWORD_HAS_CHANGED}, 01444 {__EA(PERIODIC_UIC_UPDATE_FAILED), Account::PERIODIC_UIC_UPDATE_FAILED}, 01445 {__EA(DB_DISK_FULL), Account::DB_DISK_FULL}, 01446 {__EA(DB_IO_ERROR), Account::DB_IO_ERROR}, 01447 {__EA(DB_CORRUPT), Account::DB_CORRUPT}, 01448 {__EA(DB_FAILURE), Account::DB_FAILURE}, 01449 {__EA(INVALID_APP_ID), Account::INVALID_APP_ID}, 01450 {__EA(APP_ID_FAILURE), Account::APP_ID_FAILURE}, 01451 {__EA(UNSUPPORTED_VERSION), Account::UNSUPPORTED_VERSION}, 01452 {0, 0} 01453 }; 01454 01455 namespace Sid { 01456 template<> Sid::String tostring(const Account::LOGOUTREASON& v) 01457 { 01458 return enumtostring("Account::LOGOUTREASON",ACCOUNT_LOGOUTREASON_MAP,v); 01459 } 01460 } 01461 01462 extern const PMAP ACCOUNT_PWDCHANGESTATUS_MAP[] = { 01463 {__EA(PWD_OK), Account::PWD_OK}, 01464 {__EA(PWD_CHANGING), Account::PWD_CHANGING}, 01465 {__EA(PWD_INVALID_OLD_PASSWORD), Account::PWD_INVALID_OLD_PASSWORD}, 01466 {__EA(PWD_SERVER_CONNECT_FAILED), Account::PWD_SERVER_CONNECT_FAILED}, 01467 {__EA(PWD_OK_BUT_CHANGE_SUGGESTED), Account::PWD_OK_BUT_CHANGE_SUGGESTED}, 01468 {__EA(PWD_MUST_DIFFER_FROM_OLD), Account::PWD_MUST_DIFFER_FROM_OLD}, 01469 {__EA(PWD_INVALID_NEW_PWD), Account::PWD_INVALID_NEW_PWD}, 01470 {__EA(PWD_MUST_LOG_IN_TO_CHANGE), Account::PWD_MUST_LOG_IN_TO_CHANGE}, 01471 {0, 0} 01472 }; 01473 01474 namespace Sid { 01475 template<> Sid::String tostring(const Account::PWDCHANGESTATUS& v) 01476 { 01477 return enumtostring("Account::PWDCHANGESTATUS",ACCOUNT_PWDCHANGESTATUS_MAP,v); 01478 } 01479 } 01480 01481 extern const PMAP ACCOUNT_COMMITSTATUS_MAP[] = { 01482 {__EA(COMMITTED), Account::COMMITTED}, 01483 {__EA(COMMITTING_TO_SERVER), Account::COMMITTING_TO_SERVER}, 01484 {__EA(COMMIT_FAILED), Account::COMMIT_FAILED}, 01485 {0, 0} 01486 }; 01487 01488 namespace Sid { 01489 template<> Sid::String tostring(const Account::COMMITSTATUS& v) 01490 { 01491 return enumtostring("Account::COMMITSTATUS",ACCOUNT_COMMITSTATUS_MAP,v); 01492 } 01493 } 01494 01495 extern const PMAP ACCOUNT_CHATPOLICY_MAP[] = { 01496 {__EA(EVERYONE_CAN_ADD), Account::EVERYONE_CAN_ADD}, 01497 {__EA(BUDDIES_OR_AUTHORIZED_CAN_ADD), Account::BUDDIES_OR_AUTHORIZED_CAN_ADD}, 01498 {0, 0} 01499 }; 01500 01501 namespace Sid { 01502 template<> Sid::String tostring(const Account::CHATPOLICY& v) 01503 { 01504 return enumtostring("Account::CHATPOLICY",ACCOUNT_CHATPOLICY_MAP,v); 01505 } 01506 } 01507 01508 extern const PMAP ACCOUNT_SKYPECALLPOLICY_MAP[] = { 01509 {__EA(EVERYONE_CAN_CALL), Account::EVERYONE_CAN_CALL}, 01510 {__EA(BUDDIES_OR_AUTHORIZED_CAN_CALL), Account::BUDDIES_OR_AUTHORIZED_CAN_CALL}, 01511 {0, 0} 01512 }; 01513 01514 namespace Sid { 01515 template<> Sid::String tostring(const Account::SKYPECALLPOLICY& v) 01516 { 01517 return enumtostring("Account::SKYPECALLPOLICY",ACCOUNT_SKYPECALLPOLICY_MAP,v); 01518 } 01519 } 01520 01521 extern const PMAP ACCOUNT_PSTNCALLPOLICY_MAP[] = { 01522 {__EA(ALL_NUMBERS_CAN_CALL), Account::ALL_NUMBERS_CAN_CALL}, 01523 {__EA(DISCLOSED_NUMBERS_CAN_CALL), Account::DISCLOSED_NUMBERS_CAN_CALL}, 01524 {__EA(BUDDY_NUMBERS_CAN_CALL), Account::BUDDY_NUMBERS_CAN_CALL}, 01525 {0, 0} 01526 }; 01527 01528 namespace Sid { 01529 template<> Sid::String tostring(const Account::PSTNCALLPOLICY& v) 01530 { 01531 return enumtostring("Account::PSTNCALLPOLICY",ACCOUNT_PSTNCALLPOLICY_MAP,v); 01532 } 01533 } 01534 01535 extern const PMAP ACCOUNT_AVATARPOLICY_MAP[] = { 01536 {__EA(BUDDIES_OR_AUTHORIZED_CAN_SEE), Account::BUDDIES_OR_AUTHORIZED_CAN_SEE}, 01537 {__EA(EVERYONE_CAN_SEE), Account::EVERYONE_CAN_SEE}, 01538 {0, 0} 01539 }; 01540 01541 namespace Sid { 01542 template<> Sid::String tostring(const Account::AVATARPOLICY& v) 01543 { 01544 return enumtostring("Account::AVATARPOLICY",ACCOUNT_AVATARPOLICY_MAP,v); 01545 } 01546 } 01547 01548 extern const PMAP ACCOUNT_BUDDYCOUNTPOLICY_MAP[] = { 01549 {__EA(DISCLOSE_TO_AUTHORIZED), Account::DISCLOSE_TO_AUTHORIZED}, 01550 {__EA(DISCLOSE_TO_NOONE), Account::DISCLOSE_TO_NOONE}, 01551 {0, 0} 01552 }; 01553 01554 namespace Sid { 01555 template<> Sid::String tostring(const Account::BUDDYCOUNTPOLICY& v) 01556 { 01557 return enumtostring("Account::BUDDYCOUNTPOLICY",ACCOUNT_BUDDYCOUNTPOLICY_MAP,v); 01558 } 01559 } 01560 01561 extern const PMAP ACCOUNT_TIMEZONEPOLICY_MAP[] = { 01562 {__EA(TZ_AUTOMATIC), Account::TZ_AUTOMATIC}, 01563 {__EA(TZ_MANUAL), Account::TZ_MANUAL}, 01564 {__EA(TZ_UNDISCLOSED), Account::TZ_UNDISCLOSED}, 01565 {0, 0} 01566 }; 01567 01568 namespace Sid { 01569 template<> Sid::String tostring(const Account::TIMEZONEPOLICY& v) 01570 { 01571 return enumtostring("Account::TIMEZONEPOLICY",ACCOUNT_TIMEZONEPOLICY_MAP,v); 01572 } 01573 } 01574 01575 extern const PMAP ACCOUNT_WEBPRESENCEPOLICY_MAP[] = { 01576 {__EA(WEBPRESENCE_DISABLED), Account::WEBPRESENCE_DISABLED}, 01577 {__EA(WEBPRESENCE_ENABLED), Account::WEBPRESENCE_ENABLED}, 01578 {0, 0} 01579 }; 01580 01581 namespace Sid { 01582 template<> Sid::String tostring(const Account::WEBPRESENCEPOLICY& v) 01583 { 01584 return enumtostring("Account::WEBPRESENCEPOLICY",ACCOUNT_WEBPRESENCEPOLICY_MAP,v); 01585 } 01586 } 01587 01588 extern const PMAP ACCOUNT_PHONENUMBERSPOLICY_MAP[] = { 01589 {__EA(PHONENUMBERS_VISIBLE_FOR_BUDDIES), Account::PHONENUMBERS_VISIBLE_FOR_BUDDIES}, 01590 {__EA(PHONENUMBERS_VISIBLE_FOR_EVERYONE), Account::PHONENUMBERS_VISIBLE_FOR_EVERYONE}, 01591 {0, 0} 01592 }; 01593 01594 namespace Sid { 01595 template<> Sid::String tostring(const Account::PHONENUMBERSPOLICY& v) 01596 { 01597 return enumtostring("Account::PHONENUMBERSPOLICY",ACCOUNT_PHONENUMBERSPOLICY_MAP,v); 01598 } 01599 } 01600 01601 extern const PMAP ACCOUNT_VOICEMAILPOLICY_MAP[] = { 01602 {__EA(VOICEMAIL_ENABLED), Account::VOICEMAIL_ENABLED}, 01603 {__EA(VOICEMAIL_DISABLED), Account::VOICEMAIL_DISABLED}, 01604 {0, 0} 01605 }; 01606 01607 namespace Sid { 01608 template<> Sid::String tostring(const Account::VOICEMAILPOLICY& v) 01609 { 01610 return enumtostring("Account::VOICEMAILPOLICY",ACCOUNT_VOICEMAILPOLICY_MAP,v); 01611 } 01612 } 01613 01614 extern const PMAP ACCOUNT_CAPABILITYSTATUS_MAP[] = { 01615 {__EA(NO_CAPABILITY), Account::NO_CAPABILITY}, 01616 {__EA(CAPABILITY_EXISTS), Account::CAPABILITY_EXISTS}, 01617 {__EA(FIRST_EXPIRY_WARNING), Account::FIRST_EXPIRY_WARNING}, 01618 {__EA(SECOND_EXPIRY_WARNING), Account::SECOND_EXPIRY_WARNING}, 01619 {__EA(FINAL_EXPIRY_WARNING), Account::FINAL_EXPIRY_WARNING}, 01620 {0, 0} 01621 }; 01622 01623 namespace Sid { 01624 template<> Sid::String tostring(const Account::CAPABILITYSTATUS& v) 01625 { 01626 return enumtostring("Account::CAPABILITYSTATUS",ACCOUNT_CAPABILITYSTATUS_MAP,v); 01627 } 01628 } 01629 01630 extern const EMAP ACCOUNT_EMAP[] = { 01631 {Account::P_STATUS, ACCOUNT_STATUS_MAP}, 01632 {Account::P_PWDCHANGESTATUS, ACCOUNT_PWDCHANGESTATUS_MAP}, 01633 {Account::P_LOGOUTREASON, ACCOUNT_LOGOUTREASON_MAP}, 01634 {Account::P_COMMITSTATUS, ACCOUNT_COMMITSTATUS_MAP}, 01635 {Account::P_CBLSYNCSTATUS, ACCOUNT_CBLSYNCSTATUS_MAP}, 01636 {Account::P_CHAT_POLICY, ACCOUNT_CHATPOLICY_MAP}, 01637 {Account::P_SKYPE_CALL_POLICY, ACCOUNT_SKYPECALLPOLICY_MAP}, 01638 {Account::P_PSTN_CALL_POLICY, ACCOUNT_PSTNCALLPOLICY_MAP}, 01639 {Account::P_AVATAR_POLICY, ACCOUNT_AVATARPOLICY_MAP}, 01640 {Account::P_BUDDYCOUNT_POLICY, ACCOUNT_BUDDYCOUNTPOLICY_MAP}, 01641 {Account::P_TIMEZONE_POLICY, ACCOUNT_TIMEZONEPOLICY_MAP}, 01642 {Account::P_WEBPRESENCE_POLICY, ACCOUNT_WEBPRESENCEPOLICY_MAP}, 01643 {Account::P_PHONENUMBERS_POLICY, ACCOUNT_PHONENUMBERSPOLICY_MAP}, 01644 {Account::P_VOICEMAIL_POLICY, ACCOUNT_VOICEMAILPOLICY_MAP}, 01645 {Account::P_AVAILABILITY, CONTACT_AVAILABILITY_MAP}, 01646 {0, 0} 01647 }; 01648 const EMAP* Account::getEMap() const 01649 { 01650 return ACCOUNT_EMAP; 01651 } 01652 const PMAP* Account::getPMap() const 01653 { 01654 return ACCOUNT_PROPERTY_MAP; 01655 } 01656 01657 void Skype::OnNewCustomContactGroup( 01658 __se_unused const ContactGroupRef& /*group*/ 01659 ) {} 01660 01661 extern const PMAP SKYPE_IDENTITYTYPE_MAP[] = { 01662 {__EA(UNRECOGNIZED), Skype::UNRECOGNIZED}, 01663 {__EA(SKYPE), Skype::SKYPE}, 01664 {__EA(SKYPE_MYSELF), Skype::SKYPE_MYSELF}, 01665 {__EA(SKYPE_UNDISCLOSED), Skype::SKYPE_UNDISCLOSED}, 01666 {__EA(PSTN), Skype::PSTN}, 01667 {__EA(PSTN_EMERGENCY), Skype::PSTN_EMERGENCY}, 01668 {__EA(PSTN_FREE), Skype::PSTN_FREE}, 01669 {__EA(PSTN_UNDISCLOSED), Skype::PSTN_UNDISCLOSED}, 01670 {__EA(CONFERENCE), Skype::CONFERENCE}, 01671 {__EA(EXTERNAL), Skype::EXTERNAL}, 01672 {0, 0} 01673 }; 01674 01675 namespace Sid { 01676 template<> Sid::String tostring(const Skype::IDENTITYTYPE& v) 01677 { 01678 return enumtostring("Skype::IDENTITYTYPE",SKYPE_IDENTITYTYPE_MAP,v); 01679 } 01680 } 01681 01682 extern const PMAP SKYPE_NORMALIZERESULT_MAP[] = { 01683 {__EA(IDENTITY_OK), Skype::IDENTITY_OK}, 01684 {__EA(IDENTITY_EMPTY), Skype::IDENTITY_EMPTY}, 01685 {__EA(IDENTITY_TOO_LONG), Skype::IDENTITY_TOO_LONG}, 01686 {__EA(IDENTITY_CONTAINS_INVALID_CHAR), Skype::IDENTITY_CONTAINS_INVALID_CHAR}, 01687 {__EA(PSTN_NUMBER_TOO_SHORT), Skype::PSTN_NUMBER_TOO_SHORT}, 01688 {__EA(PSTN_NUMBER_HAS_INVALID_PREFIX), Skype::PSTN_NUMBER_HAS_INVALID_PREFIX}, 01689 {__EA(SKYPENAME_STARTS_WITH_NONALPHA), Skype::SKYPENAME_STARTS_WITH_NONALPHA}, 01690 {__EA(SKYPENAME_SHORTER_THAN_6_CHARS), Skype::SKYPENAME_SHORTER_THAN_6_CHARS}, 01691 {0, 0} 01692 }; 01693 01694 namespace Sid { 01695 template<> Sid::String tostring(const Skype::NORMALIZERESULT& v) 01696 { 01697 return enumtostring("Skype::NORMALIZERESULT",SKYPE_NORMALIZERESULT_MAP,v); 01698 } 01699 } 01700 01701 void Skype::OnContactOnlineAppearance( 01702 __se_unused const ContactRef& /*contact*/ 01703 ) {} 01704 01705 void Skype::OnContactGoneOffline( 01706 __se_unused const ContactRef& /*contact*/ 01707 ) {} 01708 01709 void Skype::OnConversationListChange( 01710 __se_unused const ConversationRef& /*conversation*/, 01711 __se_unused const Conversation::LIST_TYPE& /*type*/, 01712 __se_unused const bool& /*added*/ 01713 ) {} 01714 01715 void Skype::OnMessage( 01716 __se_unused const MessageRef& /*message*/, 01717 __se_unused const bool& /*changesInboxTimestamp*/, 01718 __se_unused const MessageRef& /*supersedesHistoryMessage*/, 01719 __se_unused const ConversationRef& /*conversation*/ 01720 ) {} 01721 01722 void Skype::OnAvailableVideoDeviceListChange( 01723 ) {} 01724 01725 extern const PMAP SKYPE_PREPARESOUNDRESULT_MAP[] = { 01726 {__EA(PREPARESOUND_SUCCESS), Skype::PREPARESOUND_SUCCESS}, 01727 {__EA(PREPARESOUND_MISC_ERROR), Skype::PREPARESOUND_MISC_ERROR}, 01728 {__EA(PREPARESOUND_FILE_NOT_FOUND), Skype::PREPARESOUND_FILE_NOT_FOUND}, 01729 {__EA(PREPARESOUND_FILE_TOO_BIG), Skype::PREPARESOUND_FILE_TOO_BIG}, 01730 {__EA(PREPARESOUND_FILE_READ_ERROR), Skype::PREPARESOUND_FILE_READ_ERROR}, 01731 {__EA(PREPARESOUND_UNSUPPORTED_FILE_FORMAT), Skype::PREPARESOUND_UNSUPPORTED_FILE_FORMAT}, 01732 {__EA(PREPARESOUND_PLAYBACK_NOT_SUPPORTED), Skype::PREPARESOUND_PLAYBACK_NOT_SUPPORTED}, 01733 {0, 0} 01734 }; 01735 01736 namespace Sid { 01737 template<> Sid::String tostring(const Skype::PREPARESOUNDRESULT& v) 01738 { 01739 return enumtostring("Skype::PREPARESOUNDRESULT",SKYPE_PREPARESOUNDRESULT_MAP,v); 01740 } 01741 } 01742 01743 extern const PMAP SKYPE_AUDIODEVICE_CAPABILITIES_MAP[] = { 01744 {__EA(HAS_VIDEO_CAPTURE), Skype::HAS_VIDEO_CAPTURE}, 01745 {__EA(HAS_USB_INTERFACE), Skype::HAS_USB_INTERFACE}, 01746 {__EA(POSSIBLY_HEADSET), Skype::POSSIBLY_HEADSET}, 01747 {__EA(HAS_AUDIO_CAPTURE), Skype::HAS_AUDIO_CAPTURE}, 01748 {__EA(HAS_AUDIO_RENDERING), Skype::HAS_AUDIO_RENDERING}, 01749 {__EA(HAS_LOWBANDWIDTH_CAPTURE), Skype::HAS_LOWBANDWIDTH_CAPTURE}, 01750 {__EA(IS_WEBCAM), Skype::IS_WEBCAM}, 01751 {__EA(IS_HEADSET), Skype::IS_HEADSET}, 01752 {__EA(POSSIBLY_WEBCAM), Skype::POSSIBLY_WEBCAM}, 01753 {__EA(HAS_VIDEO_RENDERING), Skype::HAS_VIDEO_RENDERING}, 01754 {__EA(HAS_BLUETOOTH_INTERFACE), Skype::HAS_BLUETOOTH_INTERFACE}, 01755 {0, 0} 01756 }; 01757 01758 namespace Sid { 01759 template<> Sid::String tostring(const Skype::AUDIODEVICE_CAPABILITIES& v) 01760 { 01761 return enumtostring("Skype::AUDIODEVICE_CAPABILITIES",SKYPE_AUDIODEVICE_CAPABILITIES_MAP,v); 01762 } 01763 } 01764 01765 void Skype::OnAvailableDeviceListChange( 01766 ) {} 01767 01768 void Skype::OnNrgLevelsChange( 01769 ) {} 01770 01771 extern const PMAP SKYPE_OPERATING_MEDIA_MAP[] = { 01772 {__EA(OM_UNKNOWN), Skype::OM_UNKNOWN}, 01773 {__EA(OM_FREE), Skype::OM_FREE}, 01774 {__EA(OM_FREE_WIRELESS), Skype::OM_FREE_WIRELESS}, 01775 {__EA(OM_3G), Skype::OM_3G}, 01776 {__EA(OM_4G), Skype::OM_4G}, 01777 {0, 0} 01778 }; 01779 01780 namespace Sid { 01781 template<> Sid::String tostring(const Skype::OPERATING_MEDIA& v) 01782 { 01783 return enumtostring("Skype::OPERATING_MEDIA",SKYPE_OPERATING_MEDIA_MAP,v); 01784 } 01785 } 01786 01787 extern const PMAP SKYPE_VALIDATERESULT_MAP[] = { 01788 {__EA(NOT_VALIDATED), Skype::NOT_VALIDATED}, 01789 {__EA(VALIDATED_OK), Skype::VALIDATED_OK}, 01790 {__EA(TOO_SHORT), Skype::TOO_SHORT}, 01791 {__EA(TOO_LONG), Skype::TOO_LONG}, 01792 {__EA(CONTAINS_INVALID_CHAR), Skype::CONTAINS_INVALID_CHAR}, 01793 {__EA(CONTAINS_SPACE), Skype::CONTAINS_SPACE}, 01794 {__EA(SAME_AS_USERNAME), Skype::SAME_AS_USERNAME}, 01795 {__EA(INVALID_FORMAT), Skype::INVALID_FORMAT}, 01796 {__EA(CONTAINS_INVALID_WORD), Skype::CONTAINS_INVALID_WORD}, 01797 {__EA(TOO_SIMPLE), Skype::TOO_SIMPLE}, 01798 {__EA(STARTS_WITH_INVALID_CHAR), Skype::STARTS_WITH_INVALID_CHAR}, 01799 {0, 0} 01800 }; 01801 01802 namespace Sid { 01803 template<> Sid::String tostring(const Skype::VALIDATERESULT& v) 01804 { 01805 return enumtostring("Skype::VALIDATERESULT",SKYPE_VALIDATERESULT_MAP,v); 01806 } 01807 } 01808 01809 extern const PMAP SKYPE_PROXYTYPE_MAP[] = { 01810 {__EA(HTTPS_PROXY), Skype::HTTPS_PROXY}, 01811 {__EA(SOCKS_PROXY), Skype::SOCKS_PROXY}, 01812 {0, 0} 01813 }; 01814 01815 namespace Sid { 01816 template<> Sid::String tostring(const Skype::PROXYTYPE& v) 01817 { 01818 return enumtostring("Skype::PROXYTYPE",SKYPE_PROXYTYPE_MAP,v); 01819 } 01820 } 01821 01822 void Skype::OnProxyAuthFailure( 01823 __se_unused const PROXYTYPE& /*type*/ 01824 ) {} 01825 01826 extern const PMAP SKYPE_APP2APP_STREAMS_MAP[] = { 01827 {__EA(ALL_STREAMS), Skype::ALL_STREAMS}, 01828 {__EA(SENDING_STREAMS), Skype::SENDING_STREAMS}, 01829 {__EA(RECEIVED_STREAMS), Skype::RECEIVED_STREAMS}, 01830 {0, 0} 01831 }; 01832 01833 namespace Sid { 01834 template<> Sid::String tostring(const Skype::APP2APP_STREAMS& v) 01835 { 01836 return enumtostring("Skype::APP2APP_STREAMS",SKYPE_APP2APP_STREAMS_MAP,v); 01837 } 01838 } 01839 01840 void Skype::OnApp2AppDatagram( 01841 __se_unused const Sid::String& /*appname*/, 01842 __se_unused const Sid::String& /*stream*/, 01843 __se_unused const Sid::Binary& /*data*/ 01844 ) {} 01845 01846 void Skype::OnApp2AppStreamListChange( 01847 __se_unused const Sid::String& /*appname*/, 01848 __se_unused const APP2APP_STREAMS& /*listType*/, 01849 __se_unused const Sid::List_String& /*streams*/, 01850 __se_unused const Sid::List_uint& /*receivedSizes*/ 01851 ) {} 01852 01853 01854 ContactGroup * Skype::newContactGroup(int oid) 01855 { 01856 return new ContactGroup(oid, this); 01857 } 01858 01859 Contact * Skype::newContact(int oid) 01860 { 01861 return new Contact(oid, this); 01862 } 01863 01864 ContactSearch * Skype::newContactSearch(int oid) 01865 { 01866 return new ContactSearch(oid, this); 01867 } 01868 01869 Participant * Skype::newParticipant(int oid) 01870 { 01871 return new Participant(oid, this); 01872 } 01873 01874 Conversation * Skype::newConversation(int oid) 01875 { 01876 return new Conversation(oid, this); 01877 } 01878 01879 Message * Skype::newMessage(int oid) 01880 { 01881 return new Message(oid, this); 01882 } 01883 01884 Video * Skype::newVideo(int oid) 01885 { 01886 return new Video(oid, this); 01887 } 01888 01889 Voicemail * Skype::newVoicemail(int oid) 01890 { 01891 return new Voicemail(oid, this); 01892 } 01893 01894 Sms * Skype::newSms(int oid) 01895 { 01896 return new Sms(oid, this); 01897 } 01898 01899 Transfer * Skype::newTransfer(int oid) 01900 { 01901 return new Transfer(oid, this); 01902 } 01903 01904 Account * Skype::newAccount(int oid) 01905 { 01906 return new Account(oid, this); 01907 } 01908 01909 SEObject* Skype::factory(const uint& oid, const uint& modid){ 01910 SEObject* o = 0; 01911 switch (modid) { 01912 case ContactGroup::MODULE_ID: 01913 o = newContactGroup(oid); 01914 break; 01915 case Contact::MODULE_ID: 01916 o = newContact(oid); 01917 break; 01918 case ContactSearch::MODULE_ID: 01919 o = newContactSearch(oid); 01920 break; 01921 case Participant::MODULE_ID: 01922 o = newParticipant(oid); 01923 break; 01924 case Conversation::MODULE_ID: 01925 o = newConversation(oid); 01926 break; 01927 case Message::MODULE_ID: 01928 o = newMessage(oid); 01929 break; 01930 case Video::MODULE_ID: 01931 o = newVideo(oid); 01932 break; 01933 case Voicemail::MODULE_ID: 01934 o = newVoicemail(oid); 01935 break; 01936 case Sms::MODULE_ID: 01937 o = newSms(oid); 01938 break; 01939 case Transfer::MODULE_ID: 01940 o = newTransfer(oid); 01941 break; 01942 case Account::MODULE_ID: 01943 o = newAccount(oid); 01944 break; 01945 default: 01946 break; 01947 } 01948 return o; 01949 } 01950 01951 Sid::List_uint* Skype::prop_cached_list(void* propstruct, const uint& moduleid) 01952 { 01953 switch (moduleid) { 01954 case ContactGroup::MODULE_ID: 01955 return &reinterpret_cast<MsgcontactContactGroup*>(propstruct)->cachedProps; 01956 case Contact::MODULE_ID: 01957 return &reinterpret_cast<MsgcontactContact*>(propstruct)->cachedProps; 01958 case ContactSearch::MODULE_ID: 01959 return &reinterpret_cast<MsgcontactsearchContactSearch*>(propstruct)->cachedProps; 01960 case Participant::MODULE_ID: 01961 return &reinterpret_cast<MsgconversationParticipant*>(propstruct)->cachedProps; 01962 case Conversation::MODULE_ID: 01963 return &reinterpret_cast<MsgconversationConversation*>(propstruct)->cachedProps; 01964 case Message::MODULE_ID: 01965 return &reinterpret_cast<MsgconversationMessage*>(propstruct)->cachedProps; 01966 case Video::MODULE_ID: 01967 return &reinterpret_cast<MsgvideoVideo*>(propstruct)->cachedProps; 01968 case Voicemail::MODULE_ID: 01969 return &reinterpret_cast<MsgvmVoicemail*>(propstruct)->cachedProps; 01970 case Sms::MODULE_ID: 01971 return &reinterpret_cast<MsgsmsSms*>(propstruct)->cachedProps; 01972 case Transfer::MODULE_ID: 01973 return &reinterpret_cast<MsgftTransfer*>(propstruct)->cachedProps; 01974 case Account::MODULE_ID: 01975 return &reinterpret_cast<MsgaccountAccount*>(propstruct)->cachedProps; 01976 default: 01977 break; 01978 } 01979 return 0; 01980 } 01981 01982 void* Skype::prop_factory(const uint& moduleid) 01983 { 01984 switch (moduleid) { 01985 case ContactGroup::MODULE_ID: 01986 return new MsgcontactContactGroup(); 01987 case Contact::MODULE_ID: 01988 return new MsgcontactContact(); 01989 case ContactSearch::MODULE_ID: 01990 return new MsgcontactsearchContactSearch(); 01991 case Participant::MODULE_ID: 01992 return new MsgconversationParticipant(); 01993 case Conversation::MODULE_ID: 01994 return new MsgconversationConversation(); 01995 case Message::MODULE_ID: 01996 return new MsgconversationMessage(); 01997 case Video::MODULE_ID: 01998 return new MsgvideoVideo(); 01999 case Voicemail::MODULE_ID: 02000 return new MsgvmVoicemail(); 02001 case Sms::MODULE_ID: 02002 return new MsgsmsSms(); 02003 case Transfer::MODULE_ID: 02004 return new MsgftTransfer(); 02005 case Account::MODULE_ID: 02006 return new MsgaccountAccount(); 02007 default: 02008 break; 02009 } 02010 return 0; 02011 } 02012 bool Skype::start() { bool r; if (!Start(r) || !r) { stop(); return false; } return true; }
(c) Skype Technologies S.A. Confidential/Proprietary
Last updated: Fri Mar 16 2012