JTag.hh

Go to the documentation of this file.

#ifndef __JNET__JCONTROLHOSTTAG__
#define __JNET__JCONTROLHOSTTAG__
 
#include <istream>
#include <ostream>
#include <string>
 
#include "JLang/JException.hh"
#include "JLang/JType.hh"
#include "JLang/JNullType.hh"
 
 
/**
 * \file
 * ControlHost tag.
 *
 * \author mdejong
 */
 
namespace JNET {}
namespace JPP { using namespace JNET; }
 
namespace JNET {
 
  using JLANG::JControlHostException;
 
 
  /**
   * Type definition of numerical ControlHost tag.
   */
  typedef  long long int     JTag_t;
  static const size_t        TAGSIZE  =  sizeof(JTag_t);   //!< Size of ControlHost tag.
 
 
  /**
   * ControlHost tag.
   */
  class JTag {
  public:
    /**
     * Default constructor.
     */
    JTag() :
      id(0)
    {}
      
    
    /**
     * Copy constructor.
     *
     * \param  tag            tag
     */
    JTag(const JTag& tag)
    {
      setTag(tag);
    }
  
    
    /**
     * Constructor.
     *
     * \param  tag            tag
     */
    JTag(const std::string& tag)
    {
      setTag(tag);
    }
  
    
    /**
     * Constructor.
     *
     * \param  id             identifier
     */
    JTag(const JTag_t id)
    {
      setTag(id);
    }
 
 
    /**
     * Get tag.
     *
     * \return                tag
     */
    const JTag& getTag() const
    {
      return static_cast<const JTag&>(*this);
    }
 
 
    /**
     * Get tag.
     *
     * \return                tag
     */
    JTag& getTag()
    {
      return static_cast<JTag&>(*this);
    }
 
 
    /**
     * Set tag.
     *
     * \param  tag            tag
     */
    void setTag(const JTag& tag)
    {
      id = tag.getID();
    }
 
 
    /**
     * Set tag.
     *
     * This method may throw an exception.
     *
     * \param  tag            tag
     */
    void setTag(const std::string& tag)
    {
      if (!tag.empty() && tag.size() <= TAGSIZE) {
        
        char* __p = (char*) &(this->id);
 
        size_t i = 0;
 
        for ( ; i != tag.size(); ++i) {
          __p[i] = tag[i];
        }
 
        for ( ; i != TAGSIZE;    ++i) {
          __p[i] = '\0';
        }
 
      } else {
 
        THROW(JControlHostException, "Invalid tag length <" << tag << "> " << tag.size());
      }
    }
 
 
    /**
     * Set tag.
     *
     * \param  id             identifier
     */
    void setTag(const JTag_t id)
    { 
      this->id = id;
    }
 
 
    /**
     * Get identifier.
     *
     * \return                identifier
     */
    JTag_t getID() const 
    { 
      return id;
    }
 
 
    /**
     * Convert tag to string.
     *
     * \return                tag
     */
    std::string toString() const
    {
      int pos = TAGSIZE;
 
      const char* __p = (const char*) &(this->id);
      
      while (pos != 0 && __p[pos-1] == '\0') {
        --pos;
      }
 
      return std::string(__p, pos);
    }
    
 
    /**
     * Type conversion operators.
     *
     * \return                tag
     */
    inline operator std::string() const 
    {
      return toString();
    }
 
 
    /**
     * C-string.
     *
     * \return                tag
     */
    const char* c_str() const
    {
      return (const char*) &(this->id);
    }
 
 
    /**
     * Get character.
     *
     * \param  i              index
     * \return                character at index
     */
    const char operator[](int i) const
    {
      const char* __p = (const char*) &(this->id);
 
      return __p[i];
    }
 
 
    /**
     * Read JTag from input stream.
     *
     * \param  in       input stream
     * \param  object   JTag
     * \return          input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTag& object)
    {
      std::string buffer;
 
      if (in >> buffer) {
        object.setTag(buffer);
      }
      
      return in;
    }
 
 
    /**
     * Write JTag to output stream.
     *
     * \param  out      output stream
     * \param  object   JTag
     * \return          output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTag& object)
    {
      return out << object.toString();
    }
 
 
  protected:
    JTag_t id;
  };
 
 
  /**
   * Less than operator for JTag
   *
   * \param  first          tag
   * \param  second         tag
   * \return
   */
  inline bool operator<(const JTag& first, const JTag& second)
  {
    return first.getID() < second.getID();
  }
 
 
  /**
   * Equal operator for JTag
   *
   * \param  first          tag
   * \param  second         tag
   * \return
   */
  inline bool operator==(const JTag& first, const JTag& second)
  {
    return first.getID() == second.getID();
  }
 
 
  /**
   * Not equal operator for JTag
   *
   * \param  first          tag
   * \param  second         tag
   * \return
   */
  inline bool operator!=(const JTag& first, const JTag& second)
  {
    return first.getID() != second.getID();
  }
 
 
  /**
   * Special ControlHost tags
   */
  static const JTag  DISPTAG_Subscribe ("_Subscri");
  static const JTag  DISPTAG_Gime      ("_Gime");
  static const JTag  DISPTAG_Always    ("_Always");
  static const JTag  DISPTAG_MyId      ("_MyId");
  static const JTag  DISPTAG_Born      ("Born");
  static const JTag  DISPTAG_Died      ("Died");
  static const JTag  DISPTAG_ShowStat  ("_ShowSta");
  static const JTag  DISPTAG_WhereIs   ("_WhereIs");
  static const JTag  DISPTAG_Version   ("_Version");
  static const JTag  DISPTAG_Debug     ("_Debug");
  static const JTag  DISPTAG_UNDEFINED (0);
}
 
 
/**
 * Template definition for method returning JNET::JTag value.
 * The template argument refers to the data type for future ControlHost operations.
 */
template<class T>
inline JNET::JTag getTag()
{
  return getTag(JLANG::JType<T>());
}
 
 
/**
 * Default argument definition for method returning JNET::JTag.
 * The method argument refers to the data type for future I/O operations.
 * This method should be overloaded for each desired class and
 * return a corresponding JNET::JTag value.
 *
 * \param  type           data type
 */
template<class T>
inline JLANG::JNullType getTag(JLANG::JType<T> type);
 
 
 
 
/**
 * Test availability of JNET::JTag value for given class.
 *
 * The parameter result evaluates to true if for this class a JNET::JTag value is defined.
 */
template<class T>
class JTagAvailable
{
private:
  
  class JSmall { char buffer; };
  class JBig   { int  buffer; };
  
  static JBig   JTest(...);
  static JSmall JTest(const JNET::JTag&);
  
public:
  static const bool result = sizeof(JTest(getTag(JLANG::JType<T>()))) == sizeof(JSmall); //!< true if defined tag; else false
};
 
#endif