stc/exp/ml_stc_linux_make_v1.0/include/boost/detail/identifier.hpp

   1 //  boost/identifier.hpp  ----------------------------------------------------//\r
   2 \r
   3 //  Copyright Beman Dawes 2006\r
   4 \r
   5 //  Distributed under the Boost Software License, Version 1.0. (See accompanying\r
   6 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\r
   7 \r
   8 //  See documentation at http://www.boost.org/libs/utility\r
   9 \r
  10 #ifndef BOOST_IDENTIFIER_HPP\r
  11 #define BOOST_IDENTIFIER_HPP\r
  12 \r
  13 #include <boost/utility/enable_if.hpp>\r
  14 #include <boost/type_traits/is_base_of.hpp>\r
  15 #include <iosfwd>\r
  16 \r
  17 namespace boost\r
  18 {\r
  19   namespace detail\r
  20   {\r
  21     //  class template identifier  ---------------------------------------------//\r
  22 \r
  23     //  Always used as a base class so that different instantiations result in\r
  24     //  different class types even if instantiated with the same value type T.\r
  25 \r
  26     //  Expected usage is that T is often an integer type, best passed by\r
  27     //  value. There is no reason why T can't be a possibly larger class such as\r
  28     //  std::string, best passed by const reference.\r
  29 \r
  30     //  This implementation uses pass by value, based on expected common uses.\r
  31 \r
  32     template <typename T, typename D>\r
  33     class identifier\r
  34     {\r
  35     public:\r
  36       typedef T value_type;\r
  37 \r
  38       const value_type value() const           { return m_value; }\r
  39       void  assign( value_type v )             { m_value = v; }\r
  40 \r
  41       bool operator==( const D & rhs ) const   { return m_value == rhs.m_value; }\r
  42       bool operator!=( const D & rhs ) const   { return m_value != rhs.m_value; }\r
  43       bool operator< ( const D & rhs ) const   { return m_value <  rhs.m_value; }\r
  44       bool operator<=( const D & rhs ) const   { return m_value <= rhs.m_value; }\r
  45       bool operator> ( const D & rhs ) const   { return m_value >  rhs.m_value; }\r
  46       bool operator>=( const D & rhs ) const   { return m_value >= rhs.m_value; }\r
  47 \r
  48       typedef void (*unspecified_bool_type)(D); // without the D, unspecified_bool_type \r
  49       static void unspecified_bool_true(D){}    // conversion allows relational operators\r
  50                                                 // between different identifier types\r
  51 \r
  52       operator unspecified_bool_type() const   { return m_value == value_type() ? 0 : unspecified_bool_true; }\r
  53       bool operator!() const                   { return m_value == value_type(); }\r
  54 \r
  55     // constructors are protected so that class can only be used as a base class\r
  56     protected:\r
  57       identifier()                             {}\r
  58       explicit identifier( value_type v )      : m_value(v) {}\r
  59 \r
  60   #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300  // 1300 == VC++ 7.0 bug workaround\r
  61     private:\r
  62   #endif\r
  63       T m_value;\r
  64     };\r
  65 \r
  66   //#ifndef BOOST_NO_SFINAE\r
  67 \r
  68   //  template <class Ostream, class Id>\r
  69   //    typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, \r
  70   //      Ostream & >::type operator<<( Ostream & os, const Id & id )\r
  71   //  {\r
  72   //    return os << id.value();\r
  73   //  }\r
  74 \r
  75   //  template <class Istream, class Id>\r
  76   //    typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, \r
  77   //      Istream & >::type operator>>( Istream & is, Id & id )\r
  78   //  {\r
  79   //    typename Id::value_type v;\r
  80   //    is >> v;\r
  81   //    id.value( v );\r
  82   //    return is;\r
  83   //  }\r
  84   //#endif\r
  85 \r
  86   } // namespace detail\r
  87 } // namespace boost\r
  88 \r
  89 #endif // BOOST_IDENTIFIER_HPP\r