Skip to content

Instantly share code, notes, and snippets.

@Emtec

Emtec/gist:b6bd13739432a54c61c2

Created July 13, 2015 11:41
Show Gist options
  • Save Emtec/b6bd13739432a54c61c2 to your computer and use it in GitHub Desktop.
Save Emtec/b6bd13739432a54c61c2 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.cpp
#include "IndexedStructureMap.h"
#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>
// ---------------------------------------------------------------------------------
// IndexedMapObject
// ---------------------------------------------------------------------------------
IndexedMapObject::IndexedMapObject()
{
RegisterKeys();
}
MapKeyTypes IndexedMapObject::GetKeyWithTypes()
{
return _types;
}
// ---------------------------------------------------------------------------------
// IndexedStructureMap
// ---------------------------------------------------------------------------------
template<class ObjectClass, class KeyClass>
IndexedStructureMap<ObjectClass, KeyClass>::IndexedStructureMap()
{
_CREATE_MAP_TYPE(IndexedMapItemType::Boolean, bool, KeyClass);
_CREATE_MAP_TYPE(IndexedMapItemType::Uint8, uint8, KeyClass);
_CREATE_MAP_TYPE(IndexedMapItemType::Uint32, uint32, KeyClass);
_CREATE_MAP_TYPE(IndexedMapItemType::Uint64, uint64, KeyClass);
_CREATE_MAP_TYPE(IndexedMapItemType::Int8, int8, KeyClass);
_CREATE_MAP_TYPE(IndexedMapItemType::Int32, int32, KeyClass);
_CREATE_MAP_TYPE(IndexedMapItemType::Int64, int64, KeyClass);
_CREATE_MAP_TYPE(IndexedMapItemType::String, std::string, KeyClass);
IndexedMapObject o = (IndexedMapObject)(new ObjectClass());
MapKeyTypes::iterator itr = o.GetKeyWithTypes().begin();
for (; itr != o.GetKeyWithTypes().end(); ++i)
{
switch (itr->second)
{
case IndexedMapItemType::Boolean: {
_keysMap[IndexedMapItemType::Boolean][itr->first] = std::map<bool, ObjectClass*>();
} break;
case IndexedMapItemType::Uint8: {
_keysMap[IndexedMapItemType::Uint8][itr->first] = std::map<uint8, ObjectClass*>();
} break;
case IndexedMapItemType::Uint32: {
_keysMap[IndexedMapItemType::Uint32][itr->first] = std::map<uint32, ObjectClass*>();
} break;
case IndexedMapItemType::Uint64: {
_keysMap[IndexedMapItemType::Uint64][itr->first] = std::map<uint64, ObjectClass*>();
} break;
case IndexedMapItemType::Int8: {
_keysMap[IndexedMapItemType::Int8][itr->first] = std::map<int8, ObjectClass*>();
} break;
case IndexedMapItemType::Int32: {
_keysMap[IndexedMapItemType::Int32][itr->first] = std::map<int32, ObjectClass*>();
} break;
case IndexedMapItemType::Int64: {
_keysMap[IndexedMapItemType::Int64][itr->first] = std::map<int64, ObjectClass*>();
} break;
case IndexedMapItemType::String: {
_keysMap[IndexedMapItemType::String][itr->first] = std::map<std::string, ObjectClass*>();
} break;
default: {
ASSERT(false, "UNKNOWN TYPE INDEX")
} break;
}
}
}
template<class ObjectClass, class KeyClass>
bool IndexedStructureMap<ObjectClass, KeyClass>::_HasElement(KeyClass key)
{
return std::binary_search(_objectMap.begin(), _objectMap.end(), key);
}
template<class ObjectClass, class KeyClass>
void IndexedStructureMap<ObjectClass, KeyClass>::Insert(KeyClass key, ObjectClass* object)
{
boost::shared_lock<boost::shared_mutex> lock(_lock);
if (_HasElement(key))
_Remove(key, object);
_Insert(key, object);
}
template<class ObjectClass, class KeyClass>
void IndexedStructureMap<ObjectClass, KeyClass>::_Insert(KeyClass key, ObjectClass* object)
{
_objectMap[key] = object;
}
template<class ObjectClass, class KeyClass>
void IndexedStructureMap<ObjectClass, KeyClass>::Remove(KeyClass key, ObjectClass* object)
{
boost::shared_lock<boost::shared_mutex> lock(_lock);
if (!_HasElement(key))
return;
_Remove(key, object);
}
template<class ObjectClass, class KeyClass>
void IndexedStructureMap<ObjectClass, KeyClass>::_Remove(KeyClass key)
{
_objectMap.erase(key);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment