// @(#)root/reflex:$Id: TypeTemplateImpl.h 24138 2008-06-04 12:50:27Z axel $
// Author: Stefan Roiser 2004

// Copyright CERN, CH-1211 Geneva 23, 2004-2006, All rights reserved.
//
// Permission to use, copy, modify, and distribute this software for any
// purpose is hereby granted without fee, provided that this copyright and
// permissions notice appear in all copies and derivatives.
//
// This software is provided "as is" without express or implied warranty.

#ifndef Reflex_TypeTemplateImpl
#define Reflex_TypeTemplateImpl

// Include files
#include "Reflex/Kernel.h"
#include "Reflex/Scope.h"

#ifdef _WIN32
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif

namespace Reflex {

   // forward declarations
   class Type;
   class TypeTemplate;
   class TypeTemplateName;
   class ClassTemplateInstance;

   /** 
   * @class TypeTemplateImpl TypeTemplateImpl.h Reflex/TypeTemplateImpl.h
   * @author Stefan Roiser
   * @date 2005-02-03
   * @ingroup Ref
   */
   class RFLX_API TypeTemplateImpl {

   public:

      /** default constructor */
      TypeTemplateImpl( const char * templateName,
         const Scope & scop,
         std::vector < std::string > parameterNames, 
         std::vector < std::string > parameterDefaults = std::vector<std::string>());


      /** destructor */
      virtual ~TypeTemplateImpl();


      /** 
      * operator == will return true if two At templates are the same
      * @return true if At templates match
      */
      bool operator == ( const TypeTemplateImpl & rh ) const;


      /**
      * TemplateInstance_Begin returns the begin iterator of the instance container
      * @return the begin iterator of the instance container
      */
      Type_Iterator TemplateInstance_Begin() const;


      /**
      * TemplateInstance_End returns the end iterator of the instance container
      * @return the end iterator of the instance container
      */
      Type_Iterator TemplateInstance_End() const;


      /**
      * TemplateInstance_RBegin returns the rbegin iterator of the instance container
      * @return the rbegin iterator of the instance container
      */
      Reverse_Type_Iterator TemplateInstance_RBegin() const;


      /**
      * TemplateInstance_Rend returns the rend iterator of the instance container
      * @return the rend iterator of the instance container
      */
      Reverse_Type_Iterator TemplateInstance_REnd() const;


      /**
      * instantion will return a pointer to the nth template instantion
      * @param  nth template instantion
      * @return pointer to nth template instantion
      */
      Type TemplateInstanceAt( size_t nth ) const;


      /**
      * instantionSize will return the number of template instantions for
      * this template family
      * @return number of template instantions
      */
      size_t TemplateInstanceSize() const;


      /**
      * TemplateParameterSize will return the number of template parameters
      * @return number of template parameters
      */
      size_t TemplateParameterSize() const;


      /**
      * TemplateParameterDefaultAt will return the nth FunctionParameterAt default value as string
      * @param nth template FunctionParameterAt
      * @return default value of nth template FunctionParameterAt
      */
      std::string TemplateParameterDefaultAt( size_t nth ) const;


      StdString_Iterator TemplateParameterDefault_Begin() const;
      StdString_Iterator TemplateParameterDefault_End() const;
      Reverse_StdString_Iterator TemplateParameterDefault_RBegin() const;
      Reverse_StdString_Iterator TemplateParameterDefault_REnd() const;


      /**
      * TemplateParameterNameAt will the Name of the nth FunctionParameterAt
      * @param  nth template FunctionParameterAt
      * @return Name of nth template FunctionParameterAt
      */
      std::string TemplateParameterNameAt( size_t nth ) const;


      StdString_Iterator TemplateParameterName_Begin() const;
      StdString_Iterator TemplateParameterName_End() const;
      Reverse_StdString_Iterator TemplateParameterName_RBegin() const;
      Reverse_StdString_Iterator TemplateParameterName_REnd() const;


      /**
      * Return the member template API class corresponding to this member template impl
      * @return corresponding member template
      */
      TypeTemplate ThisTypeTemplate() const;

   public:

      /** 
      * AddTemplateInstance adds one TemplateInstanceAt of the template to the local container
      * @param templateInstance the template TemplateInstanceAt
      */
      void AddTemplateInstance( const Type & templateInstance ) const;

   private:

      /**
      * pointer back to the corresponding scope
      * @label type template scope
      * @clientCardinality 0..*
      * @supplierCardinality 1
      */
      Scope fScope;


      /** 
      * pointer to the class template instances
      * @supplierCardinality 1..*
      * @clientCardinality 0..1
      * @label template instances
      */
      mutable
         std::vector < Type > fTemplateInstances;


      /**
      * container of template parameter names
      */
      mutable
         std::vector < std::string > fParameterNames;


      /**
      * template parameter default values
      */
      mutable
         std::vector < std::string > fParameterDefaults;


      /**
      * number of required template parameters
      */
      size_t fReqParameters;


      /**
      * pointer back to the template name
      * @label type template name
      * @link aggregation
      * @clientCardinality 1
      * @supplierCardinality 1
      */
      TypeTemplateName * fTypeTemplateName;

   }; // class TypeTemplateImpl

} // namespace Reflex

//-------------------------------------------------------------------------------
inline size_t Reflex::TypeTemplateImpl::TemplateParameterSize() const {
//-------------------------------------------------------------------------------
   return fParameterNames.size();
}


//-------------------------------------------------------------------------------
inline std::string Reflex::TypeTemplateImpl::TemplateParameterDefaultAt( size_t nth ) const {
//-------------------------------------------------------------------------------
   if ( nth < fParameterDefaults.size() ) return fParameterDefaults[ nth ];
   return "";
}


//-------------------------------------------------------------------------------
inline Reflex::StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterDefault_Begin() const {
//-------------------------------------------------------------------------------
   return fParameterDefaults.begin();
}


//-------------------------------------------------------------------------------
inline Reflex::StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterDefault_End() const {
//-------------------------------------------------------------------------------
   return fParameterDefaults.end();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterDefault_RBegin() const {
//-------------------------------------------------------------------------------
   return ((const std::vector<std::string>&)fParameterDefaults).rbegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterDefault_REnd() const {
//-------------------------------------------------------------------------------
   return ((const std::vector<std::string>&)fParameterDefaults).rend();
}


//-------------------------------------------------------------------------------
inline std::string Reflex::TypeTemplateImpl::TemplateParameterNameAt( size_t nth ) const {
//-------------------------------------------------------------------------------
   if ( nth < fParameterNames.size() ) return fParameterNames[ nth ];
   return "";
}


//-------------------------------------------------------------------------------
inline Reflex::StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterName_Begin() const {
//-------------------------------------------------------------------------------
   return fParameterNames.begin();
}


//-------------------------------------------------------------------------------
inline Reflex::StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterName_End() const {
//-------------------------------------------------------------------------------
   return fParameterNames.end();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterName_RBegin() const {
//-------------------------------------------------------------------------------
   return ((const std::vector<std::string>&)fParameterNames).rbegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_StdString_Iterator Reflex::TypeTemplateImpl::TemplateParameterName_REnd() const {
//-------------------------------------------------------------------------------
   return ((const std::vector<std::string>&)fParameterNames).rend();
}


#ifdef _WIN32
#pragma warning( pop )
#endif

#endif // Reflex_TypeTemplateImpl