src/raw_convert.cc

   1 /*
   2     Copyright (C) 2014-2016 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34 #include "raw_convert.h"
  35 #include "locale_convert.h"
  36 #include <boost/algorithm/string.hpp>
  37
  38 using std::string;
  39 using std::wstring;
  40
  41 static
  42 string
  43 make_raw (string v)
  44 {
  45         struct lconv* lc = localeconv ();
  46         boost::algorithm::replace_all (v, lc->decimal_point, ".");
  47         boost::algorithm::replace_all (v, lc->thousands_sep, "");
  48         return v;
  49 }
  50
  51 static
  52 string
  53 make_local (string v)
  54 {
  55         struct lconv* lc = localeconv ();
  56         boost::algorithm::replace_all (v, ".", lc->decimal_point);
  57         /* We hope it's ok not to add in thousands separators here */
  58         return v;
  59 }
  60
  61 template <>
  62 string
  63 dcp::raw_convert (int v, int precision, bool fixed)
  64 {
  65         return make_raw (locale_convert<string> (v, precision, fixed));
  66 }
  67
  68 template <>
  69 string
  70 dcp::raw_convert (unsigned int v, int precision, bool fixed)
  71 {
  72         return make_raw (locale_convert<string> (v, precision, fixed));
  73 }
  74
  75 template <>
  76 string
  77 dcp::raw_convert (long v, int precision, bool fixed)
  78 {
  79         return make_raw (locale_convert<string> (v, precision, fixed));
  80 }
  81
  82 template <>
  83 string
  84 dcp::raw_convert (unsigned long v, int precision, bool fixed)
  85 {
  86         return make_raw (locale_convert<string> (v, precision, fixed));
  87 }
  88
  89 template <>
  90 string
  91 dcp::raw_convert (long long v, int precision, bool fixed)
  92 {
  93         return make_raw (locale_convert<string> (v, precision, fixed));
  94 }
  95
  96 template <>
  97 string
  98 dcp::raw_convert (unsigned long long v, int precision, bool fixed)
  99 {
 100         return make_raw (locale_convert<string> (v, precision, fixed));
 101 }
 102
 103 template <>
 104 string
 105 dcp::raw_convert (float v, int precision, bool fixed)
 106 {
 107         return make_raw (locale_convert<string> (v, precision, fixed));
 108 }
 109
 110 template <>
 111 string
 112 dcp::raw_convert (double v, int precision, bool fixed)
 113 {
 114         return make_raw (locale_convert<string> (v, precision, fixed));
 115 }
 116
 117 template <>
 118 string
 119 dcp::raw_convert (char const * v, int, bool)
 120 {
 121         return v;
 122 }
 123
 124 template <>
 125 string
 126 dcp::raw_convert (char* v, int, bool)
 127 {
 128         return v;
 129 }
 130
 131 template <>
 132 string
 133 dcp::raw_convert (string v, int, bool)
 134 {
 135         return v;
 136 }
 137
 138 template <>
 139 string
 140 dcp::raw_convert (char v, int, bool)
 141 {
 142         string s;
 143         s += v;
 144         return s;
 145 }
 146
 147 template <>
 148 string
 149 dcp::raw_convert (wchar_t const * v, int, bool)
 150 {
 151         wstring w (v);
 152         return string (w.begin(), w.end());
 153 }
 154
 155 template <>
 156 int
 157 dcp::raw_convert (string v, int precision, bool fixed)
 158 {
 159         return locale_convert<int> (make_local (v), precision, fixed);
 160 }
 161
 162 template <>
 163 long
 164 dcp::raw_convert (string v, int precision, bool fixed)
 165 {
 166         return locale_convert<long> (make_local (v), precision, fixed);
 167 }
 168
 169 template <>
 170 int
 171 dcp::raw_convert (char const * v, int precision, bool fixed)
 172 {
 173         return locale_convert<int> (make_local (v), precision, fixed);
 174 }
 175
 176 template <>
 177 float
 178 dcp::raw_convert (string v, int precision, bool fixed)
 179 {
 180         return locale_convert<float> (make_local (v), precision, fixed);
 181 }
 182
 183 template <>
 184 float
 185 dcp::raw_convert (char const * v, int precision, bool fixed)
 186 {
 187         return locale_convert<float> (make_local (v), precision, fixed);
 188 }
 189
 190 template <>
 191 double
 192 dcp::raw_convert (string v, int precision, bool fixed)
 193 {
 194         return locale_convert<double> (make_local (v), precision, fixed);
 195 }
 196
 197 template <>
 198 double
 199 dcp::raw_convert (char const * v, int precision, bool fixed)
 200 {
 201         return locale_convert<double> (make_local (v), precision, fixed);
 202 }