// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: proto/processing/processingModule.proto

#ifndef PROTOBUF_INCLUDED_proto_2fprocessing_2fprocessingModule_2eproto
#define PROTOBUF_INCLUDED_proto_2fprocessing_2fprocessingModule_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < GOOGLE_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/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/inlined_string_field.h>
#include <google/protobuf/metadata.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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_proto_2fprocessing_2fprocessingModule_2eproto 

namespace protobuf_proto_2fprocessing_2fprocessingModule_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[7];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_proto_2fprocessing_2fprocessingModule_2eproto
namespace ubii {
namespace processing {
class ModuleIO;
class ModuleIODefaultTypeInternal;
extern ModuleIODefaultTypeInternal _ModuleIO_default_instance_;
class ProcessingMode;
class ProcessingModeDefaultTypeInternal;
extern ProcessingModeDefaultTypeInternal _ProcessingMode_default_instance_;
class ProcessingMode_Frequency;
class ProcessingMode_FrequencyDefaultTypeInternal;
extern ProcessingMode_FrequencyDefaultTypeInternal _ProcessingMode_Frequency_default_instance_;
class ProcessingMode_Lockstep;
class ProcessingMode_LockstepDefaultTypeInternal;
extern ProcessingMode_LockstepDefaultTypeInternal _ProcessingMode_Lockstep_default_instance_;
class ProcessingMode_TriggerOnInput;
class ProcessingMode_TriggerOnInputDefaultTypeInternal;
extern ProcessingMode_TriggerOnInputDefaultTypeInternal _ProcessingMode_TriggerOnInput_default_instance_;
class ProcessingModule;
class ProcessingModuleDefaultTypeInternal;
extern ProcessingModuleDefaultTypeInternal _ProcessingModule_default_instance_;
class ProcessingModuleList;
class ProcessingModuleListDefaultTypeInternal;
extern ProcessingModuleListDefaultTypeInternal _ProcessingModuleList_default_instance_;
}  // namespace processing
}  // namespace ubii
namespace google {
namespace protobuf {
template<> ::ubii::processing::ModuleIO* Arena::CreateMaybeMessage<::ubii::processing::ModuleIO>(Arena*);
template<> ::ubii::processing::ProcessingMode* Arena::CreateMaybeMessage<::ubii::processing::ProcessingMode>(Arena*);
template<> ::ubii::processing::ProcessingMode_Frequency* Arena::CreateMaybeMessage<::ubii::processing::ProcessingMode_Frequency>(Arena*);
template<> ::ubii::processing::ProcessingMode_Lockstep* Arena::CreateMaybeMessage<::ubii::processing::ProcessingMode_Lockstep>(Arena*);
template<> ::ubii::processing::ProcessingMode_TriggerOnInput* Arena::CreateMaybeMessage<::ubii::processing::ProcessingMode_TriggerOnInput>(Arena*);
template<> ::ubii::processing::ProcessingModule* Arena::CreateMaybeMessage<::ubii::processing::ProcessingModule>(Arena*);
template<> ::ubii::processing::ProcessingModuleList* Arena::CreateMaybeMessage<::ubii::processing::ProcessingModuleList>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace ubii {
namespace processing {

enum ProcessingModule_Status {
  ProcessingModule_Status_INITIALIZED = 0,
  ProcessingModule_Status_CREATED = 1,
  ProcessingModule_Status_PROCESSING = 2,
  ProcessingModule_Status_HALTED = 3,
  ProcessingModule_Status_DESTROYED = 4,
  ProcessingModule_Status_ProcessingModule_Status_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  ProcessingModule_Status_ProcessingModule_Status_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool ProcessingModule_Status_IsValid(int value);
const ProcessingModule_Status ProcessingModule_Status_Status_MIN = ProcessingModule_Status_INITIALIZED;
const ProcessingModule_Status ProcessingModule_Status_Status_MAX = ProcessingModule_Status_DESTROYED;
const int ProcessingModule_Status_Status_ARRAYSIZE = ProcessingModule_Status_Status_MAX + 1;

const ::google::protobuf::EnumDescriptor* ProcessingModule_Status_descriptor();
inline const ::std::string& ProcessingModule_Status_Name(ProcessingModule_Status value) {
  return ::google::protobuf::internal::NameOfEnum(
    ProcessingModule_Status_descriptor(), value);
}
inline bool ProcessingModule_Status_Parse(
    const ::std::string& name, ProcessingModule_Status* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ProcessingModule_Status>(
    ProcessingModule_Status_descriptor(), name, value);
}
enum ProcessingModule_Language {
  ProcessingModule_Language_CPP = 0,
  ProcessingModule_Language_PY = 1,
  ProcessingModule_Language_JS = 2,
  ProcessingModule_Language_CS = 3,
  ProcessingModule_Language_JAVA = 4,
  ProcessingModule_Language_ProcessingModule_Language_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  ProcessingModule_Language_ProcessingModule_Language_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool ProcessingModule_Language_IsValid(int value);
const ProcessingModule_Language ProcessingModule_Language_Language_MIN = ProcessingModule_Language_CPP;
const ProcessingModule_Language ProcessingModule_Language_Language_MAX = ProcessingModule_Language_JAVA;
const int ProcessingModule_Language_Language_ARRAYSIZE = ProcessingModule_Language_Language_MAX + 1;

const ::google::protobuf::EnumDescriptor* ProcessingModule_Language_descriptor();
inline const ::std::string& ProcessingModule_Language_Name(ProcessingModule_Language value) {
  return ::google::protobuf::internal::NameOfEnum(
    ProcessingModule_Language_descriptor(), value);
}
inline bool ProcessingModule_Language_Parse(
    const ::std::string& name, ProcessingModule_Language* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ProcessingModule_Language>(
    ProcessingModule_Language_descriptor(), name, value);
}
// ===================================================================

class ProcessingMode_Frequency : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ubii.processing.ProcessingMode.Frequency) */ {
 public:
  ProcessingMode_Frequency();
  virtual ~ProcessingMode_Frequency();

  ProcessingMode_Frequency(const ProcessingMode_Frequency& from);

  inline ProcessingMode_Frequency& operator=(const ProcessingMode_Frequency& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ProcessingMode_Frequency(ProcessingMode_Frequency&& from) noexcept
    : ProcessingMode_Frequency() {
    *this = ::std::move(from);
  }

  inline ProcessingMode_Frequency& operator=(ProcessingMode_Frequency&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ProcessingMode_Frequency& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcessingMode_Frequency* internal_default_instance() {
    return reinterpret_cast<const ProcessingMode_Frequency*>(
               &_ProcessingMode_Frequency_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(ProcessingMode_Frequency* other);
  friend void swap(ProcessingMode_Frequency& a, ProcessingMode_Frequency& b) {
    a.Swap(&b);
  }

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

  inline ProcessingMode_Frequency* New() const final {
    return CreateMaybeMessage<ProcessingMode_Frequency>(NULL);
  }

  ProcessingMode_Frequency* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ProcessingMode_Frequency>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ProcessingMode_Frequency& from);
  void MergeFrom(const ProcessingMode_Frequency& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProcessingMode_Frequency* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // int32 hertz = 1;
  void clear_hertz();
  static const int kHertzFieldNumber = 1;
  ::google::protobuf::int32 hertz() const;
  void set_hertz(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:ubii.processing.ProcessingMode.Frequency)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int32 hertz_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_proto_2fprocessing_2fprocessingModule_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ProcessingMode_Lockstep : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ubii.processing.ProcessingMode.Lockstep) */ {
 public:
  ProcessingMode_Lockstep();
  virtual ~ProcessingMode_Lockstep();

  ProcessingMode_Lockstep(const ProcessingMode_Lockstep& from);

  inline ProcessingMode_Lockstep& operator=(const ProcessingMode_Lockstep& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ProcessingMode_Lockstep(ProcessingMode_Lockstep&& from) noexcept
    : ProcessingMode_Lockstep() {
    *this = ::std::move(from);
  }

  inline ProcessingMode_Lockstep& operator=(ProcessingMode_Lockstep&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ProcessingMode_Lockstep& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcessingMode_Lockstep* internal_default_instance() {
    return reinterpret_cast<const ProcessingMode_Lockstep*>(
               &_ProcessingMode_Lockstep_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(ProcessingMode_Lockstep* other);
  friend void swap(ProcessingMode_Lockstep& a, ProcessingMode_Lockstep& b) {
    a.Swap(&b);
  }

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

  inline ProcessingMode_Lockstep* New() const final {
    return CreateMaybeMessage<ProcessingMode_Lockstep>(NULL);
  }

  ProcessingMode_Lockstep* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ProcessingMode_Lockstep>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ProcessingMode_Lockstep& from);
  void MergeFrom(const ProcessingMode_Lockstep& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProcessingMode_Lockstep* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string process_request_endpoint = 1;
  void clear_process_request_endpoint();
  static const int kProcessRequestEndpointFieldNumber = 1;
  const ::std::string& process_request_endpoint() const;
  void set_process_request_endpoint(const ::std::string& value);
  #if LANG_CXX11
  void set_process_request_endpoint(::std::string&& value);
  #endif
  void set_process_request_endpoint(const char* value);
  void set_process_request_endpoint(const char* value, size_t size);
  ::std::string* mutable_process_request_endpoint();
  ::std::string* release_process_request_endpoint();
  void set_allocated_process_request_endpoint(::std::string* process_request_endpoint);

  // @@protoc_insertion_point(class_scope:ubii.processing.ProcessingMode.Lockstep)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr process_request_endpoint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_proto_2fprocessing_2fprocessingModule_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ProcessingMode_TriggerOnInput : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ubii.processing.ProcessingMode.TriggerOnInput) */ {
 public:
  ProcessingMode_TriggerOnInput();
  virtual ~ProcessingMode_TriggerOnInput();

  ProcessingMode_TriggerOnInput(const ProcessingMode_TriggerOnInput& from);

  inline ProcessingMode_TriggerOnInput& operator=(const ProcessingMode_TriggerOnInput& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ProcessingMode_TriggerOnInput(ProcessingMode_TriggerOnInput&& from) noexcept
    : ProcessingMode_TriggerOnInput() {
    *this = ::std::move(from);
  }

  inline ProcessingMode_TriggerOnInput& operator=(ProcessingMode_TriggerOnInput&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ProcessingMode_TriggerOnInput& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcessingMode_TriggerOnInput* internal_default_instance() {
    return reinterpret_cast<const ProcessingMode_TriggerOnInput*>(
               &_ProcessingMode_TriggerOnInput_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(ProcessingMode_TriggerOnInput* other);
  friend void swap(ProcessingMode_TriggerOnInput& a, ProcessingMode_TriggerOnInput& b) {
    a.Swap(&b);
  }

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

  inline ProcessingMode_TriggerOnInput* New() const final {
    return CreateMaybeMessage<ProcessingMode_TriggerOnInput>(NULL);
  }

  ProcessingMode_TriggerOnInput* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ProcessingMode_TriggerOnInput>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ProcessingMode_TriggerOnInput& from);
  void MergeFrom(const ProcessingMode_TriggerOnInput& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProcessingMode_TriggerOnInput* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // int32 min_delay_ms = 1;
  void clear_min_delay_ms();
  static const int kMinDelayMsFieldNumber = 1;
  ::google::protobuf::int32 min_delay_ms() const;
  void set_min_delay_ms(::google::protobuf::int32 value);

  // bool all_inputs_need_update = 2;
  void clear_all_inputs_need_update();
  static const int kAllInputsNeedUpdateFieldNumber = 2;
  bool all_inputs_need_update() const;
  void set_all_inputs_need_update(bool value);

  // @@protoc_insertion_point(class_scope:ubii.processing.ProcessingMode.TriggerOnInput)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int32 min_delay_ms_;
  bool all_inputs_need_update_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_proto_2fprocessing_2fprocessingModule_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ProcessingMode : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ubii.processing.ProcessingMode) */ {
 public:
  ProcessingMode();
  virtual ~ProcessingMode();

  ProcessingMode(const ProcessingMode& from);

  inline ProcessingMode& operator=(const ProcessingMode& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ProcessingMode(ProcessingMode&& from) noexcept
    : ProcessingMode() {
    *this = ::std::move(from);
  }

  inline ProcessingMode& operator=(ProcessingMode&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ProcessingMode& default_instance();

  enum ModeCase {
    kFrequency = 1,
    kLockstep = 2,
    kTriggerOnInput = 3,
    MODE_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcessingMode* internal_default_instance() {
    return reinterpret_cast<const ProcessingMode*>(
               &_ProcessingMode_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(ProcessingMode* other);
  friend void swap(ProcessingMode& a, ProcessingMode& b) {
    a.Swap(&b);
  }

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

  inline ProcessingMode* New() const final {
    return CreateMaybeMessage<ProcessingMode>(NULL);
  }

  ProcessingMode* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ProcessingMode>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ProcessingMode& from);
  void MergeFrom(const ProcessingMode& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProcessingMode* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

  typedef ProcessingMode_Frequency Frequency;
  typedef ProcessingMode_Lockstep Lockstep;
  typedef ProcessingMode_TriggerOnInput TriggerOnInput;

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

  // .ubii.processing.ProcessingMode.Frequency frequency = 1;
  bool has_frequency() const;
  void clear_frequency();
  static const int kFrequencyFieldNumber = 1;
  private:
  const ::ubii::processing::ProcessingMode_Frequency& _internal_frequency() const;
  public:
  const ::ubii::processing::ProcessingMode_Frequency& frequency() const;
  ::ubii::processing::ProcessingMode_Frequency* release_frequency();
  ::ubii::processing::ProcessingMode_Frequency* mutable_frequency();
  void set_allocated_frequency(::ubii::processing::ProcessingMode_Frequency* frequency);

  // .ubii.processing.ProcessingMode.Lockstep lockstep = 2;
  bool has_lockstep() const;
  void clear_lockstep();
  static const int kLockstepFieldNumber = 2;
  private:
  const ::ubii::processing::ProcessingMode_Lockstep& _internal_lockstep() const;
  public:
  const ::ubii::processing::ProcessingMode_Lockstep& lockstep() const;
  ::ubii::processing::ProcessingMode_Lockstep* release_lockstep();
  ::ubii::processing::ProcessingMode_Lockstep* mutable_lockstep();
  void set_allocated_lockstep(::ubii::processing::ProcessingMode_Lockstep* lockstep);

  // .ubii.processing.ProcessingMode.TriggerOnInput trigger_on_input = 3;
  bool has_trigger_on_input() const;
  void clear_trigger_on_input();
  static const int kTriggerOnInputFieldNumber = 3;
  private:
  const ::ubii::processing::ProcessingMode_TriggerOnInput& _internal_trigger_on_input() const;
  public:
  const ::ubii::processing::ProcessingMode_TriggerOnInput& trigger_on_input() const;
  ::ubii::processing::ProcessingMode_TriggerOnInput* release_trigger_on_input();
  ::ubii::processing::ProcessingMode_TriggerOnInput* mutable_trigger_on_input();
  void set_allocated_trigger_on_input(::ubii::processing::ProcessingMode_TriggerOnInput* trigger_on_input);

  void clear_mode();
  ModeCase mode_case() const;
  // @@protoc_insertion_point(class_scope:ubii.processing.ProcessingMode)
 private:
  void set_has_frequency();
  void set_has_lockstep();
  void set_has_trigger_on_input();

  inline bool has_mode() const;
  inline void clear_has_mode();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  union ModeUnion {
    ModeUnion() {}
    ::ubii::processing::ProcessingMode_Frequency* frequency_;
    ::ubii::processing::ProcessingMode_Lockstep* lockstep_;
    ::ubii::processing::ProcessingMode_TriggerOnInput* trigger_on_input_;
  } mode_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_proto_2fprocessing_2fprocessingModule_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ModuleIO : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ubii.processing.ModuleIO) */ {
 public:
  ModuleIO();
  virtual ~ModuleIO();

  ModuleIO(const ModuleIO& from);

  inline ModuleIO& operator=(const ModuleIO& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ModuleIO(ModuleIO&& from) noexcept
    : ModuleIO() {
    *this = ::std::move(from);
  }

  inline ModuleIO& operator=(ModuleIO&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ModuleIO& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ModuleIO* internal_default_instance() {
    return reinterpret_cast<const ModuleIO*>(
               &_ModuleIO_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(ModuleIO* other);
  friend void swap(ModuleIO& a, ModuleIO& b) {
    a.Swap(&b);
  }

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

  inline ModuleIO* New() const final {
    return CreateMaybeMessage<ModuleIO>(NULL);
  }

  ModuleIO* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ModuleIO>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ModuleIO& from);
  void MergeFrom(const ModuleIO& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ModuleIO* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string internal_name = 1;
  void clear_internal_name();
  static const int kInternalNameFieldNumber = 1;
  const ::std::string& internal_name() const;
  void set_internal_name(const ::std::string& value);
  #if LANG_CXX11
  void set_internal_name(::std::string&& value);
  #endif
  void set_internal_name(const char* value);
  void set_internal_name(const char* value, size_t size);
  ::std::string* mutable_internal_name();
  ::std::string* release_internal_name();
  void set_allocated_internal_name(::std::string* internal_name);

  // string message_format = 2;
  void clear_message_format();
  static const int kMessageFormatFieldNumber = 2;
  const ::std::string& message_format() const;
  void set_message_format(const ::std::string& value);
  #if LANG_CXX11
  void set_message_format(::std::string&& value);
  #endif
  void set_message_format(const char* value);
  void set_message_format(const char* value, size_t size);
  ::std::string* mutable_message_format();
  ::std::string* release_message_format();
  void set_allocated_message_format(::std::string* message_format);

  // @@protoc_insertion_point(class_scope:ubii.processing.ModuleIO)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr internal_name_;
  ::google::protobuf::internal::ArenaStringPtr message_format_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_proto_2fprocessing_2fprocessingModule_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ProcessingModule : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ubii.processing.ProcessingModule) */ {
 public:
  ProcessingModule();
  virtual ~ProcessingModule();

  ProcessingModule(const ProcessingModule& from);

  inline ProcessingModule& operator=(const ProcessingModule& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ProcessingModule(ProcessingModule&& from) noexcept
    : ProcessingModule() {
    *this = ::std::move(from);
  }

  inline ProcessingModule& operator=(ProcessingModule&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ProcessingModule& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcessingModule* internal_default_instance() {
    return reinterpret_cast<const ProcessingModule*>(
               &_ProcessingModule_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(ProcessingModule* other);
  friend void swap(ProcessingModule& a, ProcessingModule& b) {
    a.Swap(&b);
  }

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

  inline ProcessingModule* New() const final {
    return CreateMaybeMessage<ProcessingModule>(NULL);
  }

  ProcessingModule* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ProcessingModule>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ProcessingModule& from);
  void MergeFrom(const ProcessingModule& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProcessingModule* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

  typedef ProcessingModule_Status Status;
  static const Status INITIALIZED =
    ProcessingModule_Status_INITIALIZED;
  static const Status CREATED =
    ProcessingModule_Status_CREATED;
  static const Status PROCESSING =
    ProcessingModule_Status_PROCESSING;
  static const Status HALTED =
    ProcessingModule_Status_HALTED;
  static const Status DESTROYED =
    ProcessingModule_Status_DESTROYED;
  static inline bool Status_IsValid(int value) {
    return ProcessingModule_Status_IsValid(value);
  }
  static const Status Status_MIN =
    ProcessingModule_Status_Status_MIN;
  static const Status Status_MAX =
    ProcessingModule_Status_Status_MAX;
  static const int Status_ARRAYSIZE =
    ProcessingModule_Status_Status_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Status_descriptor() {
    return ProcessingModule_Status_descriptor();
  }
  static inline const ::std::string& Status_Name(Status value) {
    return ProcessingModule_Status_Name(value);
  }
  static inline bool Status_Parse(const ::std::string& name,
      Status* value) {
    return ProcessingModule_Status_Parse(name, value);
  }

  typedef ProcessingModule_Language Language;
  static const Language CPP =
    ProcessingModule_Language_CPP;
  static const Language PY =
    ProcessingModule_Language_PY;
  static const Language JS =
    ProcessingModule_Language_JS;
  static const Language CS =
    ProcessingModule_Language_CS;
  static const Language JAVA =
    ProcessingModule_Language_JAVA;
  static inline bool Language_IsValid(int value) {
    return ProcessingModule_Language_IsValid(value);
  }
  static const Language Language_MIN =
    ProcessingModule_Language_Language_MIN;
  static const Language Language_MAX =
    ProcessingModule_Language_Language_MAX;
  static const int Language_ARRAYSIZE =
    ProcessingModule_Language_Language_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Language_descriptor() {
    return ProcessingModule_Language_descriptor();
  }
  static inline const ::std::string& Language_Name(Language value) {
    return ProcessingModule_Language_Name(value);
  }
  static inline bool Language_Parse(const ::std::string& name,
      Language* value) {
    return ProcessingModule_Language_Parse(name, value);
  }

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

  // repeated string authors = 3;
  int authors_size() const;
  void clear_authors();
  static const int kAuthorsFieldNumber = 3;
  const ::std::string& authors(int index) const;
  ::std::string* mutable_authors(int index);
  void set_authors(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_authors(int index, ::std::string&& value);
  #endif
  void set_authors(int index, const char* value);
  void set_authors(int index, const char* value, size_t size);
  ::std::string* add_authors();
  void add_authors(const ::std::string& value);
  #if LANG_CXX11
  void add_authors(::std::string&& value);
  #endif
  void add_authors(const char* value);
  void add_authors(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& authors() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_authors();

  // repeated string tags = 4;
  int tags_size() const;
  void clear_tags();
  static const int kTagsFieldNumber = 4;
  const ::std::string& tags(int index) const;
  ::std::string* mutable_tags(int index);
  void set_tags(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_tags(int index, ::std::string&& value);
  #endif
  void set_tags(int index, const char* value);
  void set_tags(int index, const char* value, size_t size);
  ::std::string* add_tags();
  void add_tags(const ::std::string& value);
  #if LANG_CXX11
  void add_tags(::std::string&& value);
  #endif
  void add_tags(const char* value);
  void add_tags(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& tags() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_tags();

  // repeated .ubii.processing.ModuleIO inputs = 10;
  int inputs_size() const;
  void clear_inputs();
  static const int kInputsFieldNumber = 10;
  ::ubii::processing::ModuleIO* mutable_inputs(int index);
  ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >*
      mutable_inputs();
  const ::ubii::processing::ModuleIO& inputs(int index) const;
  ::ubii::processing::ModuleIO* add_inputs();
  const ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >&
      inputs() const;

  // repeated .ubii.processing.ModuleIO outputs = 11;
  int outputs_size() const;
  void clear_outputs();
  static const int kOutputsFieldNumber = 11;
  ::ubii::processing::ModuleIO* mutable_outputs(int index);
  ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >*
      mutable_outputs();
  const ::ubii::processing::ModuleIO& outputs(int index) const;
  ::ubii::processing::ModuleIO* add_outputs();
  const ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >&
      outputs() const;

  // string id = 1;
  void clear_id();
  static const int kIdFieldNumber = 1;
  const ::std::string& id() const;
  void set_id(const ::std::string& value);
  #if LANG_CXX11
  void set_id(::std::string&& value);
  #endif
  void set_id(const char* value);
  void set_id(const char* value, size_t size);
  ::std::string* mutable_id();
  ::std::string* release_id();
  void set_allocated_id(::std::string* id);

  // string name = 2;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // string description = 5;
  void clear_description();
  static const int kDescriptionFieldNumber = 5;
  const ::std::string& description() const;
  void set_description(const ::std::string& value);
  #if LANG_CXX11
  void set_description(::std::string&& value);
  #endif
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  ::std::string* mutable_description();
  ::std::string* release_description();
  void set_allocated_description(::std::string* description);

  // string node_id = 6;
  void clear_node_id();
  static const int kNodeIdFieldNumber = 6;
  const ::std::string& node_id() const;
  void set_node_id(const ::std::string& value);
  #if LANG_CXX11
  void set_node_id(::std::string&& value);
  #endif
  void set_node_id(const char* value);
  void set_node_id(const char* value, size_t size);
  ::std::string* mutable_node_id();
  ::std::string* release_node_id();
  void set_allocated_node_id(::std::string* node_id);

  // string session_id = 7;
  void clear_session_id();
  static const int kSessionIdFieldNumber = 7;
  const ::std::string& session_id() const;
  void set_session_id(const ::std::string& value);
  #if LANG_CXX11
  void set_session_id(::std::string&& value);
  #endif
  void set_session_id(const char* value);
  void set_session_id(const char* value, size_t size);
  ::std::string* mutable_session_id();
  ::std::string* release_session_id();
  void set_allocated_session_id(::std::string* session_id);

  // string on_processing_stringified = 13;
  void clear_on_processing_stringified();
  static const int kOnProcessingStringifiedFieldNumber = 13;
  const ::std::string& on_processing_stringified() const;
  void set_on_processing_stringified(const ::std::string& value);
  #if LANG_CXX11
  void set_on_processing_stringified(::std::string&& value);
  #endif
  void set_on_processing_stringified(const char* value);
  void set_on_processing_stringified(const char* value, size_t size);
  ::std::string* mutable_on_processing_stringified();
  ::std::string* release_on_processing_stringified();
  void set_allocated_on_processing_stringified(::std::string* on_processing_stringified);

  // string on_created_stringified = 14;
  void clear_on_created_stringified();
  static const int kOnCreatedStringifiedFieldNumber = 14;
  const ::std::string& on_created_stringified() const;
  void set_on_created_stringified(const ::std::string& value);
  #if LANG_CXX11
  void set_on_created_stringified(::std::string&& value);
  #endif
  void set_on_created_stringified(const char* value);
  void set_on_created_stringified(const char* value, size_t size);
  ::std::string* mutable_on_created_stringified();
  ::std::string* release_on_created_stringified();
  void set_allocated_on_created_stringified(::std::string* on_created_stringified);

  // string on_halted_stringified = 15;
  void clear_on_halted_stringified();
  static const int kOnHaltedStringifiedFieldNumber = 15;
  const ::std::string& on_halted_stringified() const;
  void set_on_halted_stringified(const ::std::string& value);
  #if LANG_CXX11
  void set_on_halted_stringified(::std::string&& value);
  #endif
  void set_on_halted_stringified(const char* value);
  void set_on_halted_stringified(const char* value, size_t size);
  ::std::string* mutable_on_halted_stringified();
  ::std::string* release_on_halted_stringified();
  void set_allocated_on_halted_stringified(::std::string* on_halted_stringified);

  // string on_destroyed_stringified = 16;
  void clear_on_destroyed_stringified();
  static const int kOnDestroyedStringifiedFieldNumber = 16;
  const ::std::string& on_destroyed_stringified() const;
  void set_on_destroyed_stringified(const ::std::string& value);
  #if LANG_CXX11
  void set_on_destroyed_stringified(::std::string&& value);
  #endif
  void set_on_destroyed_stringified(const char* value);
  void set_on_destroyed_stringified(const char* value, size_t size);
  ::std::string* mutable_on_destroyed_stringified();
  ::std::string* release_on_destroyed_stringified();
  void set_allocated_on_destroyed_stringified(::std::string* on_destroyed_stringified);

  // .ubii.processing.ProcessingMode processing_mode = 9;
  bool has_processing_mode() const;
  void clear_processing_mode();
  static const int kProcessingModeFieldNumber = 9;
  private:
  const ::ubii::processing::ProcessingMode& _internal_processing_mode() const;
  public:
  const ::ubii::processing::ProcessingMode& processing_mode() const;
  ::ubii::processing::ProcessingMode* release_processing_mode();
  ::ubii::processing::ProcessingMode* mutable_processing_mode();
  void set_allocated_processing_mode(::ubii::processing::ProcessingMode* processing_mode);

  // .ubii.processing.ProcessingModule.Status status = 8;
  void clear_status();
  static const int kStatusFieldNumber = 8;
  ::ubii::processing::ProcessingModule_Status status() const;
  void set_status(::ubii::processing::ProcessingModule_Status value);

  // .ubii.processing.ProcessingModule.Language language = 12;
  void clear_language();
  static const int kLanguageFieldNumber = 12;
  ::ubii::processing::ProcessingModule_Language language() const;
  void set_language(::ubii::processing::ProcessingModule_Language value);

  // @@protoc_insertion_point(class_scope:ubii.processing.ProcessingModule)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::std::string> authors_;
  ::google::protobuf::RepeatedPtrField< ::std::string> tags_;
  ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO > inputs_;
  ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO > outputs_;
  ::google::protobuf::internal::ArenaStringPtr id_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr description_;
  ::google::protobuf::internal::ArenaStringPtr node_id_;
  ::google::protobuf::internal::ArenaStringPtr session_id_;
  ::google::protobuf::internal::ArenaStringPtr on_processing_stringified_;
  ::google::protobuf::internal::ArenaStringPtr on_created_stringified_;
  ::google::protobuf::internal::ArenaStringPtr on_halted_stringified_;
  ::google::protobuf::internal::ArenaStringPtr on_destroyed_stringified_;
  ::ubii::processing::ProcessingMode* processing_mode_;
  int status_;
  int language_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_proto_2fprocessing_2fprocessingModule_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ProcessingModuleList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ubii.processing.ProcessingModuleList) */ {
 public:
  ProcessingModuleList();
  virtual ~ProcessingModuleList();

  ProcessingModuleList(const ProcessingModuleList& from);

  inline ProcessingModuleList& operator=(const ProcessingModuleList& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ProcessingModuleList(ProcessingModuleList&& from) noexcept
    : ProcessingModuleList() {
    *this = ::std::move(from);
  }

  inline ProcessingModuleList& operator=(ProcessingModuleList&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ProcessingModuleList& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcessingModuleList* internal_default_instance() {
    return reinterpret_cast<const ProcessingModuleList*>(
               &_ProcessingModuleList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(ProcessingModuleList* other);
  friend void swap(ProcessingModuleList& a, ProcessingModuleList& b) {
    a.Swap(&b);
  }

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

  inline ProcessingModuleList* New() const final {
    return CreateMaybeMessage<ProcessingModuleList>(NULL);
  }

  ProcessingModuleList* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ProcessingModuleList>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ProcessingModuleList& from);
  void MergeFrom(const ProcessingModuleList& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProcessingModuleList* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .ubii.processing.ProcessingModule elements = 1;
  int elements_size() const;
  void clear_elements();
  static const int kElementsFieldNumber = 1;
  ::ubii::processing::ProcessingModule* mutable_elements(int index);
  ::google::protobuf::RepeatedPtrField< ::ubii::processing::ProcessingModule >*
      mutable_elements();
  const ::ubii::processing::ProcessingModule& elements(int index) const;
  ::ubii::processing::ProcessingModule* add_elements();
  const ::google::protobuf::RepeatedPtrField< ::ubii::processing::ProcessingModule >&
      elements() const;

  // @@protoc_insertion_point(class_scope:ubii.processing.ProcessingModuleList)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::ubii::processing::ProcessingModule > elements_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_proto_2fprocessing_2fprocessingModule_2eproto::TableStruct;
};
// ===================================================================


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

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

// int32 hertz = 1;
inline void ProcessingMode_Frequency::clear_hertz() {
  hertz_ = 0;
}
inline ::google::protobuf::int32 ProcessingMode_Frequency::hertz() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingMode.Frequency.hertz)
  return hertz_;
}
inline void ProcessingMode_Frequency::set_hertz(::google::protobuf::int32 value) {
  
  hertz_ = value;
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingMode.Frequency.hertz)
}

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

// ProcessingMode_Lockstep

// string process_request_endpoint = 1;
inline void ProcessingMode_Lockstep::clear_process_request_endpoint() {
  process_request_endpoint_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingMode_Lockstep::process_request_endpoint() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
  return process_request_endpoint_.GetNoArena();
}
inline void ProcessingMode_Lockstep::set_process_request_endpoint(const ::std::string& value) {
  
  process_request_endpoint_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
}
#if LANG_CXX11
inline void ProcessingMode_Lockstep::set_process_request_endpoint(::std::string&& value) {
  
  process_request_endpoint_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
}
#endif
inline void ProcessingMode_Lockstep::set_process_request_endpoint(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  process_request_endpoint_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
}
inline void ProcessingMode_Lockstep::set_process_request_endpoint(const char* value, size_t size) {
  
  process_request_endpoint_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
}
inline ::std::string* ProcessingMode_Lockstep::mutable_process_request_endpoint() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
  return process_request_endpoint_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingMode_Lockstep::release_process_request_endpoint() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
  
  return process_request_endpoint_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingMode_Lockstep::set_allocated_process_request_endpoint(::std::string* process_request_endpoint) {
  if (process_request_endpoint != NULL) {
    
  } else {
    
  }
  process_request_endpoint_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), process_request_endpoint);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingMode.Lockstep.process_request_endpoint)
}

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

// ProcessingMode_TriggerOnInput

// int32 min_delay_ms = 1;
inline void ProcessingMode_TriggerOnInput::clear_min_delay_ms() {
  min_delay_ms_ = 0;
}
inline ::google::protobuf::int32 ProcessingMode_TriggerOnInput::min_delay_ms() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingMode.TriggerOnInput.min_delay_ms)
  return min_delay_ms_;
}
inline void ProcessingMode_TriggerOnInput::set_min_delay_ms(::google::protobuf::int32 value) {
  
  min_delay_ms_ = value;
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingMode.TriggerOnInput.min_delay_ms)
}

// bool all_inputs_need_update = 2;
inline void ProcessingMode_TriggerOnInput::clear_all_inputs_need_update() {
  all_inputs_need_update_ = false;
}
inline bool ProcessingMode_TriggerOnInput::all_inputs_need_update() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingMode.TriggerOnInput.all_inputs_need_update)
  return all_inputs_need_update_;
}
inline void ProcessingMode_TriggerOnInput::set_all_inputs_need_update(bool value) {
  
  all_inputs_need_update_ = value;
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingMode.TriggerOnInput.all_inputs_need_update)
}

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

// ProcessingMode

// .ubii.processing.ProcessingMode.Frequency frequency = 1;
inline bool ProcessingMode::has_frequency() const {
  return mode_case() == kFrequency;
}
inline void ProcessingMode::set_has_frequency() {
  _oneof_case_[0] = kFrequency;
}
inline void ProcessingMode::clear_frequency() {
  if (has_frequency()) {
    delete mode_.frequency_;
    clear_has_mode();
  }
}
inline const ::ubii::processing::ProcessingMode_Frequency& ProcessingMode::_internal_frequency() const {
  return *mode_.frequency_;
}
inline ::ubii::processing::ProcessingMode_Frequency* ProcessingMode::release_frequency() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingMode.frequency)
  if (has_frequency()) {
    clear_has_mode();
      ::ubii::processing::ProcessingMode_Frequency* temp = mode_.frequency_;
    mode_.frequency_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::ubii::processing::ProcessingMode_Frequency& ProcessingMode::frequency() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingMode.frequency)
  return has_frequency()
      ? *mode_.frequency_
      : *reinterpret_cast< ::ubii::processing::ProcessingMode_Frequency*>(&::ubii::processing::_ProcessingMode_Frequency_default_instance_);
}
inline ::ubii::processing::ProcessingMode_Frequency* ProcessingMode::mutable_frequency() {
  if (!has_frequency()) {
    clear_mode();
    set_has_frequency();
    mode_.frequency_ = CreateMaybeMessage< ::ubii::processing::ProcessingMode_Frequency >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingMode.frequency)
  return mode_.frequency_;
}

// .ubii.processing.ProcessingMode.Lockstep lockstep = 2;
inline bool ProcessingMode::has_lockstep() const {
  return mode_case() == kLockstep;
}
inline void ProcessingMode::set_has_lockstep() {
  _oneof_case_[0] = kLockstep;
}
inline void ProcessingMode::clear_lockstep() {
  if (has_lockstep()) {
    delete mode_.lockstep_;
    clear_has_mode();
  }
}
inline const ::ubii::processing::ProcessingMode_Lockstep& ProcessingMode::_internal_lockstep() const {
  return *mode_.lockstep_;
}
inline ::ubii::processing::ProcessingMode_Lockstep* ProcessingMode::release_lockstep() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingMode.lockstep)
  if (has_lockstep()) {
    clear_has_mode();
      ::ubii::processing::ProcessingMode_Lockstep* temp = mode_.lockstep_;
    mode_.lockstep_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::ubii::processing::ProcessingMode_Lockstep& ProcessingMode::lockstep() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingMode.lockstep)
  return has_lockstep()
      ? *mode_.lockstep_
      : *reinterpret_cast< ::ubii::processing::ProcessingMode_Lockstep*>(&::ubii::processing::_ProcessingMode_Lockstep_default_instance_);
}
inline ::ubii::processing::ProcessingMode_Lockstep* ProcessingMode::mutable_lockstep() {
  if (!has_lockstep()) {
    clear_mode();
    set_has_lockstep();
    mode_.lockstep_ = CreateMaybeMessage< ::ubii::processing::ProcessingMode_Lockstep >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingMode.lockstep)
  return mode_.lockstep_;
}

// .ubii.processing.ProcessingMode.TriggerOnInput trigger_on_input = 3;
inline bool ProcessingMode::has_trigger_on_input() const {
  return mode_case() == kTriggerOnInput;
}
inline void ProcessingMode::set_has_trigger_on_input() {
  _oneof_case_[0] = kTriggerOnInput;
}
inline void ProcessingMode::clear_trigger_on_input() {
  if (has_trigger_on_input()) {
    delete mode_.trigger_on_input_;
    clear_has_mode();
  }
}
inline const ::ubii::processing::ProcessingMode_TriggerOnInput& ProcessingMode::_internal_trigger_on_input() const {
  return *mode_.trigger_on_input_;
}
inline ::ubii::processing::ProcessingMode_TriggerOnInput* ProcessingMode::release_trigger_on_input() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingMode.trigger_on_input)
  if (has_trigger_on_input()) {
    clear_has_mode();
      ::ubii::processing::ProcessingMode_TriggerOnInput* temp = mode_.trigger_on_input_;
    mode_.trigger_on_input_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::ubii::processing::ProcessingMode_TriggerOnInput& ProcessingMode::trigger_on_input() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingMode.trigger_on_input)
  return has_trigger_on_input()
      ? *mode_.trigger_on_input_
      : *reinterpret_cast< ::ubii::processing::ProcessingMode_TriggerOnInput*>(&::ubii::processing::_ProcessingMode_TriggerOnInput_default_instance_);
}
inline ::ubii::processing::ProcessingMode_TriggerOnInput* ProcessingMode::mutable_trigger_on_input() {
  if (!has_trigger_on_input()) {
    clear_mode();
    set_has_trigger_on_input();
    mode_.trigger_on_input_ = CreateMaybeMessage< ::ubii::processing::ProcessingMode_TriggerOnInput >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingMode.trigger_on_input)
  return mode_.trigger_on_input_;
}

inline bool ProcessingMode::has_mode() const {
  return mode_case() != MODE_NOT_SET;
}
inline void ProcessingMode::clear_has_mode() {
  _oneof_case_[0] = MODE_NOT_SET;
}
inline ProcessingMode::ModeCase ProcessingMode::mode_case() const {
  return ProcessingMode::ModeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ModuleIO

// string internal_name = 1;
inline void ModuleIO::clear_internal_name() {
  internal_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ModuleIO::internal_name() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ModuleIO.internal_name)
  return internal_name_.GetNoArena();
}
inline void ModuleIO::set_internal_name(const ::std::string& value) {
  
  internal_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ModuleIO.internal_name)
}
#if LANG_CXX11
inline void ModuleIO::set_internal_name(::std::string&& value) {
  
  internal_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ModuleIO.internal_name)
}
#endif
inline void ModuleIO::set_internal_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  internal_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ModuleIO.internal_name)
}
inline void ModuleIO::set_internal_name(const char* value, size_t size) {
  
  internal_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ModuleIO.internal_name)
}
inline ::std::string* ModuleIO::mutable_internal_name() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ModuleIO.internal_name)
  return internal_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ModuleIO::release_internal_name() {
  // @@protoc_insertion_point(field_release:ubii.processing.ModuleIO.internal_name)
  
  return internal_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ModuleIO::set_allocated_internal_name(::std::string* internal_name) {
  if (internal_name != NULL) {
    
  } else {
    
  }
  internal_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), internal_name);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ModuleIO.internal_name)
}

// string message_format = 2;
inline void ModuleIO::clear_message_format() {
  message_format_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ModuleIO::message_format() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ModuleIO.message_format)
  return message_format_.GetNoArena();
}
inline void ModuleIO::set_message_format(const ::std::string& value) {
  
  message_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ModuleIO.message_format)
}
#if LANG_CXX11
inline void ModuleIO::set_message_format(::std::string&& value) {
  
  message_format_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ModuleIO.message_format)
}
#endif
inline void ModuleIO::set_message_format(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  message_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ModuleIO.message_format)
}
inline void ModuleIO::set_message_format(const char* value, size_t size) {
  
  message_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ModuleIO.message_format)
}
inline ::std::string* ModuleIO::mutable_message_format() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ModuleIO.message_format)
  return message_format_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ModuleIO::release_message_format() {
  // @@protoc_insertion_point(field_release:ubii.processing.ModuleIO.message_format)
  
  return message_format_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ModuleIO::set_allocated_message_format(::std::string* message_format) {
  if (message_format != NULL) {
    
  } else {
    
  }
  message_format_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message_format);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ModuleIO.message_format)
}

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

// ProcessingModule

// string id = 1;
inline void ProcessingModule::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::id() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.id)
  return id_.GetNoArena();
}
inline void ProcessingModule::set_id(const ::std::string& value) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.id)
}
#if LANG_CXX11
inline void ProcessingModule::set_id(::std::string&& value) {
  
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.id)
}
#endif
inline void ProcessingModule::set_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.id)
}
inline void ProcessingModule::set_id(const char* value, size_t size) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.id)
}
inline ::std::string* ProcessingModule::mutable_id() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_id() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.id)
  
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_id(::std::string* id) {
  if (id != NULL) {
    
  } else {
    
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.id)
}

// string name = 2;
inline void ProcessingModule::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::name() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.name)
  return name_.GetNoArena();
}
inline void ProcessingModule::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.name)
}
#if LANG_CXX11
inline void ProcessingModule::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.name)
}
#endif
inline void ProcessingModule::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.name)
}
inline void ProcessingModule::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.name)
}
inline ::std::string* ProcessingModule::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_name() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.name)
}

// repeated string authors = 3;
inline int ProcessingModule::authors_size() const {
  return authors_.size();
}
inline void ProcessingModule::clear_authors() {
  authors_.Clear();
}
inline const ::std::string& ProcessingModule::authors(int index) const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.authors)
  return authors_.Get(index);
}
inline ::std::string* ProcessingModule::mutable_authors(int index) {
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.authors)
  return authors_.Mutable(index);
}
inline void ProcessingModule::set_authors(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.authors)
  authors_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void ProcessingModule::set_authors(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.authors)
  authors_.Mutable(index)->assign(std::move(value));
}
#endif
inline void ProcessingModule::set_authors(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  authors_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.authors)
}
inline void ProcessingModule::set_authors(int index, const char* value, size_t size) {
  authors_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.authors)
}
inline ::std::string* ProcessingModule::add_authors() {
  // @@protoc_insertion_point(field_add_mutable:ubii.processing.ProcessingModule.authors)
  return authors_.Add();
}
inline void ProcessingModule::add_authors(const ::std::string& value) {
  authors_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:ubii.processing.ProcessingModule.authors)
}
#if LANG_CXX11
inline void ProcessingModule::add_authors(::std::string&& value) {
  authors_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:ubii.processing.ProcessingModule.authors)
}
#endif
inline void ProcessingModule::add_authors(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  authors_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:ubii.processing.ProcessingModule.authors)
}
inline void ProcessingModule::add_authors(const char* value, size_t size) {
  authors_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:ubii.processing.ProcessingModule.authors)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ProcessingModule::authors() const {
  // @@protoc_insertion_point(field_list:ubii.processing.ProcessingModule.authors)
  return authors_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ProcessingModule::mutable_authors() {
  // @@protoc_insertion_point(field_mutable_list:ubii.processing.ProcessingModule.authors)
  return &authors_;
}

// repeated string tags = 4;
inline int ProcessingModule::tags_size() const {
  return tags_.size();
}
inline void ProcessingModule::clear_tags() {
  tags_.Clear();
}
inline const ::std::string& ProcessingModule::tags(int index) const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.tags)
  return tags_.Get(index);
}
inline ::std::string* ProcessingModule::mutable_tags(int index) {
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.tags)
  return tags_.Mutable(index);
}
inline void ProcessingModule::set_tags(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.tags)
  tags_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void ProcessingModule::set_tags(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.tags)
  tags_.Mutable(index)->assign(std::move(value));
}
#endif
inline void ProcessingModule::set_tags(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  tags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.tags)
}
inline void ProcessingModule::set_tags(int index, const char* value, size_t size) {
  tags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.tags)
}
inline ::std::string* ProcessingModule::add_tags() {
  // @@protoc_insertion_point(field_add_mutable:ubii.processing.ProcessingModule.tags)
  return tags_.Add();
}
inline void ProcessingModule::add_tags(const ::std::string& value) {
  tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:ubii.processing.ProcessingModule.tags)
}
#if LANG_CXX11
inline void ProcessingModule::add_tags(::std::string&& value) {
  tags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:ubii.processing.ProcessingModule.tags)
}
#endif
inline void ProcessingModule::add_tags(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:ubii.processing.ProcessingModule.tags)
}
inline void ProcessingModule::add_tags(const char* value, size_t size) {
  tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:ubii.processing.ProcessingModule.tags)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
ProcessingModule::tags() const {
  // @@protoc_insertion_point(field_list:ubii.processing.ProcessingModule.tags)
  return tags_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
ProcessingModule::mutable_tags() {
  // @@protoc_insertion_point(field_mutable_list:ubii.processing.ProcessingModule.tags)
  return &tags_;
}

// string description = 5;
inline void ProcessingModule::clear_description() {
  description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::description() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.description)
  return description_.GetNoArena();
}
inline void ProcessingModule::set_description(const ::std::string& value) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.description)
}
#if LANG_CXX11
inline void ProcessingModule::set_description(::std::string&& value) {
  
  description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.description)
}
#endif
inline void ProcessingModule::set_description(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.description)
}
inline void ProcessingModule::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.description)
}
inline ::std::string* ProcessingModule::mutable_description() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.description)
  return description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_description() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.description)
  
  return description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_description(::std::string* description) {
  if (description != NULL) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.description)
}

// string node_id = 6;
inline void ProcessingModule::clear_node_id() {
  node_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::node_id() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.node_id)
  return node_id_.GetNoArena();
}
inline void ProcessingModule::set_node_id(const ::std::string& value) {
  
  node_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.node_id)
}
#if LANG_CXX11
inline void ProcessingModule::set_node_id(::std::string&& value) {
  
  node_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.node_id)
}
#endif
inline void ProcessingModule::set_node_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  node_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.node_id)
}
inline void ProcessingModule::set_node_id(const char* value, size_t size) {
  
  node_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.node_id)
}
inline ::std::string* ProcessingModule::mutable_node_id() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.node_id)
  return node_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_node_id() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.node_id)
  
  return node_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_node_id(::std::string* node_id) {
  if (node_id != NULL) {
    
  } else {
    
  }
  node_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), node_id);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.node_id)
}

// string session_id = 7;
inline void ProcessingModule::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::session_id() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.session_id)
  return session_id_.GetNoArena();
}
inline void ProcessingModule::set_session_id(const ::std::string& value) {
  
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.session_id)
}
#if LANG_CXX11
inline void ProcessingModule::set_session_id(::std::string&& value) {
  
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.session_id)
}
#endif
inline void ProcessingModule::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.session_id)
}
inline void ProcessingModule::set_session_id(const char* value, size_t size) {
  
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.session_id)
}
inline ::std::string* ProcessingModule::mutable_session_id() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_session_id() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.session_id)
  
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    
  } else {
    
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.session_id)
}

// .ubii.processing.ProcessingModule.Status status = 8;
inline void ProcessingModule::clear_status() {
  status_ = 0;
}
inline ::ubii::processing::ProcessingModule_Status ProcessingModule::status() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.status)
  return static_cast< ::ubii::processing::ProcessingModule_Status >(status_);
}
inline void ProcessingModule::set_status(::ubii::processing::ProcessingModule_Status value) {
  
  status_ = value;
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.status)
}

// .ubii.processing.ProcessingMode processing_mode = 9;
inline bool ProcessingModule::has_processing_mode() const {
  return this != internal_default_instance() && processing_mode_ != NULL;
}
inline void ProcessingModule::clear_processing_mode() {
  if (GetArenaNoVirtual() == NULL && processing_mode_ != NULL) {
    delete processing_mode_;
  }
  processing_mode_ = NULL;
}
inline const ::ubii::processing::ProcessingMode& ProcessingModule::_internal_processing_mode() const {
  return *processing_mode_;
}
inline const ::ubii::processing::ProcessingMode& ProcessingModule::processing_mode() const {
  const ::ubii::processing::ProcessingMode* p = processing_mode_;
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.processing_mode)
  return p != NULL ? *p : *reinterpret_cast<const ::ubii::processing::ProcessingMode*>(
      &::ubii::processing::_ProcessingMode_default_instance_);
}
inline ::ubii::processing::ProcessingMode* ProcessingModule::release_processing_mode() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.processing_mode)
  
  ::ubii::processing::ProcessingMode* temp = processing_mode_;
  processing_mode_ = NULL;
  return temp;
}
inline ::ubii::processing::ProcessingMode* ProcessingModule::mutable_processing_mode() {
  
  if (processing_mode_ == NULL) {
    auto* p = CreateMaybeMessage<::ubii::processing::ProcessingMode>(GetArenaNoVirtual());
    processing_mode_ = p;
  }
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.processing_mode)
  return processing_mode_;
}
inline void ProcessingModule::set_allocated_processing_mode(::ubii::processing::ProcessingMode* processing_mode) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete processing_mode_;
  }
  if (processing_mode) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      processing_mode = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, processing_mode, submessage_arena);
    }
    
  } else {
    
  }
  processing_mode_ = processing_mode;
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.processing_mode)
}

// repeated .ubii.processing.ModuleIO inputs = 10;
inline int ProcessingModule::inputs_size() const {
  return inputs_.size();
}
inline void ProcessingModule::clear_inputs() {
  inputs_.Clear();
}
inline ::ubii::processing::ModuleIO* ProcessingModule::mutable_inputs(int index) {
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.inputs)
  return inputs_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >*
ProcessingModule::mutable_inputs() {
  // @@protoc_insertion_point(field_mutable_list:ubii.processing.ProcessingModule.inputs)
  return &inputs_;
}
inline const ::ubii::processing::ModuleIO& ProcessingModule::inputs(int index) const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.inputs)
  return inputs_.Get(index);
}
inline ::ubii::processing::ModuleIO* ProcessingModule::add_inputs() {
  // @@protoc_insertion_point(field_add:ubii.processing.ProcessingModule.inputs)
  return inputs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >&
ProcessingModule::inputs() const {
  // @@protoc_insertion_point(field_list:ubii.processing.ProcessingModule.inputs)
  return inputs_;
}

// repeated .ubii.processing.ModuleIO outputs = 11;
inline int ProcessingModule::outputs_size() const {
  return outputs_.size();
}
inline void ProcessingModule::clear_outputs() {
  outputs_.Clear();
}
inline ::ubii::processing::ModuleIO* ProcessingModule::mutable_outputs(int index) {
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.outputs)
  return outputs_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >*
ProcessingModule::mutable_outputs() {
  // @@protoc_insertion_point(field_mutable_list:ubii.processing.ProcessingModule.outputs)
  return &outputs_;
}
inline const ::ubii::processing::ModuleIO& ProcessingModule::outputs(int index) const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.outputs)
  return outputs_.Get(index);
}
inline ::ubii::processing::ModuleIO* ProcessingModule::add_outputs() {
  // @@protoc_insertion_point(field_add:ubii.processing.ProcessingModule.outputs)
  return outputs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::ubii::processing::ModuleIO >&
ProcessingModule::outputs() const {
  // @@protoc_insertion_point(field_list:ubii.processing.ProcessingModule.outputs)
  return outputs_;
}

// .ubii.processing.ProcessingModule.Language language = 12;
inline void ProcessingModule::clear_language() {
  language_ = 0;
}
inline ::ubii::processing::ProcessingModule_Language ProcessingModule::language() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.language)
  return static_cast< ::ubii::processing::ProcessingModule_Language >(language_);
}
inline void ProcessingModule::set_language(::ubii::processing::ProcessingModule_Language value) {
  
  language_ = value;
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.language)
}

// string on_processing_stringified = 13;
inline void ProcessingModule::clear_on_processing_stringified() {
  on_processing_stringified_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::on_processing_stringified() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.on_processing_stringified)
  return on_processing_stringified_.GetNoArena();
}
inline void ProcessingModule::set_on_processing_stringified(const ::std::string& value) {
  
  on_processing_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.on_processing_stringified)
}
#if LANG_CXX11
inline void ProcessingModule::set_on_processing_stringified(::std::string&& value) {
  
  on_processing_stringified_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.on_processing_stringified)
}
#endif
inline void ProcessingModule::set_on_processing_stringified(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  on_processing_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.on_processing_stringified)
}
inline void ProcessingModule::set_on_processing_stringified(const char* value, size_t size) {
  
  on_processing_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.on_processing_stringified)
}
inline ::std::string* ProcessingModule::mutable_on_processing_stringified() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.on_processing_stringified)
  return on_processing_stringified_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_on_processing_stringified() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.on_processing_stringified)
  
  return on_processing_stringified_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_on_processing_stringified(::std::string* on_processing_stringified) {
  if (on_processing_stringified != NULL) {
    
  } else {
    
  }
  on_processing_stringified_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), on_processing_stringified);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.on_processing_stringified)
}

// string on_created_stringified = 14;
inline void ProcessingModule::clear_on_created_stringified() {
  on_created_stringified_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::on_created_stringified() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.on_created_stringified)
  return on_created_stringified_.GetNoArena();
}
inline void ProcessingModule::set_on_created_stringified(const ::std::string& value) {
  
  on_created_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.on_created_stringified)
}
#if LANG_CXX11
inline void ProcessingModule::set_on_created_stringified(::std::string&& value) {
  
  on_created_stringified_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.on_created_stringified)
}
#endif
inline void ProcessingModule::set_on_created_stringified(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  on_created_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.on_created_stringified)
}
inline void ProcessingModule::set_on_created_stringified(const char* value, size_t size) {
  
  on_created_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.on_created_stringified)
}
inline ::std::string* ProcessingModule::mutable_on_created_stringified() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.on_created_stringified)
  return on_created_stringified_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_on_created_stringified() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.on_created_stringified)
  
  return on_created_stringified_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_on_created_stringified(::std::string* on_created_stringified) {
  if (on_created_stringified != NULL) {
    
  } else {
    
  }
  on_created_stringified_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), on_created_stringified);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.on_created_stringified)
}

// string on_halted_stringified = 15;
inline void ProcessingModule::clear_on_halted_stringified() {
  on_halted_stringified_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::on_halted_stringified() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.on_halted_stringified)
  return on_halted_stringified_.GetNoArena();
}
inline void ProcessingModule::set_on_halted_stringified(const ::std::string& value) {
  
  on_halted_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.on_halted_stringified)
}
#if LANG_CXX11
inline void ProcessingModule::set_on_halted_stringified(::std::string&& value) {
  
  on_halted_stringified_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.on_halted_stringified)
}
#endif
inline void ProcessingModule::set_on_halted_stringified(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  on_halted_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.on_halted_stringified)
}
inline void ProcessingModule::set_on_halted_stringified(const char* value, size_t size) {
  
  on_halted_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.on_halted_stringified)
}
inline ::std::string* ProcessingModule::mutable_on_halted_stringified() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.on_halted_stringified)
  return on_halted_stringified_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_on_halted_stringified() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.on_halted_stringified)
  
  return on_halted_stringified_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_on_halted_stringified(::std::string* on_halted_stringified) {
  if (on_halted_stringified != NULL) {
    
  } else {
    
  }
  on_halted_stringified_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), on_halted_stringified);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.on_halted_stringified)
}

// string on_destroyed_stringified = 16;
inline void ProcessingModule::clear_on_destroyed_stringified() {
  on_destroyed_stringified_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ProcessingModule::on_destroyed_stringified() const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModule.on_destroyed_stringified)
  return on_destroyed_stringified_.GetNoArena();
}
inline void ProcessingModule::set_on_destroyed_stringified(const ::std::string& value) {
  
  on_destroyed_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ubii.processing.ProcessingModule.on_destroyed_stringified)
}
#if LANG_CXX11
inline void ProcessingModule::set_on_destroyed_stringified(::std::string&& value) {
  
  on_destroyed_stringified_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ubii.processing.ProcessingModule.on_destroyed_stringified)
}
#endif
inline void ProcessingModule::set_on_destroyed_stringified(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  on_destroyed_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ubii.processing.ProcessingModule.on_destroyed_stringified)
}
inline void ProcessingModule::set_on_destroyed_stringified(const char* value, size_t size) {
  
  on_destroyed_stringified_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ubii.processing.ProcessingModule.on_destroyed_stringified)
}
inline ::std::string* ProcessingModule::mutable_on_destroyed_stringified() {
  
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModule.on_destroyed_stringified)
  return on_destroyed_stringified_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessingModule::release_on_destroyed_stringified() {
  // @@protoc_insertion_point(field_release:ubii.processing.ProcessingModule.on_destroyed_stringified)
  
  return on_destroyed_stringified_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessingModule::set_allocated_on_destroyed_stringified(::std::string* on_destroyed_stringified) {
  if (on_destroyed_stringified != NULL) {
    
  } else {
    
  }
  on_destroyed_stringified_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), on_destroyed_stringified);
  // @@protoc_insertion_point(field_set_allocated:ubii.processing.ProcessingModule.on_destroyed_stringified)
}

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

// ProcessingModuleList

// repeated .ubii.processing.ProcessingModule elements = 1;
inline int ProcessingModuleList::elements_size() const {
  return elements_.size();
}
inline void ProcessingModuleList::clear_elements() {
  elements_.Clear();
}
inline ::ubii::processing::ProcessingModule* ProcessingModuleList::mutable_elements(int index) {
  // @@protoc_insertion_point(field_mutable:ubii.processing.ProcessingModuleList.elements)
  return elements_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::ubii::processing::ProcessingModule >*
ProcessingModuleList::mutable_elements() {
  // @@protoc_insertion_point(field_mutable_list:ubii.processing.ProcessingModuleList.elements)
  return &elements_;
}
inline const ::ubii::processing::ProcessingModule& ProcessingModuleList::elements(int index) const {
  // @@protoc_insertion_point(field_get:ubii.processing.ProcessingModuleList.elements)
  return elements_.Get(index);
}
inline ::ubii::processing::ProcessingModule* ProcessingModuleList::add_elements() {
  // @@protoc_insertion_point(field_add:ubii.processing.ProcessingModuleList.elements)
  return elements_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::ubii::processing::ProcessingModule >&
ProcessingModuleList::elements() const {
  // @@protoc_insertion_point(field_list:ubii.processing.ProcessingModuleList.elements)
  return elements_;
}

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace processing
}  // namespace ubii

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::ubii::processing::ProcessingModule_Status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ubii::processing::ProcessingModule_Status>() {
  return ::ubii::processing::ProcessingModule_Status_descriptor();
}
template <> struct is_proto_enum< ::ubii::processing::ProcessingModule_Language> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ubii::processing::ProcessingModule_Language>() {
  return ::ubii::processing::ProcessingModule_Language_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_proto_2fprocessing_2fprocessingModule_2eproto
