ListUtils.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: Stephan Aiche, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/StringUtils.h>
#include <OpenMS/DATASTRUCTURES/TypeAliases.h>
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/OpenMSConfig.h>
#include <OpenMS/config.h>
 
#include <cmath>
#include <iterator>
#include <vector>
#include <algorithm>
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI ListUtils
  {
private:
    struct DoubleTolerancePredicate_
    {
      DoubleTolerancePredicate_(const double& target, const double& tolerance) :
        tolerance_(tolerance),
        target_(target)
      {}
 
      inline bool operator()(const double& value) const
      {
        return std::fabs(value - target_) < tolerance_;
      }
 
private:
      double tolerance_;
      double target_;
    };
 
public:
    template <typename T>
    static std::vector<T> create(const std::string& str, const char splitter = ',')
    {
      // temporary storage for the individual elements of the string
      std::vector<std::string> temp_string_vec;
      StringUtils::split(str, splitter, temp_string_vec);
      return create<T>(temp_string_vec);
    }
 
    template <typename T>
    static std::vector<T> create(const std::vector<std::string>& s);
 
 
    template <typename T>
    static std::vector<std::string> toStringList(const std::vector<T>& s)
    {
      StringList out;
      out.reserve(s.size());
      for (const auto& elem : s) out.push_back(StringUtils::toStr(elem));
      return out;
    }
 
    template <typename T, typename E>
    static bool contains(const std::vector<T>& container, const E& elem)
    {
      return find(container.begin(), container.end(), elem) != container.end();
    }
 
    static bool contains(const std::vector<double>& container, const double& elem, double tolerance = 0.00001)
    {
      return find_if(container.begin(), container.end(), DoubleTolerancePredicate_(elem, tolerance)) != container.end();
    }
 
 
    enum class CASE { SENSITIVE, INSENSITIVE};
    static bool contains(const std::vector<std::string>& container, std::string elem, const CASE case_sensitive)
    {
      if (case_sensitive == CASE::SENSITIVE) return contains(container, elem);
      // case insensitive ...
      StringUtils::toLower(elem);
      return find_if(container.begin(), container.end(), [&elem](std::string ce) {
        return elem == StringUtils::toLower(ce);
      }) != container.end();
    }
 
    template <typename T>
    static std::string concatenate(const std::vector<T>& container, const std::string& glue = "")
    {
      return concatenate< std::vector<T> >(container, glue);
    }
 
    template <typename T>
    static std::string concatenate(const T& container, const std::string& glue = "")
    {
      // handle empty containers
      if (container.empty()) return "";
 
      typename T::const_iterator it = container.begin();
      std::string ret =StringUtils::toStr(*it);
      // we have handled the first element
      ++it;
      // add the rest
      for (; it != container.end(); ++it)
      {
        ret += (glue + StringUtils::toStr(*it));
      }
 
      return ret;
    }
 
    template <typename T, typename E>
    static Int getIndex(const std::vector<T>& container, const E& elem)
    {
      typename std::vector<T>::const_iterator pos =
        std::find(container.begin(), container.end(), elem);
      if (pos == container.end()) return -1;
 
      return static_cast<Int>(std::distance(container.begin(), pos));
    }
 
  };
 
  namespace detail
  {
    template <typename T>
    T convert(const std::string& s);
  
    template<>
    inline Int32 convert(const std::string& s)
    {
      return StringUtils::toInt32(s);
    }
    template<>
    inline double convert(const std::string& s)
    {
      return StringUtils::toDouble(s);
    }
    template<>
    inline float convert(const std::string& s)
    {
      return StringUtils::toFloat(s);
    }
    template<>
    inline std::string convert(const std::string& s)
    {
        return static_cast<std::string>(s);
    }
  }
 
  template <typename T>
  inline std::vector<T> ListUtils::create(const std::vector<std::string>& s)
  {
    std::vector<T> c;
    c.reserve(s.size());
    for (std::vector<std::string>::const_iterator it = s.begin(); it != s.end(); ++it)
    {
      try
      {
        c.push_back(detail::convert<T>(StringUtils::trimmed(*it))); // succeeds only if the whole output can be explained, i.e. "1.3 3" will fail (which is good)
      }
      catch (...)
      {
        throw Exception::ConversionError(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,std::string("Could not convert string '") + *it + "'");
      }
    }
 
    return c;
  }
 
  template <>
  inline std::vector<std::string> ListUtils::create(const std::vector<std::string>& s)
  {
    return s;
  }
 
} // namespace OpenMS