libs/EDoc/IndexedDictionary.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_INDEXEDDICTIONARY_H
#define EDOC_INDEXEDDICTIONARY_H

#include "EDoc/stdint.h"
#include "EDoc/Dictionary.h"
#include "EDoc/utils.h"
#include "EDoc/exceptions.h"
#include "EDoc/StringIdentifiedObject.h"
#include <vector>

// @@@Brendon Not sure why i need to include these here to compile on GCC 4
// Works fine without them on GCC 3
#include "EDoc/Function.h"
#include "EDoc/FunctionType.h"
#include "EDoc/Type.h"

namespace EDoc
{
   class Type;
   class Function;
   class Dictionary;
   class File;

   //===========================================================================
   /** \brief Stores a map of StringIdentifiedObject's that are indexed by an
    * integer value.
    *
    * This is designed to be used for the process of loading EDoc++ data items
    * from a file. In the EDoc++ data format all items are identified by a 
    * integer instead of a string to reduce the size of the resulting data file.
    */
   class IndexedObject
   {
   public:
   
      //------------------------------------------------------------------------
      /** \brief Create an instance to manage loading for the given dictionary.
       */
      IndexedObject(Dictionary& dict_in) :
         dict(dict_in)
      {
      }

      //------------------------------------------------------------------------
      /** \brief Destructor.
       */
      virtual ~IndexedObject() {}

      //------------------------------------------------------------------------
      /** \brief Obtain the instance for the given index or return NULL if one 
       * does not exist.
       */
      StringIdentifiedObject* CGet(uint32_t index)
      {
         if (index < items.size())
         {
            return items[index];
         }
         else
         {
            return NULL;
         }
      }

      //------------------------------------------------------------------------
      /** \brief Adds an existing StringIdentifiedObject instance to this map.
       *
       * Should not be called ore than once for a single index.
       */
      void CAdd(uint32_t index, StringIdentifiedObject* item)
      {
         // Make the vector larger if it is too small.
         if (index >= items.size())
         {
            items.resize(index + 1, NULL);
         }

         if (items[index] != NULL)
         {
            EDOC_THROW_EXCEPTION(FileIOException, "Multiple records with same index."
               "The index: " << index << ", was previously taken.",
               "");
         }
         items[index] = item;
         item->index = index;
      }

      //------------------------------------------------------------------------
      /** \brief Obtain the instance for the given index or create one if one 
       * does not exist.
       */
      StringIdentifiedObject* CAlwaysGet(uint32_t index)
      {
         StringIdentifiedObject* item = CGet(index);
         if (!item)
         {
            item = New(dict, index);
            CAdd(index, item);
         }

         return item;
      }

      //------------------------------------------------------------------------
      /** \brief Implemented in child to create instance of specific 
       * derivation from StringIdentifiedObject.
       */
      virtual StringIdentifiedObject* New(Dictionary& dict, uint32_t index) = 0;

      //------------------------------------------------------------------------
      /** \brief Reference to the dictionary object that all instances belong.
       */
      Dictionary& dict;

      //------------------------------------------------------------------------
      /** \brief List of items that currently exist.
       */
      // @@@Brendon Probably create a map for this.
      std::vector<StringIdentifiedObject*> items;
   };
   
   //===========================================================================
   /** \brief Specific varient of IndexedObject for a particular 
    * StringIdentifiedObject derivation type like, File, Function etc.
    */
   template<typename T>
   class SpecificIndexedObject : public IndexedObject
   {
   public:
      
      //------------------------------------------------------------------------
      /** \brief Create an instance for a specific dictionary.
       */
      SpecificIndexedObject(Dictionary& dict_in) :
         IndexedObject(dict_in)
      {
      }
      
      //------------------------------------------------------------------------
      /** \brief Create a new instance of the type with the given index as an
       * identifier.
       */
      virtual StringIdentifiedObject* New(Dictionary& dict, uint32_t index)
      {
         T* item = NULL;
         AllocNew(item, dict, index);
         return static_cast<StringIdentifiedObject*>(item);
      }

      //------------------------------------------------------------------------
      /** \brief Type specific implementation of IndexedObject::CGet()
       */
      T* Get(uint32_t index)
      {
         return dynamic_cast<T*>(CGet(index));
      }

      //------------------------------------------------------------------------
      /** \brief Type specific implementation of IndexedObject::AlwaysGet()
       */
      T* AlwaysGet(uint32_t index)
      {
         return dynamic_cast<T*>(CAlwaysGet(index));
      }
      
      //------------------------------------------------------------------------

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



   //===========================================================================
   /** \brief Manages all File, Type, FunctionType, and Function instances as 
    * they are being loaded from a EDoc++ data file. 
    *
    * This stores all items indexed by an integer value.
    */
   class IndexedDictionary
   {
      friend class Dictionary;
   public:

      //------------------------------------------------------------------------
      /** \brief Create an instance for loading data for the given dictionary.
       */
      IndexedDictionary(Dictionary& dict_in) :
         files(dict_in),
         types(dict_in),
         function_types(dict_in),
         functions(dict_in),
         dict(&dict_in)
      {}

      //------------------------------------------------------------------------
      /** \brief Returns a vector with all managed types.
       *
       * This is a helper to simplify the code a little.
       */
      std::vector<IndexedObject*> GetManagedObjects()
      {
         // NOTE: The order is important here.
         std::vector<IndexedObject*> ret;
         ret.push_back(&files);
         ret.push_back(&types);
         ret.push_back(&function_types);
         ret.push_back(&functions);
         
         return ret;
      }

      //------------------------------------------------------------------------
      /** \brief Map of all File instances.
       */
      SpecificIndexedObject<File> files;

      //------------------------------------------------------------------------
      /** \brief Map of all Type instances.
       */
      SpecificIndexedObject<Type> types;

      //------------------------------------------------------------------------
      /** \brief Map of all FunctionType instances.
       */
      SpecificIndexedObject<FunctionType> function_types;

      //------------------------------------------------------------------------
      /** \brief Map of all Function instances.
       */
      SpecificIndexedObject<Function> functions;

      //------------------------------------------------------------------------
      /** \brief A reference to the dictionary all these instances belong to.
       */
      Dictionary* dict;
      
      //------------------------------------------------------------------------
   };
}

#endif // EDOC_INDEXEDDICTIONARY_H

---