StringKey.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_STRINGKEY_H
#define GAUDIKERNEL_STRINGKEY_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <iosfwd>
#include <string>
#include <functional>
#include <algorithm>
#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: // equality
    // ========================================================================
    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) ; }
    // ========================================================================
  public: // ordering
    // ========================================================================
    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 ) ; }
    // ========================================================================
  public:  // few helper methods for indirect usage, mainly for Python
    // ========================================================================
    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
// ============================================================================