BVB Source Codes

CRYENGINE Show SharedParamsManager.h Source code

Return Download CRYENGINE: download SharedParamsManager.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Shared parameters manager.
  8.              System for managing storage and retrieval of shared parameters.
  9.  
  10.    -------------------------------------------------------------------------
  11.    History:
  12.    - 29:04:2010: Created by Paul Slinger
  13.  
  14. *************************************************************************/
  15.  
  16. ////////////////////////////////////////////////////////////////////////////////////////////////////
  17. // Using the Shared Parameters System
  18. // ----------------------------------
  19. //
  20. // 1) Declare a shared parameters structure
  21. //
  22. //      BEGIN_SHARED_PARAMS(SMySharedParams)
  23. //
  24. //        inline SMySharedParams(const string &_someData) : someData(_someData)
  25. //        {
  26. //        }
  27. //
  28. //        string        someData;
  29. //
  30. //      END_SHARED_PARAMS
  31. //
  32. // 2) Define type information for the shared parameters structure
  33. //
  34. //      DEFINE_SHARED_PARAMS_TYPE_INFO(SMySharedParams)
  35. //
  36. // 2) Generate a 32 bit crc (optional)
  37. //
  38. //      uint32 crc32 = pSharedParamsManager->GenerateCRC32("Name goes here");
  39. //
  40. // 3) Register the shared parameters
  41. //
  42. //      pSharedParamsManager->Register(crc32, SMySharedParams("I like chocolate milk"));
  43. //
  44. //        or
  45. //
  46. //      pSharedParamsManager->Register("MySharedParams", SMySharedParams("I like chocolate milk"));
  47. //
  48. // 4) Retrieve the shared parameters
  49. //
  50. //      SMySharedParamsConstPtr pSharedParams = CastSharedParamsPtr<SMySharedParams>pSharedParamsManager->Get(crc32);
  51. //
  52. //        or
  53. //
  54. //      SMySharedParamsConstPtr pSharedParams = CastSharedParamsPtr<SMySharedParams>pSharedParamsManager->Get("Name goes here");
  55. //
  56. // Additional Info
  57. // ---------------
  58. // The shared parameters manager stores a map of names internally in order to catch crc collisions.
  59. // This means that in the unlikely event of a name crc collision, GenerateCRC32() will return 0.
  60. // Register() and Get() will both return a null pointer.
  61. ////////////////////////////////////////////////////////////////////////////////////////////////////
  62.  
  63. #pragma once
  64.  
  65. #include <CrySystem/ISystem.h>
  66. #include <CryMemory/STLPoolAllocator_ManyElems.h>
  67. #include <CryCore/StlUtils.h>
  68. #include "ISharedParamsManager.h"
  69. #include "SharedParams/ISharedParams.h"
  70.  
  71. ////////////////////////////////////////////////////////////////////////////////////////////////////
  72. // Shared parameters manager class.
  73. // System for managing storage and retrieval of game parameters.
  74. ////////////////////////////////////////////////////////////////////////////////////////////////////
  75. class CSharedParamsManager : public ISharedParamsManager
  76. {
  77. public:
  78.  
  79.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  80.         // Default constructor.
  81.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  82.         CSharedParamsManager();
  83.  
  84.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  85.         // Destructor.
  86.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  87.         ~CSharedParamsManager();
  88.  
  89.         // ISharedParamsManager
  90.  
  91.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  92.         // Generate unique 32 bit crc.
  93.         //
  94.         // Params: pName - unique name
  95.         //
  96.         // Return: unique 32 bit crc
  97.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  98.         virtual uint32 GenerateCRC32(const char* pName);
  99.  
  100.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  101.         // Register shared parameters.
  102.         //
  103.         // Params: crc32        - unique 32 bit crc
  104.         //                               sharedParams - shared parameters
  105.         //
  106.         // Return: pointer to shared parameters
  107.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  108.         virtual ISharedParamsConstPtr Register(uint32 crc32, const ISharedParams& sharedParams);
  109.  
  110.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  111.         // Register shared parameters.
  112.         //
  113.         // Params: pName        - unique name
  114.         //                               sharedParams - shared parameters
  115.         //
  116.         // Return: pointer to shared parameters
  117.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  118.         virtual ISharedParamsConstPtr Register(const char* pName, const ISharedParams& sharedParams);
  119.  
  120.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  121.         // Remove shared parameters.
  122.         //
  123.         // Params: crc32 - unique 32 bit crc
  124.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  125.         virtual void Remove(uint32 crc32);
  126.  
  127.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  128.         // Remove shared parameters.
  129.         //
  130.         // Params: pName - unique name
  131.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  132.         virtual void Remove(const char* pName);
  133.  
  134.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  135.         // Remove all shared parameters by type.
  136.         //
  137.         // Params: typeInfo - type information of to be removed
  138.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  139.         virtual void RemoveByType(const CSharedParamsTypeInfo& typeInfo);
  140.  
  141.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  142.         // Get shared parameters.
  143.         //
  144.         // Params: crc32 - unique 32 bit crc
  145.         //
  146.         // Return: pointer to shared parameters
  147.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  148.         virtual ISharedParamsConstPtr Get(uint32 crc32) const;
  149.  
  150.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  151.         // Get shared parameters.
  152.         //
  153.         // Params: pName - unique name
  154.         //
  155.         // Return: pointer to shared parameters
  156.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  157.         virtual ISharedParamsConstPtr Get(const char* pName) const;
  158.  
  159.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  160.         // Reset.
  161.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  162.         virtual void Reset();
  163.  
  164.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  165.         // Release.
  166.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  167.         virtual void Release();
  168.  
  169.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  170.         // Get memory statistics.
  171.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  172.         virtual void GetMemoryStatistics(ICrySizer* pSizer);
  173.  
  174.         // ~ISharedParamsManager
  175.  
  176.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  177.         // Lock.
  178.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  179.         void Lock();
  180.  
  181.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  182.         // Unlock.
  183.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  184.         void Unlock();
  185.  
  186. private:
  187.  
  188.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  189.         // Verify unlocked.
  190.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  191.         bool VerifyUnlocked() const;
  192.  
  193.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  194.         // Map of names.
  195.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  196.         typedef std::unordered_map<uint32, string, std::hash<uint32>, std::equal_to<uint32>, stl::STLPoolAllocator_ManyElems<std::pair<const uint32, string>>> TNameMap;
  197.  
  198.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  199.         // Map of shared parameters.
  200.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  201.         typedef std::unordered_map<uint32, ISharedParamsPtr, std::hash<uint32>, std::equal_to<uint32>, stl::STLPoolAllocator_ManyElems<std::pair<const uint32, ISharedParamsPtr>>> TRecordMap;
  202.  
  203.         TNameMap     m_names;
  204.  
  205.         TRecordMap   m_records;
  206.  
  207.         size_t       m_sizeOfSharedParams;
  208.  
  209.         bool         m_lock;
  210.  
  211.         mutable bool m_outputLockWarning;
  212. };
  213.  
downloadSharedParamsManager.h 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