@triniwiz/nativescript-masonkit 1.0.0-alpha.12 → 1.0.0-alpha.14

package/src-native/pods/Headers/inspector/src/inspector/protocol/Protocol.h

@@ -1,617 +0,0 @@
-// This file is generated by Values_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef v8_inspector_protocol_Values_h
-#define v8_inspector_protocol_Values_h
-
-//#include "Allocator.h"
-//#include "Forward.h"
-
-#include "src/inspector/protocol/Forward.h"
-
-namespace v8_inspector {
-namespace protocol {
-
-class ListValue;
-class DictionaryValue;
-class Value;
-
-#define PROTOCOL_DISALLOW_COPY(ClassName) \
- private:                                 \
-  ClassName(const ClassName&) = delete;   \
-  ClassName& operator=(const ClassName&) = delete
-
-class  Value : public Serializable {
-    PROTOCOL_DISALLOW_COPY(Value);
-public:
-    virtual ~Value() override { }
-
-    static std::unique_ptr<Value> null()
-    {
-        return std::unique_ptr<Value>(new Value());
-    }
-
-    static std::unique_ptr<Value> parseBinary(const uint8_t* data, size_t size);
-
-    enum ValueType {
-        TypeNull = 0,
-        TypeBoolean,
-        TypeInteger,
-        TypeDouble,
-        TypeString,
-        TypeBinary,
-        TypeObject,
-        TypeArray,
-        TypeImported
-    };
-
-    ValueType type() const { return m_type; }
-
-    bool isNull() const { return m_type == TypeNull; }
-
-    virtual bool asBoolean(bool* output) const;
-    virtual bool asDouble(double* output) const;
-    virtual bool asInteger(int* output) const;
-    virtual bool asString(String* output) const;
-    virtual bool asBinary(Binary* output) const;
-
-    virtual void AppendSerialized(std::vector<uint8_t>* bytes) const override;
-    virtual std::unique_ptr<Value> clone() const;
-
-protected:
-    Value() : m_type(TypeNull) { }
-    explicit Value(ValueType type) : m_type(type) { }
-
-private:
-    friend class DictionaryValue;
-    friend class ListValue;
-
-    ValueType m_type;
-};
-
-class  FundamentalValue : public Value {
-public:
-    static std::unique_ptr<FundamentalValue> create(bool value)
-    {
-        return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
-    }
-
-    static std::unique_ptr<FundamentalValue> create(int value)
-    {
-        return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
-    }
-
-    static std::unique_ptr<FundamentalValue> create(double value)
-    {
-        return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
-    }
-
-    bool asBoolean(bool* output) const override;
-    bool asDouble(double* output) const override;
-    bool asInteger(int* output) const override;
-    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
-    std::unique_ptr<Value> clone() const override;
-
-private:
-    explicit FundamentalValue(bool value) : Value(TypeBoolean), m_boolValue(value) { }
-    explicit FundamentalValue(int value) : Value(TypeInteger), m_integerValue(value) { }
-    explicit FundamentalValue(double value) : Value(TypeDouble), m_doubleValue(value) { }
-
-    union {
-        bool m_boolValue;
-        double m_doubleValue;
-        int m_integerValue;
-    };
-};
-
-class  StringValue : public Value {
-public:
-    static std::unique_ptr<StringValue> create(const String& value)
-    {
-        return std::unique_ptr<StringValue>(new StringValue(value));
-    }
-
-    static std::unique_ptr<StringValue> create(const char* value)
-    {
-        return std::unique_ptr<StringValue>(new StringValue(value));
-    }
-
-    bool asString(String* output) const override;
-    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
-    std::unique_ptr<Value> clone() const override;
-
-private:
-    explicit StringValue(const String& value) : Value(TypeString), m_stringValue(value) { }
-    explicit StringValue(const char* value) : Value(TypeString), m_stringValue(value) { }
-
-    String m_stringValue;
-};
-
-class  BinaryValue : public Value {
-public:
-    static std::unique_ptr<BinaryValue> create(const Binary& value)
-    {
-        return std::unique_ptr<BinaryValue>(new BinaryValue(value));
-    }
-
-    bool asBinary(Binary* output) const override;
-    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
-    std::unique_ptr<Value> clone() const override;
-
-private:
-    explicit BinaryValue(const Binary& value) : Value(TypeBinary), m_binaryValue(value) { }
-
-    Binary m_binaryValue;
-};
-
-class  DictionaryValue : public Value {
-public:
-    using Entry = std::pair<String, Value*>;
-    static std::unique_ptr<DictionaryValue> create()
-    {
-        return std::unique_ptr<DictionaryValue>(new DictionaryValue());
-    }
-
-    static DictionaryValue* cast(Value* value)
-    {
-        if (!value || value->type() != TypeObject)
-            return nullptr;
-        return static_cast<DictionaryValue*>(value);
-    }
-
-    static std::unique_ptr<DictionaryValue> cast(std::unique_ptr<Value> value)
-    {
-        return std::unique_ptr<DictionaryValue>(DictionaryValue::cast(value.release()));
-    }
-
-    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
-    std::unique_ptr<Value> clone() const override;
-
-    size_t size() const { return m_data.size(); }
-
-    void setBoolean(const String& name, bool);
-    void setInteger(const String& name, int);
-    void setDouble(const String& name, double);
-    void setString(const String& name, const String&);
-    void setValue(const String& name, std::unique_ptr<Value>);
-    void setObject(const String& name, std::unique_ptr<DictionaryValue>);
-    void setArray(const String& name, std::unique_ptr<ListValue>);
-
-    bool getBoolean(const String& name, bool* output) const;
-    bool getInteger(const String& name, int* output) const;
-    bool getDouble(const String& name, double* output) const;
-    bool getString(const String& name, String* output) const;
-
-    DictionaryValue* getObject(const String& name) const;
-    ListValue* getArray(const String& name) const;
-    Value* get(const String& name) const;
-    Entry at(size_t index) const;
-
-    bool booleanProperty(const String& name, bool defaultValue) const;
-    int integerProperty(const String& name, int defaultValue) const;
-    double doubleProperty(const String& name, double defaultValue) const;
-    void remove(const String& name);
-
-    ~DictionaryValue() override;
-
-private:
-    DictionaryValue();
-    template<typename T>
-    void set(const String& key, std::unique_ptr<T>& value)
-    {
-        DCHECK(value);
-        bool isNew = m_data.find(key) == m_data.end();
-        m_data[key] = std::move(value);
-        if (isNew)
-            m_order.push_back(key);
-    }
-
-    using Dictionary = std::unordered_map<String, std::unique_ptr<Value>>;
-    Dictionary m_data;
-    std::vector<String> m_order;
-};
-
-class  ListValue : public Value {
-public:
-    static std::unique_ptr<ListValue> create()
-    {
-        return std::unique_ptr<ListValue>(new ListValue());
-    }
-
-    static ListValue* cast(Value* value)
-    {
-        if (!value || value->type() != TypeArray)
-            return nullptr;
-        return static_cast<ListValue*>(value);
-    }
-
-    static std::unique_ptr<ListValue> cast(std::unique_ptr<Value> value)
-    {
-        return std::unique_ptr<ListValue>(ListValue::cast(value.release()));
-    }
-
-    ~ListValue() override;
-
-    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
-    std::unique_ptr<Value> clone() const override;
-
-    void pushValue(std::unique_ptr<Value>);
-
-    Value* at(size_t index);
-    size_t size() const { return m_data.size(); }
-    void reserve(size_t capacity) { m_data.reserve(capacity); }
-
-private:
-    ListValue();
-    std::vector<std::unique_ptr<Value>> m_data;
-};
-
-} // namespace v8_inspector
-} // namespace protocol
-
-#endif // v8_inspector_protocol_Values_h
-
-
-// This file is generated by Object_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef v8_inspector_protocol_Object_h
-#define v8_inspector_protocol_Object_h
-
-//#include "ErrorSupport.h"
-//#include "Forward.h"
-//#include "Values.h"
-
-#include "third_party/inspector_protocol/crdtp/serializable.h"
-
-namespace v8_inspector {
-namespace protocol {
-
-class  Object : public v8_crdtp::Serializable {
-public:
-    static std::unique_ptr<Object> fromValue(protocol::Value*, ErrorSupport*);
-    explicit Object(std::unique_ptr<protocol::DictionaryValue>);
-    ~Object();
-
-    // Implements Serializable.
-    void AppendSerialized(std::vector<uint8_t>* out) const override;
-
-    std::unique_ptr<protocol::DictionaryValue> toValue() const;
-    std::unique_ptr<Object> clone() const;
-
-private:
-    Object() = default;
-    friend struct v8_crdtp::ProtocolTypeTraits<std::unique_ptr<Object>, void>;
-
-    std::unique_ptr<protocol::DictionaryValue> m_object;
-};
-
-} // namespace v8_inspector
-} // namespace protocol
-
-#endif // !defined(v8_inspector_protocol_Object_h)
-
-
-// This file is generated by ValueConversions_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef v8_inspector_protocol_ValueConversions_h
-#define v8_inspector_protocol_ValueConversions_h
-
-//#include "ErrorSupport.h"
-//#include "Forward.h"
-//#include "Values.h"
-
-namespace v8_inspector {
-namespace protocol {
-
-template<typename T>
-struct ValueConversions {
-    static std::unique_ptr<T> fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        return T::fromValue(value, errors);
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(T* value)
-    {
-        return value->toValue();
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<T>& value)
-    {
-        return value->toValue();
-    }
-};
-
-template<>
-struct ValueConversions<bool> {
-    static bool fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        bool result = false;
-        bool success = value ? value->asBoolean(&result) : false;
-        if (!success)
-            errors->AddError("boolean value expected");
-        return result;
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(bool value)
-    {
-        return FundamentalValue::create(value);
-    }
-};
-
-template<>
-struct ValueConversions<int> {
-    static int fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        int result = 0;
-        bool success = value ? value->asInteger(&result) : false;
-        if (!success)
-            errors->AddError("integer value expected");
-        return result;
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(int value)
-    {
-        return FundamentalValue::create(value);
-    }
-};
-
-template<>
-struct ValueConversions<double> {
-    static double fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        double result = 0;
-        bool success = value ? value->asDouble(&result) : false;
-        if (!success)
-            errors->AddError("double value expected");
-        return result;
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(double value)
-    {
-        return FundamentalValue::create(value);
-    }
-};
-
-template<>
-struct ValueConversions<String> {
-    static String fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        String result;
-        bool success = value ? value->asString(&result) : false;
-        if (!success)
-            errors->AddError("string value expected");
-        return result;
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(const String& value)
-    {
-        return StringValue::create(value);
-    }
-};
-
-template<>
-struct ValueConversions<Binary> {
-    static Binary fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        if (!value ||
-            (value->type() != Value::TypeBinary && value->type() != Value::TypeString)) {
-            errors->AddError("Either string base64 or binary value expected");
-            return Binary();
-        }
-        Binary binary;
-        if (value->asBinary(&binary))
-            return binary;
-        String result;
-        value->asString(&result);
-        bool success;
-        Binary out = Binary::fromBase64(result, &success);
-        if (!success)
-          errors->AddError("base64 decoding error");
-        return out;
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(const Binary& value)
-    {
-        return BinaryValue::create(value);
-    }
-};
-
-template<typename T>
-struct ValueConversions<std::vector<std::unique_ptr<T>>> {
-    static std::unique_ptr<std::vector<std::unique_ptr<T>>> fromValue(protocol::Value* value, ErrorSupport* errors) {
-        protocol::ListValue* array = ListValue::cast(value);
-        if (!array) {
-            errors->AddError("array expected");
-            return nullptr;
-        }
-        errors->Push();
-        std::unique_ptr<std::vector<std::unique_ptr<T>>> result(
-            new std::vector<std::unique_ptr<T>>());
-        result->reserve(array->size());
-        for (size_t i = 0; i < array->size(); ++i) {
-            errors->SetIndex(i);
-            auto item = ValueConversions<T>::fromValue(array->at(i), errors);
-            result->emplace_back(std::move(item));
-        }
-        errors->Pop();
-        if (!errors->Errors().empty())
-            return nullptr;
-        return result;
-    }
-
-    static std::unique_ptr<protocol::ListValue> toValue(std::vector<std::unique_ptr<T>>* v)
-    {
-        std::unique_ptr<protocol::ListValue> result = ListValue::create();
-        result->reserve(v->size());
-        for (auto& item : *v)
-            result->pushValue(ValueConversions<T>::toValue(item.get()));
-        return result;
-    }
-
-};
-
-template<typename T>
-struct ValueConversions<std::vector<T>> {
-    static std::unique_ptr<std::vector<T>> fromValue(protocol::Value* value, ErrorSupport* errors) {
-        protocol::ListValue* array = ListValue::cast(value);
-        if (!array) {
-            errors->AddError("array expected");
-            return nullptr;
-        }
-        errors->Push();
-        std::unique_ptr<std::vector<T>> result(new std::vector<T>());
-        result->reserve(array->size());
-        for (size_t i = 0; i < array->size(); ++i) {
-            errors->SetIndex(i);
-            auto item = ValueConversions<T>::fromValue(array->at(i), errors);
-            result->emplace_back(std::move(item));
-        }
-        errors->Pop();
-        if (!errors->Errors().empty())
-            return nullptr;
-        return result;
-    }
-
-    static std::unique_ptr<protocol::ListValue> toValue(std::vector<T>* v)
-    {
-        std::unique_ptr<protocol::ListValue> result = ListValue::create();
-        result->reserve(v->size());
-        for (auto& item : *v)
-            result->pushValue(ValueConversions<T>::toValue(item));
-        return result;
-    }
-};
-
-template<>
-struct ValueConversions<Value> {
-    static std::unique_ptr<Value> fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        bool success = !!value;
-        if (!success) {
-            errors->AddError("value expected");
-            return nullptr;
-        }
-        return value->clone();
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(Value* value)
-    {
-        return value->clone();
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<Value>& value)
-    {
-        return value->clone();
-    }
-};
-
-template<>
-struct ValueConversions<DictionaryValue> {
-    static std::unique_ptr<DictionaryValue> fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        bool success = value && value->type() == protocol::Value::TypeObject;
-        if (!success)
-            errors->AddError("object expected");
-        return DictionaryValue::cast(value->clone());
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(DictionaryValue* value)
-    {
-        return value->clone();
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<DictionaryValue>& value)
-    {
-        return value->clone();
-    }
-};
-
-template<>
-struct ValueConversions<ListValue> {
-    static std::unique_ptr<ListValue> fromValue(protocol::Value* value, ErrorSupport* errors)
-    {
-        bool success = value && value->type() == protocol::Value::TypeArray;
-        if (!success)
-            errors->AddError("list expected");
-        return ListValue::cast(value->clone());
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(ListValue* value)
-    {
-        return value->clone();
-    }
-
-    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<ListValue>& value)
-    {
-        return value->clone();
-    }
-};
-
-template<typename T> struct ValueTypeConverter {
-  static std::unique_ptr<T> FromValue(const protocol::Value& value) {
-    std::vector<uint8_t> bytes;
-    value.AppendSerialized(&bytes);
-    return T::FromBinary(bytes.data(), bytes.size());
-  }
-
-  static std::unique_ptr<protocol::DictionaryValue> ToValue(const T& obj) {
-    std::vector<uint8_t> bytes;
-    obj.AppendSerialized(&bytes);
-    auto result = Value::parseBinary(bytes.data(), bytes.size());
-    return DictionaryValue::cast(std::move(result));
-  }
-};
-
-} // namespace v8_inspector
-} // namespace protocol
-
-namespace v8_crdtp {
-
-template<typename T>
-struct ProtocolTypeTraits<T,
-     typename std::enable_if<std::is_base_of<v8_inspector::protocol::Value, T>::value>::type> {
-  static void Serialize(const v8_inspector::protocol::Value& value, std::vector<uint8_t>* bytes) {
-    value.AppendSerialized(bytes);
-  }
-};
-
-template <>
-struct ProtocolTypeTraits<std::unique_ptr<v8_inspector::protocol::Value>> {
-  static bool Deserialize(DeserializerState* state, std::unique_ptr<v8_inspector::protocol::Value>* value);
-  static void Serialize(const std::unique_ptr<v8_inspector::protocol::Value>& value, std::vector<uint8_t>* bytes);
-};
-
-template <>
-struct ProtocolTypeTraits<std::unique_ptr<v8_inspector::protocol::DictionaryValue>> {
-  static bool Deserialize(DeserializerState* state, std::unique_ptr<v8_inspector::protocol::DictionaryValue>* value);
-  static void Serialize(const std::unique_ptr<v8_inspector::protocol::DictionaryValue>& value, std::vector<uint8_t>* bytes);
-};
-
-// TODO(caseq): get rid of it, it's just a DictionaryValue really.
-template <>
-struct ProtocolTypeTraits<std::unique_ptr<v8_inspector::protocol::Object>> {
-  static bool Deserialize(DeserializerState* state, std::unique_ptr<v8_inspector::protocol::Object>* value);
-  static void Serialize(const std::unique_ptr<v8_inspector::protocol::Object>& value, std::vector<uint8_t>* bytes);
-};
-
-template<>
-struct ProtocolTypeTraits<v8_inspector::protocol::Object> {
-  static void Serialize(const v8_inspector::protocol::Object& value, std::vector<uint8_t>* bytes) {
-    value.AppendSerialized(bytes);
-  }
-};
-
-}  // namespace v8_crdtp
-
-#endif // !defined(v8_inspector_protocol_ValueConversions_h)