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 <utility>
#include <vector>
#include <functional>
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI MetaInfo
  {
public:
    using MapType = std::vector<std::pair<UInt, DataValue>>;
    using iterator = MapType::iterator;
    using const_iterator = MapType::const_iterator;
 
    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);
 
    const DataValue& getValue(const std::string& name, const DataValue& default_value = DataValue::EMPTY) const;
    const DataValue& getValue(UInt index, const DataValue& default_value = DataValue::EMPTY) const;
 
    bool exists(const std::string& name) const;
    bool exists(UInt index) const;
 
    void setValue(const std::string& name, const DataValue& value);
    void setValue(UInt index, const DataValue& value);
 
    void removeValue(const std::string& name);
    void removeValue(UInt index);
 
    static MetaInfoRegistry& registry();
 
    void getKeys(std::vector<std::string>& keys) const;
 
    void getKeys(std::vector<UInt>& keys) const;
 
    bool empty() const;
 
    void clear();
 
 
    const_iterator begin() const { return index_to_value_.begin(); }
 
    const_iterator end() const { return index_to_value_.end(); }
 
    const_iterator cbegin() const { return index_to_value_.cbegin(); }
 
    const_iterator cend() const { return index_to_value_.cend(); }
 
    iterator begin() { return index_to_value_.begin(); }
 
    iterator end() { return index_to_value_.end(); }
 
    Size size() const { return index_to_value_.size(); }
 
private:
    iterator find_(UInt index);
    const_iterator find_(UInt index) const;
 
 
    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