libs/EDoc/ManagedObject.cpp

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

*******************************************************************************/
#include "config.h"

#include "EDoc/ManagedObject.h"

#include "EDoc/Type.h"
#include "EDoc/Function.h"
#include "EDoc/FunctionType.h"
#include "EDoc/File.h"
#include "EDoc/PStack.h"
#include "EDoc/StackRef.h"
#include "EDoc/utils.h"

namespace EDoc
{

   //===========================================================================
   void AllocNew(File*& obj,           Dictionary& dict, std::string key_name)
   {
      EDOC_ASSERT(&dict != NULL, "");
      EDOC_Finer("Creating new file object with key name: " << key_name);
      obj = new File(dict, key_name);
   }
   //===========================================================================
   void AllocNew(Type*& obj,           Dictionary& dict, std::string key_name)
   {
      EDOC_ASSERT(&dict != NULL, "");
      obj = new Type(dict, key_name);
   }
   //===========================================================================
   void AllocNew(Function*& obj,       Dictionary& dict, std::string key_name)
   {
      EDOC_ASSERT(&dict != NULL, "");
      obj = new Function(dict, key_name);
   }
   //===========================================================================
   void AllocNew(FunctionType*& obj,   Dictionary& dict, std::string key_name)
   {
      EDOC_ASSERT(&dict != NULL, "");
      obj = new FunctionType(dict, key_name);
   }
   //===========================================================================

   void AllocNew(File*& obj,           Dictionary& dict, uint32_t index)
   {
      EDOC_ASSERT(&dict != NULL, "");
      EDOC_Finer("Creating new file object with index: " << index);
      obj = new File(dict, index);
   }
   //===========================================================================
   void AllocNew(Type*& obj,           Dictionary& dict, uint32_t index)
   {
      EDOC_ASSERT(&dict != NULL, "");
      obj = new Type(dict, index);
   }
   //===========================================================================
   void AllocNew(Function*& obj,       Dictionary& dict, uint32_t index)
   {
      EDOC_ASSERT(&dict != NULL, "");
      obj = new Function(dict, index);
   }
   //===========================================================================
   void AllocNew(FunctionType*& obj,   Dictionary& dict, uint32_t index)
   {
      EDOC_ASSERT(&dict != NULL, "");
      obj = new FunctionType(dict, index);
   }
   //===========================================================================


   //===========================================================================
   ManagedObject::ManagedObject(Dictionary& dict_in) :
      DictionarySpecific(&dict_in)
   {
      EDOC_ASSERT(&dict != NULL, "");
   }
   //===========================================================================
   void ManagedObject::EraseAll()
   {
      EDOC_FOREACH(StrIDObjPMap, it, items)
      {
         delete it->second;
         it->second = NULL;
      }
      Erase(items);
   }
   //===========================================================================
   size_t ManagedObject::ReplaceReferences(PStack& stack, void* remove, 
      void* replace)
   {
      size_t count = 0;
      EDOC_FOREACH(StrIDObjPMap, it, items)
      {
         count += it->second->ReplaceReferences(stack, remove, replace);
      }

      return count;
   }
   //===========================================================================
   void ManagedObject::Validate(PStack& stack, const Dictionary& dict_in) const
   {
      EDOC_ASSERT(&dict == &dict_in, 
         "Current dict: " << &dict 
         << "\nRequired dict: " << &dict_in);

      EDOC_FOREACH_CONST(StrIDObjPMap, it, items)
      {
         EDOC_Finer("Validating: " << it->first);
         EDOC_ASSERT(it->first == it->second->GetKeyName(), 
            "All items should be indexed by their key names."
            << " Index: " << it->first 
            << ", Key Name: " << it->second->GetKeyName());
         it->second->Validate(stack, dict_in);
      }
   }
   //===========================================================================
   std::ostream& ManagedObject::Print(std::ostream& out, 
      std::string prefix) const
   {
      EDOC_FOREACH_CONST(StrIDObjPMap, it, items)
      {
         it->second->Print(out, prefix) << std::endl;
      }

      return out;
   }
   //===========================================================================
   ManagedObject& ManagedObject::operator=(
      const ManagedObject& EDOC_UNUSED(right))
   {
      EDOC_ASSERT(false, "Assignment of managed objects should never occur "
         "but is required by SWIG wrappers.");
      return *this;
   }
   //===========================================================================
   StringIdentifiedObjectPtr ManagedObject::CAlwaysGet(std::string name)
   {
      StringIdentifiedObjectPtr item = CGet(name);
      if (!item)
      {
         item = New(dict, name);
         items.insert(std::pair<std::string, 
            StringIdentifiedObjectPtr>(name, item));
      }
      return item;
   }
   //===========================================================================
   StringIdentifiedObjectPtr ManagedObject::CAlwaysGet(
      const StringIdentifiedObject& right)
   {
      if (&right.dict == &dict)
      {
         // Cast away constness.
         return const_cast<StringIdentifiedObjectPtr>(&right);
      }
      else
      {
         return CAlwaysGet(right.GetKeyName());
      }
   }
   //===========================================================================
   void ManagedObject::CRemove(StringIdentifiedObjectPtr right)
   {
      // @@@Brendon I am removing by key name. Should i remove by pointer
      // value, i.e. iterate over all members till find second that has same
      // pointer as passed in?
      EDOC_ASSERT(items.count(right->GetKeyName()), "");
      EDOC_ASSERT(items.find(right->GetKeyName())->second == right, "");
      items.erase(items.find(right->GetKeyName()));
   }
   //===========================================================================
   void ManagedObject::CAdd(StringIdentifiedObjectPtr right)
   {
      EDOC_ASSERT(!items.count(right->GetKeyName()), "");
      items.insert(std::pair<std::string, StringIdentifiedObjectPtr>(
         right->GetKeyName(), right));
   }
   //===========================================================================

}

---