BVB Source Codes

CRYENGINE Show SharedParamsManager.cpp Source code

Return Download CRYENGINE: download SharedParamsManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: System for managing storage and retrieval of shared parameters.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 29:04:2010: Created by Paul Slinger
  12.  
  13. *************************************************************************/
  14.  
  15. #include "StdAfx.h"
  16. #include "SharedParamsManager.h"
  17.  
  18. CSharedParamsManager::CSharedParamsManager() : m_sizeOfSharedParams(0), m_lock(true), m_outputLockWarning(true)
  19. {
  20. }
  21.  
  22. CSharedParamsManager::~CSharedParamsManager()
  23. {
  24. }
  25.  
  26. uint32 CSharedParamsManager::GenerateCRC32(const char* pName)
  27. {
  28.         // Check lock.
  29.  
  30.         if (VerifyUnlocked())
  31.         {
  32.                 // Check name.
  33.  
  34.                 if (pName)
  35.                 {
  36.                         // Check to see if name has already been registered.
  37.  
  38.                         uint32 crc32 = CCrc32::Compute(pName);
  39.  
  40.                         TNameMap::const_iterator iName = m_names.find(crc32);
  41.  
  42.                         if (iName == m_names.end())
  43.                         {
  44.                                 // Register name.
  45.  
  46.                                 m_names.insert(TNameMap::value_type(crc32, pName));
  47.  
  48.                                 return crc32;
  49.                         }
  50.                         else if (iName->second == pName)
  51.                         {
  52.                                 return crc32;
  53.                         }
  54.                 }
  55.         }
  56.  
  57.         return 0;
  58. }
  59.  
  60. ISharedParamsConstPtr CSharedParamsManager::Register(uint32 crc32, const ISharedParams& sharedParams)
  61. {
  62.         // Check lock.
  63.  
  64.         if (VerifyUnlocked())
  65.         {
  66.                 // Check name has been registered.
  67.  
  68.                 if (m_names.find(crc32) != m_names.end())
  69.                 {
  70.                         // Are we running the editor? If so don't register shared parameters.
  71.  
  72.                         if (gEnv->IsEditor())
  73.                         {
  74.                                 return ISharedParamsConstPtr(sharedParams.Clone());
  75.                         }
  76.                         else
  77.                         {
  78.                                 // Check to see if record already exists.
  79.  
  80.                                 if (m_records.find(crc32) == m_records.end())
  81.                                 {
  82.                                         // Clone shared parameters.
  83.  
  84.                                         ISharedParamsPtr pSharedParams(sharedParams.Clone());
  85.  
  86.                                         if (pSharedParams)
  87.                                         {
  88.                                                 // Store record.
  89.  
  90.                                                 m_records.insert(TRecordMap::value_type(crc32, pSharedParams));
  91.  
  92.                                                 m_sizeOfSharedParams += pSharedParams->GetTypeInfo().GetSize();
  93.  
  94.                                                 return pSharedParams;
  95.                                         }
  96.                                 }
  97.                         }
  98.                 }
  99.         }
  100.  
  101.         return ISharedParamsConstPtr();
  102. }
  103.  
  104. ISharedParamsConstPtr CSharedParamsManager::Register(const char* pName, const ISharedParams& sharedParams)
  105. {
  106.         // Check lock.
  107.  
  108.         if (VerifyUnlocked())
  109.         {
  110.                 // Generate 32 bit crc.
  111.  
  112.                 uint32 crc32 = GenerateCRC32(pName);
  113.  
  114.                 if (crc32)
  115.                 {
  116.                         // Register shared parameters.
  117.  
  118.                         return Register(crc32, sharedParams);
  119.                 }
  120.         }
  121.  
  122.         return ISharedParamsConstPtr();
  123. }
  124.  
  125. void CSharedParamsManager::Remove(uint32 crc32)
  126. {
  127.         // Check lock.
  128.  
  129.         if (VerifyUnlocked())
  130.         {
  131.                 // Get record.
  132.  
  133.                 TRecordMap::iterator iRecord = m_records.find(crc32);
  134.  
  135.                 if (iRecord != m_records.end())
  136.                 {
  137.                         // Remove record.
  138.  
  139.                         m_records.erase(iRecord);
  140.                 }
  141.         }
  142. }
  143.  
  144. void CSharedParamsManager::Remove(const char* pName)
  145. {
  146.         // Check lock.
  147.  
  148.         if (VerifyUnlocked())
  149.         {
  150.                 // Check name.
  151.  
  152.                 if (pName)
  153.                 {
  154.                         uint32 crc32 = CCrc32::Compute(pName);
  155.  
  156.                         TNameMap::const_iterator iName = m_names.find(crc32);
  157.  
  158.                         if (iName != m_names.end() && iName->second == pName)
  159.                         {
  160.                                 // Remove record.
  161.  
  162.                                 Remove(crc32);
  163.                         }
  164.                 }
  165.         }
  166. }
  167.  
  168. void CSharedParamsManager::RemoveByType(const CSharedParamsTypeInfo& typeInfo)
  169. {
  170.         // Check lock.
  171.  
  172.         if (VerifyUnlocked())
  173.         {
  174.                 // Remove records by type.
  175.  
  176.                 for (TRecordMap::iterator iRecord = m_records.begin(), iEndRecord = m_records.end(); iRecord != iEndRecord; )
  177.                 {
  178.                         const ISharedParamsPtr& pSharedParams = iRecord->second;
  179.  
  180.                         if (pSharedParams->GetTypeInfo() == typeInfo)
  181.                         {
  182.                                 TRecordMap::iterator iEraseRecord = iRecord;
  183.  
  184.                                 ++iRecord;
  185.  
  186.                                 m_records.erase(iEraseRecord);
  187.                         }
  188.                         else
  189.                         {
  190.                                 ++iRecord;
  191.                         }
  192.                 }
  193.         }
  194. }
  195.  
  196. ISharedParamsConstPtr CSharedParamsManager::Get(uint32 crc32) const
  197. {
  198.         // Check lock.
  199.  
  200.         if (VerifyUnlocked())
  201.         {
  202.                 // Get record.
  203.  
  204.                 TRecordMap::const_iterator iRecord = m_records.find(crc32);
  205.  
  206.                 if (iRecord != m_records.end())
  207.                 {
  208.                         return iRecord->second;
  209.                 }
  210.         }
  211.  
  212.         return ISharedParamsConstPtr();
  213. }
  214.  
  215. ISharedParamsConstPtr CSharedParamsManager::Get(const char* pName) const
  216. {
  217.         // Check lock.
  218.  
  219.         if (VerifyUnlocked())
  220.         {
  221.                 // Check name.
  222.  
  223.                 if (pName)
  224.                 {
  225.                         uint32 crc32 = CCrc32::Compute(pName);
  226.  
  227.                         TNameMap::const_iterator iName = m_names.find(crc32);
  228.  
  229.                         if (iName != m_names.end() && iName->second == pName)
  230.                         {
  231.                                 // Get record.
  232.  
  233.                                 return Get(crc32);
  234.                         }
  235.                 }
  236.         }
  237.  
  238.         return ISharedParamsConstPtr();
  239. }
  240.  
  241. void CSharedParamsManager::Reset()
  242. {
  243. #ifdef _DEBUG
  244.         for (TRecordMap::const_iterator iRecord = m_records.begin(), iEndRecord = m_records.end(); iRecord != iEndRecord; ++iRecord)
  245.         {
  246.                 long use_count = iRecord->second.use_count();
  247.  
  248.                 CRY_ASSERT_TRACE(use_count == 1, ("Shared params structure '%s' is still referenced in %d place%s", m_names[iRecord->first].c_str(), use_count - 1, (use_count == 2) ? "" : "s"));
  249.         }
  250. #endif //_DEBUG
  251.  
  252.         // Ensure all memory is returned to the level heap.
  253.  
  254.         stl::free_container(m_records);
  255.  
  256.         stl::free_container(m_names);
  257.  
  258.         m_sizeOfSharedParams = 0;
  259. }
  260.  
  261. void CSharedParamsManager::Release()
  262. {
  263.         delete this;
  264. }
  265.  
  266. void CSharedParamsManager::GetMemoryStatistics(ICrySizer* pSizer)
  267. {
  268.         CRY_ASSERT(pSizer);
  269.  
  270.         pSizer->Add(*this);
  271.  
  272.         pSizer->AddContainer(m_names);
  273.  
  274.         pSizer->AddContainer(m_records);
  275.  
  276.         pSizer->AddObject(&m_sizeOfSharedParams, m_sizeOfSharedParams);
  277. }
  278.  
  279. void CSharedParamsManager::Lock()
  280. {
  281.         m_lock = true;
  282. }
  283.  
  284. void CSharedParamsManager::Unlock()
  285. {
  286.         m_lock = false;
  287. }
  288.  
  289. bool CSharedParamsManager::VerifyUnlocked() const
  290. {
  291.         CRY_ASSERT(!m_lock);
  292.  
  293.         if (m_lock && m_outputLockWarning)
  294.         {
  295.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CSharedParamsManager::VerifyUnlocked: Attempting to access shared parameters whilst manager is locked");
  296.  
  297.                 m_outputLockWarning = false;
  298.         }
  299.  
  300.         return !m_lock;
  301. }
  302.  
downloadSharedParamsManager.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top