requests.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: requests.proto
 
#ifndef PROTOBUF_INCLUDED_requests_2eproto
#define PROTOBUF_INCLUDED_requests_2eproto
 
#include <string>
 
#include <google/protobuf/stubs/common.h>
 
#if GOOGLE_PROTOBUF_VERSION < 3006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_requests_2eproto 
 
namespace protobuf_requests_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[24];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_requests_2eproto
namespace exif {
class RepConfig;
class RepConfigDefaultTypeInternal;
extern RepConfigDefaultTypeInternal _RepConfig_default_instance_;
class RepDisable;
class RepDisableDefaultTypeInternal;
extern RepDisableDefaultTypeInternal _RepDisable_default_instance_;
class RepEnable;
class RepEnableDefaultTypeInternal;
extern RepEnableDefaultTypeInternal _RepEnable_default_instance_;
class RepExit;
class RepExitDefaultTypeInternal;
extern RepExitDefaultTypeInternal _RepExit_default_instance_;
class RepInit;
class RepInitDefaultTypeInternal;
extern RepInitDefaultTypeInternal _RepInit_default_instance_;
class RepMove;
class RepMoveDefaultTypeInternal;
extern RepMoveDefaultTypeInternal _RepMove_default_instance_;
class RepPreset;
class RepPresetDefaultTypeInternal;
extern RepPresetDefaultTypeInternal _RepPreset_default_instance_;
class RepReset;
class RepResetDefaultTypeInternal;
extern RepResetDefaultTypeInternal _RepReset_default_instance_;
class RepSetLogLevel;
class RepSetLogLevelDefaultTypeInternal;
extern RepSetLogLevelDefaultTypeInternal _RepSetLogLevel_default_instance_;
class RepStatus;
class RepStatusDefaultTypeInternal;
extern RepStatusDefaultTypeInternal _RepStatus_default_instance_;
class RepStatus2;
class RepStatus2DefaultTypeInternal;
extern RepStatus2DefaultTypeInternal _RepStatus2_default_instance_;
class RepStop;
class RepStopDefaultTypeInternal;
extern RepStopDefaultTypeInternal _RepStop_default_instance_;
class ReqConfig;
class ReqConfigDefaultTypeInternal;
extern ReqConfigDefaultTypeInternal _ReqConfig_default_instance_;
class ReqDisable;
class ReqDisableDefaultTypeInternal;
extern ReqDisableDefaultTypeInternal _ReqDisable_default_instance_;
class ReqEnable;
class ReqEnableDefaultTypeInternal;
extern ReqEnableDefaultTypeInternal _ReqEnable_default_instance_;
class ReqExit;
class ReqExitDefaultTypeInternal;
extern ReqExitDefaultTypeInternal _ReqExit_default_instance_;
class ReqInit;
class ReqInitDefaultTypeInternal;
extern ReqInitDefaultTypeInternal _ReqInit_default_instance_;
class ReqMove;
class ReqMoveDefaultTypeInternal;
extern ReqMoveDefaultTypeInternal _ReqMove_default_instance_;
class ReqPreset;
class ReqPresetDefaultTypeInternal;
extern ReqPresetDefaultTypeInternal _ReqPreset_default_instance_;
class ReqReset;
class ReqResetDefaultTypeInternal;
extern ReqResetDefaultTypeInternal _ReqReset_default_instance_;
class ReqSetLogLevel;
class ReqSetLogLevelDefaultTypeInternal;
extern ReqSetLogLevelDefaultTypeInternal _ReqSetLogLevel_default_instance_;
class ReqStatus;
class ReqStatusDefaultTypeInternal;
extern ReqStatusDefaultTypeInternal _ReqStatus_default_instance_;
class ReqStatus2;
class ReqStatus2DefaultTypeInternal;
extern ReqStatus2DefaultTypeInternal _ReqStatus2_default_instance_;
class ReqStop;
class ReqStopDefaultTypeInternal;
extern ReqStopDefaultTypeInternal _ReqStop_default_instance_;
}  // namespace exif
namespace google {
namespace protobuf {
template<> ::exif::RepConfig* Arena::CreateMaybeMessage<::exif::RepConfig>(Arena*);
template<> ::exif::RepDisable* Arena::CreateMaybeMessage<::exif::RepDisable>(Arena*);
template<> ::exif::RepEnable* Arena::CreateMaybeMessage<::exif::RepEnable>(Arena*);
template<> ::exif::RepExit* Arena::CreateMaybeMessage<::exif::RepExit>(Arena*);
template<> ::exif::RepInit* Arena::CreateMaybeMessage<::exif::RepInit>(Arena*);
template<> ::exif::RepMove* Arena::CreateMaybeMessage<::exif::RepMove>(Arena*);
template<> ::exif::RepPreset* Arena::CreateMaybeMessage<::exif::RepPreset>(Arena*);
template<> ::exif::RepReset* Arena::CreateMaybeMessage<::exif::RepReset>(Arena*);
template<> ::exif::RepSetLogLevel* Arena::CreateMaybeMessage<::exif::RepSetLogLevel>(Arena*);
template<> ::exif::RepStatus* Arena::CreateMaybeMessage<::exif::RepStatus>(Arena*);
template<> ::exif::RepStatus2* Arena::CreateMaybeMessage<::exif::RepStatus2>(Arena*);
template<> ::exif::RepStop* Arena::CreateMaybeMessage<::exif::RepStop>(Arena*);
template<> ::exif::ReqConfig* Arena::CreateMaybeMessage<::exif::ReqConfig>(Arena*);
template<> ::exif::ReqDisable* Arena::CreateMaybeMessage<::exif::ReqDisable>(Arena*);
template<> ::exif::ReqEnable* Arena::CreateMaybeMessage<::exif::ReqEnable>(Arena*);
template<> ::exif::ReqExit* Arena::CreateMaybeMessage<::exif::ReqExit>(Arena*);
template<> ::exif::ReqInit* Arena::CreateMaybeMessage<::exif::ReqInit>(Arena*);
template<> ::exif::ReqMove* Arena::CreateMaybeMessage<::exif::ReqMove>(Arena*);
template<> ::exif::ReqPreset* Arena::CreateMaybeMessage<::exif::ReqPreset>(Arena*);
template<> ::exif::ReqReset* Arena::CreateMaybeMessage<::exif::ReqReset>(Arena*);
template<> ::exif::ReqSetLogLevel* Arena::CreateMaybeMessage<::exif::ReqSetLogLevel>(Arena*);
template<> ::exif::ReqStatus* Arena::CreateMaybeMessage<::exif::ReqStatus>(Arena*);
template<> ::exif::ReqStatus2* Arena::CreateMaybeMessage<::exif::ReqStatus2>(Arena*);
template<> ::exif::ReqStop* Arena::CreateMaybeMessage<::exif::ReqStop>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace exif {
 
// ===================================================================
 
class ReqInit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqInit) */ {
 public:
  ReqInit();
  virtual ~ReqInit();
 
  ReqInit(const ReqInit& from);
 
  inline ReqInit& operator=(const ReqInit& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqInit(ReqInit&& from) noexcept
    : ReqInit() {
    *this = ::std::move(from);
  }
 
  inline ReqInit& operator=(ReqInit&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqInit& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqInit* internal_default_instance() {
    return reinterpret_cast<const ReqInit*>(
               &_ReqInit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  void Swap(ReqInit* other);
  friend void swap(ReqInit& a, ReqInit& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqInit* New() const final {
    return CreateMaybeMessage<ReqInit>(NULL);
  }
 
  ReqInit* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqInit>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqInit& from);
  void MergeFrom(const ReqInit& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqInit* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqInit)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepInit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepInit) */ {
 public:
  RepInit();
  virtual ~RepInit();
 
  RepInit(const RepInit& from);
 
  inline RepInit& operator=(const RepInit& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepInit(RepInit&& from) noexcept
    : RepInit() {
    *this = ::std::move(from);
  }
 
  inline RepInit& operator=(RepInit&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepInit& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepInit* internal_default_instance() {
    return reinterpret_cast<const RepInit*>(
               &_RepInit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  void Swap(RepInit* other);
  friend void swap(RepInit& a, RepInit& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepInit* New() const final {
    return CreateMaybeMessage<RepInit>(NULL);
  }
 
  RepInit* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepInit>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepInit& from);
  void MergeFrom(const RepInit& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepInit* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepInit)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqExit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqExit) */ {
 public:
  ReqExit();
  virtual ~ReqExit();
 
  ReqExit(const ReqExit& from);
 
  inline ReqExit& operator=(const ReqExit& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqExit(ReqExit&& from) noexcept
    : ReqExit() {
    *this = ::std::move(from);
  }
 
  inline ReqExit& operator=(ReqExit&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqExit& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqExit* internal_default_instance() {
    return reinterpret_cast<const ReqExit*>(
               &_ReqExit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  void Swap(ReqExit* other);
  friend void swap(ReqExit& a, ReqExit& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqExit* New() const final {
    return CreateMaybeMessage<ReqExit>(NULL);
  }
 
  ReqExit* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqExit>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqExit& from);
  void MergeFrom(const ReqExit& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqExit* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqExit)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepExit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepExit) */ {
 public:
  RepExit();
  virtual ~RepExit();
 
  RepExit(const RepExit& from);
 
  inline RepExit& operator=(const RepExit& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepExit(RepExit&& from) noexcept
    : RepExit() {
    *this = ::std::move(from);
  }
 
  inline RepExit& operator=(RepExit&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepExit& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepExit* internal_default_instance() {
    return reinterpret_cast<const RepExit*>(
               &_RepExit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  void Swap(RepExit* other);
  friend void swap(RepExit& a, RepExit& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepExit* New() const final {
    return CreateMaybeMessage<RepExit>(NULL);
  }
 
  RepExit* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepExit>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepExit& from);
  void MergeFrom(const RepExit& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepExit* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepExit)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqStatus) */ {
 public:
  ReqStatus();
  virtual ~ReqStatus();
 
  ReqStatus(const ReqStatus& from);
 
  inline ReqStatus& operator=(const ReqStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqStatus(ReqStatus&& from) noexcept
    : ReqStatus() {
    *this = ::std::move(from);
  }
 
  inline ReqStatus& operator=(ReqStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqStatus& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqStatus* internal_default_instance() {
    return reinterpret_cast<const ReqStatus*>(
               &_ReqStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  void Swap(ReqStatus* other);
  friend void swap(ReqStatus& a, ReqStatus& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqStatus* New() const final {
    return CreateMaybeMessage<ReqStatus>(NULL);
  }
 
  ReqStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqStatus& from);
  void MergeFrom(const ReqStatus& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqStatus)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepStatus) */ {
 public:
  RepStatus();
  virtual ~RepStatus();
 
  RepStatus(const RepStatus& from);
 
  inline RepStatus& operator=(const RepStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepStatus(RepStatus&& from) noexcept
    : RepStatus() {
    *this = ::std::move(from);
  }
 
  inline RepStatus& operator=(RepStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepStatus& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepStatus* internal_default_instance() {
    return reinterpret_cast<const RepStatus*>(
               &_RepStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  void Swap(RepStatus* other);
  friend void swap(RepStatus& a, RepStatus& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepStatus* New() const final {
    return CreateMaybeMessage<RepStatus>(NULL);
  }
 
  RepStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepStatus& from);
  void MergeFrom(const RepStatus& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepStatus)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqStatus2 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqStatus2) */ {
 public:
  ReqStatus2();
  virtual ~ReqStatus2();
 
  ReqStatus2(const ReqStatus2& from);
 
  inline ReqStatus2& operator=(const ReqStatus2& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqStatus2(ReqStatus2&& from) noexcept
    : ReqStatus2() {
    *this = ::std::move(from);
  }
 
  inline ReqStatus2& operator=(ReqStatus2&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqStatus2& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqStatus2* internal_default_instance() {
    return reinterpret_cast<const ReqStatus2*>(
               &_ReqStatus2_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  void Swap(ReqStatus2* other);
  friend void swap(ReqStatus2& a, ReqStatus2& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqStatus2* New() const final {
    return CreateMaybeMessage<ReqStatus2>(NULL);
  }
 
  ReqStatus2* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqStatus2>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqStatus2& from);
  void MergeFrom(const ReqStatus2& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqStatus2* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqStatus2)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepStatus2 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepStatus2) */ {
 public:
  RepStatus2();
  virtual ~RepStatus2();
 
  RepStatus2(const RepStatus2& from);
 
  inline RepStatus2& operator=(const RepStatus2& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepStatus2(RepStatus2&& from) noexcept
    : RepStatus2() {
    *this = ::std::move(from);
  }
 
  inline RepStatus2& operator=(RepStatus2&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepStatus2& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepStatus2* internal_default_instance() {
    return reinterpret_cast<const RepStatus2*>(
               &_RepStatus2_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  void Swap(RepStatus2* other);
  friend void swap(RepStatus2& a, RepStatus2& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepStatus2* New() const final {
    return CreateMaybeMessage<RepStatus2>(NULL);
  }
 
  RepStatus2* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepStatus2>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepStatus2& from);
  void MergeFrom(const RepStatus2& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepStatus2* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepStatus2)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqEnable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqEnable) */ {
 public:
  ReqEnable();
  virtual ~ReqEnable();
 
  ReqEnable(const ReqEnable& from);
 
  inline ReqEnable& operator=(const ReqEnable& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqEnable(ReqEnable&& from) noexcept
    : ReqEnable() {
    *this = ::std::move(from);
  }
 
  inline ReqEnable& operator=(ReqEnable&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqEnable& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqEnable* internal_default_instance() {
    return reinterpret_cast<const ReqEnable*>(
               &_ReqEnable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  void Swap(ReqEnable* other);
  friend void swap(ReqEnable& a, ReqEnable& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqEnable* New() const final {
    return CreateMaybeMessage<ReqEnable>(NULL);
  }
 
  ReqEnable* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqEnable>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqEnable& from);
  void MergeFrom(const ReqEnable& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqEnable* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqEnable)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepEnable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepEnable) */ {
 public:
  RepEnable();
  virtual ~RepEnable();
 
  RepEnable(const RepEnable& from);
 
  inline RepEnable& operator=(const RepEnable& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepEnable(RepEnable&& from) noexcept
    : RepEnable() {
    *this = ::std::move(from);
  }
 
  inline RepEnable& operator=(RepEnable&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepEnable& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepEnable* internal_default_instance() {
    return reinterpret_cast<const RepEnable*>(
               &_RepEnable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  void Swap(RepEnable* other);
  friend void swap(RepEnable& a, RepEnable& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepEnable* New() const final {
    return CreateMaybeMessage<RepEnable>(NULL);
  }
 
  RepEnable* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepEnable>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepEnable& from);
  void MergeFrom(const RepEnable& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepEnable* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepEnable)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqDisable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqDisable) */ {
 public:
  ReqDisable();
  virtual ~ReqDisable();
 
  ReqDisable(const ReqDisable& from);
 
  inline ReqDisable& operator=(const ReqDisable& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqDisable(ReqDisable&& from) noexcept
    : ReqDisable() {
    *this = ::std::move(from);
  }
 
  inline ReqDisable& operator=(ReqDisable&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqDisable& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqDisable* internal_default_instance() {
    return reinterpret_cast<const ReqDisable*>(
               &_ReqDisable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  void Swap(ReqDisable* other);
  friend void swap(ReqDisable& a, ReqDisable& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqDisable* New() const final {
    return CreateMaybeMessage<ReqDisable>(NULL);
  }
 
  ReqDisable* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqDisable>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqDisable& from);
  void MergeFrom(const ReqDisable& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqDisable* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqDisable)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepDisable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepDisable) */ {
 public:
  RepDisable();
  virtual ~RepDisable();
 
  RepDisable(const RepDisable& from);
 
  inline RepDisable& operator=(const RepDisable& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepDisable(RepDisable&& from) noexcept
    : RepDisable() {
    *this = ::std::move(from);
  }
 
  inline RepDisable& operator=(RepDisable&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepDisable& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepDisable* internal_default_instance() {
    return reinterpret_cast<const RepDisable*>(
               &_RepDisable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;
 
  void Swap(RepDisable* other);
  friend void swap(RepDisable& a, RepDisable& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepDisable* New() const final {
    return CreateMaybeMessage<RepDisable>(NULL);
  }
 
  RepDisable* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepDisable>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepDisable& from);
  void MergeFrom(const RepDisable& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepDisable* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepDisable)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqReset : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqReset) */ {
 public:
  ReqReset();
  virtual ~ReqReset();
 
  ReqReset(const ReqReset& from);
 
  inline ReqReset& operator=(const ReqReset& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqReset(ReqReset&& from) noexcept
    : ReqReset() {
    *this = ::std::move(from);
  }
 
  inline ReqReset& operator=(ReqReset&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqReset& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqReset* internal_default_instance() {
    return reinterpret_cast<const ReqReset*>(
               &_ReqReset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;
 
  void Swap(ReqReset* other);
  friend void swap(ReqReset& a, ReqReset& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqReset* New() const final {
    return CreateMaybeMessage<ReqReset>(NULL);
  }
 
  ReqReset* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqReset>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqReset& from);
  void MergeFrom(const ReqReset& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqReset* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqReset)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepReset : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepReset) */ {
 public:
  RepReset();
  virtual ~RepReset();
 
  RepReset(const RepReset& from);
 
  inline RepReset& operator=(const RepReset& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepReset(RepReset&& from) noexcept
    : RepReset() {
    *this = ::std::move(from);
  }
 
  inline RepReset& operator=(RepReset&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepReset& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepReset* internal_default_instance() {
    return reinterpret_cast<const RepReset*>(
               &_RepReset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;
 
  void Swap(RepReset* other);
  friend void swap(RepReset& a, RepReset& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepReset* New() const final {
    return CreateMaybeMessage<RepReset>(NULL);
  }
 
  RepReset* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepReset>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepReset& from);
  void MergeFrom(const RepReset& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepReset* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepReset)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqStop : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqStop) */ {
 public:
  ReqStop();
  virtual ~ReqStop();
 
  ReqStop(const ReqStop& from);
 
  inline ReqStop& operator=(const ReqStop& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqStop(ReqStop&& from) noexcept
    : ReqStop() {
    *this = ::std::move(from);
  }
 
  inline ReqStop& operator=(ReqStop&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqStop& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqStop* internal_default_instance() {
    return reinterpret_cast<const ReqStop*>(
               &_ReqStop_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;
 
  void Swap(ReqStop* other);
  friend void swap(ReqStop& a, ReqStop& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqStop* New() const final {
    return CreateMaybeMessage<ReqStop>(NULL);
  }
 
  ReqStop* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqStop>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqStop& from);
  void MergeFrom(const ReqStop& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqStop* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqStop)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepStop : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepStop) */ {
 public:
  RepStop();
  virtual ~RepStop();
 
  RepStop(const RepStop& from);
 
  inline RepStop& operator=(const RepStop& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepStop(RepStop&& from) noexcept
    : RepStop() {
    *this = ::std::move(from);
  }
 
  inline RepStop& operator=(RepStop&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepStop& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepStop* internal_default_instance() {
    return reinterpret_cast<const RepStop*>(
               &_RepStop_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;
 
  void Swap(RepStop* other);
  friend void swap(RepStop& a, RepStop& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepStop* New() const final {
    return CreateMaybeMessage<RepStop>(NULL);
  }
 
  RepStop* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepStop>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepStop& from);
  void MergeFrom(const RepStop& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepStop* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepStop)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqConfig) */ {
 public:
  ReqConfig();
  virtual ~ReqConfig();
 
  ReqConfig(const ReqConfig& from);
 
  inline ReqConfig& operator=(const ReqConfig& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqConfig(ReqConfig&& from) noexcept
    : ReqConfig() {
    *this = ::std::move(from);
  }
 
  inline ReqConfig& operator=(ReqConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqConfig& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqConfig* internal_default_instance() {
    return reinterpret_cast<const ReqConfig*>(
               &_ReqConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;
 
  void Swap(ReqConfig* other);
  friend void swap(ReqConfig& a, ReqConfig& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqConfig* New() const final {
    return CreateMaybeMessage<ReqConfig>(NULL);
  }
 
  ReqConfig* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqConfig>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqConfig& from);
  void MergeFrom(const ReqConfig& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqConfig* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:exif.ReqConfig)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepConfig) */ {
 public:
  RepConfig();
  virtual ~RepConfig();
 
  RepConfig(const RepConfig& from);
 
  inline RepConfig& operator=(const RepConfig& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepConfig(RepConfig&& from) noexcept
    : RepConfig() {
    *this = ::std::move(from);
  }
 
  inline RepConfig& operator=(RepConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepConfig& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepConfig* internal_default_instance() {
    return reinterpret_cast<const RepConfig*>(
               &_RepConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;
 
  void Swap(RepConfig* other);
  friend void swap(RepConfig& a, RepConfig& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepConfig* New() const final {
    return CreateMaybeMessage<RepConfig>(NULL);
  }
 
  RepConfig* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepConfig>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepConfig& from);
  void MergeFrom(const RepConfig& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepConfig* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepConfig)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqSetLogLevel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqSetLogLevel) */ {
 public:
  ReqSetLogLevel();
  virtual ~ReqSetLogLevel();
 
  ReqSetLogLevel(const ReqSetLogLevel& from);
 
  inline ReqSetLogLevel& operator=(const ReqSetLogLevel& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqSetLogLevel(ReqSetLogLevel&& from) noexcept
    : ReqSetLogLevel() {
    *this = ::std::move(from);
  }
 
  inline ReqSetLogLevel& operator=(ReqSetLogLevel&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqSetLogLevel& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqSetLogLevel* internal_default_instance() {
    return reinterpret_cast<const ReqSetLogLevel*>(
               &_ReqSetLogLevel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;
 
  void Swap(ReqSetLogLevel* other);
  friend void swap(ReqSetLogLevel& a, ReqSetLogLevel& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqSetLogLevel* New() const final {
    return CreateMaybeMessage<ReqSetLogLevel>(NULL);
  }
 
  ReqSetLogLevel* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqSetLogLevel>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqSetLogLevel& from);
  void MergeFrom(const ReqSetLogLevel& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqSetLogLevel* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string loglevel = 1;
  void clear_loglevel();
  static const int kLoglevelFieldNumber = 1;
  const ::std::string& loglevel() const;
  void set_loglevel(const ::std::string& value);
  #if LANG_CXX11
  void set_loglevel(::std::string&& value);
  #endif
  void set_loglevel(const char* value);
  void set_loglevel(const char* value, size_t size);
  ::std::string* mutable_loglevel();
  ::std::string* release_loglevel();
  void set_allocated_loglevel(::std::string* loglevel);
 
  // string loggername = 2;
  void clear_loggername();
  static const int kLoggernameFieldNumber = 2;
  const ::std::string& loggername() const;
  void set_loggername(const ::std::string& value);
  #if LANG_CXX11
  void set_loggername(::std::string&& value);
  #endif
  void set_loggername(const char* value);
  void set_loggername(const char* value, size_t size);
  ::std::string* mutable_loggername();
  ::std::string* release_loggername();
  void set_allocated_loggername(::std::string* loggername);
 
  // @@protoc_insertion_point(class_scope:exif.ReqSetLogLevel)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr loglevel_;
  ::google::protobuf::internal::ArenaStringPtr loggername_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepSetLogLevel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepSetLogLevel) */ {
 public:
  RepSetLogLevel();
  virtual ~RepSetLogLevel();
 
  RepSetLogLevel(const RepSetLogLevel& from);
 
  inline RepSetLogLevel& operator=(const RepSetLogLevel& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepSetLogLevel(RepSetLogLevel&& from) noexcept
    : RepSetLogLevel() {
    *this = ::std::move(from);
  }
 
  inline RepSetLogLevel& operator=(RepSetLogLevel&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepSetLogLevel& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepSetLogLevel* internal_default_instance() {
    return reinterpret_cast<const RepSetLogLevel*>(
               &_RepSetLogLevel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;
 
  void Swap(RepSetLogLevel* other);
  friend void swap(RepSetLogLevel& a, RepSetLogLevel& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepSetLogLevel* New() const final {
    return CreateMaybeMessage<RepSetLogLevel>(NULL);
  }
 
  RepSetLogLevel* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepSetLogLevel>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepSetLogLevel& from);
  void MergeFrom(const RepSetLogLevel& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepSetLogLevel* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepSetLogLevel)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqPreset : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqPreset) */ {
 public:
  ReqPreset();
  virtual ~ReqPreset();
 
  ReqPreset(const ReqPreset& from);
 
  inline ReqPreset& operator=(const ReqPreset& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqPreset(ReqPreset&& from) noexcept
    : ReqPreset() {
    *this = ::std::move(from);
  }
 
  inline ReqPreset& operator=(ReqPreset&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqPreset& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqPreset* internal_default_instance() {
    return reinterpret_cast<const ReqPreset*>(
               &_ReqPreset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;
 
  void Swap(ReqPreset* other);
  friend void swap(ReqPreset& a, ReqPreset& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqPreset* New() const final {
    return CreateMaybeMessage<ReqPreset>(NULL);
  }
 
  ReqPreset* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqPreset>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqPreset& from);
  void MergeFrom(const ReqPreset& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqPreset* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // double ra = 1;
  void clear_ra();
  static const int kRaFieldNumber = 1;
  double ra() const;
  void set_ra(double value);
 
  // double dec = 2;
  void clear_dec();
  static const int kDecFieldNumber = 2;
  double dec() const;
  void set_dec(double value);
 
  // @@protoc_insertion_point(class_scope:exif.ReqPreset)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  double ra_;
  double dec_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepPreset : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepPreset) */ {
 public:
  RepPreset();
  virtual ~RepPreset();
 
  RepPreset(const RepPreset& from);
 
  inline RepPreset& operator=(const RepPreset& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepPreset(RepPreset&& from) noexcept
    : RepPreset() {
    *this = ::std::move(from);
  }
 
  inline RepPreset& operator=(RepPreset&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepPreset& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepPreset* internal_default_instance() {
    return reinterpret_cast<const RepPreset*>(
               &_RepPreset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;
 
  void Swap(RepPreset* other);
  friend void swap(RepPreset& a, RepPreset& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepPreset* New() const final {
    return CreateMaybeMessage<RepPreset>(NULL);
  }
 
  RepPreset* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepPreset>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepPreset& from);
  void MergeFrom(const RepPreset& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepPreset* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepPreset)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ReqMove : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.ReqMove) */ {
 public:
  ReqMove();
  virtual ~ReqMove();
 
  ReqMove(const ReqMove& from);
 
  inline ReqMove& operator=(const ReqMove& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReqMove(ReqMove&& from) noexcept
    : ReqMove() {
    *this = ::std::move(from);
  }
 
  inline ReqMove& operator=(ReqMove&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReqMove& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReqMove* internal_default_instance() {
    return reinterpret_cast<const ReqMove*>(
               &_ReqMove_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;
 
  void Swap(ReqMove* other);
  friend void swap(ReqMove& a, ReqMove& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ReqMove* New() const final {
    return CreateMaybeMessage<ReqMove>(NULL);
  }
 
  ReqMove* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReqMove>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReqMove& from);
  void MergeFrom(const ReqMove& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqMove* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // double x = 1;
  void clear_x();
  static const int kXFieldNumber = 1;
  double x() const;
  void set_x(double value);
 
  // double y = 2;
  void clear_y();
  static const int kYFieldNumber = 2;
  double y() const;
  void set_y(double value);
 
  // @@protoc_insertion_point(class_scope:exif.ReqMove)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  double x_;
  double y_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class RepMove : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exif.RepMove) */ {
 public:
  RepMove();
  virtual ~RepMove();
 
  RepMove(const RepMove& from);
 
  inline RepMove& operator=(const RepMove& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepMove(RepMove&& from) noexcept
    : RepMove() {
    *this = ::std::move(from);
  }
 
  inline RepMove& operator=(RepMove&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepMove& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepMove* internal_default_instance() {
    return reinterpret_cast<const RepMove*>(
               &_RepMove_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;
 
  void Swap(RepMove* other);
  friend void swap(RepMove& a, RepMove& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline RepMove* New() const final {
    return CreateMaybeMessage<RepMove>(NULL);
  }
 
  RepMove* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepMove>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepMove& from);
  void MergeFrom(const RepMove& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepMove* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // string reply = 1;
  void clear_reply();
  static const int kReplyFieldNumber = 1;
  const ::std::string& reply() const;
  void set_reply(const ::std::string& value);
  #if LANG_CXX11
  void set_reply(::std::string&& value);
  #endif
  void set_reply(const char* value);
  void set_reply(const char* value, size_t size);
  ::std::string* mutable_reply();
  ::std::string* release_reply();
  void set_allocated_reply(::std::string* reply);
 
  // @@protoc_insertion_point(class_scope:exif.RepMove)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr reply_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_requests_2eproto::TableStruct;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// ReqInit
 
// -------------------------------------------------------------------
 
// RepInit
 
// string reply = 1;
inline void RepInit::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepInit::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepInit.reply)
  return reply_.GetNoArena();
}
inline void RepInit::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepInit.reply)
}
#if LANG_CXX11
inline void RepInit::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepInit.reply)
}
#endif
inline void RepInit::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepInit.reply)
}
inline void RepInit::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepInit.reply)
}
inline ::std::string* RepInit::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepInit.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepInit::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepInit.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepInit::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepInit.reply)
}
 
// -------------------------------------------------------------------
 
// ReqExit
 
// -------------------------------------------------------------------
 
// RepExit
 
// string reply = 1;
inline void RepExit::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepExit::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepExit.reply)
  return reply_.GetNoArena();
}
inline void RepExit::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepExit.reply)
}
#if LANG_CXX11
inline void RepExit::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepExit.reply)
}
#endif
inline void RepExit::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepExit.reply)
}
inline void RepExit::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepExit.reply)
}
inline ::std::string* RepExit::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepExit.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepExit::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepExit.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepExit::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepExit.reply)
}
 
// -------------------------------------------------------------------
 
// ReqStatus
 
// -------------------------------------------------------------------
 
// RepStatus
 
// string reply = 1;
inline void RepStatus::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepStatus::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepStatus.reply)
  return reply_.GetNoArena();
}
inline void RepStatus::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepStatus.reply)
}
#if LANG_CXX11
inline void RepStatus::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepStatus.reply)
}
#endif
inline void RepStatus::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepStatus.reply)
}
inline void RepStatus::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepStatus.reply)
}
inline ::std::string* RepStatus::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepStatus.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepStatus::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepStatus.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepStatus::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepStatus.reply)
}
 
// -------------------------------------------------------------------
 
// ReqStatus2
 
// -------------------------------------------------------------------
 
// RepStatus2
 
// string reply = 1;
inline void RepStatus2::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepStatus2::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepStatus2.reply)
  return reply_.GetNoArena();
}
inline void RepStatus2::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepStatus2.reply)
}
#if LANG_CXX11
inline void RepStatus2::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepStatus2.reply)
}
#endif
inline void RepStatus2::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepStatus2.reply)
}
inline void RepStatus2::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepStatus2.reply)
}
inline ::std::string* RepStatus2::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepStatus2.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepStatus2::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepStatus2.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepStatus2::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepStatus2.reply)
}
 
// -------------------------------------------------------------------
 
// ReqEnable
 
// -------------------------------------------------------------------
 
// RepEnable
 
// string reply = 1;
inline void RepEnable::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepEnable::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepEnable.reply)
  return reply_.GetNoArena();
}
inline void RepEnable::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepEnable.reply)
}
#if LANG_CXX11
inline void RepEnable::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepEnable.reply)
}
#endif
inline void RepEnable::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepEnable.reply)
}
inline void RepEnable::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepEnable.reply)
}
inline ::std::string* RepEnable::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepEnable.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepEnable::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepEnable.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepEnable::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepEnable.reply)
}
 
// -------------------------------------------------------------------
 
// ReqDisable
 
// -------------------------------------------------------------------
 
// RepDisable
 
// string reply = 1;
inline void RepDisable::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepDisable::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepDisable.reply)
  return reply_.GetNoArena();
}
inline void RepDisable::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepDisable.reply)
}
#if LANG_CXX11
inline void RepDisable::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepDisable.reply)
}
#endif
inline void RepDisable::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepDisable.reply)
}
inline void RepDisable::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepDisable.reply)
}
inline ::std::string* RepDisable::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepDisable.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepDisable::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepDisable.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepDisable::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepDisable.reply)
}
 
// -------------------------------------------------------------------
 
// ReqReset
 
// -------------------------------------------------------------------
 
// RepReset
 
// string reply = 1;
inline void RepReset::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepReset::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepReset.reply)
  return reply_.GetNoArena();
}
inline void RepReset::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepReset.reply)
}
#if LANG_CXX11
inline void RepReset::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepReset.reply)
}
#endif
inline void RepReset::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepReset.reply)
}
inline void RepReset::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepReset.reply)
}
inline ::std::string* RepReset::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepReset.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepReset::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepReset.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepReset::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepReset.reply)
}
 
// -------------------------------------------------------------------
 
// ReqStop
 
// -------------------------------------------------------------------
 
// RepStop
 
// string reply = 1;
inline void RepStop::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepStop::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepStop.reply)
  return reply_.GetNoArena();
}
inline void RepStop::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepStop.reply)
}
#if LANG_CXX11
inline void RepStop::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepStop.reply)
}
#endif
inline void RepStop::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepStop.reply)
}
inline void RepStop::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepStop.reply)
}
inline ::std::string* RepStop::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepStop.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepStop::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepStop.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepStop::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepStop.reply)
}
 
// -------------------------------------------------------------------
 
// ReqConfig
 
// -------------------------------------------------------------------
 
// RepConfig
 
// string reply = 1;
inline void RepConfig::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepConfig::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepConfig.reply)
  return reply_.GetNoArena();
}
inline void RepConfig::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepConfig.reply)
}
#if LANG_CXX11
inline void RepConfig::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepConfig.reply)
}
#endif
inline void RepConfig::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepConfig.reply)
}
inline void RepConfig::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepConfig.reply)
}
inline ::std::string* RepConfig::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepConfig.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepConfig::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepConfig.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepConfig::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepConfig.reply)
}
 
// -------------------------------------------------------------------
 
// ReqSetLogLevel
 
// string loglevel = 1;
inline void ReqSetLogLevel::clear_loglevel() {
  loglevel_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ReqSetLogLevel::loglevel() const {
  // @@protoc_insertion_point(field_get:exif.ReqSetLogLevel.loglevel)
  return loglevel_.GetNoArena();
}
inline void ReqSetLogLevel::set_loglevel(const ::std::string& value) {
  
  loglevel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.ReqSetLogLevel.loglevel)
}
#if LANG_CXX11
inline void ReqSetLogLevel::set_loglevel(::std::string&& value) {
  
  loglevel_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.ReqSetLogLevel.loglevel)
}
#endif
inline void ReqSetLogLevel::set_loglevel(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  loglevel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.ReqSetLogLevel.loglevel)
}
inline void ReqSetLogLevel::set_loglevel(const char* value, size_t size) {
  
  loglevel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.ReqSetLogLevel.loglevel)
}
inline ::std::string* ReqSetLogLevel::mutable_loglevel() {
  
  // @@protoc_insertion_point(field_mutable:exif.ReqSetLogLevel.loglevel)
  return loglevel_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReqSetLogLevel::release_loglevel() {
  // @@protoc_insertion_point(field_release:exif.ReqSetLogLevel.loglevel)
  
  return loglevel_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReqSetLogLevel::set_allocated_loglevel(::std::string* loglevel) {
  if (loglevel != NULL) {
    
  } else {
    
  }
  loglevel_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), loglevel);
  // @@protoc_insertion_point(field_set_allocated:exif.ReqSetLogLevel.loglevel)
}
 
// string loggername = 2;
inline void ReqSetLogLevel::clear_loggername() {
  loggername_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ReqSetLogLevel::loggername() const {
  // @@protoc_insertion_point(field_get:exif.ReqSetLogLevel.loggername)
  return loggername_.GetNoArena();
}
inline void ReqSetLogLevel::set_loggername(const ::std::string& value) {
  
  loggername_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.ReqSetLogLevel.loggername)
}
#if LANG_CXX11
inline void ReqSetLogLevel::set_loggername(::std::string&& value) {
  
  loggername_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.ReqSetLogLevel.loggername)
}
#endif
inline void ReqSetLogLevel::set_loggername(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  loggername_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.ReqSetLogLevel.loggername)
}
inline void ReqSetLogLevel::set_loggername(const char* value, size_t size) {
  
  loggername_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.ReqSetLogLevel.loggername)
}
inline ::std::string* ReqSetLogLevel::mutable_loggername() {
  
  // @@protoc_insertion_point(field_mutable:exif.ReqSetLogLevel.loggername)
  return loggername_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReqSetLogLevel::release_loggername() {
  // @@protoc_insertion_point(field_release:exif.ReqSetLogLevel.loggername)
  
  return loggername_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReqSetLogLevel::set_allocated_loggername(::std::string* loggername) {
  if (loggername != NULL) {
    
  } else {
    
  }
  loggername_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), loggername);
  // @@protoc_insertion_point(field_set_allocated:exif.ReqSetLogLevel.loggername)
}
 
// -------------------------------------------------------------------
 
// RepSetLogLevel
 
// string reply = 1;
inline void RepSetLogLevel::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepSetLogLevel::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepSetLogLevel.reply)
  return reply_.GetNoArena();
}
inline void RepSetLogLevel::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepSetLogLevel.reply)
}
#if LANG_CXX11
inline void RepSetLogLevel::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepSetLogLevel.reply)
}
#endif
inline void RepSetLogLevel::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepSetLogLevel.reply)
}
inline void RepSetLogLevel::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepSetLogLevel.reply)
}
inline ::std::string* RepSetLogLevel::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepSetLogLevel.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepSetLogLevel::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepSetLogLevel.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepSetLogLevel::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepSetLogLevel.reply)
}
 
// -------------------------------------------------------------------
 
// ReqPreset
 
// double ra = 1;
inline void ReqPreset::clear_ra() {
  ra_ = 0;
}
inline double ReqPreset::ra() const {
  // @@protoc_insertion_point(field_get:exif.ReqPreset.ra)
  return ra_;
}
inline void ReqPreset::set_ra(double value) {
  
  ra_ = value;
  // @@protoc_insertion_point(field_set:exif.ReqPreset.ra)
}
 
// double dec = 2;
inline void ReqPreset::clear_dec() {
  dec_ = 0;
}
inline double ReqPreset::dec() const {
  // @@protoc_insertion_point(field_get:exif.ReqPreset.dec)
  return dec_;
}
inline void ReqPreset::set_dec(double value) {
  
  dec_ = value;
  // @@protoc_insertion_point(field_set:exif.ReqPreset.dec)
}
 
// -------------------------------------------------------------------
 
// RepPreset
 
// string reply = 1;
inline void RepPreset::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepPreset::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepPreset.reply)
  return reply_.GetNoArena();
}
inline void RepPreset::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepPreset.reply)
}
#if LANG_CXX11
inline void RepPreset::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepPreset.reply)
}
#endif
inline void RepPreset::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepPreset.reply)
}
inline void RepPreset::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepPreset.reply)
}
inline ::std::string* RepPreset::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepPreset.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepPreset::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepPreset.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepPreset::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepPreset.reply)
}
 
// -------------------------------------------------------------------
 
// ReqMove
 
// double x = 1;
inline void ReqMove::clear_x() {
  x_ = 0;
}
inline double ReqMove::x() const {
  // @@protoc_insertion_point(field_get:exif.ReqMove.x)
  return x_;
}
inline void ReqMove::set_x(double value) {
  
  x_ = value;
  // @@protoc_insertion_point(field_set:exif.ReqMove.x)
}
 
// double y = 2;
inline void ReqMove::clear_y() {
  y_ = 0;
}
inline double ReqMove::y() const {
  // @@protoc_insertion_point(field_get:exif.ReqMove.y)
  return y_;
}
inline void ReqMove::set_y(double value) {
  
  y_ = value;
  // @@protoc_insertion_point(field_set:exif.ReqMove.y)
}
 
// -------------------------------------------------------------------
 
// RepMove
 
// string reply = 1;
inline void RepMove::clear_reply() {
  reply_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& RepMove::reply() const {
  // @@protoc_insertion_point(field_get:exif.RepMove.reply)
  return reply_.GetNoArena();
}
inline void RepMove::set_reply(const ::std::string& value) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exif.RepMove.reply)
}
#if LANG_CXX11
inline void RepMove::set_reply(::std::string&& value) {
  
  reply_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exif.RepMove.reply)
}
#endif
inline void RepMove::set_reply(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exif.RepMove.reply)
}
inline void RepMove::set_reply(const char* value, size_t size) {
  
  reply_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exif.RepMove.reply)
}
inline ::std::string* RepMove::mutable_reply() {
  
  // @@protoc_insertion_point(field_mutable:exif.RepMove.reply)
  return reply_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RepMove::release_reply() {
  // @@protoc_insertion_point(field_release:exif.RepMove.reply)
  
  return reply_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RepMove::set_allocated_reply(::std::string* reply) {
  if (reply != NULL) {
    
  } else {
    
  }
  reply_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reply);
  // @@protoc_insertion_point(field_set_allocated:exif.RepMove.reply)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace exif
 
// @@protoc_insertion_point(global_scope)
 
#endif  // PROTOBUF_INCLUDED_requests_2eproto