CRegisteredDynamicTypes.hpp

/* This file is part of sUtil, a random collection of utilities.

sUtil is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

Alternatively, you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.

sUtil is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License and a copy of the GNU General Public License along with
sUtil. If not, see <http://www.gnu.org/licenses/>.
 */
/* \file CRegisteredDynamicTypes.hpp
 *
 *  Created on: Sep 9, 2011
 *
 *  Copyright (C) 2011, Samir Menon <smenon@stanford.edu>
 */

#ifndef CREGISTEREDDYNAMICTYPES_HPP_
#define CREGISTEREDDYNAMICTYPES_HPP_

#include <sutil/CMappedList.hpp>
#include <sutil/CSingleton.hpp>

#ifdef DEBUG
#include <iostream>
#endif

namespace sutil
{
  // Read the class comments below
  template <typename Idx> class CDynamicTypeBase; //Forward declaration

  template <typename Idx>
  class CRegisteredDynamicTypes :
    private CSingleton<CMappedPointerList<Idx,CDynamicTypeBase<Idx>,true> >
  {
    //A typedef for easy use;
    typedef CSingleton<CMappedPointerList<Idx,CDynamicTypeBase<Idx>,true> > singleton;

    friend class CDynamicTypeBase<Idx>;

  public:
    static bool typeRegistered(const Idx& arg_type_name)
    {
      CDynamicTypeBase<Idx>** mapped_type = singleton::getData()->at(arg_type_name);

      if(NULL == mapped_type)
      { return false; }

      return true;
    }

    static bool getObjectForType(const Idx& arg_type_name,
        void*& ret_object)
    {
      CDynamicTypeBase<Idx>** mapped_type = singleton::getData()->at(arg_type_name);

      if(NULL == mapped_type)
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredDynamicTypes::getObjectForType() Error :"
            <<" The passed type has not been registered.";
#endif
        return false;
      }

      if(NULL != ret_object)
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredDynamicTypes::getObjectForType() Error :"
            <<" The passed void* pointer is not NULL.";
#endif
        return false;
      }


      if(NULL == *mapped_type)
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredDynamicTypes::getObjectForType() Error :"
            <<" The typemap is corrupted. A type creator object pointer is NULL.";
#endif
        return false;
      }

      //Be really careful.
      ret_object = (*mapped_type)->createObject();
      if(NULL == ret_object)
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredDynamicTypes::getObjectForType() Error :"
            <<" The type object's createObject() function did not work.";
#endif
      }

      return true;
    }

    static bool resetDynamicTypes()
    { return singleton::resetData(); }

  private:
    static bool registerType(const Idx& arg_type_name,
        CDynamicTypeBase<Idx>* arg_type_object)
    {
      if(typeRegistered(arg_type_name))
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredDynamicTypes::registerType() Warning :"
            <<" The passed type is already registered.";
#endif
        return false;
      }

      CDynamicTypeBase<Idx>** t = singleton::getData()->create(arg_type_name,arg_type_object);
      if(NULL == t)
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredDynamicTypes::registerType() Error :"
            <<" Failed to create type in the type mapped list.";
#endif
        return false;
      }

      return true;
    }

    CRegisteredDynamicTypes();

    CRegisteredDynamicTypes(const CRegisteredDynamicTypes&);

    CRegisteredDynamicTypes& operator= (const CRegisteredDynamicTypes&);
  };

  template <typename Idx>
  class CDynamicTypeBase
  {
  public:
    CDynamicTypeBase(const Idx &arg_type_name) : type_name_(arg_type_name){}

    virtual ~CDynamicTypeBase(){}

    virtual void* createObject()=0;

  protected:
    virtual bool registerMyType(CDynamicTypeBase* arg_obj)
    {
      return CRegisteredDynamicTypes<Idx>::registerType(type_name_,arg_obj);
    }

    Idx type_name_;

  private:
    CDynamicTypeBase();
    CDynamicTypeBase(const CDynamicTypeBase&);
    CDynamicTypeBase& operator= (const CDynamicTypeBase&);
  };

  template <typename Idx, typename Type>
  class CDynamicType : public CDynamicTypeBase<Idx>
  {
  public:
    CDynamicType(const Idx &arg_type_name) :
      CDynamicTypeBase<Idx>::CDynamicTypeBase(arg_type_name)
    { }

    virtual ~CDynamicType(){}

    virtual void* createObject()
    {
      Type* obj = new Type();
      return reinterpret_cast<void*>(obj);
    }

    bool registerType()
    {
      bool flag;
      flag = CRegisteredDynamicTypes<Idx>::typeRegistered(CDynamicTypeBase<Idx>::type_name_);

      if(flag)//Type already registered. Do nothing and return false.
      {
#ifdef DEBUG
        std::cerr<<"\nCDynamicType::registerType() Warning :"
            <<" This object's type has already been registered.";
#endif
        return false;
      }
      else
      {
        CDynamicType<Idx,Type>* obj = new CDynamicType<Idx,Type>(
            CDynamicTypeBase<Idx>::type_name_);
        flag = CDynamicTypeBase<Idx>::registerMyType(obj);
        if(!flag)
        {
#ifdef DEBUG
          std::cerr<<"\nCDynamicType::registerType() Error :"
              <<" This object's type could not be registered.";
#endif
          return false;
        }
      }
      return true;
    }

  private:
      CDynamicType();
      CDynamicType(const CDynamicType&);
      CDynamicType& operator= (const CDynamicType&);
  };

}

#endif /* CREGISTEREDDYNAMICTYPES_HPP_ */