ControlledVocabulary.h

Go to the documentation of this file.

// Copyright (c) 2002-2023, The OpenMS Team -- 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/ListUtils.h> // StringList
#include <OpenMS/DATASTRUCTURES/StringListUtils.h>
#include <OpenMS/CONCEPT/Exception.h>
 
#include <set>
#include <map>
 
namespace OpenMS
{
  class OPENMS_DLLAPI ControlledVocabulary
  {
    friend OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const ControlledVocabulary& cv);
 
public:
    struct OPENMS_DLLAPI CVTerm
    {
      enum 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 String getXRefTypeName(XRefType type);
      //static bool isSearchEngineSpecificScore();
      static bool isHigherBetterScore(ControlledVocabulary::CVTerm term); 
 
      String name; 
      String id; 
      std::set<String> parents; 
      std::set<String> children; 
      bool obsolete; 
      String description; 
      StringList synonyms; 
      StringList unparsed; 
      XRefType xref_type; 
      StringList xref_binary; 
      std::set<String> units; 
 
      CVTerm();
 
      CVTerm(const CVTerm& rhs);
 
      CVTerm& operator=(const CVTerm& rhs);
 
      String toXMLString(const String& ref, const String& value = String("")) const;
 
      String toXMLString(const String& ref, const DataValue& value) const;
 
    };
 
    ControlledVocabulary();
 
    virtual ~ControlledVocabulary();
 
    const String& name() const;
 
    const String& label() const;
 
    const String& version() const;
 
    const String& url() const;
 
    void loadFromOBO(const String& name, const String& filename);
 
    bool exists(const String& id) const;
 
    bool hasTermWithName(const String& name) const;
 
    const CVTerm& getTerm(const String& id) const;
 
    const CVTerm& getTermByName(const String& name, const String& desc = "") const;
 
 
    const std::map<String, CVTerm>& getTerms() const;
 
    void getAllChildTerms(std::set<String>& terms, const String& parent_id) const;
 
    template <class LAMBDA>
    bool iterateAllChildren(const 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 OpenMS::String& name) const;
 
    bool isChildOf(const String& child_id, const String& parent_id) const;
 
 
    static const ControlledVocabulary& getPSIMSCV();
 
protected:
    bool checkName_(const String& id, const String& name, bool ignore_case = true) const;
 
    std::map<String, CVTerm> terms_;
    std::map<String, String> namesToIds_;
    String name_;
    String label_;
    String version_;
    String url_;
  };
 
  OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const ControlledVocabulary& cv);
 
 
} // namespace OpenMS