text: /*=============================================================================
      Copyright (c) 2001-2003 Joel de Guzman
      Copyright (c) 2001 Daniel Nuffer
      http://spirit.sourceforge.net/
  
      Use, modification and distribution is subject to the Boost Software
      License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
      http://www.boost.org/LICENSE_1_0.txt)
  =============================================================================*/
  #if !defined(BOOST_SPIRIT_PARSER_ID_HPP)
  #define BOOST_SPIRIT_PARSER_ID_HPP
  
  ///////////////////////////////////////////////////////////////////////////////
  namespace boost { namespace spirit {
  
      ///////////////////////////////////////////////////////////////////////////
      //
      //  parser_id class
      //
      ///////////////////////////////////////////////////////////////////////////
      class parser_id
      {
      public:
                      parser_id()                     : p(0) {}
          explicit    parser_id(void const* prule)    : p(prule) {}
                      parser_id(std::size_t l_)       : l(l_) {}
  
          bool operator==(parser_id const& x) const   { return p == x.p; }
          bool operator!=(parser_id const& x) const   { return !(*this == x); }
          bool operator<(parser_id const& x) const    { return p < x.p; }
          std::size_t to_long() const                 { return l; }
  
      private:
  
          union
          {
              void const* p;
              std::size_t l;
          };
      };
  
      #if defined(BOOST_SPIRIT_DEBUG)
      inline std::ostream&
      operator<<(std::ostream& out, parser_id const& rid)
      {
          out << rid.to_long();
          return out;
      }
      #endif
  
      ///////////////////////////////////////////////////////////////////////////
      //
      //  parser_tag_base class: base class of all parser tags
      //
      ///////////////////////////////////////////////////////////////////////////
      struct parser_tag_base {};
      
      ///////////////////////////////////////////////////////////////////////////
      //
      //  parser_address_tag class: tags a parser with its address
      //
      ///////////////////////////////////////////////////////////////////////////
      struct parser_address_tag : parser_tag_base
      {
          parser_id id() const
          { return parser_id(reinterpret_cast<std::size_t>(this)); }
      };
  
      ///////////////////////////////////////////////////////////////////////////
      //
      //  parser_tag class: tags a parser with an integer ID
      //
      ///////////////////////////////////////////////////////////////////////////
      template <int N>
      struct parser_tag : parser_tag_base
      {
          static parser_id id()
          { return parser_id(std::size_t(N)); }
      };
  
      ///////////////////////////////////////////////////////////////////////////
      //
      //  dynamic_parser_tag class: tags a parser with a dynamically changeable
      //  integer ID
      //
      ///////////////////////////////////////////////////////////////////////////
      class dynamic_parser_tag : public parser_tag_base
      {
      public:
      
          dynamic_parser_tag() 
          : tag(std::size_t(0)) {}
          
          parser_id 
          id() const
          { 
              return 
                  tag.to_long() 
                  ? tag 
                  : parser_id(reinterpret_cast<std::size_t>(this)); 
          }
  
          void set_id(parser_id id) { tag = id; } 
          
      private:
      
          parser_id tag;
      };
  
  ///////////////////////////////////////////////////////////////////////////////
  }} // namespace boost::spirit
  
  #endif
  
  