MetaInfoInterface.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <vector>
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <OpenMS/METADATA/MetaInfoRegistry.h>
#include <OpenMS/DATASTRUCTURES/DataValue.h>
 
namespace OpenMS
{
  class String;
  class MetaInfo;
 
  class OPENMS_DLLAPI MetaInfoInterface
  {
public:
 
    MetaInfoInterface() = default;
    MetaInfoInterface(const MetaInfoInterface& rhs);
    MetaInfoInterface(MetaInfoInterface&&) noexcept;
    ~MetaInfoInterface();
 
    MetaInfoInterface& operator=(const MetaInfoInterface& rhs);
    MetaInfoInterface& operator=(MetaInfoInterface&&) noexcept;
 
    void swap(MetaInfoInterface& rhs);
 
    bool operator==(const MetaInfoInterface& rhs) const;
    bool operator!=(const MetaInfoInterface& rhs) const;
 
    const DataValue& getMetaValue(const String& name) const;
 
    DataValue getMetaValue(const String& name, const DataValue& default_value) const; // Note: return needs to be by value to prevent life-time issues at caller site (e.g. if he passes a temporary to default-value)
 
    const DataValue& getMetaValue(UInt index) const;
 
    DataValue getMetaValue(UInt index, const DataValue& default_value) const; // Note: return needs to be by value to prevent life-time issues at caller site
 
    bool metaValueExists(const String& name) const;
    bool metaValueExists(UInt index) const;
 
    void setMetaValue(const String& name, const DataValue& value);
    void setMetaValue(UInt index, const DataValue& value);
 
    void removeMetaValue(const String& name);
    void removeMetaValue(UInt index);
 
    void addMetaValues(const MetaInfoInterface& from);
 
    static MetaInfoRegistry& metaRegistry();
 
    void getKeys(std::vector<String>& keys) const;
 
    void getKeys(std::vector<UInt>& keys) const;
 
    bool isMetaEmpty() const;
 
    void clearMetaInfo();
 
protected:
 
    inline void createIfNotExists_();
 
    MetaInfo* meta_ = nullptr;
  };
 
} // namespace OpenMS
 
// Hash function specialization for MetaInfoInterface
namespace std
{
  template<>
  struct hash<OpenMS::MetaInfoInterface>
  {
    std::size_t operator()(const OpenMS::MetaInfoInterface& meta) const noexcept
    {
      // Use additive accumulation for order-independent hashing (O(n) vs O(n log n))
      std::size_t hash = 0;
 
      // Hash String keys (names)
      std::vector<OpenMS::String> str_keys;
      meta.getKeys(str_keys);
      for (const auto& key : str_keys)
      {
        std::size_t pair_hash = OpenMS::fnv1a_hash_string(key);
        OpenMS::hash_combine(pair_hash, std::hash<OpenMS::DataValue>{}(meta.getMetaValue(key)));
        hash += pair_hash;  // Order-independent accumulation
      }
 
      // Hash UInt keys (indices) - critical for correctness
      std::vector<OpenMS::UInt> uint_keys;
      meta.getKeys(uint_keys);
      for (const auto& key : uint_keys)
      {
        std::size_t pair_hash = OpenMS::hash_int(static_cast<int64_t>(key));
        OpenMS::hash_combine(pair_hash, std::hash<OpenMS::DataValue>{}(meta.getMetaValue(key)));
        hash += pair_hash;  // Order-independent accumulation
      }
 
      return hash;
    }
  };
} // namespace std