include/EDoc/SpecificManagedObject.h

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2007 by Brendon Costa

   This library is free software; you can redistribute it and/or modify 
   it under the terms of the "LGPL Like" License defined in the file COPYING 
   that should have been distributed along with this source.

   This library 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.  

   You should have received a copy of the "LGPL Like" License 
   along with this library; see the file COPYING. if not, it can be 
   obtained from the EDoc++ website: 
   http://edoc.sourceforge.net/license.html

*******************************************************************************/
#ifndef EDOC_SPECIFICMANAGEDOBJECT_H
#define EDOC_SPECIFICMANAGEDOBJECT_H

#include "EDoc/ManagedObject.h"
#include "EDoc/utils.h"

namespace EDoc
{

   //===========================================================================
   /** \brief Provides a managed container for types that are specifically
    * derived from StringIdentifiedObject.
    *
    * Where ManagedObject is a generic container for StringIdentifiedObject's
    * this class is a container providing the same functionality but for
    * specific class types that derive from StringIdentifiedObject. For example
    * this is can contain types: File, Type, FunctionType, Function.
    */
   template<typename T>
   class SpecificManagedObject : public ManagedObject
   {
   public:

      //------------------------------------------------------------------------
      /** \brief See ManagedObject::ManagedObject()
       */
      SpecificManagedObject(Dictionary& dict_in) :
         ManagedObject(dict_in)
      {
      }

      //------------------------------------------------------------------------
      /** \brief See ManagedObject::operator=()
       */
      SpecificManagedObject& operator=(const SpecificManagedObject& right)
      {
         ManagedObject::operator=(right);
         return *this;
      }

      //------------------------------------------------------------------------
      /** \brief Creates a new instance of the particular derived type that this
       * container manages.
       */
      virtual StringIdentifiedObjectPtr New(Dictionary& dict, std::string name)
      {
         T* item = NULL;
         AllocNew(item, dict, name);
         return item;
      }


      //------------------------------------------------------------------------
      /** \brief See ManagedObject::CGet()
       */
      inline T* Get(std::string name)
      {
         return dynamic_cast<T*>(CGet(name));
      }

      //------------------------------------------------------------------------
      /** \brief See ManagedObject::CGet()
       */
      inline const T* Get(std::string name) const
      {
         return dynamic_cast<const T*>(CGet(name));
      }

      //------------------------------------------------------------------------
      /** \brief See ManagedObject::CAlwaysGet()
       */
      T* AlwaysGet(std::string name)
      {
         return dynamic_cast<T*>(CAlwaysGet(name));
      }

      //------------------------------------------------------------------------
      /** \brief See ManagedObject::CAlwaysGet()
       */
      T* AlwaysGet(const T& right)
      {
         return dynamic_cast<T*>(CAlwaysGet(right));
      }

      //------------------------------------------------------------------------
      /** \brief Gets a map of the objects using their derived type.
       *
       * NOTE: Was specifically created for use from python. 
       *
       * This is not efficient, but will do. Changes made to the resulting map
       * will not change the internal map only changes made to the objects
       * themselves will have any lasting effect.
       *
       * This means that from python erasing items from this map will not remove
       * them from the resulting SpecificManagedObject instance.
       */
      std::map<std::string, T*> GetItems()
      {
         std::map<std::string, T*> ret;
         EDOC_FOREACH(StrIDObjPMap, it, items)
         {
            ret.insert(std::pair<std::string, T*>(it->first,
               dynamic_cast<T*>(it->second)));
         }
         
         return ret;
      }
      
      //------------------------------------------------------------------------

   };
   //===========================================================================

}

#endif // EDOC_SPECIFICMANAGEDOBJECT_H

---