File calculator_graph_template.pb.h

File List > framework > tool > calculator_graph_template.pb.h

Go to the documentation of this file

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: mediapipe/framework/tool/calculator_graph_template.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "mediapipe/framework/calculator.pb.h"
#include "mediapipe/framework/calculator_options.pb.h"
#include "mediapipe/framework/deps/proto_descriptor.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
namespace mediapipe {
class CalculatorGraphTemplate;
struct CalculatorGraphTemplateDefaultTypeInternal;
extern CalculatorGraphTemplateDefaultTypeInternal _CalculatorGraphTemplate_default_instance_;
class TemplateArgument;
struct TemplateArgumentDefaultTypeInternal;
extern TemplateArgumentDefaultTypeInternal _TemplateArgument_default_instance_;
class TemplateDict;
struct TemplateDictDefaultTypeInternal;
extern TemplateDictDefaultTypeInternal _TemplateDict_default_instance_;
class TemplateDict_Parameter;
struct TemplateDict_ParameterDefaultTypeInternal;
extern TemplateDict_ParameterDefaultTypeInternal _TemplateDict_Parameter_default_instance_;
class TemplateExpression;
struct TemplateExpressionDefaultTypeInternal;
extern TemplateExpressionDefaultTypeInternal _TemplateExpression_default_instance_;
class TemplateSubgraphOptions;
struct TemplateSubgraphOptionsDefaultTypeInternal;
extern TemplateSubgraphOptionsDefaultTypeInternal _TemplateSubgraphOptions_default_instance_;
}  // namespace mediapipe
PROTOBUF_NAMESPACE_OPEN
template<> ::mediapipe::CalculatorGraphTemplate* Arena::CreateMaybeMessage<::mediapipe::CalculatorGraphTemplate>(Arena*);
template<> ::mediapipe::TemplateArgument* Arena::CreateMaybeMessage<::mediapipe::TemplateArgument>(Arena*);
template<> ::mediapipe::TemplateDict* Arena::CreateMaybeMessage<::mediapipe::TemplateDict>(Arena*);
template<> ::mediapipe::TemplateDict_Parameter* Arena::CreateMaybeMessage<::mediapipe::TemplateDict_Parameter>(Arena*);
template<> ::mediapipe::TemplateExpression* Arena::CreateMaybeMessage<::mediapipe::TemplateExpression>(Arena*);
template<> ::mediapipe::TemplateSubgraphOptions* Arena::CreateMaybeMessage<::mediapipe::TemplateSubgraphOptions>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace mediapipe {

// ===================================================================

class TemplateExpression final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:mediapipe.TemplateExpression) */ {
 public:
  inline TemplateExpression() : TemplateExpression(nullptr) {}
  ~TemplateExpression() override;
  explicit constexpr TemplateExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateExpression(const TemplateExpression& from);
  TemplateExpression(TemplateExpression&& from) noexcept
    : TemplateExpression() {
    *this = ::std::move(from);
  }

  inline TemplateExpression& operator=(const TemplateExpression& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateExpression& operator=(TemplateExpression&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateExpression& default_instance() {
    return *internal_default_instance();
  }
  static inline const TemplateExpression* internal_default_instance() {
    return reinterpret_cast<const TemplateExpression*>(
               &_TemplateExpression_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(TemplateExpression& a, TemplateExpression& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateExpression* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TemplateExpression* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateExpression>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateExpression& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TemplateExpression& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateExpression* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mediapipe.TemplateExpression";
  }
  protected:
  explicit TemplateExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgFieldNumber = 3,
    kKeyTypeFieldNumber = 6,
    kParamFieldNumber = 1,
    kOpFieldNumber = 2,
    kPathFieldNumber = 4,
    kFieldValueFieldNumber = 7,
    kFieldTypeFieldNumber = 5,
  };
  // repeated .mediapipe.TemplateExpression arg = 3;
  int arg_size() const;
  private:
  int _internal_arg_size() const;
  public:
  void clear_arg();
  ::mediapipe::TemplateExpression* mutable_arg(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >*
      mutable_arg();
  private:
  const ::mediapipe::TemplateExpression& _internal_arg(int index) const;
  ::mediapipe::TemplateExpression* _internal_add_arg();
  public:
  const ::mediapipe::TemplateExpression& arg(int index) const;
  ::mediapipe::TemplateExpression* add_arg();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >&
      arg() const;

  // repeated .mediapipe.FieldDescriptorProto.Type key_type = 6;
  int key_type_size() const;
  private:
  int _internal_key_type_size() const;
  public:
  void clear_key_type();
  private:
  ::mediapipe::FieldDescriptorProto_Type _internal_key_type(int index) const;
  void _internal_add_key_type(::mediapipe::FieldDescriptorProto_Type value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_key_type();
  public:
  ::mediapipe::FieldDescriptorProto_Type key_type(int index) const;
  void set_key_type(int index, ::mediapipe::FieldDescriptorProto_Type value);
  void add_key_type(::mediapipe::FieldDescriptorProto_Type value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& key_type() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_key_type();

  // optional string param = 1;
  bool has_param() const;
  private:
  bool _internal_has_param() const;
  public:
  void clear_param();
  const std::string& param() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_param(ArgT0&& arg0, ArgT... args);
  std::string* mutable_param();
  PROTOBUF_NODISCARD std::string* release_param();
  void set_allocated_param(std::string* param);
  private:
  const std::string& _internal_param() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_param(const std::string& value);
  std::string* _internal_mutable_param();
  public:

  // optional string op = 2;
  bool has_op() const;
  private:
  bool _internal_has_op() const;
  public:
  void clear_op();
  const std::string& op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_op();
  PROTOBUF_NODISCARD std::string* release_op();
  void set_allocated_op(std::string* op);
  private:
  const std::string& _internal_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_op(const std::string& value);
  std::string* _internal_mutable_op();
  public:

  // optional string path = 4;
  bool has_path() const;
  private:
  bool _internal_has_path() const;
  public:
  void clear_path();
  const std::string& path() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_path(ArgT0&& arg0, ArgT... args);
  std::string* mutable_path();
  PROTOBUF_NODISCARD std::string* release_path();
  void set_allocated_path(std::string* path);
  private:
  const std::string& _internal_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_path(const std::string& value);
  std::string* _internal_mutable_path();
  public:

  // optional string field_value = 7;
  bool has_field_value() const;
  private:
  bool _internal_has_field_value() const;
  public:
  void clear_field_value();
  const std::string& field_value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_field_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_field_value();
  PROTOBUF_NODISCARD std::string* release_field_value();
  void set_allocated_field_value(std::string* field_value);
  private:
  const std::string& _internal_field_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_field_value(const std::string& value);
  std::string* _internal_mutable_field_value();
  public:

  // optional .mediapipe.FieldDescriptorProto.Type field_type = 5;
  bool has_field_type() const;
  private:
  bool _internal_has_field_type() const;
  public:
  void clear_field_type();
  ::mediapipe::FieldDescriptorProto_Type field_type() const;
  void set_field_type(::mediapipe::FieldDescriptorProto_Type value);
  private:
  ::mediapipe::FieldDescriptorProto_Type _internal_field_type() const;
  void _internal_set_field_type(::mediapipe::FieldDescriptorProto_Type value);
  public:

  // @@protoc_insertion_point(class_scope:mediapipe.TemplateExpression)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression > arg_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> key_type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr path_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_value_;
  int field_type_;
  friend struct ::TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
};
// -------------------------------------------------------------------

class CalculatorGraphTemplate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:mediapipe.CalculatorGraphTemplate) */ {
 public:
  inline CalculatorGraphTemplate() : CalculatorGraphTemplate(nullptr) {}
  ~CalculatorGraphTemplate() override;
  explicit constexpr CalculatorGraphTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CalculatorGraphTemplate(const CalculatorGraphTemplate& from);
  CalculatorGraphTemplate(CalculatorGraphTemplate&& from) noexcept
    : CalculatorGraphTemplate() {
    *this = ::std::move(from);
  }

  inline CalculatorGraphTemplate& operator=(const CalculatorGraphTemplate& from) {
    CopyFrom(from);
    return *this;
  }
  inline CalculatorGraphTemplate& operator=(CalculatorGraphTemplate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CalculatorGraphTemplate& default_instance() {
    return *internal_default_instance();
  }
  static inline const CalculatorGraphTemplate* internal_default_instance() {
    return reinterpret_cast<const CalculatorGraphTemplate*>(
               &_CalculatorGraphTemplate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CalculatorGraphTemplate& a, CalculatorGraphTemplate& b) {
    a.Swap(&b);
  }
  inline void Swap(CalculatorGraphTemplate* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CalculatorGraphTemplate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CalculatorGraphTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CalculatorGraphTemplate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CalculatorGraphTemplate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CalculatorGraphTemplate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CalculatorGraphTemplate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mediapipe.CalculatorGraphTemplate";
  }
  protected:
  explicit CalculatorGraphTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRuleFieldNumber = 2,
    kConfigFieldNumber = 1,
  };
  // repeated .mediapipe.TemplateExpression rule = 2;
  int rule_size() const;
  private:
  int _internal_rule_size() const;
  public:
  void clear_rule();
  ::mediapipe::TemplateExpression* mutable_rule(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >*
      mutable_rule();
  private:
  const ::mediapipe::TemplateExpression& _internal_rule(int index) const;
  ::mediapipe::TemplateExpression* _internal_add_rule();
  public:
  const ::mediapipe::TemplateExpression& rule(int index) const;
  ::mediapipe::TemplateExpression* add_rule();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >&
      rule() const;

  // optional .mediapipe.CalculatorGraphConfig config = 1;
  bool has_config() const;
  private:
  bool _internal_has_config() const;
  public:
  void clear_config();
  const ::mediapipe::CalculatorGraphConfig& config() const;
  PROTOBUF_NODISCARD ::mediapipe::CalculatorGraphConfig* release_config();
  ::mediapipe::CalculatorGraphConfig* mutable_config();
  void set_allocated_config(::mediapipe::CalculatorGraphConfig* config);
  private:
  const ::mediapipe::CalculatorGraphConfig& _internal_config() const;
  ::mediapipe::CalculatorGraphConfig* _internal_mutable_config();
  public:
  void unsafe_arena_set_allocated_config(
      ::mediapipe::CalculatorGraphConfig* config);
  ::mediapipe::CalculatorGraphConfig* unsafe_arena_release_config();

  // @@protoc_insertion_point(class_scope:mediapipe.CalculatorGraphTemplate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression > rule_;
  ::mediapipe::CalculatorGraphConfig* config_;
  friend struct ::TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
};
// -------------------------------------------------------------------

class TemplateArgument final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:mediapipe.TemplateArgument) */ {
 public:
  inline TemplateArgument() : TemplateArgument(nullptr) {}
  ~TemplateArgument() override;
  explicit constexpr TemplateArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateArgument(const TemplateArgument& from);
  TemplateArgument(TemplateArgument&& from) noexcept
    : TemplateArgument() {
    *this = ::std::move(from);
  }

  inline TemplateArgument& operator=(const TemplateArgument& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateArgument& operator=(TemplateArgument&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateArgument& default_instance() {
    return *internal_default_instance();
  }
  enum ParamValueCase {
    kStr = 1,
    kNum = 2,
    kDict = 3,
    PARAM_VALUE_NOT_SET = 0,
  };

  static inline const TemplateArgument* internal_default_instance() {
    return reinterpret_cast<const TemplateArgument*>(
               &_TemplateArgument_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(TemplateArgument& a, TemplateArgument& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateArgument* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TemplateArgument* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateArgument>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateArgument& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TemplateArgument& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateArgument* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mediapipe.TemplateArgument";
  }
  protected:
  explicit TemplateArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kElementFieldNumber = 4,
    kStrFieldNumber = 1,
    kNumFieldNumber = 2,
    kDictFieldNumber = 3,
  };
  // repeated .mediapipe.TemplateArgument element = 4;
  int element_size() const;
  private:
  int _internal_element_size() const;
  public:
  void clear_element();
  ::mediapipe::TemplateArgument* mutable_element(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateArgument >*
      mutable_element();
  private:
  const ::mediapipe::TemplateArgument& _internal_element(int index) const;
  ::mediapipe::TemplateArgument* _internal_add_element();
  public:
  const ::mediapipe::TemplateArgument& element(int index) const;
  ::mediapipe::TemplateArgument* add_element();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateArgument >&
      element() const;

  // string str = 1;
  bool has_str() const;
  private:
  bool _internal_has_str() const;
  public:
  void clear_str();
  const std::string& str() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_str(ArgT0&& arg0, ArgT... args);
  std::string* mutable_str();
  PROTOBUF_NODISCARD std::string* release_str();
  void set_allocated_str(std::string* str);
  private:
  const std::string& _internal_str() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_str(const std::string& value);
  std::string* _internal_mutable_str();
  public:

  // double num = 2;
  bool has_num() const;
  private:
  bool _internal_has_num() const;
  public:
  void clear_num();
  double num() const;
  void set_num(double value);
  private:
  double _internal_num() const;
  void _internal_set_num(double value);
  public:

  // .mediapipe.TemplateDict dict = 3;
  bool has_dict() const;
  private:
  bool _internal_has_dict() const;
  public:
  void clear_dict();
  const ::mediapipe::TemplateDict& dict() const;
  PROTOBUF_NODISCARD ::mediapipe::TemplateDict* release_dict();
  ::mediapipe::TemplateDict* mutable_dict();
  void set_allocated_dict(::mediapipe::TemplateDict* dict);
  private:
  const ::mediapipe::TemplateDict& _internal_dict() const;
  ::mediapipe::TemplateDict* _internal_mutable_dict();
  public:
  void unsafe_arena_set_allocated_dict(
      ::mediapipe::TemplateDict* dict);
  ::mediapipe::TemplateDict* unsafe_arena_release_dict();

  void clear_param_value();
  ParamValueCase param_value_case() const;
  // @@protoc_insertion_point(class_scope:mediapipe.TemplateArgument)
 private:
  class _Internal;
  void set_has_str();
  void set_has_num();
  void set_has_dict();

  inline bool has_param_value() const;
  inline void clear_has_param_value();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateArgument > element_;
  union ParamValueUnion {
    constexpr ParamValueUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_;
    double num_;
    ::mediapipe::TemplateDict* dict_;
  } param_value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
};
// -------------------------------------------------------------------

class TemplateDict_Parameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:mediapipe.TemplateDict.Parameter) */ {
 public:
  inline TemplateDict_Parameter() : TemplateDict_Parameter(nullptr) {}
  ~TemplateDict_Parameter() override;
  explicit constexpr TemplateDict_Parameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateDict_Parameter(const TemplateDict_Parameter& from);
  TemplateDict_Parameter(TemplateDict_Parameter&& from) noexcept
    : TemplateDict_Parameter() {
    *this = ::std::move(from);
  }

  inline TemplateDict_Parameter& operator=(const TemplateDict_Parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateDict_Parameter& operator=(TemplateDict_Parameter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateDict_Parameter& default_instance() {
    return *internal_default_instance();
  }
  static inline const TemplateDict_Parameter* internal_default_instance() {
    return reinterpret_cast<const TemplateDict_Parameter*>(
               &_TemplateDict_Parameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(TemplateDict_Parameter& a, TemplateDict_Parameter& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateDict_Parameter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TemplateDict_Parameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateDict_Parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateDict_Parameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateDict_Parameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TemplateDict_Parameter& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateDict_Parameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mediapipe.TemplateDict.Parameter";
  }
  protected:
  explicit TemplateDict_Parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // optional string key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // optional .mediapipe.TemplateArgument value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::mediapipe::TemplateArgument& value() const;
  PROTOBUF_NODISCARD ::mediapipe::TemplateArgument* release_value();
  ::mediapipe::TemplateArgument* mutable_value();
  void set_allocated_value(::mediapipe::TemplateArgument* value);
  private:
  const ::mediapipe::TemplateArgument& _internal_value() const;
  ::mediapipe::TemplateArgument* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::mediapipe::TemplateArgument* value);
  ::mediapipe::TemplateArgument* unsafe_arena_release_value();

  // @@protoc_insertion_point(class_scope:mediapipe.TemplateDict.Parameter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::mediapipe::TemplateArgument* value_;
  friend struct ::TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
};
// -------------------------------------------------------------------

class TemplateDict final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:mediapipe.TemplateDict) */ {
 public:
  inline TemplateDict() : TemplateDict(nullptr) {}
  ~TemplateDict() override;
  explicit constexpr TemplateDict(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateDict(const TemplateDict& from);
  TemplateDict(TemplateDict&& from) noexcept
    : TemplateDict() {
    *this = ::std::move(from);
  }

  inline TemplateDict& operator=(const TemplateDict& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateDict& operator=(TemplateDict&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateDict& default_instance() {
    return *internal_default_instance();
  }
  static inline const TemplateDict* internal_default_instance() {
    return reinterpret_cast<const TemplateDict*>(
               &_TemplateDict_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(TemplateDict& a, TemplateDict& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateDict* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TemplateDict* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateDict* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateDict>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateDict& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TemplateDict& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateDict* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mediapipe.TemplateDict";
  }
  protected:
  explicit TemplateDict(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TemplateDict_Parameter Parameter;

  // accessors -------------------------------------------------------

  enum : int {
    kArgFieldNumber = 1,
  };
  // repeated .mediapipe.TemplateDict.Parameter arg = 1;
  int arg_size() const;
  private:
  int _internal_arg_size() const;
  public:
  void clear_arg();
  ::mediapipe::TemplateDict_Parameter* mutable_arg(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateDict_Parameter >*
      mutable_arg();
  private:
  const ::mediapipe::TemplateDict_Parameter& _internal_arg(int index) const;
  ::mediapipe::TemplateDict_Parameter* _internal_add_arg();
  public:
  const ::mediapipe::TemplateDict_Parameter& arg(int index) const;
  ::mediapipe::TemplateDict_Parameter* add_arg();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateDict_Parameter >&
      arg() const;

  // @@protoc_insertion_point(class_scope:mediapipe.TemplateDict)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateDict_Parameter > arg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
};
// -------------------------------------------------------------------

class TemplateSubgraphOptions final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:mediapipe.TemplateSubgraphOptions) */ {
 public:
  inline TemplateSubgraphOptions() : TemplateSubgraphOptions(nullptr) {}
  ~TemplateSubgraphOptions() override;
  explicit constexpr TemplateSubgraphOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateSubgraphOptions(const TemplateSubgraphOptions& from);
  TemplateSubgraphOptions(TemplateSubgraphOptions&& from) noexcept
    : TemplateSubgraphOptions() {
    *this = ::std::move(from);
  }

  inline TemplateSubgraphOptions& operator=(const TemplateSubgraphOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateSubgraphOptions& operator=(TemplateSubgraphOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateSubgraphOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const TemplateSubgraphOptions* internal_default_instance() {
    return reinterpret_cast<const TemplateSubgraphOptions*>(
               &_TemplateSubgraphOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(TemplateSubgraphOptions& a, TemplateSubgraphOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateSubgraphOptions* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TemplateSubgraphOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateSubgraphOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateSubgraphOptions>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateSubgraphOptions& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TemplateSubgraphOptions& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateSubgraphOptions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "mediapipe.TemplateSubgraphOptions";
  }
  protected:
  explicit TemplateSubgraphOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDictFieldNumber = 1,
  };
  // optional .mediapipe.TemplateDict dict = 1;
  bool has_dict() const;
  private:
  bool _internal_has_dict() const;
  public:
  void clear_dict();
  const ::mediapipe::TemplateDict& dict() const;
  PROTOBUF_NODISCARD ::mediapipe::TemplateDict* release_dict();
  ::mediapipe::TemplateDict* mutable_dict();
  void set_allocated_dict(::mediapipe::TemplateDict* dict);
  private:
  const ::mediapipe::TemplateDict& _internal_dict() const;
  ::mediapipe::TemplateDict* _internal_mutable_dict();
  public:
  void unsafe_arena_set_allocated_dict(
      ::mediapipe::TemplateDict* dict);
  ::mediapipe::TemplateDict* unsafe_arena_release_dict();

  static const int kExtFieldNumber = 172998261;
  static ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::mediapipe::CalculatorOptions,
      ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::mediapipe::TemplateSubgraphOptions >, 11, false >
    ext;
  // @@protoc_insertion_point(class_scope:mediapipe.TemplateSubgraphOptions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::mediapipe::TemplateDict* dict_;
  friend struct ::TableStruct_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// TemplateExpression

// optional string param = 1;
inline bool TemplateExpression::_internal_has_param() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TemplateExpression::has_param() const {
  return _internal_has_param();
}
inline void TemplateExpression::clear_param() {
  param_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TemplateExpression::param() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateExpression.param)
  return _internal_param();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TemplateExpression::set_param(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mediapipe.TemplateExpression.param)
}
inline std::string* TemplateExpression::mutable_param() {
  std::string* _s = _internal_mutable_param();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateExpression.param)
  return _s;
}
inline const std::string& TemplateExpression::_internal_param() const {
  return param_.Get();
}
inline void TemplateExpression::_internal_set_param(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  param_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TemplateExpression::_internal_mutable_param() {
  _has_bits_[0] |= 0x00000001u;
  return param_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TemplateExpression::release_param() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateExpression.param)
  if (!_internal_has_param()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = param_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (param_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TemplateExpression::set_allocated_param(std::string* param) {
  if (param != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  param_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), param,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (param_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    param_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateExpression.param)
}

// optional string op = 2;
inline bool TemplateExpression::_internal_has_op() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TemplateExpression::has_op() const {
  return _internal_has_op();
}
inline void TemplateExpression::clear_op() {
  op_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& TemplateExpression::op() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateExpression.op)
  return _internal_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TemplateExpression::set_op(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 op_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mediapipe.TemplateExpression.op)
}
inline std::string* TemplateExpression::mutable_op() {
  std::string* _s = _internal_mutable_op();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateExpression.op)
  return _s;
}
inline const std::string& TemplateExpression::_internal_op() const {
  return op_.Get();
}
inline void TemplateExpression::_internal_set_op(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  op_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TemplateExpression::_internal_mutable_op() {
  _has_bits_[0] |= 0x00000002u;
  return op_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TemplateExpression::release_op() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateExpression.op)
  if (!_internal_has_op()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = op_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (op_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    op_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TemplateExpression::set_allocated_op(std::string* op) {
  if (op != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  op_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (op_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    op_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateExpression.op)
}

// repeated .mediapipe.TemplateExpression arg = 3;
inline int TemplateExpression::_internal_arg_size() const {
  return arg_.size();
}
inline int TemplateExpression::arg_size() const {
  return _internal_arg_size();
}
inline void TemplateExpression::clear_arg() {
  arg_.Clear();
}
inline ::mediapipe::TemplateExpression* TemplateExpression::mutable_arg(int index) {
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateExpression.arg)
  return arg_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >*
TemplateExpression::mutable_arg() {
  // @@protoc_insertion_point(field_mutable_list:mediapipe.TemplateExpression.arg)
  return &arg_;
}
inline const ::mediapipe::TemplateExpression& TemplateExpression::_internal_arg(int index) const {
  return arg_.Get(index);
}
inline const ::mediapipe::TemplateExpression& TemplateExpression::arg(int index) const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateExpression.arg)
  return _internal_arg(index);
}
inline ::mediapipe::TemplateExpression* TemplateExpression::_internal_add_arg() {
  return arg_.Add();
}
inline ::mediapipe::TemplateExpression* TemplateExpression::add_arg() {
  ::mediapipe::TemplateExpression* _add = _internal_add_arg();
  // @@protoc_insertion_point(field_add:mediapipe.TemplateExpression.arg)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >&
TemplateExpression::arg() const {
  // @@protoc_insertion_point(field_list:mediapipe.TemplateExpression.arg)
  return arg_;
}

// optional string path = 4;
inline bool TemplateExpression::_internal_has_path() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TemplateExpression::has_path() const {
  return _internal_has_path();
}
inline void TemplateExpression::clear_path() {
  path_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& TemplateExpression::path() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateExpression.path)
  return _internal_path();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TemplateExpression::set_path(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mediapipe.TemplateExpression.path)
}
inline std::string* TemplateExpression::mutable_path() {
  std::string* _s = _internal_mutable_path();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateExpression.path)
  return _s;
}
inline const std::string& TemplateExpression::_internal_path() const {
  return path_.Get();
}
inline void TemplateExpression::_internal_set_path(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TemplateExpression::_internal_mutable_path() {
  _has_bits_[0] |= 0x00000004u;
  return path_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TemplateExpression::release_path() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateExpression.path)
  if (!_internal_has_path()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (path_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TemplateExpression::set_allocated_path(std::string* path) {
  if (path != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  path_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), path,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (path_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateExpression.path)
}

// optional .mediapipe.FieldDescriptorProto.Type field_type = 5;
inline bool TemplateExpression::_internal_has_field_type() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool TemplateExpression::has_field_type() const {
  return _internal_has_field_type();
}
inline void TemplateExpression::clear_field_type() {
  field_type_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::mediapipe::FieldDescriptorProto_Type TemplateExpression::_internal_field_type() const {
  return static_cast< ::mediapipe::FieldDescriptorProto_Type >(field_type_);
}
inline ::mediapipe::FieldDescriptorProto_Type TemplateExpression::field_type() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateExpression.field_type)
  return _internal_field_type();
}
inline void TemplateExpression::_internal_set_field_type(::mediapipe::FieldDescriptorProto_Type value) {
  assert(::mediapipe::FieldDescriptorProto_Type_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  field_type_ = value;
}
inline void TemplateExpression::set_field_type(::mediapipe::FieldDescriptorProto_Type value) {
  _internal_set_field_type(value);
  // @@protoc_insertion_point(field_set:mediapipe.TemplateExpression.field_type)
}

// repeated .mediapipe.FieldDescriptorProto.Type key_type = 6;
inline int TemplateExpression::_internal_key_type_size() const {
  return key_type_.size();
}
inline int TemplateExpression::key_type_size() const {
  return _internal_key_type_size();
}
inline void TemplateExpression::clear_key_type() {
  key_type_.Clear();
}
inline ::mediapipe::FieldDescriptorProto_Type TemplateExpression::_internal_key_type(int index) const {
  return static_cast< ::mediapipe::FieldDescriptorProto_Type >(key_type_.Get(index));
}
inline ::mediapipe::FieldDescriptorProto_Type TemplateExpression::key_type(int index) const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateExpression.key_type)
  return _internal_key_type(index);
}
inline void TemplateExpression::set_key_type(int index, ::mediapipe::FieldDescriptorProto_Type value) {
  assert(::mediapipe::FieldDescriptorProto_Type_IsValid(value));
  key_type_.Set(index, value);
  // @@protoc_insertion_point(field_set:mediapipe.TemplateExpression.key_type)
}
inline void TemplateExpression::_internal_add_key_type(::mediapipe::FieldDescriptorProto_Type value) {
  assert(::mediapipe::FieldDescriptorProto_Type_IsValid(value));
  key_type_.Add(value);
}
inline void TemplateExpression::add_key_type(::mediapipe::FieldDescriptorProto_Type value) {
  _internal_add_key_type(value);
  // @@protoc_insertion_point(field_add:mediapipe.TemplateExpression.key_type)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
TemplateExpression::key_type() const {
  // @@protoc_insertion_point(field_list:mediapipe.TemplateExpression.key_type)
  return key_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
TemplateExpression::_internal_mutable_key_type() {
  return &key_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
TemplateExpression::mutable_key_type() {
  // @@protoc_insertion_point(field_mutable_list:mediapipe.TemplateExpression.key_type)
  return _internal_mutable_key_type();
}

// optional string field_value = 7;
inline bool TemplateExpression::_internal_has_field_value() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool TemplateExpression::has_field_value() const {
  return _internal_has_field_value();
}
inline void TemplateExpression::clear_field_value() {
  field_value_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& TemplateExpression::field_value() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateExpression.field_value)
  return _internal_field_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TemplateExpression::set_field_value(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 field_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mediapipe.TemplateExpression.field_value)
}
inline std::string* TemplateExpression::mutable_field_value() {
  std::string* _s = _internal_mutable_field_value();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateExpression.field_value)
  return _s;
}
inline const std::string& TemplateExpression::_internal_field_value() const {
  return field_value_.Get();
}
inline void TemplateExpression::_internal_set_field_value(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  field_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TemplateExpression::_internal_mutable_field_value() {
  _has_bits_[0] |= 0x00000008u;
  return field_value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TemplateExpression::release_field_value() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateExpression.field_value)
  if (!_internal_has_field_value()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  auto* p = field_value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (field_value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    field_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TemplateExpression::set_allocated_field_value(std::string* field_value) {
  if (field_value != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  field_value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_value,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (field_value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    field_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateExpression.field_value)
}

// -------------------------------------------------------------------

// CalculatorGraphTemplate

// optional .mediapipe.CalculatorGraphConfig config = 1;
inline bool CalculatorGraphTemplate::_internal_has_config() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || config_ != nullptr);
  return value;
}
inline bool CalculatorGraphTemplate::has_config() const {
  return _internal_has_config();
}
inline const ::mediapipe::CalculatorGraphConfig& CalculatorGraphTemplate::_internal_config() const {
  const ::mediapipe::CalculatorGraphConfig* p = config_;
  return p != nullptr ? *p : reinterpret_cast<const ::mediapipe::CalculatorGraphConfig&>(
      ::mediapipe::_CalculatorGraphConfig_default_instance_);
}
inline const ::mediapipe::CalculatorGraphConfig& CalculatorGraphTemplate::config() const {
  // @@protoc_insertion_point(field_get:mediapipe.CalculatorGraphTemplate.config)
  return _internal_config();
}
inline void CalculatorGraphTemplate::unsafe_arena_set_allocated_config(
    ::mediapipe::CalculatorGraphConfig* config) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(config_);
  }
  config_ = config;
  if (config) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mediapipe.CalculatorGraphTemplate.config)
}
inline ::mediapipe::CalculatorGraphConfig* CalculatorGraphTemplate::release_config() {
  _has_bits_[0] &= ~0x00000001u;
  ::mediapipe::CalculatorGraphConfig* temp = config_;
  config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::mediapipe::CalculatorGraphConfig* CalculatorGraphTemplate::unsafe_arena_release_config() {
  // @@protoc_insertion_point(field_release:mediapipe.CalculatorGraphTemplate.config)
  _has_bits_[0] &= ~0x00000001u;
  ::mediapipe::CalculatorGraphConfig* temp = config_;
  config_ = nullptr;
  return temp;
}
inline ::mediapipe::CalculatorGraphConfig* CalculatorGraphTemplate::_internal_mutable_config() {
  _has_bits_[0] |= 0x00000001u;
  if (config_ == nullptr) {
    auto* p = CreateMaybeMessage<::mediapipe::CalculatorGraphConfig>(GetArenaForAllocation());
    config_ = p;
  }
  return config_;
}
inline ::mediapipe::CalculatorGraphConfig* CalculatorGraphTemplate::mutable_config() {
  ::mediapipe::CalculatorGraphConfig* _msg = _internal_mutable_config();
  // @@protoc_insertion_point(field_mutable:mediapipe.CalculatorGraphTemplate.config)
  return _msg;
}
inline void CalculatorGraphTemplate::set_allocated_config(::mediapipe::CalculatorGraphConfig* config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(config_);
  }
  if (config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(config));
    if (message_arena != submessage_arena) {
      config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, config, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  config_ = config;
  // @@protoc_insertion_point(field_set_allocated:mediapipe.CalculatorGraphTemplate.config)
}

// repeated .mediapipe.TemplateExpression rule = 2;
inline int CalculatorGraphTemplate::_internal_rule_size() const {
  return rule_.size();
}
inline int CalculatorGraphTemplate::rule_size() const {
  return _internal_rule_size();
}
inline void CalculatorGraphTemplate::clear_rule() {
  rule_.Clear();
}
inline ::mediapipe::TemplateExpression* CalculatorGraphTemplate::mutable_rule(int index) {
  // @@protoc_insertion_point(field_mutable:mediapipe.CalculatorGraphTemplate.rule)
  return rule_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >*
CalculatorGraphTemplate::mutable_rule() {
  // @@protoc_insertion_point(field_mutable_list:mediapipe.CalculatorGraphTemplate.rule)
  return &rule_;
}
inline const ::mediapipe::TemplateExpression& CalculatorGraphTemplate::_internal_rule(int index) const {
  return rule_.Get(index);
}
inline const ::mediapipe::TemplateExpression& CalculatorGraphTemplate::rule(int index) const {
  // @@protoc_insertion_point(field_get:mediapipe.CalculatorGraphTemplate.rule)
  return _internal_rule(index);
}
inline ::mediapipe::TemplateExpression* CalculatorGraphTemplate::_internal_add_rule() {
  return rule_.Add();
}
inline ::mediapipe::TemplateExpression* CalculatorGraphTemplate::add_rule() {
  ::mediapipe::TemplateExpression* _add = _internal_add_rule();
  // @@protoc_insertion_point(field_add:mediapipe.CalculatorGraphTemplate.rule)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateExpression >&
CalculatorGraphTemplate::rule() const {
  // @@protoc_insertion_point(field_list:mediapipe.CalculatorGraphTemplate.rule)
  return rule_;
}

// -------------------------------------------------------------------

// TemplateArgument

// string str = 1;
inline bool TemplateArgument::_internal_has_str() const {
  return param_value_case() == kStr;
}
inline bool TemplateArgument::has_str() const {
  return _internal_has_str();
}
inline void TemplateArgument::set_has_str() {
  _oneof_case_[0] = kStr;
}
inline void TemplateArgument::clear_str() {
  if (_internal_has_str()) {
    param_value_.str_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_param_value();
  }
}
inline const std::string& TemplateArgument::str() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateArgument.str)
  return _internal_str();
}
template <typename ArgT0, typename... ArgT>
inline void TemplateArgument::set_str(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_str()) {
    clear_param_value();
    set_has_str();
    param_value_.str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  param_value_.str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mediapipe.TemplateArgument.str)
}
inline std::string* TemplateArgument::mutable_str() {
  std::string* _s = _internal_mutable_str();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateArgument.str)
  return _s;
}
inline const std::string& TemplateArgument::_internal_str() const {
  if (_internal_has_str()) {
    return param_value_.str_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void TemplateArgument::_internal_set_str(const std::string& value) {
  if (!_internal_has_str()) {
    clear_param_value();
    set_has_str();
    param_value_.str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  param_value_.str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TemplateArgument::_internal_mutable_str() {
  if (!_internal_has_str()) {
    clear_param_value();
    set_has_str();
    param_value_.str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return param_value_.str_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TemplateArgument::release_str() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateArgument.str)
  if (_internal_has_str()) {
    clear_has_param_value();
    return param_value_.str_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void TemplateArgument::set_allocated_str(std::string* str) {
  if (has_param_value()) {
    clear_param_value();
  }
  if (str != nullptr) {
    set_has_str();
    param_value_.str_.UnsafeSetDefault(str);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(str);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateArgument.str)
}

// double num = 2;
inline bool TemplateArgument::_internal_has_num() const {
  return param_value_case() == kNum;
}
inline bool TemplateArgument::has_num() const {
  return _internal_has_num();
}
inline void TemplateArgument::set_has_num() {
  _oneof_case_[0] = kNum;
}
inline void TemplateArgument::clear_num() {
  if (_internal_has_num()) {
    param_value_.num_ = 0;
    clear_has_param_value();
  }
}
inline double TemplateArgument::_internal_num() const {
  if (_internal_has_num()) {
    return param_value_.num_;
  }
  return 0;
}
inline void TemplateArgument::_internal_set_num(double value) {
  if (!_internal_has_num()) {
    clear_param_value();
    set_has_num();
  }
  param_value_.num_ = value;
}
inline double TemplateArgument::num() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateArgument.num)
  return _internal_num();
}
inline void TemplateArgument::set_num(double value) {
  _internal_set_num(value);
  // @@protoc_insertion_point(field_set:mediapipe.TemplateArgument.num)
}

// .mediapipe.TemplateDict dict = 3;
inline bool TemplateArgument::_internal_has_dict() const {
  return param_value_case() == kDict;
}
inline bool TemplateArgument::has_dict() const {
  return _internal_has_dict();
}
inline void TemplateArgument::set_has_dict() {
  _oneof_case_[0] = kDict;
}
inline void TemplateArgument::clear_dict() {
  if (_internal_has_dict()) {
    if (GetArenaForAllocation() == nullptr) {
      delete param_value_.dict_;
    }
    clear_has_param_value();
  }
}
inline ::mediapipe::TemplateDict* TemplateArgument::release_dict() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateArgument.dict)
  if (_internal_has_dict()) {
    clear_has_param_value();
      ::mediapipe::TemplateDict* temp = param_value_.dict_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    param_value_.dict_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::mediapipe::TemplateDict& TemplateArgument::_internal_dict() const {
  return _internal_has_dict()
      ? *param_value_.dict_
      : reinterpret_cast< ::mediapipe::TemplateDict&>(::mediapipe::_TemplateDict_default_instance_);
}
inline const ::mediapipe::TemplateDict& TemplateArgument::dict() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateArgument.dict)
  return _internal_dict();
}
inline ::mediapipe::TemplateDict* TemplateArgument::unsafe_arena_release_dict() {
  // @@protoc_insertion_point(field_unsafe_arena_release:mediapipe.TemplateArgument.dict)
  if (_internal_has_dict()) {
    clear_has_param_value();
    ::mediapipe::TemplateDict* temp = param_value_.dict_;
    param_value_.dict_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TemplateArgument::unsafe_arena_set_allocated_dict(::mediapipe::TemplateDict* dict) {
  clear_param_value();
  if (dict) {
    set_has_dict();
    param_value_.dict_ = dict;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mediapipe.TemplateArgument.dict)
}
inline ::mediapipe::TemplateDict* TemplateArgument::_internal_mutable_dict() {
  if (!_internal_has_dict()) {
    clear_param_value();
    set_has_dict();
    param_value_.dict_ = CreateMaybeMessage< ::mediapipe::TemplateDict >(GetArenaForAllocation());
  }
  return param_value_.dict_;
}
inline ::mediapipe::TemplateDict* TemplateArgument::mutable_dict() {
  ::mediapipe::TemplateDict* _msg = _internal_mutable_dict();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateArgument.dict)
  return _msg;
}

// repeated .mediapipe.TemplateArgument element = 4;
inline int TemplateArgument::_internal_element_size() const {
  return element_.size();
}
inline int TemplateArgument::element_size() const {
  return _internal_element_size();
}
inline void TemplateArgument::clear_element() {
  element_.Clear();
}
inline ::mediapipe::TemplateArgument* TemplateArgument::mutable_element(int index) {
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateArgument.element)
  return element_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateArgument >*
TemplateArgument::mutable_element() {
  // @@protoc_insertion_point(field_mutable_list:mediapipe.TemplateArgument.element)
  return &element_;
}
inline const ::mediapipe::TemplateArgument& TemplateArgument::_internal_element(int index) const {
  return element_.Get(index);
}
inline const ::mediapipe::TemplateArgument& TemplateArgument::element(int index) const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateArgument.element)
  return _internal_element(index);
}
inline ::mediapipe::TemplateArgument* TemplateArgument::_internal_add_element() {
  return element_.Add();
}
inline ::mediapipe::TemplateArgument* TemplateArgument::add_element() {
  ::mediapipe::TemplateArgument* _add = _internal_add_element();
  // @@protoc_insertion_point(field_add:mediapipe.TemplateArgument.element)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateArgument >&
TemplateArgument::element() const {
  // @@protoc_insertion_point(field_list:mediapipe.TemplateArgument.element)
  return element_;
}

inline bool TemplateArgument::has_param_value() const {
  return param_value_case() != PARAM_VALUE_NOT_SET;
}
inline void TemplateArgument::clear_has_param_value() {
  _oneof_case_[0] = PARAM_VALUE_NOT_SET;
}
inline TemplateArgument::ParamValueCase TemplateArgument::param_value_case() const {
  return TemplateArgument::ParamValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TemplateDict_Parameter

// optional string key = 1;
inline bool TemplateDict_Parameter::_internal_has_key() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TemplateDict_Parameter::has_key() const {
  return _internal_has_key();
}
inline void TemplateDict_Parameter::clear_key() {
  key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TemplateDict_Parameter::key() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateDict.Parameter.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TemplateDict_Parameter::set_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:mediapipe.TemplateDict.Parameter.key)
}
inline std::string* TemplateDict_Parameter::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateDict.Parameter.key)
  return _s;
}
inline const std::string& TemplateDict_Parameter::_internal_key() const {
  return key_.Get();
}
inline void TemplateDict_Parameter::_internal_set_key(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* TemplateDict_Parameter::_internal_mutable_key() {
  _has_bits_[0] |= 0x00000001u;
  return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* TemplateDict_Parameter::release_key() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateDict.Parameter.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TemplateDict_Parameter::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateDict.Parameter.key)
}

// optional .mediapipe.TemplateArgument value = 2;
inline bool TemplateDict_Parameter::_internal_has_value() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || value_ != nullptr);
  return value;
}
inline bool TemplateDict_Parameter::has_value() const {
  return _internal_has_value();
}
inline void TemplateDict_Parameter::clear_value() {
  if (value_ != nullptr) value_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::mediapipe::TemplateArgument& TemplateDict_Parameter::_internal_value() const {
  const ::mediapipe::TemplateArgument* p = value_;
  return p != nullptr ? *p : reinterpret_cast<const ::mediapipe::TemplateArgument&>(
      ::mediapipe::_TemplateArgument_default_instance_);
}
inline const ::mediapipe::TemplateArgument& TemplateDict_Parameter::value() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateDict.Parameter.value)
  return _internal_value();
}
inline void TemplateDict_Parameter::unsafe_arena_set_allocated_value(
    ::mediapipe::TemplateArgument* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  value_ = value;
  if (value) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mediapipe.TemplateDict.Parameter.value)
}
inline ::mediapipe::TemplateArgument* TemplateDict_Parameter::release_value() {
  _has_bits_[0] &= ~0x00000002u;
  ::mediapipe::TemplateArgument* temp = value_;
  value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::mediapipe::TemplateArgument* TemplateDict_Parameter::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateDict.Parameter.value)
  _has_bits_[0] &= ~0x00000002u;
  ::mediapipe::TemplateArgument* temp = value_;
  value_ = nullptr;
  return temp;
}
inline ::mediapipe::TemplateArgument* TemplateDict_Parameter::_internal_mutable_value() {
  _has_bits_[0] |= 0x00000002u;
  if (value_ == nullptr) {
    auto* p = CreateMaybeMessage<::mediapipe::TemplateArgument>(GetArenaForAllocation());
    value_ = p;
  }
  return value_;
}
inline ::mediapipe::TemplateArgument* TemplateDict_Parameter::mutable_value() {
  ::mediapipe::TemplateArgument* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateDict.Parameter.value)
  return _msg;
}
inline void TemplateDict_Parameter::set_allocated_value(::mediapipe::TemplateArgument* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::TemplateArgument>::GetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  value_ = value;
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateDict.Parameter.value)
}

// -------------------------------------------------------------------

// TemplateDict

// repeated .mediapipe.TemplateDict.Parameter arg = 1;
inline int TemplateDict::_internal_arg_size() const {
  return arg_.size();
}
inline int TemplateDict::arg_size() const {
  return _internal_arg_size();
}
inline void TemplateDict::clear_arg() {
  arg_.Clear();
}
inline ::mediapipe::TemplateDict_Parameter* TemplateDict::mutable_arg(int index) {
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateDict.arg)
  return arg_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateDict_Parameter >*
TemplateDict::mutable_arg() {
  // @@protoc_insertion_point(field_mutable_list:mediapipe.TemplateDict.arg)
  return &arg_;
}
inline const ::mediapipe::TemplateDict_Parameter& TemplateDict::_internal_arg(int index) const {
  return arg_.Get(index);
}
inline const ::mediapipe::TemplateDict_Parameter& TemplateDict::arg(int index) const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateDict.arg)
  return _internal_arg(index);
}
inline ::mediapipe::TemplateDict_Parameter* TemplateDict::_internal_add_arg() {
  return arg_.Add();
}
inline ::mediapipe::TemplateDict_Parameter* TemplateDict::add_arg() {
  ::mediapipe::TemplateDict_Parameter* _add = _internal_add_arg();
  // @@protoc_insertion_point(field_add:mediapipe.TemplateDict.arg)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mediapipe::TemplateDict_Parameter >&
TemplateDict::arg() const {
  // @@protoc_insertion_point(field_list:mediapipe.TemplateDict.arg)
  return arg_;
}

// -------------------------------------------------------------------

// TemplateSubgraphOptions

// optional .mediapipe.TemplateDict dict = 1;
inline bool TemplateSubgraphOptions::_internal_has_dict() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || dict_ != nullptr);
  return value;
}
inline bool TemplateSubgraphOptions::has_dict() const {
  return _internal_has_dict();
}
inline void TemplateSubgraphOptions::clear_dict() {
  if (dict_ != nullptr) dict_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::mediapipe::TemplateDict& TemplateSubgraphOptions::_internal_dict() const {
  const ::mediapipe::TemplateDict* p = dict_;
  return p != nullptr ? *p : reinterpret_cast<const ::mediapipe::TemplateDict&>(
      ::mediapipe::_TemplateDict_default_instance_);
}
inline const ::mediapipe::TemplateDict& TemplateSubgraphOptions::dict() const {
  // @@protoc_insertion_point(field_get:mediapipe.TemplateSubgraphOptions.dict)
  return _internal_dict();
}
inline void TemplateSubgraphOptions::unsafe_arena_set_allocated_dict(
    ::mediapipe::TemplateDict* dict) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dict_);
  }
  dict_ = dict;
  if (dict) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:mediapipe.TemplateSubgraphOptions.dict)
}
inline ::mediapipe::TemplateDict* TemplateSubgraphOptions::release_dict() {
  _has_bits_[0] &= ~0x00000001u;
  ::mediapipe::TemplateDict* temp = dict_;
  dict_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::mediapipe::TemplateDict* TemplateSubgraphOptions::unsafe_arena_release_dict() {
  // @@protoc_insertion_point(field_release:mediapipe.TemplateSubgraphOptions.dict)
  _has_bits_[0] &= ~0x00000001u;
  ::mediapipe::TemplateDict* temp = dict_;
  dict_ = nullptr;
  return temp;
}
inline ::mediapipe::TemplateDict* TemplateSubgraphOptions::_internal_mutable_dict() {
  _has_bits_[0] |= 0x00000001u;
  if (dict_ == nullptr) {
    auto* p = CreateMaybeMessage<::mediapipe::TemplateDict>(GetArenaForAllocation());
    dict_ = p;
  }
  return dict_;
}
inline ::mediapipe::TemplateDict* TemplateSubgraphOptions::mutable_dict() {
  ::mediapipe::TemplateDict* _msg = _internal_mutable_dict();
  // @@protoc_insertion_point(field_mutable:mediapipe.TemplateSubgraphOptions.dict)
  return _msg;
}
inline void TemplateSubgraphOptions::set_allocated_dict(::mediapipe::TemplateDict* dict) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete dict_;
  }
  if (dict) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::TemplateDict>::GetOwningArena(dict);
    if (message_arena != submessage_arena) {
      dict = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dict, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  dict_ = dict;
  // @@protoc_insertion_point(field_set_allocated:mediapipe.TemplateSubgraphOptions.dict)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace mediapipe

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_mediapipe_2fframework_2ftool_2fcalculator_5fgraph_5ftemplate_2eproto