libs/EDoc/FunctionLoc.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/FunctionLoc.h"
#include "EDoc/Function.h"
#include "EDoc/Dictionary.h"
#include "EDoc/PStack.h"
#include "EDoc/StackRef.h"

#include "EDoc/PersistenceIFace.h"
#include "IndexedDictionary.h"
#include "EDoc/persistence_data.h"

namespace EDoc
{
   //===========================================================================
   FunctionLoc::FunctionLoc(Dictionary& dict_in, Function* value_in, 
         const Location& loc_in) :
      
      DictionarySpecific(&dict_in),
      loc(loc_in, dict_in),
      value(value_in),
      possible(false),
      is_top_level(false)
   {
      EDOC_ASSERT(!value || dict.functions.Get(value->GetKeyName()), "");
   }
   //===========================================================================
   FunctionLoc::FunctionLoc(Dictionary* dict_in) :
      DictionarySpecific(dict_in),
      loc(dict_in),
      value(NULL),
      possible(false),
      is_top_level(false)
   {
   }
   //===========================================================================
   FunctionLoc::FunctionLoc(const FunctionLoc& right) :
      DictionarySpecific(&right.dict),
      loc(right.loc),
      value(right.value),
      possible(right.possible),
      is_top_level(false)
   {
   }
   //===========================================================================
   FunctionLoc::FunctionLoc(const FunctionLoc& right, Dictionary& dict_in) :
      DictionarySpecific(&dict_in),
      loc(right.loc, dict_in),
      value(NULL),
      possible(right.possible),
      is_top_level(false)
   {
      if (right.value)
      {
         value = dict.functions.AlwaysGet(*right.value);
      }
   }
   //===========================================================================
   FunctionLoc& FunctionLoc::operator=(const FunctionLoc& right)
   {
      if (this == &right)
      {
         return *this;
      }
      
      value = NULL;
      if (right.value)
      {
         value = dict.functions.AlwaysGet(*right.value);
      }
      possible = right.possible;
      
      return *this;
   }
   //===========================================================================
   void FunctionLoc::Read(PersistenceIFace& file, IndexedDictionary& idict)
   {
      // Item then location.
      value = idict.functions.AlwaysGet(file.ReadUInt32(KEY_FUNCTION));
      
      loc.Read(file, idict);
   }
   //===========================================================================
   void FunctionLoc::Write(PersistenceIFace& file) const
   {
      // Item then location.
      EDOC_ASSERT(value, "Value should only ever be NULL for "
         "PropagatingException instances and they are never written to file.");
      file.WriteUInt32Debug(KEY_FUNCTION, 
         value->GetIndex(), value->GetDeclaredName());
      
      loc.Write(file);
   }
   //===========================================================================
   bool FunctionLoc::operator==(const FunctionLoc& right) const
   {
      if (loc != right.loc)
      {
         return false;
      }
      
      // Value can be NULL in which case both must be null to be equal.
      if (!value || !right.value)
      {
         return value == right.value;
      }
      else
      {
         return (value->GetNormalisedName() == 
            right.value->GetNormalisedName());
      }
   }
   //===========================================================================
   bool FunctionLoc::operator<(const FunctionLoc& right) const
   {
      if (loc < right.loc)
      {
         return true;
      }
      else if (!(loc == right.loc))
      {
         return false;
      }

      
      // Value can be NULL in which case both must be null to be equal.
      if (!value || !right.value)
      {
         // Use a pointer comparison as the NULL pointer will always be less.
         return value < right.value;
      }
      else
      {
         return value->GetKeyName() < right.value->GetKeyName();
      }

   }
   //===========================================================================
   //@@@Brendon Possibly use special C++ type conversion functions.
   #define EDOC_REPLACE(DataType, Data, From, To, Count) \
      if ((void*)Data == From) {Data = (DataType*)To; Count++;}
   //===========================================================================
   size_t FunctionLoc::ReplaceReferences(PStack& stack, void* remove, 
      void* replace)
   {
      size_t count = 0;
      if (!stack.Push(this))
      {
         return count;
      }

      // Dont replace recursivly. Only replace inside us.
      EDOC_REPLACE(Function, value, remove, replace, count);

      count += loc.ReplaceReferences(stack, remove, replace);
      
      return count;
   }
   //===========================================================================
   void FunctionLoc::Validate(PStack& stack, const Dictionary& dict_in) const
   {
      StackRef ref(stack, this);
      if (!ref)
      {
         return;
      }
      
      EDOC_ASSERT(&dict == &dict_in, "");
      
      loc.Validate(stack, dict_in);
      if (value)
      {
         value->Validate(stack, dict_in);
      }
   }
   //===========================================================================
   std::ostream& FunctionLoc::Print(std::ostream& out, std::string prefix) const
   {
      // Print the location first
      loc.Print(out, prefix);
      
      // Then the functions key.
      out << prefix << "Function: ";
      if (value)
      {
         out << value->GetKeyName();
      }
      else
      {
         out << "(NULL)";
      }
      out << std::endl;
      return out;
   }
   //===========================================================================
}

---