basic_symbol.hh

Go to the documentation of this file.

/* -*- C++ -*-
 * $Id: basic_symbol.hh 961 2005-03-11 14:05:33Z fpy $
 */
#ifndef UTILMM_TYPES_BASIC_SYMBOL_HEADER
# define UTILMM_TYPES_BASIC_SYMBOL_HEADER

#include "utilmm/smart/uniq_pointer.hh"
#include "utilmm/hash/hash.hh"

#include "utilmm/types/bits/basic_symbol_fwd.hh"

namespace utilmm {
  
  template<class CharT, class Traits, class Alloc>
  class basic_symbol {
  public:
    typedef std::basic_string<CharT, Traits, Alloc> str_type;
    
  private:
    typedef typename smart::uniq_pointer<str_type>::type ref_type;

  public:
    basic_symbol(str_type const &str = str_type())
      :name(create(str)) {}
    basic_symbol(CharT const *str)
      :name(create(str_type(str))) {}
    basic_symbol(basic_symbol const &other)
      :name(other.name) {}

    ~basic_symbol() {}

    basic_symbol &operator= (basic_symbol const &other) {
      name = other.name;
      return *this;
    }

    bool empty() const {
      return name.null();
    }
    size_t length() const {
      return size_t(empty()?0:name->size());
    }

    bool operator==(basic_symbol const &other) const {
      return name==other.name;
    }
    bool operator!=(basic_symbol const &other) const {
      return !operator==(other);
    }

    bool operator< (basic_symbol const &other) const;
    bool operator> (basic_symbol const &other) const {
      return other.operator< (*this);
    }
    bool operator<=(basic_symbol const &other) const {
      return !operator> (other);
    }
    bool operator>=(basic_symbol const &other) const {
      return !operator< (other);
    }

    bool starts_with(basic_symbol const &sub) const;

    basic_symbol &append(basic_symbol const &other);
    basic_symbol &operator+=(basic_symbol const &other) {
      return append(other);
    }

    basic_symbol operator+ (basic_symbol const &other) const;

    str_type const &str() const {
      return *name;
    }

  private:
    ref_type name;

    static ref_type create(str_type const &str);

    template<typename Ty>
    friend struct hash;
  }; // class utilmm::basic_symbol<>

  template<class CharT, class Traits, class Alloc>
  struct hash< basic_symbol<CharT, Traits, Alloc> >
    :public std::unary_function< basic_symbol<CharT, Traits, Alloc>,
                                 size_t > {
    size_t operator()(basic_symbol<CharT, Traits, Alloc> const &x) const;
  }; // struct utilmm::hash< utilmm::basic_symbol<> >
  
} // namespace utilmm

# define IN_UTILMM_TYPES_BASIC_SYMBOL_HEADER
#include "utilmm/types/bits/basic_symbol.tcc"
# undef IN_UTILMM_TYPES_BASIC_SYMBOL_HEADER
#endif // UTILMM_TYPES_BASIC_SYMBOL_HEADER