// automatically generated by the FlatBuffers compiler, do not modify

#ifndef FLATBUFFERS_GENERATED_CONTROL_XE_DEBUG_PROTO_H_
#define FLATBUFFERS_GENERATED_CONTROL_XE_DEBUG_PROTO_H_

#include "flatbuffers/flatbuffers.h"

namespace xe {
namespace debug {
namespace proto {
struct XObject;
}  // namespace proto
}  // namespace debug
}  // namespace xe

namespace xe {
namespace debug {
namespace proto {

struct StopRequest;
struct StopResponse;
struct BreakRequest;
struct BreakResponse;
struct ContinueRequest;
struct ContinueResponse;
struct StepRequest;
struct StepResponse;
struct BreakpointEvent;
struct AccessViolationEvent;

enum ContinueAction {
  ContinueAction_Continue = 0,
  ContinueAction_ContinueTo = 1
};

inline const char **EnumNamesContinueAction() {
  static const char *names[] = {"Continue", "ContinueTo", nullptr};
  return names;
}

inline const char *EnumNameContinueAction(ContinueAction e) {
  return EnumNamesContinueAction()[e];
}

enum StepAction {
  StepAction_StepIn = 0,
  StepAction_StepOver = 1,
  StepAction_StepOut = 2
};

inline const char **EnumNamesStepAction() {
  static const char *names[] = {"StepIn", "StepOver", "StepOut", nullptr};
  return names;
}

inline const char *EnumNameStepAction(StepAction e) {
  return EnumNamesStepAction()[e];
}

struct StopRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
};

struct StopRequestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  StopRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StopRequestBuilder &operator=(const StopRequestBuilder &);
  flatbuffers::Offset<StopRequest> Finish() {
    auto o = flatbuffers::Offset<StopRequest>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<StopRequest> CreateStopRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  StopRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

struct StopResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
};

struct StopResponseBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  StopResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StopResponseBuilder &operator=(const StopResponseBuilder &);
  flatbuffers::Offset<StopResponse> Finish() {
    auto o = flatbuffers::Offset<StopResponse>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<StopResponse> CreateStopResponse(
    flatbuffers::FlatBufferBuilder &_fbb) {
  StopResponseBuilder builder_(_fbb);
  return builder_.Finish();
}

struct BreakRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
};

struct BreakRequestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  BreakRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  BreakRequestBuilder &operator=(const BreakRequestBuilder &);
  flatbuffers::Offset<BreakRequest> Finish() {
    auto o = flatbuffers::Offset<BreakRequest>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<BreakRequest> CreateBreakRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  BreakRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

struct BreakResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
};

struct BreakResponseBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  BreakResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  BreakResponseBuilder &operator=(const BreakResponseBuilder &);
  flatbuffers::Offset<BreakResponse> Finish() {
    auto o = flatbuffers::Offset<BreakResponse>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<BreakResponse> CreateBreakResponse(
    flatbuffers::FlatBufferBuilder &_fbb) {
  BreakResponseBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ContinueRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  ContinueAction action() const {
    return static_cast<ContinueAction>(GetField<int8_t>(4, 0));
  }
  uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, 4 /* action */) &&
           VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
           verifier.EndTable();
  }
};

struct ContinueRequestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_action(ContinueAction action) {
    fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0);
  }
  void add_target_address(uint32_t target_address) {
    fbb_.AddElement<uint32_t>(6, target_address, 0);
  }
  ContinueRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ContinueRequestBuilder &operator=(const ContinueRequestBuilder &);
  flatbuffers::Offset<ContinueRequest> Finish() {
    auto o = flatbuffers::Offset<ContinueRequest>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    ContinueAction action = ContinueAction_Continue,
    uint32_t target_address = 0) {
  ContinueRequestBuilder builder_(_fbb);
  builder_.add_target_address(target_address);
  builder_.add_action(action);
  return builder_.Finish();
}

struct ContinueResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
};

struct ContinueResponseBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  ContinueResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ContinueResponseBuilder &operator=(const ContinueResponseBuilder &);
  flatbuffers::Offset<ContinueResponse> Finish() {
    auto o = flatbuffers::Offset<ContinueResponse>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<ContinueResponse> CreateContinueResponse(
    flatbuffers::FlatBufferBuilder &_fbb) {
  ContinueResponseBuilder builder_(_fbb);
  return builder_.Finish();
}

struct StepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  StepAction action() const {
    return static_cast<StepAction>(GetField<int8_t>(4, 0));
  }
  uint32_t thread_id() const { return GetField<uint32_t>(6, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, 4 /* action */) &&
           VerifyField<uint32_t>(verifier, 6 /* thread_id */) &&
           verifier.EndTable();
  }
};

struct StepRequestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_action(StepAction action) {
    fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0);
  }
  void add_thread_id(uint32_t thread_id) {
    fbb_.AddElement<uint32_t>(6, thread_id, 0);
  }
  StepRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StepRequestBuilder &operator=(const StepRequestBuilder &);
  flatbuffers::Offset<StepRequest> Finish() {
    auto o = flatbuffers::Offset<StepRequest>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<StepRequest> CreateStepRequest(
    flatbuffers::FlatBufferBuilder &_fbb, StepAction action = StepAction_StepIn,
    uint32_t thread_id = 0) {
  StepRequestBuilder builder_(_fbb);
  builder_.add_thread_id(thread_id);
  builder_.add_action(action);
  return builder_.Finish();
}

struct StepResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) && verifier.EndTable();
  }
};

struct StepResponseBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  StepResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StepResponseBuilder &operator=(const StepResponseBuilder &);
  flatbuffers::Offset<StepResponse> Finish() {
    auto o = flatbuffers::Offset<StepResponse>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<StepResponse> CreateStepResponse(
    flatbuffers::FlatBufferBuilder &_fbb) {
  StepResponseBuilder builder_(_fbb);
  return builder_.Finish();
}

struct BreakpointEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
  uint32_t breakpoint_id() const { return GetField<uint32_t>(6, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
           VerifyField<uint32_t>(verifier, 6 /* breakpoint_id */) &&
           verifier.EndTable();
  }
};

struct BreakpointEventBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_thread_id(uint32_t thread_id) {
    fbb_.AddElement<uint32_t>(4, thread_id, 0);
  }
  void add_breakpoint_id(uint32_t breakpoint_id) {
    fbb_.AddElement<uint32_t>(6, breakpoint_id, 0);
  }
  BreakpointEventBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  BreakpointEventBuilder &operator=(const BreakpointEventBuilder &);
  flatbuffers::Offset<BreakpointEvent> Finish() {
    auto o = flatbuffers::Offset<BreakpointEvent>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<BreakpointEvent> CreateBreakpointEvent(
    flatbuffers::FlatBufferBuilder &_fbb, uint32_t thread_id = 0,
    uint32_t breakpoint_id = 0) {
  BreakpointEventBuilder builder_(_fbb);
  builder_.add_breakpoint_id(breakpoint_id);
  builder_.add_thread_id(thread_id);
  return builder_.Finish();
}

struct AccessViolationEvent FLATBUFFERS_FINAL_CLASS
    : private flatbuffers::Table {
  uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
  uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
           VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
           verifier.EndTable();
  }
};

struct AccessViolationEventBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_thread_id(uint32_t thread_id) {
    fbb_.AddElement<uint32_t>(4, thread_id, 0);
  }
  void add_target_address(uint32_t target_address) {
    fbb_.AddElement<uint32_t>(6, target_address, 0);
  }
  AccessViolationEventBuilder(flatbuffers::FlatBufferBuilder &_fbb)
      : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  AccessViolationEventBuilder &operator=(const AccessViolationEventBuilder &);
  flatbuffers::Offset<AccessViolationEvent> Finish() {
    auto o =
        flatbuffers::Offset<AccessViolationEvent>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<AccessViolationEvent> CreateAccessViolationEvent(
    flatbuffers::FlatBufferBuilder &_fbb, uint32_t thread_id = 0,
    uint32_t target_address = 0) {
  AccessViolationEventBuilder builder_(_fbb);
  builder_.add_target_address(target_address);
  builder_.add_thread_id(thread_id);
  return builder_.Finish();
}

}  // namespace proto
}  // namespace debug
}  // namespace xe

#endif  // FLATBUFFERS_GENERATED_CONTROL_XE_DEBUG_PROTO_H_