JTypeID.hh

Go to the documentation of this file.

#ifndef __JLANG__JTYPEID__
#define __JLANG__JTYPEID__
 
#include <ostream>
 
#include "JLang/JNullType.hh"
#include "JLang/JTest.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
  /**
   * Auxiliary data structure to label data types within a type list.
   */
  struct JLabel_t {
    /**
     * Constructor.
     *
     * \param  ID                identifier
     * \param  name              name
     * \param  version           version
     */
    JLabel_t(const int   ID,
             const char* name,
             const int   version) :
      __ID     (ID),
      __name   (name),
      __version(version)
    {}
 
 
    /**
     * Get data type identifier.
     *
     * \return                   identifier
     */
    inline int getID() const
    {
      return __ID;
    }
    
    
    /**
     * Get name of data type.
     *
     * \return                   name
     */
    inline const char* getName() const
    { 
      return __name;
    }
    
    
    /**
     * Get version of data type.
     *
     * \return                   version
     */
    inline int getVersion() const
    {
      return __version;
    }
 
 
    /**
     * Write label to output.
     *
     * \param  out        output stream
     * \param  object     label
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JLabel_t& object)
    {
      return out << object.getID()   << '/'
                 << object.getName() << ':'
                 << object.getVersion();
    }
 
  protected:
    int         __ID;
    const char* __name;
    int         __version;
  };
 
 
  /**
   * Get default name of data type.
   *
   * \return                   name
   */
  inline const char* getDefaultName()
  {
    return "?";
  }
  
  
  /**
   * Get default version of data type.
   *
   * \return                   version
   */
  inline int getDefaultVersion()
  {
    return -1;
  }
  
 
  /**
   * Test availability of static member methods for labelling data types in a type list.
   */
  template <class T>
  class JTypeID_t :
    public JTest
  {
    template<class U> static JTrue  test1(JTypecheck<const char* (*)(), &U::getName>*);
    template<class U> static JFalse test1(...);
 
    template<class U> static JTrue  test2(JTypecheck<int (*)(), &U::getVersion>*);
    template<class U> static JFalse test2(...);
 
  public:
    static const bool has_name     =  sizeof(test1<T>(NULL)) == sizeof(JTrue);
    static const bool has_version  =  sizeof(test2<T>(NULL)) == sizeof(JTrue);
  };
}
 
 
/**
 * Auxiliary data structure to label data types within a type list.
 */
template<int __ID, 
         const char* (*__getName)   () = JLANG::getDefaultName, 
         int         (*__getVersion)() = JLANG::getDefaultVersion>
struct JLabel {
 
  /**
   * Data type identifier.
   */
  static const int ID = __ID;
 
 
  /**
   * Get name of data type.
   *
   * \return                   name
   */
  static inline const char* getName()
  { 
    return (*__getName)();
  }
 
 
  /**
   * Get version of data type.
   *
   * \return                   version
   */
  static inline int getVersion()
  {
    return (*__getVersion)();
  }
};
 
 
/**
 * Template definition of policy class to label data types in a type list.
 * 
 * A default implementation of this class is provided for data types which already have a unique identifier.
 * This identifier should be implemented as follows:
 * <pre>
 *             static const int ID = <value>;
 * </pre>
 *
 * The optional name and/or a version is then maintained, provided their implementations
 * follow the corresponding declarations in JLANG::JTypeID_t, i.e:
 * <pre>
 *             static const char* getName();
 *             static int         getVersion();
 * </pre>
 *
 * A specialisation of this class should otherwise be provided, e.g. by deriving it from class JLabel.
 * The specialisation should provide the static data member <tt>ID</tt> and the static member methods listed above.
 */
template<class T,
         bool = JLANG::JTypeID_t<T>::has_name,
         bool = JLANG::JTypeID_t<T>::has_version>
struct JTypeID {};
 
 
/**
 * Template specialisation of class without name and version.
 */
template<class T> 
struct JTypeID<T, false, false> : 
  public JLabel<T::ID>
{};
 
 
/**
 * Template specialisation of class with name and without version.
 */
template<class T> 
struct JTypeID<T, true, false> : 
  public JLabel<T::ID, &T::getName>
{};
 
 
/**
 * Template specialisation of class without name and with version.
 */
template<class T> 
struct JTypeID<T, false, true> : 
  public JLabel<T::ID, &JLANG::getDefaultName, &T::getVersion>
{};
 
 
/**
 * Template specialisation of class with name and version.
 */
template<class T> 
struct JTypeID<T, true, true> : 
  public JLabel<T::ID, &T::getName, &T::getVersion>
{};
 
 
/**
 * Template specialisation of class JTypeID for class JLANG::JNullType.
 */
template<> 
struct JTypeID<JLANG::JNullType> : 
  public JLabel<0> 
{};
 
#endif