git.sesse.net Git - casparcg/blob - common/param.h

   1 #pragma once
   2
   3 #include "except.h"
   4
   5 #include <boost/lexical_cast.hpp>
   6 #include <boost/algorithm/string.hpp>
   7
   8 #include <type_traits>
   9 #include <string>
  10
  11 namespace caspar {
  12
  13 class param_comparer
  14 {
  15         const std::wstring& lhs;
  16 public:
  17         explicit param_comparer(const std::wstring& p) : lhs(p) {}
  18         bool operator()(const std::wstring& rhs) { return boost::iequals(lhs, rhs); }
  19 };
  20
  21 template<typename C>
  22 bool contains_param(const std::wstring& name, C&& params)
  23 {
  24         return std::find_if(params.begin(), params.end(), param_comparer(name)) != params.end();
  25 }
  26
  27 template<typename C>
  28 bool get_and_consume_flag(const std::wstring& flag_param, C& params)
  29 {
  30         auto flag_it = std::find_if(params.begin(), params.end(), param_comparer(flag_param));
  31         bool flag = false;
  32
  33         if (flag_it != params.end())
  34         {
  35                 flag = true;
  36                 params.erase(flag_it);
  37         }
  38
  39         return flag;
  40 }
  41
  42 template<typename C>
  43 void replace_placeholders(const std::wstring& placeholder, const std::wstring& replacement, C&& params)
  44 {
  45         for (auto& param : params)
  46                 boost::ireplace_all(param, placeholder, replacement);
  47 }
  48
  49 static std::vector<std::wstring> protocol_split(const std::wstring& s)
  50 {
  51         std::vector<std::wstring> result;
  52         size_t pos;
  53
  54         if ((pos = s.find(L"://")) != std::wstring::npos)
  55         {
  56                 result.push_back(s.substr(0, pos));
  57                 result.push_back(s.substr(pos + 3));
  58         }
  59         else
  60         {
  61                 result.push_back(L"");
  62                 result.push_back(s);
  63         }
  64
  65         return result;
  66 }
  67
  68 template<typename T, typename C>
  69 typename std::enable_if<!std::is_convertible<T, std::wstring>::value, typename std::decay<T>::type>::type get_param(const std::wstring& name, C&& params, T fail_value = T())
  70 {
  71         auto it = std::find_if(std::begin(params), std::end(params), param_comparer(name));
  72         if(it == params.end())
  73                 return fail_value;
  74
  75         try
  76         {
  77                 if(++it == params.end())
  78                         throw std::out_of_range("");
  79
  80                 return boost::lexical_cast<typename std::decay<T>::type>(*it);
  81         }
  82         catch(...)
  83         {
  84                 CASPAR_THROW_EXCEPTION(user_error() << msg_info(L"Failed to parse param " + name) << nested_exception(std::current_exception()));
  85         }
  86 }
  87
  88 template<typename C>
  89 std::wstring get_param(const std::wstring& name, C&& params, const std::wstring& fail_value = L"")
  90 {
  91         auto it = std::find_if(std::begin(params), std::end(params), param_comparer(name));
  92         if(it == params.end())
  93                 return fail_value;
  94
  95         try
  96         {
  97                 if(++it == params.end())
  98                         throw std::out_of_range("");
  99
 100                 return *it;
 101         }
 102         catch(...)
 103         {
 104                 CASPAR_THROW_EXCEPTION(user_error() << msg_info(L"Failed to parse param " + name) << nested_exception(std::current_exception()));
 105         }
 106 }
 107
 108 }