MICO Platform  1.0.0
 All Classes Namespaces Functions Variables Friends
Event.pb.h
1 
14 // Generated by the protocol buffer compiler. DO NOT EDIT!
15 // source: Event.proto
16 
17 #ifndef PROTOBUF_Event_2eproto__INCLUDED
18 #define PROTOBUF_Event_2eproto__INCLUDED
19 
20 #include <string>
21 
22 #include <google/protobuf/stubs/common.h>
23 
24 #if GOOGLE_PROTOBUF_VERSION < 2006000
25 #error This file was generated by a newer version of protoc which is
26 #error incompatible with your Protocol Buffer headers. Please update
27 #error your headers.
28 #endif
29 #if 2006000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
30 #error This file was generated by an older version of protoc which is
31 #error incompatible with your Protocol Buffer headers. Please
32 #error regenerate this file with a newer version of protoc.
33 #endif
34 
35 #include <google/protobuf/generated_message_util.h>
36 #include <google/protobuf/message.h>
37 #include <google/protobuf/repeated_field.h>
38 #include <google/protobuf/extension_set.h>
39 #include <google/protobuf/generated_enum_reflection.h>
40 #include <google/protobuf/unknown_field_set.h>
41 // @@protoc_insertion_point(includes)
42 
43 namespace mico {
44 namespace event {
45 namespace model {
46 
47 // Internal implementation detail -- do not call these.
48 void protobuf_AddDesc_Event_2eproto();
49 void protobuf_AssignDesc_Event_2eproto();
50 void protobuf_ShutdownFile_Event_2eproto();
51 
52 class RegistrationEvent;
53 class AnalysisEvent;
54 class ContentEvent;
55 class DiscoveryEvent;
56 
57 enum Implementation {
58  JAVA = 1,
59  CPP = 2,
60  PYTHON = 3
61 };
62 bool Implementation_IsValid(int value);
63 const Implementation Implementation_MIN = JAVA;
64 const Implementation Implementation_MAX = PYTHON;
65 const int Implementation_ARRAYSIZE = Implementation_MAX + 1;
66 
67 const ::google::protobuf::EnumDescriptor* Implementation_descriptor();
68 inline const ::std::string& Implementation_Name(Implementation value) {
69  return ::google::protobuf::internal::NameOfEnum(
70  Implementation_descriptor(), value);
71 }
72 inline bool Implementation_Parse(
73  const ::std::string& name, Implementation* value) {
74  return ::google::protobuf::internal::ParseNamedEnum<Implementation>(
75  Implementation_descriptor(), name, value);
76 }
77 enum RegistrationType {
78  REGISTER = 1,
79  UNREGISTER = 2
80 };
81 bool RegistrationType_IsValid(int value);
82 const RegistrationType RegistrationType_MIN = REGISTER;
83 const RegistrationType RegistrationType_MAX = UNREGISTER;
84 const int RegistrationType_ARRAYSIZE = RegistrationType_MAX + 1;
85 
86 const ::google::protobuf::EnumDescriptor* RegistrationType_descriptor();
87 inline const ::std::string& RegistrationType_Name(RegistrationType value) {
88  return ::google::protobuf::internal::NameOfEnum(
89  RegistrationType_descriptor(), value);
90 }
91 inline bool RegistrationType_Parse(
92  const ::std::string& name, RegistrationType* value) {
93  return ::google::protobuf::internal::ParseNamedEnum<RegistrationType>(
94  RegistrationType_descriptor(), name, value);
95 }
96 // ===================================================================
97 
98 class RegistrationEvent : public ::google::protobuf::Message {
99  public:
100  RegistrationEvent();
101  virtual ~RegistrationEvent();
102 
103  RegistrationEvent(const RegistrationEvent& from);
104 
105  inline RegistrationEvent& operator=(const RegistrationEvent& from) {
106  CopyFrom(from);
107  return *this;
108  }
109 
110  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
111  return _unknown_fields_;
112  }
113 
114  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
115  return &_unknown_fields_;
116  }
117 
118  static const ::google::protobuf::Descriptor* descriptor();
119  static const RegistrationEvent& default_instance();
120 
121  void Swap(RegistrationEvent* other);
122 
123  // implements Message ----------------------------------------------
124 
125  RegistrationEvent* New() const;
126  void CopyFrom(const ::google::protobuf::Message& from);
127  void MergeFrom(const ::google::protobuf::Message& from);
128  void CopyFrom(const RegistrationEvent& from);
129  void MergeFrom(const RegistrationEvent& from);
130  void Clear();
131  bool IsInitialized() const;
132 
133  int ByteSize() const;
134  bool MergePartialFromCodedStream(
135  ::google::protobuf::io::CodedInputStream* input);
136  void SerializeWithCachedSizes(
137  ::google::protobuf::io::CodedOutputStream* output) const;
138  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
139  int GetCachedSize() const { return _cached_size_; }
140  private:
141  void SharedCtor();
142  void SharedDtor();
143  void SetCachedSize(int size) const;
144  public:
145  ::google::protobuf::Metadata GetMetadata() const;
146 
147  // nested types ----------------------------------------------------
148 
149  // accessors -------------------------------------------------------
150 
151  // required string serviceId = 1;
152  inline bool has_serviceid() const;
153  inline void clear_serviceid();
154  static const int kServiceIdFieldNumber = 1;
155  inline const ::std::string& serviceid() const;
156  inline void set_serviceid(const ::std::string& value);
157  inline void set_serviceid(const char* value);
158  inline void set_serviceid(const char* value, size_t size);
159  inline ::std::string* mutable_serviceid();
160  inline ::std::string* release_serviceid();
161  inline void set_allocated_serviceid(::std::string* serviceid);
162 
163  // required string queueName = 2;
164  inline bool has_queuename() const;
165  inline void clear_queuename();
166  static const int kQueueNameFieldNumber = 2;
167  inline const ::std::string& queuename() const;
168  inline void set_queuename(const ::std::string& value);
169  inline void set_queuename(const char* value);
170  inline void set_queuename(const char* value, size_t size);
171  inline ::std::string* mutable_queuename();
172  inline ::std::string* release_queuename();
173  inline void set_allocated_queuename(::std::string* queuename);
174 
175  // required string provides = 3;
176  inline bool has_provides() const;
177  inline void clear_provides();
178  static const int kProvidesFieldNumber = 3;
179  inline const ::std::string& provides() const;
180  inline void set_provides(const ::std::string& value);
181  inline void set_provides(const char* value);
182  inline void set_provides(const char* value, size_t size);
183  inline ::std::string* mutable_provides();
184  inline ::std::string* release_provides();
185  inline void set_allocated_provides(::std::string* provides);
186 
187  // required string requires = 4;
188  inline bool has_requires() const;
189  inline void clear_requires();
190  static const int kRequiresFieldNumber = 4;
191  inline const ::std::string& requires() const;
192  inline void set_requires(const ::std::string& value);
193  inline void set_requires(const char* value);
194  inline void set_requires(const char* value, size_t size);
195  inline ::std::string* mutable_requires();
196  inline ::std::string* release_requires();
197  inline void set_allocated_requires(::std::string* requires);
198 
199  // optional .mico.event.model.Implementation language = 5 [default = JAVA];
200  inline bool has_language() const;
201  inline void clear_language();
202  static const int kLanguageFieldNumber = 5;
203  inline ::mico::event::model::Implementation language() const;
204  inline void set_language(::mico::event::model::Implementation value);
205 
206  // optional .mico.event.model.RegistrationType type = 6 [default = REGISTER];
207  inline bool has_type() const;
208  inline void clear_type();
209  static const int kTypeFieldNumber = 6;
210  inline ::mico::event::model::RegistrationType type() const;
211  inline void set_type(::mico::event::model::RegistrationType value);
212 
213  // @@protoc_insertion_point(class_scope:mico.event.model.RegistrationEvent)
214  private:
215  inline void set_has_serviceid();
216  inline void clear_has_serviceid();
217  inline void set_has_queuename();
218  inline void clear_has_queuename();
219  inline void set_has_provides();
220  inline void clear_has_provides();
221  inline void set_has_requires();
222  inline void clear_has_requires();
223  inline void set_has_language();
224  inline void clear_has_language();
225  inline void set_has_type();
226  inline void clear_has_type();
227 
228  ::google::protobuf::UnknownFieldSet _unknown_fields_;
229 
230  ::google::protobuf::uint32 _has_bits_[1];
231  mutable int _cached_size_;
232  ::std::string* serviceid_;
233  ::std::string* queuename_;
234  ::std::string* provides_;
235  ::std::string* requires_;
236  int language_;
237  int type_;
238  friend void protobuf_AddDesc_Event_2eproto();
239  friend void protobuf_AssignDesc_Event_2eproto();
240  friend void protobuf_ShutdownFile_Event_2eproto();
241 
242  void InitAsDefaultInstance();
243  static RegistrationEvent* default_instance_;
244 };
245 // -------------------------------------------------------------------
246 
247 class AnalysisEvent : public ::google::protobuf::Message {
248  public:
249  AnalysisEvent();
250  virtual ~AnalysisEvent();
251 
252  AnalysisEvent(const AnalysisEvent& from);
253 
254  inline AnalysisEvent& operator=(const AnalysisEvent& from) {
255  CopyFrom(from);
256  return *this;
257  }
258 
259  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
260  return _unknown_fields_;
261  }
262 
263  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
264  return &_unknown_fields_;
265  }
266 
267  static const ::google::protobuf::Descriptor* descriptor();
268  static const AnalysisEvent& default_instance();
269 
270  void Swap(AnalysisEvent* other);
271 
272  // implements Message ----------------------------------------------
273 
274  AnalysisEvent* New() const;
275  void CopyFrom(const ::google::protobuf::Message& from);
276  void MergeFrom(const ::google::protobuf::Message& from);
277  void CopyFrom(const AnalysisEvent& from);
278  void MergeFrom(const AnalysisEvent& from);
279  void Clear();
280  bool IsInitialized() const;
281 
282  int ByteSize() const;
283  bool MergePartialFromCodedStream(
284  ::google::protobuf::io::CodedInputStream* input);
285  void SerializeWithCachedSizes(
286  ::google::protobuf::io::CodedOutputStream* output) const;
287  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
288  int GetCachedSize() const { return _cached_size_; }
289  private:
290  void SharedCtor();
291  void SharedDtor();
292  void SetCachedSize(int size) const;
293  public:
294  ::google::protobuf::Metadata GetMetadata() const;
295 
296  // nested types ----------------------------------------------------
297 
298  // accessors -------------------------------------------------------
299 
300  // required string serviceId = 1;
301  inline bool has_serviceid() const;
302  inline void clear_serviceid();
303  static const int kServiceIdFieldNumber = 1;
304  inline const ::std::string& serviceid() const;
305  inline void set_serviceid(const ::std::string& value);
306  inline void set_serviceid(const char* value);
307  inline void set_serviceid(const char* value, size_t size);
308  inline ::std::string* mutable_serviceid();
309  inline ::std::string* release_serviceid();
310  inline void set_allocated_serviceid(::std::string* serviceid);
311 
312  // required string contentItemUri = 2;
313  inline bool has_contentitemuri() const;
314  inline void clear_contentitemuri();
315  static const int kContentItemUriFieldNumber = 2;
316  inline const ::std::string& contentitemuri() const;
317  inline void set_contentitemuri(const ::std::string& value);
318  inline void set_contentitemuri(const char* value);
319  inline void set_contentitemuri(const char* value, size_t size);
320  inline ::std::string* mutable_contentitemuri();
321  inline ::std::string* release_contentitemuri();
322  inline void set_allocated_contentitemuri(::std::string* contentitemuri);
323 
324  // optional string objectUri = 3;
325  inline bool has_objecturi() const;
326  inline void clear_objecturi();
327  static const int kObjectUriFieldNumber = 3;
328  inline const ::std::string& objecturi() const;
329  inline void set_objecturi(const ::std::string& value);
330  inline void set_objecturi(const char* value);
331  inline void set_objecturi(const char* value, size_t size);
332  inline ::std::string* mutable_objecturi();
333  inline ::std::string* release_objecturi();
334  inline void set_allocated_objecturi(::std::string* objecturi);
335 
336  // @@protoc_insertion_point(class_scope:mico.event.model.AnalysisEvent)
337  private:
338  inline void set_has_serviceid();
339  inline void clear_has_serviceid();
340  inline void set_has_contentitemuri();
341  inline void clear_has_contentitemuri();
342  inline void set_has_objecturi();
343  inline void clear_has_objecturi();
344 
345  ::google::protobuf::UnknownFieldSet _unknown_fields_;
346 
347  ::google::protobuf::uint32 _has_bits_[1];
348  mutable int _cached_size_;
349  ::std::string* serviceid_;
350  ::std::string* contentitemuri_;
351  ::std::string* objecturi_;
352  friend void protobuf_AddDesc_Event_2eproto();
353  friend void protobuf_AssignDesc_Event_2eproto();
354  friend void protobuf_ShutdownFile_Event_2eproto();
355 
356  void InitAsDefaultInstance();
357  static AnalysisEvent* default_instance_;
358 };
359 // -------------------------------------------------------------------
360 
361 class ContentEvent : public ::google::protobuf::Message {
362  public:
363  ContentEvent();
364  virtual ~ContentEvent();
365 
366  ContentEvent(const ContentEvent& from);
367 
368  inline ContentEvent& operator=(const ContentEvent& from) {
369  CopyFrom(from);
370  return *this;
371  }
372 
373  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
374  return _unknown_fields_;
375  }
376 
377  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
378  return &_unknown_fields_;
379  }
380 
381  static const ::google::protobuf::Descriptor* descriptor();
382  static const ContentEvent& default_instance();
383 
384  void Swap(ContentEvent* other);
385 
386  // implements Message ----------------------------------------------
387 
388  ContentEvent* New() const;
389  void CopyFrom(const ::google::protobuf::Message& from);
390  void MergeFrom(const ::google::protobuf::Message& from);
391  void CopyFrom(const ContentEvent& from);
392  void MergeFrom(const ContentEvent& from);
393  void Clear();
394  bool IsInitialized() const;
395 
396  int ByteSize() const;
397  bool MergePartialFromCodedStream(
398  ::google::protobuf::io::CodedInputStream* input);
399  void SerializeWithCachedSizes(
400  ::google::protobuf::io::CodedOutputStream* output) const;
401  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
402  int GetCachedSize() const { return _cached_size_; }
403  private:
404  void SharedCtor();
405  void SharedDtor();
406  void SetCachedSize(int size) const;
407  public:
408  ::google::protobuf::Metadata GetMetadata() const;
409 
410  // nested types ----------------------------------------------------
411 
412  // accessors -------------------------------------------------------
413 
414  // required string contentItemUri = 1;
415  inline bool has_contentitemuri() const;
416  inline void clear_contentitemuri();
417  static const int kContentItemUriFieldNumber = 1;
418  inline const ::std::string& contentitemuri() const;
419  inline void set_contentitemuri(const ::std::string& value);
420  inline void set_contentitemuri(const char* value);
421  inline void set_contentitemuri(const char* value, size_t size);
422  inline ::std::string* mutable_contentitemuri();
423  inline ::std::string* release_contentitemuri();
424  inline void set_allocated_contentitemuri(::std::string* contentitemuri);
425 
426  // @@protoc_insertion_point(class_scope:mico.event.model.ContentEvent)
427  private:
428  inline void set_has_contentitemuri();
429  inline void clear_has_contentitemuri();
430 
431  ::google::protobuf::UnknownFieldSet _unknown_fields_;
432 
433  ::google::protobuf::uint32 _has_bits_[1];
434  mutable int _cached_size_;
435  ::std::string* contentitemuri_;
436  friend void protobuf_AddDesc_Event_2eproto();
437  friend void protobuf_AssignDesc_Event_2eproto();
438  friend void protobuf_ShutdownFile_Event_2eproto();
439 
440  void InitAsDefaultInstance();
441  static ContentEvent* default_instance_;
442 };
443 // -------------------------------------------------------------------
444 
445 class DiscoveryEvent : public ::google::protobuf::Message {
446  public:
447  DiscoveryEvent();
448  virtual ~DiscoveryEvent();
449 
450  DiscoveryEvent(const DiscoveryEvent& from);
451 
452  inline DiscoveryEvent& operator=(const DiscoveryEvent& from) {
453  CopyFrom(from);
454  return *this;
455  }
456 
457  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
458  return _unknown_fields_;
459  }
460 
461  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
462  return &_unknown_fields_;
463  }
464 
465  static const ::google::protobuf::Descriptor* descriptor();
466  static const DiscoveryEvent& default_instance();
467 
468  void Swap(DiscoveryEvent* other);
469 
470  // implements Message ----------------------------------------------
471 
472  DiscoveryEvent* New() const;
473  void CopyFrom(const ::google::protobuf::Message& from);
474  void MergeFrom(const ::google::protobuf::Message& from);
475  void CopyFrom(const DiscoveryEvent& from);
476  void MergeFrom(const DiscoveryEvent& from);
477  void Clear();
478  bool IsInitialized() const;
479 
480  int ByteSize() const;
481  bool MergePartialFromCodedStream(
482  ::google::protobuf::io::CodedInputStream* input);
483  void SerializeWithCachedSizes(
484  ::google::protobuf::io::CodedOutputStream* output) const;
485  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
486  int GetCachedSize() const { return _cached_size_; }
487  private:
488  void SharedCtor();
489  void SharedDtor();
490  void SetCachedSize(int size) const;
491  public:
492  ::google::protobuf::Metadata GetMetadata() const;
493 
494  // nested types ----------------------------------------------------
495 
496  // accessors -------------------------------------------------------
497 
498  // @@protoc_insertion_point(class_scope:mico.event.model.DiscoveryEvent)
499  private:
500 
501  ::google::protobuf::UnknownFieldSet _unknown_fields_;
502 
503  ::google::protobuf::uint32 _has_bits_[1];
504  mutable int _cached_size_;
505  friend void protobuf_AddDesc_Event_2eproto();
506  friend void protobuf_AssignDesc_Event_2eproto();
507  friend void protobuf_ShutdownFile_Event_2eproto();
508 
509  void InitAsDefaultInstance();
510  static DiscoveryEvent* default_instance_;
511 };
512 // ===================================================================
513 
514 
515 // ===================================================================
516 
517 // RegistrationEvent
518 
519 // required string serviceId = 1;
520 inline bool RegistrationEvent::has_serviceid() const {
521  return (_has_bits_[0] & 0x00000001u) != 0;
522 }
523 inline void RegistrationEvent::set_has_serviceid() {
524  _has_bits_[0] |= 0x00000001u;
525 }
526 inline void RegistrationEvent::clear_has_serviceid() {
527  _has_bits_[0] &= ~0x00000001u;
528 }
529 inline void RegistrationEvent::clear_serviceid() {
530  if (serviceid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
531  serviceid_->clear();
532  }
533  clear_has_serviceid();
534 }
535 inline const ::std::string& RegistrationEvent::serviceid() const {
536  // @@protoc_insertion_point(field_get:mico.event.model.RegistrationEvent.serviceId)
537  return *serviceid_;
538 }
539 inline void RegistrationEvent::set_serviceid(const ::std::string& value) {
540  set_has_serviceid();
541  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
542  serviceid_ = new ::std::string;
543  }
544  serviceid_->assign(value);
545  // @@protoc_insertion_point(field_set:mico.event.model.RegistrationEvent.serviceId)
546 }
547 inline void RegistrationEvent::set_serviceid(const char* value) {
548  set_has_serviceid();
549  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
550  serviceid_ = new ::std::string;
551  }
552  serviceid_->assign(value);
553  // @@protoc_insertion_point(field_set_char:mico.event.model.RegistrationEvent.serviceId)
554 }
555 inline void RegistrationEvent::set_serviceid(const char* value, size_t size) {
556  set_has_serviceid();
557  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
558  serviceid_ = new ::std::string;
559  }
560  serviceid_->assign(reinterpret_cast<const char*>(value), size);
561  // @@protoc_insertion_point(field_set_pointer:mico.event.model.RegistrationEvent.serviceId)
562 }
563 inline ::std::string* RegistrationEvent::mutable_serviceid() {
564  set_has_serviceid();
565  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
566  serviceid_ = new ::std::string;
567  }
568  // @@protoc_insertion_point(field_mutable:mico.event.model.RegistrationEvent.serviceId)
569  return serviceid_;
570 }
571 inline ::std::string* RegistrationEvent::release_serviceid() {
572  clear_has_serviceid();
573  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
574  return NULL;
575  } else {
576  ::std::string* temp = serviceid_;
577  serviceid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
578  return temp;
579  }
580 }
581 inline void RegistrationEvent::set_allocated_serviceid(::std::string* serviceid) {
582  if (serviceid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
583  delete serviceid_;
584  }
585  if (serviceid) {
586  set_has_serviceid();
587  serviceid_ = serviceid;
588  } else {
589  clear_has_serviceid();
590  serviceid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
591  }
592  // @@protoc_insertion_point(field_set_allocated:mico.event.model.RegistrationEvent.serviceId)
593 }
594 
595 // required string queueName = 2;
596 inline bool RegistrationEvent::has_queuename() const {
597  return (_has_bits_[0] & 0x00000002u) != 0;
598 }
599 inline void RegistrationEvent::set_has_queuename() {
600  _has_bits_[0] |= 0x00000002u;
601 }
602 inline void RegistrationEvent::clear_has_queuename() {
603  _has_bits_[0] &= ~0x00000002u;
604 }
605 inline void RegistrationEvent::clear_queuename() {
606  if (queuename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
607  queuename_->clear();
608  }
609  clear_has_queuename();
610 }
611 inline const ::std::string& RegistrationEvent::queuename() const {
612  // @@protoc_insertion_point(field_get:mico.event.model.RegistrationEvent.queueName)
613  return *queuename_;
614 }
615 inline void RegistrationEvent::set_queuename(const ::std::string& value) {
616  set_has_queuename();
617  if (queuename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
618  queuename_ = new ::std::string;
619  }
620  queuename_->assign(value);
621  // @@protoc_insertion_point(field_set:mico.event.model.RegistrationEvent.queueName)
622 }
623 inline void RegistrationEvent::set_queuename(const char* value) {
624  set_has_queuename();
625  if (queuename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
626  queuename_ = new ::std::string;
627  }
628  queuename_->assign(value);
629  // @@protoc_insertion_point(field_set_char:mico.event.model.RegistrationEvent.queueName)
630 }
631 inline void RegistrationEvent::set_queuename(const char* value, size_t size) {
632  set_has_queuename();
633  if (queuename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
634  queuename_ = new ::std::string;
635  }
636  queuename_->assign(reinterpret_cast<const char*>(value), size);
637  // @@protoc_insertion_point(field_set_pointer:mico.event.model.RegistrationEvent.queueName)
638 }
639 inline ::std::string* RegistrationEvent::mutable_queuename() {
640  set_has_queuename();
641  if (queuename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
642  queuename_ = new ::std::string;
643  }
644  // @@protoc_insertion_point(field_mutable:mico.event.model.RegistrationEvent.queueName)
645  return queuename_;
646 }
647 inline ::std::string* RegistrationEvent::release_queuename() {
648  clear_has_queuename();
649  if (queuename_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
650  return NULL;
651  } else {
652  ::std::string* temp = queuename_;
653  queuename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
654  return temp;
655  }
656 }
657 inline void RegistrationEvent::set_allocated_queuename(::std::string* queuename) {
658  if (queuename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
659  delete queuename_;
660  }
661  if (queuename) {
662  set_has_queuename();
663  queuename_ = queuename;
664  } else {
665  clear_has_queuename();
666  queuename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
667  }
668  // @@protoc_insertion_point(field_set_allocated:mico.event.model.RegistrationEvent.queueName)
669 }
670 
671 // required string provides = 3;
672 inline bool RegistrationEvent::has_provides() const {
673  return (_has_bits_[0] & 0x00000004u) != 0;
674 }
675 inline void RegistrationEvent::set_has_provides() {
676  _has_bits_[0] |= 0x00000004u;
677 }
678 inline void RegistrationEvent::clear_has_provides() {
679  _has_bits_[0] &= ~0x00000004u;
680 }
681 inline void RegistrationEvent::clear_provides() {
682  if (provides_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
683  provides_->clear();
684  }
685  clear_has_provides();
686 }
687 inline const ::std::string& RegistrationEvent::provides() const {
688  // @@protoc_insertion_point(field_get:mico.event.model.RegistrationEvent.provides)
689  return *provides_;
690 }
691 inline void RegistrationEvent::set_provides(const ::std::string& value) {
692  set_has_provides();
693  if (provides_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
694  provides_ = new ::std::string;
695  }
696  provides_->assign(value);
697  // @@protoc_insertion_point(field_set:mico.event.model.RegistrationEvent.provides)
698 }
699 inline void RegistrationEvent::set_provides(const char* value) {
700  set_has_provides();
701  if (provides_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
702  provides_ = new ::std::string;
703  }
704  provides_->assign(value);
705  // @@protoc_insertion_point(field_set_char:mico.event.model.RegistrationEvent.provides)
706 }
707 inline void RegistrationEvent::set_provides(const char* value, size_t size) {
708  set_has_provides();
709  if (provides_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
710  provides_ = new ::std::string;
711  }
712  provides_->assign(reinterpret_cast<const char*>(value), size);
713  // @@protoc_insertion_point(field_set_pointer:mico.event.model.RegistrationEvent.provides)
714 }
715 inline ::std::string* RegistrationEvent::mutable_provides() {
716  set_has_provides();
717  if (provides_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
718  provides_ = new ::std::string;
719  }
720  // @@protoc_insertion_point(field_mutable:mico.event.model.RegistrationEvent.provides)
721  return provides_;
722 }
723 inline ::std::string* RegistrationEvent::release_provides() {
724  clear_has_provides();
725  if (provides_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
726  return NULL;
727  } else {
728  ::std::string* temp = provides_;
729  provides_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
730  return temp;
731  }
732 }
733 inline void RegistrationEvent::set_allocated_provides(::std::string* provides) {
734  if (provides_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
735  delete provides_;
736  }
737  if (provides) {
738  set_has_provides();
739  provides_ = provides;
740  } else {
741  clear_has_provides();
742  provides_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
743  }
744  // @@protoc_insertion_point(field_set_allocated:mico.event.model.RegistrationEvent.provides)
745 }
746 
747 // required string requires = 4;
748 inline bool RegistrationEvent::has_requires() const {
749  return (_has_bits_[0] & 0x00000008u) != 0;
750 }
751 inline void RegistrationEvent::set_has_requires() {
752  _has_bits_[0] |= 0x00000008u;
753 }
754 inline void RegistrationEvent::clear_has_requires() {
755  _has_bits_[0] &= ~0x00000008u;
756 }
757 inline void RegistrationEvent::clear_requires() {
758  if (requires_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
759  requires_->clear();
760  }
761  clear_has_requires();
762 }
763 inline const ::std::string& RegistrationEvent::requires() const {
764  // @@protoc_insertion_point(field_get:mico.event.model.RegistrationEvent.requires)
765  return *requires_;
766 }
767 inline void RegistrationEvent::set_requires(const ::std::string& value) {
768  set_has_requires();
769  if (requires_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
770  requires_ = new ::std::string;
771  }
772  requires_->assign(value);
773  // @@protoc_insertion_point(field_set:mico.event.model.RegistrationEvent.requires)
774 }
775 inline void RegistrationEvent::set_requires(const char* value) {
776  set_has_requires();
777  if (requires_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
778  requires_ = new ::std::string;
779  }
780  requires_->assign(value);
781  // @@protoc_insertion_point(field_set_char:mico.event.model.RegistrationEvent.requires)
782 }
783 inline void RegistrationEvent::set_requires(const char* value, size_t size) {
784  set_has_requires();
785  if (requires_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
786  requires_ = new ::std::string;
787  }
788  requires_->assign(reinterpret_cast<const char*>(value), size);
789  // @@protoc_insertion_point(field_set_pointer:mico.event.model.RegistrationEvent.requires)
790 }
791 inline ::std::string* RegistrationEvent::mutable_requires() {
792  set_has_requires();
793  if (requires_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
794  requires_ = new ::std::string;
795  }
796  // @@protoc_insertion_point(field_mutable:mico.event.model.RegistrationEvent.requires)
797  return requires_;
798 }
799 inline ::std::string* RegistrationEvent::release_requires() {
800  clear_has_requires();
801  if (requires_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
802  return NULL;
803  } else {
804  ::std::string* temp = requires_;
805  requires_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
806  return temp;
807  }
808 }
809 inline void RegistrationEvent::set_allocated_requires(::std::string* requires) {
810  if (requires_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
811  delete requires_;
812  }
813  if (requires) {
814  set_has_requires();
815  requires_ = requires;
816  } else {
817  clear_has_requires();
818  requires_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
819  }
820  // @@protoc_insertion_point(field_set_allocated:mico.event.model.RegistrationEvent.requires)
821 }
822 
823 // optional .mico.event.model.Implementation language = 5 [default = JAVA];
824 inline bool RegistrationEvent::has_language() const {
825  return (_has_bits_[0] & 0x00000010u) != 0;
826 }
827 inline void RegistrationEvent::set_has_language() {
828  _has_bits_[0] |= 0x00000010u;
829 }
830 inline void RegistrationEvent::clear_has_language() {
831  _has_bits_[0] &= ~0x00000010u;
832 }
833 inline void RegistrationEvent::clear_language() {
834  language_ = 1;
835  clear_has_language();
836 }
837 inline ::mico::event::model::Implementation RegistrationEvent::language() const {
838  // @@protoc_insertion_point(field_get:mico.event.model.RegistrationEvent.language)
839  return static_cast< ::mico::event::model::Implementation >(language_);
840 }
841 inline void RegistrationEvent::set_language(::mico::event::model::Implementation value) {
842  assert(::mico::event::model::Implementation_IsValid(value));
843  set_has_language();
844  language_ = value;
845  // @@protoc_insertion_point(field_set:mico.event.model.RegistrationEvent.language)
846 }
847 
848 // optional .mico.event.model.RegistrationType type = 6 [default = REGISTER];
849 inline bool RegistrationEvent::has_type() const {
850  return (_has_bits_[0] & 0x00000020u) != 0;
851 }
852 inline void RegistrationEvent::set_has_type() {
853  _has_bits_[0] |= 0x00000020u;
854 }
855 inline void RegistrationEvent::clear_has_type() {
856  _has_bits_[0] &= ~0x00000020u;
857 }
858 inline void RegistrationEvent::clear_type() {
859  type_ = 1;
860  clear_has_type();
861 }
862 inline ::mico::event::model::RegistrationType RegistrationEvent::type() const {
863  // @@protoc_insertion_point(field_get:mico.event.model.RegistrationEvent.type)
864  return static_cast< ::mico::event::model::RegistrationType >(type_);
865 }
866 inline void RegistrationEvent::set_type(::mico::event::model::RegistrationType value) {
867  assert(::mico::event::model::RegistrationType_IsValid(value));
868  set_has_type();
869  type_ = value;
870  // @@protoc_insertion_point(field_set:mico.event.model.RegistrationEvent.type)
871 }
872 
873 // -------------------------------------------------------------------
874 
875 // AnalysisEvent
876 
877 // required string serviceId = 1;
878 inline bool AnalysisEvent::has_serviceid() const {
879  return (_has_bits_[0] & 0x00000001u) != 0;
880 }
881 inline void AnalysisEvent::set_has_serviceid() {
882  _has_bits_[0] |= 0x00000001u;
883 }
884 inline void AnalysisEvent::clear_has_serviceid() {
885  _has_bits_[0] &= ~0x00000001u;
886 }
887 inline void AnalysisEvent::clear_serviceid() {
888  if (serviceid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
889  serviceid_->clear();
890  }
891  clear_has_serviceid();
892 }
893 inline const ::std::string& AnalysisEvent::serviceid() const {
894  // @@protoc_insertion_point(field_get:mico.event.model.AnalysisEvent.serviceId)
895  return *serviceid_;
896 }
897 inline void AnalysisEvent::set_serviceid(const ::std::string& value) {
898  set_has_serviceid();
899  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
900  serviceid_ = new ::std::string;
901  }
902  serviceid_->assign(value);
903  // @@protoc_insertion_point(field_set:mico.event.model.AnalysisEvent.serviceId)
904 }
905 inline void AnalysisEvent::set_serviceid(const char* value) {
906  set_has_serviceid();
907  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
908  serviceid_ = new ::std::string;
909  }
910  serviceid_->assign(value);
911  // @@protoc_insertion_point(field_set_char:mico.event.model.AnalysisEvent.serviceId)
912 }
913 inline void AnalysisEvent::set_serviceid(const char* value, size_t size) {
914  set_has_serviceid();
915  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
916  serviceid_ = new ::std::string;
917  }
918  serviceid_->assign(reinterpret_cast<const char*>(value), size);
919  // @@protoc_insertion_point(field_set_pointer:mico.event.model.AnalysisEvent.serviceId)
920 }
921 inline ::std::string* AnalysisEvent::mutable_serviceid() {
922  set_has_serviceid();
923  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
924  serviceid_ = new ::std::string;
925  }
926  // @@protoc_insertion_point(field_mutable:mico.event.model.AnalysisEvent.serviceId)
927  return serviceid_;
928 }
929 inline ::std::string* AnalysisEvent::release_serviceid() {
930  clear_has_serviceid();
931  if (serviceid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
932  return NULL;
933  } else {
934  ::std::string* temp = serviceid_;
935  serviceid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
936  return temp;
937  }
938 }
939 inline void AnalysisEvent::set_allocated_serviceid(::std::string* serviceid) {
940  if (serviceid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
941  delete serviceid_;
942  }
943  if (serviceid) {
944  set_has_serviceid();
945  serviceid_ = serviceid;
946  } else {
947  clear_has_serviceid();
948  serviceid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
949  }
950  // @@protoc_insertion_point(field_set_allocated:mico.event.model.AnalysisEvent.serviceId)
951 }
952 
953 // required string contentItemUri = 2;
954 inline bool AnalysisEvent::has_contentitemuri() const {
955  return (_has_bits_[0] & 0x00000002u) != 0;
956 }
957 inline void AnalysisEvent::set_has_contentitemuri() {
958  _has_bits_[0] |= 0x00000002u;
959 }
960 inline void AnalysisEvent::clear_has_contentitemuri() {
961  _has_bits_[0] &= ~0x00000002u;
962 }
963 inline void AnalysisEvent::clear_contentitemuri() {
964  if (contentitemuri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
965  contentitemuri_->clear();
966  }
967  clear_has_contentitemuri();
968 }
969 inline const ::std::string& AnalysisEvent::contentitemuri() const {
970  // @@protoc_insertion_point(field_get:mico.event.model.AnalysisEvent.contentItemUri)
971  return *contentitemuri_;
972 }
973 inline void AnalysisEvent::set_contentitemuri(const ::std::string& value) {
974  set_has_contentitemuri();
975  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
976  contentitemuri_ = new ::std::string;
977  }
978  contentitemuri_->assign(value);
979  // @@protoc_insertion_point(field_set:mico.event.model.AnalysisEvent.contentItemUri)
980 }
981 inline void AnalysisEvent::set_contentitemuri(const char* value) {
982  set_has_contentitemuri();
983  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
984  contentitemuri_ = new ::std::string;
985  }
986  contentitemuri_->assign(value);
987  // @@protoc_insertion_point(field_set_char:mico.event.model.AnalysisEvent.contentItemUri)
988 }
989 inline void AnalysisEvent::set_contentitemuri(const char* value, size_t size) {
990  set_has_contentitemuri();
991  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
992  contentitemuri_ = new ::std::string;
993  }
994  contentitemuri_->assign(reinterpret_cast<const char*>(value), size);
995  // @@protoc_insertion_point(field_set_pointer:mico.event.model.AnalysisEvent.contentItemUri)
996 }
997 inline ::std::string* AnalysisEvent::mutable_contentitemuri() {
998  set_has_contentitemuri();
999  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1000  contentitemuri_ = new ::std::string;
1001  }
1002  // @@protoc_insertion_point(field_mutable:mico.event.model.AnalysisEvent.contentItemUri)
1003  return contentitemuri_;
1004 }
1005 inline ::std::string* AnalysisEvent::release_contentitemuri() {
1006  clear_has_contentitemuri();
1007  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1008  return NULL;
1009  } else {
1010  ::std::string* temp = contentitemuri_;
1011  contentitemuri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1012  return temp;
1013  }
1014 }
1015 inline void AnalysisEvent::set_allocated_contentitemuri(::std::string* contentitemuri) {
1016  if (contentitemuri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1017  delete contentitemuri_;
1018  }
1019  if (contentitemuri) {
1020  set_has_contentitemuri();
1021  contentitemuri_ = contentitemuri;
1022  } else {
1023  clear_has_contentitemuri();
1024  contentitemuri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1025  }
1026  // @@protoc_insertion_point(field_set_allocated:mico.event.model.AnalysisEvent.contentItemUri)
1027 }
1028 
1029 // optional string objectUri = 3;
1030 inline bool AnalysisEvent::has_objecturi() const {
1031  return (_has_bits_[0] & 0x00000004u) != 0;
1032 }
1033 inline void AnalysisEvent::set_has_objecturi() {
1034  _has_bits_[0] |= 0x00000004u;
1035 }
1036 inline void AnalysisEvent::clear_has_objecturi() {
1037  _has_bits_[0] &= ~0x00000004u;
1038 }
1039 inline void AnalysisEvent::clear_objecturi() {
1040  if (objecturi_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1041  objecturi_->clear();
1042  }
1043  clear_has_objecturi();
1044 }
1045 inline const ::std::string& AnalysisEvent::objecturi() const {
1046  // @@protoc_insertion_point(field_get:mico.event.model.AnalysisEvent.objectUri)
1047  return *objecturi_;
1048 }
1049 inline void AnalysisEvent::set_objecturi(const ::std::string& value) {
1050  set_has_objecturi();
1051  if (objecturi_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1052  objecturi_ = new ::std::string;
1053  }
1054  objecturi_->assign(value);
1055  // @@protoc_insertion_point(field_set:mico.event.model.AnalysisEvent.objectUri)
1056 }
1057 inline void AnalysisEvent::set_objecturi(const char* value) {
1058  set_has_objecturi();
1059  if (objecturi_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1060  objecturi_ = new ::std::string;
1061  }
1062  objecturi_->assign(value);
1063  // @@protoc_insertion_point(field_set_char:mico.event.model.AnalysisEvent.objectUri)
1064 }
1065 inline void AnalysisEvent::set_objecturi(const char* value, size_t size) {
1066  set_has_objecturi();
1067  if (objecturi_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1068  objecturi_ = new ::std::string;
1069  }
1070  objecturi_->assign(reinterpret_cast<const char*>(value), size);
1071  // @@protoc_insertion_point(field_set_pointer:mico.event.model.AnalysisEvent.objectUri)
1072 }
1073 inline ::std::string* AnalysisEvent::mutable_objecturi() {
1074  set_has_objecturi();
1075  if (objecturi_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1076  objecturi_ = new ::std::string;
1077  }
1078  // @@protoc_insertion_point(field_mutable:mico.event.model.AnalysisEvent.objectUri)
1079  return objecturi_;
1080 }
1081 inline ::std::string* AnalysisEvent::release_objecturi() {
1082  clear_has_objecturi();
1083  if (objecturi_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1084  return NULL;
1085  } else {
1086  ::std::string* temp = objecturi_;
1087  objecturi_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1088  return temp;
1089  }
1090 }
1091 inline void AnalysisEvent::set_allocated_objecturi(::std::string* objecturi) {
1092  if (objecturi_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1093  delete objecturi_;
1094  }
1095  if (objecturi) {
1096  set_has_objecturi();
1097  objecturi_ = objecturi;
1098  } else {
1099  clear_has_objecturi();
1100  objecturi_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1101  }
1102  // @@protoc_insertion_point(field_set_allocated:mico.event.model.AnalysisEvent.objectUri)
1103 }
1104 
1105 // -------------------------------------------------------------------
1106 
1107 // ContentEvent
1108 
1109 // required string contentItemUri = 1;
1110 inline bool ContentEvent::has_contentitemuri() const {
1111  return (_has_bits_[0] & 0x00000001u) != 0;
1112 }
1113 inline void ContentEvent::set_has_contentitemuri() {
1114  _has_bits_[0] |= 0x00000001u;
1115 }
1116 inline void ContentEvent::clear_has_contentitemuri() {
1117  _has_bits_[0] &= ~0x00000001u;
1118 }
1119 inline void ContentEvent::clear_contentitemuri() {
1120  if (contentitemuri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1121  contentitemuri_->clear();
1122  }
1123  clear_has_contentitemuri();
1124 }
1125 inline const ::std::string& ContentEvent::contentitemuri() const {
1126  // @@protoc_insertion_point(field_get:mico.event.model.ContentEvent.contentItemUri)
1127  return *contentitemuri_;
1128 }
1129 inline void ContentEvent::set_contentitemuri(const ::std::string& value) {
1130  set_has_contentitemuri();
1131  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1132  contentitemuri_ = new ::std::string;
1133  }
1134  contentitemuri_->assign(value);
1135  // @@protoc_insertion_point(field_set:mico.event.model.ContentEvent.contentItemUri)
1136 }
1137 inline void ContentEvent::set_contentitemuri(const char* value) {
1138  set_has_contentitemuri();
1139  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1140  contentitemuri_ = new ::std::string;
1141  }
1142  contentitemuri_->assign(value);
1143  // @@protoc_insertion_point(field_set_char:mico.event.model.ContentEvent.contentItemUri)
1144 }
1145 inline void ContentEvent::set_contentitemuri(const char* value, size_t size) {
1146  set_has_contentitemuri();
1147  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1148  contentitemuri_ = new ::std::string;
1149  }
1150  contentitemuri_->assign(reinterpret_cast<const char*>(value), size);
1151  // @@protoc_insertion_point(field_set_pointer:mico.event.model.ContentEvent.contentItemUri)
1152 }
1153 inline ::std::string* ContentEvent::mutable_contentitemuri() {
1154  set_has_contentitemuri();
1155  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1156  contentitemuri_ = new ::std::string;
1157  }
1158  // @@protoc_insertion_point(field_mutable:mico.event.model.ContentEvent.contentItemUri)
1159  return contentitemuri_;
1160 }
1161 inline ::std::string* ContentEvent::release_contentitemuri() {
1162  clear_has_contentitemuri();
1163  if (contentitemuri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1164  return NULL;
1165  } else {
1166  ::std::string* temp = contentitemuri_;
1167  contentitemuri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1168  return temp;
1169  }
1170 }
1171 inline void ContentEvent::set_allocated_contentitemuri(::std::string* contentitemuri) {
1172  if (contentitemuri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
1173  delete contentitemuri_;
1174  }
1175  if (contentitemuri) {
1176  set_has_contentitemuri();
1177  contentitemuri_ = contentitemuri;
1178  } else {
1179  clear_has_contentitemuri();
1180  contentitemuri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1181  }
1182  // @@protoc_insertion_point(field_set_allocated:mico.event.model.ContentEvent.contentItemUri)
1183 }
1184 
1185 // -------------------------------------------------------------------
1186 
1187 // DiscoveryEvent
1188 
1189 
1190 // @@protoc_insertion_point(namespace_scope)
1191 
1192 } // namespace model
1193 } // namespace event
1194 } // namespace mico
1195 
1196 #ifndef SWIG
1197 namespace google {
1198 namespace protobuf {
1199 
1200 template <> struct is_proto_enum< ::mico::event::model::Implementation> : ::google::protobuf::internal::true_type {};
1201 template <>
1202 inline const EnumDescriptor* GetEnumDescriptor< ::mico::event::model::Implementation>() {
1203  return ::mico::event::model::Implementation_descriptor();
1204 }
1205 template <> struct is_proto_enum< ::mico::event::model::RegistrationType> : ::google::protobuf::internal::true_type {};
1206 template <>
1207 inline const EnumDescriptor* GetEnumDescriptor< ::mico::event::model::RegistrationType>() {
1208  return ::mico::event::model::RegistrationType_descriptor();
1209 }
1210 
1211 } // namespace google
1212 } // namespace protobuf
1213 #endif // SWIG
1214 
1215 // @@protoc_insertion_point(global_scope)
1216 
1217 #endif // PROTOBUF_Event_2eproto__INCLUDED
mico
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in c...
Definition: http_client.cpp:23
mico::event::model::AnalysisEvent
Definition: Event.pb.h:247
mico::event::model::RegistrationEvent
Definition: Event.pb.h:98
mico::event::model::DiscoveryEvent
Definition: Event.pb.h:445
google
Definition: Event.pb.h:1197
mico::event::model::ContentEvent
Definition: Event.pb.h:361
Generated on Tue Nov 4 2014 09:55:13 for MICO Platform by   doxygen 1.8.8