Compomer.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: Chris Bielow $
// $Authors: Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/HashUtils.h>
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/Adduct.h>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
#include <OpenMS/OpenMSConfig.h>
 
#include <functional>
#include <map>
#include <vector>
 
namespace OpenMS
{
 
 
  class OPENMS_DLLAPI Compomer
  {
public:
    enum SIDE {LEFT, RIGHT, BOTH};
 
    typedef std::map<std::string, Adduct> CompomerSide;
    
    typedef std::vector<CompomerSide> CompomerComponents;
 
    Compomer();
 
    Compomer(Int net_charge, double mass, double log_p);
 
    Compomer(const Compomer& p);
 
    Compomer& operator=(const Compomer& source);
 
    void add(const Adduct& a, UInt side);
 
    bool isConflicting(const Compomer& cmp, UInt side_this, UInt side_other) const;
 
    void setID(const Size& id);
    
    const Size& getID() const;
    
    const CompomerComponents& getComponent() const;
 
    const Int& getNetCharge() const;
 
    const double& getMass() const;
 
    const Int& getPositiveCharges() const;
 
    const Int& getNegativeCharges() const;
 
    const double& getLogP() const;
 
    const double& getRTShift() const;
 
    std::string getAdductsAsString() const;
 
    std::string getAdductsAsString(UInt side) const;
 
    bool isSingleAdduct(Adduct& a, const UInt side) const;
 
    Compomer removeAdduct(const Adduct& a) const;
 
    Compomer removeAdduct(const Adduct& a, const UInt side) const;
 
    StringList getLabels(const UInt side) const;
 
    double getSideMass(const UInt side) const;
 
    void add(const CompomerSide& add_side, UInt side);
 
    friend OPENMS_DLLAPI bool operator<(const Compomer& c1, const Compomer& c2);
 
    friend OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const Compomer& cmp);
 
    friend OPENMS_DLLAPI bool operator==(const Compomer& a, const  Compomer& b);
 
private:
 
    CompomerComponents cmp_;   
    Int net_charge_;           
    double mass_;              
    Int pos_charges_;          
    Int neg_charges_;          
    double log_p_;             
    double rt_shift_;          
    Size id_;                  
 
  }; // \Compomer
 
} // namespace OpenMS
 
// Hash function specialization for Compomer
// Note: Only hash fields used in operator== (cmp_, net_charge_, mass_, pos_charges_, neg_charges_, log_p_, id_)
// Do NOT hash rt_shift_ as it is not compared in operator==
namespace std
{
  template<>
  struct hash<OpenMS::Compomer>
  {
    std::size_t operator()(const OpenMS::Compomer& c) const noexcept
    {
      std::size_t seed = OpenMS::hash_int(c.getNetCharge());
      OpenMS::hash_combine(seed, OpenMS::hash_float(c.getMass()));
      OpenMS::hash_combine(seed, OpenMS::hash_int(c.getPositiveCharges()));
      OpenMS::hash_combine(seed, OpenMS::hash_int(c.getNegativeCharges()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(c.getLogP()));
      OpenMS::hash_combine(seed, OpenMS::hash_int(c.getID()));
 
      // Hash the compomer components (vector<map<std::string, Adduct>>)
      const auto& components = c.getComponent();
      OpenMS::hash_combine(seed, OpenMS::hash_int(components.size()));
      for (const auto& side : components)
      {
        OpenMS::hash_combine(seed, OpenMS::hash_int(side.size()));
        for (const auto& [key, adduct] : side)
        {
          OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(key));
          OpenMS::hash_combine(seed, std::hash<OpenMS::Adduct>{}(adduct));
        }
      }
      return seed;
    }
  };
} // namespace std