void pyllbc_Service::AfterStop() { _cppFacade = NULL; // Recreate service. LLBC_XDelete(_llbcSvc); this->CreateLLBCService(_llbcSvcType); // Cleanup all python layer facades. for (_Facades::iterator it = _facades.begin(); it != _facades.end(); it++) Py_DECREF(*it); _facades.clear(); // Cleanup all python layer codecs. for (_Codecs::iterator it = _codecs.begin(); it != _codecs.end(); it++) Py_DECREF(it->second); _codecs.clear(); // Cleanup all python layer handlers/prehandlers/unify_prehandlers(if enabled). LLBC_STLHelper::DeleteContainer(_handlers); LLBC_STLHelper::DeleteContainer(_preHandlers); #if LLBC_CFG_COMM_ENABLE_UNIFY_PRESUBSCRIBE LLBC_XDelete(_unifyPreHandler); #endif // LLBC_CFG_COMM_ENABLE_UNIFY_PRESUBSCRIBE // Destroy all frame callables. _handledBeforeFrameCallables = false; this->DestroyFrameCallables(_beforeFrameCallables, _handlingBeforeFrameCallables); this->DestroyFrameCallables(_afterFrameCallables, _handlingAfterFrameCallables); }
LLBC_Variant::Holder::~Holder() { if (type == LLBC_VariantType::VT_DICT_DFT) { LLBC_XDelete(dict); } }
int pyllbc_Service::Broadcast(int opcode, PyObject *data, int status, PyObject *parts) { // Started check. if (UNLIKELY(!this->IsStarted())) { pyllbc_SetError("service not start"); return LLBC_RTN_FAILED; } // Build parts, if exists. LLBC_PacketHeaderParts *cLayerParts = NULL; if (parts && _llbcSvcType != LLBC_IService::Raw) { if (!(cLayerParts = this->BuildCLayerParts(parts))) return LLBC_RTN_FAILED; } // Serialize python layer 'data' object to stream. LLBC_Stream stream; if (this->SerializePyObj2Stream(data, stream) != LLBC_RTN_OK) { LLBC_XDelete(cLayerParts); return LLBC_RTN_FAILED; } // Send it. const void *bytes = stream.GetBuf(); const size_t len = stream.GetPos(); return _llbcSvc->Broadcast2(opcode, bytes, len, status, cLayerParts); }
void LLBC_Variant::OptimizePerformance() { if (IsDict()) { if (_holder.dict && _holder.dict->empty()) { LLBC_XDelete(_holder.dict); } } }
int pyllbc_Service::Send(int sessionId, int opcode, PyObject *data, int status, PyObject *parts) { // Started check. if (UNLIKELY(!this->IsStarted())) { pyllbc_SetError("service not start"); return LLBC_RTN_FAILED; } // Build parts, if exists. LLBC_PacketHeaderParts *cLayerParts = NULL; if (parts && _llbcSvcType != LLBC_IService::Raw) { if (!(cLayerParts = this->BuildCLayerParts(parts))) return LLBC_RTN_FAILED; } // Serialize python layer 'data' object to stream. LLBC_Stream stream; const int ret = this->SerializePyObj2Stream(data, stream); if (UNLIKELY(ret != LLBC_RTN_OK)) { LLBC_XDelete(cLayerParts); return LLBC_RTN_FAILED; } // Build packet & send. LLBC_Packet *packet = LLBC_New(LLBC_Packet); packet->Write(stream.GetBuf(), stream.GetPos()); packet->SetSessionId(sessionId); if (_llbcSvcType != LLBC_IService::Raw) { packet->SetOpcode(opcode); packet->SetStatus(status); if (cLayerParts) { cLayerParts->SetToPacket(*packet); LLBC_Delete(cLayerParts); } } if (UNLIKELY(_llbcSvc->Send(packet) == LLBC_RTN_FAILED)) { pyllbc_TransferLLBCError(__FILE__, __LINE__); return LLBC_RTN_FAILED; } return LLBC_RTN_OK; }
int LLBC_IocpPoller::StartupMonitor() { LLBC_IDelegate0 *deleg = new LLBC_Delegate0< LLBC_IocpPoller>(this, &LLBC_IocpPoller::MonitorSvc); _monitor = new LLBC_PollerMonitor(deleg); if (_monitor->Start() != LLBC_OK) { LLBC_XDelete(_monitor); return LLBC_FAILED; } return LLBC_OK; }
int LLBC_BaseLogAppender::Initialize(const LLBC_LogAppenderInitInfo &initInfo) { if (_chain) { LLBC_SetLastError(LLBC_ERROR_REENTRY); return LLBC_FAILED; } _chain = new LLBC_LogTokenChain; if (_chain->Build(initInfo.pattern) != LLBC_OK) { LLBC_XDelete(_chain); return LLBC_FAILED; } return LLBC_OK; }
void LLBC_Variant::CleanDictData() { LLBC_XDelete(_holder.dict); }
bool LLBC_Variant::DeSerialize(LLBC_Stream &stream) { BecomeNil(); if (!stream.Read(_holder.type)) { return false; } if (IsNil()) { return true; } if (IsRaw()) { if (!stream.Read(_holder.raw.uint64Val)) { _holder.type = LLBC_VariantType::VT_NIL; return false; } } else if (IsStr()) { if (!stream.Read(_holder.str)) { _holder.type = LLBC_VariantType::VT_NIL; return false; } } else if (IsDict()) { uint32 count = 0; if (!stream.Read(count)) { _holder.type = LLBC_VariantType::VT_NIL; return false; } if (count == 0) { return true; } _holder.dict = new Dict; for (uint32 i = 0; i < count; i ++) { LLBC_Variant key; LLBC_Variant val; if (!stream.Read(key) || !stream.Read(val)) { LLBC_XDelete(_holder.dict); _holder.type = LLBC_VariantType::VT_NIL; return false; } _holder.dict->insert(std::make_pair(key, val)); } return true; } return false; }
void LLBC_IocpPoller::StopMonitor() { LLBC_XDelete(_monitor); }
LLBC_Session::~LLBC_Session() { LLBC_XDelete(_socket); LLBC_XDelete(_protoStack); }
LLBC_SvcEv_DataArrival::~LLBC_SvcEv_DataArrival() { LLBC_XDelete(packet); }
LLBC_SvcEv_SessionDestroy::~LLBC_SvcEv_SessionDestroy() { LLBC_XDelete(closeInfo); }
void LLBC_TimerScheduler::DestroyEntryThreadScheduler() { LLBC_XDelete(LLBC_INTERNAL_NS __g_entryThreadTimerScheduler); }
LLBC_SvcEv_SubscribeEv::~LLBC_SvcEv_SubscribeEv() { LLBC_XDelete(deleg); }
LLBC_SvcEv_FireEv::~LLBC_SvcEv_FireEv() { LLBC_XDelete(ev); }
void LLBC_BaseLogAppender::Finalize() { LLBC_XDelete(_chain); }
pyllbc_PackLemma_Dict::~pyllbc_PackLemma_Dict() { LLBC_XDelete(_keyLemma); LLBC_XDelete(_valueLemma); }
int LLBC_LogTokenChain::Build(const LLBC_String &pattern) { if (_head) { LLBC_SetLastError(LLBC_ERROR_REENTRY); return LLBC_RTN_FAILED; } char ch = '\0'; const char *curPattern = NULL; LLBC_String::size_type patternLength = 0; int state = LLBC_INTERNAL_NS __g_literal_state; LLBC_ILogToken *token = NULL; LLBC_LogFormattingInfo *formatter = NULL; LLBC_String buf; if (pattern.empty()) { curPattern = LLBC_INTERNAL_NS __g_default_pattern; patternLength = LLBC_StrLenA(LLBC_INTERNAL_NS __g_default_pattern); } else { curPattern = pattern.data(); patternLength = pattern.size(); } for (size_t i = 0; i < patternLength;) { ch = curPattern[i ++]; switch(state) { case LLBC_INTERNAL_NS __g_literal_state: if (i == patternLength) { buf.append(1, ch); break; } if (ch == LLBC_LogTokenType::EscapeToken) { if (curPattern[i] == LLBC_LogTokenType::EscapeToken) { buf.append(1, ch); i ++; } else { if (!buf.empty()) { token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken); token->Initialize(formatter, buf); this->AppendToken(token); buf.clear(); formatter = NULL; } buf.append(1, ch); LLBC_XDelete(formatter); state = LLBC_INTERNAL_NS __g_converter_state; } } else { buf.append(1, ch); } break; case LLBC_INTERNAL_NS __g_converter_state: buf.append(1, ch); if ((ch >= 0x30 && ch <= 0x39) || ch == '-') { state = LLBC_INTERNAL_NS __g_number_state; break; } buf.erase(buf.rfind(LLBC_LogTokenType::EscapeToken)); token = LLBC_LogTokenBuilderSingleton->BuildLogToken(ch); if (!formatter) { formatter = new LLBC_LogFormattingInfo; } token->Initialize(formatter, ""); this->AppendToken(token); formatter = NULL; state = LLBC_INTERNAL_NS __g_literal_state; break; case LLBC_INTERNAL_NS __g_number_state: if ((ch < 0x30 || ch > 0x39) && ch != '-') { int minLength = LLBC_Str2Int32(&buf[buf.rfind(LLBC_LogTokenType::EscapeToken) + 1]); if (!formatter) { formatter = new LLBC_LogFormattingInfo(minLength < 0 ? true : false, ::abs(minLength), INT_MAX); } else { formatter->SetLeftAligh(minLength < 0 ? true : false); formatter->SetMinLen(minLength); formatter->SetMaxLen(INT_MAX); } i --; state = LLBC_INTERNAL_NS __g_converter_state; break; } buf.append(1, ch); break; default: LLBC_XDelete(formatter); this->Cleanup(); LLBC_SetLastError(LLBC_ERROR_FORMAT); return LLBC_RTN_FAILED; break; } } if (!buf.empty()) { token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken); token->Initialize(NULL, buf); this->AppendToken(token); } return LLBC_RTN_OK; }