StringConversions.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg, Chris Bielow $
// $Authors: Marc Sturm, Stephan Aiche, Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/DATASTRUCTURES/DataValue.h>
#include <OpenMS/CONCEPT/PrecisionWrapper.h>
 
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/type_traits.hpp>
 
#include <string>
#include <vector>
 
 
namespace OpenMS
{
  class String;
 
  namespace StringConversions
  {
 
    // Karma full precision float policy
    template <typename T> 
    class BK_PrecPolicy : public boost::spirit::karma::real_policies<T>
    {
        typedef boost::spirit::karma::real_policies<T> base_policy_type;
    public:
        static unsigned precision(T /*n*/) 
        {
            /* The following would be the only way for a lossless double-string-double
            * roundtrip but:
            * a) We only care about speed
            * b) Many tests have to be changed
            * c) In the end boost::karma is bugged and hard limits the fractional digits
            *    even though you have leading zeros (basically forcing scientific notation)
            *    for full precision https://github.com/boostorg/spirit/issues/585
            if (BK_PrecPolicy::floatfield(n))
            {
                T abs_n = boost::spirit::traits::get_absolute_value(n);
                if (abs_n >= 1)
                {
                    return std::numeric_limits<T>::max_digits10 - (floor(log10(abs_n)) + 1);
                }
                else
                {
                    return std::numeric_limits<T>::max_digits10 - (floor(log10(abs_n)));
                }  
            }
            else
            {
                return std::numeric_limits<T>::max_digits10 - 1;
            }
            */
            return writtenDigits<T>();
        }
        
        //  we want the numbers always to be in scientific format
        static unsigned floatfield(T n)
        {
            if (boost::spirit::traits::test_zero(n))
                return base_policy_type::fmtflags::fixed;
 
            T abs_n = boost::spirit::traits::get_absolute_value(n);
            // this is due to a bug in downstream thirdparty tools that only can read
            // up to 19 digits. https://github.com/OpenMS/OpenMS/issues/4627
            return (abs_n >= 1e4 || abs_n < 1e-2) 
                ? base_policy_type::fmtflags::scientific : base_policy_type::fmtflags::fixed;
        }
    };
    typedef boost::spirit::karma::real_generator<float, BK_PrecPolicy<float> > BK_PrecPolicyFloat_type;
    const BK_PrecPolicyFloat_type BK_PrecPolicyFloat;
    typedef boost::spirit::karma::real_generator<double, BK_PrecPolicy<double> > BK_PrecPolicyDouble_type;
    const BK_PrecPolicyDouble_type BK_PrecPolicyDouble;
    typedef boost::spirit::karma::real_generator<long double, BK_PrecPolicy<long double> > BK_PrecPolicyLongDouble_type;
    const BK_PrecPolicyLongDouble_type BK_PrecPolicyLongDouble;
    
    // toString functions (single argument)
 
    template <typename T>
    inline void append(const T& i, String& target)
    {
      std::back_insert_iterator<std::string> sink(target);
      boost::spirit::karma::generate(sink, i);
    }
 
    template <typename T>
    inline String toString(const T& i)
    {
      //std::stringstream s;
      //s << i;
      //return s.str();
      String str;
      append(i, str);
      return str;
    }
    
 
    inline void appendLowP(float f, String& target)
    {
      std::back_insert_iterator<std::string> sink(target);
      boost::spirit::karma::generate(sink, f);
    }
    inline String toStringLowP(float f)
    {
      String str;
      appendLowP(f, str);
      return str;
    }
 
 
    inline void appendLowP(double d, String& target)
    {
      std::back_insert_iterator<std::string> sink(target);
      boost::spirit::karma::generate(sink, d);
    }
    inline String toStringLowP(double d)
    {
      String str;
      appendLowP(d, str);
      return str;
    }
 
 
    inline void appendLowP(long double ld, String& target)
    {
      std::back_insert_iterator<std::string> sink(target);
      boost::spirit::karma::generate(sink, ld);
    }
    inline String toStringLowP(long double ld)
    {
      String str;
      appendLowP(ld, str);
      return str;
    }
 
 
 
    inline void append(float f, String& target)
    {
      std::back_insert_iterator<std::string> sink(target);
      boost::spirit::karma::generate(sink, BK_PrecPolicyFloat, f);
    }
    inline String toString(float f)
    {
      String str;
      append(f, str);
      return str;
    }
 
 
 
    inline void append(double d, String& target)
    {
      std::back_insert_iterator<std::string> sink(target);
      boost::spirit::karma::generate(sink, BK_PrecPolicyDouble, d);
    }
    inline String toString(double d)
    {
      String str;
      append(d, str);
      return str;
    }
 
 
    inline void append(long double ld, String& target)
    {
      std::back_insert_iterator<std::string> sink(target);
      boost::spirit::karma::generate(sink, BK_PrecPolicyLongDouble, ld);
    }
    inline String toString(long double ld)
    {
      String str;
      append(ld, str);
      return str;
    }
 
    
    inline void append(const DataValue& d, bool full_precision, String& target)
    {
      target += d.toString(full_precision);
    }
    inline String toString(const DataValue& d, bool full_precision)
    {
      return d.toString(full_precision);
    }
 
 
 
    inline String toString(const char c)
    {
      return std::string(1, c);
    }
 
    inline String toString(const std::string& s)
    {
      return s;
    }
 
    inline String toString(const char* s)
    {
      return std::string(s);
    }
 
    inline String toString()
    {
      return String();
    }
 
  }
 
} // namespace OPENMS