chromium/gin/converter.cc

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "gin/converter.h"

#include <stdint.h>

#include <string_view>

#include "base/strings/string_util.h"
#include "base/time/time.h"
#include "v8/include/v8-array-buffer.h"
#include "v8/include/v8-external.h"
#include "v8/include/v8-function.h"
#include "v8/include/v8-maybe.h"
#include "v8/include/v8-object.h"
#include "v8/include/v8-primitive.h"
#include "v8/include/v8-promise.h"
#include "v8/include/v8-value.h"

ArrayBuffer;
External;
Function;
Int32;
Integer;
Isolate;
Local;
Maybe;
MaybeLocal;
Number;
Object;
Promise;
String;
Uint32;
Value;

namespace {

template <typename T, typename U>
bool FromMaybe(Maybe<T> maybe, U* out) { … }

}  // namespace

namespace gin {

Local<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) { … }

bool Converter<bool>::FromV8(Isolate* isolate, Local<Value> val, bool* out) { … }

Local<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) { … }

bool Converter<int32_t>::FromV8(Isolate* isolate,
                                Local<Value> val,
                                int32_t* out) { … }

Local<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) { … }

bool Converter<uint32_t>::FromV8(Isolate* isolate,
                                 Local<Value> val,
                                 uint32_t* out) { … }

Local<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) { … }

bool Converter<int64_t>::FromV8(Isolate* isolate,
                                Local<Value> val,
                                int64_t* out) { … }

Local<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) { … }

bool Converter<uint64_t>::FromV8(Isolate* isolate,
                                 Local<Value> val,
                                 uint64_t* out) { … }

Local<Value> Converter<float>::ToV8(Isolate* isolate, float val) { … }

bool Converter<float>::FromV8(Isolate* isolate, Local<Value> val, float* out) { … }

Local<Value> Converter<double>::ToV8(Isolate* isolate, double val) { … }

bool Converter<double>::FromV8(Isolate* isolate,
                               Local<Value> val,
                               double* out) { … }

Local<Value> Converter<std::string_view>::ToV8(Isolate* isolate,
                                               const std::string_view& val) { … }

Local<Value> Converter<std::string>::ToV8(Isolate* isolate,
                                          const std::string& val) { … }

bool Converter<std::string>::FromV8(Isolate* isolate,
                                    Local<Value> val,
                                    std::string* out) { … }

Local<Value> Converter<std::u16string>::ToV8(Isolate* isolate,
                                             const std::u16string& val) { … }

bool Converter<std::u16string>::FromV8(Isolate* isolate,
                                       Local<Value> val,
                                       std::u16string* out) { … }

v8::Local<v8::Value> Converter<base::TimeTicks>::ToV8(v8::Isolate* isolate,
                                                      base::TimeTicks val) { … }

Local<Value> Converter<Local<Function>>::ToV8(Isolate* isolate,
                                              Local<Function> val) { … }

bool Converter<Local<Function>>::FromV8(Isolate* isolate,
                                        Local<Value> val,
                                        Local<Function>* out) { … }

Local<Value> Converter<Local<Object>>::ToV8(Isolate* isolate,
                                            Local<Object> val) { … }

bool Converter<Local<Object>>::FromV8(Isolate* isolate,
                                      Local<Value> val,
                                      Local<Object>* out) { … }

Local<Value> Converter<Local<Promise>>::ToV8(Isolate* isolate,
                                             Local<Promise> val) { … }

bool Converter<Local<Promise>>::FromV8(Isolate* isolate,
                                       Local<Value> val,
                                       Local<Promise>* out) { … }

Local<Value> Converter<Local<ArrayBuffer>>::ToV8(Isolate* isolate,
                                                 Local<ArrayBuffer> val) { … }

bool Converter<Local<ArrayBuffer>>::FromV8(Isolate* isolate,
                                           Local<Value> val,
                                           Local<ArrayBuffer>* out) { … }

Local<Value> Converter<Local<External>>::ToV8(Isolate* isolate,
                                              Local<External> val) { … }

bool Converter<Local<External>>::FromV8(Isolate* isolate,
                                        v8::Local<Value> val,
                                        Local<External>* out) { … }

Local<Value> Converter<Local<Value>>::ToV8(Isolate* isolate, Local<Value> val) { … }

bool Converter<Local<Value>>::FromV8(Isolate* isolate,
                                     Local<Value> val,
                                     Local<Value>* out) { … }

v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
                                     const std::string_view& val) { … }

v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
                                     const std::u16string_view& val) { … }

base::Location V8ToBaseLocation(const v8::SourceLocation& location) { … }

std::string V8ToString(v8::Isolate* isolate, v8::Local<v8::Value> value) { … }

}  // namespace gin