IonSource.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 <OpenMS/METADATA/MetaInfoInterface.h>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
#include <OpenMS/CONCEPT/HashUtils.h>
 
#include <functional>
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI IonSource :
    public MetaInfoInterface
  {
public:
    enum class InletType
    {
      INLETNULL,                           
      DIRECT,                              
      BATCH,                               
      CHROMATOGRAPHY,                      
      PARTICLEBEAM,                        
      MEMBRANESEPARATOR,                   
      OPENSPLIT,                           
      JETSEPARATOR,                        
      SEPTUM,                              
      RESERVOIR,                           
      MOVINGBELT,                          
      MOVINGWIRE,                          
      FLOWINJECTIONANALYSIS,               
      ELECTROSPRAYINLET,                   
      THERMOSPRAYINLET,                    
      INFUSION,                            
      CONTINUOUSFLOWFASTATOMBOMBARDMENT,   
      INDUCTIVELYCOUPLEDPLASMA,            
      MEMBRANE,                            
      NANOSPRAY,                           
      SIZE_OF_INLETTYPE
    };
    static const std::string NamesOfInletType[static_cast<size_t>(InletType::SIZE_OF_INLETTYPE)];
 
    enum class IonizationMethod
    {
      IONMETHODNULL,           
      ESI,                     
      EI,                      
      CI,                      
      FAB,                     
      TSP,                     
      LD,                      
      FD,                      
      FI,                      
      PD,                      
      SI,                      
      TI,                      
      API,                     
      ISI,                     
      CID,                     
      CAD,                     
      HN,                      
      APCI,                    
      APPI,                    
      ICP,                     
      NESI,                    
      MESI,                    
      SELDI,                   
      SEND,                    
      FIB,                     
      MALDI,                   
      MPI,                     
      DI,                      
      FA,                      
      FII,                     
      GD_MS,                   
      NICI,                    
      NRMS,                    
      PI,                      
      PYMS,                    
      REMPI,                   
      AI,                      
      ASI,                     
      AD,                      
      AUI,                     
      CEI,                     
      CHEMI,                   
      DISSI,                   
      LSI,                     
      PEI,                     
      SOI,                     
      SPI,                     
      SUI,                     
      VI,                      
      AP_MALDI,                
      SILI,                    
      SALDI,                   
      SIZE_OF_IONIZATIONMETHOD
    };
    static const std::string NamesOfIonizationMethod[static_cast<size_t>(IonizationMethod::SIZE_OF_IONIZATIONMETHOD)];
 
    enum class Polarity
    {
      POLNULL,          
      POSITIVE,         
      NEGATIVE,         
      SIZE_OF_POLARITY
    };
    static const std::string NamesOfPolarity[static_cast<size_t>(Polarity::SIZE_OF_POLARITY)];
 
    static StringList getAllNamesOfInletType();
    static StringList getAllNamesOfIonizationMethod();
    static StringList getAllNamesOfPolarity();
 
    static const std::string& inletTypeToString(InletType type);
 
    static InletType toInletType(const std::string& name);
 
    static const std::string& ionizationMethodToString(IonizationMethod method);
 
    static IonizationMethod toIonizationMethod(const std::string& name);
 
    static const std::string& polarityToString(Polarity polarity);
 
    static Polarity toPolarity(const std::string& name);
 
    IonSource();
    IonSource(const IonSource &) = default;
    IonSource(IonSource&&) = default;
    ~IonSource();
 
    IonSource & operator=(const IonSource &) = default;
    IonSource& operator=(IonSource&&) & = default;
 
    bool operator==(const IonSource & rhs) const;
    bool operator!=(const IonSource & rhs) const;
 
    InletType getInletType() const;
    void setInletType(InletType inlet_type);
 
    IonizationMethod getIonizationMethod() const;
    void setIonizationMethod(IonizationMethod ionization_type);
 
    Polarity getPolarity() const;
    void setPolarity(Polarity polarity);
 
    Int getOrder() const;
    void setOrder(Int order);
 
protected:
    InletType inlet_type_;
    IonizationMethod ionization_method_;
    Polarity polarity_;
    Int order_;
 
  };
 
} // namespace OpenMS
 
// Hash function specialization for IonSource
namespace std
{
  template<>
  struct hash<OpenMS::IonSource>
  {
    std::size_t operator()(const OpenMS::IonSource& is) const noexcept
    {
      // Hash all fields used in operator==: order_, inlet_type_, ionization_method_, polarity_, and MetaInfoInterface
      std::size_t seed = OpenMS::hash_int(is.getOrder());
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(is.getInletType())));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(is.getIonizationMethod())));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(is.getPolarity())));
 
      // Hash MetaInfoInterface base class (handles both UInt and String keys)
      OpenMS::hash_combine(seed, std::hash<OpenMS::MetaInfoInterface>{}(is));
 
      return seed;
    }
  };
}