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/METADATA/MetaInfo.h>
#include <OpenMS/DATASTRUCTURES/DataValue.h>
 
namespace OpenMS
{
  class String;
 
  class OPENMS_DLLAPI MetaInfoInterface
  {
public:
    using MetaInfoConstIterator = MetaInfo::const_iterator;
 
    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();
 
 
    MetaInfoConstIterator metaBegin() const;
 
    MetaInfoConstIterator metaEnd() const;
 
    Size metaSize() const;
 
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
    {
      std::size_t hash = 0;
      // Iterate directly over the underlying flat_map entries
      for (auto it = meta.metaBegin(); it != meta.metaEnd(); ++it)
      {
        std::size_t pair_hash = OpenMS::hash_int(static_cast<int64_t>(it->first));
        OpenMS::hash_combine(pair_hash, std::hash<OpenMS::DataValue>{}(it->second));
        hash += pair_hash;  // Order-independent accumulation
      }
      return hash;
    }
  };
} // namespace std