MetaInfo.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>
 
#include <boost/container/flat_map.hpp>
#include <functional>
 
namespace OpenMS
{
  class String;
 
  class OPENMS_DLLAPI MetaInfo
  {
public:
    MetaInfo() = default;
 
    MetaInfo(const MetaInfo&) = default;
 
    MetaInfo(MetaInfo&&) = default;
 
    ~MetaInfo();
 
    MetaInfo& operator=(const MetaInfo&) = default;
    MetaInfo& operator=(MetaInfo&&) & = default;
 
    bool operator==(const MetaInfo& rhs) const;
    bool operator!=(const MetaInfo& rhs) const;
 
    MetaInfo& operator+=(const MetaInfo& rhs)
    {
      // index_to_value_.insert(rhs.index_to_value_.begin(), rhs.index_to_value_.end()); // does not overwrite existing data
      for (const auto& kv : rhs.index_to_value_)
      {
        index_to_value_[kv.first] = kv.second;
      }
      return *this;
    }
 
    const DataValue& getValue(const String& name, const DataValue& default_value = DataValue::EMPTY) const;
    const DataValue& getValue(UInt index, const DataValue& default_value = DataValue::EMPTY) const;
 
    bool exists(const String& name) const;
    bool exists(UInt index) const;
 
    void setValue(const String& name, const DataValue& value);
    void setValue(UInt index, const DataValue& value);
 
    void removeValue(const String& name);
    void removeValue(UInt index);
 
    static MetaInfoRegistry& registry();
 
    void getKeys(std::vector<String>& keys) const;
 
    void getKeys(std::vector<UInt>& keys) const;
 
    bool empty() const;
 
    void clear();
 
private:
    using MapType = boost::container::flat_map<UInt, DataValue>;
 
    static MetaInfoRegistry registry_;
 
    MapType index_to_value_;
 
    // Grant access to hash implementation
    friend struct std::hash<MetaInfo>;
  };
 
} // namespace OpenMS
 
// Hash function specialization for MetaInfo
namespace std
{
  template<>
  struct hash<OpenMS::MetaInfo>
  {
    std::size_t operator()(const OpenMS::MetaInfo& mi) const noexcept
    {
      std::size_t seed = 0;
      // Hash each key-value pair in sorted order (flat_map is already sorted by key)
      for (const auto& [key, value] : mi.index_to_value_)
      {
        OpenMS::hash_combine(seed, OpenMS::hash_int(key));
        OpenMS::hash_combine(seed, std::hash<OpenMS::DataValue>{}(value));
      }
      return seed;
    }
  };
} // namespace std