StringKey.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_STRINGKEY_H
#define GAUDIKERNEL_STRINGKEY_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <algorithm>
#include <functional>
#include <iosfwd>
#include <string>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StatusCode.h"
// ============================================================================
namespace Gaudi
{
  // ==========================================================================
  class GAUDI_API StringKey
  {
  public:
    // ========================================================================
    StringKey( const char* key = "" ); // constructor, perform hashing
    StringKey( std::string key ); // constructor, perform hashing
    // ========================================================================
  public:
    // ========================================================================
    const std::string& str() const { return m_str; }
    operator const std::string&() const { return str(); }
    bool empty() const { return m_str.empty(); }
    bool operator!() const { return empty(); }
    // ========================================================================
  public:
    // ========================================================================
    bool operator==( const StringKey& o ) const { return m_hash == o.m_hash && m_str == o.m_str; }
    bool operator==( const std::string& o ) const { return m_str == o; }
    // ========================================================================
  public: // non-equality
    // ========================================================================
    bool operator!=( const StringKey& o ) const { return !( *this == o ); }
    bool operator!=( const std::string& o ) const { return !( *this == o ); }
    // ========================================================================
    // ordering
    // ========================================================================
  public:
    bool operator<( const StringKey& o ) const { return m_hash == o.m_hash ? m_str < o.m_str : m_hash < o.m_hash; }
    bool operator>( const StringKey& o ) const { return o < *this; }
    bool operator<=( const StringKey& o ) const { return !( *this > o ); }
    bool operator>=( const StringKey& o ) const { return !( *this < o ); }
    // ========================================================================
    // few helper methods for indirect usage, mainly for Python
    // ========================================================================
  public:
    std::size_t __hash__() const { return m_hash; }
    // ========================================================================
    std::string __str__() const; // the representation of the object
    std::string __repr__() const; // the representation of the object
    bool __eq__( const StringKey& right ) const;
    bool __eq__( const std::string& right ) const;
    bool __neq__( const StringKey& right ) const;
    bool __neq__( const std::string& right ) const;
    // ========================================================================
  public:
    // ========================================================================
    std::string toString() const; // string representation (for properties)
    // ========================================================================
  private:
    // ========================================================================
    std::string m_str; // the actual string
    std::size_t m_hash; //          the hash
    // ========================================================================
  };
  // ==========================================================================
  template <unsigned int N>
  inline bool operator==( const Gaudi::StringKey& key1, const char ( &key2 )[N] )
  {
    return key1.str().size() == N && std::equal( key2, key2 + N, key1.str().begin() );
  }
  // ==========================================================================
  template <unsigned int N>
  inline bool operator!=( const Gaudi::StringKey& key1, const char ( &key2 )[N] )
  {
    return !( key1 == key2 );
  }
  // ==========================================================================
  inline bool operator==( const std::string& key1, const Gaudi::StringKey& key2 ) { return key2 == key1; }
  // ==========================================================================
  template <unsigned int N>
  inline bool operator==( const char ( &key1 )[N], const Gaudi::StringKey& key2 )
  {
    return key2 == key1;
  }
  // ==========================================================================
  inline bool operator!=( const std::string& key1, const Gaudi::StringKey& key2 ) { return key2 != key1; }
  // ==========================================================================
  template <unsigned int N>
  inline bool operator!=( const char ( &key1 )[N], const Gaudi::StringKey& key2 )
  {
    return key2 != key1;
  }
  // ==========================================================================
  inline std::size_t hash_value( const Gaudi::StringKey& key ) { return key.__hash__(); }
  // ==========================================================================
} //                                                     end of namespace Gaudi
// interoperability with std::string and const char*
inline std::string operator+( const std::string& lhs, const Gaudi::StringKey& rhs ) { return lhs + rhs.str(); }
inline std::string operator+( const char* lhs, const Gaudi::StringKey& rhs ) { return lhs + rhs.str(); }
inline std::string operator+( const Gaudi::StringKey& lhs, const std::string& rhs ) { return lhs.str() + rhs; }
inline std::string operator+( const Gaudi::StringKey& lhs, const char* rhs ) { return lhs.str() + rhs; }
// ============================================================================
// Streaming  value -> string
// ============================================================================
namespace Gaudi
{
  // ==========================================================================
  namespace Utils
  {
    // ========================================================================
    GAUDI_API std::ostream& toStream( const Gaudi::StringKey& key, std::ostream& s );
    // ========================================================================
  } //                                            end of namespace Gaudi::Utils
  // ==========================================================================
  inline std::ostream& operator<<( std::ostream& o, const Gaudi::StringKey& key ) { return o << key.str(); }
  // ==========================================================================
} //                                                     end of namespace Gaudi
// ============================================================================
// Parsing : string -> value
// ============================================================================
namespace Gaudi
{
  // ==========================================================================
  namespace Parsers
  {
    // ========================================================================
    GAUDI_API StatusCode parse( Gaudi::StringKey& result, const std::string& input );
    // ========================================================================
    GAUDI_API StatusCode parse( std::vector<Gaudi::StringKey>& result, const std::string& input );
    // ========================================================================
  } //                                          end of namespace Gaudi::Parsers
  // ==========================================================================
} //                                                     end of namespace Gaudi
// ============================================================================
namespace std
{
  template <>
  struct hash<Gaudi::StringKey> {
    inline std::size_t operator()( Gaudi::StringKey const& s ) const { return hash_value( s ); }
  };
}
// ============================================================================
#endif // GAUDIKERNEL_STRINGKEY_H
// ============================================================================