wiselib.testing/external_interface/iphone/proto/WSNAppMessages.pb.h

Go to the documentation of this file.

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

#ifndef PROTOBUF_WSNAppMessages_2eproto__INCLUDED
#define PROTOBUF_WSNAppMessages_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 2003000
#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 2003000 < 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/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
// @@protoc_insertion_point(includes)

namespace de {
namespace uniluebeck {
namespace itm {
namespace tr {
namespace runtime {
namespace wsnapp {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_WSNAppMessages_2eproto();
void protobuf_AssignDesc_WSNAppMessages_2eproto();
void protobuf_ShutdownFile_WSNAppMessages_2eproto();

class ListenerManagement;
class RequestStatus;
class RequestStatus_Status;
class Program;
class Program_ProgramMetaData;
class Notification;
class Message;
class SetVirtualLinkRequest;
class DestroyVirtualLinkRequest;
class DisablePhysicalLink;
class EnablePhysicalLink;
class OperationInvocation;

enum ListenerManagement_Operation {
  ListenerManagement_Operation_REGISTER = 1,
  ListenerManagement_Operation_UNREGISTER = 2
};
bool ListenerManagement_Operation_IsValid(int value);
const ListenerManagement_Operation ListenerManagement_Operation_Operation_MIN = ListenerManagement_Operation_REGISTER;
const ListenerManagement_Operation ListenerManagement_Operation_Operation_MAX = ListenerManagement_Operation_UNREGISTER;
const int ListenerManagement_Operation_Operation_ARRAYSIZE = ListenerManagement_Operation_Operation_MAX + 1;

const ::google::protobuf::EnumDescriptor* ListenerManagement_Operation_descriptor();
inline const ::std::string& ListenerManagement_Operation_Name(ListenerManagement_Operation value) {
  return ::google::protobuf::internal::NameOfEnum(
    ListenerManagement_Operation_descriptor(), value);
}
inline bool ListenerManagement_Operation_Parse(
    const ::std::string& name, ListenerManagement_Operation* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ListenerManagement_Operation>(
    ListenerManagement_Operation_descriptor(), name, value);
}
enum OperationInvocation_Operation {
  OperationInvocation_Operation_SEND = 0,
  OperationInvocation_Operation_ARE_NODES_ALIVE = 1,
  OperationInvocation_Operation_FLASH_PROGRAMS = 2,
  OperationInvocation_Operation_RESET_NODES = 3,
  OperationInvocation_Operation_SET_VIRTUAL_LINK = 4,
  OperationInvocation_Operation_DESTROY_VIRTUAL_LINK = 5,
  OperationInvocation_Operation_DISABLE_NODE = 6,
  OperationInvocation_Operation_ENABLE_NODE = 7,
  OperationInvocation_Operation_DISABLE_PHYSICAL_LINK = 8,
  OperationInvocation_Operation_ENABLE_PHYSICAL_LINK = 9
};
bool OperationInvocation_Operation_IsValid(int value);
const OperationInvocation_Operation OperationInvocation_Operation_Operation_MIN = OperationInvocation_Operation_SEND;
const OperationInvocation_Operation OperationInvocation_Operation_Operation_MAX = OperationInvocation_Operation_ENABLE_PHYSICAL_LINK;
const int OperationInvocation_Operation_Operation_ARRAYSIZE = OperationInvocation_Operation_Operation_MAX + 1;

const ::google::protobuf::EnumDescriptor* OperationInvocation_Operation_descriptor();
inline const ::std::string& OperationInvocation_Operation_Name(OperationInvocation_Operation value) {
  return ::google::protobuf::internal::NameOfEnum(
    OperationInvocation_Operation_descriptor(), value);
}
inline bool OperationInvocation_Operation_Parse(
    const ::std::string& name, OperationInvocation_Operation* value) {
  return ::google::protobuf::internal::ParseNamedEnum<OperationInvocation_Operation>(
    OperationInvocation_Operation_descriptor(), name, value);
}
// ===================================================================

class ListenerManagement : public ::google::protobuf::Message {
 public:
  ListenerManagement();
  virtual ~ListenerManagement();
  
  ListenerManagement(const ListenerManagement& from);
  
  inline ListenerManagement& operator=(const ListenerManagement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ListenerManagement& default_instance();
  
  void Swap(ListenerManagement* other);
  
  // implements Message ----------------------------------------------
  
  ListenerManagement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ListenerManagement& from);
  void MergeFrom(const ListenerManagement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ListenerManagement_Operation Operation;
  static const Operation REGISTER = ListenerManagement_Operation_REGISTER;
  static const Operation UNREGISTER = ListenerManagement_Operation_UNREGISTER;
  static inline bool Operation_IsValid(int value) {
    return ListenerManagement_Operation_IsValid(value);
  }
  static const Operation Operation_MIN =
    ListenerManagement_Operation_Operation_MIN;
  static const Operation Operation_MAX =
    ListenerManagement_Operation_Operation_MAX;
  static const int Operation_ARRAYSIZE =
    ListenerManagement_Operation_Operation_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Operation_descriptor() {
    return ListenerManagement_Operation_descriptor();
  }
  static inline const ::std::string& Operation_Name(Operation value) {
    return ListenerManagement_Operation_Name(value);
  }
  static inline bool Operation_Parse(const ::std::string& name,
      Operation* value) {
    return ListenerManagement_Operation_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required .de.uniluebeck.itm.tr.runtime.wsnapp.ListenerManagement.Operation operation = 1;
  inline bool has_operation() const;
  inline void clear_operation();
  static const int kOperationFieldNumber = 1;
  inline ::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation operation() const;
  inline void set_operation(::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation value);
  
  // required string nodeName = 2;
  inline bool has_nodename() const;
  inline void clear_nodename();
  static const int kNodeNameFieldNumber = 2;
  inline const ::std::string& nodename() const;
  inline void set_nodename(const ::std::string& value);
  inline void set_nodename(const char* value);
  inline void set_nodename(const char* value, size_t size);
  inline ::std::string* mutable_nodename();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.ListenerManagement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int operation_;
  ::std::string* nodename_;
  static const ::std::string _default_nodename_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static ListenerManagement* default_instance_;
};
// -------------------------------------------------------------------

class RequestStatus_Status : public ::google::protobuf::Message {
 public:
  RequestStatus_Status();
  virtual ~RequestStatus_Status();
  
  RequestStatus_Status(const RequestStatus_Status& from);
  
  inline RequestStatus_Status& operator=(const RequestStatus_Status& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const RequestStatus_Status& default_instance();
  
  void Swap(RequestStatus_Status* other);
  
  // implements Message ----------------------------------------------
  
  RequestStatus_Status* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RequestStatus_Status& from);
  void MergeFrom(const RequestStatus_Status& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string nodeId = 1;
  inline bool has_nodeid() const;
  inline void clear_nodeid();
  static const int kNodeIdFieldNumber = 1;
  inline const ::std::string& nodeid() const;
  inline void set_nodeid(const ::std::string& value);
  inline void set_nodeid(const char* value);
  inline void set_nodeid(const char* value, size_t size);
  inline ::std::string* mutable_nodeid();
  
  // optional int32 value = 2;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 2;
  inline ::google::protobuf::int32 value() const;
  inline void set_value(::google::protobuf::int32 value);
  
  // optional string msg = 3;
  inline bool has_msg() const;
  inline void clear_msg();
  static const int kMsgFieldNumber = 3;
  inline const ::std::string& msg() const;
  inline void set_msg(const ::std::string& value);
  inline void set_msg(const char* value);
  inline void set_msg(const char* value, size_t size);
  inline ::std::string* mutable_msg();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.RequestStatus.Status)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* nodeid_;
  static const ::std::string _default_nodeid_;
  ::google::protobuf::int32 value_;
  ::std::string* msg_;
  static const ::std::string _default_msg_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static RequestStatus_Status* default_instance_;
};
// -------------------------------------------------------------------

class RequestStatus : public ::google::protobuf::Message {
 public:
  RequestStatus();
  virtual ~RequestStatus();
  
  RequestStatus(const RequestStatus& from);
  
  inline RequestStatus& operator=(const RequestStatus& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const RequestStatus& default_instance();
  
  void Swap(RequestStatus* other);
  
  // implements Message ----------------------------------------------
  
  RequestStatus* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RequestStatus& from);
  void MergeFrom(const RequestStatus& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef RequestStatus_Status Status;
  
  // accessors -------------------------------------------------------
  
  // required .de.uniluebeck.itm.tr.runtime.wsnapp.RequestStatus.Status status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline const ::de::uniluebeck::itm::tr::runtime::wsnapp::RequestStatus_Status& status() const;
  inline ::de::uniluebeck::itm::tr::runtime::wsnapp::RequestStatus_Status* mutable_status();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.RequestStatus)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::de::uniluebeck::itm::tr::runtime::wsnapp::RequestStatus_Status* status_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static RequestStatus* default_instance_;
};
// -------------------------------------------------------------------

class Program_ProgramMetaData : public ::google::protobuf::Message {
 public:
  Program_ProgramMetaData();
  virtual ~Program_ProgramMetaData();
  
  Program_ProgramMetaData(const Program_ProgramMetaData& from);
  
  inline Program_ProgramMetaData& operator=(const Program_ProgramMetaData& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Program_ProgramMetaData& default_instance();
  
  void Swap(Program_ProgramMetaData* other);
  
  // implements Message ----------------------------------------------
  
  Program_ProgramMetaData* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Program_ProgramMetaData& from);
  void MergeFrom(const Program_ProgramMetaData& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string version = 1;
  inline bool has_version() const;
  inline void clear_version();
  static const int kVersionFieldNumber = 1;
  inline const ::std::string& version() const;
  inline void set_version(const ::std::string& value);
  inline void set_version(const char* value);
  inline void set_version(const char* value, size_t size);
  inline ::std::string* mutable_version();
  
  // required string name = 2;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 2;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  
  // required string platform = 3;
  inline bool has_platform() const;
  inline void clear_platform();
  static const int kPlatformFieldNumber = 3;
  inline const ::std::string& platform() const;
  inline void set_platform(const ::std::string& value);
  inline void set_platform(const char* value);
  inline void set_platform(const char* value, size_t size);
  inline ::std::string* mutable_platform();
  
  // required string other = 4;
  inline bool has_other() const;
  inline void clear_other();
  static const int kOtherFieldNumber = 4;
  inline const ::std::string& other() const;
  inline void set_other(const ::std::string& value);
  inline void set_other(const char* value);
  inline void set_other(const char* value, size_t size);
  inline ::std::string* mutable_other();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.Program.ProgramMetaData)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* version_;
  static const ::std::string _default_version_;
  ::std::string* name_;
  static const ::std::string _default_name_;
  ::std::string* platform_;
  static const ::std::string _default_platform_;
  ::std::string* other_;
  static const ::std::string _default_other_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Program_ProgramMetaData* default_instance_;
};
// -------------------------------------------------------------------

class Program : public ::google::protobuf::Message {
 public:
  Program();
  virtual ~Program();
  
  Program(const Program& from);
  
  inline Program& operator=(const Program& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Program& default_instance();
  
  void Swap(Program* other);
  
  // implements Message ----------------------------------------------
  
  Program* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Program& from);
  void MergeFrom(const Program& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef Program_ProgramMetaData ProgramMetaData;
  
  // accessors -------------------------------------------------------
  
  // required bytes program = 1;
  inline bool has_program() const;
  inline void clear_program();
  static const int kProgramFieldNumber = 1;
  inline const ::std::string& program() const;
  inline void set_program(const ::std::string& value);
  inline void set_program(const char* value);
  inline void set_program(const void* value, size_t size);
  inline ::std::string* mutable_program();
  
  // optional .de.uniluebeck.itm.tr.runtime.wsnapp.Program.ProgramMetaData metaData = 2;
  inline bool has_metadata() const;
  inline void clear_metadata();
  static const int kMetaDataFieldNumber = 2;
  inline const ::de::uniluebeck::itm::tr::runtime::wsnapp::Program_ProgramMetaData& metadata() const;
  inline ::de::uniluebeck::itm::tr::runtime::wsnapp::Program_ProgramMetaData* mutable_metadata();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.Program)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* program_;
  static const ::std::string _default_program_;
  ::de::uniluebeck::itm::tr::runtime::wsnapp::Program_ProgramMetaData* metadata_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Program* default_instance_;
};
// -------------------------------------------------------------------

class Notification : public ::google::protobuf::Message {
 public:
  Notification();
  virtual ~Notification();
  
  Notification(const Notification& from);
  
  inline Notification& operator=(const Notification& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Notification& default_instance();
  
  void Swap(Notification* other);
  
  // implements Message ----------------------------------------------
  
  Notification* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Notification& from);
  void MergeFrom(const Notification& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string message = 1;
  inline bool has_message() const;
  inline void clear_message();
  static const int kMessageFieldNumber = 1;
  inline const ::std::string& message() const;
  inline void set_message(const ::std::string& value);
  inline void set_message(const char* value);
  inline void set_message(const char* value, size_t size);
  inline ::std::string* mutable_message();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.Notification)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* message_;
  static const ::std::string _default_message_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Notification* default_instance_;
};
// -------------------------------------------------------------------

class Message : public ::google::protobuf::Message {
 public:
  Message();
  virtual ~Message();
  
  Message(const Message& from);
  
  inline Message& operator=(const Message& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Message& default_instance();
  
  void Swap(Message* other);
  
  // implements Message ----------------------------------------------
  
  Message* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Message& from);
  void MergeFrom(const Message& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string sourceNodeId = 1;
  inline bool has_sourcenodeid() const;
  inline void clear_sourcenodeid();
  static const int kSourceNodeIdFieldNumber = 1;
  inline const ::std::string& sourcenodeid() const;
  inline void set_sourcenodeid(const ::std::string& value);
  inline void set_sourcenodeid(const char* value);
  inline void set_sourcenodeid(const char* value, size_t size);
  inline ::std::string* mutable_sourcenodeid();
  
  // required string timestamp = 2;
  inline bool has_timestamp() const;
  inline void clear_timestamp();
  static const int kTimestampFieldNumber = 2;
  inline const ::std::string& timestamp() const;
  inline void set_timestamp(const ::std::string& value);
  inline void set_timestamp(const char* value);
  inline void set_timestamp(const char* value, size_t size);
  inline ::std::string* mutable_timestamp();
  
  // required bytes binaryData = 3;
  inline bool has_binarydata() const;
  inline void clear_binarydata();
  static const int kBinaryDataFieldNumber = 3;
  inline const ::std::string& binarydata() const;
  inline void set_binarydata(const ::std::string& value);
  inline void set_binarydata(const char* value);
  inline void set_binarydata(const void* value, size_t size);
  inline ::std::string* mutable_binarydata();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.Message)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* sourcenodeid_;
  static const ::std::string _default_sourcenodeid_;
  ::std::string* timestamp_;
  static const ::std::string _default_timestamp_;
  ::std::string* binarydata_;
  static const ::std::string _default_binarydata_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Message* default_instance_;
};
// -------------------------------------------------------------------

class SetVirtualLinkRequest : public ::google::protobuf::Message {
 public:
  SetVirtualLinkRequest();
  virtual ~SetVirtualLinkRequest();
  
  SetVirtualLinkRequest(const SetVirtualLinkRequest& from);
  
  inline SetVirtualLinkRequest& operator=(const SetVirtualLinkRequest& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const SetVirtualLinkRequest& default_instance();
  
  void Swap(SetVirtualLinkRequest* other);
  
  // implements Message ----------------------------------------------
  
  SetVirtualLinkRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SetVirtualLinkRequest& from);
  void MergeFrom(const SetVirtualLinkRequest& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string sourceNode = 1;
  inline bool has_sourcenode() const;
  inline void clear_sourcenode();
  static const int kSourceNodeFieldNumber = 1;
  inline const ::std::string& sourcenode() const;
  inline void set_sourcenode(const ::std::string& value);
  inline void set_sourcenode(const char* value);
  inline void set_sourcenode(const char* value, size_t size);
  inline ::std::string* mutable_sourcenode();
  
  // required string targetNode = 2;
  inline bool has_targetnode() const;
  inline void clear_targetnode();
  static const int kTargetNodeFieldNumber = 2;
  inline const ::std::string& targetnode() const;
  inline void set_targetnode(const ::std::string& value);
  inline void set_targetnode(const char* value);
  inline void set_targetnode(const char* value, size_t size);
  inline ::std::string* mutable_targetnode();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.SetVirtualLinkRequest)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* sourcenode_;
  static const ::std::string _default_sourcenode_;
  ::std::string* targetnode_;
  static const ::std::string _default_targetnode_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static SetVirtualLinkRequest* default_instance_;
};
// -------------------------------------------------------------------

class DestroyVirtualLinkRequest : public ::google::protobuf::Message {
 public:
  DestroyVirtualLinkRequest();
  virtual ~DestroyVirtualLinkRequest();
  
  DestroyVirtualLinkRequest(const DestroyVirtualLinkRequest& from);
  
  inline DestroyVirtualLinkRequest& operator=(const DestroyVirtualLinkRequest& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DestroyVirtualLinkRequest& default_instance();
  
  void Swap(DestroyVirtualLinkRequest* other);
  
  // implements Message ----------------------------------------------
  
  DestroyVirtualLinkRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DestroyVirtualLinkRequest& from);
  void MergeFrom(const DestroyVirtualLinkRequest& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string sourceNode = 1;
  inline bool has_sourcenode() const;
  inline void clear_sourcenode();
  static const int kSourceNodeFieldNumber = 1;
  inline const ::std::string& sourcenode() const;
  inline void set_sourcenode(const ::std::string& value);
  inline void set_sourcenode(const char* value);
  inline void set_sourcenode(const char* value, size_t size);
  inline ::std::string* mutable_sourcenode();
  
  // required string targetNode = 2;
  inline bool has_targetnode() const;
  inline void clear_targetnode();
  static const int kTargetNodeFieldNumber = 2;
  inline const ::std::string& targetnode() const;
  inline void set_targetnode(const ::std::string& value);
  inline void set_targetnode(const char* value);
  inline void set_targetnode(const char* value, size_t size);
  inline ::std::string* mutable_targetnode();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.DestroyVirtualLinkRequest)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* sourcenode_;
  static const ::std::string _default_sourcenode_;
  ::std::string* targetnode_;
  static const ::std::string _default_targetnode_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DestroyVirtualLinkRequest* default_instance_;
};
// -------------------------------------------------------------------

class DisablePhysicalLink : public ::google::protobuf::Message {
 public:
  DisablePhysicalLink();
  virtual ~DisablePhysicalLink();
  
  DisablePhysicalLink(const DisablePhysicalLink& from);
  
  inline DisablePhysicalLink& operator=(const DisablePhysicalLink& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DisablePhysicalLink& default_instance();
  
  void Swap(DisablePhysicalLink* other);
  
  // implements Message ----------------------------------------------
  
  DisablePhysicalLink* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DisablePhysicalLink& from);
  void MergeFrom(const DisablePhysicalLink& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string nodeB = 2;
  inline bool has_nodeb() const;
  inline void clear_nodeb();
  static const int kNodeBFieldNumber = 2;
  inline const ::std::string& nodeb() const;
  inline void set_nodeb(const ::std::string& value);
  inline void set_nodeb(const char* value);
  inline void set_nodeb(const char* value, size_t size);
  inline ::std::string* mutable_nodeb();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.DisablePhysicalLink)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* nodeb_;
  static const ::std::string _default_nodeb_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DisablePhysicalLink* default_instance_;
};
// -------------------------------------------------------------------

class EnablePhysicalLink : public ::google::protobuf::Message {
 public:
  EnablePhysicalLink();
  virtual ~EnablePhysicalLink();
  
  EnablePhysicalLink(const EnablePhysicalLink& from);
  
  inline EnablePhysicalLink& operator=(const EnablePhysicalLink& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const EnablePhysicalLink& default_instance();
  
  void Swap(EnablePhysicalLink* other);
  
  // implements Message ----------------------------------------------
  
  EnablePhysicalLink* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const EnablePhysicalLink& from);
  void MergeFrom(const EnablePhysicalLink& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string nodeB = 2;
  inline bool has_nodeb() const;
  inline void clear_nodeb();
  static const int kNodeBFieldNumber = 2;
  inline const ::std::string& nodeb() const;
  inline void set_nodeb(const ::std::string& value);
  inline void set_nodeb(const char* value);
  inline void set_nodeb(const char* value, size_t size);
  inline ::std::string* mutable_nodeb();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.EnablePhysicalLink)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* nodeb_;
  static const ::std::string _default_nodeb_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static EnablePhysicalLink* default_instance_;
};
// -------------------------------------------------------------------

class OperationInvocation : public ::google::protobuf::Message {
 public:
  OperationInvocation();
  virtual ~OperationInvocation();
  
  OperationInvocation(const OperationInvocation& from);
  
  inline OperationInvocation& operator=(const OperationInvocation& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const OperationInvocation& default_instance();
  
  void Swap(OperationInvocation* other);
  
  // implements Message ----------------------------------------------
  
  OperationInvocation* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const OperationInvocation& from);
  void MergeFrom(const OperationInvocation& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef OperationInvocation_Operation Operation;
  static const Operation SEND = OperationInvocation_Operation_SEND;
  static const Operation ARE_NODES_ALIVE = OperationInvocation_Operation_ARE_NODES_ALIVE;
  static const Operation FLASH_PROGRAMS = OperationInvocation_Operation_FLASH_PROGRAMS;
  static const Operation RESET_NODES = OperationInvocation_Operation_RESET_NODES;
  static const Operation SET_VIRTUAL_LINK = OperationInvocation_Operation_SET_VIRTUAL_LINK;
  static const Operation DESTROY_VIRTUAL_LINK = OperationInvocation_Operation_DESTROY_VIRTUAL_LINK;
  static const Operation DISABLE_NODE = OperationInvocation_Operation_DISABLE_NODE;
  static const Operation ENABLE_NODE = OperationInvocation_Operation_ENABLE_NODE;
  static const Operation DISABLE_PHYSICAL_LINK = OperationInvocation_Operation_DISABLE_PHYSICAL_LINK;
  static const Operation ENABLE_PHYSICAL_LINK = OperationInvocation_Operation_ENABLE_PHYSICAL_LINK;
  static inline bool Operation_IsValid(int value) {
    return OperationInvocation_Operation_IsValid(value);
  }
  static const Operation Operation_MIN =
    OperationInvocation_Operation_Operation_MIN;
  static const Operation Operation_MAX =
    OperationInvocation_Operation_Operation_MAX;
  static const int Operation_ARRAYSIZE =
    OperationInvocation_Operation_Operation_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Operation_descriptor() {
    return OperationInvocation_Operation_descriptor();
  }
  static inline const ::std::string& Operation_Name(Operation value) {
    return OperationInvocation_Operation_Name(value);
  }
  static inline bool Operation_Parse(const ::std::string& name,
      Operation* value) {
    return OperationInvocation_Operation_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required .de.uniluebeck.itm.tr.runtime.wsnapp.OperationInvocation.Operation operation = 1;
  inline bool has_operation() const;
  inline void clear_operation();
  static const int kOperationFieldNumber = 1;
  inline ::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation operation() const;
  inline void set_operation(::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation value);
  
  // optional bytes arguments = 2;
  inline bool has_arguments() const;
  inline void clear_arguments();
  static const int kArgumentsFieldNumber = 2;
  inline const ::std::string& arguments() const;
  inline void set_arguments(const ::std::string& value);
  inline void set_arguments(const char* value);
  inline void set_arguments(const void* value, size_t size);
  inline ::std::string* mutable_arguments();
  
  // @@protoc_insertion_point(class_scope:de.uniluebeck.itm.tr.runtime.wsnapp.OperationInvocation)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int operation_;
  ::std::string* arguments_;
  static const ::std::string _default_arguments_;
  friend void  protobuf_AddDesc_WSNAppMessages_2eproto();
  friend void protobuf_AssignDesc_WSNAppMessages_2eproto();
  friend void protobuf_ShutdownFile_WSNAppMessages_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static OperationInvocation* default_instance_;
};
// ===================================================================


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

// ListenerManagement

// required .de.uniluebeck.itm.tr.runtime.wsnapp.ListenerManagement.Operation operation = 1;
inline bool ListenerManagement::has_operation() const {
  return _has_bit(0);
}
inline void ListenerManagement::clear_operation() {
  operation_ = 1;
  _clear_bit(0);
}
inline ::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation ListenerManagement::operation() const {
  return static_cast< ::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation >(operation_);
}
inline void ListenerManagement::set_operation(::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation value) {
  GOOGLE_DCHECK(::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation_IsValid(value));
  _set_bit(0);
  operation_ = value;
}

// required string nodeName = 2;
inline bool ListenerManagement::has_nodename() const {
  return _has_bit(1);
}
inline void ListenerManagement::clear_nodename() {
  if (nodename_ != &_default_nodename_) {
    nodename_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& ListenerManagement::nodename() const {
  return *nodename_;
}
inline void ListenerManagement::set_nodename(const ::std::string& value) {
  _set_bit(1);
  if (nodename_ == &_default_nodename_) {
    nodename_ = new ::std::string;
  }
  nodename_->assign(value);
}
inline void ListenerManagement::set_nodename(const char* value) {
  _set_bit(1);
  if (nodename_ == &_default_nodename_) {
    nodename_ = new ::std::string;
  }
  nodename_->assign(value);
}
inline void ListenerManagement::set_nodename(const char* value, size_t size) {
  _set_bit(1);
  if (nodename_ == &_default_nodename_) {
    nodename_ = new ::std::string;
  }
  nodename_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ListenerManagement::mutable_nodename() {
  _set_bit(1);
  if (nodename_ == &_default_nodename_) {
    nodename_ = new ::std::string;
  }
  return nodename_;
}

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

// RequestStatus_Status

// required string nodeId = 1;
inline bool RequestStatus_Status::has_nodeid() const {
  return _has_bit(0);
}
inline void RequestStatus_Status::clear_nodeid() {
  if (nodeid_ != &_default_nodeid_) {
    nodeid_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& RequestStatus_Status::nodeid() const {
  return *nodeid_;
}
inline void RequestStatus_Status::set_nodeid(const ::std::string& value) {
  _set_bit(0);
  if (nodeid_ == &_default_nodeid_) {
    nodeid_ = new ::std::string;
  }
  nodeid_->assign(value);
}
inline void RequestStatus_Status::set_nodeid(const char* value) {
  _set_bit(0);
  if (nodeid_ == &_default_nodeid_) {
    nodeid_ = new ::std::string;
  }
  nodeid_->assign(value);
}
inline void RequestStatus_Status::set_nodeid(const char* value, size_t size) {
  _set_bit(0);
  if (nodeid_ == &_default_nodeid_) {
    nodeid_ = new ::std::string;
  }
  nodeid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RequestStatus_Status::mutable_nodeid() {
  _set_bit(0);
  if (nodeid_ == &_default_nodeid_) {
    nodeid_ = new ::std::string;
  }
  return nodeid_;
}

// optional int32 value = 2;
inline bool RequestStatus_Status::has_value() const {
  return _has_bit(1);
}
inline void RequestStatus_Status::clear_value() {
  value_ = 0;
  _clear_bit(1);
}
inline ::google::protobuf::int32 RequestStatus_Status::value() const {
  return value_;
}
inline void RequestStatus_Status::set_value(::google::protobuf::int32 value) {
  _set_bit(1);
  value_ = value;
}

// optional string msg = 3;
inline bool RequestStatus_Status::has_msg() const {
  return _has_bit(2);
}
inline void RequestStatus_Status::clear_msg() {
  if (msg_ != &_default_msg_) {
    msg_->clear();
  }
  _clear_bit(2);
}
inline const ::std::string& RequestStatus_Status::msg() const {
  return *msg_;
}
inline void RequestStatus_Status::set_msg(const ::std::string& value) {
  _set_bit(2);
  if (msg_ == &_default_msg_) {
    msg_ = new ::std::string;
  }
  msg_->assign(value);
}
inline void RequestStatus_Status::set_msg(const char* value) {
  _set_bit(2);
  if (msg_ == &_default_msg_) {
    msg_ = new ::std::string;
  }
  msg_->assign(value);
}
inline void RequestStatus_Status::set_msg(const char* value, size_t size) {
  _set_bit(2);
  if (msg_ == &_default_msg_) {
    msg_ = new ::std::string;
  }
  msg_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RequestStatus_Status::mutable_msg() {
  _set_bit(2);
  if (msg_ == &_default_msg_) {
    msg_ = new ::std::string;
  }
  return msg_;
}

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

// RequestStatus

// required .de.uniluebeck.itm.tr.runtime.wsnapp.RequestStatus.Status status = 1;
inline bool RequestStatus::has_status() const {
  return _has_bit(0);
}
inline void RequestStatus::clear_status() {
  if (status_ != NULL) status_->::de::uniluebeck::itm::tr::runtime::wsnapp::RequestStatus_Status::Clear();
  _clear_bit(0);
}
inline const ::de::uniluebeck::itm::tr::runtime::wsnapp::RequestStatus_Status& RequestStatus::status() const {
  return status_ != NULL ? *status_ : *default_instance_->status_;
}
inline ::de::uniluebeck::itm::tr::runtime::wsnapp::RequestStatus_Status* RequestStatus::mutable_status() {
  _set_bit(0);
  if (status_ == NULL) status_ = new ::de::uniluebeck::itm::tr::runtime::wsnapp::RequestStatus_Status;
  return status_;
}

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

// Program_ProgramMetaData

// required string version = 1;
inline bool Program_ProgramMetaData::has_version() const {
  return _has_bit(0);
}
inline void Program_ProgramMetaData::clear_version() {
  if (version_ != &_default_version_) {
    version_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Program_ProgramMetaData::version() const {
  return *version_;
}
inline void Program_ProgramMetaData::set_version(const ::std::string& value) {
  _set_bit(0);
  if (version_ == &_default_version_) {
    version_ = new ::std::string;
  }
  version_->assign(value);
}
inline void Program_ProgramMetaData::set_version(const char* value) {
  _set_bit(0);
  if (version_ == &_default_version_) {
    version_ = new ::std::string;
  }
  version_->assign(value);
}
inline void Program_ProgramMetaData::set_version(const char* value, size_t size) {
  _set_bit(0);
  if (version_ == &_default_version_) {
    version_ = new ::std::string;
  }
  version_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Program_ProgramMetaData::mutable_version() {
  _set_bit(0);
  if (version_ == &_default_version_) {
    version_ = new ::std::string;
  }
  return version_;
}

// required string name = 2;
inline bool Program_ProgramMetaData::has_name() const {
  return _has_bit(1);
}
inline void Program_ProgramMetaData::clear_name() {
  if (name_ != &_default_name_) {
    name_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& Program_ProgramMetaData::name() const {
  return *name_;
}
inline void Program_ProgramMetaData::set_name(const ::std::string& value) {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Program_ProgramMetaData::set_name(const char* value) {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Program_ProgramMetaData::set_name(const char* value, size_t size) {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Program_ProgramMetaData::mutable_name() {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  return name_;
}

// required string platform = 3;
inline bool Program_ProgramMetaData::has_platform() const {
  return _has_bit(2);
}
inline void Program_ProgramMetaData::clear_platform() {
  if (platform_ != &_default_platform_) {
    platform_->clear();
  }
  _clear_bit(2);
}
inline const ::std::string& Program_ProgramMetaData::platform() const {
  return *platform_;
}
inline void Program_ProgramMetaData::set_platform(const ::std::string& value) {
  _set_bit(2);
  if (platform_ == &_default_platform_) {
    platform_ = new ::std::string;
  }
  platform_->assign(value);
}
inline void Program_ProgramMetaData::set_platform(const char* value) {
  _set_bit(2);
  if (platform_ == &_default_platform_) {
    platform_ = new ::std::string;
  }
  platform_->assign(value);
}
inline void Program_ProgramMetaData::set_platform(const char* value, size_t size) {
  _set_bit(2);
  if (platform_ == &_default_platform_) {
    platform_ = new ::std::string;
  }
  platform_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Program_ProgramMetaData::mutable_platform() {
  _set_bit(2);
  if (platform_ == &_default_platform_) {
    platform_ = new ::std::string;
  }
  return platform_;
}

// required string other = 4;
inline bool Program_ProgramMetaData::has_other() const {
  return _has_bit(3);
}
inline void Program_ProgramMetaData::clear_other() {
  if (other_ != &_default_other_) {
    other_->clear();
  }
  _clear_bit(3);
}
inline const ::std::string& Program_ProgramMetaData::other() const {
  return *other_;
}
inline void Program_ProgramMetaData::set_other(const ::std::string& value) {
  _set_bit(3);
  if (other_ == &_default_other_) {
    other_ = new ::std::string;
  }
  other_->assign(value);
}
inline void Program_ProgramMetaData::set_other(const char* value) {
  _set_bit(3);
  if (other_ == &_default_other_) {
    other_ = new ::std::string;
  }
  other_->assign(value);
}
inline void Program_ProgramMetaData::set_other(const char* value, size_t size) {
  _set_bit(3);
  if (other_ == &_default_other_) {
    other_ = new ::std::string;
  }
  other_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Program_ProgramMetaData::mutable_other() {
  _set_bit(3);
  if (other_ == &_default_other_) {
    other_ = new ::std::string;
  }
  return other_;
}

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

// Program

// required bytes program = 1;
inline bool Program::has_program() const {
  return _has_bit(0);
}
inline void Program::clear_program() {
  if (program_ != &_default_program_) {
    program_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Program::program() const {
  return *program_;
}
inline void Program::set_program(const ::std::string& value) {
  _set_bit(0);
  if (program_ == &_default_program_) {
    program_ = new ::std::string;
  }
  program_->assign(value);
}
inline void Program::set_program(const char* value) {
  _set_bit(0);
  if (program_ == &_default_program_) {
    program_ = new ::std::string;
  }
  program_->assign(value);
}
inline void Program::set_program(const void* value, size_t size) {
  _set_bit(0);
  if (program_ == &_default_program_) {
    program_ = new ::std::string;
  }
  program_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Program::mutable_program() {
  _set_bit(0);
  if (program_ == &_default_program_) {
    program_ = new ::std::string;
  }
  return program_;
}

// optional .de.uniluebeck.itm.tr.runtime.wsnapp.Program.ProgramMetaData metaData = 2;
inline bool Program::has_metadata() const {
  return _has_bit(1);
}
inline void Program::clear_metadata() {
  if (metadata_ != NULL) metadata_->::de::uniluebeck::itm::tr::runtime::wsnapp::Program_ProgramMetaData::Clear();
  _clear_bit(1);
}
inline const ::de::uniluebeck::itm::tr::runtime::wsnapp::Program_ProgramMetaData& Program::metadata() const {
  return metadata_ != NULL ? *metadata_ : *default_instance_->metadata_;
}
inline ::de::uniluebeck::itm::tr::runtime::wsnapp::Program_ProgramMetaData* Program::mutable_metadata() {
  _set_bit(1);
  if (metadata_ == NULL) metadata_ = new ::de::uniluebeck::itm::tr::runtime::wsnapp::Program_ProgramMetaData;
  return metadata_;
}

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

// Notification

// required string message = 1;
inline bool Notification::has_message() const {
  return _has_bit(0);
}
inline void Notification::clear_message() {
  if (message_ != &_default_message_) {
    message_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Notification::message() const {
  return *message_;
}
inline void Notification::set_message(const ::std::string& value) {
  _set_bit(0);
  if (message_ == &_default_message_) {
    message_ = new ::std::string;
  }
  message_->assign(value);
}
inline void Notification::set_message(const char* value) {
  _set_bit(0);
  if (message_ == &_default_message_) {
    message_ = new ::std::string;
  }
  message_->assign(value);
}
inline void Notification::set_message(const char* value, size_t size) {
  _set_bit(0);
  if (message_ == &_default_message_) {
    message_ = new ::std::string;
  }
  message_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Notification::mutable_message() {
  _set_bit(0);
  if (message_ == &_default_message_) {
    message_ = new ::std::string;
  }
  return message_;
}

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

// Message

// required string sourceNodeId = 1;
inline bool Message::has_sourcenodeid() const {
  return _has_bit(0);
}
inline void Message::clear_sourcenodeid() {
  if (sourcenodeid_ != &_default_sourcenodeid_) {
    sourcenodeid_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Message::sourcenodeid() const {
  return *sourcenodeid_;
}
inline void Message::set_sourcenodeid(const ::std::string& value) {
  _set_bit(0);
  if (sourcenodeid_ == &_default_sourcenodeid_) {
    sourcenodeid_ = new ::std::string;
  }
  sourcenodeid_->assign(value);
}
inline void Message::set_sourcenodeid(const char* value) {
  _set_bit(0);
  if (sourcenodeid_ == &_default_sourcenodeid_) {
    sourcenodeid_ = new ::std::string;
  }
  sourcenodeid_->assign(value);
}
inline void Message::set_sourcenodeid(const char* value, size_t size) {
  _set_bit(0);
  if (sourcenodeid_ == &_default_sourcenodeid_) {
    sourcenodeid_ = new ::std::string;
  }
  sourcenodeid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Message::mutable_sourcenodeid() {
  _set_bit(0);
  if (sourcenodeid_ == &_default_sourcenodeid_) {
    sourcenodeid_ = new ::std::string;
  }
  return sourcenodeid_;
}

// required string timestamp = 2;
inline bool Message::has_timestamp() const {
  return _has_bit(1);
}
inline void Message::clear_timestamp() {
  if (timestamp_ != &_default_timestamp_) {
    timestamp_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& Message::timestamp() const {
  return *timestamp_;
}
inline void Message::set_timestamp(const ::std::string& value) {
  _set_bit(1);
  if (timestamp_ == &_default_timestamp_) {
    timestamp_ = new ::std::string;
  }
  timestamp_->assign(value);
}
inline void Message::set_timestamp(const char* value) {
  _set_bit(1);
  if (timestamp_ == &_default_timestamp_) {
    timestamp_ = new ::std::string;
  }
  timestamp_->assign(value);
}
inline void Message::set_timestamp(const char* value, size_t size) {
  _set_bit(1);
  if (timestamp_ == &_default_timestamp_) {
    timestamp_ = new ::std::string;
  }
  timestamp_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Message::mutable_timestamp() {
  _set_bit(1);
  if (timestamp_ == &_default_timestamp_) {
    timestamp_ = new ::std::string;
  }
  return timestamp_;
}

// required bytes binaryData = 3;
inline bool Message::has_binarydata() const {
  return _has_bit(2);
}
inline void Message::clear_binarydata() {
  if (binarydata_ != &_default_binarydata_) {
    binarydata_->clear();
  }
  _clear_bit(2);
}
inline const ::std::string& Message::binarydata() const {
  return *binarydata_;
}
inline void Message::set_binarydata(const ::std::string& value) {
  _set_bit(2);
  if (binarydata_ == &_default_binarydata_) {
    binarydata_ = new ::std::string;
  }
  binarydata_->assign(value);
}
inline void Message::set_binarydata(const char* value) {
  _set_bit(2);
  if (binarydata_ == &_default_binarydata_) {
    binarydata_ = new ::std::string;
  }
  binarydata_->assign(value);
}
inline void Message::set_binarydata(const void* value, size_t size) {
  _set_bit(2);
  if (binarydata_ == &_default_binarydata_) {
    binarydata_ = new ::std::string;
  }
  binarydata_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Message::mutable_binarydata() {
  _set_bit(2);
  if (binarydata_ == &_default_binarydata_) {
    binarydata_ = new ::std::string;
  }
  return binarydata_;
}

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

// SetVirtualLinkRequest

// required string sourceNode = 1;
inline bool SetVirtualLinkRequest::has_sourcenode() const {
  return _has_bit(0);
}
inline void SetVirtualLinkRequest::clear_sourcenode() {
  if (sourcenode_ != &_default_sourcenode_) {
    sourcenode_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& SetVirtualLinkRequest::sourcenode() const {
  return *sourcenode_;
}
inline void SetVirtualLinkRequest::set_sourcenode(const ::std::string& value) {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  sourcenode_->assign(value);
}
inline void SetVirtualLinkRequest::set_sourcenode(const char* value) {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  sourcenode_->assign(value);
}
inline void SetVirtualLinkRequest::set_sourcenode(const char* value, size_t size) {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  sourcenode_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SetVirtualLinkRequest::mutable_sourcenode() {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  return sourcenode_;
}

// required string targetNode = 2;
inline bool SetVirtualLinkRequest::has_targetnode() const {
  return _has_bit(1);
}
inline void SetVirtualLinkRequest::clear_targetnode() {
  if (targetnode_ != &_default_targetnode_) {
    targetnode_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& SetVirtualLinkRequest::targetnode() const {
  return *targetnode_;
}
inline void SetVirtualLinkRequest::set_targetnode(const ::std::string& value) {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  targetnode_->assign(value);
}
inline void SetVirtualLinkRequest::set_targetnode(const char* value) {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  targetnode_->assign(value);
}
inline void SetVirtualLinkRequest::set_targetnode(const char* value, size_t size) {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  targetnode_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SetVirtualLinkRequest::mutable_targetnode() {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  return targetnode_;
}

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

// DestroyVirtualLinkRequest

// required string sourceNode = 1;
inline bool DestroyVirtualLinkRequest::has_sourcenode() const {
  return _has_bit(0);
}
inline void DestroyVirtualLinkRequest::clear_sourcenode() {
  if (sourcenode_ != &_default_sourcenode_) {
    sourcenode_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& DestroyVirtualLinkRequest::sourcenode() const {
  return *sourcenode_;
}
inline void DestroyVirtualLinkRequest::set_sourcenode(const ::std::string& value) {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  sourcenode_->assign(value);
}
inline void DestroyVirtualLinkRequest::set_sourcenode(const char* value) {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  sourcenode_->assign(value);
}
inline void DestroyVirtualLinkRequest::set_sourcenode(const char* value, size_t size) {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  sourcenode_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DestroyVirtualLinkRequest::mutable_sourcenode() {
  _set_bit(0);
  if (sourcenode_ == &_default_sourcenode_) {
    sourcenode_ = new ::std::string;
  }
  return sourcenode_;
}

// required string targetNode = 2;
inline bool DestroyVirtualLinkRequest::has_targetnode() const {
  return _has_bit(1);
}
inline void DestroyVirtualLinkRequest::clear_targetnode() {
  if (targetnode_ != &_default_targetnode_) {
    targetnode_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& DestroyVirtualLinkRequest::targetnode() const {
  return *targetnode_;
}
inline void DestroyVirtualLinkRequest::set_targetnode(const ::std::string& value) {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  targetnode_->assign(value);
}
inline void DestroyVirtualLinkRequest::set_targetnode(const char* value) {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  targetnode_->assign(value);
}
inline void DestroyVirtualLinkRequest::set_targetnode(const char* value, size_t size) {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  targetnode_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DestroyVirtualLinkRequest::mutable_targetnode() {
  _set_bit(1);
  if (targetnode_ == &_default_targetnode_) {
    targetnode_ = new ::std::string;
  }
  return targetnode_;
}

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

// DisablePhysicalLink

// required string nodeB = 2;
inline bool DisablePhysicalLink::has_nodeb() const {
  return _has_bit(0);
}
inline void DisablePhysicalLink::clear_nodeb() {
  if (nodeb_ != &_default_nodeb_) {
    nodeb_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& DisablePhysicalLink::nodeb() const {
  return *nodeb_;
}
inline void DisablePhysicalLink::set_nodeb(const ::std::string& value) {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  nodeb_->assign(value);
}
inline void DisablePhysicalLink::set_nodeb(const char* value) {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  nodeb_->assign(value);
}
inline void DisablePhysicalLink::set_nodeb(const char* value, size_t size) {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  nodeb_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DisablePhysicalLink::mutable_nodeb() {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  return nodeb_;
}

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

// EnablePhysicalLink

// required string nodeB = 2;
inline bool EnablePhysicalLink::has_nodeb() const {
  return _has_bit(0);
}
inline void EnablePhysicalLink::clear_nodeb() {
  if (nodeb_ != &_default_nodeb_) {
    nodeb_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& EnablePhysicalLink::nodeb() const {
  return *nodeb_;
}
inline void EnablePhysicalLink::set_nodeb(const ::std::string& value) {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  nodeb_->assign(value);
}
inline void EnablePhysicalLink::set_nodeb(const char* value) {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  nodeb_->assign(value);
}
inline void EnablePhysicalLink::set_nodeb(const char* value, size_t size) {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  nodeb_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EnablePhysicalLink::mutable_nodeb() {
  _set_bit(0);
  if (nodeb_ == &_default_nodeb_) {
    nodeb_ = new ::std::string;
  }
  return nodeb_;
}

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

// OperationInvocation

// required .de.uniluebeck.itm.tr.runtime.wsnapp.OperationInvocation.Operation operation = 1;
inline bool OperationInvocation::has_operation() const {
  return _has_bit(0);
}
inline void OperationInvocation::clear_operation() {
  operation_ = 0;
  _clear_bit(0);
}
inline ::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation OperationInvocation::operation() const {
  return static_cast< ::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation >(operation_);
}
inline void OperationInvocation::set_operation(::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation value) {
  GOOGLE_DCHECK(::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation_IsValid(value));
  _set_bit(0);
  operation_ = value;
}

// optional bytes arguments = 2;
inline bool OperationInvocation::has_arguments() const {
  return _has_bit(1);
}
inline void OperationInvocation::clear_arguments() {
  if (arguments_ != &_default_arguments_) {
    arguments_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& OperationInvocation::arguments() const {
  return *arguments_;
}
inline void OperationInvocation::set_arguments(const ::std::string& value) {
  _set_bit(1);
  if (arguments_ == &_default_arguments_) {
    arguments_ = new ::std::string;
  }
  arguments_->assign(value);
}
inline void OperationInvocation::set_arguments(const char* value) {
  _set_bit(1);
  if (arguments_ == &_default_arguments_) {
    arguments_ = new ::std::string;
  }
  arguments_->assign(value);
}
inline void OperationInvocation::set_arguments(const void* value, size_t size) {
  _set_bit(1);
  if (arguments_ == &_default_arguments_) {
    arguments_ = new ::std::string;
  }
  arguments_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationInvocation::mutable_arguments() {
  _set_bit(1);
  if (arguments_ == &_default_arguments_) {
    arguments_ = new ::std::string;
  }
  return arguments_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace wsnapp
}  // namespace runtime
}  // namespace tr
}  // namespace itm
}  // namespace uniluebeck
}  // namespace de

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation>() {
  return ::de::uniluebeck::itm::tr::runtime::wsnapp::ListenerManagement_Operation_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation>() {
  return ::de::uniluebeck::itm::tr::runtime::wsnapp::OperationInvocation_Operation_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_WSNAppMessages_2eproto__INCLUDED