Line data Source code
1 : // Generated by the protocol buffer compiler. DO NOT EDIT!
2 : // source: img.proto
3 :
4 : #ifndef PROTOBUF_INCLUDED_img_2eproto
5 : #define PROTOBUF_INCLUDED_img_2eproto
6 :
7 : #include <string>
8 :
9 : #include <google/protobuf/stubs/common.h>
10 :
11 : #if GOOGLE_PROTOBUF_VERSION < 3006001
12 : #error This file was generated by a newer version of protoc which is
13 : #error incompatible with your Protocol Buffer headers. Please update
14 : #error your headers.
15 : #endif
16 : #if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17 : #error This file was generated by an older version of protoc which is
18 : #error incompatible with your Protocol Buffer headers. Please
19 : #error regenerate this file with a newer version of protoc.
20 : #endif
21 :
22 : #include <google/protobuf/io/coded_stream.h>
23 : #include <google/protobuf/arena.h>
24 : #include <google/protobuf/arenastring.h>
25 : #include <google/protobuf/generated_message_table_driven.h>
26 : #include <google/protobuf/generated_message_util.h>
27 : #include <google/protobuf/inlined_string_field.h>
28 : #include <google/protobuf/metadata.h>
29 : #include <google/protobuf/message.h>
30 : #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 : #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 : #include <google/protobuf/unknown_field_set.h>
33 : #include <google/protobuf/empty.pb.h>
34 : #include <google/protobuf/wrappers.pb.h>
35 : // @@protoc_insertion_point(includes)
36 : #define PROTOBUF_INTERNAL_EXPORT_protobuf_img_2eproto
37 :
38 : namespace protobuf_img_2eproto {
39 : // Internal implementation detail -- do not use these members.
40 : struct TableStruct {
41 : static const ::google::protobuf::internal::ParseTableField entries[];
42 : static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
43 : static const ::google::protobuf::internal::ParseTable schema[22];
44 : static const ::google::protobuf::internal::FieldMetadata field_metadata[];
45 : static const ::google::protobuf::internal::SerializationTable serialization_table[];
46 : static const ::google::protobuf::uint32 offsets[];
47 : };
48 : void AddDescriptors();
49 : } // namespace protobuf_img_2eproto
50 : namespace rpc {
51 : namespace img {
52 : class Axes;
53 : class AxesDefaultTypeInternal;
54 : extern AxesDefaultTypeInternal _Axes_default_instance_;
55 : class ColorMap;
56 : class ColorMapDefaultTypeInternal;
57 : extern ColorMapDefaultTypeInternal _ColorMap_default_instance_;
58 : class ContourColor;
59 : class ContourColorDefaultTypeInternal;
60 : extern ContourColorDefaultTypeInternal _ContourColor_default_instance_;
61 : class ContourLevels;
62 : class ContourLevelsDefaultTypeInternal;
63 : extern ContourLevelsDefaultTypeInternal _ContourLevels_default_instance_;
64 : class ContourThickness;
65 : class ContourThicknessDefaultTypeInternal;
66 : extern ContourThicknessDefaultTypeInternal _ContourThickness_default_instance_;
67 : class Coord2D;
68 : class Coord2DDefaultTypeInternal;
69 : extern Coord2DDefaultTypeInternal _Coord2D_default_instance_;
70 : class DataRange;
71 : class DataRangeDefaultTypeInternal;
72 : extern DataRangeDefaultTypeInternal _DataRange_default_instance_;
73 : class FileInfo;
74 : class FileInfoDefaultTypeInternal;
75 : extern FileInfoDefaultTypeInternal _FileInfo_default_instance_;
76 : class Id;
77 : class IdDefaultTypeInternal;
78 : extern IdDefaultTypeInternal _Id_default_instance_;
79 : class InteractiveMaskOptions;
80 : class InteractiveMaskOptionsDefaultTypeInternal;
81 : extern InteractiveMaskOptionsDefaultTypeInternal _InteractiveMaskOptions_default_instance_;
82 : class InteractiveMaskResult;
83 : class InteractiveMaskResultDefaultTypeInternal;
84 : extern InteractiveMaskResultDefaultTypeInternal _InteractiveMaskResult_default_instance_;
85 : class KeyInfo;
86 : class KeyInfoDefaultTypeInternal;
87 : extern KeyInfoDefaultTypeInternal _KeyInfo_default_instance_;
88 : class NewData;
89 : class NewDataDefaultTypeInternal;
90 : extern NewDataDefaultTypeInternal _NewData_default_instance_;
91 : class NewPanel;
92 : class NewPanelDefaultTypeInternal;
93 : extern NewPanelDefaultTypeInternal _NewPanel_default_instance_;
94 : class Output;
95 : class OutputDefaultTypeInternal;
96 : extern OutputDefaultTypeInternal _Output_default_instance_;
97 : class Path;
98 : class PathDefaultTypeInternal;
99 : extern PathDefaultTypeInternal _Path_default_instance_;
100 : class PopUp;
101 : class PopUpDefaultTypeInternal;
102 : extern PopUpDefaultTypeInternal _PopUp_default_instance_;
103 : class Restore;
104 : class RestoreDefaultTypeInternal;
105 : extern RestoreDefaultTypeInternal _Restore_default_instance_;
106 : class SetChannel;
107 : class SetChannelDefaultTypeInternal;
108 : extern SetChannelDefaultTypeInternal _SetChannel_default_instance_;
109 : class SetZoomBox;
110 : class SetZoomBoxDefaultTypeInternal;
111 : extern SetZoomBoxDefaultTypeInternal _SetZoomBox_default_instance_;
112 : class SetZoomLevel;
113 : class SetZoomLevelDefaultTypeInternal;
114 : extern SetZoomLevelDefaultTypeInternal _SetZoomLevel_default_instance_;
115 : class Toggle;
116 : class ToggleDefaultTypeInternal;
117 : extern ToggleDefaultTypeInternal _Toggle_default_instance_;
118 : } // namespace img
119 : } // namespace rpc
120 : namespace google {
121 : namespace protobuf {
122 : template<> ::rpc::img::Axes* Arena::CreateMaybeMessage<::rpc::img::Axes>(Arena*);
123 : template<> ::rpc::img::ColorMap* Arena::CreateMaybeMessage<::rpc::img::ColorMap>(Arena*);
124 : template<> ::rpc::img::ContourColor* Arena::CreateMaybeMessage<::rpc::img::ContourColor>(Arena*);
125 : template<> ::rpc::img::ContourLevels* Arena::CreateMaybeMessage<::rpc::img::ContourLevels>(Arena*);
126 : template<> ::rpc::img::ContourThickness* Arena::CreateMaybeMessage<::rpc::img::ContourThickness>(Arena*);
127 : template<> ::rpc::img::Coord2D* Arena::CreateMaybeMessage<::rpc::img::Coord2D>(Arena*);
128 : template<> ::rpc::img::DataRange* Arena::CreateMaybeMessage<::rpc::img::DataRange>(Arena*);
129 : template<> ::rpc::img::FileInfo* Arena::CreateMaybeMessage<::rpc::img::FileInfo>(Arena*);
130 : template<> ::rpc::img::Id* Arena::CreateMaybeMessage<::rpc::img::Id>(Arena*);
131 : template<> ::rpc::img::InteractiveMaskOptions* Arena::CreateMaybeMessage<::rpc::img::InteractiveMaskOptions>(Arena*);
132 : template<> ::rpc::img::InteractiveMaskResult* Arena::CreateMaybeMessage<::rpc::img::InteractiveMaskResult>(Arena*);
133 : template<> ::rpc::img::KeyInfo* Arena::CreateMaybeMessage<::rpc::img::KeyInfo>(Arena*);
134 : template<> ::rpc::img::NewData* Arena::CreateMaybeMessage<::rpc::img::NewData>(Arena*);
135 : template<> ::rpc::img::NewPanel* Arena::CreateMaybeMessage<::rpc::img::NewPanel>(Arena*);
136 : template<> ::rpc::img::Output* Arena::CreateMaybeMessage<::rpc::img::Output>(Arena*);
137 : template<> ::rpc::img::Path* Arena::CreateMaybeMessage<::rpc::img::Path>(Arena*);
138 : template<> ::rpc::img::PopUp* Arena::CreateMaybeMessage<::rpc::img::PopUp>(Arena*);
139 : template<> ::rpc::img::Restore* Arena::CreateMaybeMessage<::rpc::img::Restore>(Arena*);
140 : template<> ::rpc::img::SetChannel* Arena::CreateMaybeMessage<::rpc::img::SetChannel>(Arena*);
141 : template<> ::rpc::img::SetZoomBox* Arena::CreateMaybeMessage<::rpc::img::SetZoomBox>(Arena*);
142 : template<> ::rpc::img::SetZoomLevel* Arena::CreateMaybeMessage<::rpc::img::SetZoomLevel>(Arena*);
143 : template<> ::rpc::img::Toggle* Arena::CreateMaybeMessage<::rpc::img::Toggle>(Arena*);
144 : } // namespace protobuf
145 : } // namespace google
146 : namespace rpc {
147 : namespace img {
148 :
149 : // ===================================================================
150 :
151 : class Id : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.Id) */ {
152 : public:
153 : Id();
154 : virtual ~Id();
155 :
156 : Id(const Id& from);
157 :
158 : inline Id& operator=(const Id& from) {
159 : CopyFrom(from);
160 : return *this;
161 : }
162 : #if LANG_CXX11
163 : Id(Id&& from) noexcept
164 : : Id() {
165 : *this = ::std::move(from);
166 : }
167 :
168 : inline Id& operator=(Id&& from) noexcept {
169 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
170 : if (this != &from) InternalSwap(&from);
171 : } else {
172 : CopyFrom(from);
173 : }
174 : return *this;
175 : }
176 : #endif
177 : static const ::google::protobuf::Descriptor* descriptor();
178 : static const Id& default_instance();
179 :
180 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
181 150 : static inline const Id* internal_default_instance() {
182 : return reinterpret_cast<const Id*>(
183 150 : &_Id_default_instance_);
184 : }
185 : static constexpr int kIndexInFileMessages =
186 : 0;
187 :
188 : void Swap(Id* other);
189 : friend void swap(Id& a, Id& b) {
190 : a.Swap(&b);
191 : }
192 :
193 : // implements Message ----------------------------------------------
194 :
195 0 : inline Id* New() const final {
196 0 : return CreateMaybeMessage<Id>(NULL);
197 : }
198 :
199 0 : Id* New(::google::protobuf::Arena* arena) const final {
200 0 : return CreateMaybeMessage<Id>(arena);
201 : }
202 : void CopyFrom(const ::google::protobuf::Message& from) final;
203 : void MergeFrom(const ::google::protobuf::Message& from) final;
204 : void CopyFrom(const Id& from);
205 : void MergeFrom(const Id& from);
206 : void Clear() final;
207 : bool IsInitialized() const final;
208 :
209 : size_t ByteSizeLong() const final;
210 : bool MergePartialFromCodedStream(
211 : ::google::protobuf::io::CodedInputStream* input) final;
212 : void SerializeWithCachedSizes(
213 : ::google::protobuf::io::CodedOutputStream* output) const final;
214 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
215 : bool deterministic, ::google::protobuf::uint8* target) const final;
216 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
217 :
218 : private:
219 : void SharedCtor();
220 : void SharedDtor();
221 : void SetCachedSize(int size) const final;
222 : void InternalSwap(Id* other);
223 : private:
224 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
225 : return NULL;
226 : }
227 : inline void* MaybeArenaPtr() const {
228 : return NULL;
229 : }
230 : public:
231 :
232 : ::google::protobuf::Metadata GetMetadata() const final;
233 :
234 : // nested types ----------------------------------------------------
235 :
236 : // accessors -------------------------------------------------------
237 :
238 : // int32 id = 1;
239 : void clear_id();
240 : static const int kIdFieldNumber = 1;
241 : ::google::protobuf::int32 id() const;
242 : void set_id(::google::protobuf::int32 value);
243 :
244 : // @@protoc_insertion_point(class_scope:rpc.img.Id)
245 : private:
246 :
247 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
248 : ::google::protobuf::int32 id_;
249 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
250 : friend struct ::protobuf_img_2eproto::TableStruct;
251 : };
252 : // -------------------------------------------------------------------
253 :
254 : class NewPanel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.NewPanel) */ {
255 : public:
256 : NewPanel();
257 : virtual ~NewPanel();
258 :
259 : NewPanel(const NewPanel& from);
260 :
261 : inline NewPanel& operator=(const NewPanel& from) {
262 : CopyFrom(from);
263 : return *this;
264 : }
265 : #if LANG_CXX11
266 : NewPanel(NewPanel&& from) noexcept
267 : : NewPanel() {
268 : *this = ::std::move(from);
269 : }
270 :
271 : inline NewPanel& operator=(NewPanel&& from) noexcept {
272 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
273 : if (this != &from) InternalSwap(&from);
274 : } else {
275 : CopyFrom(from);
276 : }
277 : return *this;
278 : }
279 : #endif
280 : static const ::google::protobuf::Descriptor* descriptor();
281 : static const NewPanel& default_instance();
282 :
283 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
284 0 : static inline const NewPanel* internal_default_instance() {
285 : return reinterpret_cast<const NewPanel*>(
286 0 : &_NewPanel_default_instance_);
287 : }
288 : static constexpr int kIndexInFileMessages =
289 : 1;
290 :
291 : void Swap(NewPanel* other);
292 : friend void swap(NewPanel& a, NewPanel& b) {
293 : a.Swap(&b);
294 : }
295 :
296 : // implements Message ----------------------------------------------
297 :
298 0 : inline NewPanel* New() const final {
299 0 : return CreateMaybeMessage<NewPanel>(NULL);
300 : }
301 :
302 0 : NewPanel* New(::google::protobuf::Arena* arena) const final {
303 0 : return CreateMaybeMessage<NewPanel>(arena);
304 : }
305 : void CopyFrom(const ::google::protobuf::Message& from) final;
306 : void MergeFrom(const ::google::protobuf::Message& from) final;
307 : void CopyFrom(const NewPanel& from);
308 : void MergeFrom(const NewPanel& from);
309 : void Clear() final;
310 : bool IsInitialized() const final;
311 :
312 : size_t ByteSizeLong() const final;
313 : bool MergePartialFromCodedStream(
314 : ::google::protobuf::io::CodedInputStream* input) final;
315 : void SerializeWithCachedSizes(
316 : ::google::protobuf::io::CodedOutputStream* output) const final;
317 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
318 : bool deterministic, ::google::protobuf::uint8* target) const final;
319 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
320 :
321 : private:
322 : void SharedCtor();
323 : void SharedDtor();
324 : void SetCachedSize(int size) const final;
325 : void InternalSwap(NewPanel* other);
326 : private:
327 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
328 0 : return NULL;
329 : }
330 : inline void* MaybeArenaPtr() const {
331 : return NULL;
332 : }
333 : public:
334 :
335 : ::google::protobuf::Metadata GetMetadata() const final;
336 :
337 : // nested types ----------------------------------------------------
338 :
339 : // accessors -------------------------------------------------------
340 :
341 : // string type = 1;
342 : void clear_type();
343 : static const int kTypeFieldNumber = 1;
344 : const ::std::string& type() const;
345 : void set_type(const ::std::string& value);
346 : #if LANG_CXX11
347 : void set_type(::std::string&& value);
348 : #endif
349 : void set_type(const char* value);
350 : void set_type(const char* value, size_t size);
351 : ::std::string* mutable_type();
352 : ::std::string* release_type();
353 : void set_allocated_type(::std::string* type);
354 :
355 : // bool hidden = 2;
356 : void clear_hidden();
357 : static const int kHiddenFieldNumber = 2;
358 : bool hidden() const;
359 : void set_hidden(bool value);
360 :
361 : // @@protoc_insertion_point(class_scope:rpc.img.NewPanel)
362 : private:
363 :
364 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
365 : ::google::protobuf::internal::ArenaStringPtr type_;
366 : bool hidden_;
367 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
368 : friend struct ::protobuf_img_2eproto::TableStruct;
369 : };
370 : // -------------------------------------------------------------------
371 :
372 : class NewData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.NewData) */ {
373 : public:
374 : NewData();
375 : virtual ~NewData();
376 :
377 : NewData(const NewData& from);
378 :
379 : inline NewData& operator=(const NewData& from) {
380 : CopyFrom(from);
381 : return *this;
382 : }
383 : #if LANG_CXX11
384 : NewData(NewData&& from) noexcept
385 : : NewData() {
386 : *this = ::std::move(from);
387 : }
388 :
389 : inline NewData& operator=(NewData&& from) noexcept {
390 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
391 : if (this != &from) InternalSwap(&from);
392 : } else {
393 : CopyFrom(from);
394 : }
395 : return *this;
396 : }
397 : #endif
398 : static const ::google::protobuf::Descriptor* descriptor();
399 : static const NewData& default_instance();
400 :
401 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
402 0 : static inline const NewData* internal_default_instance() {
403 : return reinterpret_cast<const NewData*>(
404 0 : &_NewData_default_instance_);
405 : }
406 : static constexpr int kIndexInFileMessages =
407 : 2;
408 :
409 : void Swap(NewData* other);
410 : friend void swap(NewData& a, NewData& b) {
411 : a.Swap(&b);
412 : }
413 :
414 : // implements Message ----------------------------------------------
415 :
416 0 : inline NewData* New() const final {
417 0 : return CreateMaybeMessage<NewData>(NULL);
418 : }
419 :
420 0 : NewData* New(::google::protobuf::Arena* arena) const final {
421 0 : return CreateMaybeMessage<NewData>(arena);
422 : }
423 : void CopyFrom(const ::google::protobuf::Message& from) final;
424 : void MergeFrom(const ::google::protobuf::Message& from) final;
425 : void CopyFrom(const NewData& from);
426 : void MergeFrom(const NewData& from);
427 : void Clear() final;
428 : bool IsInitialized() const final;
429 :
430 : size_t ByteSizeLong() const final;
431 : bool MergePartialFromCodedStream(
432 : ::google::protobuf::io::CodedInputStream* input) final;
433 : void SerializeWithCachedSizes(
434 : ::google::protobuf::io::CodedOutputStream* output) const final;
435 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
436 : bool deterministic, ::google::protobuf::uint8* target) const final;
437 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
438 :
439 : private:
440 : void SharedCtor();
441 : void SharedDtor();
442 : void SetCachedSize(int size) const final;
443 : void InternalSwap(NewData* other);
444 : private:
445 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
446 0 : return NULL;
447 : }
448 : inline void* MaybeArenaPtr() const {
449 : return NULL;
450 : }
451 : public:
452 :
453 : ::google::protobuf::Metadata GetMetadata() const final;
454 :
455 : // nested types ----------------------------------------------------
456 :
457 : // accessors -------------------------------------------------------
458 :
459 : // string path = 2;
460 : void clear_path();
461 : static const int kPathFieldNumber = 2;
462 : const ::std::string& path() const;
463 : void set_path(const ::std::string& value);
464 : #if LANG_CXX11
465 : void set_path(::std::string&& value);
466 : #endif
467 : void set_path(const char* value);
468 : void set_path(const char* value, size_t size);
469 : ::std::string* mutable_path();
470 : ::std::string* release_path();
471 : void set_allocated_path(::std::string* path);
472 :
473 : // string type = 3;
474 : void clear_type();
475 : static const int kTypeFieldNumber = 3;
476 : const ::std::string& type() const;
477 : void set_type(const ::std::string& value);
478 : #if LANG_CXX11
479 : void set_type(::std::string&& value);
480 : #endif
481 : void set_type(const char* value);
482 : void set_type(const char* value, size_t size);
483 : ::std::string* mutable_type();
484 : ::std::string* release_type();
485 : void set_allocated_type(::std::string* type);
486 :
487 : // .rpc.img.Id panel = 1;
488 : bool has_panel() const;
489 : void clear_panel();
490 : static const int kPanelFieldNumber = 1;
491 : private:
492 : const ::rpc::img::Id& _internal_panel() const;
493 : public:
494 : const ::rpc::img::Id& panel() const;
495 : ::rpc::img::Id* release_panel();
496 : ::rpc::img::Id* mutable_panel();
497 : void set_allocated_panel(::rpc::img::Id* panel);
498 :
499 : // float scale = 4;
500 : void clear_scale();
501 : static const int kScaleFieldNumber = 4;
502 : float scale() const;
503 : void set_scale(float value);
504 :
505 : // @@protoc_insertion_point(class_scope:rpc.img.NewData)
506 : private:
507 :
508 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
509 : ::google::protobuf::internal::ArenaStringPtr path_;
510 : ::google::protobuf::internal::ArenaStringPtr type_;
511 : ::rpc::img::Id* panel_;
512 : float scale_;
513 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
514 : friend struct ::protobuf_img_2eproto::TableStruct;
515 : };
516 : // -------------------------------------------------------------------
517 :
518 : class PopUp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.PopUp) */ {
519 : public:
520 : PopUp();
521 : virtual ~PopUp();
522 :
523 : PopUp(const PopUp& from);
524 :
525 : inline PopUp& operator=(const PopUp& from) {
526 : CopyFrom(from);
527 : return *this;
528 : }
529 : #if LANG_CXX11
530 : PopUp(PopUp&& from) noexcept
531 : : PopUp() {
532 : *this = ::std::move(from);
533 : }
534 :
535 : inline PopUp& operator=(PopUp&& from) noexcept {
536 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
537 : if (this != &from) InternalSwap(&from);
538 : } else {
539 : CopyFrom(from);
540 : }
541 : return *this;
542 : }
543 : #endif
544 : static const ::google::protobuf::Descriptor* descriptor();
545 : static const PopUp& default_instance();
546 :
547 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
548 0 : static inline const PopUp* internal_default_instance() {
549 : return reinterpret_cast<const PopUp*>(
550 0 : &_PopUp_default_instance_);
551 : }
552 : static constexpr int kIndexInFileMessages =
553 : 3;
554 :
555 : void Swap(PopUp* other);
556 : friend void swap(PopUp& a, PopUp& b) {
557 : a.Swap(&b);
558 : }
559 :
560 : // implements Message ----------------------------------------------
561 :
562 0 : inline PopUp* New() const final {
563 0 : return CreateMaybeMessage<PopUp>(NULL);
564 : }
565 :
566 0 : PopUp* New(::google::protobuf::Arena* arena) const final {
567 0 : return CreateMaybeMessage<PopUp>(arena);
568 : }
569 : void CopyFrom(const ::google::protobuf::Message& from) final;
570 : void MergeFrom(const ::google::protobuf::Message& from) final;
571 : void CopyFrom(const PopUp& from);
572 : void MergeFrom(const PopUp& from);
573 : void Clear() final;
574 : bool IsInitialized() const final;
575 :
576 : size_t ByteSizeLong() const final;
577 : bool MergePartialFromCodedStream(
578 : ::google::protobuf::io::CodedInputStream* input) final;
579 : void SerializeWithCachedSizes(
580 : ::google::protobuf::io::CodedOutputStream* output) const final;
581 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
582 : bool deterministic, ::google::protobuf::uint8* target) const final;
583 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
584 :
585 : private:
586 : void SharedCtor();
587 : void SharedDtor();
588 : void SetCachedSize(int size) const final;
589 : void InternalSwap(PopUp* other);
590 : private:
591 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
592 0 : return NULL;
593 : }
594 : inline void* MaybeArenaPtr() const {
595 : return NULL;
596 : }
597 : public:
598 :
599 : ::google::protobuf::Metadata GetMetadata() const final;
600 :
601 : // nested types ----------------------------------------------------
602 :
603 : // accessors -------------------------------------------------------
604 :
605 : // string name = 2;
606 : void clear_name();
607 : static const int kNameFieldNumber = 2;
608 : const ::std::string& name() const;
609 : void set_name(const ::std::string& value);
610 : #if LANG_CXX11
611 : void set_name(::std::string&& value);
612 : #endif
613 : void set_name(const char* value);
614 : void set_name(const char* value, size_t size);
615 : ::std::string* mutable_name();
616 : ::std::string* release_name();
617 : void set_allocated_name(::std::string* name);
618 :
619 : // .rpc.img.Id panel = 1;
620 : bool has_panel() const;
621 : void clear_panel();
622 : static const int kPanelFieldNumber = 1;
623 : private:
624 : const ::rpc::img::Id& _internal_panel() const;
625 : public:
626 : const ::rpc::img::Id& panel() const;
627 : ::rpc::img::Id* release_panel();
628 : ::rpc::img::Id* mutable_panel();
629 : void set_allocated_panel(::rpc::img::Id* panel);
630 :
631 : // @@protoc_insertion_point(class_scope:rpc.img.PopUp)
632 : private:
633 :
634 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
635 : ::google::protobuf::internal::ArenaStringPtr name_;
636 : ::rpc::img::Id* panel_;
637 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
638 : friend struct ::protobuf_img_2eproto::TableStruct;
639 : };
640 : // -------------------------------------------------------------------
641 :
642 : class Restore : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.Restore) */ {
643 : public:
644 : Restore();
645 : virtual ~Restore();
646 :
647 : Restore(const Restore& from);
648 :
649 : inline Restore& operator=(const Restore& from) {
650 : CopyFrom(from);
651 : return *this;
652 : }
653 : #if LANG_CXX11
654 : Restore(Restore&& from) noexcept
655 : : Restore() {
656 : *this = ::std::move(from);
657 : }
658 :
659 : inline Restore& operator=(Restore&& from) noexcept {
660 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
661 : if (this != &from) InternalSwap(&from);
662 : } else {
663 : CopyFrom(from);
664 : }
665 : return *this;
666 : }
667 : #endif
668 : static const ::google::protobuf::Descriptor* descriptor();
669 : static const Restore& default_instance();
670 :
671 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
672 0 : static inline const Restore* internal_default_instance() {
673 : return reinterpret_cast<const Restore*>(
674 0 : &_Restore_default_instance_);
675 : }
676 : static constexpr int kIndexInFileMessages =
677 : 4;
678 :
679 : void Swap(Restore* other);
680 : friend void swap(Restore& a, Restore& b) {
681 : a.Swap(&b);
682 : }
683 :
684 : // implements Message ----------------------------------------------
685 :
686 0 : inline Restore* New() const final {
687 0 : return CreateMaybeMessage<Restore>(NULL);
688 : }
689 :
690 0 : Restore* New(::google::protobuf::Arena* arena) const final {
691 0 : return CreateMaybeMessage<Restore>(arena);
692 : }
693 : void CopyFrom(const ::google::protobuf::Message& from) final;
694 : void MergeFrom(const ::google::protobuf::Message& from) final;
695 : void CopyFrom(const Restore& from);
696 : void MergeFrom(const Restore& from);
697 : void Clear() final;
698 : bool IsInitialized() const final;
699 :
700 : size_t ByteSizeLong() const final;
701 : bool MergePartialFromCodedStream(
702 : ::google::protobuf::io::CodedInputStream* input) final;
703 : void SerializeWithCachedSizes(
704 : ::google::protobuf::io::CodedOutputStream* output) const final;
705 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
706 : bool deterministic, ::google::protobuf::uint8* target) const final;
707 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
708 :
709 : private:
710 : void SharedCtor();
711 : void SharedDtor();
712 : void SetCachedSize(int size) const final;
713 : void InternalSwap(Restore* other);
714 : private:
715 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
716 0 : return NULL;
717 : }
718 : inline void* MaybeArenaPtr() const {
719 : return NULL;
720 : }
721 : public:
722 :
723 : ::google::protobuf::Metadata GetMetadata() const final;
724 :
725 : // nested types ----------------------------------------------------
726 :
727 : // accessors -------------------------------------------------------
728 :
729 : // string path = 2;
730 : void clear_path();
731 : static const int kPathFieldNumber = 2;
732 : const ::std::string& path() const;
733 : void set_path(const ::std::string& value);
734 : #if LANG_CXX11
735 : void set_path(::std::string&& value);
736 : #endif
737 : void set_path(const char* value);
738 : void set_path(const char* value, size_t size);
739 : ::std::string* mutable_path();
740 : ::std::string* release_path();
741 : void set_allocated_path(::std::string* path);
742 :
743 : // .rpc.img.Id panel = 1;
744 : bool has_panel() const;
745 : void clear_panel();
746 : static const int kPanelFieldNumber = 1;
747 : private:
748 : const ::rpc::img::Id& _internal_panel() const;
749 : public:
750 : const ::rpc::img::Id& panel() const;
751 : ::rpc::img::Id* release_panel();
752 : ::rpc::img::Id* mutable_panel();
753 : void set_allocated_panel(::rpc::img::Id* panel);
754 :
755 : // @@protoc_insertion_point(class_scope:rpc.img.Restore)
756 : private:
757 :
758 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
759 : ::google::protobuf::internal::ArenaStringPtr path_;
760 : ::rpc::img::Id* panel_;
761 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
762 : friend struct ::protobuf_img_2eproto::TableStruct;
763 : };
764 : // -------------------------------------------------------------------
765 :
766 : class FileInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.FileInfo) */ {
767 : public:
768 : FileInfo();
769 : virtual ~FileInfo();
770 :
771 : FileInfo(const FileInfo& from);
772 :
773 : inline FileInfo& operator=(const FileInfo& from) {
774 : CopyFrom(from);
775 : return *this;
776 : }
777 : #if LANG_CXX11
778 : FileInfo(FileInfo&& from) noexcept
779 : : FileInfo() {
780 : *this = ::std::move(from);
781 : }
782 :
783 : inline FileInfo& operator=(FileInfo&& from) noexcept {
784 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
785 : if (this != &from) InternalSwap(&from);
786 : } else {
787 : CopyFrom(from);
788 : }
789 : return *this;
790 : }
791 : #endif
792 : static const ::google::protobuf::Descriptor* descriptor();
793 : static const FileInfo& default_instance();
794 :
795 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
796 0 : static inline const FileInfo* internal_default_instance() {
797 : return reinterpret_cast<const FileInfo*>(
798 0 : &_FileInfo_default_instance_);
799 : }
800 : static constexpr int kIndexInFileMessages =
801 : 5;
802 :
803 : void Swap(FileInfo* other);
804 : friend void swap(FileInfo& a, FileInfo& b) {
805 : a.Swap(&b);
806 : }
807 :
808 : // implements Message ----------------------------------------------
809 :
810 0 : inline FileInfo* New() const final {
811 0 : return CreateMaybeMessage<FileInfo>(NULL);
812 : }
813 :
814 0 : FileInfo* New(::google::protobuf::Arena* arena) const final {
815 0 : return CreateMaybeMessage<FileInfo>(arena);
816 : }
817 : void CopyFrom(const ::google::protobuf::Message& from) final;
818 : void MergeFrom(const ::google::protobuf::Message& from) final;
819 : void CopyFrom(const FileInfo& from);
820 : void MergeFrom(const FileInfo& from);
821 : void Clear() final;
822 : bool IsInitialized() const final;
823 :
824 : size_t ByteSizeLong() const final;
825 : bool MergePartialFromCodedStream(
826 : ::google::protobuf::io::CodedInputStream* input) final;
827 : void SerializeWithCachedSizes(
828 : ::google::protobuf::io::CodedOutputStream* output) const final;
829 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
830 : bool deterministic, ::google::protobuf::uint8* target) const final;
831 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
832 :
833 : private:
834 : void SharedCtor();
835 : void SharedDtor();
836 : void SetCachedSize(int size) const final;
837 : void InternalSwap(FileInfo* other);
838 : private:
839 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
840 0 : return NULL;
841 : }
842 : inline void* MaybeArenaPtr() const {
843 : return NULL;
844 : }
845 : public:
846 :
847 : ::google::protobuf::Metadata GetMetadata() const final;
848 :
849 : // nested types ----------------------------------------------------
850 :
851 : // accessors -------------------------------------------------------
852 :
853 : // string type = 1;
854 : void clear_type();
855 : static const int kTypeFieldNumber = 1;
856 : const ::std::string& type() const;
857 : void set_type(const ::std::string& value);
858 : #if LANG_CXX11
859 : void set_type(::std::string&& value);
860 : #endif
861 : void set_type(const char* value);
862 : void set_type(const char* value, size_t size);
863 : ::std::string* mutable_type();
864 : ::std::string* release_type();
865 : void set_allocated_type(::std::string* type);
866 :
867 : // @@protoc_insertion_point(class_scope:rpc.img.FileInfo)
868 : private:
869 :
870 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
871 : ::google::protobuf::internal::ArenaStringPtr type_;
872 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
873 : friend struct ::protobuf_img_2eproto::TableStruct;
874 : };
875 : // -------------------------------------------------------------------
876 :
877 : class KeyInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.KeyInfo) */ {
878 : public:
879 : KeyInfo();
880 : virtual ~KeyInfo();
881 :
882 : KeyInfo(const KeyInfo& from);
883 :
884 : inline KeyInfo& operator=(const KeyInfo& from) {
885 : CopyFrom(from);
886 : return *this;
887 : }
888 : #if LANG_CXX11
889 : KeyInfo(KeyInfo&& from) noexcept
890 : : KeyInfo() {
891 : *this = ::std::move(from);
892 : }
893 :
894 : inline KeyInfo& operator=(KeyInfo&& from) noexcept {
895 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
896 : if (this != &from) InternalSwap(&from);
897 : } else {
898 : CopyFrom(from);
899 : }
900 : return *this;
901 : }
902 : #endif
903 : static const ::google::protobuf::Descriptor* descriptor();
904 : static const KeyInfo& default_instance();
905 :
906 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
907 0 : static inline const KeyInfo* internal_default_instance() {
908 : return reinterpret_cast<const KeyInfo*>(
909 0 : &_KeyInfo_default_instance_);
910 : }
911 : static constexpr int kIndexInFileMessages =
912 : 6;
913 :
914 : void Swap(KeyInfo* other);
915 : friend void swap(KeyInfo& a, KeyInfo& b) {
916 : a.Swap(&b);
917 : }
918 :
919 : // implements Message ----------------------------------------------
920 :
921 0 : inline KeyInfo* New() const final {
922 0 : return CreateMaybeMessage<KeyInfo>(NULL);
923 : }
924 :
925 0 : KeyInfo* New(::google::protobuf::Arena* arena) const final {
926 0 : return CreateMaybeMessage<KeyInfo>(arena);
927 : }
928 : void CopyFrom(const ::google::protobuf::Message& from) final;
929 : void MergeFrom(const ::google::protobuf::Message& from) final;
930 : void CopyFrom(const KeyInfo& from);
931 : void MergeFrom(const KeyInfo& from);
932 : void Clear() final;
933 : bool IsInitialized() const final;
934 :
935 : size_t ByteSizeLong() const final;
936 : bool MergePartialFromCodedStream(
937 : ::google::protobuf::io::CodedInputStream* input) final;
938 : void SerializeWithCachedSizes(
939 : ::google::protobuf::io::CodedOutputStream* output) const final;
940 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
941 : bool deterministic, ::google::protobuf::uint8* target) const final;
942 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
943 :
944 : private:
945 : void SharedCtor();
946 : void SharedDtor();
947 : void SetCachedSize(int size) const final;
948 : void InternalSwap(KeyInfo* other);
949 : private:
950 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
951 0 : return NULL;
952 : }
953 : inline void* MaybeArenaPtr() const {
954 : return NULL;
955 : }
956 : public:
957 :
958 : ::google::protobuf::Metadata GetMetadata() const final;
959 :
960 : // nested types ----------------------------------------------------
961 :
962 : // accessors -------------------------------------------------------
963 :
964 : // string type = 1;
965 : void clear_type();
966 : static const int kTypeFieldNumber = 1;
967 : const ::std::string& type() const;
968 : void set_type(const ::std::string& value);
969 : #if LANG_CXX11
970 : void set_type(::std::string&& value);
971 : #endif
972 : void set_type(const char* value);
973 : void set_type(const char* value, size_t size);
974 : ::std::string* mutable_type();
975 : ::std::string* release_type();
976 : void set_allocated_type(::std::string* type);
977 :
978 : // @@protoc_insertion_point(class_scope:rpc.img.KeyInfo)
979 : private:
980 :
981 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
982 : ::google::protobuf::internal::ArenaStringPtr type_;
983 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
984 : friend struct ::protobuf_img_2eproto::TableStruct;
985 : };
986 : // -------------------------------------------------------------------
987 :
988 : class Path : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.Path) */ {
989 : public:
990 : Path();
991 : virtual ~Path();
992 :
993 : Path(const Path& from);
994 :
995 : inline Path& operator=(const Path& from) {
996 : CopyFrom(from);
997 : return *this;
998 : }
999 : #if LANG_CXX11
1000 : Path(Path&& from) noexcept
1001 : : Path() {
1002 : *this = ::std::move(from);
1003 : }
1004 :
1005 : inline Path& operator=(Path&& from) noexcept {
1006 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1007 : if (this != &from) InternalSwap(&from);
1008 : } else {
1009 : CopyFrom(from);
1010 : }
1011 : return *this;
1012 : }
1013 : #endif
1014 : static const ::google::protobuf::Descriptor* descriptor();
1015 : static const Path& default_instance();
1016 :
1017 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1018 0 : static inline const Path* internal_default_instance() {
1019 : return reinterpret_cast<const Path*>(
1020 0 : &_Path_default_instance_);
1021 : }
1022 : static constexpr int kIndexInFileMessages =
1023 : 7;
1024 :
1025 : void Swap(Path* other);
1026 : friend void swap(Path& a, Path& b) {
1027 : a.Swap(&b);
1028 : }
1029 :
1030 : // implements Message ----------------------------------------------
1031 :
1032 0 : inline Path* New() const final {
1033 0 : return CreateMaybeMessage<Path>(NULL);
1034 : }
1035 :
1036 0 : Path* New(::google::protobuf::Arena* arena) const final {
1037 0 : return CreateMaybeMessage<Path>(arena);
1038 : }
1039 : void CopyFrom(const ::google::protobuf::Message& from) final;
1040 : void MergeFrom(const ::google::protobuf::Message& from) final;
1041 : void CopyFrom(const Path& from);
1042 : void MergeFrom(const Path& from);
1043 : void Clear() final;
1044 : bool IsInitialized() const final;
1045 :
1046 : size_t ByteSizeLong() const final;
1047 : bool MergePartialFromCodedStream(
1048 : ::google::protobuf::io::CodedInputStream* input) final;
1049 : void SerializeWithCachedSizes(
1050 : ::google::protobuf::io::CodedOutputStream* output) const final;
1051 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1052 : bool deterministic, ::google::protobuf::uint8* target) const final;
1053 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1054 :
1055 : private:
1056 : void SharedCtor();
1057 : void SharedDtor();
1058 : void SetCachedSize(int size) const final;
1059 : void InternalSwap(Path* other);
1060 : private:
1061 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1062 0 : return NULL;
1063 : }
1064 : inline void* MaybeArenaPtr() const {
1065 : return NULL;
1066 : }
1067 : public:
1068 :
1069 : ::google::protobuf::Metadata GetMetadata() const final;
1070 :
1071 : // nested types ----------------------------------------------------
1072 :
1073 : // accessors -------------------------------------------------------
1074 :
1075 : // string path = 1;
1076 : void clear_path();
1077 : static const int kPathFieldNumber = 1;
1078 : const ::std::string& path() const;
1079 : void set_path(const ::std::string& value);
1080 : #if LANG_CXX11
1081 : void set_path(::std::string&& value);
1082 : #endif
1083 : void set_path(const char* value);
1084 : void set_path(const char* value, size_t size);
1085 : ::std::string* mutable_path();
1086 : ::std::string* release_path();
1087 : void set_allocated_path(::std::string* path);
1088 :
1089 : // @@protoc_insertion_point(class_scope:rpc.img.Path)
1090 : private:
1091 :
1092 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1093 : ::google::protobuf::internal::ArenaStringPtr path_;
1094 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
1095 : friend struct ::protobuf_img_2eproto::TableStruct;
1096 : };
1097 : // -------------------------------------------------------------------
1098 :
1099 : class Coord2D : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.Coord2D) */ {
1100 : public:
1101 : Coord2D();
1102 : virtual ~Coord2D();
1103 :
1104 : Coord2D(const Coord2D& from);
1105 :
1106 : inline Coord2D& operator=(const Coord2D& from) {
1107 : CopyFrom(from);
1108 : return *this;
1109 : }
1110 : #if LANG_CXX11
1111 : Coord2D(Coord2D&& from) noexcept
1112 : : Coord2D() {
1113 : *this = ::std::move(from);
1114 : }
1115 :
1116 : inline Coord2D& operator=(Coord2D&& from) noexcept {
1117 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1118 : if (this != &from) InternalSwap(&from);
1119 : } else {
1120 : CopyFrom(from);
1121 : }
1122 : return *this;
1123 : }
1124 : #endif
1125 : static const ::google::protobuf::Descriptor* descriptor();
1126 : static const Coord2D& default_instance();
1127 :
1128 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1129 20 : static inline const Coord2D* internal_default_instance() {
1130 : return reinterpret_cast<const Coord2D*>(
1131 20 : &_Coord2D_default_instance_);
1132 : }
1133 : static constexpr int kIndexInFileMessages =
1134 : 8;
1135 :
1136 : void Swap(Coord2D* other);
1137 : friend void swap(Coord2D& a, Coord2D& b) {
1138 : a.Swap(&b);
1139 : }
1140 :
1141 : // implements Message ----------------------------------------------
1142 :
1143 0 : inline Coord2D* New() const final {
1144 0 : return CreateMaybeMessage<Coord2D>(NULL);
1145 : }
1146 :
1147 0 : Coord2D* New(::google::protobuf::Arena* arena) const final {
1148 0 : return CreateMaybeMessage<Coord2D>(arena);
1149 : }
1150 : void CopyFrom(const ::google::protobuf::Message& from) final;
1151 : void MergeFrom(const ::google::protobuf::Message& from) final;
1152 : void CopyFrom(const Coord2D& from);
1153 : void MergeFrom(const Coord2D& from);
1154 : void Clear() final;
1155 : bool IsInitialized() const final;
1156 :
1157 : size_t ByteSizeLong() const final;
1158 : bool MergePartialFromCodedStream(
1159 : ::google::protobuf::io::CodedInputStream* input) final;
1160 : void SerializeWithCachedSizes(
1161 : ::google::protobuf::io::CodedOutputStream* output) const final;
1162 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1163 : bool deterministic, ::google::protobuf::uint8* target) const final;
1164 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1165 :
1166 : private:
1167 : void SharedCtor();
1168 : void SharedDtor();
1169 : void SetCachedSize(int size) const final;
1170 : void InternalSwap(Coord2D* other);
1171 : private:
1172 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1173 : return NULL;
1174 : }
1175 : inline void* MaybeArenaPtr() const {
1176 : return NULL;
1177 : }
1178 : public:
1179 :
1180 : ::google::protobuf::Metadata GetMetadata() const final;
1181 :
1182 : // nested types ----------------------------------------------------
1183 :
1184 : // accessors -------------------------------------------------------
1185 :
1186 : // float x = 1;
1187 : void clear_x();
1188 : static const int kXFieldNumber = 1;
1189 : float x() const;
1190 : void set_x(float value);
1191 :
1192 : // float y = 2;
1193 : void clear_y();
1194 : static const int kYFieldNumber = 2;
1195 : float y() const;
1196 : void set_y(float value);
1197 :
1198 : // @@protoc_insertion_point(class_scope:rpc.img.Coord2D)
1199 : private:
1200 :
1201 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1202 : float x_;
1203 : float y_;
1204 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
1205 : friend struct ::protobuf_img_2eproto::TableStruct;
1206 : };
1207 : // -------------------------------------------------------------------
1208 :
1209 : class Output : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.Output) */ {
1210 : public:
1211 : Output();
1212 : virtual ~Output();
1213 :
1214 : Output(const Output& from);
1215 :
1216 : inline Output& operator=(const Output& from) {
1217 : CopyFrom(from);
1218 : return *this;
1219 : }
1220 : #if LANG_CXX11
1221 : Output(Output&& from) noexcept
1222 : : Output() {
1223 : *this = ::std::move(from);
1224 : }
1225 :
1226 : inline Output& operator=(Output&& from) noexcept {
1227 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1228 : if (this != &from) InternalSwap(&from);
1229 : } else {
1230 : CopyFrom(from);
1231 : }
1232 : return *this;
1233 : }
1234 : #endif
1235 : static const ::google::protobuf::Descriptor* descriptor();
1236 : static const Output& default_instance();
1237 :
1238 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1239 0 : static inline const Output* internal_default_instance() {
1240 : return reinterpret_cast<const Output*>(
1241 0 : &_Output_default_instance_);
1242 : }
1243 : static constexpr int kIndexInFileMessages =
1244 : 9;
1245 :
1246 : void Swap(Output* other);
1247 : friend void swap(Output& a, Output& b) {
1248 : a.Swap(&b);
1249 : }
1250 :
1251 : // implements Message ----------------------------------------------
1252 :
1253 0 : inline Output* New() const final {
1254 0 : return CreateMaybeMessage<Output>(NULL);
1255 : }
1256 :
1257 0 : Output* New(::google::protobuf::Arena* arena) const final {
1258 0 : return CreateMaybeMessage<Output>(arena);
1259 : }
1260 : void CopyFrom(const ::google::protobuf::Message& from) final;
1261 : void MergeFrom(const ::google::protobuf::Message& from) final;
1262 : void CopyFrom(const Output& from);
1263 : void MergeFrom(const Output& from);
1264 : void Clear() final;
1265 : bool IsInitialized() const final;
1266 :
1267 : size_t ByteSizeLong() const final;
1268 : bool MergePartialFromCodedStream(
1269 : ::google::protobuf::io::CodedInputStream* input) final;
1270 : void SerializeWithCachedSizes(
1271 : ::google::protobuf::io::CodedOutputStream* output) const final;
1272 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1273 : bool deterministic, ::google::protobuf::uint8* target) const final;
1274 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1275 :
1276 : private:
1277 : void SharedCtor();
1278 : void SharedDtor();
1279 : void SetCachedSize(int size) const final;
1280 : void InternalSwap(Output* other);
1281 : private:
1282 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1283 0 : return NULL;
1284 : }
1285 : inline void* MaybeArenaPtr() const {
1286 : return NULL;
1287 : }
1288 : public:
1289 :
1290 : ::google::protobuf::Metadata GetMetadata() const final;
1291 :
1292 : // nested types ----------------------------------------------------
1293 :
1294 : // accessors -------------------------------------------------------
1295 :
1296 : // string device = 2;
1297 : void clear_device();
1298 : static const int kDeviceFieldNumber = 2;
1299 : const ::std::string& device() const;
1300 : void set_device(const ::std::string& value);
1301 : #if LANG_CXX11
1302 : void set_device(::std::string&& value);
1303 : #endif
1304 : void set_device(const char* value);
1305 : void set_device(const char* value, size_t size);
1306 : ::std::string* mutable_device();
1307 : ::std::string* release_device();
1308 : void set_allocated_device(::std::string* device);
1309 :
1310 : // string devicetype = 3;
1311 : void clear_devicetype();
1312 : static const int kDevicetypeFieldNumber = 3;
1313 : const ::std::string& devicetype() const;
1314 : void set_devicetype(const ::std::string& value);
1315 : #if LANG_CXX11
1316 : void set_devicetype(::std::string&& value);
1317 : #endif
1318 : void set_devicetype(const char* value);
1319 : void set_devicetype(const char* value, size_t size);
1320 : ::std::string* mutable_devicetype();
1321 : ::std::string* release_devicetype();
1322 : void set_allocated_devicetype(::std::string* devicetype);
1323 :
1324 : // string orientation = 4;
1325 : void clear_orientation();
1326 : static const int kOrientationFieldNumber = 4;
1327 : const ::std::string& orientation() const;
1328 : void set_orientation(const ::std::string& value);
1329 : #if LANG_CXX11
1330 : void set_orientation(::std::string&& value);
1331 : #endif
1332 : void set_orientation(const char* value);
1333 : void set_orientation(const char* value, size_t size);
1334 : ::std::string* mutable_orientation();
1335 : ::std::string* release_orientation();
1336 : void set_allocated_orientation(::std::string* orientation);
1337 :
1338 : // string media = 5;
1339 : void clear_media();
1340 : static const int kMediaFieldNumber = 5;
1341 : const ::std::string& media() const;
1342 : void set_media(const ::std::string& value);
1343 : #if LANG_CXX11
1344 : void set_media(::std::string&& value);
1345 : #endif
1346 : void set_media(const char* value);
1347 : void set_media(const char* value, size_t size);
1348 : ::std::string* mutable_media();
1349 : ::std::string* release_media();
1350 : void set_allocated_media(::std::string* media);
1351 :
1352 : // string format = 6;
1353 : void clear_format();
1354 : static const int kFormatFieldNumber = 6;
1355 : const ::std::string& format() const;
1356 : void set_format(const ::std::string& value);
1357 : #if LANG_CXX11
1358 : void set_format(::std::string&& value);
1359 : #endif
1360 : void set_format(const char* value);
1361 : void set_format(const char* value, size_t size);
1362 : ::std::string* mutable_format();
1363 : ::std::string* release_format();
1364 : void set_allocated_format(::std::string* format);
1365 :
1366 : // .rpc.img.Id panel = 1;
1367 : bool has_panel() const;
1368 : void clear_panel();
1369 : static const int kPanelFieldNumber = 1;
1370 : private:
1371 : const ::rpc::img::Id& _internal_panel() const;
1372 : public:
1373 : const ::rpc::img::Id& panel() const;
1374 : ::rpc::img::Id* release_panel();
1375 : ::rpc::img::Id* mutable_panel();
1376 : void set_allocated_panel(::rpc::img::Id* panel);
1377 :
1378 : // float scale = 7;
1379 : void clear_scale();
1380 : static const int kScaleFieldNumber = 7;
1381 : float scale() const;
1382 : void set_scale(float value);
1383 :
1384 : // int32 dpi = 8;
1385 : void clear_dpi();
1386 : static const int kDpiFieldNumber = 8;
1387 : ::google::protobuf::int32 dpi() const;
1388 : void set_dpi(::google::protobuf::int32 value);
1389 :
1390 : // @@protoc_insertion_point(class_scope:rpc.img.Output)
1391 : private:
1392 :
1393 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1394 : ::google::protobuf::internal::ArenaStringPtr device_;
1395 : ::google::protobuf::internal::ArenaStringPtr devicetype_;
1396 : ::google::protobuf::internal::ArenaStringPtr orientation_;
1397 : ::google::protobuf::internal::ArenaStringPtr media_;
1398 : ::google::protobuf::internal::ArenaStringPtr format_;
1399 : ::rpc::img::Id* panel_;
1400 : float scale_;
1401 : ::google::protobuf::int32 dpi_;
1402 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
1403 : friend struct ::protobuf_img_2eproto::TableStruct;
1404 : };
1405 : // -------------------------------------------------------------------
1406 :
1407 : class SetChannel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.SetChannel) */ {
1408 : public:
1409 : SetChannel();
1410 : virtual ~SetChannel();
1411 :
1412 : SetChannel(const SetChannel& from);
1413 :
1414 : inline SetChannel& operator=(const SetChannel& from) {
1415 : CopyFrom(from);
1416 : return *this;
1417 : }
1418 : #if LANG_CXX11
1419 : SetChannel(SetChannel&& from) noexcept
1420 : : SetChannel() {
1421 : *this = ::std::move(from);
1422 : }
1423 :
1424 : inline SetChannel& operator=(SetChannel&& from) noexcept {
1425 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1426 : if (this != &from) InternalSwap(&from);
1427 : } else {
1428 : CopyFrom(from);
1429 : }
1430 : return *this;
1431 : }
1432 : #endif
1433 : static const ::google::protobuf::Descriptor* descriptor();
1434 : static const SetChannel& default_instance();
1435 :
1436 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1437 0 : static inline const SetChannel* internal_default_instance() {
1438 : return reinterpret_cast<const SetChannel*>(
1439 0 : &_SetChannel_default_instance_);
1440 : }
1441 : static constexpr int kIndexInFileMessages =
1442 : 10;
1443 :
1444 : void Swap(SetChannel* other);
1445 : friend void swap(SetChannel& a, SetChannel& b) {
1446 : a.Swap(&b);
1447 : }
1448 :
1449 : // implements Message ----------------------------------------------
1450 :
1451 0 : inline SetChannel* New() const final {
1452 0 : return CreateMaybeMessage<SetChannel>(NULL);
1453 : }
1454 :
1455 0 : SetChannel* New(::google::protobuf::Arena* arena) const final {
1456 0 : return CreateMaybeMessage<SetChannel>(arena);
1457 : }
1458 : void CopyFrom(const ::google::protobuf::Message& from) final;
1459 : void MergeFrom(const ::google::protobuf::Message& from) final;
1460 : void CopyFrom(const SetChannel& from);
1461 : void MergeFrom(const SetChannel& from);
1462 : void Clear() final;
1463 : bool IsInitialized() const final;
1464 :
1465 : size_t ByteSizeLong() const final;
1466 : bool MergePartialFromCodedStream(
1467 : ::google::protobuf::io::CodedInputStream* input) final;
1468 : void SerializeWithCachedSizes(
1469 : ::google::protobuf::io::CodedOutputStream* output) const final;
1470 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1471 : bool deterministic, ::google::protobuf::uint8* target) const final;
1472 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1473 :
1474 : private:
1475 : void SharedCtor();
1476 : void SharedDtor();
1477 : void SetCachedSize(int size) const final;
1478 : void InternalSwap(SetChannel* other);
1479 : private:
1480 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1481 0 : return NULL;
1482 : }
1483 : inline void* MaybeArenaPtr() const {
1484 : return NULL;
1485 : }
1486 : public:
1487 :
1488 : ::google::protobuf::Metadata GetMetadata() const final;
1489 :
1490 : // nested types ----------------------------------------------------
1491 :
1492 : // accessors -------------------------------------------------------
1493 :
1494 : // .rpc.img.Id panel = 1;
1495 : bool has_panel() const;
1496 : void clear_panel();
1497 : static const int kPanelFieldNumber = 1;
1498 : private:
1499 : const ::rpc::img::Id& _internal_panel() const;
1500 : public:
1501 : const ::rpc::img::Id& panel() const;
1502 : ::rpc::img::Id* release_panel();
1503 : ::rpc::img::Id* mutable_panel();
1504 : void set_allocated_panel(::rpc::img::Id* panel);
1505 :
1506 : // int32 number = 2;
1507 : void clear_number();
1508 : static const int kNumberFieldNumber = 2;
1509 : ::google::protobuf::int32 number() const;
1510 : void set_number(::google::protobuf::int32 value);
1511 :
1512 : // @@protoc_insertion_point(class_scope:rpc.img.SetChannel)
1513 : private:
1514 :
1515 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1516 : ::rpc::img::Id* panel_;
1517 : ::google::protobuf::int32 number_;
1518 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
1519 : friend struct ::protobuf_img_2eproto::TableStruct;
1520 : };
1521 : // -------------------------------------------------------------------
1522 :
1523 : class SetZoomLevel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.SetZoomLevel) */ {
1524 : public:
1525 : SetZoomLevel();
1526 : virtual ~SetZoomLevel();
1527 :
1528 : SetZoomLevel(const SetZoomLevel& from);
1529 :
1530 : inline SetZoomLevel& operator=(const SetZoomLevel& from) {
1531 : CopyFrom(from);
1532 : return *this;
1533 : }
1534 : #if LANG_CXX11
1535 : SetZoomLevel(SetZoomLevel&& from) noexcept
1536 : : SetZoomLevel() {
1537 : *this = ::std::move(from);
1538 : }
1539 :
1540 : inline SetZoomLevel& operator=(SetZoomLevel&& from) noexcept {
1541 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1542 : if (this != &from) InternalSwap(&from);
1543 : } else {
1544 : CopyFrom(from);
1545 : }
1546 : return *this;
1547 : }
1548 : #endif
1549 : static const ::google::protobuf::Descriptor* descriptor();
1550 : static const SetZoomLevel& default_instance();
1551 :
1552 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1553 0 : static inline const SetZoomLevel* internal_default_instance() {
1554 : return reinterpret_cast<const SetZoomLevel*>(
1555 0 : &_SetZoomLevel_default_instance_);
1556 : }
1557 : static constexpr int kIndexInFileMessages =
1558 : 11;
1559 :
1560 : void Swap(SetZoomLevel* other);
1561 : friend void swap(SetZoomLevel& a, SetZoomLevel& b) {
1562 : a.Swap(&b);
1563 : }
1564 :
1565 : // implements Message ----------------------------------------------
1566 :
1567 0 : inline SetZoomLevel* New() const final {
1568 0 : return CreateMaybeMessage<SetZoomLevel>(NULL);
1569 : }
1570 :
1571 0 : SetZoomLevel* New(::google::protobuf::Arena* arena) const final {
1572 0 : return CreateMaybeMessage<SetZoomLevel>(arena);
1573 : }
1574 : void CopyFrom(const ::google::protobuf::Message& from) final;
1575 : void MergeFrom(const ::google::protobuf::Message& from) final;
1576 : void CopyFrom(const SetZoomLevel& from);
1577 : void MergeFrom(const SetZoomLevel& from);
1578 : void Clear() final;
1579 : bool IsInitialized() const final;
1580 :
1581 : size_t ByteSizeLong() const final;
1582 : bool MergePartialFromCodedStream(
1583 : ::google::protobuf::io::CodedInputStream* input) final;
1584 : void SerializeWithCachedSizes(
1585 : ::google::protobuf::io::CodedOutputStream* output) const final;
1586 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1587 : bool deterministic, ::google::protobuf::uint8* target) const final;
1588 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1589 :
1590 : private:
1591 : void SharedCtor();
1592 : void SharedDtor();
1593 : void SetCachedSize(int size) const final;
1594 : void InternalSwap(SetZoomLevel* other);
1595 : private:
1596 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1597 0 : return NULL;
1598 : }
1599 : inline void* MaybeArenaPtr() const {
1600 : return NULL;
1601 : }
1602 : public:
1603 :
1604 : ::google::protobuf::Metadata GetMetadata() const final;
1605 :
1606 : // nested types ----------------------------------------------------
1607 :
1608 : // accessors -------------------------------------------------------
1609 :
1610 : // .rpc.img.Id panel = 1;
1611 : bool has_panel() const;
1612 : void clear_panel();
1613 : static const int kPanelFieldNumber = 1;
1614 : private:
1615 : const ::rpc::img::Id& _internal_panel() const;
1616 : public:
1617 : const ::rpc::img::Id& panel() const;
1618 : ::rpc::img::Id* release_panel();
1619 : ::rpc::img::Id* mutable_panel();
1620 : void set_allocated_panel(::rpc::img::Id* panel);
1621 :
1622 : // int32 level = 2;
1623 : void clear_level();
1624 : static const int kLevelFieldNumber = 2;
1625 : ::google::protobuf::int32 level() const;
1626 : void set_level(::google::protobuf::int32 value);
1627 :
1628 : // @@protoc_insertion_point(class_scope:rpc.img.SetZoomLevel)
1629 : private:
1630 :
1631 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1632 : ::rpc::img::Id* panel_;
1633 : ::google::protobuf::int32 level_;
1634 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
1635 : friend struct ::protobuf_img_2eproto::TableStruct;
1636 : };
1637 : // -------------------------------------------------------------------
1638 :
1639 : class SetZoomBox : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.SetZoomBox) */ {
1640 : public:
1641 : SetZoomBox();
1642 : virtual ~SetZoomBox();
1643 :
1644 : SetZoomBox(const SetZoomBox& from);
1645 :
1646 : inline SetZoomBox& operator=(const SetZoomBox& from) {
1647 : CopyFrom(from);
1648 : return *this;
1649 : }
1650 : #if LANG_CXX11
1651 : SetZoomBox(SetZoomBox&& from) noexcept
1652 : : SetZoomBox() {
1653 : *this = ::std::move(from);
1654 : }
1655 :
1656 : inline SetZoomBox& operator=(SetZoomBox&& from) noexcept {
1657 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1658 : if (this != &from) InternalSwap(&from);
1659 : } else {
1660 : CopyFrom(from);
1661 : }
1662 : return *this;
1663 : }
1664 : #endif
1665 : static const ::google::protobuf::Descriptor* descriptor();
1666 : static const SetZoomBox& default_instance();
1667 :
1668 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1669 0 : static inline const SetZoomBox* internal_default_instance() {
1670 : return reinterpret_cast<const SetZoomBox*>(
1671 0 : &_SetZoomBox_default_instance_);
1672 : }
1673 : static constexpr int kIndexInFileMessages =
1674 : 12;
1675 :
1676 : void Swap(SetZoomBox* other);
1677 : friend void swap(SetZoomBox& a, SetZoomBox& b) {
1678 : a.Swap(&b);
1679 : }
1680 :
1681 : // implements Message ----------------------------------------------
1682 :
1683 0 : inline SetZoomBox* New() const final {
1684 0 : return CreateMaybeMessage<SetZoomBox>(NULL);
1685 : }
1686 :
1687 0 : SetZoomBox* New(::google::protobuf::Arena* arena) const final {
1688 0 : return CreateMaybeMessage<SetZoomBox>(arena);
1689 : }
1690 : void CopyFrom(const ::google::protobuf::Message& from) final;
1691 : void MergeFrom(const ::google::protobuf::Message& from) final;
1692 : void CopyFrom(const SetZoomBox& from);
1693 : void MergeFrom(const SetZoomBox& from);
1694 : void Clear() final;
1695 : bool IsInitialized() const final;
1696 :
1697 : size_t ByteSizeLong() const final;
1698 : bool MergePartialFromCodedStream(
1699 : ::google::protobuf::io::CodedInputStream* input) final;
1700 : void SerializeWithCachedSizes(
1701 : ::google::protobuf::io::CodedOutputStream* output) const final;
1702 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1703 : bool deterministic, ::google::protobuf::uint8* target) const final;
1704 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1705 :
1706 : private:
1707 : void SharedCtor();
1708 : void SharedDtor();
1709 : void SetCachedSize(int size) const final;
1710 : void InternalSwap(SetZoomBox* other);
1711 : private:
1712 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1713 0 : return NULL;
1714 : }
1715 : inline void* MaybeArenaPtr() const {
1716 : return NULL;
1717 : }
1718 : public:
1719 :
1720 : ::google::protobuf::Metadata GetMetadata() const final;
1721 :
1722 : // nested types ----------------------------------------------------
1723 :
1724 : // accessors -------------------------------------------------------
1725 :
1726 : // string coord_type = 4;
1727 : void clear_coord_type();
1728 : static const int kCoordTypeFieldNumber = 4;
1729 : const ::std::string& coord_type() const;
1730 : void set_coord_type(const ::std::string& value);
1731 : #if LANG_CXX11
1732 : void set_coord_type(::std::string&& value);
1733 : #endif
1734 : void set_coord_type(const char* value);
1735 : void set_coord_type(const char* value, size_t size);
1736 : ::std::string* mutable_coord_type();
1737 : ::std::string* release_coord_type();
1738 : void set_allocated_coord_type(::std::string* coord_type);
1739 :
1740 : // .rpc.img.Id panel = 1;
1741 : bool has_panel() const;
1742 : void clear_panel();
1743 : static const int kPanelFieldNumber = 1;
1744 : private:
1745 : const ::rpc::img::Id& _internal_panel() const;
1746 : public:
1747 : const ::rpc::img::Id& panel() const;
1748 : ::rpc::img::Id* release_panel();
1749 : ::rpc::img::Id* mutable_panel();
1750 : void set_allocated_panel(::rpc::img::Id* panel);
1751 :
1752 : // .rpc.img.Coord2D blc = 2;
1753 : bool has_blc() const;
1754 : void clear_blc();
1755 : static const int kBlcFieldNumber = 2;
1756 : private:
1757 : const ::rpc::img::Coord2D& _internal_blc() const;
1758 : public:
1759 : const ::rpc::img::Coord2D& blc() const;
1760 : ::rpc::img::Coord2D* release_blc();
1761 : ::rpc::img::Coord2D* mutable_blc();
1762 : void set_allocated_blc(::rpc::img::Coord2D* blc);
1763 :
1764 : // .rpc.img.Coord2D trc = 3;
1765 : bool has_trc() const;
1766 : void clear_trc();
1767 : static const int kTrcFieldNumber = 3;
1768 : private:
1769 : const ::rpc::img::Coord2D& _internal_trc() const;
1770 : public:
1771 : const ::rpc::img::Coord2D& trc() const;
1772 : ::rpc::img::Coord2D* release_trc();
1773 : ::rpc::img::Coord2D* mutable_trc();
1774 : void set_allocated_trc(::rpc::img::Coord2D* trc);
1775 :
1776 : // @@protoc_insertion_point(class_scope:rpc.img.SetZoomBox)
1777 : private:
1778 :
1779 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1780 : ::google::protobuf::internal::ArenaStringPtr coord_type_;
1781 : ::rpc::img::Id* panel_;
1782 : ::rpc::img::Coord2D* blc_;
1783 : ::rpc::img::Coord2D* trc_;
1784 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
1785 : friend struct ::protobuf_img_2eproto::TableStruct;
1786 : };
1787 : // -------------------------------------------------------------------
1788 :
1789 : class DataRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.DataRange) */ {
1790 : public:
1791 : DataRange();
1792 : virtual ~DataRange();
1793 :
1794 : DataRange(const DataRange& from);
1795 :
1796 : inline DataRange& operator=(const DataRange& from) {
1797 : CopyFrom(from);
1798 : return *this;
1799 : }
1800 : #if LANG_CXX11
1801 : DataRange(DataRange&& from) noexcept
1802 : : DataRange() {
1803 : *this = ::std::move(from);
1804 : }
1805 :
1806 : inline DataRange& operator=(DataRange&& from) noexcept {
1807 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1808 : if (this != &from) InternalSwap(&from);
1809 : } else {
1810 : CopyFrom(from);
1811 : }
1812 : return *this;
1813 : }
1814 : #endif
1815 : static const ::google::protobuf::Descriptor* descriptor();
1816 : static const DataRange& default_instance();
1817 :
1818 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1819 0 : static inline const DataRange* internal_default_instance() {
1820 : return reinterpret_cast<const DataRange*>(
1821 0 : &_DataRange_default_instance_);
1822 : }
1823 : static constexpr int kIndexInFileMessages =
1824 : 13;
1825 :
1826 : void Swap(DataRange* other);
1827 : friend void swap(DataRange& a, DataRange& b) {
1828 : a.Swap(&b);
1829 : }
1830 :
1831 : // implements Message ----------------------------------------------
1832 :
1833 0 : inline DataRange* New() const final {
1834 0 : return CreateMaybeMessage<DataRange>(NULL);
1835 : }
1836 :
1837 0 : DataRange* New(::google::protobuf::Arena* arena) const final {
1838 0 : return CreateMaybeMessage<DataRange>(arena);
1839 : }
1840 : void CopyFrom(const ::google::protobuf::Message& from) final;
1841 : void MergeFrom(const ::google::protobuf::Message& from) final;
1842 : void CopyFrom(const DataRange& from);
1843 : void MergeFrom(const DataRange& from);
1844 : void Clear() final;
1845 : bool IsInitialized() const final;
1846 :
1847 : size_t ByteSizeLong() const final;
1848 : bool MergePartialFromCodedStream(
1849 : ::google::protobuf::io::CodedInputStream* input) final;
1850 : void SerializeWithCachedSizes(
1851 : ::google::protobuf::io::CodedOutputStream* output) const final;
1852 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1853 : bool deterministic, ::google::protobuf::uint8* target) const final;
1854 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1855 :
1856 : private:
1857 : void SharedCtor();
1858 : void SharedDtor();
1859 : void SetCachedSize(int size) const final;
1860 : void InternalSwap(DataRange* other);
1861 : private:
1862 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1863 0 : return NULL;
1864 : }
1865 : inline void* MaybeArenaPtr() const {
1866 : return NULL;
1867 : }
1868 : public:
1869 :
1870 : ::google::protobuf::Metadata GetMetadata() const final;
1871 :
1872 : // nested types ----------------------------------------------------
1873 :
1874 : // accessors -------------------------------------------------------
1875 :
1876 : // .rpc.img.Id data = 1;
1877 : bool has_data() const;
1878 : void clear_data();
1879 : static const int kDataFieldNumber = 1;
1880 : private:
1881 : const ::rpc::img::Id& _internal_data() const;
1882 : public:
1883 : const ::rpc::img::Id& data() const;
1884 : ::rpc::img::Id* release_data();
1885 : ::rpc::img::Id* mutable_data();
1886 : void set_allocated_data(::rpc::img::Id* data);
1887 :
1888 : // float min = 2;
1889 : void clear_min();
1890 : static const int kMinFieldNumber = 2;
1891 : float min() const;
1892 : void set_min(float value);
1893 :
1894 : // float max = 3;
1895 : void clear_max();
1896 : static const int kMaxFieldNumber = 3;
1897 : float max() const;
1898 : void set_max(float value);
1899 :
1900 : // @@protoc_insertion_point(class_scope:rpc.img.DataRange)
1901 : private:
1902 :
1903 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1904 : ::rpc::img::Id* data_;
1905 : float min_;
1906 : float max_;
1907 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
1908 : friend struct ::protobuf_img_2eproto::TableStruct;
1909 : };
1910 : // -------------------------------------------------------------------
1911 :
1912 : class ContourLevels : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.ContourLevels) */ {
1913 : public:
1914 : ContourLevels();
1915 : virtual ~ContourLevels();
1916 :
1917 : ContourLevels(const ContourLevels& from);
1918 :
1919 : inline ContourLevels& operator=(const ContourLevels& from) {
1920 : CopyFrom(from);
1921 : return *this;
1922 : }
1923 : #if LANG_CXX11
1924 : ContourLevels(ContourLevels&& from) noexcept
1925 : : ContourLevels() {
1926 : *this = ::std::move(from);
1927 : }
1928 :
1929 : inline ContourLevels& operator=(ContourLevels&& from) noexcept {
1930 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1931 : if (this != &from) InternalSwap(&from);
1932 : } else {
1933 : CopyFrom(from);
1934 : }
1935 : return *this;
1936 : }
1937 : #endif
1938 : static const ::google::protobuf::Descriptor* descriptor();
1939 : static const ContourLevels& default_instance();
1940 :
1941 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1942 0 : static inline const ContourLevels* internal_default_instance() {
1943 : return reinterpret_cast<const ContourLevels*>(
1944 0 : &_ContourLevels_default_instance_);
1945 : }
1946 : static constexpr int kIndexInFileMessages =
1947 : 14;
1948 :
1949 : void Swap(ContourLevels* other);
1950 : friend void swap(ContourLevels& a, ContourLevels& b) {
1951 : a.Swap(&b);
1952 : }
1953 :
1954 : // implements Message ----------------------------------------------
1955 :
1956 0 : inline ContourLevels* New() const final {
1957 0 : return CreateMaybeMessage<ContourLevels>(NULL);
1958 : }
1959 :
1960 0 : ContourLevels* New(::google::protobuf::Arena* arena) const final {
1961 0 : return CreateMaybeMessage<ContourLevels>(arena);
1962 : }
1963 : void CopyFrom(const ::google::protobuf::Message& from) final;
1964 : void MergeFrom(const ::google::protobuf::Message& from) final;
1965 : void CopyFrom(const ContourLevels& from);
1966 : void MergeFrom(const ContourLevels& from);
1967 : void Clear() final;
1968 : bool IsInitialized() const final;
1969 :
1970 : size_t ByteSizeLong() const final;
1971 : bool MergePartialFromCodedStream(
1972 : ::google::protobuf::io::CodedInputStream* input) final;
1973 : void SerializeWithCachedSizes(
1974 : ::google::protobuf::io::CodedOutputStream* output) const final;
1975 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1976 : bool deterministic, ::google::protobuf::uint8* target) const final;
1977 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
1978 :
1979 : private:
1980 : void SharedCtor();
1981 : void SharedDtor();
1982 : void SetCachedSize(int size) const final;
1983 : void InternalSwap(ContourLevels* other);
1984 : private:
1985 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1986 0 : return NULL;
1987 : }
1988 : inline void* MaybeArenaPtr() const {
1989 : return NULL;
1990 : }
1991 : public:
1992 :
1993 : ::google::protobuf::Metadata GetMetadata() const final;
1994 :
1995 : // nested types ----------------------------------------------------
1996 :
1997 : // accessors -------------------------------------------------------
1998 :
1999 : // repeated float levels = 2;
2000 : int levels_size() const;
2001 : void clear_levels();
2002 : static const int kLevelsFieldNumber = 2;
2003 : float levels(int index) const;
2004 : void set_levels(int index, float value);
2005 : void add_levels(float value);
2006 : const ::google::protobuf::RepeatedField< float >&
2007 : levels() const;
2008 : ::google::protobuf::RepeatedField< float >*
2009 : mutable_levels();
2010 :
2011 : // .rpc.img.Id id = 1;
2012 : bool has_id() const;
2013 : void clear_id();
2014 : static const int kIdFieldNumber = 1;
2015 : private:
2016 : const ::rpc::img::Id& _internal_id() const;
2017 : public:
2018 : const ::rpc::img::Id& id() const;
2019 : ::rpc::img::Id* release_id();
2020 : ::rpc::img::Id* mutable_id();
2021 : void set_allocated_id(::rpc::img::Id* id);
2022 :
2023 : // float baselevel = 3;
2024 : void clear_baselevel();
2025 : static const int kBaselevelFieldNumber = 3;
2026 : float baselevel() const;
2027 : void set_baselevel(float value);
2028 :
2029 : // float unitlevel = 4;
2030 : void clear_unitlevel();
2031 : static const int kUnitlevelFieldNumber = 4;
2032 : float unitlevel() const;
2033 : void set_unitlevel(float value);
2034 :
2035 : // @@protoc_insertion_point(class_scope:rpc.img.ContourLevels)
2036 : private:
2037 :
2038 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2039 : ::google::protobuf::RepeatedField< float > levels_;
2040 : mutable int _levels_cached_byte_size_;
2041 : ::rpc::img::Id* id_;
2042 : float baselevel_;
2043 : float unitlevel_;
2044 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2045 : friend struct ::protobuf_img_2eproto::TableStruct;
2046 : };
2047 : // -------------------------------------------------------------------
2048 :
2049 : class ContourThickness : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.ContourThickness) */ {
2050 : public:
2051 : ContourThickness();
2052 : virtual ~ContourThickness();
2053 :
2054 : ContourThickness(const ContourThickness& from);
2055 :
2056 : inline ContourThickness& operator=(const ContourThickness& from) {
2057 : CopyFrom(from);
2058 : return *this;
2059 : }
2060 : #if LANG_CXX11
2061 : ContourThickness(ContourThickness&& from) noexcept
2062 : : ContourThickness() {
2063 : *this = ::std::move(from);
2064 : }
2065 :
2066 : inline ContourThickness& operator=(ContourThickness&& from) noexcept {
2067 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2068 : if (this != &from) InternalSwap(&from);
2069 : } else {
2070 : CopyFrom(from);
2071 : }
2072 : return *this;
2073 : }
2074 : #endif
2075 : static const ::google::protobuf::Descriptor* descriptor();
2076 : static const ContourThickness& default_instance();
2077 :
2078 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2079 0 : static inline const ContourThickness* internal_default_instance() {
2080 : return reinterpret_cast<const ContourThickness*>(
2081 0 : &_ContourThickness_default_instance_);
2082 : }
2083 : static constexpr int kIndexInFileMessages =
2084 : 15;
2085 :
2086 : void Swap(ContourThickness* other);
2087 : friend void swap(ContourThickness& a, ContourThickness& b) {
2088 : a.Swap(&b);
2089 : }
2090 :
2091 : // implements Message ----------------------------------------------
2092 :
2093 0 : inline ContourThickness* New() const final {
2094 0 : return CreateMaybeMessage<ContourThickness>(NULL);
2095 : }
2096 :
2097 0 : ContourThickness* New(::google::protobuf::Arena* arena) const final {
2098 0 : return CreateMaybeMessage<ContourThickness>(arena);
2099 : }
2100 : void CopyFrom(const ::google::protobuf::Message& from) final;
2101 : void MergeFrom(const ::google::protobuf::Message& from) final;
2102 : void CopyFrom(const ContourThickness& from);
2103 : void MergeFrom(const ContourThickness& from);
2104 : void Clear() final;
2105 : bool IsInitialized() const final;
2106 :
2107 : size_t ByteSizeLong() const final;
2108 : bool MergePartialFromCodedStream(
2109 : ::google::protobuf::io::CodedInputStream* input) final;
2110 : void SerializeWithCachedSizes(
2111 : ::google::protobuf::io::CodedOutputStream* output) const final;
2112 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2113 : bool deterministic, ::google::protobuf::uint8* target) const final;
2114 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
2115 :
2116 : private:
2117 : void SharedCtor();
2118 : void SharedDtor();
2119 : void SetCachedSize(int size) const final;
2120 : void InternalSwap(ContourThickness* other);
2121 : private:
2122 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2123 0 : return NULL;
2124 : }
2125 : inline void* MaybeArenaPtr() const {
2126 : return NULL;
2127 : }
2128 : public:
2129 :
2130 : ::google::protobuf::Metadata GetMetadata() const final;
2131 :
2132 : // nested types ----------------------------------------------------
2133 :
2134 : // accessors -------------------------------------------------------
2135 :
2136 : // .rpc.img.Id id = 1;
2137 : bool has_id() const;
2138 : void clear_id();
2139 : static const int kIdFieldNumber = 1;
2140 : private:
2141 : const ::rpc::img::Id& _internal_id() const;
2142 : public:
2143 : const ::rpc::img::Id& id() const;
2144 : ::rpc::img::Id* release_id();
2145 : ::rpc::img::Id* mutable_id();
2146 : void set_allocated_id(::rpc::img::Id* id);
2147 :
2148 : // float thickness = 2;
2149 : void clear_thickness();
2150 : static const int kThicknessFieldNumber = 2;
2151 : float thickness() const;
2152 : void set_thickness(float value);
2153 :
2154 : // @@protoc_insertion_point(class_scope:rpc.img.ContourThickness)
2155 : private:
2156 :
2157 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2158 : ::rpc::img::Id* id_;
2159 : float thickness_;
2160 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2161 : friend struct ::protobuf_img_2eproto::TableStruct;
2162 : };
2163 : // -------------------------------------------------------------------
2164 :
2165 : class ContourColor : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.ContourColor) */ {
2166 : public:
2167 : ContourColor();
2168 : virtual ~ContourColor();
2169 :
2170 : ContourColor(const ContourColor& from);
2171 :
2172 : inline ContourColor& operator=(const ContourColor& from) {
2173 : CopyFrom(from);
2174 : return *this;
2175 : }
2176 : #if LANG_CXX11
2177 : ContourColor(ContourColor&& from) noexcept
2178 : : ContourColor() {
2179 : *this = ::std::move(from);
2180 : }
2181 :
2182 : inline ContourColor& operator=(ContourColor&& from) noexcept {
2183 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2184 : if (this != &from) InternalSwap(&from);
2185 : } else {
2186 : CopyFrom(from);
2187 : }
2188 : return *this;
2189 : }
2190 : #endif
2191 : static const ::google::protobuf::Descriptor* descriptor();
2192 : static const ContourColor& default_instance();
2193 :
2194 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2195 0 : static inline const ContourColor* internal_default_instance() {
2196 : return reinterpret_cast<const ContourColor*>(
2197 0 : &_ContourColor_default_instance_);
2198 : }
2199 : static constexpr int kIndexInFileMessages =
2200 : 16;
2201 :
2202 : void Swap(ContourColor* other);
2203 : friend void swap(ContourColor& a, ContourColor& b) {
2204 : a.Swap(&b);
2205 : }
2206 :
2207 : // implements Message ----------------------------------------------
2208 :
2209 0 : inline ContourColor* New() const final {
2210 0 : return CreateMaybeMessage<ContourColor>(NULL);
2211 : }
2212 :
2213 0 : ContourColor* New(::google::protobuf::Arena* arena) const final {
2214 0 : return CreateMaybeMessage<ContourColor>(arena);
2215 : }
2216 : void CopyFrom(const ::google::protobuf::Message& from) final;
2217 : void MergeFrom(const ::google::protobuf::Message& from) final;
2218 : void CopyFrom(const ContourColor& from);
2219 : void MergeFrom(const ContourColor& from);
2220 : void Clear() final;
2221 : bool IsInitialized() const final;
2222 :
2223 : size_t ByteSizeLong() const final;
2224 : bool MergePartialFromCodedStream(
2225 : ::google::protobuf::io::CodedInputStream* input) final;
2226 : void SerializeWithCachedSizes(
2227 : ::google::protobuf::io::CodedOutputStream* output) const final;
2228 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2229 : bool deterministic, ::google::protobuf::uint8* target) const final;
2230 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
2231 :
2232 : private:
2233 : void SharedCtor();
2234 : void SharedDtor();
2235 : void SetCachedSize(int size) const final;
2236 : void InternalSwap(ContourColor* other);
2237 : private:
2238 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2239 0 : return NULL;
2240 : }
2241 : inline void* MaybeArenaPtr() const {
2242 : return NULL;
2243 : }
2244 : public:
2245 :
2246 : ::google::protobuf::Metadata GetMetadata() const final;
2247 :
2248 : // nested types ----------------------------------------------------
2249 :
2250 : // accessors -------------------------------------------------------
2251 :
2252 : // string color = 2;
2253 : void clear_color();
2254 : static const int kColorFieldNumber = 2;
2255 : const ::std::string& color() const;
2256 : void set_color(const ::std::string& value);
2257 : #if LANG_CXX11
2258 : void set_color(::std::string&& value);
2259 : #endif
2260 : void set_color(const char* value);
2261 : void set_color(const char* value, size_t size);
2262 : ::std::string* mutable_color();
2263 : ::std::string* release_color();
2264 : void set_allocated_color(::std::string* color);
2265 :
2266 : // .rpc.img.Id id = 1;
2267 : bool has_id() const;
2268 : void clear_id();
2269 : static const int kIdFieldNumber = 1;
2270 : private:
2271 : const ::rpc::img::Id& _internal_id() const;
2272 : public:
2273 : const ::rpc::img::Id& id() const;
2274 : ::rpc::img::Id* release_id();
2275 : ::rpc::img::Id* mutable_id();
2276 : void set_allocated_id(::rpc::img::Id* id);
2277 :
2278 : // @@protoc_insertion_point(class_scope:rpc.img.ContourColor)
2279 : private:
2280 :
2281 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2282 : ::google::protobuf::internal::ArenaStringPtr color_;
2283 : ::rpc::img::Id* id_;
2284 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2285 : friend struct ::protobuf_img_2eproto::TableStruct;
2286 : };
2287 : // -------------------------------------------------------------------
2288 :
2289 : class Axes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.Axes) */ {
2290 : public:
2291 : Axes();
2292 : virtual ~Axes();
2293 :
2294 : Axes(const Axes& from);
2295 :
2296 : inline Axes& operator=(const Axes& from) {
2297 : CopyFrom(from);
2298 : return *this;
2299 : }
2300 : #if LANG_CXX11
2301 : Axes(Axes&& from) noexcept
2302 : : Axes() {
2303 : *this = ::std::move(from);
2304 : }
2305 :
2306 : inline Axes& operator=(Axes&& from) noexcept {
2307 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2308 : if (this != &from) InternalSwap(&from);
2309 : } else {
2310 : CopyFrom(from);
2311 : }
2312 : return *this;
2313 : }
2314 : #endif
2315 : static const ::google::protobuf::Descriptor* descriptor();
2316 : static const Axes& default_instance();
2317 :
2318 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2319 0 : static inline const Axes* internal_default_instance() {
2320 : return reinterpret_cast<const Axes*>(
2321 0 : &_Axes_default_instance_);
2322 : }
2323 : static constexpr int kIndexInFileMessages =
2324 : 17;
2325 :
2326 : void Swap(Axes* other);
2327 : friend void swap(Axes& a, Axes& b) {
2328 : a.Swap(&b);
2329 : }
2330 :
2331 : // implements Message ----------------------------------------------
2332 :
2333 0 : inline Axes* New() const final {
2334 0 : return CreateMaybeMessage<Axes>(NULL);
2335 : }
2336 :
2337 0 : Axes* New(::google::protobuf::Arena* arena) const final {
2338 0 : return CreateMaybeMessage<Axes>(arena);
2339 : }
2340 : void CopyFrom(const ::google::protobuf::Message& from) final;
2341 : void MergeFrom(const ::google::protobuf::Message& from) final;
2342 : void CopyFrom(const Axes& from);
2343 : void MergeFrom(const Axes& from);
2344 : void Clear() final;
2345 : bool IsInitialized() const final;
2346 :
2347 : size_t ByteSizeLong() const final;
2348 : bool MergePartialFromCodedStream(
2349 : ::google::protobuf::io::CodedInputStream* input) final;
2350 : void SerializeWithCachedSizes(
2351 : ::google::protobuf::io::CodedOutputStream* output) const final;
2352 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2353 : bool deterministic, ::google::protobuf::uint8* target) const final;
2354 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
2355 :
2356 : private:
2357 : void SharedCtor();
2358 : void SharedDtor();
2359 : void SetCachedSize(int size) const final;
2360 : void InternalSwap(Axes* other);
2361 : private:
2362 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2363 0 : return NULL;
2364 : }
2365 : inline void* MaybeArenaPtr() const {
2366 : return NULL;
2367 : }
2368 : public:
2369 :
2370 : ::google::protobuf::Metadata GetMetadata() const final;
2371 :
2372 : // nested types ----------------------------------------------------
2373 :
2374 : // accessors -------------------------------------------------------
2375 :
2376 : // string x = 2;
2377 : void clear_x();
2378 : static const int kXFieldNumber = 2;
2379 : const ::std::string& x() const;
2380 : void set_x(const ::std::string& value);
2381 : #if LANG_CXX11
2382 : void set_x(::std::string&& value);
2383 : #endif
2384 : void set_x(const char* value);
2385 : void set_x(const char* value, size_t size);
2386 : ::std::string* mutable_x();
2387 : ::std::string* release_x();
2388 : void set_allocated_x(::std::string* x);
2389 :
2390 : // string y = 3;
2391 : void clear_y();
2392 : static const int kYFieldNumber = 3;
2393 : const ::std::string& y() const;
2394 : void set_y(const ::std::string& value);
2395 : #if LANG_CXX11
2396 : void set_y(::std::string&& value);
2397 : #endif
2398 : void set_y(const char* value);
2399 : void set_y(const char* value, size_t size);
2400 : ::std::string* mutable_y();
2401 : ::std::string* release_y();
2402 : void set_allocated_y(::std::string* y);
2403 :
2404 : // string z = 4;
2405 : void clear_z();
2406 : static const int kZFieldNumber = 4;
2407 : const ::std::string& z() const;
2408 : void set_z(const ::std::string& value);
2409 : #if LANG_CXX11
2410 : void set_z(::std::string&& value);
2411 : #endif
2412 : void set_z(const char* value);
2413 : void set_z(const char* value, size_t size);
2414 : ::std::string* mutable_z();
2415 : ::std::string* release_z();
2416 : void set_allocated_z(::std::string* z);
2417 :
2418 : // .rpc.img.Id panel = 1;
2419 : bool has_panel() const;
2420 : void clear_panel();
2421 : static const int kPanelFieldNumber = 1;
2422 : private:
2423 : const ::rpc::img::Id& _internal_panel() const;
2424 : public:
2425 : const ::rpc::img::Id& panel() const;
2426 : ::rpc::img::Id* release_panel();
2427 : ::rpc::img::Id* mutable_panel();
2428 : void set_allocated_panel(::rpc::img::Id* panel);
2429 :
2430 : // @@protoc_insertion_point(class_scope:rpc.img.Axes)
2431 : private:
2432 :
2433 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2434 : ::google::protobuf::internal::ArenaStringPtr x_;
2435 : ::google::protobuf::internal::ArenaStringPtr y_;
2436 : ::google::protobuf::internal::ArenaStringPtr z_;
2437 : ::rpc::img::Id* panel_;
2438 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2439 : friend struct ::protobuf_img_2eproto::TableStruct;
2440 : };
2441 : // -------------------------------------------------------------------
2442 :
2443 : class ColorMap : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.ColorMap) */ {
2444 : public:
2445 : ColorMap();
2446 : virtual ~ColorMap();
2447 :
2448 : ColorMap(const ColorMap& from);
2449 :
2450 : inline ColorMap& operator=(const ColorMap& from) {
2451 : CopyFrom(from);
2452 : return *this;
2453 : }
2454 : #if LANG_CXX11
2455 : ColorMap(ColorMap&& from) noexcept
2456 : : ColorMap() {
2457 : *this = ::std::move(from);
2458 : }
2459 :
2460 : inline ColorMap& operator=(ColorMap&& from) noexcept {
2461 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2462 : if (this != &from) InternalSwap(&from);
2463 : } else {
2464 : CopyFrom(from);
2465 : }
2466 : return *this;
2467 : }
2468 : #endif
2469 : static const ::google::protobuf::Descriptor* descriptor();
2470 : static const ColorMap& default_instance();
2471 :
2472 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2473 0 : static inline const ColorMap* internal_default_instance() {
2474 : return reinterpret_cast<const ColorMap*>(
2475 0 : &_ColorMap_default_instance_);
2476 : }
2477 : static constexpr int kIndexInFileMessages =
2478 : 18;
2479 :
2480 : void Swap(ColorMap* other);
2481 : friend void swap(ColorMap& a, ColorMap& b) {
2482 : a.Swap(&b);
2483 : }
2484 :
2485 : // implements Message ----------------------------------------------
2486 :
2487 0 : inline ColorMap* New() const final {
2488 0 : return CreateMaybeMessage<ColorMap>(NULL);
2489 : }
2490 :
2491 0 : ColorMap* New(::google::protobuf::Arena* arena) const final {
2492 0 : return CreateMaybeMessage<ColorMap>(arena);
2493 : }
2494 : void CopyFrom(const ::google::protobuf::Message& from) final;
2495 : void MergeFrom(const ::google::protobuf::Message& from) final;
2496 : void CopyFrom(const ColorMap& from);
2497 : void MergeFrom(const ColorMap& from);
2498 : void Clear() final;
2499 : bool IsInitialized() const final;
2500 :
2501 : size_t ByteSizeLong() const final;
2502 : bool MergePartialFromCodedStream(
2503 : ::google::protobuf::io::CodedInputStream* input) final;
2504 : void SerializeWithCachedSizes(
2505 : ::google::protobuf::io::CodedOutputStream* output) const final;
2506 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2507 : bool deterministic, ::google::protobuf::uint8* target) const final;
2508 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
2509 :
2510 : private:
2511 : void SharedCtor();
2512 : void SharedDtor();
2513 : void SetCachedSize(int size) const final;
2514 : void InternalSwap(ColorMap* other);
2515 : private:
2516 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2517 0 : return NULL;
2518 : }
2519 : inline void* MaybeArenaPtr() const {
2520 : return NULL;
2521 : }
2522 : public:
2523 :
2524 : ::google::protobuf::Metadata GetMetadata() const final;
2525 :
2526 : // nested types ----------------------------------------------------
2527 :
2528 : // accessors -------------------------------------------------------
2529 :
2530 : // string map = 2;
2531 : void clear_map();
2532 : static const int kMapFieldNumber = 2;
2533 : const ::std::string& map() const;
2534 : void set_map(const ::std::string& value);
2535 : #if LANG_CXX11
2536 : void set_map(::std::string&& value);
2537 : #endif
2538 : void set_map(const char* value);
2539 : void set_map(const char* value, size_t size);
2540 : ::std::string* mutable_map();
2541 : ::std::string* release_map();
2542 : void set_allocated_map(::std::string* map);
2543 :
2544 : // .rpc.img.Id id = 1;
2545 : bool has_id() const;
2546 : void clear_id();
2547 : static const int kIdFieldNumber = 1;
2548 : private:
2549 : const ::rpc::img::Id& _internal_id() const;
2550 : public:
2551 : const ::rpc::img::Id& id() const;
2552 : ::rpc::img::Id* release_id();
2553 : ::rpc::img::Id* mutable_id();
2554 : void set_allocated_id(::rpc::img::Id* id);
2555 :
2556 : // @@protoc_insertion_point(class_scope:rpc.img.ColorMap)
2557 : private:
2558 :
2559 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2560 : ::google::protobuf::internal::ArenaStringPtr map_;
2561 : ::rpc::img::Id* id_;
2562 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2563 : friend struct ::protobuf_img_2eproto::TableStruct;
2564 : };
2565 : // -------------------------------------------------------------------
2566 :
2567 : class Toggle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.Toggle) */ {
2568 : public:
2569 : Toggle();
2570 : virtual ~Toggle();
2571 :
2572 : Toggle(const Toggle& from);
2573 :
2574 : inline Toggle& operator=(const Toggle& from) {
2575 : CopyFrom(from);
2576 : return *this;
2577 : }
2578 : #if LANG_CXX11
2579 : Toggle(Toggle&& from) noexcept
2580 : : Toggle() {
2581 : *this = ::std::move(from);
2582 : }
2583 :
2584 : inline Toggle& operator=(Toggle&& from) noexcept {
2585 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2586 : if (this != &from) InternalSwap(&from);
2587 : } else {
2588 : CopyFrom(from);
2589 : }
2590 : return *this;
2591 : }
2592 : #endif
2593 : static const ::google::protobuf::Descriptor* descriptor();
2594 : static const Toggle& default_instance();
2595 :
2596 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2597 0 : static inline const Toggle* internal_default_instance() {
2598 : return reinterpret_cast<const Toggle*>(
2599 0 : &_Toggle_default_instance_);
2600 : }
2601 : static constexpr int kIndexInFileMessages =
2602 : 19;
2603 :
2604 : void Swap(Toggle* other);
2605 : friend void swap(Toggle& a, Toggle& b) {
2606 : a.Swap(&b);
2607 : }
2608 :
2609 : // implements Message ----------------------------------------------
2610 :
2611 0 : inline Toggle* New() const final {
2612 0 : return CreateMaybeMessage<Toggle>(NULL);
2613 : }
2614 :
2615 0 : Toggle* New(::google::protobuf::Arena* arena) const final {
2616 0 : return CreateMaybeMessage<Toggle>(arena);
2617 : }
2618 : void CopyFrom(const ::google::protobuf::Message& from) final;
2619 : void MergeFrom(const ::google::protobuf::Message& from) final;
2620 : void CopyFrom(const Toggle& from);
2621 : void MergeFrom(const Toggle& from);
2622 : void Clear() final;
2623 : bool IsInitialized() const final;
2624 :
2625 : size_t ByteSizeLong() const final;
2626 : bool MergePartialFromCodedStream(
2627 : ::google::protobuf::io::CodedInputStream* input) final;
2628 : void SerializeWithCachedSizes(
2629 : ::google::protobuf::io::CodedOutputStream* output) const final;
2630 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2631 : bool deterministic, ::google::protobuf::uint8* target) const final;
2632 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
2633 :
2634 : private:
2635 : void SharedCtor();
2636 : void SharedDtor();
2637 : void SetCachedSize(int size) const final;
2638 : void InternalSwap(Toggle* other);
2639 : private:
2640 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2641 0 : return NULL;
2642 : }
2643 : inline void* MaybeArenaPtr() const {
2644 : return NULL;
2645 : }
2646 : public:
2647 :
2648 : ::google::protobuf::Metadata GetMetadata() const final;
2649 :
2650 : // nested types ----------------------------------------------------
2651 :
2652 : // accessors -------------------------------------------------------
2653 :
2654 : // .rpc.img.Id id = 1;
2655 : bool has_id() const;
2656 : void clear_id();
2657 : static const int kIdFieldNumber = 1;
2658 : private:
2659 : const ::rpc::img::Id& _internal_id() const;
2660 : public:
2661 : const ::rpc::img::Id& id() const;
2662 : ::rpc::img::Id* release_id();
2663 : ::rpc::img::Id* mutable_id();
2664 : void set_allocated_id(::rpc::img::Id* id);
2665 :
2666 : // bool state = 2;
2667 : void clear_state();
2668 : static const int kStateFieldNumber = 2;
2669 : bool state() const;
2670 : void set_state(bool value);
2671 :
2672 : // @@protoc_insertion_point(class_scope:rpc.img.Toggle)
2673 : private:
2674 :
2675 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2676 : ::rpc::img::Id* id_;
2677 : bool state_;
2678 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2679 : friend struct ::protobuf_img_2eproto::TableStruct;
2680 : };
2681 : // -------------------------------------------------------------------
2682 :
2683 : class InteractiveMaskOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.InteractiveMaskOptions) */ {
2684 : public:
2685 : InteractiveMaskOptions();
2686 : virtual ~InteractiveMaskOptions();
2687 :
2688 : InteractiveMaskOptions(const InteractiveMaskOptions& from);
2689 :
2690 : inline InteractiveMaskOptions& operator=(const InteractiveMaskOptions& from) {
2691 : CopyFrom(from);
2692 : return *this;
2693 : }
2694 : #if LANG_CXX11
2695 : InteractiveMaskOptions(InteractiveMaskOptions&& from) noexcept
2696 : : InteractiveMaskOptions() {
2697 : *this = ::std::move(from);
2698 : }
2699 :
2700 : inline InteractiveMaskOptions& operator=(InteractiveMaskOptions&& from) noexcept {
2701 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2702 : if (this != &from) InternalSwap(&from);
2703 : } else {
2704 : CopyFrom(from);
2705 : }
2706 : return *this;
2707 : }
2708 : #endif
2709 : static const ::google::protobuf::Descriptor* descriptor();
2710 : static const InteractiveMaskOptions& default_instance();
2711 :
2712 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2713 10 : static inline const InteractiveMaskOptions* internal_default_instance() {
2714 : return reinterpret_cast<const InteractiveMaskOptions*>(
2715 10 : &_InteractiveMaskOptions_default_instance_);
2716 : }
2717 : static constexpr int kIndexInFileMessages =
2718 : 20;
2719 :
2720 : void Swap(InteractiveMaskOptions* other);
2721 : friend void swap(InteractiveMaskOptions& a, InteractiveMaskOptions& b) {
2722 : a.Swap(&b);
2723 : }
2724 :
2725 : // implements Message ----------------------------------------------
2726 :
2727 0 : inline InteractiveMaskOptions* New() const final {
2728 0 : return CreateMaybeMessage<InteractiveMaskOptions>(NULL);
2729 : }
2730 :
2731 0 : InteractiveMaskOptions* New(::google::protobuf::Arena* arena) const final {
2732 0 : return CreateMaybeMessage<InteractiveMaskOptions>(arena);
2733 : }
2734 : void CopyFrom(const ::google::protobuf::Message& from) final;
2735 : void MergeFrom(const ::google::protobuf::Message& from) final;
2736 : void CopyFrom(const InteractiveMaskOptions& from);
2737 : void MergeFrom(const InteractiveMaskOptions& from);
2738 : void Clear() final;
2739 : bool IsInitialized() const final;
2740 :
2741 : size_t ByteSizeLong() const final;
2742 : bool MergePartialFromCodedStream(
2743 : ::google::protobuf::io::CodedInputStream* input) final;
2744 : void SerializeWithCachedSizes(
2745 : ::google::protobuf::io::CodedOutputStream* output) const final;
2746 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2747 : bool deterministic, ::google::protobuf::uint8* target) const final;
2748 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
2749 :
2750 : private:
2751 : void SharedCtor();
2752 : void SharedDtor();
2753 : void SetCachedSize(int size) const final;
2754 : void InternalSwap(InteractiveMaskOptions* other);
2755 : private:
2756 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2757 0 : return NULL;
2758 : }
2759 : inline void* MaybeArenaPtr() const {
2760 : return NULL;
2761 : }
2762 : public:
2763 :
2764 : ::google::protobuf::Metadata GetMetadata() const final;
2765 :
2766 : // nested types ----------------------------------------------------
2767 :
2768 : // accessors -------------------------------------------------------
2769 :
2770 : // string threshold = 4;
2771 : void clear_threshold();
2772 : static const int kThresholdFieldNumber = 4;
2773 : const ::std::string& threshold() const;
2774 : void set_threshold(const ::std::string& value);
2775 : #if LANG_CXX11
2776 : void set_threshold(::std::string&& value);
2777 : #endif
2778 : void set_threshold(const char* value);
2779 : void set_threshold(const char* value, size_t size);
2780 : ::std::string* mutable_threshold();
2781 : ::std::string* release_threshold();
2782 : void set_allocated_threshold(::std::string* threshold);
2783 :
2784 : // string cyclethreshold = 5;
2785 : void clear_cyclethreshold();
2786 : static const int kCyclethresholdFieldNumber = 5;
2787 : const ::std::string& cyclethreshold() const;
2788 : void set_cyclethreshold(const ::std::string& value);
2789 : #if LANG_CXX11
2790 : void set_cyclethreshold(::std::string&& value);
2791 : #endif
2792 : void set_cyclethreshold(const char* value);
2793 : void set_cyclethreshold(const char* value, size_t size);
2794 : ::std::string* mutable_cyclethreshold();
2795 : ::std::string* release_cyclethreshold();
2796 : void set_allocated_cyclethreshold(::std::string* cyclethreshold);
2797 :
2798 : // .rpc.img.Id panel = 1;
2799 : bool has_panel() const;
2800 : void clear_panel();
2801 : static const int kPanelFieldNumber = 1;
2802 : private:
2803 : const ::rpc::img::Id& _internal_panel() const;
2804 : public:
2805 : const ::rpc::img::Id& panel() const;
2806 : ::rpc::img::Id* release_panel();
2807 : ::rpc::img::Id* mutable_panel();
2808 : void set_allocated_panel(::rpc::img::Id* panel);
2809 :
2810 : // int32 niter = 2;
2811 : void clear_niter();
2812 : static const int kNiterFieldNumber = 2;
2813 : ::google::protobuf::int32 niter() const;
2814 : void set_niter(::google::protobuf::int32 value);
2815 :
2816 : // int32 cycleniter = 3;
2817 : void clear_cycleniter();
2818 : static const int kCycleniterFieldNumber = 3;
2819 : ::google::protobuf::int32 cycleniter() const;
2820 : void set_cycleniter(::google::protobuf::int32 value);
2821 :
2822 : // @@protoc_insertion_point(class_scope:rpc.img.InteractiveMaskOptions)
2823 : private:
2824 :
2825 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2826 : ::google::protobuf::internal::ArenaStringPtr threshold_;
2827 : ::google::protobuf::internal::ArenaStringPtr cyclethreshold_;
2828 : ::rpc::img::Id* panel_;
2829 : ::google::protobuf::int32 niter_;
2830 : ::google::protobuf::int32 cycleniter_;
2831 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2832 : friend struct ::protobuf_img_2eproto::TableStruct;
2833 : };
2834 : // -------------------------------------------------------------------
2835 :
2836 : class InteractiveMaskResult : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rpc.img.InteractiveMaskResult) */ {
2837 : public:
2838 : InteractiveMaskResult();
2839 : virtual ~InteractiveMaskResult();
2840 :
2841 : InteractiveMaskResult(const InteractiveMaskResult& from);
2842 :
2843 : inline InteractiveMaskResult& operator=(const InteractiveMaskResult& from) {
2844 : CopyFrom(from);
2845 : return *this;
2846 : }
2847 : #if LANG_CXX11
2848 : InteractiveMaskResult(InteractiveMaskResult&& from) noexcept
2849 : : InteractiveMaskResult() {
2850 : *this = ::std::move(from);
2851 : }
2852 :
2853 : inline InteractiveMaskResult& operator=(InteractiveMaskResult&& from) noexcept {
2854 : if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2855 : if (this != &from) InternalSwap(&from);
2856 : } else {
2857 : CopyFrom(from);
2858 : }
2859 : return *this;
2860 : }
2861 : #endif
2862 : static const ::google::protobuf::Descriptor* descriptor();
2863 : static const InteractiveMaskResult& default_instance();
2864 :
2865 : static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2866 0 : static inline const InteractiveMaskResult* internal_default_instance() {
2867 : return reinterpret_cast<const InteractiveMaskResult*>(
2868 0 : &_InteractiveMaskResult_default_instance_);
2869 : }
2870 : static constexpr int kIndexInFileMessages =
2871 : 21;
2872 :
2873 : void Swap(InteractiveMaskResult* other);
2874 : friend void swap(InteractiveMaskResult& a, InteractiveMaskResult& b) {
2875 : a.Swap(&b);
2876 : }
2877 :
2878 : // implements Message ----------------------------------------------
2879 :
2880 0 : inline InteractiveMaskResult* New() const final {
2881 0 : return CreateMaybeMessage<InteractiveMaskResult>(NULL);
2882 : }
2883 :
2884 0 : InteractiveMaskResult* New(::google::protobuf::Arena* arena) const final {
2885 0 : return CreateMaybeMessage<InteractiveMaskResult>(arena);
2886 : }
2887 : void CopyFrom(const ::google::protobuf::Message& from) final;
2888 : void MergeFrom(const ::google::protobuf::Message& from) final;
2889 : void CopyFrom(const InteractiveMaskResult& from);
2890 : void MergeFrom(const InteractiveMaskResult& from);
2891 : void Clear() final;
2892 : bool IsInitialized() const final;
2893 :
2894 : size_t ByteSizeLong() const final;
2895 : bool MergePartialFromCodedStream(
2896 : ::google::protobuf::io::CodedInputStream* input) final;
2897 : void SerializeWithCachedSizes(
2898 : ::google::protobuf::io::CodedOutputStream* output) const final;
2899 : ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2900 : bool deterministic, ::google::protobuf::uint8* target) const final;
2901 0 : int GetCachedSize() const final { return _cached_size_.Get(); }
2902 :
2903 : private:
2904 : void SharedCtor();
2905 : void SharedDtor();
2906 : void SetCachedSize(int size) const final;
2907 : void InternalSwap(InteractiveMaskResult* other);
2908 : private:
2909 0 : inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2910 0 : return NULL;
2911 : }
2912 : inline void* MaybeArenaPtr() const {
2913 : return NULL;
2914 : }
2915 : public:
2916 :
2917 : ::google::protobuf::Metadata GetMetadata() const final;
2918 :
2919 : // nested types ----------------------------------------------------
2920 :
2921 : // accessors -------------------------------------------------------
2922 :
2923 : // string action = 1;
2924 : void clear_action();
2925 : static const int kActionFieldNumber = 1;
2926 : const ::std::string& action() const;
2927 : void set_action(const ::std::string& value);
2928 : #if LANG_CXX11
2929 : void set_action(::std::string&& value);
2930 : #endif
2931 : void set_action(const char* value);
2932 : void set_action(const char* value, size_t size);
2933 : ::std::string* mutable_action();
2934 : ::std::string* release_action();
2935 : void set_allocated_action(::std::string* action);
2936 :
2937 : // .rpc.img.InteractiveMaskOptions state = 2;
2938 : bool has_state() const;
2939 : void clear_state();
2940 : static const int kStateFieldNumber = 2;
2941 : private:
2942 : const ::rpc::img::InteractiveMaskOptions& _internal_state() const;
2943 : public:
2944 : const ::rpc::img::InteractiveMaskOptions& state() const;
2945 : ::rpc::img::InteractiveMaskOptions* release_state();
2946 : ::rpc::img::InteractiveMaskOptions* mutable_state();
2947 : void set_allocated_state(::rpc::img::InteractiveMaskOptions* state);
2948 :
2949 : // @@protoc_insertion_point(class_scope:rpc.img.InteractiveMaskResult)
2950 : private:
2951 :
2952 : ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2953 : ::google::protobuf::internal::ArenaStringPtr action_;
2954 : ::rpc::img::InteractiveMaskOptions* state_;
2955 : mutable ::google::protobuf::internal::CachedSize _cached_size_;
2956 : friend struct ::protobuf_img_2eproto::TableStruct;
2957 : };
2958 : // ===================================================================
2959 :
2960 :
2961 : // ===================================================================
2962 :
2963 : #ifdef __GNUC__
2964 : #pragma GCC diagnostic push
2965 : #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2966 : #endif // __GNUC__
2967 : // Id
2968 :
2969 : // int32 id = 1;
2970 : inline void Id::clear_id() {
2971 : id_ = 0;
2972 : }
2973 0 : inline ::google::protobuf::int32 Id::id() const {
2974 : // @@protoc_insertion_point(field_get:rpc.img.Id.id)
2975 0 : return id_;
2976 : }
2977 0 : inline void Id::set_id(::google::protobuf::int32 value) {
2978 :
2979 0 : id_ = value;
2980 : // @@protoc_insertion_point(field_set:rpc.img.Id.id)
2981 0 : }
2982 :
2983 : // -------------------------------------------------------------------
2984 :
2985 : // NewPanel
2986 :
2987 : // string type = 1;
2988 : inline void NewPanel::clear_type() {
2989 : type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2990 : }
2991 0 : inline const ::std::string& NewPanel::type() const {
2992 : // @@protoc_insertion_point(field_get:rpc.img.NewPanel.type)
2993 0 : return type_.GetNoArena();
2994 : }
2995 : inline void NewPanel::set_type(const ::std::string& value) {
2996 :
2997 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2998 : // @@protoc_insertion_point(field_set:rpc.img.NewPanel.type)
2999 : }
3000 : #if LANG_CXX11
3001 : inline void NewPanel::set_type(::std::string&& value) {
3002 :
3003 : type_.SetNoArena(
3004 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3005 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.NewPanel.type)
3006 : }
3007 : #endif
3008 0 : inline void NewPanel::set_type(const char* value) {
3009 0 : GOOGLE_DCHECK(value != NULL);
3010 :
3011 0 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3012 : // @@protoc_insertion_point(field_set_char:rpc.img.NewPanel.type)
3013 0 : }
3014 : inline void NewPanel::set_type(const char* value, size_t size) {
3015 :
3016 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3017 : ::std::string(reinterpret_cast<const char*>(value), size));
3018 : // @@protoc_insertion_point(field_set_pointer:rpc.img.NewPanel.type)
3019 : }
3020 0 : inline ::std::string* NewPanel::mutable_type() {
3021 :
3022 : // @@protoc_insertion_point(field_mutable:rpc.img.NewPanel.type)
3023 0 : return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3024 : }
3025 : inline ::std::string* NewPanel::release_type() {
3026 : // @@protoc_insertion_point(field_release:rpc.img.NewPanel.type)
3027 :
3028 : return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3029 : }
3030 : inline void NewPanel::set_allocated_type(::std::string* type) {
3031 : if (type != NULL) {
3032 :
3033 : } else {
3034 :
3035 : }
3036 : type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
3037 : // @@protoc_insertion_point(field_set_allocated:rpc.img.NewPanel.type)
3038 : }
3039 :
3040 : // bool hidden = 2;
3041 : inline void NewPanel::clear_hidden() {
3042 : hidden_ = false;
3043 : }
3044 0 : inline bool NewPanel::hidden() const {
3045 : // @@protoc_insertion_point(field_get:rpc.img.NewPanel.hidden)
3046 0 : return hidden_;
3047 : }
3048 0 : inline void NewPanel::set_hidden(bool value) {
3049 :
3050 0 : hidden_ = value;
3051 : // @@protoc_insertion_point(field_set:rpc.img.NewPanel.hidden)
3052 0 : }
3053 :
3054 : // -------------------------------------------------------------------
3055 :
3056 : // NewData
3057 :
3058 : // .rpc.img.Id panel = 1;
3059 0 : inline bool NewData::has_panel() const {
3060 0 : return this != internal_default_instance() && panel_ != NULL;
3061 : }
3062 : inline void NewData::clear_panel() {
3063 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
3064 : delete panel_;
3065 : }
3066 : panel_ = NULL;
3067 : }
3068 0 : inline const ::rpc::img::Id& NewData::_internal_panel() const {
3069 0 : return *panel_;
3070 : }
3071 0 : inline const ::rpc::img::Id& NewData::panel() const {
3072 0 : const ::rpc::img::Id* p = panel_;
3073 : // @@protoc_insertion_point(field_get:rpc.img.NewData.panel)
3074 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
3075 0 : &::rpc::img::_Id_default_instance_);
3076 : }
3077 : inline ::rpc::img::Id* NewData::release_panel() {
3078 : // @@protoc_insertion_point(field_release:rpc.img.NewData.panel)
3079 :
3080 : ::rpc::img::Id* temp = panel_;
3081 : panel_ = NULL;
3082 : return temp;
3083 : }
3084 0 : inline ::rpc::img::Id* NewData::mutable_panel() {
3085 :
3086 0 : if (panel_ == NULL) {
3087 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
3088 0 : panel_ = p;
3089 : }
3090 : // @@protoc_insertion_point(field_mutable:rpc.img.NewData.panel)
3091 0 : return panel_;
3092 : }
3093 : inline void NewData::set_allocated_panel(::rpc::img::Id* panel) {
3094 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3095 : if (message_arena == NULL) {
3096 : delete panel_;
3097 : }
3098 : if (panel) {
3099 : ::google::protobuf::Arena* submessage_arena = NULL;
3100 : if (message_arena != submessage_arena) {
3101 : panel = ::google::protobuf::internal::GetOwnedMessage(
3102 : message_arena, panel, submessage_arena);
3103 : }
3104 :
3105 : } else {
3106 :
3107 : }
3108 : panel_ = panel;
3109 : // @@protoc_insertion_point(field_set_allocated:rpc.img.NewData.panel)
3110 : }
3111 :
3112 : // string path = 2;
3113 : inline void NewData::clear_path() {
3114 : path_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3115 : }
3116 0 : inline const ::std::string& NewData::path() const {
3117 : // @@protoc_insertion_point(field_get:rpc.img.NewData.path)
3118 0 : return path_.GetNoArena();
3119 : }
3120 0 : inline void NewData::set_path(const ::std::string& value) {
3121 :
3122 0 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3123 : // @@protoc_insertion_point(field_set:rpc.img.NewData.path)
3124 0 : }
3125 : #if LANG_CXX11
3126 : inline void NewData::set_path(::std::string&& value) {
3127 :
3128 : path_.SetNoArena(
3129 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3130 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.NewData.path)
3131 : }
3132 : #endif
3133 : inline void NewData::set_path(const char* value) {
3134 : GOOGLE_DCHECK(value != NULL);
3135 :
3136 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3137 : // @@protoc_insertion_point(field_set_char:rpc.img.NewData.path)
3138 : }
3139 : inline void NewData::set_path(const char* value, size_t size) {
3140 :
3141 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3142 : ::std::string(reinterpret_cast<const char*>(value), size));
3143 : // @@protoc_insertion_point(field_set_pointer:rpc.img.NewData.path)
3144 : }
3145 0 : inline ::std::string* NewData::mutable_path() {
3146 :
3147 : // @@protoc_insertion_point(field_mutable:rpc.img.NewData.path)
3148 0 : return path_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3149 : }
3150 : inline ::std::string* NewData::release_path() {
3151 : // @@protoc_insertion_point(field_release:rpc.img.NewData.path)
3152 :
3153 : return path_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3154 : }
3155 : inline void NewData::set_allocated_path(::std::string* path) {
3156 : if (path != NULL) {
3157 :
3158 : } else {
3159 :
3160 : }
3161 : path_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), path);
3162 : // @@protoc_insertion_point(field_set_allocated:rpc.img.NewData.path)
3163 : }
3164 :
3165 : // string type = 3;
3166 : inline void NewData::clear_type() {
3167 : type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3168 : }
3169 0 : inline const ::std::string& NewData::type() const {
3170 : // @@protoc_insertion_point(field_get:rpc.img.NewData.type)
3171 0 : return type_.GetNoArena();
3172 : }
3173 : inline void NewData::set_type(const ::std::string& value) {
3174 :
3175 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3176 : // @@protoc_insertion_point(field_set:rpc.img.NewData.type)
3177 : }
3178 : #if LANG_CXX11
3179 : inline void NewData::set_type(::std::string&& value) {
3180 :
3181 : type_.SetNoArena(
3182 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3183 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.NewData.type)
3184 : }
3185 : #endif
3186 0 : inline void NewData::set_type(const char* value) {
3187 0 : GOOGLE_DCHECK(value != NULL);
3188 :
3189 0 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3190 : // @@protoc_insertion_point(field_set_char:rpc.img.NewData.type)
3191 0 : }
3192 : inline void NewData::set_type(const char* value, size_t size) {
3193 :
3194 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3195 : ::std::string(reinterpret_cast<const char*>(value), size));
3196 : // @@protoc_insertion_point(field_set_pointer:rpc.img.NewData.type)
3197 : }
3198 0 : inline ::std::string* NewData::mutable_type() {
3199 :
3200 : // @@protoc_insertion_point(field_mutable:rpc.img.NewData.type)
3201 0 : return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3202 : }
3203 : inline ::std::string* NewData::release_type() {
3204 : // @@protoc_insertion_point(field_release:rpc.img.NewData.type)
3205 :
3206 : return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3207 : }
3208 : inline void NewData::set_allocated_type(::std::string* type) {
3209 : if (type != NULL) {
3210 :
3211 : } else {
3212 :
3213 : }
3214 : type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
3215 : // @@protoc_insertion_point(field_set_allocated:rpc.img.NewData.type)
3216 : }
3217 :
3218 : // float scale = 4;
3219 : inline void NewData::clear_scale() {
3220 : scale_ = 0;
3221 : }
3222 0 : inline float NewData::scale() const {
3223 : // @@protoc_insertion_point(field_get:rpc.img.NewData.scale)
3224 0 : return scale_;
3225 : }
3226 0 : inline void NewData::set_scale(float value) {
3227 :
3228 0 : scale_ = value;
3229 : // @@protoc_insertion_point(field_set:rpc.img.NewData.scale)
3230 0 : }
3231 :
3232 : // -------------------------------------------------------------------
3233 :
3234 : // PopUp
3235 :
3236 : // .rpc.img.Id panel = 1;
3237 0 : inline bool PopUp::has_panel() const {
3238 0 : return this != internal_default_instance() && panel_ != NULL;
3239 : }
3240 : inline void PopUp::clear_panel() {
3241 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
3242 : delete panel_;
3243 : }
3244 : panel_ = NULL;
3245 : }
3246 0 : inline const ::rpc::img::Id& PopUp::_internal_panel() const {
3247 0 : return *panel_;
3248 : }
3249 0 : inline const ::rpc::img::Id& PopUp::panel() const {
3250 0 : const ::rpc::img::Id* p = panel_;
3251 : // @@protoc_insertion_point(field_get:rpc.img.PopUp.panel)
3252 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
3253 0 : &::rpc::img::_Id_default_instance_);
3254 : }
3255 : inline ::rpc::img::Id* PopUp::release_panel() {
3256 : // @@protoc_insertion_point(field_release:rpc.img.PopUp.panel)
3257 :
3258 : ::rpc::img::Id* temp = panel_;
3259 : panel_ = NULL;
3260 : return temp;
3261 : }
3262 0 : inline ::rpc::img::Id* PopUp::mutable_panel() {
3263 :
3264 0 : if (panel_ == NULL) {
3265 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
3266 0 : panel_ = p;
3267 : }
3268 : // @@protoc_insertion_point(field_mutable:rpc.img.PopUp.panel)
3269 0 : return panel_;
3270 : }
3271 : inline void PopUp::set_allocated_panel(::rpc::img::Id* panel) {
3272 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3273 : if (message_arena == NULL) {
3274 : delete panel_;
3275 : }
3276 : if (panel) {
3277 : ::google::protobuf::Arena* submessage_arena = NULL;
3278 : if (message_arena != submessage_arena) {
3279 : panel = ::google::protobuf::internal::GetOwnedMessage(
3280 : message_arena, panel, submessage_arena);
3281 : }
3282 :
3283 : } else {
3284 :
3285 : }
3286 : panel_ = panel;
3287 : // @@protoc_insertion_point(field_set_allocated:rpc.img.PopUp.panel)
3288 : }
3289 :
3290 : // string name = 2;
3291 : inline void PopUp::clear_name() {
3292 : name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3293 : }
3294 0 : inline const ::std::string& PopUp::name() const {
3295 : // @@protoc_insertion_point(field_get:rpc.img.PopUp.name)
3296 0 : return name_.GetNoArena();
3297 : }
3298 : inline void PopUp::set_name(const ::std::string& value) {
3299 :
3300 : name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3301 : // @@protoc_insertion_point(field_set:rpc.img.PopUp.name)
3302 : }
3303 : #if LANG_CXX11
3304 : inline void PopUp::set_name(::std::string&& value) {
3305 :
3306 : name_.SetNoArena(
3307 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3308 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.PopUp.name)
3309 : }
3310 : #endif
3311 : inline void PopUp::set_name(const char* value) {
3312 : GOOGLE_DCHECK(value != NULL);
3313 :
3314 : name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3315 : // @@protoc_insertion_point(field_set_char:rpc.img.PopUp.name)
3316 : }
3317 : inline void PopUp::set_name(const char* value, size_t size) {
3318 :
3319 : name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3320 : ::std::string(reinterpret_cast<const char*>(value), size));
3321 : // @@protoc_insertion_point(field_set_pointer:rpc.img.PopUp.name)
3322 : }
3323 0 : inline ::std::string* PopUp::mutable_name() {
3324 :
3325 : // @@protoc_insertion_point(field_mutable:rpc.img.PopUp.name)
3326 0 : return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3327 : }
3328 : inline ::std::string* PopUp::release_name() {
3329 : // @@protoc_insertion_point(field_release:rpc.img.PopUp.name)
3330 :
3331 : return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3332 : }
3333 : inline void PopUp::set_allocated_name(::std::string* name) {
3334 : if (name != NULL) {
3335 :
3336 : } else {
3337 :
3338 : }
3339 : name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
3340 : // @@protoc_insertion_point(field_set_allocated:rpc.img.PopUp.name)
3341 : }
3342 :
3343 : // -------------------------------------------------------------------
3344 :
3345 : // Restore
3346 :
3347 : // .rpc.img.Id panel = 1;
3348 0 : inline bool Restore::has_panel() const {
3349 0 : return this != internal_default_instance() && panel_ != NULL;
3350 : }
3351 : inline void Restore::clear_panel() {
3352 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
3353 : delete panel_;
3354 : }
3355 : panel_ = NULL;
3356 : }
3357 0 : inline const ::rpc::img::Id& Restore::_internal_panel() const {
3358 0 : return *panel_;
3359 : }
3360 0 : inline const ::rpc::img::Id& Restore::panel() const {
3361 0 : const ::rpc::img::Id* p = panel_;
3362 : // @@protoc_insertion_point(field_get:rpc.img.Restore.panel)
3363 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
3364 0 : &::rpc::img::_Id_default_instance_);
3365 : }
3366 : inline ::rpc::img::Id* Restore::release_panel() {
3367 : // @@protoc_insertion_point(field_release:rpc.img.Restore.panel)
3368 :
3369 : ::rpc::img::Id* temp = panel_;
3370 : panel_ = NULL;
3371 : return temp;
3372 : }
3373 0 : inline ::rpc::img::Id* Restore::mutable_panel() {
3374 :
3375 0 : if (panel_ == NULL) {
3376 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
3377 0 : panel_ = p;
3378 : }
3379 : // @@protoc_insertion_point(field_mutable:rpc.img.Restore.panel)
3380 0 : return panel_;
3381 : }
3382 : inline void Restore::set_allocated_panel(::rpc::img::Id* panel) {
3383 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3384 : if (message_arena == NULL) {
3385 : delete panel_;
3386 : }
3387 : if (panel) {
3388 : ::google::protobuf::Arena* submessage_arena = NULL;
3389 : if (message_arena != submessage_arena) {
3390 : panel = ::google::protobuf::internal::GetOwnedMessage(
3391 : message_arena, panel, submessage_arena);
3392 : }
3393 :
3394 : } else {
3395 :
3396 : }
3397 : panel_ = panel;
3398 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Restore.panel)
3399 : }
3400 :
3401 : // string path = 2;
3402 : inline void Restore::clear_path() {
3403 : path_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3404 : }
3405 0 : inline const ::std::string& Restore::path() const {
3406 : // @@protoc_insertion_point(field_get:rpc.img.Restore.path)
3407 0 : return path_.GetNoArena();
3408 : }
3409 : inline void Restore::set_path(const ::std::string& value) {
3410 :
3411 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3412 : // @@protoc_insertion_point(field_set:rpc.img.Restore.path)
3413 : }
3414 : #if LANG_CXX11
3415 : inline void Restore::set_path(::std::string&& value) {
3416 :
3417 : path_.SetNoArena(
3418 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3419 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Restore.path)
3420 : }
3421 : #endif
3422 : inline void Restore::set_path(const char* value) {
3423 : GOOGLE_DCHECK(value != NULL);
3424 :
3425 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3426 : // @@protoc_insertion_point(field_set_char:rpc.img.Restore.path)
3427 : }
3428 : inline void Restore::set_path(const char* value, size_t size) {
3429 :
3430 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3431 : ::std::string(reinterpret_cast<const char*>(value), size));
3432 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Restore.path)
3433 : }
3434 0 : inline ::std::string* Restore::mutable_path() {
3435 :
3436 : // @@protoc_insertion_point(field_mutable:rpc.img.Restore.path)
3437 0 : return path_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3438 : }
3439 : inline ::std::string* Restore::release_path() {
3440 : // @@protoc_insertion_point(field_release:rpc.img.Restore.path)
3441 :
3442 : return path_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3443 : }
3444 : inline void Restore::set_allocated_path(::std::string* path) {
3445 : if (path != NULL) {
3446 :
3447 : } else {
3448 :
3449 : }
3450 : path_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), path);
3451 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Restore.path)
3452 : }
3453 :
3454 : // -------------------------------------------------------------------
3455 :
3456 : // FileInfo
3457 :
3458 : // string type = 1;
3459 : inline void FileInfo::clear_type() {
3460 : type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3461 : }
3462 0 : inline const ::std::string& FileInfo::type() const {
3463 : // @@protoc_insertion_point(field_get:rpc.img.FileInfo.type)
3464 0 : return type_.GetNoArena();
3465 : }
3466 : inline void FileInfo::set_type(const ::std::string& value) {
3467 :
3468 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3469 : // @@protoc_insertion_point(field_set:rpc.img.FileInfo.type)
3470 : }
3471 : #if LANG_CXX11
3472 : inline void FileInfo::set_type(::std::string&& value) {
3473 :
3474 : type_.SetNoArena(
3475 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3476 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.FileInfo.type)
3477 : }
3478 : #endif
3479 : inline void FileInfo::set_type(const char* value) {
3480 : GOOGLE_DCHECK(value != NULL);
3481 :
3482 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3483 : // @@protoc_insertion_point(field_set_char:rpc.img.FileInfo.type)
3484 : }
3485 : inline void FileInfo::set_type(const char* value, size_t size) {
3486 :
3487 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3488 : ::std::string(reinterpret_cast<const char*>(value), size));
3489 : // @@protoc_insertion_point(field_set_pointer:rpc.img.FileInfo.type)
3490 : }
3491 0 : inline ::std::string* FileInfo::mutable_type() {
3492 :
3493 : // @@protoc_insertion_point(field_mutable:rpc.img.FileInfo.type)
3494 0 : return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3495 : }
3496 : inline ::std::string* FileInfo::release_type() {
3497 : // @@protoc_insertion_point(field_release:rpc.img.FileInfo.type)
3498 :
3499 : return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3500 : }
3501 : inline void FileInfo::set_allocated_type(::std::string* type) {
3502 : if (type != NULL) {
3503 :
3504 : } else {
3505 :
3506 : }
3507 : type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
3508 : // @@protoc_insertion_point(field_set_allocated:rpc.img.FileInfo.type)
3509 : }
3510 :
3511 : // -------------------------------------------------------------------
3512 :
3513 : // KeyInfo
3514 :
3515 : // string type = 1;
3516 : inline void KeyInfo::clear_type() {
3517 : type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3518 : }
3519 0 : inline const ::std::string& KeyInfo::type() const {
3520 : // @@protoc_insertion_point(field_get:rpc.img.KeyInfo.type)
3521 0 : return type_.GetNoArena();
3522 : }
3523 : inline void KeyInfo::set_type(const ::std::string& value) {
3524 :
3525 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3526 : // @@protoc_insertion_point(field_set:rpc.img.KeyInfo.type)
3527 : }
3528 : #if LANG_CXX11
3529 : inline void KeyInfo::set_type(::std::string&& value) {
3530 :
3531 : type_.SetNoArena(
3532 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3533 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.KeyInfo.type)
3534 : }
3535 : #endif
3536 : inline void KeyInfo::set_type(const char* value) {
3537 : GOOGLE_DCHECK(value != NULL);
3538 :
3539 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3540 : // @@protoc_insertion_point(field_set_char:rpc.img.KeyInfo.type)
3541 : }
3542 : inline void KeyInfo::set_type(const char* value, size_t size) {
3543 :
3544 : type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3545 : ::std::string(reinterpret_cast<const char*>(value), size));
3546 : // @@protoc_insertion_point(field_set_pointer:rpc.img.KeyInfo.type)
3547 : }
3548 0 : inline ::std::string* KeyInfo::mutable_type() {
3549 :
3550 : // @@protoc_insertion_point(field_mutable:rpc.img.KeyInfo.type)
3551 0 : return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3552 : }
3553 : inline ::std::string* KeyInfo::release_type() {
3554 : // @@protoc_insertion_point(field_release:rpc.img.KeyInfo.type)
3555 :
3556 : return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3557 : }
3558 : inline void KeyInfo::set_allocated_type(::std::string* type) {
3559 : if (type != NULL) {
3560 :
3561 : } else {
3562 :
3563 : }
3564 : type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
3565 : // @@protoc_insertion_point(field_set_allocated:rpc.img.KeyInfo.type)
3566 : }
3567 :
3568 : // -------------------------------------------------------------------
3569 :
3570 : // Path
3571 :
3572 : // string path = 1;
3573 : inline void Path::clear_path() {
3574 : path_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3575 : }
3576 0 : inline const ::std::string& Path::path() const {
3577 : // @@protoc_insertion_point(field_get:rpc.img.Path.path)
3578 0 : return path_.GetNoArena();
3579 : }
3580 : inline void Path::set_path(const ::std::string& value) {
3581 :
3582 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3583 : // @@protoc_insertion_point(field_set:rpc.img.Path.path)
3584 : }
3585 : #if LANG_CXX11
3586 : inline void Path::set_path(::std::string&& value) {
3587 :
3588 : path_.SetNoArena(
3589 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3590 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Path.path)
3591 : }
3592 : #endif
3593 : inline void Path::set_path(const char* value) {
3594 : GOOGLE_DCHECK(value != NULL);
3595 :
3596 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3597 : // @@protoc_insertion_point(field_set_char:rpc.img.Path.path)
3598 : }
3599 : inline void Path::set_path(const char* value, size_t size) {
3600 :
3601 : path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3602 : ::std::string(reinterpret_cast<const char*>(value), size));
3603 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Path.path)
3604 : }
3605 0 : inline ::std::string* Path::mutable_path() {
3606 :
3607 : // @@protoc_insertion_point(field_mutable:rpc.img.Path.path)
3608 0 : return path_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3609 : }
3610 : inline ::std::string* Path::release_path() {
3611 : // @@protoc_insertion_point(field_release:rpc.img.Path.path)
3612 :
3613 : return path_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3614 : }
3615 : inline void Path::set_allocated_path(::std::string* path) {
3616 : if (path != NULL) {
3617 :
3618 : } else {
3619 :
3620 : }
3621 : path_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), path);
3622 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Path.path)
3623 : }
3624 :
3625 : // -------------------------------------------------------------------
3626 :
3627 : // Coord2D
3628 :
3629 : // float x = 1;
3630 : inline void Coord2D::clear_x() {
3631 : x_ = 0;
3632 : }
3633 0 : inline float Coord2D::x() const {
3634 : // @@protoc_insertion_point(field_get:rpc.img.Coord2D.x)
3635 0 : return x_;
3636 : }
3637 0 : inline void Coord2D::set_x(float value) {
3638 :
3639 0 : x_ = value;
3640 : // @@protoc_insertion_point(field_set:rpc.img.Coord2D.x)
3641 0 : }
3642 :
3643 : // float y = 2;
3644 : inline void Coord2D::clear_y() {
3645 : y_ = 0;
3646 : }
3647 0 : inline float Coord2D::y() const {
3648 : // @@protoc_insertion_point(field_get:rpc.img.Coord2D.y)
3649 0 : return y_;
3650 : }
3651 0 : inline void Coord2D::set_y(float value) {
3652 :
3653 0 : y_ = value;
3654 : // @@protoc_insertion_point(field_set:rpc.img.Coord2D.y)
3655 0 : }
3656 :
3657 : // -------------------------------------------------------------------
3658 :
3659 : // Output
3660 :
3661 : // .rpc.img.Id panel = 1;
3662 0 : inline bool Output::has_panel() const {
3663 0 : return this != internal_default_instance() && panel_ != NULL;
3664 : }
3665 : inline void Output::clear_panel() {
3666 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
3667 : delete panel_;
3668 : }
3669 : panel_ = NULL;
3670 : }
3671 0 : inline const ::rpc::img::Id& Output::_internal_panel() const {
3672 0 : return *panel_;
3673 : }
3674 0 : inline const ::rpc::img::Id& Output::panel() const {
3675 0 : const ::rpc::img::Id* p = panel_;
3676 : // @@protoc_insertion_point(field_get:rpc.img.Output.panel)
3677 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
3678 0 : &::rpc::img::_Id_default_instance_);
3679 : }
3680 : inline ::rpc::img::Id* Output::release_panel() {
3681 : // @@protoc_insertion_point(field_release:rpc.img.Output.panel)
3682 :
3683 : ::rpc::img::Id* temp = panel_;
3684 : panel_ = NULL;
3685 : return temp;
3686 : }
3687 0 : inline ::rpc::img::Id* Output::mutable_panel() {
3688 :
3689 0 : if (panel_ == NULL) {
3690 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
3691 0 : panel_ = p;
3692 : }
3693 : // @@protoc_insertion_point(field_mutable:rpc.img.Output.panel)
3694 0 : return panel_;
3695 : }
3696 : inline void Output::set_allocated_panel(::rpc::img::Id* panel) {
3697 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3698 : if (message_arena == NULL) {
3699 : delete panel_;
3700 : }
3701 : if (panel) {
3702 : ::google::protobuf::Arena* submessage_arena = NULL;
3703 : if (message_arena != submessage_arena) {
3704 : panel = ::google::protobuf::internal::GetOwnedMessage(
3705 : message_arena, panel, submessage_arena);
3706 : }
3707 :
3708 : } else {
3709 :
3710 : }
3711 : panel_ = panel;
3712 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Output.panel)
3713 : }
3714 :
3715 : // string device = 2;
3716 : inline void Output::clear_device() {
3717 : device_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3718 : }
3719 0 : inline const ::std::string& Output::device() const {
3720 : // @@protoc_insertion_point(field_get:rpc.img.Output.device)
3721 0 : return device_.GetNoArena();
3722 : }
3723 : inline void Output::set_device(const ::std::string& value) {
3724 :
3725 : device_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3726 : // @@protoc_insertion_point(field_set:rpc.img.Output.device)
3727 : }
3728 : #if LANG_CXX11
3729 : inline void Output::set_device(::std::string&& value) {
3730 :
3731 : device_.SetNoArena(
3732 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3733 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Output.device)
3734 : }
3735 : #endif
3736 : inline void Output::set_device(const char* value) {
3737 : GOOGLE_DCHECK(value != NULL);
3738 :
3739 : device_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3740 : // @@protoc_insertion_point(field_set_char:rpc.img.Output.device)
3741 : }
3742 : inline void Output::set_device(const char* value, size_t size) {
3743 :
3744 : device_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3745 : ::std::string(reinterpret_cast<const char*>(value), size));
3746 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Output.device)
3747 : }
3748 0 : inline ::std::string* Output::mutable_device() {
3749 :
3750 : // @@protoc_insertion_point(field_mutable:rpc.img.Output.device)
3751 0 : return device_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3752 : }
3753 : inline ::std::string* Output::release_device() {
3754 : // @@protoc_insertion_point(field_release:rpc.img.Output.device)
3755 :
3756 : return device_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3757 : }
3758 : inline void Output::set_allocated_device(::std::string* device) {
3759 : if (device != NULL) {
3760 :
3761 : } else {
3762 :
3763 : }
3764 : device_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), device);
3765 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Output.device)
3766 : }
3767 :
3768 : // string devicetype = 3;
3769 : inline void Output::clear_devicetype() {
3770 : devicetype_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3771 : }
3772 0 : inline const ::std::string& Output::devicetype() const {
3773 : // @@protoc_insertion_point(field_get:rpc.img.Output.devicetype)
3774 0 : return devicetype_.GetNoArena();
3775 : }
3776 : inline void Output::set_devicetype(const ::std::string& value) {
3777 :
3778 : devicetype_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3779 : // @@protoc_insertion_point(field_set:rpc.img.Output.devicetype)
3780 : }
3781 : #if LANG_CXX11
3782 : inline void Output::set_devicetype(::std::string&& value) {
3783 :
3784 : devicetype_.SetNoArena(
3785 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3786 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Output.devicetype)
3787 : }
3788 : #endif
3789 : inline void Output::set_devicetype(const char* value) {
3790 : GOOGLE_DCHECK(value != NULL);
3791 :
3792 : devicetype_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3793 : // @@protoc_insertion_point(field_set_char:rpc.img.Output.devicetype)
3794 : }
3795 : inline void Output::set_devicetype(const char* value, size_t size) {
3796 :
3797 : devicetype_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3798 : ::std::string(reinterpret_cast<const char*>(value), size));
3799 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Output.devicetype)
3800 : }
3801 0 : inline ::std::string* Output::mutable_devicetype() {
3802 :
3803 : // @@protoc_insertion_point(field_mutable:rpc.img.Output.devicetype)
3804 0 : return devicetype_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3805 : }
3806 : inline ::std::string* Output::release_devicetype() {
3807 : // @@protoc_insertion_point(field_release:rpc.img.Output.devicetype)
3808 :
3809 : return devicetype_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3810 : }
3811 : inline void Output::set_allocated_devicetype(::std::string* devicetype) {
3812 : if (devicetype != NULL) {
3813 :
3814 : } else {
3815 :
3816 : }
3817 : devicetype_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), devicetype);
3818 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Output.devicetype)
3819 : }
3820 :
3821 : // string orientation = 4;
3822 : inline void Output::clear_orientation() {
3823 : orientation_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3824 : }
3825 0 : inline const ::std::string& Output::orientation() const {
3826 : // @@protoc_insertion_point(field_get:rpc.img.Output.orientation)
3827 0 : return orientation_.GetNoArena();
3828 : }
3829 : inline void Output::set_orientation(const ::std::string& value) {
3830 :
3831 : orientation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3832 : // @@protoc_insertion_point(field_set:rpc.img.Output.orientation)
3833 : }
3834 : #if LANG_CXX11
3835 : inline void Output::set_orientation(::std::string&& value) {
3836 :
3837 : orientation_.SetNoArena(
3838 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3839 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Output.orientation)
3840 : }
3841 : #endif
3842 : inline void Output::set_orientation(const char* value) {
3843 : GOOGLE_DCHECK(value != NULL);
3844 :
3845 : orientation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3846 : // @@protoc_insertion_point(field_set_char:rpc.img.Output.orientation)
3847 : }
3848 : inline void Output::set_orientation(const char* value, size_t size) {
3849 :
3850 : orientation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3851 : ::std::string(reinterpret_cast<const char*>(value), size));
3852 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Output.orientation)
3853 : }
3854 0 : inline ::std::string* Output::mutable_orientation() {
3855 :
3856 : // @@protoc_insertion_point(field_mutable:rpc.img.Output.orientation)
3857 0 : return orientation_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3858 : }
3859 : inline ::std::string* Output::release_orientation() {
3860 : // @@protoc_insertion_point(field_release:rpc.img.Output.orientation)
3861 :
3862 : return orientation_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3863 : }
3864 : inline void Output::set_allocated_orientation(::std::string* orientation) {
3865 : if (orientation != NULL) {
3866 :
3867 : } else {
3868 :
3869 : }
3870 : orientation_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), orientation);
3871 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Output.orientation)
3872 : }
3873 :
3874 : // string media = 5;
3875 : inline void Output::clear_media() {
3876 : media_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3877 : }
3878 0 : inline const ::std::string& Output::media() const {
3879 : // @@protoc_insertion_point(field_get:rpc.img.Output.media)
3880 0 : return media_.GetNoArena();
3881 : }
3882 : inline void Output::set_media(const ::std::string& value) {
3883 :
3884 : media_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3885 : // @@protoc_insertion_point(field_set:rpc.img.Output.media)
3886 : }
3887 : #if LANG_CXX11
3888 : inline void Output::set_media(::std::string&& value) {
3889 :
3890 : media_.SetNoArena(
3891 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3892 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Output.media)
3893 : }
3894 : #endif
3895 : inline void Output::set_media(const char* value) {
3896 : GOOGLE_DCHECK(value != NULL);
3897 :
3898 : media_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3899 : // @@protoc_insertion_point(field_set_char:rpc.img.Output.media)
3900 : }
3901 : inline void Output::set_media(const char* value, size_t size) {
3902 :
3903 : media_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3904 : ::std::string(reinterpret_cast<const char*>(value), size));
3905 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Output.media)
3906 : }
3907 0 : inline ::std::string* Output::mutable_media() {
3908 :
3909 : // @@protoc_insertion_point(field_mutable:rpc.img.Output.media)
3910 0 : return media_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3911 : }
3912 : inline ::std::string* Output::release_media() {
3913 : // @@protoc_insertion_point(field_release:rpc.img.Output.media)
3914 :
3915 : return media_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3916 : }
3917 : inline void Output::set_allocated_media(::std::string* media) {
3918 : if (media != NULL) {
3919 :
3920 : } else {
3921 :
3922 : }
3923 : media_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), media);
3924 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Output.media)
3925 : }
3926 :
3927 : // string format = 6;
3928 : inline void Output::clear_format() {
3929 : format_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3930 : }
3931 0 : inline const ::std::string& Output::format() const {
3932 : // @@protoc_insertion_point(field_get:rpc.img.Output.format)
3933 0 : return format_.GetNoArena();
3934 : }
3935 : inline void Output::set_format(const ::std::string& value) {
3936 :
3937 : format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3938 : // @@protoc_insertion_point(field_set:rpc.img.Output.format)
3939 : }
3940 : #if LANG_CXX11
3941 : inline void Output::set_format(::std::string&& value) {
3942 :
3943 : format_.SetNoArena(
3944 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3945 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Output.format)
3946 : }
3947 : #endif
3948 : inline void Output::set_format(const char* value) {
3949 : GOOGLE_DCHECK(value != NULL);
3950 :
3951 : format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3952 : // @@protoc_insertion_point(field_set_char:rpc.img.Output.format)
3953 : }
3954 : inline void Output::set_format(const char* value, size_t size) {
3955 :
3956 : format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3957 : ::std::string(reinterpret_cast<const char*>(value), size));
3958 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Output.format)
3959 : }
3960 0 : inline ::std::string* Output::mutable_format() {
3961 :
3962 : // @@protoc_insertion_point(field_mutable:rpc.img.Output.format)
3963 0 : return format_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3964 : }
3965 : inline ::std::string* Output::release_format() {
3966 : // @@protoc_insertion_point(field_release:rpc.img.Output.format)
3967 :
3968 : return format_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3969 : }
3970 : inline void Output::set_allocated_format(::std::string* format) {
3971 : if (format != NULL) {
3972 :
3973 : } else {
3974 :
3975 : }
3976 : format_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), format);
3977 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Output.format)
3978 : }
3979 :
3980 : // float scale = 7;
3981 : inline void Output::clear_scale() {
3982 : scale_ = 0;
3983 : }
3984 0 : inline float Output::scale() const {
3985 : // @@protoc_insertion_point(field_get:rpc.img.Output.scale)
3986 0 : return scale_;
3987 : }
3988 0 : inline void Output::set_scale(float value) {
3989 :
3990 0 : scale_ = value;
3991 : // @@protoc_insertion_point(field_set:rpc.img.Output.scale)
3992 0 : }
3993 :
3994 : // int32 dpi = 8;
3995 : inline void Output::clear_dpi() {
3996 : dpi_ = 0;
3997 : }
3998 0 : inline ::google::protobuf::int32 Output::dpi() const {
3999 : // @@protoc_insertion_point(field_get:rpc.img.Output.dpi)
4000 0 : return dpi_;
4001 : }
4002 0 : inline void Output::set_dpi(::google::protobuf::int32 value) {
4003 :
4004 0 : dpi_ = value;
4005 : // @@protoc_insertion_point(field_set:rpc.img.Output.dpi)
4006 0 : }
4007 :
4008 : // -------------------------------------------------------------------
4009 :
4010 : // SetChannel
4011 :
4012 : // .rpc.img.Id panel = 1;
4013 0 : inline bool SetChannel::has_panel() const {
4014 0 : return this != internal_default_instance() && panel_ != NULL;
4015 : }
4016 : inline void SetChannel::clear_panel() {
4017 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
4018 : delete panel_;
4019 : }
4020 : panel_ = NULL;
4021 : }
4022 0 : inline const ::rpc::img::Id& SetChannel::_internal_panel() const {
4023 0 : return *panel_;
4024 : }
4025 0 : inline const ::rpc::img::Id& SetChannel::panel() const {
4026 0 : const ::rpc::img::Id* p = panel_;
4027 : // @@protoc_insertion_point(field_get:rpc.img.SetChannel.panel)
4028 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4029 0 : &::rpc::img::_Id_default_instance_);
4030 : }
4031 : inline ::rpc::img::Id* SetChannel::release_panel() {
4032 : // @@protoc_insertion_point(field_release:rpc.img.SetChannel.panel)
4033 :
4034 : ::rpc::img::Id* temp = panel_;
4035 : panel_ = NULL;
4036 : return temp;
4037 : }
4038 0 : inline ::rpc::img::Id* SetChannel::mutable_panel() {
4039 :
4040 0 : if (panel_ == NULL) {
4041 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4042 0 : panel_ = p;
4043 : }
4044 : // @@protoc_insertion_point(field_mutable:rpc.img.SetChannel.panel)
4045 0 : return panel_;
4046 : }
4047 : inline void SetChannel::set_allocated_panel(::rpc::img::Id* panel) {
4048 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4049 : if (message_arena == NULL) {
4050 : delete panel_;
4051 : }
4052 : if (panel) {
4053 : ::google::protobuf::Arena* submessage_arena = NULL;
4054 : if (message_arena != submessage_arena) {
4055 : panel = ::google::protobuf::internal::GetOwnedMessage(
4056 : message_arena, panel, submessage_arena);
4057 : }
4058 :
4059 : } else {
4060 :
4061 : }
4062 : panel_ = panel;
4063 : // @@protoc_insertion_point(field_set_allocated:rpc.img.SetChannel.panel)
4064 : }
4065 :
4066 : // int32 number = 2;
4067 : inline void SetChannel::clear_number() {
4068 : number_ = 0;
4069 : }
4070 0 : inline ::google::protobuf::int32 SetChannel::number() const {
4071 : // @@protoc_insertion_point(field_get:rpc.img.SetChannel.number)
4072 0 : return number_;
4073 : }
4074 0 : inline void SetChannel::set_number(::google::protobuf::int32 value) {
4075 :
4076 0 : number_ = value;
4077 : // @@protoc_insertion_point(field_set:rpc.img.SetChannel.number)
4078 0 : }
4079 :
4080 : // -------------------------------------------------------------------
4081 :
4082 : // SetZoomLevel
4083 :
4084 : // .rpc.img.Id panel = 1;
4085 0 : inline bool SetZoomLevel::has_panel() const {
4086 0 : return this != internal_default_instance() && panel_ != NULL;
4087 : }
4088 : inline void SetZoomLevel::clear_panel() {
4089 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
4090 : delete panel_;
4091 : }
4092 : panel_ = NULL;
4093 : }
4094 0 : inline const ::rpc::img::Id& SetZoomLevel::_internal_panel() const {
4095 0 : return *panel_;
4096 : }
4097 0 : inline const ::rpc::img::Id& SetZoomLevel::panel() const {
4098 0 : const ::rpc::img::Id* p = panel_;
4099 : // @@protoc_insertion_point(field_get:rpc.img.SetZoomLevel.panel)
4100 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4101 0 : &::rpc::img::_Id_default_instance_);
4102 : }
4103 : inline ::rpc::img::Id* SetZoomLevel::release_panel() {
4104 : // @@protoc_insertion_point(field_release:rpc.img.SetZoomLevel.panel)
4105 :
4106 : ::rpc::img::Id* temp = panel_;
4107 : panel_ = NULL;
4108 : return temp;
4109 : }
4110 0 : inline ::rpc::img::Id* SetZoomLevel::mutable_panel() {
4111 :
4112 0 : if (panel_ == NULL) {
4113 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4114 0 : panel_ = p;
4115 : }
4116 : // @@protoc_insertion_point(field_mutable:rpc.img.SetZoomLevel.panel)
4117 0 : return panel_;
4118 : }
4119 : inline void SetZoomLevel::set_allocated_panel(::rpc::img::Id* panel) {
4120 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4121 : if (message_arena == NULL) {
4122 : delete panel_;
4123 : }
4124 : if (panel) {
4125 : ::google::protobuf::Arena* submessage_arena = NULL;
4126 : if (message_arena != submessage_arena) {
4127 : panel = ::google::protobuf::internal::GetOwnedMessage(
4128 : message_arena, panel, submessage_arena);
4129 : }
4130 :
4131 : } else {
4132 :
4133 : }
4134 : panel_ = panel;
4135 : // @@protoc_insertion_point(field_set_allocated:rpc.img.SetZoomLevel.panel)
4136 : }
4137 :
4138 : // int32 level = 2;
4139 : inline void SetZoomLevel::clear_level() {
4140 : level_ = 0;
4141 : }
4142 0 : inline ::google::protobuf::int32 SetZoomLevel::level() const {
4143 : // @@protoc_insertion_point(field_get:rpc.img.SetZoomLevel.level)
4144 0 : return level_;
4145 : }
4146 0 : inline void SetZoomLevel::set_level(::google::protobuf::int32 value) {
4147 :
4148 0 : level_ = value;
4149 : // @@protoc_insertion_point(field_set:rpc.img.SetZoomLevel.level)
4150 0 : }
4151 :
4152 : // -------------------------------------------------------------------
4153 :
4154 : // SetZoomBox
4155 :
4156 : // .rpc.img.Id panel = 1;
4157 0 : inline bool SetZoomBox::has_panel() const {
4158 0 : return this != internal_default_instance() && panel_ != NULL;
4159 : }
4160 : inline void SetZoomBox::clear_panel() {
4161 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
4162 : delete panel_;
4163 : }
4164 : panel_ = NULL;
4165 : }
4166 0 : inline const ::rpc::img::Id& SetZoomBox::_internal_panel() const {
4167 0 : return *panel_;
4168 : }
4169 0 : inline const ::rpc::img::Id& SetZoomBox::panel() const {
4170 0 : const ::rpc::img::Id* p = panel_;
4171 : // @@protoc_insertion_point(field_get:rpc.img.SetZoomBox.panel)
4172 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4173 0 : &::rpc::img::_Id_default_instance_);
4174 : }
4175 : inline ::rpc::img::Id* SetZoomBox::release_panel() {
4176 : // @@protoc_insertion_point(field_release:rpc.img.SetZoomBox.panel)
4177 :
4178 : ::rpc::img::Id* temp = panel_;
4179 : panel_ = NULL;
4180 : return temp;
4181 : }
4182 0 : inline ::rpc::img::Id* SetZoomBox::mutable_panel() {
4183 :
4184 0 : if (panel_ == NULL) {
4185 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4186 0 : panel_ = p;
4187 : }
4188 : // @@protoc_insertion_point(field_mutable:rpc.img.SetZoomBox.panel)
4189 0 : return panel_;
4190 : }
4191 : inline void SetZoomBox::set_allocated_panel(::rpc::img::Id* panel) {
4192 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4193 : if (message_arena == NULL) {
4194 : delete panel_;
4195 : }
4196 : if (panel) {
4197 : ::google::protobuf::Arena* submessage_arena = NULL;
4198 : if (message_arena != submessage_arena) {
4199 : panel = ::google::protobuf::internal::GetOwnedMessage(
4200 : message_arena, panel, submessage_arena);
4201 : }
4202 :
4203 : } else {
4204 :
4205 : }
4206 : panel_ = panel;
4207 : // @@protoc_insertion_point(field_set_allocated:rpc.img.SetZoomBox.panel)
4208 : }
4209 :
4210 : // .rpc.img.Coord2D blc = 2;
4211 0 : inline bool SetZoomBox::has_blc() const {
4212 0 : return this != internal_default_instance() && blc_ != NULL;
4213 : }
4214 : inline void SetZoomBox::clear_blc() {
4215 : if (GetArenaNoVirtual() == NULL && blc_ != NULL) {
4216 : delete blc_;
4217 : }
4218 : blc_ = NULL;
4219 : }
4220 0 : inline const ::rpc::img::Coord2D& SetZoomBox::_internal_blc() const {
4221 0 : return *blc_;
4222 : }
4223 0 : inline const ::rpc::img::Coord2D& SetZoomBox::blc() const {
4224 0 : const ::rpc::img::Coord2D* p = blc_;
4225 : // @@protoc_insertion_point(field_get:rpc.img.SetZoomBox.blc)
4226 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Coord2D*>(
4227 0 : &::rpc::img::_Coord2D_default_instance_);
4228 : }
4229 : inline ::rpc::img::Coord2D* SetZoomBox::release_blc() {
4230 : // @@protoc_insertion_point(field_release:rpc.img.SetZoomBox.blc)
4231 :
4232 : ::rpc::img::Coord2D* temp = blc_;
4233 : blc_ = NULL;
4234 : return temp;
4235 : }
4236 0 : inline ::rpc::img::Coord2D* SetZoomBox::mutable_blc() {
4237 :
4238 0 : if (blc_ == NULL) {
4239 0 : auto* p = CreateMaybeMessage<::rpc::img::Coord2D>(GetArenaNoVirtual());
4240 0 : blc_ = p;
4241 : }
4242 : // @@protoc_insertion_point(field_mutable:rpc.img.SetZoomBox.blc)
4243 0 : return blc_;
4244 : }
4245 : inline void SetZoomBox::set_allocated_blc(::rpc::img::Coord2D* blc) {
4246 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4247 : if (message_arena == NULL) {
4248 : delete blc_;
4249 : }
4250 : if (blc) {
4251 : ::google::protobuf::Arena* submessage_arena = NULL;
4252 : if (message_arena != submessage_arena) {
4253 : blc = ::google::protobuf::internal::GetOwnedMessage(
4254 : message_arena, blc, submessage_arena);
4255 : }
4256 :
4257 : } else {
4258 :
4259 : }
4260 : blc_ = blc;
4261 : // @@protoc_insertion_point(field_set_allocated:rpc.img.SetZoomBox.blc)
4262 : }
4263 :
4264 : // .rpc.img.Coord2D trc = 3;
4265 0 : inline bool SetZoomBox::has_trc() const {
4266 0 : return this != internal_default_instance() && trc_ != NULL;
4267 : }
4268 : inline void SetZoomBox::clear_trc() {
4269 : if (GetArenaNoVirtual() == NULL && trc_ != NULL) {
4270 : delete trc_;
4271 : }
4272 : trc_ = NULL;
4273 : }
4274 0 : inline const ::rpc::img::Coord2D& SetZoomBox::_internal_trc() const {
4275 0 : return *trc_;
4276 : }
4277 0 : inline const ::rpc::img::Coord2D& SetZoomBox::trc() const {
4278 0 : const ::rpc::img::Coord2D* p = trc_;
4279 : // @@protoc_insertion_point(field_get:rpc.img.SetZoomBox.trc)
4280 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Coord2D*>(
4281 0 : &::rpc::img::_Coord2D_default_instance_);
4282 : }
4283 : inline ::rpc::img::Coord2D* SetZoomBox::release_trc() {
4284 : // @@protoc_insertion_point(field_release:rpc.img.SetZoomBox.trc)
4285 :
4286 : ::rpc::img::Coord2D* temp = trc_;
4287 : trc_ = NULL;
4288 : return temp;
4289 : }
4290 0 : inline ::rpc::img::Coord2D* SetZoomBox::mutable_trc() {
4291 :
4292 0 : if (trc_ == NULL) {
4293 0 : auto* p = CreateMaybeMessage<::rpc::img::Coord2D>(GetArenaNoVirtual());
4294 0 : trc_ = p;
4295 : }
4296 : // @@protoc_insertion_point(field_mutable:rpc.img.SetZoomBox.trc)
4297 0 : return trc_;
4298 : }
4299 : inline void SetZoomBox::set_allocated_trc(::rpc::img::Coord2D* trc) {
4300 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4301 : if (message_arena == NULL) {
4302 : delete trc_;
4303 : }
4304 : if (trc) {
4305 : ::google::protobuf::Arena* submessage_arena = NULL;
4306 : if (message_arena != submessage_arena) {
4307 : trc = ::google::protobuf::internal::GetOwnedMessage(
4308 : message_arena, trc, submessage_arena);
4309 : }
4310 :
4311 : } else {
4312 :
4313 : }
4314 : trc_ = trc;
4315 : // @@protoc_insertion_point(field_set_allocated:rpc.img.SetZoomBox.trc)
4316 : }
4317 :
4318 : // string coord_type = 4;
4319 : inline void SetZoomBox::clear_coord_type() {
4320 : coord_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4321 : }
4322 0 : inline const ::std::string& SetZoomBox::coord_type() const {
4323 : // @@protoc_insertion_point(field_get:rpc.img.SetZoomBox.coord_type)
4324 0 : return coord_type_.GetNoArena();
4325 : }
4326 : inline void SetZoomBox::set_coord_type(const ::std::string& value) {
4327 :
4328 : coord_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4329 : // @@protoc_insertion_point(field_set:rpc.img.SetZoomBox.coord_type)
4330 : }
4331 : #if LANG_CXX11
4332 : inline void SetZoomBox::set_coord_type(::std::string&& value) {
4333 :
4334 : coord_type_.SetNoArena(
4335 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4336 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.SetZoomBox.coord_type)
4337 : }
4338 : #endif
4339 : inline void SetZoomBox::set_coord_type(const char* value) {
4340 : GOOGLE_DCHECK(value != NULL);
4341 :
4342 : coord_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4343 : // @@protoc_insertion_point(field_set_char:rpc.img.SetZoomBox.coord_type)
4344 : }
4345 : inline void SetZoomBox::set_coord_type(const char* value, size_t size) {
4346 :
4347 : coord_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4348 : ::std::string(reinterpret_cast<const char*>(value), size));
4349 : // @@protoc_insertion_point(field_set_pointer:rpc.img.SetZoomBox.coord_type)
4350 : }
4351 0 : inline ::std::string* SetZoomBox::mutable_coord_type() {
4352 :
4353 : // @@protoc_insertion_point(field_mutable:rpc.img.SetZoomBox.coord_type)
4354 0 : return coord_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4355 : }
4356 : inline ::std::string* SetZoomBox::release_coord_type() {
4357 : // @@protoc_insertion_point(field_release:rpc.img.SetZoomBox.coord_type)
4358 :
4359 : return coord_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4360 : }
4361 : inline void SetZoomBox::set_allocated_coord_type(::std::string* coord_type) {
4362 : if (coord_type != NULL) {
4363 :
4364 : } else {
4365 :
4366 : }
4367 : coord_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), coord_type);
4368 : // @@protoc_insertion_point(field_set_allocated:rpc.img.SetZoomBox.coord_type)
4369 : }
4370 :
4371 : // -------------------------------------------------------------------
4372 :
4373 : // DataRange
4374 :
4375 : // .rpc.img.Id data = 1;
4376 0 : inline bool DataRange::has_data() const {
4377 0 : return this != internal_default_instance() && data_ != NULL;
4378 : }
4379 : inline void DataRange::clear_data() {
4380 : if (GetArenaNoVirtual() == NULL && data_ != NULL) {
4381 : delete data_;
4382 : }
4383 : data_ = NULL;
4384 : }
4385 0 : inline const ::rpc::img::Id& DataRange::_internal_data() const {
4386 0 : return *data_;
4387 : }
4388 0 : inline const ::rpc::img::Id& DataRange::data() const {
4389 0 : const ::rpc::img::Id* p = data_;
4390 : // @@protoc_insertion_point(field_get:rpc.img.DataRange.data)
4391 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4392 0 : &::rpc::img::_Id_default_instance_);
4393 : }
4394 : inline ::rpc::img::Id* DataRange::release_data() {
4395 : // @@protoc_insertion_point(field_release:rpc.img.DataRange.data)
4396 :
4397 : ::rpc::img::Id* temp = data_;
4398 : data_ = NULL;
4399 : return temp;
4400 : }
4401 0 : inline ::rpc::img::Id* DataRange::mutable_data() {
4402 :
4403 0 : if (data_ == NULL) {
4404 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4405 0 : data_ = p;
4406 : }
4407 : // @@protoc_insertion_point(field_mutable:rpc.img.DataRange.data)
4408 0 : return data_;
4409 : }
4410 : inline void DataRange::set_allocated_data(::rpc::img::Id* data) {
4411 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4412 : if (message_arena == NULL) {
4413 : delete data_;
4414 : }
4415 : if (data) {
4416 : ::google::protobuf::Arena* submessage_arena = NULL;
4417 : if (message_arena != submessage_arena) {
4418 : data = ::google::protobuf::internal::GetOwnedMessage(
4419 : message_arena, data, submessage_arena);
4420 : }
4421 :
4422 : } else {
4423 :
4424 : }
4425 : data_ = data;
4426 : // @@protoc_insertion_point(field_set_allocated:rpc.img.DataRange.data)
4427 : }
4428 :
4429 : // float min = 2;
4430 : inline void DataRange::clear_min() {
4431 : min_ = 0;
4432 : }
4433 0 : inline float DataRange::min() const {
4434 : // @@protoc_insertion_point(field_get:rpc.img.DataRange.min)
4435 0 : return min_;
4436 : }
4437 0 : inline void DataRange::set_min(float value) {
4438 :
4439 0 : min_ = value;
4440 : // @@protoc_insertion_point(field_set:rpc.img.DataRange.min)
4441 0 : }
4442 :
4443 : // float max = 3;
4444 : inline void DataRange::clear_max() {
4445 : max_ = 0;
4446 : }
4447 0 : inline float DataRange::max() const {
4448 : // @@protoc_insertion_point(field_get:rpc.img.DataRange.max)
4449 0 : return max_;
4450 : }
4451 0 : inline void DataRange::set_max(float value) {
4452 :
4453 0 : max_ = value;
4454 : // @@protoc_insertion_point(field_set:rpc.img.DataRange.max)
4455 0 : }
4456 :
4457 : // -------------------------------------------------------------------
4458 :
4459 : // ContourLevels
4460 :
4461 : // .rpc.img.Id id = 1;
4462 0 : inline bool ContourLevels::has_id() const {
4463 0 : return this != internal_default_instance() && id_ != NULL;
4464 : }
4465 : inline void ContourLevels::clear_id() {
4466 : if (GetArenaNoVirtual() == NULL && id_ != NULL) {
4467 : delete id_;
4468 : }
4469 : id_ = NULL;
4470 : }
4471 0 : inline const ::rpc::img::Id& ContourLevels::_internal_id() const {
4472 0 : return *id_;
4473 : }
4474 0 : inline const ::rpc::img::Id& ContourLevels::id() const {
4475 0 : const ::rpc::img::Id* p = id_;
4476 : // @@protoc_insertion_point(field_get:rpc.img.ContourLevels.id)
4477 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4478 0 : &::rpc::img::_Id_default_instance_);
4479 : }
4480 : inline ::rpc::img::Id* ContourLevels::release_id() {
4481 : // @@protoc_insertion_point(field_release:rpc.img.ContourLevels.id)
4482 :
4483 : ::rpc::img::Id* temp = id_;
4484 : id_ = NULL;
4485 : return temp;
4486 : }
4487 0 : inline ::rpc::img::Id* ContourLevels::mutable_id() {
4488 :
4489 0 : if (id_ == NULL) {
4490 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4491 0 : id_ = p;
4492 : }
4493 : // @@protoc_insertion_point(field_mutable:rpc.img.ContourLevels.id)
4494 0 : return id_;
4495 : }
4496 : inline void ContourLevels::set_allocated_id(::rpc::img::Id* id) {
4497 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4498 : if (message_arena == NULL) {
4499 : delete id_;
4500 : }
4501 : if (id) {
4502 : ::google::protobuf::Arena* submessage_arena = NULL;
4503 : if (message_arena != submessage_arena) {
4504 : id = ::google::protobuf::internal::GetOwnedMessage(
4505 : message_arena, id, submessage_arena);
4506 : }
4507 :
4508 : } else {
4509 :
4510 : }
4511 : id_ = id;
4512 : // @@protoc_insertion_point(field_set_allocated:rpc.img.ContourLevels.id)
4513 : }
4514 :
4515 : // repeated float levels = 2;
4516 0 : inline int ContourLevels::levels_size() const {
4517 0 : return levels_.size();
4518 : }
4519 : inline void ContourLevels::clear_levels() {
4520 : levels_.Clear();
4521 : }
4522 : inline float ContourLevels::levels(int index) const {
4523 : // @@protoc_insertion_point(field_get:rpc.img.ContourLevels.levels)
4524 : return levels_.Get(index);
4525 : }
4526 : inline void ContourLevels::set_levels(int index, float value) {
4527 : levels_.Set(index, value);
4528 : // @@protoc_insertion_point(field_set:rpc.img.ContourLevels.levels)
4529 : }
4530 : inline void ContourLevels::add_levels(float value) {
4531 : levels_.Add(value);
4532 : // @@protoc_insertion_point(field_add:rpc.img.ContourLevels.levels)
4533 : }
4534 : inline const ::google::protobuf::RepeatedField< float >&
4535 0 : ContourLevels::levels() const {
4536 : // @@protoc_insertion_point(field_list:rpc.img.ContourLevels.levels)
4537 0 : return levels_;
4538 : }
4539 : inline ::google::protobuf::RepeatedField< float >*
4540 0 : ContourLevels::mutable_levels() {
4541 : // @@protoc_insertion_point(field_mutable_list:rpc.img.ContourLevels.levels)
4542 0 : return &levels_;
4543 : }
4544 :
4545 : // float baselevel = 3;
4546 : inline void ContourLevels::clear_baselevel() {
4547 : baselevel_ = 0;
4548 : }
4549 0 : inline float ContourLevels::baselevel() const {
4550 : // @@protoc_insertion_point(field_get:rpc.img.ContourLevels.baselevel)
4551 0 : return baselevel_;
4552 : }
4553 0 : inline void ContourLevels::set_baselevel(float value) {
4554 :
4555 0 : baselevel_ = value;
4556 : // @@protoc_insertion_point(field_set:rpc.img.ContourLevels.baselevel)
4557 0 : }
4558 :
4559 : // float unitlevel = 4;
4560 : inline void ContourLevels::clear_unitlevel() {
4561 : unitlevel_ = 0;
4562 : }
4563 0 : inline float ContourLevels::unitlevel() const {
4564 : // @@protoc_insertion_point(field_get:rpc.img.ContourLevels.unitlevel)
4565 0 : return unitlevel_;
4566 : }
4567 0 : inline void ContourLevels::set_unitlevel(float value) {
4568 :
4569 0 : unitlevel_ = value;
4570 : // @@protoc_insertion_point(field_set:rpc.img.ContourLevels.unitlevel)
4571 0 : }
4572 :
4573 : // -------------------------------------------------------------------
4574 :
4575 : // ContourThickness
4576 :
4577 : // .rpc.img.Id id = 1;
4578 0 : inline bool ContourThickness::has_id() const {
4579 0 : return this != internal_default_instance() && id_ != NULL;
4580 : }
4581 : inline void ContourThickness::clear_id() {
4582 : if (GetArenaNoVirtual() == NULL && id_ != NULL) {
4583 : delete id_;
4584 : }
4585 : id_ = NULL;
4586 : }
4587 0 : inline const ::rpc::img::Id& ContourThickness::_internal_id() const {
4588 0 : return *id_;
4589 : }
4590 0 : inline const ::rpc::img::Id& ContourThickness::id() const {
4591 0 : const ::rpc::img::Id* p = id_;
4592 : // @@protoc_insertion_point(field_get:rpc.img.ContourThickness.id)
4593 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4594 0 : &::rpc::img::_Id_default_instance_);
4595 : }
4596 : inline ::rpc::img::Id* ContourThickness::release_id() {
4597 : // @@protoc_insertion_point(field_release:rpc.img.ContourThickness.id)
4598 :
4599 : ::rpc::img::Id* temp = id_;
4600 : id_ = NULL;
4601 : return temp;
4602 : }
4603 0 : inline ::rpc::img::Id* ContourThickness::mutable_id() {
4604 :
4605 0 : if (id_ == NULL) {
4606 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4607 0 : id_ = p;
4608 : }
4609 : // @@protoc_insertion_point(field_mutable:rpc.img.ContourThickness.id)
4610 0 : return id_;
4611 : }
4612 : inline void ContourThickness::set_allocated_id(::rpc::img::Id* id) {
4613 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4614 : if (message_arena == NULL) {
4615 : delete id_;
4616 : }
4617 : if (id) {
4618 : ::google::protobuf::Arena* submessage_arena = NULL;
4619 : if (message_arena != submessage_arena) {
4620 : id = ::google::protobuf::internal::GetOwnedMessage(
4621 : message_arena, id, submessage_arena);
4622 : }
4623 :
4624 : } else {
4625 :
4626 : }
4627 : id_ = id;
4628 : // @@protoc_insertion_point(field_set_allocated:rpc.img.ContourThickness.id)
4629 : }
4630 :
4631 : // float thickness = 2;
4632 : inline void ContourThickness::clear_thickness() {
4633 : thickness_ = 0;
4634 : }
4635 0 : inline float ContourThickness::thickness() const {
4636 : // @@protoc_insertion_point(field_get:rpc.img.ContourThickness.thickness)
4637 0 : return thickness_;
4638 : }
4639 0 : inline void ContourThickness::set_thickness(float value) {
4640 :
4641 0 : thickness_ = value;
4642 : // @@protoc_insertion_point(field_set:rpc.img.ContourThickness.thickness)
4643 0 : }
4644 :
4645 : // -------------------------------------------------------------------
4646 :
4647 : // ContourColor
4648 :
4649 : // .rpc.img.Id id = 1;
4650 0 : inline bool ContourColor::has_id() const {
4651 0 : return this != internal_default_instance() && id_ != NULL;
4652 : }
4653 : inline void ContourColor::clear_id() {
4654 : if (GetArenaNoVirtual() == NULL && id_ != NULL) {
4655 : delete id_;
4656 : }
4657 : id_ = NULL;
4658 : }
4659 0 : inline const ::rpc::img::Id& ContourColor::_internal_id() const {
4660 0 : return *id_;
4661 : }
4662 0 : inline const ::rpc::img::Id& ContourColor::id() const {
4663 0 : const ::rpc::img::Id* p = id_;
4664 : // @@protoc_insertion_point(field_get:rpc.img.ContourColor.id)
4665 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4666 0 : &::rpc::img::_Id_default_instance_);
4667 : }
4668 : inline ::rpc::img::Id* ContourColor::release_id() {
4669 : // @@protoc_insertion_point(field_release:rpc.img.ContourColor.id)
4670 :
4671 : ::rpc::img::Id* temp = id_;
4672 : id_ = NULL;
4673 : return temp;
4674 : }
4675 0 : inline ::rpc::img::Id* ContourColor::mutable_id() {
4676 :
4677 0 : if (id_ == NULL) {
4678 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4679 0 : id_ = p;
4680 : }
4681 : // @@protoc_insertion_point(field_mutable:rpc.img.ContourColor.id)
4682 0 : return id_;
4683 : }
4684 : inline void ContourColor::set_allocated_id(::rpc::img::Id* id) {
4685 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4686 : if (message_arena == NULL) {
4687 : delete id_;
4688 : }
4689 : if (id) {
4690 : ::google::protobuf::Arena* submessage_arena = NULL;
4691 : if (message_arena != submessage_arena) {
4692 : id = ::google::protobuf::internal::GetOwnedMessage(
4693 : message_arena, id, submessage_arena);
4694 : }
4695 :
4696 : } else {
4697 :
4698 : }
4699 : id_ = id;
4700 : // @@protoc_insertion_point(field_set_allocated:rpc.img.ContourColor.id)
4701 : }
4702 :
4703 : // string color = 2;
4704 : inline void ContourColor::clear_color() {
4705 : color_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4706 : }
4707 0 : inline const ::std::string& ContourColor::color() const {
4708 : // @@protoc_insertion_point(field_get:rpc.img.ContourColor.color)
4709 0 : return color_.GetNoArena();
4710 : }
4711 : inline void ContourColor::set_color(const ::std::string& value) {
4712 :
4713 : color_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4714 : // @@protoc_insertion_point(field_set:rpc.img.ContourColor.color)
4715 : }
4716 : #if LANG_CXX11
4717 : inline void ContourColor::set_color(::std::string&& value) {
4718 :
4719 : color_.SetNoArena(
4720 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4721 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.ContourColor.color)
4722 : }
4723 : #endif
4724 : inline void ContourColor::set_color(const char* value) {
4725 : GOOGLE_DCHECK(value != NULL);
4726 :
4727 : color_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4728 : // @@protoc_insertion_point(field_set_char:rpc.img.ContourColor.color)
4729 : }
4730 : inline void ContourColor::set_color(const char* value, size_t size) {
4731 :
4732 : color_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4733 : ::std::string(reinterpret_cast<const char*>(value), size));
4734 : // @@protoc_insertion_point(field_set_pointer:rpc.img.ContourColor.color)
4735 : }
4736 0 : inline ::std::string* ContourColor::mutable_color() {
4737 :
4738 : // @@protoc_insertion_point(field_mutable:rpc.img.ContourColor.color)
4739 0 : return color_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4740 : }
4741 : inline ::std::string* ContourColor::release_color() {
4742 : // @@protoc_insertion_point(field_release:rpc.img.ContourColor.color)
4743 :
4744 : return color_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4745 : }
4746 : inline void ContourColor::set_allocated_color(::std::string* color) {
4747 : if (color != NULL) {
4748 :
4749 : } else {
4750 :
4751 : }
4752 : color_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), color);
4753 : // @@protoc_insertion_point(field_set_allocated:rpc.img.ContourColor.color)
4754 : }
4755 :
4756 : // -------------------------------------------------------------------
4757 :
4758 : // Axes
4759 :
4760 : // .rpc.img.Id panel = 1;
4761 0 : inline bool Axes::has_panel() const {
4762 0 : return this != internal_default_instance() && panel_ != NULL;
4763 : }
4764 : inline void Axes::clear_panel() {
4765 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
4766 : delete panel_;
4767 : }
4768 : panel_ = NULL;
4769 : }
4770 0 : inline const ::rpc::img::Id& Axes::_internal_panel() const {
4771 0 : return *panel_;
4772 : }
4773 0 : inline const ::rpc::img::Id& Axes::panel() const {
4774 0 : const ::rpc::img::Id* p = panel_;
4775 : // @@protoc_insertion_point(field_get:rpc.img.Axes.panel)
4776 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4777 0 : &::rpc::img::_Id_default_instance_);
4778 : }
4779 : inline ::rpc::img::Id* Axes::release_panel() {
4780 : // @@protoc_insertion_point(field_release:rpc.img.Axes.panel)
4781 :
4782 : ::rpc::img::Id* temp = panel_;
4783 : panel_ = NULL;
4784 : return temp;
4785 : }
4786 0 : inline ::rpc::img::Id* Axes::mutable_panel() {
4787 :
4788 0 : if (panel_ == NULL) {
4789 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
4790 0 : panel_ = p;
4791 : }
4792 : // @@protoc_insertion_point(field_mutable:rpc.img.Axes.panel)
4793 0 : return panel_;
4794 : }
4795 : inline void Axes::set_allocated_panel(::rpc::img::Id* panel) {
4796 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4797 : if (message_arena == NULL) {
4798 : delete panel_;
4799 : }
4800 : if (panel) {
4801 : ::google::protobuf::Arena* submessage_arena = NULL;
4802 : if (message_arena != submessage_arena) {
4803 : panel = ::google::protobuf::internal::GetOwnedMessage(
4804 : message_arena, panel, submessage_arena);
4805 : }
4806 :
4807 : } else {
4808 :
4809 : }
4810 : panel_ = panel;
4811 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Axes.panel)
4812 : }
4813 :
4814 : // string x = 2;
4815 : inline void Axes::clear_x() {
4816 : x_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4817 : }
4818 0 : inline const ::std::string& Axes::x() const {
4819 : // @@protoc_insertion_point(field_get:rpc.img.Axes.x)
4820 0 : return x_.GetNoArena();
4821 : }
4822 : inline void Axes::set_x(const ::std::string& value) {
4823 :
4824 : x_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4825 : // @@protoc_insertion_point(field_set:rpc.img.Axes.x)
4826 : }
4827 : #if LANG_CXX11
4828 : inline void Axes::set_x(::std::string&& value) {
4829 :
4830 : x_.SetNoArena(
4831 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4832 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Axes.x)
4833 : }
4834 : #endif
4835 : inline void Axes::set_x(const char* value) {
4836 : GOOGLE_DCHECK(value != NULL);
4837 :
4838 : x_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4839 : // @@protoc_insertion_point(field_set_char:rpc.img.Axes.x)
4840 : }
4841 : inline void Axes::set_x(const char* value, size_t size) {
4842 :
4843 : x_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4844 : ::std::string(reinterpret_cast<const char*>(value), size));
4845 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Axes.x)
4846 : }
4847 0 : inline ::std::string* Axes::mutable_x() {
4848 :
4849 : // @@protoc_insertion_point(field_mutable:rpc.img.Axes.x)
4850 0 : return x_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4851 : }
4852 : inline ::std::string* Axes::release_x() {
4853 : // @@protoc_insertion_point(field_release:rpc.img.Axes.x)
4854 :
4855 : return x_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4856 : }
4857 : inline void Axes::set_allocated_x(::std::string* x) {
4858 : if (x != NULL) {
4859 :
4860 : } else {
4861 :
4862 : }
4863 : x_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), x);
4864 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Axes.x)
4865 : }
4866 :
4867 : // string y = 3;
4868 : inline void Axes::clear_y() {
4869 : y_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4870 : }
4871 0 : inline const ::std::string& Axes::y() const {
4872 : // @@protoc_insertion_point(field_get:rpc.img.Axes.y)
4873 0 : return y_.GetNoArena();
4874 : }
4875 : inline void Axes::set_y(const ::std::string& value) {
4876 :
4877 : y_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4878 : // @@protoc_insertion_point(field_set:rpc.img.Axes.y)
4879 : }
4880 : #if LANG_CXX11
4881 : inline void Axes::set_y(::std::string&& value) {
4882 :
4883 : y_.SetNoArena(
4884 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4885 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Axes.y)
4886 : }
4887 : #endif
4888 : inline void Axes::set_y(const char* value) {
4889 : GOOGLE_DCHECK(value != NULL);
4890 :
4891 : y_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4892 : // @@protoc_insertion_point(field_set_char:rpc.img.Axes.y)
4893 : }
4894 : inline void Axes::set_y(const char* value, size_t size) {
4895 :
4896 : y_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4897 : ::std::string(reinterpret_cast<const char*>(value), size));
4898 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Axes.y)
4899 : }
4900 0 : inline ::std::string* Axes::mutable_y() {
4901 :
4902 : // @@protoc_insertion_point(field_mutable:rpc.img.Axes.y)
4903 0 : return y_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4904 : }
4905 : inline ::std::string* Axes::release_y() {
4906 : // @@protoc_insertion_point(field_release:rpc.img.Axes.y)
4907 :
4908 : return y_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4909 : }
4910 : inline void Axes::set_allocated_y(::std::string* y) {
4911 : if (y != NULL) {
4912 :
4913 : } else {
4914 :
4915 : }
4916 : y_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), y);
4917 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Axes.y)
4918 : }
4919 :
4920 : // string z = 4;
4921 : inline void Axes::clear_z() {
4922 : z_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4923 : }
4924 0 : inline const ::std::string& Axes::z() const {
4925 : // @@protoc_insertion_point(field_get:rpc.img.Axes.z)
4926 0 : return z_.GetNoArena();
4927 : }
4928 : inline void Axes::set_z(const ::std::string& value) {
4929 :
4930 : z_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4931 : // @@protoc_insertion_point(field_set:rpc.img.Axes.z)
4932 : }
4933 : #if LANG_CXX11
4934 : inline void Axes::set_z(::std::string&& value) {
4935 :
4936 : z_.SetNoArena(
4937 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4938 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.Axes.z)
4939 : }
4940 : #endif
4941 : inline void Axes::set_z(const char* value) {
4942 : GOOGLE_DCHECK(value != NULL);
4943 :
4944 : z_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4945 : // @@protoc_insertion_point(field_set_char:rpc.img.Axes.z)
4946 : }
4947 : inline void Axes::set_z(const char* value, size_t size) {
4948 :
4949 : z_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4950 : ::std::string(reinterpret_cast<const char*>(value), size));
4951 : // @@protoc_insertion_point(field_set_pointer:rpc.img.Axes.z)
4952 : }
4953 0 : inline ::std::string* Axes::mutable_z() {
4954 :
4955 : // @@protoc_insertion_point(field_mutable:rpc.img.Axes.z)
4956 0 : return z_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4957 : }
4958 : inline ::std::string* Axes::release_z() {
4959 : // @@protoc_insertion_point(field_release:rpc.img.Axes.z)
4960 :
4961 : return z_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4962 : }
4963 : inline void Axes::set_allocated_z(::std::string* z) {
4964 : if (z != NULL) {
4965 :
4966 : } else {
4967 :
4968 : }
4969 : z_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), z);
4970 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Axes.z)
4971 : }
4972 :
4973 : // -------------------------------------------------------------------
4974 :
4975 : // ColorMap
4976 :
4977 : // .rpc.img.Id id = 1;
4978 0 : inline bool ColorMap::has_id() const {
4979 0 : return this != internal_default_instance() && id_ != NULL;
4980 : }
4981 : inline void ColorMap::clear_id() {
4982 : if (GetArenaNoVirtual() == NULL && id_ != NULL) {
4983 : delete id_;
4984 : }
4985 : id_ = NULL;
4986 : }
4987 0 : inline const ::rpc::img::Id& ColorMap::_internal_id() const {
4988 0 : return *id_;
4989 : }
4990 0 : inline const ::rpc::img::Id& ColorMap::id() const {
4991 0 : const ::rpc::img::Id* p = id_;
4992 : // @@protoc_insertion_point(field_get:rpc.img.ColorMap.id)
4993 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
4994 0 : &::rpc::img::_Id_default_instance_);
4995 : }
4996 : inline ::rpc::img::Id* ColorMap::release_id() {
4997 : // @@protoc_insertion_point(field_release:rpc.img.ColorMap.id)
4998 :
4999 : ::rpc::img::Id* temp = id_;
5000 : id_ = NULL;
5001 : return temp;
5002 : }
5003 0 : inline ::rpc::img::Id* ColorMap::mutable_id() {
5004 :
5005 0 : if (id_ == NULL) {
5006 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
5007 0 : id_ = p;
5008 : }
5009 : // @@protoc_insertion_point(field_mutable:rpc.img.ColorMap.id)
5010 0 : return id_;
5011 : }
5012 : inline void ColorMap::set_allocated_id(::rpc::img::Id* id) {
5013 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5014 : if (message_arena == NULL) {
5015 : delete id_;
5016 : }
5017 : if (id) {
5018 : ::google::protobuf::Arena* submessage_arena = NULL;
5019 : if (message_arena != submessage_arena) {
5020 : id = ::google::protobuf::internal::GetOwnedMessage(
5021 : message_arena, id, submessage_arena);
5022 : }
5023 :
5024 : } else {
5025 :
5026 : }
5027 : id_ = id;
5028 : // @@protoc_insertion_point(field_set_allocated:rpc.img.ColorMap.id)
5029 : }
5030 :
5031 : // string map = 2;
5032 : inline void ColorMap::clear_map() {
5033 : map_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5034 : }
5035 0 : inline const ::std::string& ColorMap::map() const {
5036 : // @@protoc_insertion_point(field_get:rpc.img.ColorMap.map)
5037 0 : return map_.GetNoArena();
5038 : }
5039 : inline void ColorMap::set_map(const ::std::string& value) {
5040 :
5041 : map_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5042 : // @@protoc_insertion_point(field_set:rpc.img.ColorMap.map)
5043 : }
5044 : #if LANG_CXX11
5045 : inline void ColorMap::set_map(::std::string&& value) {
5046 :
5047 : map_.SetNoArena(
5048 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5049 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.ColorMap.map)
5050 : }
5051 : #endif
5052 : inline void ColorMap::set_map(const char* value) {
5053 : GOOGLE_DCHECK(value != NULL);
5054 :
5055 : map_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5056 : // @@protoc_insertion_point(field_set_char:rpc.img.ColorMap.map)
5057 : }
5058 : inline void ColorMap::set_map(const char* value, size_t size) {
5059 :
5060 : map_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5061 : ::std::string(reinterpret_cast<const char*>(value), size));
5062 : // @@protoc_insertion_point(field_set_pointer:rpc.img.ColorMap.map)
5063 : }
5064 0 : inline ::std::string* ColorMap::mutable_map() {
5065 :
5066 : // @@protoc_insertion_point(field_mutable:rpc.img.ColorMap.map)
5067 0 : return map_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5068 : }
5069 : inline ::std::string* ColorMap::release_map() {
5070 : // @@protoc_insertion_point(field_release:rpc.img.ColorMap.map)
5071 :
5072 : return map_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5073 : }
5074 : inline void ColorMap::set_allocated_map(::std::string* map) {
5075 : if (map != NULL) {
5076 :
5077 : } else {
5078 :
5079 : }
5080 : map_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), map);
5081 : // @@protoc_insertion_point(field_set_allocated:rpc.img.ColorMap.map)
5082 : }
5083 :
5084 : // -------------------------------------------------------------------
5085 :
5086 : // Toggle
5087 :
5088 : // .rpc.img.Id id = 1;
5089 0 : inline bool Toggle::has_id() const {
5090 0 : return this != internal_default_instance() && id_ != NULL;
5091 : }
5092 : inline void Toggle::clear_id() {
5093 : if (GetArenaNoVirtual() == NULL && id_ != NULL) {
5094 : delete id_;
5095 : }
5096 : id_ = NULL;
5097 : }
5098 0 : inline const ::rpc::img::Id& Toggle::_internal_id() const {
5099 0 : return *id_;
5100 : }
5101 0 : inline const ::rpc::img::Id& Toggle::id() const {
5102 0 : const ::rpc::img::Id* p = id_;
5103 : // @@protoc_insertion_point(field_get:rpc.img.Toggle.id)
5104 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
5105 0 : &::rpc::img::_Id_default_instance_);
5106 : }
5107 : inline ::rpc::img::Id* Toggle::release_id() {
5108 : // @@protoc_insertion_point(field_release:rpc.img.Toggle.id)
5109 :
5110 : ::rpc::img::Id* temp = id_;
5111 : id_ = NULL;
5112 : return temp;
5113 : }
5114 0 : inline ::rpc::img::Id* Toggle::mutable_id() {
5115 :
5116 0 : if (id_ == NULL) {
5117 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
5118 0 : id_ = p;
5119 : }
5120 : // @@protoc_insertion_point(field_mutable:rpc.img.Toggle.id)
5121 0 : return id_;
5122 : }
5123 : inline void Toggle::set_allocated_id(::rpc::img::Id* id) {
5124 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5125 : if (message_arena == NULL) {
5126 : delete id_;
5127 : }
5128 : if (id) {
5129 : ::google::protobuf::Arena* submessage_arena = NULL;
5130 : if (message_arena != submessage_arena) {
5131 : id = ::google::protobuf::internal::GetOwnedMessage(
5132 : message_arena, id, submessage_arena);
5133 : }
5134 :
5135 : } else {
5136 :
5137 : }
5138 : id_ = id;
5139 : // @@protoc_insertion_point(field_set_allocated:rpc.img.Toggle.id)
5140 : }
5141 :
5142 : // bool state = 2;
5143 : inline void Toggle::clear_state() {
5144 : state_ = false;
5145 : }
5146 0 : inline bool Toggle::state() const {
5147 : // @@protoc_insertion_point(field_get:rpc.img.Toggle.state)
5148 0 : return state_;
5149 : }
5150 0 : inline void Toggle::set_state(bool value) {
5151 :
5152 0 : state_ = value;
5153 : // @@protoc_insertion_point(field_set:rpc.img.Toggle.state)
5154 0 : }
5155 :
5156 : // -------------------------------------------------------------------
5157 :
5158 : // InteractiveMaskOptions
5159 :
5160 : // .rpc.img.Id panel = 1;
5161 0 : inline bool InteractiveMaskOptions::has_panel() const {
5162 0 : return this != internal_default_instance() && panel_ != NULL;
5163 : }
5164 : inline void InteractiveMaskOptions::clear_panel() {
5165 : if (GetArenaNoVirtual() == NULL && panel_ != NULL) {
5166 : delete panel_;
5167 : }
5168 : panel_ = NULL;
5169 : }
5170 0 : inline const ::rpc::img::Id& InteractiveMaskOptions::_internal_panel() const {
5171 0 : return *panel_;
5172 : }
5173 0 : inline const ::rpc::img::Id& InteractiveMaskOptions::panel() const {
5174 0 : const ::rpc::img::Id* p = panel_;
5175 : // @@protoc_insertion_point(field_get:rpc.img.InteractiveMaskOptions.panel)
5176 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::Id*>(
5177 0 : &::rpc::img::_Id_default_instance_);
5178 : }
5179 : inline ::rpc::img::Id* InteractiveMaskOptions::release_panel() {
5180 : // @@protoc_insertion_point(field_release:rpc.img.InteractiveMaskOptions.panel)
5181 :
5182 : ::rpc::img::Id* temp = panel_;
5183 : panel_ = NULL;
5184 : return temp;
5185 : }
5186 0 : inline ::rpc::img::Id* InteractiveMaskOptions::mutable_panel() {
5187 :
5188 0 : if (panel_ == NULL) {
5189 0 : auto* p = CreateMaybeMessage<::rpc::img::Id>(GetArenaNoVirtual());
5190 0 : panel_ = p;
5191 : }
5192 : // @@protoc_insertion_point(field_mutable:rpc.img.InteractiveMaskOptions.panel)
5193 0 : return panel_;
5194 : }
5195 : inline void InteractiveMaskOptions::set_allocated_panel(::rpc::img::Id* panel) {
5196 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5197 : if (message_arena == NULL) {
5198 : delete panel_;
5199 : }
5200 : if (panel) {
5201 : ::google::protobuf::Arena* submessage_arena = NULL;
5202 : if (message_arena != submessage_arena) {
5203 : panel = ::google::protobuf::internal::GetOwnedMessage(
5204 : message_arena, panel, submessage_arena);
5205 : }
5206 :
5207 : } else {
5208 :
5209 : }
5210 : panel_ = panel;
5211 : // @@protoc_insertion_point(field_set_allocated:rpc.img.InteractiveMaskOptions.panel)
5212 : }
5213 :
5214 : // int32 niter = 2;
5215 : inline void InteractiveMaskOptions::clear_niter() {
5216 : niter_ = 0;
5217 : }
5218 0 : inline ::google::protobuf::int32 InteractiveMaskOptions::niter() const {
5219 : // @@protoc_insertion_point(field_get:rpc.img.InteractiveMaskOptions.niter)
5220 0 : return niter_;
5221 : }
5222 0 : inline void InteractiveMaskOptions::set_niter(::google::protobuf::int32 value) {
5223 :
5224 0 : niter_ = value;
5225 : // @@protoc_insertion_point(field_set:rpc.img.InteractiveMaskOptions.niter)
5226 0 : }
5227 :
5228 : // int32 cycleniter = 3;
5229 : inline void InteractiveMaskOptions::clear_cycleniter() {
5230 : cycleniter_ = 0;
5231 : }
5232 0 : inline ::google::protobuf::int32 InteractiveMaskOptions::cycleniter() const {
5233 : // @@protoc_insertion_point(field_get:rpc.img.InteractiveMaskOptions.cycleniter)
5234 0 : return cycleniter_;
5235 : }
5236 0 : inline void InteractiveMaskOptions::set_cycleniter(::google::protobuf::int32 value) {
5237 :
5238 0 : cycleniter_ = value;
5239 : // @@protoc_insertion_point(field_set:rpc.img.InteractiveMaskOptions.cycleniter)
5240 0 : }
5241 :
5242 : // string threshold = 4;
5243 : inline void InteractiveMaskOptions::clear_threshold() {
5244 : threshold_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5245 : }
5246 0 : inline const ::std::string& InteractiveMaskOptions::threshold() const {
5247 : // @@protoc_insertion_point(field_get:rpc.img.InteractiveMaskOptions.threshold)
5248 0 : return threshold_.GetNoArena();
5249 : }
5250 0 : inline void InteractiveMaskOptions::set_threshold(const ::std::string& value) {
5251 :
5252 0 : threshold_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5253 : // @@protoc_insertion_point(field_set:rpc.img.InteractiveMaskOptions.threshold)
5254 0 : }
5255 : #if LANG_CXX11
5256 : inline void InteractiveMaskOptions::set_threshold(::std::string&& value) {
5257 :
5258 : threshold_.SetNoArena(
5259 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5260 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.InteractiveMaskOptions.threshold)
5261 : }
5262 : #endif
5263 : inline void InteractiveMaskOptions::set_threshold(const char* value) {
5264 : GOOGLE_DCHECK(value != NULL);
5265 :
5266 : threshold_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5267 : // @@protoc_insertion_point(field_set_char:rpc.img.InteractiveMaskOptions.threshold)
5268 : }
5269 : inline void InteractiveMaskOptions::set_threshold(const char* value, size_t size) {
5270 :
5271 : threshold_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5272 : ::std::string(reinterpret_cast<const char*>(value), size));
5273 : // @@protoc_insertion_point(field_set_pointer:rpc.img.InteractiveMaskOptions.threshold)
5274 : }
5275 0 : inline ::std::string* InteractiveMaskOptions::mutable_threshold() {
5276 :
5277 : // @@protoc_insertion_point(field_mutable:rpc.img.InteractiveMaskOptions.threshold)
5278 0 : return threshold_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5279 : }
5280 : inline ::std::string* InteractiveMaskOptions::release_threshold() {
5281 : // @@protoc_insertion_point(field_release:rpc.img.InteractiveMaskOptions.threshold)
5282 :
5283 : return threshold_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5284 : }
5285 : inline void InteractiveMaskOptions::set_allocated_threshold(::std::string* threshold) {
5286 : if (threshold != NULL) {
5287 :
5288 : } else {
5289 :
5290 : }
5291 : threshold_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), threshold);
5292 : // @@protoc_insertion_point(field_set_allocated:rpc.img.InteractiveMaskOptions.threshold)
5293 : }
5294 :
5295 : // string cyclethreshold = 5;
5296 : inline void InteractiveMaskOptions::clear_cyclethreshold() {
5297 : cyclethreshold_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5298 : }
5299 0 : inline const ::std::string& InteractiveMaskOptions::cyclethreshold() const {
5300 : // @@protoc_insertion_point(field_get:rpc.img.InteractiveMaskOptions.cyclethreshold)
5301 0 : return cyclethreshold_.GetNoArena();
5302 : }
5303 0 : inline void InteractiveMaskOptions::set_cyclethreshold(const ::std::string& value) {
5304 :
5305 0 : cyclethreshold_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5306 : // @@protoc_insertion_point(field_set:rpc.img.InteractiveMaskOptions.cyclethreshold)
5307 0 : }
5308 : #if LANG_CXX11
5309 : inline void InteractiveMaskOptions::set_cyclethreshold(::std::string&& value) {
5310 :
5311 : cyclethreshold_.SetNoArena(
5312 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5313 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.InteractiveMaskOptions.cyclethreshold)
5314 : }
5315 : #endif
5316 : inline void InteractiveMaskOptions::set_cyclethreshold(const char* value) {
5317 : GOOGLE_DCHECK(value != NULL);
5318 :
5319 : cyclethreshold_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5320 : // @@protoc_insertion_point(field_set_char:rpc.img.InteractiveMaskOptions.cyclethreshold)
5321 : }
5322 : inline void InteractiveMaskOptions::set_cyclethreshold(const char* value, size_t size) {
5323 :
5324 : cyclethreshold_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5325 : ::std::string(reinterpret_cast<const char*>(value), size));
5326 : // @@protoc_insertion_point(field_set_pointer:rpc.img.InteractiveMaskOptions.cyclethreshold)
5327 : }
5328 0 : inline ::std::string* InteractiveMaskOptions::mutable_cyclethreshold() {
5329 :
5330 : // @@protoc_insertion_point(field_mutable:rpc.img.InteractiveMaskOptions.cyclethreshold)
5331 0 : return cyclethreshold_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5332 : }
5333 : inline ::std::string* InteractiveMaskOptions::release_cyclethreshold() {
5334 : // @@protoc_insertion_point(field_release:rpc.img.InteractiveMaskOptions.cyclethreshold)
5335 :
5336 : return cyclethreshold_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5337 : }
5338 : inline void InteractiveMaskOptions::set_allocated_cyclethreshold(::std::string* cyclethreshold) {
5339 : if (cyclethreshold != NULL) {
5340 :
5341 : } else {
5342 :
5343 : }
5344 : cyclethreshold_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cyclethreshold);
5345 : // @@protoc_insertion_point(field_set_allocated:rpc.img.InteractiveMaskOptions.cyclethreshold)
5346 : }
5347 :
5348 : // -------------------------------------------------------------------
5349 :
5350 : // InteractiveMaskResult
5351 :
5352 : // string action = 1;
5353 : inline void InteractiveMaskResult::clear_action() {
5354 : action_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5355 : }
5356 0 : inline const ::std::string& InteractiveMaskResult::action() const {
5357 : // @@protoc_insertion_point(field_get:rpc.img.InteractiveMaskResult.action)
5358 0 : return action_.GetNoArena();
5359 : }
5360 : inline void InteractiveMaskResult::set_action(const ::std::string& value) {
5361 :
5362 : action_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5363 : // @@protoc_insertion_point(field_set:rpc.img.InteractiveMaskResult.action)
5364 : }
5365 : #if LANG_CXX11
5366 : inline void InteractiveMaskResult::set_action(::std::string&& value) {
5367 :
5368 : action_.SetNoArena(
5369 : &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5370 : // @@protoc_insertion_point(field_set_rvalue:rpc.img.InteractiveMaskResult.action)
5371 : }
5372 : #endif
5373 : inline void InteractiveMaskResult::set_action(const char* value) {
5374 : GOOGLE_DCHECK(value != NULL);
5375 :
5376 : action_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5377 : // @@protoc_insertion_point(field_set_char:rpc.img.InteractiveMaskResult.action)
5378 : }
5379 : inline void InteractiveMaskResult::set_action(const char* value, size_t size) {
5380 :
5381 : action_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5382 : ::std::string(reinterpret_cast<const char*>(value), size));
5383 : // @@protoc_insertion_point(field_set_pointer:rpc.img.InteractiveMaskResult.action)
5384 : }
5385 0 : inline ::std::string* InteractiveMaskResult::mutable_action() {
5386 :
5387 : // @@protoc_insertion_point(field_mutable:rpc.img.InteractiveMaskResult.action)
5388 0 : return action_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5389 : }
5390 : inline ::std::string* InteractiveMaskResult::release_action() {
5391 : // @@protoc_insertion_point(field_release:rpc.img.InteractiveMaskResult.action)
5392 :
5393 : return action_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5394 : }
5395 : inline void InteractiveMaskResult::set_allocated_action(::std::string* action) {
5396 : if (action != NULL) {
5397 :
5398 : } else {
5399 :
5400 : }
5401 : action_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), action);
5402 : // @@protoc_insertion_point(field_set_allocated:rpc.img.InteractiveMaskResult.action)
5403 : }
5404 :
5405 : // .rpc.img.InteractiveMaskOptions state = 2;
5406 0 : inline bool InteractiveMaskResult::has_state() const {
5407 0 : return this != internal_default_instance() && state_ != NULL;
5408 : }
5409 : inline void InteractiveMaskResult::clear_state() {
5410 : if (GetArenaNoVirtual() == NULL && state_ != NULL) {
5411 : delete state_;
5412 : }
5413 : state_ = NULL;
5414 : }
5415 0 : inline const ::rpc::img::InteractiveMaskOptions& InteractiveMaskResult::_internal_state() const {
5416 0 : return *state_;
5417 : }
5418 0 : inline const ::rpc::img::InteractiveMaskOptions& InteractiveMaskResult::state() const {
5419 0 : const ::rpc::img::InteractiveMaskOptions* p = state_;
5420 : // @@protoc_insertion_point(field_get:rpc.img.InteractiveMaskResult.state)
5421 0 : return p != NULL ? *p : *reinterpret_cast<const ::rpc::img::InteractiveMaskOptions*>(
5422 0 : &::rpc::img::_InteractiveMaskOptions_default_instance_);
5423 : }
5424 : inline ::rpc::img::InteractiveMaskOptions* InteractiveMaskResult::release_state() {
5425 : // @@protoc_insertion_point(field_release:rpc.img.InteractiveMaskResult.state)
5426 :
5427 : ::rpc::img::InteractiveMaskOptions* temp = state_;
5428 : state_ = NULL;
5429 : return temp;
5430 : }
5431 0 : inline ::rpc::img::InteractiveMaskOptions* InteractiveMaskResult::mutable_state() {
5432 :
5433 0 : if (state_ == NULL) {
5434 0 : auto* p = CreateMaybeMessage<::rpc::img::InteractiveMaskOptions>(GetArenaNoVirtual());
5435 0 : state_ = p;
5436 : }
5437 : // @@protoc_insertion_point(field_mutable:rpc.img.InteractiveMaskResult.state)
5438 0 : return state_;
5439 : }
5440 : inline void InteractiveMaskResult::set_allocated_state(::rpc::img::InteractiveMaskOptions* state) {
5441 : ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5442 : if (message_arena == NULL) {
5443 : delete state_;
5444 : }
5445 : if (state) {
5446 : ::google::protobuf::Arena* submessage_arena = NULL;
5447 : if (message_arena != submessage_arena) {
5448 : state = ::google::protobuf::internal::GetOwnedMessage(
5449 : message_arena, state, submessage_arena);
5450 : }
5451 :
5452 : } else {
5453 :
5454 : }
5455 : state_ = state;
5456 : // @@protoc_insertion_point(field_set_allocated:rpc.img.InteractiveMaskResult.state)
5457 : }
5458 :
5459 : #ifdef __GNUC__
5460 : #pragma GCC diagnostic pop
5461 : #endif // __GNUC__
5462 : // -------------------------------------------------------------------
5463 :
5464 : // -------------------------------------------------------------------
5465 :
5466 : // -------------------------------------------------------------------
5467 :
5468 : // -------------------------------------------------------------------
5469 :
5470 : // -------------------------------------------------------------------
5471 :
5472 : // -------------------------------------------------------------------
5473 :
5474 : // -------------------------------------------------------------------
5475 :
5476 : // -------------------------------------------------------------------
5477 :
5478 : // -------------------------------------------------------------------
5479 :
5480 : // -------------------------------------------------------------------
5481 :
5482 : // -------------------------------------------------------------------
5483 :
5484 : // -------------------------------------------------------------------
5485 :
5486 : // -------------------------------------------------------------------
5487 :
5488 : // -------------------------------------------------------------------
5489 :
5490 : // -------------------------------------------------------------------
5491 :
5492 : // -------------------------------------------------------------------
5493 :
5494 : // -------------------------------------------------------------------
5495 :
5496 : // -------------------------------------------------------------------
5497 :
5498 : // -------------------------------------------------------------------
5499 :
5500 : // -------------------------------------------------------------------
5501 :
5502 : // -------------------------------------------------------------------
5503 :
5504 :
5505 : // @@protoc_insertion_point(namespace_scope)
5506 :
5507 : } // namespace img
5508 : } // namespace rpc
5509 :
5510 : // @@protoc_insertion_point(global_scope)
5511 :
5512 : #endif // PROTOBUF_INCLUDED_img_2eproto
|
