ppapi/cpp/extensions/from_var_converter.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef PPAPI_CPP_EXTENSIONS_FROM_VAR_CONVERTOR_H_
   6 #define PPAPI_CPP_EXTENSIONS_FROM_VAR_CONVERTOR_H_
   7
   8 #include <string>
   9
  10 #include "ppapi/c/pp_var.h"
  11 #include "ppapi/cpp/extensions/optional.h"
  12 #include "ppapi/cpp/logging.h"
  13 #include "ppapi/cpp/var.h"
  14 #include "ppapi/cpp/var_array.h"
  15 #include "ppapi/cpp/var_array_buffer.h"
  16 #include "ppapi/cpp/var_dictionary.h"
  17
  18 namespace pp {
  19 namespace ext {
  20 namespace internal {
  21
  22 template <class T>
  23 class FromVarConverterBase {
  24  public:
  25   T& value() { return value_; }
  26
  27  protected:
  28   FromVarConverterBase() : value_() {
  29   }
  30
  31   explicit FromVarConverterBase(const T& value) : value_(value) {
  32   }
  33
  34   ~FromVarConverterBase() {
  35   }
  36
  37   T value_;
  38 };
  39
  40 template <class T>
  41 class FromVarConverter : public FromVarConverterBase<T> {
  42  public:
  43   FromVarConverter() {
  44   }
  45
  46   explicit FromVarConverter(const PP_Var& var) {
  47     Set(var);
  48   }
  49
  50   ~FromVarConverter() {
  51   }
  52
  53   void Set(const PP_Var& var) {
  54     bool succeeded = FromVarConverterBase<T>::value_.Populate(var);
  55     // Suppress unused variable warnings.
  56     static_cast<void>(succeeded);
  57     PP_DCHECK(succeeded);
  58   }
  59 };
  60
  61 template <class T>
  62 class FromVarConverter<Optional<T> >
  63     : public FromVarConverterBase<Optional<T> > {
  64  public:
  65   FromVarConverter() {
  66   }
  67
  68   explicit FromVarConverter(const PP_Var& var) {
  69     Set(var);
  70   }
  71
  72   ~FromVarConverter() {
  73   }
  74
  75   void Set(const PP_Var& var) {
  76     if (var.type == PP_VARTYPE_UNDEFINED) {
  77       FromVarConverterBase<Optional<T> >::value_.Reset();
  78     } else {
  79       FromVarConverter<T> converter(var);
  80       FromVarConverterBase<Optional<T> >::value_ = converter.value();
  81     }
  82   }
  83 };
  84
  85 template <>
  86 class FromVarConverter<bool> : public FromVarConverterBase<bool> {
  87  public:
  88   FromVarConverter() {
  89   }
  90
  91   explicit FromVarConverter(const PP_Var& var) {
  92     Set(var);
  93   }
  94
  95   ~FromVarConverter() {
  96   }
  97
  98   void Set(const PP_Var& var) {
  99     FromVarConverterBase<bool>::value_ = Var(var).AsBool();
 100   }
 101 };
 102
 103 template <>
 104 class FromVarConverter<int32_t> : public FromVarConverterBase<int32_t> {
 105  public:
 106   FromVarConverter() {
 107   }
 108
 109   explicit FromVarConverter(const PP_Var& var) {
 110     Set(var);
 111   }
 112
 113   ~FromVarConverter() {
 114   }
 115
 116   void Set(const PP_Var& var) {
 117     FromVarConverterBase<int32_t>::value_ = Var(var).AsInt();
 118   }
 119 };
 120
 121 template <>
 122 class FromVarConverter<double> : public FromVarConverterBase<double> {
 123  public:
 124   FromVarConverter() {
 125   }
 126
 127   explicit FromVarConverter(const PP_Var& var) {
 128     Set(var);
 129   }
 130
 131   ~FromVarConverter() {
 132   }
 133
 134   void Set(const PP_Var& var) {
 135     FromVarConverterBase<double>::value_ = Var(var).AsDouble();
 136   }
 137 };
 138
 139 template <>
 140 class FromVarConverter<std::string> : public FromVarConverterBase<std::string> {
 141  public:
 142   FromVarConverter() {
 143   }
 144
 145   explicit FromVarConverter(const PP_Var& var) {
 146     Set(var);
 147   }
 148
 149   ~FromVarConverter() {
 150   }
 151
 152   void Set(const PP_Var& var) {
 153     FromVarConverterBase<std::string>::value_ = Var(var).AsString();
 154   }
 155 };
 156
 157 template <>
 158 class FromVarConverter<Var> : public FromVarConverterBase<Var> {
 159  public:
 160   FromVarConverter() {
 161   }
 162
 163   explicit FromVarConverter(const PP_Var& var) {
 164     Set(var);
 165   }
 166
 167   ~FromVarConverter() {
 168   }
 169
 170   void Set(const PP_Var& var) {
 171     FromVarConverterBase<Var>::value_ = Var(var);
 172   }
 173 };
 174
 175 template <>
 176 class FromVarConverter<VarArray>
 177     : public FromVarConverterBase<VarArray> {
 178  public:
 179   FromVarConverter() {
 180   }
 181
 182   explicit FromVarConverter(const PP_Var& var) {
 183     Set(var);
 184   }
 185
 186   ~FromVarConverter() {
 187   }
 188
 189   void Set(const PP_Var& var) {
 190     FromVarConverterBase<VarArray>::value_ = Var(var);
 191   }
 192 };
 193
 194 template <>
 195 class FromVarConverter<VarDictionary>
 196     : public FromVarConverterBase<VarDictionary> {
 197  public:
 198   FromVarConverter() {
 199   }
 200
 201   explicit FromVarConverter(const PP_Var& var) {
 202     Set(var);
 203   }
 204
 205   ~FromVarConverter() {
 206   }
 207
 208   void Set(const PP_Var& var) {
 209     FromVarConverterBase<VarDictionary>::value_ = Var(var);
 210   }
 211 };
 212
 213 template <>
 214 class FromVarConverter<VarArrayBuffer>
 215     : public FromVarConverterBase<VarArrayBuffer> {
 216  public:
 217   FromVarConverter() {
 218   }
 219
 220   explicit FromVarConverter(const PP_Var& var) {
 221     Set(var);
 222   }
 223
 224   ~FromVarConverter() {
 225   }
 226
 227   void Set(const PP_Var& var) {
 228     FromVarConverterBase<VarArrayBuffer>::value_ = Var(var);
 229   }
 230 };
 231
 232 }  // namespace internal
 233 }  // namespace ext
 234 }  // namespace pp
 235
 236 #endif  // PPAPI_CPP_EXTENSIONS_FROM_VAR_CONVERTOR_H_