自学教程：C++ BEHAVIAC_ASSERT函数代码示例

	char* Workspace::ReadFileToBuffer(const char* file)	{		IFile* fp = CFileManager::GetInstance()->FileOpen(file, CFileSystem::EOpenAccess_Read);		if (!fp)		{			return 0;		}		//fp->Seek(0, CFileSystem::ESeekMoveMode_End);		uint32_t fileSize = (uint32_t)fp->GetSize();		BEHAVIAC_ASSERT(ms_fileBufferTop < kFileBufferDepth - 1);		uint32_t offset = ms_fileBufferOffset[ms_fileBufferTop++];		uint32_t offsetNew = offset + fileSize + 1;		ms_fileBufferOffset[ms_fileBufferTop] = offsetNew;		if (ms_fileBuffer == 0 || offsetNew > ms_fileBufferLength)		{			//to allocate extra 10k 			ms_fileBufferLength = offsetNew + 10 * 1024;			if (ms_fileBufferLength < 50 * 1024)			{				ms_fileBufferLength = 50 * 1024;			}			ms_fileBuffer = (char*)BEHAVIAC_REALLOC(ms_fileBuffer, ms_fileBufferLength);		}		BEHAVIAC_ASSERT(ms_fileBuffer);		BEHAVIAC_ASSERT(offsetNew < ms_fileBufferLength);		char* pBuffer = ms_fileBuffer + offset;		fp->Read(pBuffer, sizeof(char) * fileSize);		pBuffer[fileSize] = 0;		CFileManager::GetInstance()->FileClose(fp);		return pBuffer;	}

    EBTStatus ActionTask::update(Agent* pAgent, EBTStatus childStatus)    {        BEHAVIAC_UNUSED_VAR(pAgent);        BEHAVIAC_UNUSED_VAR(childStatus);        BEHAVIAC_ASSERT(Action::DynamicCast(this->GetNode()));        Action* pActionNode = (Action*)(this->GetNode());        EBTStatus result = pActionNode->Execute(pAgent, childStatus);        return result;    }

    Mutex::Mutex() : _impl(0)    {        // uint32_t s = sizeof(MutexImpl);        // printf("size of MutexImpl %d/n", s);        // Be sure that the shadow is large enough        BEHAVIAC_ASSERT(sizeof(m_Shadow) >= sizeof(MutexImpl));        // Use the shadow as memory space for the platform specific implementation        _impl = (MutexImpl*)m_Shadow;        pthread_mutex_init(&_impl->_mutex, 0);    }

int CFunctionHandler::EndFunction(IScriptObject* pObj){    if (!pObj)    {        BEHAVIAC_ASSERT(!"CFunctionHandler::EndFunction - Invalid object reference");        lua_pushnil(m_pLS);        return 0;    }    lua_xgetref(m_pLS, pObj->GetRef());    return 1;}

    int ConnectorInterface::GetBufferIndex(bool bReserve)    {#if BEHAVIAC_COMPILER_MSVC        BEHAVIAC_ASSERT(t_packetBufferIndex != TLS_OUT_OF_INDEXES);		uint32_t bufferIndex = (uint32_t)(uint64_t)TlsGetValue(t_packetBufferIndex);#else        BEHAVIAC_ASSERT(t_packetBufferIndex != (unsigned int) - 1);		uint32_t bufferIndex = t_packetBufferIndex;#endif        //WHEN bReserve is false, it is unsafe to allocate memory as other threads might be allocating        //you can avoid the following assert to malloc a block of memory in your thread at the very beginning        BEHAVIAC_ASSERT(bufferIndex > 0 || bReserve);        //bufferIndex initially is 0        if (bufferIndex <= 0 && bReserve)        {            bufferIndex = ReserveThreadPacketBuffer();        }        return (int)bufferIndex;    }

void CScriptSystem::CheckStackOnEndCall(){    m_CurrentDeep = (m_CurrentDeep == 0) ? 0 : --m_CurrentDeep;    int aLocal = lua_gettop(m_pLS);    if (m_BeginStackTop != aLocal && m_CurrentDeep == 0)    {        BEHAVIAC_ASSERT(false && "Last invoked LUA script has corrupted the LUA stack (don't ignore all)");        // Set new top (even if corrupted)        m_BeginStackTop = aLocal;    }}

    bool TaskTask::onenter(Agent* pAgent) {        this->m_activeChildIndex = CompositeTask::InvalidChildIndex;        BEHAVIAC_ASSERT(this->m_activeChildIndex == CompositeTask::InvalidChildIndex);        Task* pMethodNode = (Task*)(this->GetNode());#if BEHAVIAC_USE_HTN        _planner->Init(pAgent, pMethodNode);#endif //BEHAVIAC_USE_HTN        BEHAVIAC_UNUSED_VAR(pMethodNode);        return super::onenter(pAgent);    }

    void PlannerTaskReference::onexit(Agent* pAgent, EBTStatus status)    {        BEHAVIAC_UNUSED_VAR(pAgent);        BEHAVIAC_UNUSED_VAR(status);        BEHAVIAC_ASSERT(ReferencedBehavior::DynamicCast(this->m_node) != 0);        ReferencedBehavior* pNode = (ReferencedBehavior*)this->m_node;        BEHAVIAC_UNUSED_VAR(pNode);        BEHAVIAC_ASSERT(pNode != NULL);		this->m_subTree = 0;#if !BEHAVIAC_RELEASE        pAgent->LogReturnTree(pNode->GetReferencedTree());#endif        BEHAVIAC_ASSERT(this->currentState != NULL);        this->currentState->Pop();		this->currentState = 0;    }

    Workspace* Workspace::GetInstance()    {        if (ms_instance == NULL)        {            //if new  an Workspace class ,then the staict variable will be set value            Workspace* _workspace = BEHAVIAC_NEW Workspace();            BEHAVIAC_UNUSED_VAR(_workspace);            BEHAVIAC_ASSERT(ms_instance != NULL);        }        return ms_instance;    }

	void ReferencedBehavior::Attach(BehaviorNode* pAttachment, bool bIsPrecondition, bool bIsEffector, bool bIsTransition)	{		if (bIsTransition)		{			BEHAVIAC_ASSERT(!bIsEffector && !bIsPrecondition);			if (this->m_transitions == 0)			{				this->m_transitions = BEHAVIAC_NEW behaviac::vector<Transition*>();			}			BEHAVIAC_ASSERT(Transition::DynamicCast(pAttachment) != 0);			Transition* pTransition = (Transition*)pAttachment;			this->m_transitions->push_back(pTransition);			return;		}		BEHAVIAC_ASSERT(bIsTransition == false);		super::Attach(pAttachment, bIsPrecondition, bIsEffector, bIsTransition);	}

    void SingeChildTask::copyto(BehaviorTask* target) const    {        super::copyto(target);        BEHAVIAC_ASSERT(SingeChildTask::DynamicCast(target));        SingeChildTask* ttask = (SingeChildTask*)target;        if (this->m_root)        {            //referencebehavior/query, etc.            if (!ttask->m_root)            {                const BehaviorNode* pNode = this->m_root->GetNode();                BEHAVIAC_ASSERT(BehaviorTree::DynamicCast(pNode));                ttask->m_root = pNode->CreateAndInitTask();            }            BEHAVIAC_ASSERT(ttask->m_root);            this->m_root->copyto(ttask->m_root);        }    }

    void SingeChildTask::load(ISerializableNode* node)    {        super::load(node);        if (this->m_status != BT_INVALID)        {            CSerializationID  rootId("root");            ISerializableNode* rootNode = node->findChild(rootId);            BEHAVIAC_ASSERT(rootNode);            this->m_root->load(rootNode);        }    }

    void Context::CleanupInstances()    {        //don't delete it as it is DestroyInstance's resposibity        //for (Context::NamedAgents_t::iterator it = m_namedAgents.begin(); it != m_namedAgents.end(); ++it)        //{        //	Agent* pAgent = it->second;        //	BEHAVIAC_DELETE(pAgent);        //}        BEHAVIAC_ASSERT(m_namedAgents.size() == 0, "you need to call DestroyInstance or UnbindInstance");        m_namedAgents.clear();    }

	bool CFileSystem::copyFile(const char* lpExistingFileName,		const char* lpNewFileName,		bool bFailIfExists)	{		BEHAVIAC_UNUSED_VAR(lpExistingFileName);		BEHAVIAC_UNUSED_VAR(lpNewFileName);		BEHAVIAC_UNUSED_VAR(bFailIfExists);		BEHAVIAC_ASSERT(0);		return false;	}

    EBTStatus IfElseTask::update(Agent* pAgent, EBTStatus childStatus) {		BEHAVIAC_ASSERT(childStatus != BT_INVALID);		BEHAVIAC_ASSERT(this->m_children.size() == 3);		EBTStatus conditionResult = BT_INVALID;		if (childStatus == BT_SUCCESS || childStatus == BT_FAILURE) {			// if the condition returned running then ended with childStatus			conditionResult = childStatus;		}		if (this->m_activeChildIndex == CompositeTask::InvalidChildIndex) {            BehaviorTask* pCondition = this->m_children[0];			if (conditionResult == BT_INVALID) {				// condition has not been checked				conditionResult = pCondition->exec(pAgent);			}            if (conditionResult == BT_SUCCESS) {				// if                this->m_activeChildIndex = 1;            } else if (conditionResult == BT_FAILURE) {				// else                this->m_activeChildIndex = 2;            }        }		else {			return childStatus;		}        if (this->m_activeChildIndex != CompositeTask::InvalidChildIndex) {            BehaviorTask* pBehavior = this->m_children[this->m_activeChildIndex];            EBTStatus s = pBehavior->exec(pAgent);            return s;        }        return BT_RUNNING;    }

        size_t Read(Handle& h, const void* buffer, size_t bytesMax)        {            size_t bytesRead = 0;            if (bytesMax == 0 || !h)            {                return bytesRead;            }            fd_set readfds;            FD_ZERO(&readfds);            FD_SET(::AsWinSocket(h), &readfds);            struct timeval tv;            tv.tv_sec = 0;            tv.tv_usec = 100000;//0.1s            int rv = ::select(1, &readfds, 0, 0, &tv);            if (rv == -1)            {                BEHAVIAC_ASSERT(0);            }            else if (rv == 0)            {                //timeout            }            else            {                int res = ::recv(::AsWinSocket(h), (char*)buffer, (int)bytesMax, 0);                if (res == SOCKET_ERROR)                {                    int err = WSAGetLastError();                    if (err == WSAECONNRESET || err == WSAECONNABORTED)                    {                        Close(h);                    }                }                else                {                    bytesRead = res;                    gs_packetsReceived++;                }                return bytesRead;            }            return 0;        }

    void BehaviorNode::load_custom(int version, const char* agentType, BsonDeserizer& d)    {        d.OpenDocument();        BsonDeserizer::BsonTypes type = d.ReadType();        BEHAVIAC_UNUSED_VAR(type);        //BEHAVIAC_ASSERT(type == BsonDeserizer.BsonTypes.BT_NodeElement);        BEHAVIAC_ASSERT(type == BsonDeserizer::BT_NodeElement);        d.OpenDocument();        BehaviorNode* pChildNode = this->load(agentType, d, version);        this->m_customCondition = pChildNode;        d.CloseDocument(false);        d.CloseDocument(false);        type = d.ReadType();        //BEHAVIAC_ASSERT(type == BsonDeserizer.BsonTypes.BT_None);        BEHAVIAC_ASSERT(type == BsonDeserizer::BT_None);    }

    bool BsonDeserizer::OpenDocument()    {        const char* head = this->m_pPtr;        uint32_t size = this->ReadInt32();        //uint16_t size = this->ReadUInt16();        const char* end = head + size - 1;        if (*end == 0)        {#if USE_DOCUMENET            BEHAVIAC_ASSERT(this->m_documentStackTop >= 0 && this->m_documentStackTop < kDocumentStackMax - 1);            this->m_documentStack[this->m_documentStackTop++] = this->m_document;            this->m_document = head;#endif            return true;        }        BEHAVIAC_ASSERT(0);        return false;    }

    int DecoratorWeight::GetWeight(behaviac::Agent* pAgent) const    {        if (this->m_weight_var)        {            BEHAVIAC_ASSERT(this->m_weight_var);            TProperty<int>* pP = (TProperty<int>*)this->m_weight_var;            uint64_t count = pP->GetValue(pAgent);            return (count == ((uint64_t) - 1) ? -1 : (int)count);        }        return 0;    }

	bool ReferencedBehaviorTask::onevent(Agent* pAgent, const char* eventName)	{		if (this->m_status == BT_RUNNING && this->m_node->HasEvents())        {			BEHAVIAC_ASSERT(this->m_subTree);            if (!this->m_subTree->onevent(pAgent, eventName))            {                return false;            }		}		return true;	}

    int DecoratorCount::GetCount(Agent* pAgent) const    {        if (this->m_count_var)        {            BEHAVIAC_ASSERT(this->m_count_var);            TProperty<int>* pP = (TProperty<int>*)this->m_count_var;            uint64_t count = pP->GetValue(pAgent);            return (count == ((uint64_t) - 1) ? -1 : (int)count);        }        return 0;    }

    bool IfElseTask::onenter(Agent* pAgent) {        BEHAVIAC_UNUSED_VAR(pAgent);        //reset it as it will be checked for the condition execution at the first time        this->m_activeChildIndex = CompositeTask::InvalidChildIndex;        if (this->m_children.size() == 3) {            return true;        }        BEHAVIAC_ASSERT(false, "IfElseTask has to have three children: condition, if, else");        return false;    }

    bool Mutex::TryLock()    {#if !BEHAVIAC_COMPILER_GCC_LINUX        int rval = pthread_mutex_trylock(&_impl->_mutex);        // valid returns are 0 (locked) and [EBUSY]        BEHAVIAC_ASSERT(rval == 0 || rval == EBUSY, "critical_section::trylock: pthread_mutex_trylock failed");        bool gotlock = (rval == 0);        return gotlock;#else        return false;#endif    }