static unsigned __stdcall winmm_buffer_thread(void * user_ptr) { cubeb * ctx = (cubeb *) user_ptr; XASSERT(ctx); for (;;) { DWORD r; PSLIST_ENTRY item; r = WaitForSingleObject(ctx->event, INFINITE); XASSERT(r == WAIT_OBJECT_0); /* Process work items in batches so that a single stream can't starve the others by continuously adding new work to the top of the work item stack. */ item = InterlockedFlushSList(ctx->work); while (item != NULL) { PSLIST_ENTRY tmp = item; winmm_refill_stream(((struct cubeb_stream_item *) tmp)->stream); item = item->Next; _aligned_free(tmp); } if (ctx->shutdown) { break; } } return 0; }
static void winmm_destroy(cubeb * ctx) { DWORD r; XASSERT(ctx->active_streams == 0); XASSERT(!InterlockedPopEntrySList(ctx->work)); DeleteCriticalSection(&ctx->lock); if (ctx->thread) { ctx->shutdown = 1; SetEvent(ctx->event); r = WaitForSingleObject(ctx->thread, INFINITE); XASSERT(r == WAIT_OBJECT_0); CloseHandle(ctx->thread); } if (ctx->event) { CloseHandle(ctx->event); } _aligned_free(ctx->work); free(ctx); }
//-------------------------------------------------------------------------------- // SendRequest //-------------------------------------------------------------------------------- IrDAErr TIASClient::SendRequest() { Size classNameLen; Size attrNameLen; TIrLookupRequest* lookupRequest = (TIrLookupRequest*)GetCurrentEvent(); XTRACE(kSendRequestEvent, 0, 0); // Save the request so it can be replied to XASSERT(fLookupRequest == nil); fLookupRequest = lookupRequest; // Get lengths of class and attr strings classNameLen = strlen((const char*)(lookupRequest->fClassName)); attrNameLen = strlen((const char*)(lookupRequest->fAttrName)); // Validate that className and attrName strings fit in buffer provided XASSERT((classNameLen + attrNameLen + 3) <= kIASClientBufferSize); if ((classNameLen + attrNameLen + 3) > kIASClientBufferSize) { return kIrDAErrBadParameter; } // Fill out the request fGetPutBuffer->Seek(0, kPosBeg); fGetPutBuffer->Put(kIASOpGetValueByClass | kIASFrameLstBit); fGetPutBuffer->Put((UByte)classNameLen); fGetPutBuffer->Putn((const UByte *)lookupRequest->fClassName, classNameLen); fGetPutBuffer->Put((UByte)attrNameLen); fGetPutBuffer->Putn((const UByte *)lookupRequest->fAttrName, attrNameLen); PutStart(); return noErr; } // TIASClient::SendRequest
bool handle_entity(const Entity &hero) { if(hero.clazz->name.find("CDOTA_Unit_Hero_") != 0) return false; // Most likely an illusion. std::string player = _hph.player_name_for_hero_id(hero.id); if(player.empty()) return false; try { int cell_x = hero.properties.at("DT_DOTA_BaseNPC.m_cellX")->value_as<IntProperty>(); int cell_y = hero.properties.at("DT_DOTA_BaseNPC.m_cellY")->value_as<IntProperty>(); int cell_z = hero.properties.at("DT_DOTA_BaseNPC.m_cellZ")->value_as<IntProperty>(); auto origin_prop = std::dynamic_pointer_cast<VectorXYProperty>(hero.properties.at("DT_DOTA_BaseNPC.m_vecOrigin")); int x = cell_x*128 + origin_prop->values[0]; int y = cell_y*128 + origin_prop->values[1]; // Write the coords to the "coords of all heroes" file. if(_json) { if(_files.empty()) { _all << "[ "; } else { _all << ", "; } } // Write to the hero-specific files. // TODO: A "hero created" callback would be nice, wouldn't it? std::string heroname(hero.clazz->name, 16); auto iFile = _files.find(heroname); if(iFile == _files.end()) { _files[heroname] = new std::ofstream((_basepath + heroname + (_json ? ".json" : ".csv")).c_str()); iFile = _files.find(heroname); if(_json) { *(iFile->second) << "[ "; } } else if(_json) { *(iFile->second) << ", "; } if(_json) { *(iFile->second) << '[' << x << ',' << y << ']'; _all << '[' << x << ',' << y << ']'; } else { *(iFile->second) << x << ',' << y << '\n'; _all << x << ',' << y << '\n'; } } catch(const std::out_of_range& e) { XASSERT(false, "%s", e.what()); } catch(const std::bad_cast& e) { XASSERT(false, "%s", e.what()); } return true; }
static void winmm_stream_destroy(cubeb_stream * stm) { DWORD r; int i; int enqueued; if (stm->waveout) { EnterCriticalSection(&stm->lock); stm->shutdown = 1; waveOutReset(stm->waveout); enqueued = NBUFS - stm->free_buffers; LeaveCriticalSection(&stm->lock); /* Wait for all blocks to complete. */ while (enqueued > 0) { r = WaitForSingleObject(stm->event, INFINITE); XASSERT(r == WAIT_OBJECT_0); EnterCriticalSection(&stm->lock); enqueued = NBUFS - stm->free_buffers; LeaveCriticalSection(&stm->lock); } EnterCriticalSection(&stm->lock); for (i = 0; i < NBUFS; ++i) { if (stm->buffers[i].dwFlags & WHDR_PREPARED) { waveOutUnprepareHeader(stm->waveout, &stm->buffers[i], sizeof(stm->buffers[i])); } } waveOutClose(stm->waveout); LeaveCriticalSection(&stm->lock); } if (stm->event) { CloseHandle(stm->event); } DeleteCriticalSection(&stm->lock); for (i = 0; i < NBUFS; ++i) { free(stm->buffers[i].lpData); } EnterCriticalSection(&stm->context->lock); XASSERT(stm->context->active_streams >= 1); stm->context->active_streams -= 1; LeaveCriticalSection(&stm->context->lock); free(stm); }
bool CxStdString::operator > (const CxStdString & compare) const { if ( allocated && compare.allocated ) { XASSERT( cstring ); XASSERT( compare.cstring ); return ( strcmp( cstring, compare.cstring ) < 0 ); } return false; }
bool CGlow::init() { // get the glow manager from this sig ( which is 2 bytes into the sig ) DWORD dwGlowLoc = gSignatures.GetClientSignature("8B 0D ? ? ? ? A1 ? ? ? ? 56 8B 37") + 0x2; XASSERT(dwGlowLoc); pGlowObjectManger = *(CGlowManager **)dwGlowLoc; XASSERT(pGlowObjectManger); return true; }
int64_t read_locations(const char *filename, const int64_t ntrees, struct locations *l, int *num_files, int *box_div) { char buffer[MAXBUFSIZE]; int max_fileid = 0; const char comment = '#'; /* By passing the comment character, getnumlines will return the actual number of lines, ignoring the first header line. */ struct locations *locations = l; int64_t ntrees_found = 0; FILE *fp = my_fopen(filename, "r"); while(fgets(buffer, MAXBUFSIZE, fp) != NULL) { if(buffer[0] == comment) { continue; } else { const int nitems_expected = 4; char linebuf[MAXLEN]; XASSERT(ntrees_found < ntrees, "ntrees=%"PRId64" should be less than ntrees_found=%"PRId64"\n", ntrees, ntrees_found); int nitems = sscanf(buffer, "%"SCNd64" %"SCNd64 " %"SCNd64 "%s", &(locations[ntrees_found].tree_root), &(locations[ntrees_found].fileid), &(locations[ntrees_found].offset), linebuf); /* The filename is separated out to save memory but I want to ensure that the actual filename does not get truncated. The filename field might actually be removed later. */ my_snprintf(locations[ntrees_found].filename, LOCATIONS_FILENAME_SIZE, "%s", linebuf); XASSERT(nitems == nitems_expected, "Expected to parse two long integers but found `%s' in the buffer\n", buffer); ntrees_found++; } } XASSERT(ntrees == ntrees_found, "ntrees=%"PRId64" should be equal to ntrees_found=%"PRId64"\n", ntrees, ntrees_found); fclose(fp); for(int i=0;i<ntrees_found;i++){ if (locations[i].fileid > max_fileid) { max_fileid = locations[i].fileid; } } /* number of files is one greater from 0 based indexing of C files */ *num_files = max_fileid + 1; const int box_divisions = (int) round(cbrt(*num_files)); const int box_cube = box_divisions * box_divisions * box_divisions; XASSERT( (box_cube) == (*num_files), "box_divisions^3=%d should be equal to nfiles=%d\n", box_cube, *num_files); *box_div = box_divisions; return ntrees_found; }
// ------------------------------------------------------- // add transition // ------------------------------------------------------- void StateManager::addTransition(int from, int outcome, int to, float ttl) { // FIXME: assert that from and to are valid XASSERT(from != to, "You cannot add a transition pointing to itself"); XASSERT(_states.find(from) != _states.end(), "The from %d paramter is an unknown state",from); XASSERT(_states.find(to) != _states.end(), "The to %d paramter is an unknown state",to); StateTransition t; t.from = from; t.to = to; t.outcome = outcome; t.ttl = ttl; _transitions.push_back(t); }
XOrderCamera::XOrderCamera( XSeq *pSeq, int idxOrder ) : XOrder( pSeq, idxOrder ) { Init(); m_spProp = std::static_pointer_cast<XPropCamera>( pSeq->GetspProp()->m_aryOrder[ idxOrder ] ); if( SCENE_WORLD ) { if( m_spProp->m_bPopPos ) { // 좌표 pop mode if( XASSERT(!s_stackPos.empty()) ) { // 좌표 복구. const XE::VEC2 vwCamera = s_stackPos.top(); s_stackPos.pop(); SCENE_WORLD->DoMovePosInWorld( vwCamera ); } } else { if( m_spProp->m_bPushPos ) { // 좌표 백업 s_stackPos.push( SCENE_WORLD->GetvwCamera() ); } // 지정된 좌표로 이동 if( m_spProp->m_aryIdsTarget.size() ) { // 카메라에서는 idsTarget을 하나만 쓴다. auto idsTarget = m_spProp->m_aryIdsTarget[0]; auto pWnd = GAME->Find( idsTarget ); if( pWnd ) { auto vPos = pWnd->GetPosLocal(); SCENE_WORLD->DoMovePosInWorld( vPos, 0.5f ); } else { XBREAKF( 1, "%s not found", C2SZ(idsTarget) ); } } else { SCENE_WORLD->DoMovePosInWorld( m_spProp->m_vwDst, 0.5f ); } } } else if( SCENE_BATTLE ) { if( m_spProp->m_bPopPos ) { if( XASSERT( !s_stackPos.empty() ) ) { SCENE_BATTLE->DoMoveCamera( s_stackPos.top() ); s_stackPos.pop(); } } else { if( m_spProp->m_bPushPos ) { s_stackPos.push( SCENE_BATTLE->GetvwCamera() ); } // 지정된 좌표로 이동 XBREAK( m_spProp->m_vwDst.IsZero() ); SCENE_BATTLE->DoMoveCamera( m_spProp->m_vwDst ); } } }
static WAVEHDR * winmm_get_next_buffer(cubeb_stream * stm) { WAVEHDR * hdr = NULL; XASSERT(stm->free_buffers > 0 && stm->free_buffers <= NBUFS); hdr = &stm->buffers[stm->next_buffer]; XASSERT(hdr->dwFlags & WHDR_PREPARED || (hdr->dwFlags & WHDR_DONE && !(hdr->dwFlags & WHDR_INQUEUE))); stm->next_buffer = (stm->next_buffer + 1) % NBUFS; stm->free_buffers -= 1; return hdr; }
//-------------------------------------------------------------------------------- // CItemComparer::TestItem //-------------------------------------------------------------------------------- CompareResult CItemComparer::TestItem(const void* criteria) const { XASSERT(fItem); XASSERT(criteria); if (fItem < criteria) return kItemLessThanCriteria; else if (fItem > criteria) return kItemGreaterThanCriteria; else return kItemEqualCriteria; }
void CGBLStorageManagerTestBBBase::ElementToXstring(int i, int c, CKDataArray *array, XString *elem) { XASSERT(array); int elemSize = array->GetElementStringValue(i, c, NULL); CKSTRING elemHolder = new CKCHAR[elemSize]; XASSERT(elemHolder); array->GetElementStringValue(i, c, elemHolder); *elem = elemHolder; delete [] elemHolder; elemHolder = NULL; }
char* StrReadLine( const char* str, char* outLine ) { XASSERT(str && outLine); LOOP: if(*str) { if(*str != '\n') { *outLine = *str; str++; outLine++; goto LOOP; } else { *(outLine - 1) = '\0'; str++; return (char*)str; } } else { *outLine = '\0'; return nullptr; } }
void StrTrimRight( const char* str, char* dst ) { XASSERT(str && dst); const char* _str = str; if(*str) { str++; while(*str) str++; str--; } else goto END; XSTRING_PREFETCH_TBL(TblSpaceTab); while(ChrIsSpaceTab(*str)) str--; str++; while(_str != str) { *dst = *_str; _str++; dst++; } END: *dst = '\0'; }
/** @brief pEff의 발동스킬을 발동대상(혹은 발동좌표)에 사용한다. this는 발동자. @param pIvkTarget 발동대상. 발동대상이 좌표형이면 null이다 @param vIvkPos 발동대상이 좌표형태일때 IzNotZero가 된다. */ bool XSkillReceiver::DoInvokeSkill( XSkillReceiver* pIvkTarget, const XE::VEC2& vIvkPos, const XSkillDat* pDat, const EFFECT* pEffect, int level, XSkillUser* pCaster, ID idCallerBuff ) { // 좌표에 값이 있으면 타겟은 널이어야 한다., XBREAK( vIvkPos.IsNotZero() && pIvkTarget != nullptr ); bool bApplied = false; auto pInvoker = this; // this는 발동자 // 발동스킬이 있는가? _tstring strInvokeSkillMut = pEffect->strInvokeSkill; XBREAK( strInvokeSkillMut.empty() ); // strInvokeSkill이 바뀔수 있음. bool bInvoke = (pIvkTarget)? pInvoker->OnInvokeSkill( pDat, pEffect, pIvkTarget, level, &strInvokeSkillMut ) : true; if( bInvoke ) { #ifdef _XSINGLE // XTRACE( "스킬발동: %s", pEffect->strInvokeSkill.c_str() ); #endif // _XSINGLE // 발동스킬을 실행시킨다. 기준타겟은 pIvkTarget로 된다. // 발동스킬이 m_listUseSkill에 들어가는 문제가 있어 안들어가도록 수정함. auto infoUseSkill = pCaster->UseSkillByIds( strInvokeSkillMut, level, pIvkTarget, vIvkPos ); XASSERT( infoUseSkill.errCode == xOK ); if( infoUseSkill.errCode == xOK ) { // 발동스킬은 지속형일수도 있고 즉시발동형일수도 있다. pCaster->OnShootSkill( infoUseSkill, idCallerBuff ); bApplied = true; } } return bApplied; }
int main(int argc, char** argv) { XASSERT(argc == 5, "usage: $0 THREADS CONNECTIONS IP PORT"); int thread_count = atoi(argv[1]); connections = atoi(argv[2]); ip = argv[3]; port = (uint16_t)atoi(argv[4]); pthread_t* threads = cx_alloc((size_t)thread_count * sizeof(pthread_t*)); PROFILE_BEGIN_FMT("threads:%d requests/thread:%d\n", thread_count, connections); int i; for (i = 0; i < thread_count; i++) pthread_create(&threads[i], NULL, thread_send_data, NULL); for (i = 0; i < thread_count; i++) pthread_join(threads[i], NULL); PROFILE_END cx_free(threads); return 0; }
void XEWinSocketSvr::OnDestroy() { BTRACE( "save user" ); if( XASSERT(m_pUserMng) ) { m_pUserMng->Save(); } }
void XESkillMng::LoadCond( TiXmlElement *pElemCond, EFFECT *pEffect ) { // "발동조건"안의 attribute들을 읽는다. xCOND cond; TiXmlAttribute *pCondAttr = pElemCond->FirstAttribute(); while( pCondAttr ) { // "발동조건"블럭안의 attribute들을 모두 읽는다. const char *cAttrName = pCondAttr->Name(); const char *cVal = pCondAttr->Value(); XU8LOG( cAttrName ); XU8LOG( cVal ); // 조건파라메터를 하나씩 분석해서 어레이에 쌓는다. xCOND_PARAM param; param.cond = (XSKILL::xtCondition)ParsingParam( cAttrName ); param.val = ParsingParam( cVal ); if( param.cond ) cond.aryParam.Add( param ); pCondAttr = pCondAttr->Next(); } if( cond.aryParam.size() > 0 ) { if( XASSERT(pEffect) ) pEffect->aryInvokeCondition.Add( cond ); } }
void XOrderIndicate::Process( float dt ) { if( m_timerSec.IsOver() ) { if( CreateIndicator() == false ) { if( ++m_numFailed >= 3 ) SetbEnd( true ); // 타겟을 3초간 못찾으면 그냥 끝냄. } m_timerSec.Reset(); } // 시간되면 자동 종료 if( m_timerFinish.IsOver() ) { // 이 인디케이터가 다른 order의 end가 종료시점일때 if( GetspProp()->m_typeEnd == xFIN_END_ORDER ) { auto spOrderProp = m_spPropSeq->GetspOrderProp( GetspProp()->m_idsEnd ); if( XASSERT(spOrderProp) ) { // 그 다른 order가 touch방식이 아닐때만 자동 사라짐. if( spOrderProp->m_typeEnd != xFIN_TOUCH ) { CONSOLE("XOrderIndicate::Process:시간초과로 자동 종료됨."); SetbEnd( true ); m_timerFinish.Off(); } else { m_timerFinish.Off(); // 더이상 검사하지 않도록. } } } else if( GetspProp()->m_typeEnd == xFIN_DELAY ) { m_timerFinish.Off(); SetbEnd( true ); } } }
void DeathBalls::handleEvents(const ds::ActionEventBuffer& buffer) { for (int i = 0; i < buffer.events.size(); ++i) { const ds::ActionEvent& event = buffer.events[i]; if (_world->contains(event.sid) && event.spriteType == OT_DEATHBALL) { if (event.type == ds::AT_ROTATE_BY ) { float angle = _world->getRotation(event.sid); v2 v = ds::vector::getRadialVelocity(angle, 500.0f); _world->moveBy(event.sid, v); DeathBall* data = (DeathBall*)_world->get_data(event.sid); XASSERT(data != 0, "No Deathball data found for %d",event.sid); _world->moveBy(data->innerID, v); _context->trails->add(event.sid, 4.0f, DEATHBALL_TRAIL, 20.0f); _world->stopAction(event.sid, ds::AT_COLOR_FLASH); _world->stopAction(data->innerID, ds::AT_COLOR_FLASH); _world->setColor(event.sid, ds::Color(255, 128, 0, 255)); _world->setColor(data->innerID, ds::Color(255, 128, 0, 255)); } else if (event.type == ds::AT_MOVE_BY) { // let it explode v2 p = _world->getPosition(event.sid); _context->particles->start(DEATHBALL_EXPLOSION, p); DeathBall* data = (DeathBall*)_world->get_data(event.sid); _world->remove(data->innerID); _world->remove(event.sid); } } } }
bool XEUser::IsDestroy() const { auto spConn = m_spConnect.lock(); if( XASSERT(spConn) ) return spConn->IsbDestroy(); return true; // 커넥션이 없는경우는 파괴된걸로 판단. }
uint32_t read_var_int(const char *data, size_t length, size_t *offset) { uint32_t b; int count = 0; uint32_t result = 0; do { XASSERT(count != 5, "Corrupt data."); XASSERT(*offset <= length, "Premature end of stream."); b = data[(*offset)++]; result |= (b & 0x7F) << (7 * count); ++count; } while (b & 0x80); return result; }
/** * _cairo_cache_freeze: * @cache: a cache with some precious entries in it (or about to be * added) * * Disable the automatic ejection of entries from the cache. For as * long as the cache is "frozen", calls to _cairo_cache_insert() will * add new entries to the cache regardless of how large the cache * grows. See _cairo_cache_thaw(). * * Note: Multiple calls to _cairo_cache_freeze() will stack, in that * the cache will remain "frozen" until a corresponding number of * calls are made to _cairo_cache_thaw(). **/ void _cairo_cache_freeze (cairo_cache_t *cache) { XASSERT (cache->freeze_count >= 0); cache->freeze_count++; }
/** @brief Invoke대상에게 pEffect효과를 적용시킨다. @param pInvoker pEffect효과를 발동시킨측. pCaster와는 다르다. @param vIvkPos 발동대상이 좌표인경우 0이아닌값이 들어온다. 이때 pInvokeTarget은 null이된다. @return 효과적용에 성공하면 true를 리턴한다. */ bool XSkillUser::ApplyInvokeEffToIvkTarget( XSkillReceiver* pIvkTarget, // null일수도 있음. const XE::VEC2& vIvkPos, // 발동대상이 좌표형태인경우. const XSkillDat *pDat, const EFFECT *pEffect, XSkillReceiver *pInvoker, bool bCreateSfx, int level, XBuffObj *pBuffObj ) { // 좌표에 값이 있으면 타겟은 널이어야 한다., XBREAK( vIvkPos.IsNotZero() && pIvkTarget != nullptr ); // 발동적용확률이 있다면 확률검사를 통과해야 한다.(XBuffObj에 이것이 있을때는 GetInvokeTarget을 하기전에 수행되었는데 지금은 발동타겟 개별적으로 확률검사를 하도록 바뀜. 이게 맞는거 같아서) bool bOk = XSKILL::DoDiceInvokeApplyRatio( pEffect, level ); if( !bOk ) return false; bool bOrCond = false; // 조건블럭이 없으면 무조건 true if( pEffect->aryInvokeCondition.size() == 0 ) { bOrCond = true; } else // 발동조건 블럭검사. if( pIvkTarget && IsInvokeTargetCondition( pDat, pEffect, pIvkTarget ) ) { bOrCond = true; } if( !bOrCond ) return false; if( pEffect->idInvokeSound ) { OnSkillPlaySound( pEffect->idInvokeSound ); } // 발동타겟에게 실제 효과적용 if( pIvkTarget ) { int retApplied = pIvkTarget->ApplyInvokeEffect( const_cast<XSkillDat*>(pDat), this , pInvoker, pBuffObj , pEffect, level ); // 발동대상이펙트가 있다면 생성해준다. if( bCreateSfx && pEffect->m_invokeTargetEff.IsHave() ) { const float secPlay = 0.f; // 1play. 발동이펙트는 반복플레이가 없음. const XE::VEC2 vZero; CreateSfx( pIvkTarget, pDat, pEffect->m_invokeTargetEff, secPlay, vZero ); } return retApplied != 0; } else if( vIvkPos.IsNotZero() ) { // 발동타겟이 좌표형태 // 발동타겟이 좌표이면 바닥에 놓는 버프객체를 뜻한다. // 발동좌표를 기준타겟좌표로해서 시전한다. 기준타겟좌표로 시전된 스킬은 가상의 리시버객체가 생성되고 거기에 버프가 걸리는 형태. if( XASSERT(!pEffect->strInvokeSkill.empty()) ) { // 발동대상이 좌표형태인경우 그 효과는 반드시 발동스킬로 구현되어야 한다. const ID idCallerBuff = ( pBuffObj ) ? pBuffObj->GetidSkill() : 0; pInvoker->DoInvokeSkill( nullptr, vIvkPos, pDat, pEffect, level, this, idCallerBuff ); } // 발동대상이펙트가 있다면 생성해준다. if( bCreateSfx && pEffect->m_invokeTargetEff.IsHave() ) { const float secPlay = 0.f; // 1play. 발동이펙트는 반복플레이가 없음. CreateSfx( pIvkTarget, pDat, pEffect->m_invokeTargetEff, secPlay, vIvkPos ); } return true; } return false; } // ApplyInvokeEffectToInvokeTarget
CxSimpleADO::IRecordSetPtr CxSimpleADO::Execute(LPCWSTR lpszSql) { if (!IsConnect()) return IRecordSetPtr(m_pCommand, NULL); USES_CONVERSION; m_pCommand->SetActiveConnection( m_pConnection ); m_pCommand->SetCommandText( W2T((LPWSTR)lpszSql) ); int nParamCount = m_pParameterSet->GetCount(); for ( int i=0 ; i<nParamCount ; i++ ) { CxADOParameterSet::ParameterSet* pParamSet = m_pParameterSet->GetAt(i); XASSERT( !pParamSet->pParameter ); pParamSet->pParameter = m_pCommand->CreateParameter( pParamSet->strName, pParamSet->size, adLongVarBinary ); m_pCommand->Append(pParamSet->pParameter); pParamSet->pParameter->AppendChunk(pParamSet->var); } CxADORecordSet* pRs = m_pCommand->Execute(); m_pParameterSet->Clear(); if (!pRs) return IRecordSetPtr(m_pCommand, NULL); return IRecordSetPtr(m_pCommand, pRs); }
//////////////////////////////////////////////////////////////////////////TempAllocator void TempAllocator::init( size_t buffSize ) { m_tac.init(); m_bufferBegin = (byte*)::GlobalAlloc(0, buffSize); XASSERT(m_bufferBegin); m_bufferSeek = m_bufferBegin; m_bufferEnd = m_bufferBegin + buffSize; }
/** * _cairo_cache_thaw: * @cache: a cache, just after the entries in it have become less * precious * * Cancels the effects of _cairo_cache_freeze(). * * When a number of calls to _cairo_cache_thaw() is made corresponding * to the number of calls to _cairo_cache_freeze() the cache will no * longer be "frozen". If the cache had grown larger than max_size * while frozen, entries will immediately be ejected (by random) from * the cache until the cache is smaller than max_size. Also, the * automatic ejection of entries on _cairo_cache_insert() will resume. **/ void _cairo_cache_thaw (cairo_cache_t *cache) { XASSERT (cache->freeze_count > 0); if (--cache->freeze_count == 0) _cairo_cache_shrink_to_accommodate (cache, 0); }
void XKeyEmitter::Execute( XSprObj *pSprObj, float fOverSec ) { // spLayer를 인수로 받아쓰면 될거 같은데... auto pLayer = SafeCast<XLayerParticle*>( pSprObj->GetLayer(GetLayerType(), GetnLayer()) ); if( XASSERT( pLayer ) ) { pLayer->SetEmitter( m_Emit ); } }
void XEWinSocketSvr::ReleaseConnectInMap( ID idKey, XSharedObj<XMap_Connection>& shoMapConnects ) { auto pMap = &shoMapConnects.GetSharedObj(); if( XASSERT(pMap) ) { ReleaseConnectInMap( idKey, *pMap ); } shoMapConnects.ReleaseSharedObj(); }