IdString.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SAT_IDSTR_H
#define ZYPP_SAT_IDSTR_H
 
#include <iosfwd>
#include <string>
#include <string_view>
#include <unordered_set>
 
#include <boost/utility/string_ref_fwd.hpp>
 
#include <zypp-core/Globals.h>
#include <zypp-core/base/Hash.h>
 
#include <zypp/sat/detail/PoolDefines.h>
 
 
#if ( LEGACY(1735) ) && !ZYPPNG
#include <zypp/sat/detail/PoolMember.h>
#endif

namespace zypp
{ 
 
  class IdString;
  using IdStringSet = std::unordered_set<IdString>;

  //
  //    CLASS NAME : IdString
  //
  class ZYPP_API IdString
#if ( LEGACY(1735) ) && !ZYPPNG
    : protected sat::detail::PoolMember
#endif
  {
    public:
      using IdType = sat::detail::IdType;
 
    public:
      constexpr IdString() : _id( sat::detail::emptyId ) {}

      constexpr explicit IdString( IdType id_r ) : _id( id_r ) {}

      explicit IdString( const char * str_r );

      IdString( const char * str_r, unsigned len_r );

      explicit IdString( const std::string & str_r );

      explicit IdString( boost::string_ref str_r );
 
#ifdef __cpp_lib_string_view
      explicit IdString( std::string_view str_r )
      : IdString( str_r.data(), str_r.size() )
      {}
#endif
 
    public:
      static const IdString Null;

      static const IdString Empty;
 
    public:
      constexpr explicit operator bool() const
      { return _id; }

      constexpr bool empty() const
      { return( _id == sat::detail::emptyId || _id == sat::detail::noId ); }

      unsigned size() const;
 
    public:
      const char * c_str() const;

      std::string asString() const
      { return c_str(); }

      explicit operator std::string() const
      { return asString(); }
 
#ifdef __cpp_lib_string_view
      std::string_view asStringView() const
      { return { c_str(), size() }; }

      explicit operator std::string_view() const
      { return asStringView(); }
#endif
 
    public:
      bool compareEQ( const IdString & rhs ) const
      { return( _id == rhs.id() ); }

      int compare( const IdString & rhs ) const;

      int compare( const char * rhs ) const;

      int compare( const std::string & rhs ) const
      { return compare( rhs.c_str() ); }
 
    public:
      IdType id() const
      { return _id; }
 
    private:
      IdType _id;
  };


  std::ostream & operator<<( std::ostream & str, const IdString & obj ) ZYPP_API;

  std::ostream & dumpOn( std::ostream & str, const IdString & obj ) ZYPP_API;

  inline bool operator==( const IdString & lhs, const IdString & rhs )
  { return lhs.compareEQ( rhs ); }

  inline bool operator==( const IdString & lhs, const char * rhs )
  { return lhs.compare( rhs ) == 0; }

  inline bool operator==( const IdString & lhs, const std::string & rhs )
  { return lhs.compare( rhs ) == 0; }

  inline bool operator==( const char * lhs, const IdString & rhs )
  { return rhs.compare( lhs ) == 0; }

  inline bool operator==( const std::string & lhs, const IdString & rhs )
  { return rhs.compare( lhs ) == 0; }

  inline bool operator!=( const IdString & lhs, const IdString & rhs )
  { return ! lhs.compareEQ( rhs ); }

  inline bool operator!=( const IdString & lhs, const char * rhs )
  { return lhs.compare( rhs ) != 0; }

  inline bool operator!=( const IdString & lhs, const std::string & rhs )
  { return lhs.compare( rhs ) != 0; }

  inline bool operator!=( const char * lhs, const IdString & rhs )
  { return rhs.compare( lhs ) != 0; }

  inline bool operator!=( const std::string & lhs, const IdString & rhs )
  { return rhs.compare( lhs ) != 0; }

  inline bool operator<( const IdString & lhs, const IdString & rhs )
  { return lhs.compare( rhs ) < 0; }

  inline bool operator<( const IdString & lhs, const char * rhs )
  { return lhs.compare( rhs ) < 0; }

  inline bool operator<( const IdString & lhs, const std::string & rhs )
  { return lhs.compare( rhs ) < 0; }

  inline bool operator<( const char * lhs, const IdString & rhs )
  { return rhs.compare( lhs ) >= 0; }

  inline bool operator<( const std::string & lhs, const IdString & rhs )
  { return rhs.compare( lhs ) >= 0; }

  inline bool operator<=( const IdString & lhs, const IdString & rhs )
  { return lhs.compare( rhs ) <= 0; }

  inline bool operator<=( const IdString & lhs, const char * rhs )
  { return lhs.compare( rhs ) <= 0; }

  inline bool operator<=( const IdString & lhs, const std::string & rhs )
  { return lhs.compare( rhs ) <= 0; }

  inline bool operator<=( const char * lhs, const IdString & rhs )
  { return rhs.compare( lhs ) > 0; }

  inline bool operator<=( const std::string & lhs, const IdString & rhs )
  { return rhs.compare( lhs ) > 0; }

  inline bool operator>( const IdString & lhs, const IdString & rhs )
  { return lhs.compare( rhs ) > 0; }

  inline bool operator>( const IdString & lhs, const char * rhs )
  { return lhs.compare( rhs ) > 0; }

  inline bool operator>( const IdString & lhs, const std::string & rhs )
  { return lhs.compare( rhs ) > 0; }

  inline bool operator>( const char * lhs, const IdString & rhs )
  { return rhs.compare( lhs ) <= 0; }

  inline bool operator>( const std::string & lhs, const IdString & rhs )
  { return rhs.compare( lhs ) <= 0; }

  inline bool operator>=( const IdString & lhs, const IdString & rhs )
  { return lhs.compare( rhs ) >= 0; }

  inline bool operator>=( const IdString & lhs, const char * rhs )
  { return lhs.compare( rhs ) >= 0; }

  inline bool operator>=( const IdString & lhs, const std::string & rhs )
  { return lhs.compare( rhs ) >= 0; }

  inline bool operator>=( const char * lhs, const IdString & rhs )
  { return rhs.compare( lhs ) < 0; }

  inline bool operator>=( const std::string & lhs, const IdString & rhs )
  { return rhs.compare( lhs ) < 0; }

} // namespace zypp
 
ZYPP_DEFINE_ID_HASHABLE( ::zypp::IdString );
 
#endif // ZYPP_SAT_IDSTR_H