include/EDoc/Type.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_TYPE_H
#define EDOC_TYPE_H

#include "EDoc/StringIdentifiedObject.h"
#include "EDoc/Location.h"

#include <string>
#include <vector>
#include <sstream>
#include <list>
#include <list>

namespace EDoc
{
   class PersistenceIFace;
   class IndexedDictionary;
   class Dictionary;
   class Function;
   class PStack;
   class File;
   class TranslationUnit;
   
   //===========================================================================
   /** \brief Represents a type in C/C++ code that has been encounterd
    * during compilation.
    *
    * 
    */
   class Type : public StringIdentifiedObject
   {
   public:

      //------------------------------------------------------------------------
      /** \brief See StringIdentifiedObject::(Dictionary& dict_in, 
       * std::string key_name_in, bool populated_in=false)
       */
      Type(Dictionary& dict_in, std::string key_name_in);

      //------------------------------------------------------------------------
      /** \brief See StringIdentifiedObject(Dictionary& dict_in, 
       * int32_t index_in, bool populated_in=false)
       */
      Type(Dictionary& dict_in, int32_t index_in);

      //------------------------------------------------------------------------
      /** \brief Copies data from another object into this one.
       *
       * This can be used across different dictionaries and will only copy
       * object data but not identification information used in the
       * StringIdentifiedObject such as the key name.
       */
      Type& operator=(const Type& right);

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

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

      //------------------------------------------------------------------------
      /** \brief See StringIdentifiedObject::Merge()
       */
      virtual void Merge(const StringIdentifiedObject& right);

      //------------------------------------------------------------------------
      /** \brief 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 Returns true if the two types are the same.
       *
       * Works across dictionaries.
       */
      bool operator==(const Type& right) const;

      //------------------------------------------------------------------------
      /** \brief See operator==()
       */
      bool operator!=(const Type& right) const
      {
         return !(*this == right);
      }

      //------------------------------------------------------------------------
      /** \brief See StringIdentifiedObject::GetRecordType()
       */
      virtual uint8_t GetRecordType() const;










      //------------------------------------------------------------------------
      /** \brief Returns the root name of this type.
       */
      inline std::string GetNormalisedName() const
      {
         return root_type->name;
      }

      //------------------------------------------------------------------------
      /** \brief Returns the name of this type as declared by the user in the
       * source code.
       */
      inline std::string GetDeclaredName() const
      {
         return name;
      }

      //------------------------------------------------------------------------
      /** \brief Will return one of GetKeyName() or GetDeclaredName()
       * depending upon how much information is available in the object (I.e. if
       * it has been populated yet).
       */
      inline std::string GetBestName() const
      {
         return (IsPopulated() ? name : GetKeyName());
      }

      


      //------------------------------------------------------------------------
      /** \brief True if an exception of this type is thrown and it can be
       * caught by the type passed into right.
       */
      bool IsCaughtBy(const Type& right) const;

      //------------------------------------------------------------------------
      /** \brief See FunctionType::IsEquivilant()
       */
      bool IsEquivilant(const Type& right) const;

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



      //------------------------------------------------------------------------
      // Public Primary Data values.
      //------------------------------------------------------------------------

      //------------------------------------------------------------------------
      /** \brief Name of the type as declared by the user.
       */
      std::string name;

      //------------------------------------------------------------------------
      /** \brief True if this type has external linkage identification or false
       * if defined privatly to the translation unit.
       */
      bool external_linkage;
      
      //------------------------------------------------------------------------
      /** \brief A reference to the translation unit this type belongs to.
       *
       * This may change in the future, or not... It is NON-NULL if the type has
       * external linkage. Possible remove the boolean value and just have the
       * pointer. If NULL then is external if not null then internal.
       */
      TranslationUnit* translation_unit;
      
      //------------------------------------------------------------------------
      /** \brief If this type is thrown what is a base type that will be used in
       * all exception calculations. 
       *
       * This is usually the base type (followed back typedefs) stripped of top
       * level const/volatile qualifiers.
       */
      Type* throw_type;

      //------------------------------------------------------------------------
      /** \brief This is usually the base type (followed back typedefs) with
       * equivilant const/volatile qualifiers.
       */
      Type* root_type;

      //------------------------------------------------------------------------
      /** \brief A list of other types that are considered identical to this
       * one.
       *
       * Determined by typedefs etc.
       */
      std::vector<Type*> identical;

      //------------------------------------------------------------------------
      /** \brief A list of other types that can be used to catch this type.
       */
      std::vector<Type*> catchable;

      //------------------------------------------------------------------------
      /** \brief The source Location where this type was defined.
       */
      Location loc;

      //------------------------------------------------------------------------
      /** \brief A list of source files that this type is used in.
       */
      std::list<File*> referenced_in_files;

      //------------------------------------------------------------------------
      /** \brief Returns the name of the type with translation unit info
       * appended if it is provate to the translation unit.
       */
      std::string GetNameInternal() const;

      //------------------------------------------------------------------------
      /** \brief True if this type is visible to the user for exceptions or
       * false if any exceptions of this type will never be shown to the user.
       *
       * This is used for suppressions.
       */
      bool visible;

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

   };
   //===========================================================================
   typedef std::vector<EDoc::Type*> TypePVec;

}

#endif // EDOC_TYPE_H

---