SafeConvert.hpp

/*
 * SafeConvert.hpp
 *
 * Copyright (C) 2022 by RStudio, PBC
 *
 * Unless you have received this program directly from RStudio pursuant to the terms of a commercial license agreement
 * with RStudio, then this program is licensed to you under the following terms:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifndef LAUNCHER_PLUGINS_SAFE_CONVERT_HPP
#define LAUNCHER_PLUGINS_SAFE_CONVERT_HPP
 
#include <string>
#include <ios>
#include <iostream>
#include <locale>
 
#include <boost/lexical_cast.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <Optional.hpp>
 
#include <Error.hpp>
 
namespace rstudio {
namespace launcher_plugins {
namespace safe_convert {
 
template <typename T>
T stringTo(const std::string& in_strValue, T in_defaultValue)
{
   try
   {
      return boost::lexical_cast<T>(in_strValue);
   }
   catch(boost::bad_lexical_cast&)
   {
      return in_defaultValue;
   }
}
 
template <typename T>
Optional<T> stringTo(const std::string& str)
{
   Optional<T> result;
 
   try
   {
      result = boost::lexical_cast<T>(str);
   }
   catch(boost::bad_lexical_cast&)
   {
   }
 
   return result;
}
 
template <typename T>
T stringTo(const std::string& in_strValue,
           T in_defaultValue,
           std::ios_base& (*in_f)(std::ios_base&))
{
   std::istringstream iss(in_strValue);
   T result;
   if ((iss >> in_f >> result).fail())
      return in_defaultValue;
   return result;
}
 
inline std::string numberToString(double in_input, bool in_localeIndependent = true)
{
   try
   {
      std::ostringstream stream;
      if (in_localeIndependent)
         stream.imbue(std::locale::classic()); // force locale-independence
      stream << std::fixed;
      stream << in_input;
      return stream.str();
   }
   CATCH_UNEXPECTED_EXCEPTION
 
   // return empty string for unexpected error
   return std::string();
}
 
template <typename T>
std::string numberToString(T input, bool localeIndependent = true)
{
   try
   {
      std::ostringstream stream;
      if (localeIndependent)
         stream.imbue(std::locale::classic()); // force locale-independence
 
      stream << input;
      return stream.str();
   }
   CATCH_UNEXPECTED_EXCEPTION
 
   // return empty string for unexpected error
   return std::string();
}
 
template <typename TInput, typename TOutput>
TOutput numberTo(TInput input, TOutput defaultValue)
{
   try
   {
      return boost::numeric_cast<TOutput>(input);
   }
   catch(...)
   {
      return defaultValue;
   }
}
 
template <typename TInput, typename TOutput>
Optional<TOutput> numberTo(TInput input)
{
   Optional<TOutput> result;
 
   try
   {
      result = boost::numeric_cast<TOutput>(input);
   }
   catch(...)
   {
   }
 
   return result;
}
 
} // namespace safe_convert
} // namespace launcher_plugins 
} // namespace rstudio
 
#endif // LAUNCHER_PLUGINS_SAFE_CONVERT_HPP