SGVersionedKey.h

Go to the documentation of this file.

/* -*- C++ -*- */
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef SGTOOLS_VERSIONEDKEY_H
#define SGTOOLS_VERSIONEDKEY_H 1
#include <iostream>
#include <string>
class StoreGateSvc; //our friend
class SGImplSvc; //our friend
namespace SG {
  template <class T>  class ObjectWithVersion;
 
  class VersionedKey {
    friend class ::StoreGateSvc; //call copyVK
    friend class ::SGImplSvc; //call copyVK
  public:
    static bool isVersionedKey(const char *);
    static bool isVersionedKey(const std::string&);
 
    static bool isAuto(const std::string&);
 
    VersionedKey(const char* key, unsigned char version);
    VersionedKey(const std::string& key, unsigned char version);
 
    explicit VersionedKey(const char* vkey);
    explicit VersionedKey(const std::string& vkey);
 
    //Defaulted copy and move constructors and assignment operators
    //since the class only holds strings.
    VersionedKey(const VersionedKey& rhs) = default;    
    VersionedKey(VersionedKey&& rhs) = default;
    VersionedKey& operator= (const VersionedKey& rhs) = default;
    VersionedKey& operator= (VersionedKey&& rhs) = default;
 
    ~VersionedKey();
 
    void decode(std::string& outKey, unsigned char& version) const;
    // cppcheck-suppress returnByReference
    operator std::string() const { return m_versionKey; }
    unsigned char version() const;
    const std::string& key() const;
    const std::string& rawVersionKey() const {
      return m_versionKey;
    }
    bool sameKey(const VersionedKey& vkey) const;
    bool sameKey(const std::string& baseKey) const;
    bool sameKey(const char* baseKey) const;
    bool isAuto() const { return version() == VersionedKey::autoV(); }
 
  private:
    template <class U> friend class ObjectWithVersion;
    VersionedKey(): m_versionKey() {}
 
    void encode(const std::string& inKey, unsigned char version);
    void copyVK(const std::string& inKey);
 
    static char separator() {return ';';}
    static const char* versionFormatString() {return ";%02u;";}
    static const char* formatString() {return ";%02u;%s";}
 
    static unsigned char autoV() { return 99;}
    static unsigned char defaultV() { return 0;}
    static const char* autoVS() { return "_99_"; }
    static const char* defaultVS() { return "_00_"; }
 
    std::string m_versionKey; 
    std::string m_baseKey;
  };
} // ns SG
 
bool operator < (const SG::VersionedKey& lhs, const SG::VersionedKey& rhs);
 
namespace SG {
  inline
    std::ostream& operator <<(std::ostream& ost, const SG::VersionedKey& k) {
    return ost << k.rawVersionKey();
    //  return ost.write(k.rawVersionKey(), strlen(k.rawVersionKey()));
  }
}
 
#endif