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>
#include <format>
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();
  }
}

namespace std {
template <>
struct formatter<SG::VersionedKey>
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format(const SG::VersionedKey& k, FmtContext& ctx) const
  {
    return formatter<string_view>::format (k.rawVersionKey(), ctx);
  }
};
}
 
#endif