/*
 CONCEPT SKETCH:
 Singleton Cache Manager Using Custom Smart Pointer Deleters
 by Patrick Hebron
*/

#include <iostream>
#include <memory>
#include <map>

typedef std::shared_ptr<class Object>	ObjectRef;
typedef std::shared_ptr<class Derived>	DerivedRef;

class Object
{
  public:

	std::string name;

	Object(const std::string& n = "") : name( n ) { std::cout << "Object(" << name << ")" << std::endl; }
	virtual ~Object() { std::cout << "~Object(" << name << ")" << std::endl; }

	virtual void init() { std::cout << "Object::init(" << name << ")" << std::endl; }

	void testA() { std::cout << "Object::testA(" << name << ")" << std::endl; }
	virtual void testB() { std::cout << "Object::testB(" << name << ")" << std::endl; }
};

class Derived : public Object
{
  public:

	Derived(const std::string& n = "") : Object( n ) { std::cout << "Derived(" << name << ")" << std::endl; }
	~Derived() { std::cout << "~Derived(" << name << ")" << std::endl; }

	void testB() { std::cout << "Derived::testB(" << name << ")" << std::endl; }
};

/** @brief cache manager singleton class */
struct CacheManager
{
  private:

	std::map<uintptr_t,int> mItems;

	bool cache_contains(uintptr_t key) const
	{
		return ( mItems.find( key ) != mItems.cend() );
	}

	void cache_remove(uintptr_t key)
	{
		auto needle = mItems.find( key );
		if( needle != mItems.end() )
			mItems.erase( needle );
	}

	void cache_insert(uintptr_t key, int value)
	{
		mItems[ key ] = value;
	}

	int cache_retrieve(uintptr_t key) const
	{
		auto needle = mItems.find( key );
		if( needle != mItems.cend() )
			return needle->second;
		throw std::runtime_error( "Cache manager could not retrieve item." );
	}

  public:

	static CacheManager* get()
	{
		static CacheManager* manager = NULL;

		if( manager == NULL )
			manager = new CacheManager();

		return manager;
	}

	static uintptr_t cast_key(const Object* obj)
	{
		return reinterpret_cast<uintptr_t>( obj );
	}

	static bool contains(const Object* key)
	{
		std::cout << "CacheManager::contains(" << key->name << ")" << std::endl;

		return get()->cache_contains( cast_key( key ) );
	}

	static void remove(const Object* key)
	{
		std::cout << "CacheManager::remove(" << key->name << ")" << std::endl;

		get()->cache_remove( cast_key( key ) );
	}

	static void insert(const Object* key, int value)
	{
		std::cout << "CacheManager::insert(" << key->name << ")" << std::endl;

		get()->cache_insert( cast_key( key ), value );
	}

	static int retrieve(const Object* key)
	{
		std::cout << "CacheManager::retrieve(" << key->name << ")" << std::endl;

		return get()->cache_retrieve( cast_key( key ) );
	}
};

static void CachedObjectDeleter(Object* item)
{
	CacheManager::remove( item );

	std::cout << "CachedObjectDeleter(" << item->name << ")" << std::endl;

	delete item;
}

using namespace std;

int main(int argc, const char * argv[])
{
	std::cout << std::string( 20, '-' ) << std::endl;

	{
		ObjectRef item = ObjectRef( new Object("item0") );
		item->testA();
		item->testB();
	}

	std::cout << std::string( 20, '-' ) << std::endl;

	{
		ObjectRef item = ObjectRef( new Object("item1"), CachedObjectDeleter );
		item->testA();
		item->testB();
	}

	std::cout << std::string( 20, '-' ) << std::endl;

	{
		ObjectRef item = ObjectRef( new Derived("item2") );
		CacheManager::insert( item.get(), 2 );
		item->testA();
		item->testB();
	}

	std::cout << std::string( 20, '-' ) << std::endl;

	{
		ObjectRef item = ObjectRef( new Derived("item3"), CachedObjectDeleter );
		CacheManager::insert( item.get(), 3 );
		item->testA();
		item->testB();
	}

	std::cout << std::string( 20, '-' ) << std::endl;

	{
		DerivedRef item = DerivedRef( new Derived("item4") );
		CacheManager::insert( item.get(), 4 );
		item->testA();
		item->testB();
	}

	std::cout << std::string( 20, '-' ) << std::endl;

	{
		DerivedRef item = DerivedRef( new Derived("item5"), CachedObjectDeleter );
		CacheManager::insert( item.get(), 5 );
		item->testA();
		item->testB();
	}

	std::cout << std::string( 20, '-' ) << std::endl;

    return 0;
}