gin/converter.h

   1 // Copyright 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 GIN_CONVERTER_H_
   6 #define GIN_CONVERTER_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/strings/string_piece.h"
  12 #include "gin/gin_export.h"
  13 #include "v8/include/v8.h"
  14
  15 namespace gin {
  16
  17 template<typename T, typename Enable = void>
  18 struct Converter {};
  19
  20 template<>
  21 struct GIN_EXPORT Converter<bool> {
  22   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  23                                     bool val);
  24   static bool FromV8(v8::Isolate* isolate,
  25                      v8::Handle<v8::Value> val,
  26                      bool* out);
  27 };
  28
  29 template<>
  30 struct GIN_EXPORT Converter<int32_t> {
  31   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  32                                     int32_t val);
  33   static bool FromV8(v8::Isolate* isolate,
  34                      v8::Handle<v8::Value> val,
  35                      int32_t* out);
  36 };
  37
  38 template<>
  39 struct GIN_EXPORT Converter<uint32_t> {
  40   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  41                                     uint32_t val);
  42   static bool FromV8(v8::Isolate* isolate,
  43                      v8::Handle<v8::Value> val,
  44                      uint32_t* out);
  45 };
  46
  47 template<>
  48 struct GIN_EXPORT Converter<int64_t> {
  49   // Warning: JavaScript cannot represent 64 integers precisely.
  50   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  51                                     int64_t val);
  52   static bool FromV8(v8::Isolate* isolate,
  53                      v8::Handle<v8::Value> val,
  54                      int64_t* out);
  55 };
  56
  57 template<>
  58 struct GIN_EXPORT Converter<uint64_t> {
  59   // Warning: JavaScript cannot represent 64 integers precisely.
  60   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  61                                     uint64_t val);
  62   static bool FromV8(v8::Isolate* isolate,
  63                      v8::Handle<v8::Value> val,
  64                      uint64_t* out);
  65 };
  66
  67 template<>
  68 struct GIN_EXPORT Converter<float> {
  69   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  70                                     float val);
  71   static bool FromV8(v8::Isolate* isolate,
  72                      v8::Handle<v8::Value> val,
  73                      float* out);
  74 };
  75
  76 template<>
  77 struct GIN_EXPORT Converter<double> {
  78   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  79                                     double val);
  80   static bool FromV8(v8::Isolate* isolate,
  81                      v8::Handle<v8::Value> val,
  82                      double* out);
  83 };
  84
  85 template<>
  86 struct GIN_EXPORT Converter<base::StringPiece> {
  87   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  88                                     const base::StringPiece& val);
  89   // No conversion out is possible because StringPiece does not contain storage.
  90 };
  91
  92 template<>
  93 struct GIN_EXPORT Converter<std::string> {
  94   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
  95                                     const std::string& val);
  96   static bool FromV8(v8::Isolate* isolate,
  97                      v8::Handle<v8::Value> val,
  98                      std::string* out);
  99 };
 100
 101 template<>
 102 struct GIN_EXPORT Converter<v8::Handle<v8::Function> > {
 103   static bool FromV8(v8::Isolate* isolate,
 104                      v8::Handle<v8::Value> val,
 105                      v8::Handle<v8::Function>* out);
 106 };
 107
 108 template<>
 109 struct GIN_EXPORT Converter<v8::Handle<v8::Object> > {
 110   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
 111                                     v8::Handle<v8::Object> val);
 112   static bool FromV8(v8::Isolate* isolate,
 113                      v8::Handle<v8::Value> val,
 114                      v8::Handle<v8::Object>* out);
 115 };
 116
 117 template<>
 118 struct GIN_EXPORT Converter<v8::Handle<v8::ArrayBuffer> > {
 119   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
 120                                     v8::Handle<v8::ArrayBuffer> val);
 121   static bool FromV8(v8::Isolate* isolate,
 122                      v8::Handle<v8::Value> val,
 123                      v8::Handle<v8::ArrayBuffer>* out);
 124 };
 125
 126 template<>
 127 struct GIN_EXPORT Converter<v8::Handle<v8::External> > {
 128   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
 129                                     v8::Handle<v8::External> val);
 130   static bool FromV8(v8::Isolate* isolate,
 131                      v8::Handle<v8::Value> val,
 132                      v8::Handle<v8::External>* out);
 133 };
 134
 135 template<>
 136 struct GIN_EXPORT Converter<v8::Handle<v8::Value> > {
 137   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
 138                                     v8::Handle<v8::Value> val);
 139   static bool FromV8(v8::Isolate* isolate,
 140                      v8::Handle<v8::Value> val,
 141                      v8::Handle<v8::Value>* out);
 142 };
 143
 144 template<typename T>
 145 struct Converter<std::vector<T> > {
 146   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
 147                                     const std::vector<T>& val) {
 148     v8::Handle<v8::Array> result(
 149         v8::Array::New(isolate, static_cast<int>(val.size())));
 150     for (size_t i = 0; i < val.size(); ++i) {
 151       result->Set(static_cast<int>(i), Converter<T>::ToV8(isolate, val[i]));
 152     }
 153     return result;
 154   }
 155
 156   static bool FromV8(v8::Isolate* isolate,
 157                      v8::Handle<v8::Value> val,
 158                      std::vector<T>* out) {
 159     if (!val->IsArray())
 160       return false;
 161
 162     std::vector<T> result;
 163     v8::Handle<v8::Array> array(v8::Handle<v8::Array>::Cast(val));
 164     uint32_t length = array->Length();
 165     for (uint32_t i = 0; i < length; ++i) {
 166       T item;
 167       if (!Converter<T>::FromV8(isolate, array->Get(i), &item))
 168         return false;
 169       result.push_back(item);
 170     }
 171
 172     out->swap(result);
 173     return true;
 174   }
 175 };
 176
 177 // Convenience functions that deduce T.
 178 template<typename T>
 179 v8::Handle<v8::Value> ConvertToV8(v8::Isolate* isolate,
 180                                   T input) {
 181   return Converter<T>::ToV8(isolate, input);
 182 }
 183
 184 GIN_EXPORT inline v8::Handle<v8::String> StringToV8(
 185     v8::Isolate* isolate,
 186     const base::StringPiece& input) {
 187   return ConvertToV8(isolate, input).As<v8::String>();
 188 }
 189
 190 GIN_EXPORT v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
 191                                                  const base::StringPiece& val);
 192
 193 template<typename T>
 194 bool ConvertFromV8(v8::Isolate* isolate, v8::Handle<v8::Value> input,
 195                    T* result) {
 196   return Converter<T>::FromV8(isolate, input, result);
 197 }
 198
 199 GIN_EXPORT std::string V8ToString(v8::Handle<v8::Value> value);
 200
 201 }  // namespace gin
 202
 203 #endif  // GIN_CONVERTER_H_