Ustring.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       Ustring.h

   Author:     Michael Andres <ma@suse.de>
   Maintainer: Michael Andres <ma@suse.de>

/-*/
#ifndef Ustring_h
#define Ustring_h

#include <iostream>
#include <string>
// MemUsage.h defines/undefines D_MEMUSAGE
#include "y2util/MemUsage.h"
#include <set>

//
//      CLASS NAME : UstringHash
class UstringHash
#ifdef D_MEMUSAGE
 : public MemUsage
#endif
 {

  protected:

    typedef std::set<std::string> UstringHash_type;

    UstringHash_type _UstringHash;

  public:

    const std::string & add( const std::string & nstr_r )
    {
        return *(_UstringHash.insert( nstr_r ).first);
    }

    unsigned size() const { return _UstringHash.size(); }
    unsigned long sum() const {
        UstringHash_type::const_iterator it = _UstringHash.begin();
        UstringHash_type::const_iterator e = _UstringHash.end();
        unsigned long sum = 0;
        while (it != e)
        {
            sum += it->size();
            it++;
        }
        return sum;
    }
#ifdef D_MEMUSAGE
    virtual size_t mem_size () const { return sizeof (UstringHash); }
#endif
};


//
//      CLASS NAME : Ustring
class Ustring
#ifdef D_MEMUSAGE
  : public MemUsage
#endif
 {

  private:

    std::string _name;

  public:
#ifdef D_MEMUSAGE
    virtual size_t mem_size () const { return sizeof (Ustring); }
#endif

    Ustring( UstringHash & nameHash_r, const std::string & n  )
      :_name( nameHash_r.add( n ) )
    {}

  public:

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

    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 );
    }

    int compare( const Ustring & rhs ) const {
      if ( *this == rhs )
        return 0;
      return( *this < rhs ? -1 : 1 );
    }

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

    // operator ==

    friend bool operator==( const Ustring & lhs, const Ustring & rhs ) {
      // Ustrings share their string representation
      return ( lhs->c_str() == rhs->c_str() );
    }

    friend bool operator==( const Ustring & lhs, const std::string & rhs ) {
      return ( (const std::string &)lhs == rhs );
    }

    friend bool operator==( const std::string & lhs, const Ustring & rhs ) {
      return ( lhs == (const std::string &)rhs );
    }

    // operator !=

    friend bool operator!=( const Ustring & lhs, const Ustring & rhs ) {
      return ( ! operator==( lhs, rhs ) );
    }

    friend bool operator!=( const Ustring & lhs, const std::string & rhs ) {
      return ( ! operator==( lhs, rhs ) );
    }

    friend bool operator!=( const std::string & lhs, const Ustring & rhs ) {
      return ( ! operator==( lhs, rhs ) );
    }

    // operator <

    friend bool operator<( const Ustring & lhs, const Ustring & rhs ) {
      return ( (const std::string &)lhs < (const std::string &)rhs );
    }

    friend bool operator<( const Ustring & lhs, const std::string & rhs ) {
      return ( (const std::string &)lhs < rhs );
    }

    friend bool operator<( const std::string & lhs, const Ustring & rhs ) {
      return ( lhs < (const std::string &)rhs );
    }

    // operator >

    friend bool operator>( const Ustring & lhs, const Ustring & rhs ) {
      return ( (const std::string &)lhs > (const std::string &)rhs );
    }

    friend bool operator>( const Ustring & lhs, const std::string & rhs ) {
      return ( (const std::string &)lhs > rhs );
    }

    friend bool operator>( const std::string & lhs, const Ustring & rhs ) {
      return ( lhs > (const std::string &)rhs );
    }

    // operator >=

    friend bool operator>=( const Ustring & lhs, const Ustring & rhs ) {
      return ( ! operator<( lhs, rhs ) );
    }

    friend bool operator>=( const Ustring & lhs, const std::string & rhs ) {
      return ( ! operator<( lhs, rhs ) );
    }

    friend bool operator>=( const std::string & lhs, const Ustring & rhs ) {
      return ( ! operator<( lhs, rhs ) );
    }

    // operator <=

    friend bool operator<=( const Ustring & lhs, const Ustring & rhs ) {
      return ( ! operator>( lhs, rhs ) );
    }

    friend bool operator<=( const Ustring & lhs, const std::string & rhs ) {
      return ( ! operator>( lhs, rhs ) );
    }

    friend bool operator<=( const std::string & lhs, const Ustring & rhs ) {
      return ( ! operator>( lhs, rhs ) );
    }

    // IO

    friend std::ostream & operator<<( std::ostream & str, const Ustring & obj ) {
      return str << (const std::string &)obj;
    }
};

#endif // Ustring_h