C++ NF_SHARE_PTR::AddElement方法代码示例

bool NFCTileModule::AddBuilding(const NFGUID & self, const int nX, const int nY, const NFGUID & id, const std::string & strCnfID)
{
	NF_SHARE_PTR<TileData> xTileData = mxTileData.GetElement(self);
	if (!xTileData)
	{
		xTileData = NF_SHARE_PTR<TileData>(NF_NEW TileData());
		mxTileData.AddElement(self, xTileData);
	}

	NF_SHARE_PTR<NFMapEx<int, TileBuilding>> xStateDataMap = xTileData->mxTileBuilding.GetElement(nX);
	if (!xStateDataMap)
	{
		xStateDataMap = NF_SHARE_PTR<NFMapEx<int, TileBuilding>>(NF_NEW NFMapEx<int, TileBuilding>());
		xTileData->mxTileBuilding.AddElement(nX, xStateDataMap);
	}

	NF_SHARE_PTR<TileBuilding> xTileBuilding = xStateDataMap->GetElement(nY);
	if (!xTileBuilding)
	{
		xTileBuilding = NF_SHARE_PTR<TileBuilding>(NF_NEW TileBuilding());
		xStateDataMap->AddElement(nY, xTileBuilding);
	}
	
	xTileBuilding->x = nX;
	xTileBuilding->y = nY;
	xTileBuilding->configID = strCnfID;
	xTileBuilding->ID = id;
	//save
	//SaveTileData(self);

	return true;
}

bool NFCTileModule::AddNPC(const NFGUID & self, const int nX, const int nY, const NFGUID & id, const std::string & strCnfID)
{
	NF_SHARE_PTR<TileData> xTileData = mxTileData.GetElement(self);
	if (!xTileData)
	{
		xTileData = NF_SHARE_PTR<TileData>(NF_NEW TileData());
		mxTileData.AddElement(self, xTileData);
	}

	NF_SHARE_PTR<NFMapEx<int, TileNPC>> xStateDataMap = xTileData->mxTileNPC.GetElement(nX);
	if (!xStateDataMap)
	{
		xStateDataMap = NF_SHARE_PTR<NFMapEx<int, TileNPC>>(NF_NEW NFMapEx<int, TileNPC>());
		xTileData->mxTileNPC.AddElement(nX, xStateDataMap);
	}

	NF_SHARE_PTR<TileNPC> xTileNPC = xStateDataMap->GetElement(nY);
	if (!xTileNPC)
	{
		xTileNPC = NF_SHARE_PTR<TileNPC>(NF_NEW TileNPC());
		xStateDataMap->AddElement(nY, xTileNPC);
	}

	xTileNPC->x = nX;
	xTileNPC->y = nY;
	xTileNPC->configID = strCnfID;
	xTileNPC->ID = id;

	return true;
}

void NFCPropertyConfigModule::Load()
{
    NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::InitProperty::ThisName());
    if (xLogicClass)
    {
		const std::vector<std::string>& strIdList = xLogicClass->GetIDList();
		for (int i = 0; i < strIdList.size(); ++i)
		{
			const std::string& strId = strIdList[i];

            NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = m_pElementModule->GetPropertyManager(strId);
            if (pPropertyManager)
            {
                int nJob = m_pElementModule->GetPropertyInt32(strId, NFrame::InitProperty::Job());
                int nLevel = m_pElementModule->GetPropertyInt32(strId, NFrame::InitProperty::Level());
                std::string strEffectData = m_pElementModule->GetPropertyString(strId, NFrame::InitProperty::EffectData());

				NF_SHARE_PTR <NFMapEx<int, std::string> > xPropertyMap = mhtCoefficienData.GetElement(nJob);
				if (!xPropertyMap)
				{
					xPropertyMap = NF_SHARE_PTR<NFMapEx<int, std::string>>(NF_NEW NFMapEx<int, std::string>());
					mhtCoefficienData.AddElement(nJob, xPropertyMap);
				}

				NF_SHARE_PTR<std::string> xRefPropertyIDName = xPropertyMap->GetElement(nLevel);
				if (!xRefPropertyIDName)
				{
					xRefPropertyIDName = NF_SHARE_PTR<std::string>(NF_NEW std::string(strEffectData));
				}

				xPropertyMap->AddElement(nLevel, xRefPropertyIDName);
            }
        }
    }
}

bool NFCEventProcessModule::AddAsyncEventCallBack( const NFIDENTID& objectID, const int nEventID, const EVENT_ASYNC_PROCESS_BEGIN_FUNCTOR_PTR& cb, const EVENT_ASYNC_PROCESS_END_FUNCTOR_PTR& cb_end )
{
	NF_SHARE_PTR<NFCObjectAsyncEventInfo> pObjectSyncEventInfo = mObjectSyncEventInfoMapEx.GetElement(objectID);
	if (nullptr == pObjectSyncEventInfo)
	{
		pObjectSyncEventInfo = NF_SHARE_PTR<NFCObjectAsyncEventInfo>(NF_NEW NFCObjectAsyncEventInfo());
		mObjectSyncEventInfoMapEx.AddElement(objectID, pObjectSyncEventInfo);
	}

	assert(NULL != pObjectSyncEventInfo);

	NF_SHARE_PTR<NFAsyncEventFunc> pSyncEventInfo = pObjectSyncEventInfo->GetElement(nEventID);
	if (nullptr == pSyncEventInfo)
	{
		pSyncEventInfo = NF_SHARE_PTR<NFAsyncEventFunc>(NF_NEW NFAsyncEventFunc());
		pObjectSyncEventInfo->AddElement(nEventID, pSyncEventInfo);
	}

	assert(NULL != pSyncEventInfo);

	pSyncEventInfo->xBeginFuncptr = cb;
	pSyncEventInfo->xEndFuncptr = cb_end;

	return true;
}

bool NFCSceneProcessModule::LoadSceneResource( const int nSceneID )
{
    char szSceneIDName[MAX_PATH] = { 0 };
    sprintf( szSceneIDName, "%d", nSceneID );

    const std::string& strSceneFilePath = m_pElementInfoModule->GetPropertyString( szSceneIDName, NFrame::Scene::FilePath() );
    const int nCanClone = m_pElementInfoModule->GetPropertyInt( szSceneIDName, NFrame::Scene::CanClone() );

    //场景对应资源
    NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>> pSceneResourceMap = mtSceneResourceConfig.GetElement( nSceneID );
    if ( !pSceneResourceMap.get() )
    {
        pSceneResourceMap = NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>>(NF_NEW NFMapEx<std::string, SceneSeedResource>());
        mtSceneResourceConfig.AddElement( nSceneID, pSceneResourceMap );
    }

	rapidxml::file<> xFileSource( strSceneFilePath.c_str() );
	rapidxml::xml_document<>  xFileDoc;
	xFileDoc.parse<0>( xFileSource.data() );

	//资源文件列表
	rapidxml::xml_node<>* pSeedFileRoot = xFileDoc.first_node();
	for ( rapidxml::xml_node<>* pSeedFileNode = pSeedFileRoot->first_node(); pSeedFileNode; pSeedFileNode = pSeedFileNode->next_sibling() )
	{
		//种子具体信息
		std::string strSeedID = pSeedFileNode->first_attribute( "ID" )->value();
		std::string strConfigID = pSeedFileNode->first_attribute( "NPCConfigID" )->value();
		float fSeedX = lexical_cast<float>(pSeedFileNode->first_attribute( "SeedX" )->value());
		float fSeedY = lexical_cast<float>(pSeedFileNode->first_attribute( "SeedY" )->value());
		float fSeedZ = lexical_cast<float>(pSeedFileNode->first_attribute( "SeedZ" )->value());

		if (!m_pElementInfoModule->ExistElement(strConfigID))
		{
			assert(0);
		}

		NF_SHARE_PTR<SceneSeedResource> pSeedResource = pSceneResourceMap->GetElement(strSeedID);
		if ( !pSeedResource.get() )
		{
			pSeedResource = NF_SHARE_PTR<SceneSeedResource>(NF_NEW SceneSeedResource());
			pSceneResourceMap->AddElement( strSeedID, pSeedResource );
		}

		pSeedResource->strSeedID = strSeedID;
		pSeedResource->strConfigID = strConfigID;
		pSeedResource->fSeedX = fSeedX;
		pSeedResource->fSeedY = fSeedY;
		pSeedResource->fSeedZ = fSeedZ;

	}

    return true;
}

bool NFCTileModule::AddTile(const NFGUID & self, const int nX, const int nY, const int nOpr)
{
	NF_SHARE_PTR<TileData> xTileData = mxTileData.GetElement(self);
	if (!xTileData)
	{
		xTileData = NF_SHARE_PTR<TileData>(NF_NEW TileData());
		mxTileData.AddElement(self, xTileData);
	}

	NF_SHARE_PTR<NFMapEx<int, TileState>> xStateDataMap = xTileData->mxTileState.GetElement(nX);
	if (!xStateDataMap)
	{
		xStateDataMap = NF_SHARE_PTR<NFMapEx<int, TileState>>(NF_NEW NFMapEx<int, TileState>());
		xTileData->mxTileState.AddElement(nX, xStateDataMap);
	}

	NF_SHARE_PTR<TileState> xTileState  = xStateDataMap->GetElement(nY);
	if (!xTileState)
	{
		xTileState = NF_SHARE_PTR<TileState>(NF_NEW TileState());
		xStateDataMap->AddElement(nY, xTileState);
	}
	else
	{
		if (nOpr == xTileState->state)
		{
			//has be deleted
			return false;
		}
	}
	xTileState->x = nX;
	xTileState->y = nY;
	xTileState->state = nOpr;
	//save
	//SaveTileData(self);

	return true;
}

bool NFCEventProcessModule::AddEventCallBack(const NFIDENTID& objectID, const int nEventID, const EVENT_PROCESS_FUNCTOR_PTR& cb)
{
    NF_SHARE_PTR<NFCObjectEventInfo> pObjectEventInfo = mObjectEventInfoMapEx.GetElement(objectID);
    if (!pObjectEventInfo.get())
    {
        pObjectEventInfo = NF_SHARE_PTR<NFCObjectEventInfo>(NF_NEW NFCObjectEventInfo());
        mObjectEventInfoMapEx.AddElement(objectID, pObjectEventInfo);
    }

    assert(nullptr != pObjectEventInfo);

    NF_SHARE_PTR<NFEventList> pEventInfo = pObjectEventInfo->GetElement(nEventID);
    if (!pEventInfo)
    {
        pEventInfo = NF_SHARE_PTR<NFEventList>(NF_NEW NFEventList());
        pObjectEventInfo->AddElement(nEventID, pEventInfo);
    }

    assert(nullptr != pEventInfo);

    pEventInfo->Add(cb);

    return true;
}

bool NFCSceneProcessModule::LoadInitFileResource( const int& nContainerID )
{
    char szSceneIDName[MAX_PATH] = { 0 };
    sprintf( szSceneIDName, "%d", nContainerID );

    const std::string& strSceneFilePath = m_pElementInfoModule->GetPropertyString( szSceneIDName, "FilePath" );
    const int nCanClone = m_pElementInfoModule->GetPropertyInt( szSceneIDName, "CanClone" );

    //场景对应资源
    NF_SHARE_PTR<NFMapEx<std::string, SceneGroupResource>> pSceneResourceMap = mtSceneResourceConfig.GetElement( nContainerID );
    if ( !pSceneResourceMap.get() )
    {
        pSceneResourceMap = NF_SHARE_PTR<NFMapEx<std::string, SceneGroupResource>>(NF_NEW NFMapEx<std::string, SceneGroupResource>());
        mtSceneResourceConfig.AddElement( nContainerID, pSceneResourceMap );
    }

    if ( !strSceneFilePath.empty() )
    {
        std::string strFilePathName( strSceneFilePath );
        strFilePathName.append( "File.xml" );

        NF_SHARE_PTR<SceneGroupResource> pSceneGroupResource = pSceneResourceMap->GetElement( "File.xml" );
        if ( !pSceneGroupResource.get() )
        {
            pSceneGroupResource = NF_SHARE_PTR<SceneGroupResource>(NF_NEW SceneGroupResource());
            pSceneGroupResource->bCanClone = (nCanClone > 0 ? true : false);
            pSceneResourceMap->AddElement( "File.xml", pSceneGroupResource );
        }

        rapidxml::file<> xFileSource( strFilePathName.c_str() );
        rapidxml::xml_document<>  xFileDoc;
        xFileDoc.parse<0>( xFileSource.data() );

        //资源文件列表
        rapidxml::xml_node<>* pSeedFileRoot = xFileDoc.first_node();
        for ( rapidxml::xml_node<>* pSeedFileNode = pSeedFileRoot->first_node(); pSeedFileNode; pSeedFileNode = pSeedFileNode->next_sibling() )
        {
            std::string strSeedFileName = pSeedFileNode->first_attribute( "ID" )->value();
            
            //资源对应种子列表
            NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>> pSeedResourceList = pSceneGroupResource->xSceneGroupResource.GetElement(strSeedFileName);
            if ( !pSeedResourceList.get() )
            {
                pSeedResourceList = NF_SHARE_PTR<NFMapEx<std::string, SceneSeedResource>>(NF_NEW NFMapEx<std::string, SceneSeedResource>());
                pSceneGroupResource->xSceneGroupResource.AddElement( strSeedFileName, pSeedResourceList );
            }

            std::string strObjectFileName( strSceneFilePath );
            strObjectFileName.append( strSeedFileName );
            strObjectFileName.append( ".xml" );


            rapidxml::file<> xSeedListSource( strObjectFileName.c_str() );
            rapidxml::xml_document<>  xFileDoc;
            xFileDoc.parse<0>( xSeedListSource.data() );
            rapidxml::xml_node<>* pSeedObjectRoot = xFileDoc.first_node();
            for ( rapidxml::xml_node<>* pSeedObjectNode = pSeedObjectRoot->first_node(); pSeedObjectNode; pSeedObjectNode = pSeedObjectNode->next_sibling() )
            {
                //种子具体信息
                std::string strSeedName = pSeedObjectNode->first_attribute( "ID" )->value();
                std::string strConfigID = pSeedObjectNode->first_attribute( "NPCConfigID" )->value();

                if (!m_pElementInfoModule->ExistElement(strConfigID))
                {
                    assert(0);
                }

                NF_SHARE_PTR<SceneSeedResource> pSeedResource = pSeedResourceList->GetElement(strSeedName);
                if ( !pSeedResource.get() )
                {
                    pSeedResource = NF_SHARE_PTR<SceneSeedResource>(NF_NEW SceneSeedResource());
                    pSeedResourceList->AddElement( strSeedName, pSeedResource );
                }

                pSeedResource->strSeedID = strSeedName;
                pSeedResource->strConfigID = strConfigID;
                pSeedResource->fSeedX = boost::lexical_cast<float>(pSeedObjectNode->first_attribute( "SeedX" )->value());
                pSeedResource->fSeedY = boost::lexical_cast<float>(pSeedObjectNode->first_attribute( "SeedY" )->value());
                pSeedResource->fSeedZ = boost::lexical_cast<float>(pSeedObjectNode->first_attribute( "SeedZ" )->value());
            }
        }
    }
    
    return true;
}

bool NFCCommonConfigModule::LoadConfig(const std::string& strFile)
{
	try
	{
		rapidxml::file<> xFile(strFile.c_str());
		rapidxml::xml_document<> xDoc;
		xDoc.parse<0>(xFile.data());

		rapidxml::xml_node<>* pRoot = xDoc.first_node();
		if (NULL == pRoot)
		{
			return false;
		}

		for (rapidxml::xml_node<>* pRootNode = pRoot->first_node(); pRootNode; pRootNode = pRootNode->next_sibling())
		{
			if (pRootNode)
			{
				rapidxml::xml_attribute<>* pNameAttribute = pRootNode->first_attribute("Name");
				if (NULL == pNameAttribute)
				{
					//foreach

					continue;
				}

				std::string strName = pNameAttribute->value();
				NF_SHARE_PTR<CStructInfo> pAppSDKConfigInfo = mmData.GetElement(strName);
				if (!pAppSDKConfigInfo)
				{
					pAppSDKConfigInfo = NF_SHARE_PTR<CStructInfo>(NF_NEW CStructInfo());
					mmData.AddElement(strName, pAppSDKConfigInfo);
				}

				
				for (rapidxml::xml_attribute<>* pAttribute = pRootNode->first_attribute(); pAttribute; pAttribute = pAttribute->next_attribute())
				{
					if (pAttribute)
					{
						const char* pstrConfigName = pAttribute->name();
						const char* pstrConfigValue = pAttribute->value();

						pAppSDKConfigInfo->mmStructAttribute.AddElement(pstrConfigName, NF_SHARE_PTR<std::string>(NF_NEW std::string(pstrConfigValue)));
					}
				}

				
				for (rapidxml::xml_node<>* pSDKInterfaceNode = pRootNode->first_node(); pSDKInterfaceNode; pSDKInterfaceNode = pSDKInterfaceNode->next_sibling())
				{
					if (pSDKInterfaceNode)
					{
						if (pSDKInterfaceNode->first_attribute("Name") != NULL)
						{
							std::string strStructItemName = pSDKInterfaceNode->first_attribute("Name")->value();   
							NF_SHARE_PTR<CAttributeList> pConfigData = pAppSDKConfigInfo->GetElement(strStructItemName);
							if (!pConfigData)
							{
								pConfigData = NF_SHARE_PTR<CAttributeList>(NF_NEW CAttributeList());
								pAppSDKConfigInfo->AddElement(strStructItemName, pConfigData);
							}

							for (rapidxml::xml_attribute<>* pAttribute = pSDKInterfaceNode->first_attribute(); pAttribute; pAttribute = pAttribute->next_attribute())
							{
								if (pAttribute)
								{
									const char* pstrConfigName = pAttribute->name();
									const char* pstrConfigValue = pAttribute->value();

									pConfigData->AddElement(pstrConfigName, NF_SHARE_PTR<std::string>(NF_NEW std::string(pstrConfigValue)));
								}
							}
						}
					}
				}
			}
		}
	}
	catch(...)
	{
		return false;
	}

	return true;
}

const bool NFCObjectSaveModule::LoadDataFormNoSql( const NFIDENTID& self , const std::string& strClassName)
{
    NF_SHARE_PTR<NFIPropertyManager> pProManager = m_pLogicClassModule->GetClassPropertyManager(strClassName);
    NF_SHARE_PTR<NFIRecordManager> pRecordManager = m_pLogicClassModule->GetClassRecordManager(strClassName);

    if (!pProManager || !pRecordManager)
    {
        return false;
    }

    std::vector<std::string> vFieldVec;
    std::vector<std::string> vValueVec;

    int nIndex = 0;
    std::string strName;
    std::map<std::string, int> xDataIndex;

    //witch Property Need Load
    NF_SHARE_PTR<NFIProperty> xProperty = pProManager->First(strName);
    while (xProperty)
    {
        if (xProperty->GetSave())
        {
            vFieldVec.push_back(strName);
            xDataIndex.insert(std::make_pair(strName, nIndex));
            nIndex ++;
        }

        strName.clear();
        xProperty = pProManager->Next(strName);
    }

    //witch Record Need Load
    NF_SHARE_PTR<NFIRecord> xRecord = pRecordManager->First(strName);
    while (xRecord)
    {
        if (xRecord->GetSave())
        {
            vFieldVec.push_back(strName);
            xDataIndex.insert(std::make_pair(strName, nIndex));
            nIndex ++;
        }

        strName.clear();
        xRecord = pRecordManager->Next(strName);
    }


    if(!m_pClusterSQLModule->Query(strClassName, self.ToString(), vFieldVec, vValueVec))
    {
        return false;
    }

    if (vFieldVec.size() != vValueVec.size())
    {
        return false;
    }

    NF_SHARE_PTR<NFMapEx<std::string, std::string> > pSelf = mtObjectCache.GetElement(self);
    if (!pSelf)
    {
        pSelf = NF_SHARE_PTR< NFMapEx<std::string, std::string> > (NF_NEW NFMapEx<std::string, std::string>());
        if (!mtObjectCache.AddElement(self, pSelf))
        {
            return false;
        }
    }

    for (int i = 0; i< vValueVec.size(); i++)
    {
        const std::string& strName = vFieldVec[i];
        const std::string& strValue = vValueVec[i];

        pSelf->AddElement(strName, NF_SHARE_PTR<std::string>(NF_NEW std::string(strValue)));
    }

    return true;
}

bool NFCScheduleModule::Execute()
{
	//execute every schedule
	NF_SHARE_PTR<NFMapEx <std::string, NFCScheduleElement >> xObjectSchedule = mObjectScheduleMap.First();
	while (xObjectSchedule)
	{
		std::string str;
		NF_SHARE_PTR<NFCScheduleElement> pSchedule = xObjectSchedule->First();
		while (pSchedule)
		{
			NFINT64 nNow = NFGetTime();
			if (nNow > pSchedule->mnNextTriggerTime)
			{
				std::map<NFGUID, std::string>::iterator itRet = mObjectRemoveList.find(pSchedule->self);
				if (itRet != mObjectRemoveList.end())
				{
					if (itRet->second != pSchedule->mstrScheduleName)
					{
						if (pSchedule->mnRemainCount > 0 || pSchedule->mbForever == true)
						{
							pSchedule->mnRemainCount--;
							pSchedule->DoHeartBeatEvent();

							if (pSchedule->mnRemainCount <= 0 && pSchedule->mbForever == false)
							{
								mObjectRemoveList.insert(std::map<NFGUID, std::string>::value_type(pSchedule->self, pSchedule->mstrScheduleName));
							}
							else
							{
								NFINT64 nNextCostTime = NFINT64(pSchedule->mfIntervalTime * 1000) * (pSchedule->mnAllCount - pSchedule->mnRemainCount);
								pSchedule->mnNextTriggerTime = pSchedule->mnStartTime + nNextCostTime;
							}
						}
					}
				}
			}

			pSchedule = xObjectSchedule->Next();
		}

		xObjectSchedule = mObjectScheduleMap.Next();
	}

	//remove schedule
	for (std::map<NFGUID, std::string>::iterator it = mObjectRemoveList.begin(); it != mObjectRemoveList.end(); ++it)
	{
		NFGUID self = it->first;
		std::string scheduleName = it->second;
		auto findIter = mObjectScheduleMap.GetElement(self);
		if (NULL != findIter)
		{
			findIter->RemoveElement(scheduleName);
			if (findIter->Count() == 0)
			{
				mObjectScheduleMap.RemoveElement(self);
			}
		}
	}
	mObjectRemoveList.clear();

	//add schedule
	for (std::list<NFCScheduleElement>::iterator iter = mObjectAddList.begin(); iter != mObjectAddList.end(); ++iter)
	{
		NF_SHARE_PTR< NFMapEx <std::string, NFCScheduleElement >> xObjectScheduleMap = mObjectScheduleMap.GetElement(iter->self);
		if (NULL == xObjectScheduleMap)
		{
			xObjectScheduleMap = NF_SHARE_PTR< NFMapEx <std::string, NFCScheduleElement >>(NF_NEW NFMapEx <std::string, NFCScheduleElement >());
			mObjectScheduleMap.AddElement(iter->self, xObjectScheduleMap);
		}

		NF_SHARE_PTR<NFCScheduleElement> xScheduleElement = xObjectScheduleMap->GetElement(iter->mstrScheduleName);
		if (NULL == xScheduleElement)
		{
			xScheduleElement = NF_SHARE_PTR<NFCScheduleElement>(NF_NEW NFCScheduleElement());
			*xScheduleElement = *iter;

			xObjectScheduleMap->AddElement(iter->mstrScheduleName, xScheduleElement);
		}
	}

	mObjectAddList.clear();

	////////////////////////////////////////////
	//execute every schedule
	NF_SHARE_PTR< NFCScheduleElement > xModuleSchedule = mModuleScheduleMap.First();
	while (xModuleSchedule)
	{
		NFINT64 nNow = NFGetTime();
		if (nNow > xModuleSchedule->mnNextTriggerTime)
		{
			if (xModuleSchedule->mnRemainCount > 0 || xModuleSchedule->mbForever == true)
			{
				xModuleSchedule->mnRemainCount--;
				xModuleSchedule->DoHeartBeatEvent();

				if (xModuleSchedule->mnRemainCount <= 0 && xModuleSchedule->mbForever == false)
				{
					mModuleRemoveList.push_back(xModuleSchedule->mstrScheduleName);
				}
				else
//.........这里部分代码省略.........