include/EDoc/FunctionTypeLoc.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_FUNCTIONTYPELOC_H
#define EDOC_FUNCTIONTYPELOC_H

#include "EDoc/DictionarySpecific.h"
#include "EDoc/Location.h"
#include <list>

namespace EDoc
{
   class FunctionType;
   class Type;
   class PStack;
   
   //===========================================================================
   /** \brief Is a conglomerate of a reference to a FunctionType object and a
    * Location in a source file.
    *
    * This can be used for a few purposes one of which is to store data for a
    * function pointer call. 
    */
   class FunctionTypeLoc : public DictionarySpecific
   {
   public:

      //------------------------------------------------------------------------
      /** \brief Create a new FunctionTypeLoc given the dictionary, a 
       * function type to reference and the location.
       */
      FunctionTypeLoc(Dictionary& dict_in, FunctionType* value_in, 
         const Location& loc_in);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::CodeBlock(Dictionary* dict_in=NULL)
       */
      FunctionTypeLoc(Dictionary* dict_in = NULL);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::CodeBlock(const CodeBlock& right)
       */
      FunctionTypeLoc(const FunctionTypeLoc& right);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::CodeBlock(const CodeBlock& right, 
       * Dictionary& dict_in)
       */
      FunctionTypeLoc(const FunctionTypeLoc& right, Dictionary& dict_in);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::operator=()
       */
      FunctionTypeLoc& operator=(const FunctionTypeLoc& right);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::Read()
       */
      void Read(PersistenceIFace& file, IndexedDictionary& idict);

      //------------------------------------------------------------------------
      /** \brief See CodeBlock::Write()
       */
      void Write(PersistenceIFace& file) const;

      //------------------------------------------------------------------------
      /** \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 Equivilance operator (Works across dictionaries).
       */
      bool operator==(const FunctionTypeLoc& right) const;

      //------------------------------------------------------------------------
      /** \brief Less than comparison so this can be used for std::map keys.
       *
       * Compares Location first then FunctionType instances.
       */
      bool operator<(const FunctionTypeLoc& right) const;






      //------------------------------------------------------------------------
      /** \brief A location in a source file.
       */
      Location loc;

      //------------------------------------------------------------------------
      /** \brief A reference to a FunctionType.
       */
      FunctionType* value;

   };
   //===========================================================================
   typedef std::list<FunctionTypeLoc> FTypeLocList;
}

#endif // EDOC_FUNCTIONTYPELOC_H

---