ControlledVocabulary.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, Andreas Bertsch, Mathias Walzer $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/TypeAliases.h> // StringList
#include <OpenMS/DATASTRUCTURES/StringListUtils.h>
#include <OpenMS/CONCEPT/Exception.h>
 
#include <set>
#include <map>
#include <string_view>
#include <unordered_map>
 
namespace OpenMS
{
  class OPENMS_DLLAPI ControlledVocabulary
  {
    friend OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const ControlledVocabulary& cv);
 
public:
    struct FNV1aHasher
    {
      size_t operator()(const std::string& key) const noexcept
      {
        size_t hash = 14695981039346656037ull;
        for (auto c : key)
        {
          hash ^= static_cast<unsigned char>(c);
          hash *= 1099511628211ull;
        }
        return hash;
      }
    };
 
    struct OPENMS_DLLAPI CVTerm
    {
      enum class XRefType
      {
        XSD_STRING = 0, // xsd:string A string
        XSD_INTEGER, // xsd:integer Any integer
        XSD_DECIMAL, // xsd:decimal Any real number
        XSD_NEGATIVE_INTEGER, // xsd:negativeInteger Any negative integer
        XSD_POSITIVE_INTEGER, // xsd:positiveInteger Any integer > 0
        XSD_NON_NEGATIVE_INTEGER, // xsd:nonNegativeInteger Any integer >= 0
        XSD_NON_POSITIVE_INTEGER, // xsd:nonPositiveInteger Any integer < 0
        XSD_BOOLEAN, // xsd:boolean True or false
        XSD_DATE, // xsd:date An XML-Schema date
        XSD_ANYURI, // xsd:anyURI uniform resource identifier
        NONE
      };
 
      static std::string getXRefTypeName(XRefType type);
      //static bool isSearchEngineSpecificScore();
      static bool isHigherBetterScore(ControlledVocabulary::CVTerm term); 
 
      std::string name; 
      std::string id; 
      std::set<std::string> parents; 
      std::set<std::string> children; 
      bool obsolete; 
      std::string description; 
      StringList synonyms; 
      StringList unparsed; 
      XRefType xref_type; 
      StringList xref_binary; 
      std::set<std::string> units; 
 
      CVTerm();
 
      CVTerm(const CVTerm& rhs);
 
      CVTerm& operator=(const CVTerm& rhs);
 
      std::string toXMLString(const std::string& ref, const std::string& value =std::string("")) const;
 
      std::string toXMLString(const std::string& ref, const DataValue& value) const;
 
    };
 
    ControlledVocabulary();
 
    ControlledVocabulary(const ControlledVocabulary& rhs);
 
    ControlledVocabulary(ControlledVocabulary&& rhs) noexcept;
 
    ControlledVocabulary& operator=(const ControlledVocabulary& rhs);
 
    ControlledVocabulary& operator=(ControlledVocabulary&& rhs) noexcept;
 
    virtual ~ControlledVocabulary();
 
    const std::string& name() const;
 
    const std::string& label() const;
 
    const std::string& version() const;
 
    const std::string& url() const;
 
    void loadFromOBO(const std::string& name, const std::string& filename);
 
    bool exists(const std::string& id) const;
 
    bool hasTermWithName(const std::string& name) const;
 
    const CVTerm& getTerm(const std::string& id) const;
 
    const CVTerm& getTermByName(const std::string& name, const std::string& desc = "") const;
 
 
    const std::map<std::string, CVTerm>& getTerms() const;
 
    void getAllChildTerms(std::set<std::string>& terms, const std::string& parent_id) const;
 
    void addAllChildTerms(std::set<std::string>& terms, const std::string& parent_id) const;
 
    template <class LAMBDA>
    bool iterateAllChildren(const std::string& parent_id, LAMBDA lbd) const
    {
      for (const auto& child_id : getTerm(parent_id).children)
      {
        if (lbd(child_id) || iterateAllChildren(child_id, lbd))
          return true;
      }
      return false;
    }
 
    const ControlledVocabulary::CVTerm* checkAndGetTermByName(const std::string& name) const;
 
    bool isChildOf(const std::string& child_id, const std::string& parent_id) const;
 
 
    static const ControlledVocabulary& getPSIMSCV();
 
protected:
    bool checkName_(const std::string& id, const std::string& name, bool ignore_case = true) const;
 
    const CVTerm* findTerm_(std::string_view id) const;
 
    void rebuildIndex_();
 
    // note: an unordered_map would iterate in a platform-dependent order; index_ provides the fast lookups
    std::map<std::string, CVTerm> terms_;
    std::unordered_map<std::string_view, const CVTerm*> index_;
    std::map<std::string, std::string> namesToIds_;
    std::string name_;
    std::string label_;
    std::string version_;
    std::string url_;
  };
 
  OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const ControlledVocabulary& cv);
 
 
} // namespace OpenMS