Adduct.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: $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/OpenMSConfig.h>
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <OpenMS/DATASTRUCTURES/StringUtils.h>
 
#include <functional>
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI Adduct
  {
public:
 
    typedef std::vector<Adduct> AdductsType;
 
    Adduct();
 
    Adduct(Int charge);
 
    Adduct(Int charge, Int amount, double singleMass, const std::string& formula, double log_prob, double rt_shift, const std::string& label = "");
 
    Adduct operator*(const Int m) const;
 
    Adduct operator+(const Adduct& rhs);
 
    void operator+=(const Adduct& rhs);
 
 
    friend OPENMS_DLLAPI std::ostream& operator<<(std::ostream& os, const Adduct& a);
 
    friend OPENMS_DLLAPI bool operator==(const Adduct& a, const Adduct& b);
 
 
    const Int& getCharge() const;
 
    void setCharge(const Int& charge);
 
    const Int& getAmount() const;
 
    void setAmount(const Int& amount);
 
    const double& getSingleMass() const;
 
    void setSingleMass(const double& singleMass);
 
    const double& getLogProb() const;
 
    void setLogProb(const double& log_prob);
 
    const std::string& getFormula() const;
 
    void setFormula(const std::string& formula);
 
    const double& getRTShift() const;
 
    const std::string& getLabel() const;
 
    std::string toAdductString(const std::string& ion_string, const Int& charge);
 
    static std::string toAdductString(const std::string& ion_string, const Int& charge, Int mol_multiplier);
    //}
 
private:
    Int charge_;        
    Int amount_;        
    double singleMass_; 
    double log_prob_;   
    std::string formula_;    
    double rt_shift_;   
    std::string label_;      
 
    std::string checkFormula_(const std::string& formula);
 
  };
 
} // namespace OpenMS
 
// Hash function specialization for Adduct.
//
// Note: only the fields compared by operator== (charge, amount, singleMass,
// log_prob, formula) feed into the hash. rt_shift and label are deliberately
// excluded so two Adducts that compare equal also hash equal.
namespace std
{
  template<>
  struct hash<OpenMS::Adduct>
  {
    std::size_t operator()(const OpenMS::Adduct& a) const noexcept
    {
      std::size_t seed = OpenMS::hash_int(a.getCharge());
      OpenMS::hash_combine(seed, OpenMS::hash_int(a.getAmount()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(a.getSingleMass()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(a.getLogProb()));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(a.getFormula()));
      return seed;
    }
  };
} // namespace std