UniqueString.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_UNIQUESTRING_H
#define ZYPP_BASE_UNIQUESTRING_H

#include <iosfwd>
#include <string>

#include <zypp/base/Hash.h>

namespace zypp
{ 

  namespace base
  { 

    //
    //  CLASS NAME : UniqueString
    //
    template<class _Derived>
        class UniqueString
    {
    protected:
      UniqueString()
      {}

      UniqueString( const std::string & name_r )
      {
        if ( !name_r.empty() )
        {
          _name = *(this->hash().insert( name_r ).first);
        }
      }

      virtual ~UniqueString()
      {}

    public:
      const std::string & asString() const
      { return _name; }

      const std::string & str() const
      { return asString(); }

      operator const std::string & () const
      { return asString(); }

      std::string::size_type size() const
      { return asString().size(); }

      bool empty() const
      { return asString().empty(); }

      int compare( const std::string & rhs ) const
      { return asString().compare( rhs ); }

    public:
      typedef hash_set<std::string>::size_type size_type;
      typedef hash_set<std::string>::const_iterator const_iterator;

      static bool allEmpty()
      { return hash().empty(); }

      static size_type allSize()
      { return hash().size(); }

      static const_iterator allBegin()
      { return hash().begin(); }

      static const_iterator allEnd()
      { return hash().end(); }

    private:
      static hash_set<std::string> & hash()
      {
        static hash_set<std::string> _value;
        return _value;
      }

    private:
      std::string _name;
    };

    template<class _Derived>
        inline bool operator==( const UniqueString<_Derived> & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs.str() == rhs.str() ); }
    template<class _Derived>
        inline bool operator==( const UniqueString<_Derived> & lhs, const std::string & rhs )
    { return ( lhs.str() == rhs ); }
    template<class _Derived>
        inline bool operator==( const std::string & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs == rhs.str() ); }


    template<class _Derived>
        inline bool operator!=( const UniqueString<_Derived> & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs.str() != rhs.str() ); }
    template<class _Derived>
        inline bool operator!=( const UniqueString<_Derived> & lhs, const std::string & rhs )
    { return ( lhs.str() != rhs ); }
    template<class _Derived>
        inline bool operator!=( const std::string & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs != rhs.str() ); }


    template<class _Derived>
        inline bool operator<( const UniqueString<_Derived> & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs.str() < rhs.str() ); }
    template<class _Derived>
        inline bool operator<( const UniqueString<_Derived> & lhs, const std::string & rhs )
    { return ( lhs.str() < rhs ); }
    template<class _Derived>
        inline bool operator<( const std::string & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs < rhs.str() ); }


    template<class _Derived>
        inline bool operator>( const UniqueString<_Derived> & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs.str() > rhs.str() ); }
    template<class _Derived>
        inline bool operator>( const UniqueString<_Derived> & lhs, const std::string & rhs )
    { return ( lhs.str() > rhs ); }
    template<class _Derived>
        inline bool operator>( const std::string & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs > rhs.str() ); }


    template<class _Derived>
        inline bool operator<=( const UniqueString<_Derived> & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs.str() <= rhs.str() ); }
    template<class _Derived>
        inline bool operator<=( const UniqueString<_Derived> & lhs, const std::string & rhs )
    { return ( lhs.str() <= rhs ); }
    template<class _Derived>
        inline bool operator<=( const std::string & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs <= rhs.str() ); }


    template<class _Derived>
        inline bool operator>=( const UniqueString<_Derived> & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs.str() >= rhs.str() ); }
    template<class _Derived>
        inline bool operator>=( const UniqueString<_Derived> & lhs, const std::string & rhs )
    { return ( lhs.str() >= rhs ); }
    template<class _Derived>
        inline bool operator>=( const std::string & lhs, const UniqueString<_Derived> & rhs )
    { return ( lhs >= rhs.str() ); }

    template<class _Derived>
        inline std::ostream & operator<<( std::ostream & str, const UniqueString<_Derived> & obj )
    { return str << obj.str(); }

  } // namespace base
} // namespace zypp
#endif // ZYPP_BASE_UNIQUESTRING_H

---