TypeBuilder_h.template

// This file is generated

// Copyright (c) 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 {{class_name}}_h
#define {{class_name}}_h

#include "platform/PlatformExport.h"
#include "platform/inspector_protocol/Array.h"
#include "platform/inspector_protocol/ErrorSupport.h"
#include "platform/inspector_protocol/Maybe.h"
#include "platform/inspector_protocol/Object.h"
#include "platform/inspector_protocol/String16.h"
#include "platform/inspector_protocol/Values.h"
#include "platform/inspector_protocol/ValueConversions.h"
#include "wtf/Assertions.h"
#include "wtf/PtrUtil.h"

namespace blink {
namespace protocol {

{% for domain in api.domains %}

// ------------- Forward declarations and typedefs.

namespace {{domain.domain}} {
  {% for type in domain.types %}
    {% if type.type == "object" %}
      {% if "properties" in type %}
// {{type.description}}
class {{type.id}};
      {% else %}
// {{type.description}}
using {{type.id}} = Object;
      {% endif %}
    {% elif type.type != "array" %}
// {{type.description}}
using {{type.id}} = {{resolve_type(type).type}};
    {% endif %}
  {% endfor %}
} // {{domain.domain}}
{% endfor %}

// ------------- Enum values from types.
{% for domain in api.domains %}
  {% for type in domain.types %}
    {% if "enum" in type %}

namespace {{domain.domain}} {
namespace {{type.id}}Enum {
      {% for literal in type.enum %}
PLATFORM_EXPORT extern const char* {{ literal | dash_to_camelcase}};
      {% endfor %}
} // {{type.id}}Enum
} // {{domain.domain}}
    {% endif %}
  {% endfor %}
{% endfor %}

// ------------- Enum values from params.
{% for domain in api.domains %}
  {% for command in join_arrays(domain, ["commands", "events"]) %}
    {% for param in join_arrays(command, ["parameters", "returns"]) %}
      {% if "enum" in param %}

namespace {{domain.domain}} {
namespace {{command.name | to_title_case}} {
namespace {{param.name | to_title_case}}Enum {
        {% for literal in param.enum %}
PLATFORM_EXPORT extern const char* {{ literal | dash_to_camelcase}};
        {% endfor %}
} // {{param.name | to_title_case}}Enum
} // {{command.name | to_title_case }}
} // {{domain.domain}}
      {% endif %}
    {% endfor %}
  {% endfor %}
{% endfor %}

// ------------- Type and builder declarations.
{% for domain in api.domains %}

namespace {{domain.domain}} {
  {% for type in domain.types %}
    {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
    {% set type_def = type_definition(domain.domain + "." + type.id)%}

// {{type.description}}
class PLATFORM_EXPORT {{type.id}} {
public:
    static std::unique_ptr<{{type.id}}> parse(protocol::Value* value, ErrorSupport* errors);

    ~{{type.id}}() { }
    {% for property in type.properties %}
      {% if "enum" in property %}

    struct PLATFORM_EXPORT {{property.name | to_title_case}}Enum {
        {% for literal in property.enum %}
        static const char* {{ literal | dash_to_camelcase}};
        {% endfor %}
    }; // {{property.name | to_title_case}}Enum
      {% endif %}

      {% if property.optional %}
    bool has{{property.name | to_title_case}}() { return m_{{property.name}}.isJust(); }
    {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}({{resolve_type(property).raw_pass_type}} defaultValue) { return m_{{property.name}}.isJust() ? m_{{property.name}}.fromJust() : defaultValue; }
      {% else %}
    {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}() { return {{resolve_type(property).to_raw_type % ("m_" + property.name)}}; }
      {% endif %}
    void set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) { m_{{property.name}} = {{resolve_type(property).to_rvalue % "value"}}; }
    {% endfor %}

    std::unique_ptr<protocol::DictionaryValue> serialize() const;
    std::unique_ptr<{{type.id}}> clone() const;

    template<int STATE>
    class {{type.id}}Builder {
    public:
        enum {
            NoFieldsSet = 0,
    {% set count = 0 %}
    {% for property in type.properties %}
      {% if not(property.optional) %}
        {% set count = count + 1 %}
          {{property.name | to_title_case}}Set = 1 << {{count}},
      {% endif %}
    {% endfor %}
            AllFieldsSet = (
    {%- for property in type.properties %}
      {% if not(property.optional) %}{{property.name | to_title_case}}Set | {%endif %}
    {% endfor %}0)};

    {% for property in type.properties %}

      {% if property.optional %}
        {{type.id}}Builder<STATE>& set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value)
        {
            m_result->set{{property.name | to_title_case}}({{resolve_type(property).to_rvalue % "value"}});
            return *this;
        }
      {% else %}
        {{type.id}}Builder<STATE | {{property.name | to_title_case}}Set>& set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value)
        {
            static_assert(!(STATE & {{property.name | to_title_case}}Set), "property {{property.name}} should not be set yet");
            m_result->set{{property.name | to_title_case}}({{resolve_type(property).to_rvalue % "value"}});
            return castState<{{property.name | to_title_case}}Set>();
        }
      {% endif %}
    {% endfor %}

        std::unique_ptr<{{type.id}}> build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class {{type.id}};
        {{type.id}}Builder() : m_result(new {{type.id}}()) { }

        template<int STEP> {{type.id}}Builder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<{{type.id}}Builder<STATE | STEP>*>(this);
        }

        {{type_def.type}} m_result;
    };

    static {{type.id}}Builder<0> create()
    {
        return {{type.id}}Builder<0>();
    }

private:
    {{type.id}}() { }

    {% for property in type.properties %}
      {% if property.optional %}
    Maybe<{{resolve_type(property).raw_type}}> m_{{property.name}};
      {% else %}
    {{resolve_type(property).type}} m_{{property.name}};
      {% endif %}
    {% endfor %}
};

  {% endfor %}

} // {{domain.domain}}
{% endfor %}

} // namespace protocol
} // namespace blink

using blink::protocol::ErrorString;

#endif // !defined({{class_name}}_h)