include/EDoc/ManagedObject.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_MANAGEDOBJECT_H
#define EDOC_MANAGEDOBJECT_H

#include "EDoc/DictionarySpecific.h"
#include "EDoc/exceptions.h"
#include "EDoc/StringIdentifiedObject.h"
#include <string>
#include <map>
#include <list>
#include <vector>

namespace EDoc
{
   class File;
   class Type;
   class FunctionType;
   class Function;
   class Dictionary;
   
   void AllocNew(File*& obj,           Dictionary& dict, std::string key_name);
   void AllocNew(Type*& obj,           Dictionary& dict, std::string key_name);
   void AllocNew(Function*& obj,       Dictionary& dict, std::string key_name);
   void AllocNew(FunctionType*& obj,   Dictionary& dict, std::string key_name);

   void AllocNew(File*& obj,           Dictionary& dict, uint32_t index);
   void AllocNew(Type*& obj,           Dictionary& dict, uint32_t index);
   void AllocNew(Function*& obj,       Dictionary& dict, uint32_t index);
   void AllocNew(FunctionType*& obj,   Dictionary& dict, uint32_t index);


   //===========================================================================
   /** \brief Generic representation for a collection of StringIdentifiedObject
    * instances.
    *
    * This stores the StringIdentifiedObject instances and is the ultimate
    * authority of where to find them. This class will be derived by a template
    * class for each dervied varient of StringIdentifiedObject. Namely File,
    * Type, FunctionType and Function.
    *
    * This class provides basic functionality for creating new
    * StringIdentifiedObject instances and searchif for existing instances.
    */
   class ManagedObject : public DictionarySpecific
   {
   public:

      //------------------------------------------------------------------------
      /** \brief Constructor.
       */
      ManagedObject(Dictionary& dict_in);

      //------------------------------------------------------------------------
      /** \brief Destructor.
       */
      virtual ~ManagedObject() {}
      
      //------------------------------------------------------------------------
      /** \brief Assignment operator.
       */
      ManagedObject& operator=(const ManagedObject& right);
      
      //------------------------------------------------------------------------
      /** \brief See DictionarySpecific::ReplaceReferences()
       */
      virtual size_t ReplaceReferences(PStack& stack, 
         void* remove, void* replace);

      //------------------------------------------------------------------------
      /** \brief See DictionarySpecific::Print()
       */
      virtual std::ostream& Print(std::ostream& out, 
         std::string prefix="") const;

      //------------------------------------------------------------------------
      /** \brief See DictionarySpecific::Validate()
       */
      virtual void Validate(PStack& stack, const Dictionary& dict_in) const;










      //------------------------------------------------------------------------
      /** \brief Rease all StringIdentifiedObject instances referenced by this
       * contains and the data they use.
       */
      void EraseAll();

      //------------------------------------------------------------------------
      /** \brief Common : get instance from key name.
       */
      inline StringIdentifiedObjectPtr CGet(std::string name)
      {
         if (!items.count(name))
         {
            return NULL;
         }
         else
         {
            return items.find(name)->second;
         }
      }

      //------------------------------------------------------------------------
      /** \brief Common : get instance from key name or create new instance if
       * key does not exist.
       */
      StringIdentifiedObjectPtr CAlwaysGet(std::string name);

      //------------------------------------------------------------------------
      /** \brief Common : get instance equivilant to right or create new
       * instance if no equivilant to right exists in this collection.
       */
      StringIdentifiedObjectPtr CAlwaysGet(const StringIdentifiedObject& right);

      //------------------------------------------------------------------------
      /** \brief Common : Remove instance equivilant to right.
       *
       * Throws BugException if equivilant to right does not exist in this
       * collection.
       */
      void CRemove(StringIdentifiedObjectPtr right);

      //------------------------------------------------------------------------
      /** \brief Add given instance to this collection.
       *
       * If an equivilant to right already exists in collection will throw a
       * BugException.
       */
      void CAdd(StringIdentifiedObjectPtr right);

      //------------------------------------------------------------------------
      /** \brief See CGet()
       */
      inline const StringIdentifiedObjectPtr CGet(std::string name) const
      {
         return const_cast<ManagedObject*>(this)->CGet(name);
      }

      //------------------------------------------------------------------------
      /** \brief Used to create new instance of particular type of
       * StringIdentifiedObject that this collection manages.
       */
      virtual StringIdentifiedObjectPtr New(Dictionary& dict, std::string name) = 0;

      //------------------------------------------------------------------------
      // @@@Brendon This should be private.
      /** \brief Maps unique string idenitifcation keys to object instances.
       */
      std::map<std::string, StringIdentifiedObjectPtr> items;

      //------------------------------------------------------------------------

   };
   //===========================================================================
   typedef ManagedObject* ManagedObjectPtr;
   typedef std::list<ManagedObject*> MngObjPList;
   typedef std::vector<ManagedObject*> MngObjPVec;
}

#endif // EDOC_MANAGEDOBJECT_H

---