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

#ifndef GOOGLE_PROTOBUF_INCLUDED_ByteInterval_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_ByteInterval_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3015000
#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 3015005 < 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/port_undef.inc>
#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/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.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/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/unknown_field_set.h>
#include "CodeBlock.pb.h"
#include "DataBlock.pb.h"
#include "SymbolicExpression.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_ByteInterval_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_ByteInterval_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ByteInterval_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_ByteInterval_2eproto_metadata_getter(int index);
namespace gtirb {
namespace proto {
class Block;
struct BlockDefaultTypeInternal;
extern BlockDefaultTypeInternal _Block_default_instance_;
class ByteInterval;
struct ByteIntervalDefaultTypeInternal;
extern ByteIntervalDefaultTypeInternal _ByteInterval_default_instance_;
class ByteInterval_SymbolicExpressionsEntry_DoNotUse;
struct ByteInterval_SymbolicExpressionsEntry_DoNotUseDefaultTypeInternal;
extern ByteInterval_SymbolicExpressionsEntry_DoNotUseDefaultTypeInternal _ByteInterval_SymbolicExpressionsEntry_DoNotUse_default_instance_;
}  // namespace proto
}  // namespace gtirb
PROTOBUF_NAMESPACE_OPEN
template<> ::gtirb::proto::Block* Arena::CreateMaybeMessage<::gtirb::proto::Block>(Arena*);
template<> ::gtirb::proto::ByteInterval* Arena::CreateMaybeMessage<::gtirb::proto::ByteInterval>(Arena*);
template<> ::gtirb::proto::ByteInterval_SymbolicExpressionsEntry_DoNotUse* Arena::CreateMaybeMessage<::gtirb::proto::ByteInterval_SymbolicExpressionsEntry_DoNotUse>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace gtirb {
namespace proto {

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

class Block PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtirb.proto.Block) */ {
 public:
  inline Block() : Block(nullptr) {}
  virtual ~Block();
  explicit constexpr Block(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Block(const Block& from);
  Block(Block&& from) noexcept
    : Block() {
    *this = ::std::move(from);
  }

  inline Block& operator=(const Block& from) {
    CopyFrom(from);
    return *this;
  }
  inline Block& operator=(Block&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Block& default_instance() {
    return *internal_default_instance();
  }
  enum ValueCase {
    kCode = 2,
    kData = 3,
    VALUE_NOT_SET = 0,
  };

  static inline const Block* internal_default_instance() {
    return reinterpret_cast<const Block*>(
               &_Block_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Block& a, Block& b) {
    a.Swap(&b);
  }
  inline void Swap(Block* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Block* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Block* New() const final {
    return CreateMaybeMessage<Block>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Block* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtirb.proto.Block";
  }
  protected:
  explicit Block(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_ByteInterval_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kOffsetFieldNumber = 1,
    kCodeFieldNumber = 2,
    kDataFieldNumber = 3,
  };
  // uint64 offset = 1;
  void clear_offset();
  ::PROTOBUF_NAMESPACE_ID::uint64 offset() const;
  void set_offset(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_offset() const;
  void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // .gtirb.proto.CodeBlock code = 2;
  bool has_code() const;
  private:
  bool _internal_has_code() const;
  public:
  void clear_code();
  const ::gtirb::proto::CodeBlock& code() const;
  ::gtirb::proto::CodeBlock* release_code();
  ::gtirb::proto::CodeBlock* mutable_code();
  void set_allocated_code(::gtirb::proto::CodeBlock* code);
  private:
  const ::gtirb::proto::CodeBlock& _internal_code() const;
  ::gtirb::proto::CodeBlock* _internal_mutable_code();
  public:
  void unsafe_arena_set_allocated_code(
      ::gtirb::proto::CodeBlock* code);
  ::gtirb::proto::CodeBlock* unsafe_arena_release_code();

  // .gtirb.proto.DataBlock data = 3;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const ::gtirb::proto::DataBlock& data() const;
  ::gtirb::proto::DataBlock* release_data();
  ::gtirb::proto::DataBlock* mutable_data();
  void set_allocated_data(::gtirb::proto::DataBlock* data);
  private:
  const ::gtirb::proto::DataBlock& _internal_data() const;
  ::gtirb::proto::DataBlock* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::gtirb::proto::DataBlock* data);
  ::gtirb::proto::DataBlock* unsafe_arena_release_data();

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:gtirb.proto.Block)
 private:
  class _Internal;
  void set_has_code();
  void set_has_data();

  inline bool has_value() const;
  inline void clear_has_value();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint64 offset_;
  union ValueUnion {
    constexpr ValueUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::gtirb::proto::CodeBlock* code_;
    ::gtirb::proto::DataBlock* data_;
  } value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_ByteInterval_2eproto;
};
// -------------------------------------------------------------------

class ByteInterval_SymbolicExpressionsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ByteInterval_SymbolicExpressionsEntry_DoNotUse, 
    ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ByteInterval_SymbolicExpressionsEntry_DoNotUse, 
    ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ByteInterval_SymbolicExpressionsEntry_DoNotUse();
  explicit constexpr ByteInterval_SymbolicExpressionsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ByteInterval_SymbolicExpressionsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ByteInterval_SymbolicExpressionsEntry_DoNotUse& other);
  static const ByteInterval_SymbolicExpressionsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ByteInterval_SymbolicExpressionsEntry_DoNotUse*>(&_ByteInterval_SymbolicExpressionsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(void*) { return true; }
  static bool ValidateValue(void*) { return true; }
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ByteInterval_2eproto);
    return ::descriptor_table_ByteInterval_2eproto.file_level_metadata[1];
  }

  public:
};

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

class ByteInterval PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:gtirb.proto.ByteInterval) */ {
 public:
  inline ByteInterval() : ByteInterval(nullptr) {}
  virtual ~ByteInterval();
  explicit constexpr ByteInterval(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ByteInterval(const ByteInterval& from);
  ByteInterval(ByteInterval&& from) noexcept
    : ByteInterval() {
    *this = ::std::move(from);
  }

  inline ByteInterval& operator=(const ByteInterval& from) {
    CopyFrom(from);
    return *this;
  }
  inline ByteInterval& operator=(ByteInterval&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ByteInterval& default_instance() {
    return *internal_default_instance();
  }
  static inline const ByteInterval* internal_default_instance() {
    return reinterpret_cast<const ByteInterval*>(
               &_ByteInterval_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ByteInterval& a, ByteInterval& b) {
    a.Swap(&b);
  }
  inline void Swap(ByteInterval* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ByteInterval* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ByteInterval* New() const final {
    return CreateMaybeMessage<ByteInterval>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ByteInterval* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "gtirb.proto.ByteInterval";
  }
  protected:
  explicit ByteInterval(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_ByteInterval_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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


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

  enum : int {
    kBlocksFieldNumber = 2,
    kSymbolicExpressionsFieldNumber = 3,
    kUuidFieldNumber = 1,
    kContentsFieldNumber = 7,
    kAddressFieldNumber = 5,
    kSizeFieldNumber = 6,
    kHasAddressFieldNumber = 4,
  };
  // repeated .gtirb.proto.Block blocks = 2;
  int blocks_size() const;
  private:
  int _internal_blocks_size() const;
  public:
  void clear_blocks();
  ::gtirb::proto::Block* mutable_blocks(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gtirb::proto::Block >*
      mutable_blocks();
  private:
  const ::gtirb::proto::Block& _internal_blocks(int index) const;
  ::gtirb::proto::Block* _internal_add_blocks();
  public:
  const ::gtirb::proto::Block& blocks(int index) const;
  ::gtirb::proto::Block* add_blocks();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gtirb::proto::Block >&
      blocks() const;

  // map<uint64, .gtirb.proto.SymbolicExpression> symbolic_expressions = 3;
  int symbolic_expressions_size() const;
  private:
  int _internal_symbolic_expressions_size() const;
  public:
  void clear_symbolic_expressions();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >&
      _internal_symbolic_expressions() const;
  ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >*
      _internal_mutable_symbolic_expressions();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >&
      symbolic_expressions() const;
  ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >*
      mutable_symbolic_expressions();

  // bytes uuid = 1;
  void clear_uuid();
  const std::string& uuid() const;
  void set_uuid(const std::string& value);
  void set_uuid(std::string&& value);
  void set_uuid(const char* value);
  void set_uuid(const void* value, size_t size);
  std::string* mutable_uuid();
  std::string* release_uuid();
  void set_allocated_uuid(std::string* uuid);
  private:
  const std::string& _internal_uuid() const;
  void _internal_set_uuid(const std::string& value);
  std::string* _internal_mutable_uuid();
  public:

  // bytes contents = 7;
  void clear_contents();
  const std::string& contents() const;
  void set_contents(const std::string& value);
  void set_contents(std::string&& value);
  void set_contents(const char* value);
  void set_contents(const void* value, size_t size);
  std::string* mutable_contents();
  std::string* release_contents();
  void set_allocated_contents(std::string* contents);
  private:
  const std::string& _internal_contents() const;
  void _internal_set_contents(const std::string& value);
  std::string* _internal_mutable_contents();
  public:

  // uint64 address = 5;
  void clear_address();
  ::PROTOBUF_NAMESPACE_ID::uint64 address() const;
  void set_address(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_address() const;
  void _internal_set_address(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // uint64 size = 6;
  void clear_size();
  ::PROTOBUF_NAMESPACE_ID::uint64 size() const;
  void set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_size() const;
  void _internal_set_size(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // bool has_address = 4;
  void clear_has_address();
  bool has_address() const;
  void set_has_address(bool value);
  private:
  bool _internal_has_address() const;
  void _internal_set_has_address(bool value);
  public:

  // @@protoc_insertion_point(class_scope:gtirb.proto.ByteInterval)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gtirb::proto::Block > blocks_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      ByteInterval_SymbolicExpressionsEntry_DoNotUse,
      ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> symbolic_expressions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contents_;
  ::PROTOBUF_NAMESPACE_ID::uint64 address_;
  ::PROTOBUF_NAMESPACE_ID::uint64 size_;
  bool has_address_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ByteInterval_2eproto;
};
// ===================================================================


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

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

// uint64 offset = 1;
inline void Block::clear_offset() {
  offset_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Block::_internal_offset() const {
  return offset_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Block::offset() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.Block.offset)
  return _internal_offset();
}
inline void Block::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  offset_ = value;
}
inline void Block::set_offset(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.Block.offset)
}

// .gtirb.proto.CodeBlock code = 2;
inline bool Block::_internal_has_code() const {
  return value_case() == kCode;
}
inline bool Block::has_code() const {
  return _internal_has_code();
}
inline void Block::set_has_code() {
  _oneof_case_[0] = kCode;
}
inline ::gtirb::proto::CodeBlock* Block::release_code() {
  // @@protoc_insertion_point(field_release:gtirb.proto.Block.code)
  if (_internal_has_code()) {
    clear_has_value();
      ::gtirb::proto::CodeBlock* temp = value_.code_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.code_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gtirb::proto::CodeBlock& Block::_internal_code() const {
  return _internal_has_code()
      ? *value_.code_
      : reinterpret_cast< ::gtirb::proto::CodeBlock&>(::gtirb::proto::_CodeBlock_default_instance_);
}
inline const ::gtirb::proto::CodeBlock& Block::code() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.Block.code)
  return _internal_code();
}
inline ::gtirb::proto::CodeBlock* Block::unsafe_arena_release_code() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gtirb.proto.Block.code)
  if (_internal_has_code()) {
    clear_has_value();
    ::gtirb::proto::CodeBlock* temp = value_.code_;
    value_.code_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Block::unsafe_arena_set_allocated_code(::gtirb::proto::CodeBlock* code) {
  clear_value();
  if (code) {
    set_has_code();
    value_.code_ = code;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gtirb.proto.Block.code)
}
inline ::gtirb::proto::CodeBlock* Block::_internal_mutable_code() {
  if (!_internal_has_code()) {
    clear_value();
    set_has_code();
    value_.code_ = CreateMaybeMessage< ::gtirb::proto::CodeBlock >(GetArena());
  }
  return value_.code_;
}
inline ::gtirb::proto::CodeBlock* Block::mutable_code() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.Block.code)
  return _internal_mutable_code();
}

// .gtirb.proto.DataBlock data = 3;
inline bool Block::_internal_has_data() const {
  return value_case() == kData;
}
inline bool Block::has_data() const {
  return _internal_has_data();
}
inline void Block::set_has_data() {
  _oneof_case_[0] = kData;
}
inline ::gtirb::proto::DataBlock* Block::release_data() {
  // @@protoc_insertion_point(field_release:gtirb.proto.Block.data)
  if (_internal_has_data()) {
    clear_has_value();
      ::gtirb::proto::DataBlock* temp = value_.data_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::gtirb::proto::DataBlock& Block::_internal_data() const {
  return _internal_has_data()
      ? *value_.data_
      : reinterpret_cast< ::gtirb::proto::DataBlock&>(::gtirb::proto::_DataBlock_default_instance_);
}
inline const ::gtirb::proto::DataBlock& Block::data() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.Block.data)
  return _internal_data();
}
inline ::gtirb::proto::DataBlock* Block::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:gtirb.proto.Block.data)
  if (_internal_has_data()) {
    clear_has_value();
    ::gtirb::proto::DataBlock* temp = value_.data_;
    value_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Block::unsafe_arena_set_allocated_data(::gtirb::proto::DataBlock* data) {
  clear_value();
  if (data) {
    set_has_data();
    value_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:gtirb.proto.Block.data)
}
inline ::gtirb::proto::DataBlock* Block::_internal_mutable_data() {
  if (!_internal_has_data()) {
    clear_value();
    set_has_data();
    value_.data_ = CreateMaybeMessage< ::gtirb::proto::DataBlock >(GetArena());
  }
  return value_.data_;
}
inline ::gtirb::proto::DataBlock* Block::mutable_data() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.Block.data)
  return _internal_mutable_data();
}

inline bool Block::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void Block::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline Block::ValueCase Block::value_case() const {
  return Block::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

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

// ByteInterval

// bytes uuid = 1;
inline void ByteInterval::clear_uuid() {
  uuid_.ClearToEmpty();
}
inline const std::string& ByteInterval::uuid() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.ByteInterval.uuid)
  return _internal_uuid();
}
inline void ByteInterval::set_uuid(const std::string& value) {
  _internal_set_uuid(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.ByteInterval.uuid)
}
inline std::string* ByteInterval::mutable_uuid() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.ByteInterval.uuid)
  return _internal_mutable_uuid();
}
inline const std::string& ByteInterval::_internal_uuid() const {
  return uuid_.Get();
}
inline void ByteInterval::_internal_set_uuid(const std::string& value) {
  
  uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ByteInterval::set_uuid(std::string&& value) {
  
  uuid_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:gtirb.proto.ByteInterval.uuid)
}
inline void ByteInterval::set_uuid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:gtirb.proto.ByteInterval.uuid)
}
inline void ByteInterval::set_uuid(const void* value,
    size_t size) {
  
  uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:gtirb.proto.ByteInterval.uuid)
}
inline std::string* ByteInterval::_internal_mutable_uuid() {
  
  return uuid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ByteInterval::release_uuid() {
  // @@protoc_insertion_point(field_release:gtirb.proto.ByteInterval.uuid)
  return uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ByteInterval::set_allocated_uuid(std::string* uuid) {
  if (uuid != nullptr) {
    
  } else {
    
  }
  uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uuid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:gtirb.proto.ByteInterval.uuid)
}

// repeated .gtirb.proto.Block blocks = 2;
inline int ByteInterval::_internal_blocks_size() const {
  return blocks_.size();
}
inline int ByteInterval::blocks_size() const {
  return _internal_blocks_size();
}
inline void ByteInterval::clear_blocks() {
  blocks_.Clear();
}
inline ::gtirb::proto::Block* ByteInterval::mutable_blocks(int index) {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.ByteInterval.blocks)
  return blocks_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gtirb::proto::Block >*
ByteInterval::mutable_blocks() {
  // @@protoc_insertion_point(field_mutable_list:gtirb.proto.ByteInterval.blocks)
  return &blocks_;
}
inline const ::gtirb::proto::Block& ByteInterval::_internal_blocks(int index) const {
  return blocks_.Get(index);
}
inline const ::gtirb::proto::Block& ByteInterval::blocks(int index) const {
  // @@protoc_insertion_point(field_get:gtirb.proto.ByteInterval.blocks)
  return _internal_blocks(index);
}
inline ::gtirb::proto::Block* ByteInterval::_internal_add_blocks() {
  return blocks_.Add();
}
inline ::gtirb::proto::Block* ByteInterval::add_blocks() {
  // @@protoc_insertion_point(field_add:gtirb.proto.ByteInterval.blocks)
  return _internal_add_blocks();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::gtirb::proto::Block >&
ByteInterval::blocks() const {
  // @@protoc_insertion_point(field_list:gtirb.proto.ByteInterval.blocks)
  return blocks_;
}

// map<uint64, .gtirb.proto.SymbolicExpression> symbolic_expressions = 3;
inline int ByteInterval::_internal_symbolic_expressions_size() const {
  return symbolic_expressions_.size();
}
inline int ByteInterval::symbolic_expressions_size() const {
  return _internal_symbolic_expressions_size();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >&
ByteInterval::_internal_symbolic_expressions() const {
  return symbolic_expressions_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >&
ByteInterval::symbolic_expressions() const {
  // @@protoc_insertion_point(field_map:gtirb.proto.ByteInterval.symbolic_expressions)
  return _internal_symbolic_expressions();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >*
ByteInterval::_internal_mutable_symbolic_expressions() {
  return symbolic_expressions_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::uint64, ::gtirb::proto::SymbolicExpression >*
ByteInterval::mutable_symbolic_expressions() {
  // @@protoc_insertion_point(field_mutable_map:gtirb.proto.ByteInterval.symbolic_expressions)
  return _internal_mutable_symbolic_expressions();
}

// bool has_address = 4;
inline void ByteInterval::clear_has_address() {
  has_address_ = false;
}
inline bool ByteInterval::_internal_has_address() const {
  return has_address_;
}
inline bool ByteInterval::has_address() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.ByteInterval.has_address)
  return _internal_has_address();
}
inline void ByteInterval::_internal_set_has_address(bool value) {
  
  has_address_ = value;
}
inline void ByteInterval::set_has_address(bool value) {
  _internal_set_has_address(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.ByteInterval.has_address)
}

// uint64 address = 5;
inline void ByteInterval::clear_address() {
  address_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ByteInterval::_internal_address() const {
  return address_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ByteInterval::address() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.ByteInterval.address)
  return _internal_address();
}
inline void ByteInterval::_internal_set_address(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  address_ = value;
}
inline void ByteInterval::set_address(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_address(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.ByteInterval.address)
}

// uint64 size = 6;
inline void ByteInterval::clear_size() {
  size_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ByteInterval::_internal_size() const {
  return size_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ByteInterval::size() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.ByteInterval.size)
  return _internal_size();
}
inline void ByteInterval::_internal_set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  size_ = value;
}
inline void ByteInterval::set_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.ByteInterval.size)
}

// bytes contents = 7;
inline void ByteInterval::clear_contents() {
  contents_.ClearToEmpty();
}
inline const std::string& ByteInterval::contents() const {
  // @@protoc_insertion_point(field_get:gtirb.proto.ByteInterval.contents)
  return _internal_contents();
}
inline void ByteInterval::set_contents(const std::string& value) {
  _internal_set_contents(value);
  // @@protoc_insertion_point(field_set:gtirb.proto.ByteInterval.contents)
}
inline std::string* ByteInterval::mutable_contents() {
  // @@protoc_insertion_point(field_mutable:gtirb.proto.ByteInterval.contents)
  return _internal_mutable_contents();
}
inline const std::string& ByteInterval::_internal_contents() const {
  return contents_.Get();
}
inline void ByteInterval::_internal_set_contents(const std::string& value) {
  
  contents_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ByteInterval::set_contents(std::string&& value) {
  
  contents_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:gtirb.proto.ByteInterval.contents)
}
inline void ByteInterval::set_contents(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  contents_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:gtirb.proto.ByteInterval.contents)
}
inline void ByteInterval::set_contents(const void* value,
    size_t size) {
  
  contents_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:gtirb.proto.ByteInterval.contents)
}
inline std::string* ByteInterval::_internal_mutable_contents() {
  
  return contents_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ByteInterval::release_contents() {
  // @@protoc_insertion_point(field_release:gtirb.proto.ByteInterval.contents)
  return contents_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ByteInterval::set_allocated_contents(std::string* contents) {
  if (contents != nullptr) {
    
  } else {
    
  }
  contents_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), contents,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:gtirb.proto.ByteInterval.contents)
}

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace gtirb

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ByteInterval_2eproto
