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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "scheduling/firmament_scheduler.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace firmament {

namespace {

const ::google::protobuf::Descriptor* ScheduleRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ScheduleRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* SchedulingDeltas_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SchedulingDeltas_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskCompletedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskCompletedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskDescription_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskDescription_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskSubmittedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskSubmittedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskRemovedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskRemovedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskFailedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskFailedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskUpdatedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskUpdatedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* NodeAddedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  NodeAddedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* NodeRemovedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  NodeRemovedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* NodeFailedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  NodeFailedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* NodeUpdatedResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  NodeUpdatedResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskStatsResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskStatsResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* ResourceStatsResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ResourceStatsResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* TaskUID_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TaskUID_reflection_ = NULL;
const ::google::protobuf::Descriptor* ResourceUID_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ResourceUID_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* TaskReplyType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* NodeReplyType_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_scheduling_2ffirmament_5fscheduler_2eproto() GOOGLE_ATTRIBUTE_COLD;
void protobuf_AssignDesc_scheduling_2ffirmament_5fscheduler_2eproto() {
  protobuf_AddDesc_scheduling_2ffirmament_5fscheduler_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "scheduling/firmament_scheduler.proto");
  GOOGLE_CHECK(file != NULL);
  ScheduleRequest_descriptor_ = file->message_type(0);
  static const int ScheduleRequest_offsets_[1] = {
  };
  ScheduleRequest_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ScheduleRequest_descriptor_,
      ScheduleRequest::internal_default_instance(),
      ScheduleRequest_offsets_,
      -1,
      -1,
      -1,
      sizeof(ScheduleRequest),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ScheduleRequest, _internal_metadata_));
  SchedulingDeltas_descriptor_ = file->message_type(1);
  static const int SchedulingDeltas_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchedulingDeltas, deltas_),
  };
  SchedulingDeltas_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      SchedulingDeltas_descriptor_,
      SchedulingDeltas::internal_default_instance(),
      SchedulingDeltas_offsets_,
      -1,
      -1,
      -1,
      sizeof(SchedulingDeltas),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SchedulingDeltas, _internal_metadata_));
  TaskCompletedResponse_descriptor_ = file->message_type(2);
  static const int TaskCompletedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskCompletedResponse, type_),
  };
  TaskCompletedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskCompletedResponse_descriptor_,
      TaskCompletedResponse::internal_default_instance(),
      TaskCompletedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskCompletedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskCompletedResponse, _internal_metadata_));
  TaskDescription_descriptor_ = file->message_type(3);
  static const int TaskDescription_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskDescription, task_descriptor_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskDescription, job_descriptor_),
  };
  TaskDescription_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskDescription_descriptor_,
      TaskDescription::internal_default_instance(),
      TaskDescription_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskDescription),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskDescription, _internal_metadata_));
  TaskSubmittedResponse_descriptor_ = file->message_type(4);
  static const int TaskSubmittedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskSubmittedResponse, type_),
  };
  TaskSubmittedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskSubmittedResponse_descriptor_,
      TaskSubmittedResponse::internal_default_instance(),
      TaskSubmittedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskSubmittedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskSubmittedResponse, _internal_metadata_));
  TaskRemovedResponse_descriptor_ = file->message_type(5);
  static const int TaskRemovedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskRemovedResponse, type_),
  };
  TaskRemovedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskRemovedResponse_descriptor_,
      TaskRemovedResponse::internal_default_instance(),
      TaskRemovedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskRemovedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskRemovedResponse, _internal_metadata_));
  TaskFailedResponse_descriptor_ = file->message_type(6);
  static const int TaskFailedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskFailedResponse, type_),
  };
  TaskFailedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskFailedResponse_descriptor_,
      TaskFailedResponse::internal_default_instance(),
      TaskFailedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskFailedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskFailedResponse, _internal_metadata_));
  TaskUpdatedResponse_descriptor_ = file->message_type(7);
  static const int TaskUpdatedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskUpdatedResponse, type_),
  };
  TaskUpdatedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskUpdatedResponse_descriptor_,
      TaskUpdatedResponse::internal_default_instance(),
      TaskUpdatedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskUpdatedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskUpdatedResponse, _internal_metadata_));
  NodeAddedResponse_descriptor_ = file->message_type(8);
  static const int NodeAddedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeAddedResponse, type_),
  };
  NodeAddedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      NodeAddedResponse_descriptor_,
      NodeAddedResponse::internal_default_instance(),
      NodeAddedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(NodeAddedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeAddedResponse, _internal_metadata_));
  NodeRemovedResponse_descriptor_ = file->message_type(9);
  static const int NodeRemovedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeRemovedResponse, type_),
  };
  NodeRemovedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      NodeRemovedResponse_descriptor_,
      NodeRemovedResponse::internal_default_instance(),
      NodeRemovedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(NodeRemovedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeRemovedResponse, _internal_metadata_));
  NodeFailedResponse_descriptor_ = file->message_type(10);
  static const int NodeFailedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeFailedResponse, type_),
  };
  NodeFailedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      NodeFailedResponse_descriptor_,
      NodeFailedResponse::internal_default_instance(),
      NodeFailedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(NodeFailedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeFailedResponse, _internal_metadata_));
  NodeUpdatedResponse_descriptor_ = file->message_type(11);
  static const int NodeUpdatedResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeUpdatedResponse, type_),
  };
  NodeUpdatedResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      NodeUpdatedResponse_descriptor_,
      NodeUpdatedResponse::internal_default_instance(),
      NodeUpdatedResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(NodeUpdatedResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NodeUpdatedResponse, _internal_metadata_));
  TaskStatsResponse_descriptor_ = file->message_type(12);
  static const int TaskStatsResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskStatsResponse, type_),
  };
  TaskStatsResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskStatsResponse_descriptor_,
      TaskStatsResponse::internal_default_instance(),
      TaskStatsResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskStatsResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskStatsResponse, _internal_metadata_));
  ResourceStatsResponse_descriptor_ = file->message_type(13);
  static const int ResourceStatsResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResourceStatsResponse, type_),
  };
  ResourceStatsResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ResourceStatsResponse_descriptor_,
      ResourceStatsResponse::internal_default_instance(),
      ResourceStatsResponse_offsets_,
      -1,
      -1,
      -1,
      sizeof(ResourceStatsResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResourceStatsResponse, _internal_metadata_));
  TaskUID_descriptor_ = file->message_type(14);
  static const int TaskUID_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskUID, task_uid_),
  };
  TaskUID_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      TaskUID_descriptor_,
      TaskUID::internal_default_instance(),
      TaskUID_offsets_,
      -1,
      -1,
      -1,
      sizeof(TaskUID),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TaskUID, _internal_metadata_));
  ResourceUID_descriptor_ = file->message_type(15);
  static const int ResourceUID_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResourceUID, resource_uid_),
  };
  ResourceUID_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ResourceUID_descriptor_,
      ResourceUID::internal_default_instance(),
      ResourceUID_offsets_,
      -1,
      -1,
      -1,
      sizeof(ResourceUID),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResourceUID, _internal_metadata_));
  TaskReplyType_descriptor_ = file->enum_type(0);
  NodeReplyType_descriptor_ = file->enum_type(1);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_scheduling_2ffirmament_5fscheduler_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ScheduleRequest_descriptor_, ScheduleRequest::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      SchedulingDeltas_descriptor_, SchedulingDeltas::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskCompletedResponse_descriptor_, TaskCompletedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskDescription_descriptor_, TaskDescription::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskSubmittedResponse_descriptor_, TaskSubmittedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskRemovedResponse_descriptor_, TaskRemovedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskFailedResponse_descriptor_, TaskFailedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskUpdatedResponse_descriptor_, TaskUpdatedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      NodeAddedResponse_descriptor_, NodeAddedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      NodeRemovedResponse_descriptor_, NodeRemovedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      NodeFailedResponse_descriptor_, NodeFailedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      NodeUpdatedResponse_descriptor_, NodeUpdatedResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskStatsResponse_descriptor_, TaskStatsResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ResourceStatsResponse_descriptor_, ResourceStatsResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      TaskUID_descriptor_, TaskUID::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ResourceUID_descriptor_, ResourceUID::internal_default_instance());
}

}  // namespace

void protobuf_ShutdownFile_scheduling_2ffirmament_5fscheduler_2eproto() {
  ScheduleRequest_default_instance_.Shutdown();
  delete ScheduleRequest_reflection_;
  SchedulingDeltas_default_instance_.Shutdown();
  delete SchedulingDeltas_reflection_;
  TaskCompletedResponse_default_instance_.Shutdown();
  delete TaskCompletedResponse_reflection_;
  TaskDescription_default_instance_.Shutdown();
  delete TaskDescription_reflection_;
  TaskSubmittedResponse_default_instance_.Shutdown();
  delete TaskSubmittedResponse_reflection_;
  TaskRemovedResponse_default_instance_.Shutdown();
  delete TaskRemovedResponse_reflection_;
  TaskFailedResponse_default_instance_.Shutdown();
  delete TaskFailedResponse_reflection_;
  TaskUpdatedResponse_default_instance_.Shutdown();
  delete TaskUpdatedResponse_reflection_;
  NodeAddedResponse_default_instance_.Shutdown();
  delete NodeAddedResponse_reflection_;
  NodeRemovedResponse_default_instance_.Shutdown();
  delete NodeRemovedResponse_reflection_;
  NodeFailedResponse_default_instance_.Shutdown();
  delete NodeFailedResponse_reflection_;
  NodeUpdatedResponse_default_instance_.Shutdown();
  delete NodeUpdatedResponse_reflection_;
  TaskStatsResponse_default_instance_.Shutdown();
  delete TaskStatsResponse_reflection_;
  ResourceStatsResponse_default_instance_.Shutdown();
  delete ResourceStatsResponse_reflection_;
  TaskUID_default_instance_.Shutdown();
  delete TaskUID_reflection_;
  ResourceUID_default_instance_.Shutdown();
  delete ResourceUID_reflection_;
}

void protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::firmament::protobuf_InitDefaults_base_2fjob_5fdesc_2eproto();
  ::firmament::protobuf_InitDefaults_base_2fresource_5fstats_2eproto();
  ::firmament::protobuf_InitDefaults_base_2fresource_5ftopology_5fnode_5fdesc_2eproto();
  ::firmament::protobuf_InitDefaults_base_2ftask_5fdesc_2eproto();
  ::firmament::protobuf_InitDefaults_base_2ftask_5fstats_2eproto();
  ::firmament::protobuf_InitDefaults_scheduling_2fscheduling_5fdelta_2eproto();
  ScheduleRequest_default_instance_.DefaultConstruct();
  SchedulingDeltas_default_instance_.DefaultConstruct();
  TaskCompletedResponse_default_instance_.DefaultConstruct();
  TaskDescription_default_instance_.DefaultConstruct();
  TaskSubmittedResponse_default_instance_.DefaultConstruct();
  TaskRemovedResponse_default_instance_.DefaultConstruct();
  TaskFailedResponse_default_instance_.DefaultConstruct();
  TaskUpdatedResponse_default_instance_.DefaultConstruct();
  NodeAddedResponse_default_instance_.DefaultConstruct();
  NodeRemovedResponse_default_instance_.DefaultConstruct();
  NodeFailedResponse_default_instance_.DefaultConstruct();
  NodeUpdatedResponse_default_instance_.DefaultConstruct();
  TaskStatsResponse_default_instance_.DefaultConstruct();
  ResourceStatsResponse_default_instance_.DefaultConstruct();
  TaskUID_default_instance_.DefaultConstruct();
  ::google::protobuf::internal::GetEmptyString();
  ResourceUID_default_instance_.DefaultConstruct();
  ScheduleRequest_default_instance_.get_mutable()->InitAsDefaultInstance();
  SchedulingDeltas_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskCompletedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskDescription_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskSubmittedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskRemovedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskFailedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskUpdatedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  NodeAddedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  NodeRemovedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  NodeFailedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  NodeUpdatedResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskStatsResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  ResourceStatsResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  TaskUID_default_instance_.get_mutable()->InitAsDefaultInstance();
  ResourceUID_default_instance_.get_mutable()->InitAsDefaultInstance();
}

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto_once_);
void protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto_once_,
                 &protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto_impl);
}
void protobuf_AddDesc_scheduling_2ffirmament_5fscheduler_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n$scheduling/firmament_scheduler.proto\022\t"
    "firmament\032\023base/job_desc.proto\032\031base/res"
    "ource_stats.proto\032&base/resource_topolog"
    "y_node_desc.proto\032\024base/task_desc.proto\032"
    "\025base/task_stats.proto\032!scheduling/sched"
    "uling_delta.proto\"\021\n\017ScheduleRequest\">\n\020"
    "SchedulingDeltas\022*\n\006deltas\030\001 \003(\0132\032.firma"
    "ment.SchedulingDelta\"\?\n\025TaskCompletedRes"
    "ponse\022&\n\004type\030\001 \001(\0162\030.firmament.TaskRepl"
    "yType\"w\n\017TaskDescription\0222\n\017task_descrip"
    "tor\030\001 \001(\0132\031.firmament.TaskDescriptor\0220\n\016"
    "job_descriptor\030\002 \001(\0132\030.firmament.JobDesc"
    "riptor\"\?\n\025TaskSubmittedResponse\022&\n\004type\030"
    "\001 \001(\0162\030.firmament.TaskReplyType\"=\n\023TaskR"
    "emovedResponse\022&\n\004type\030\001 \001(\0162\030.firmament"
    ".TaskReplyType\"<\n\022TaskFailedResponse\022&\n\004"
    "type\030\001 \001(\0162\030.firmament.TaskReplyType\"=\n\023"
    "TaskUpdatedResponse\022&\n\004type\030\001 \001(\0162\030.firm"
    "ament.TaskReplyType\";\n\021NodeAddedResponse"
    "\022&\n\004type\030\001 \001(\0162\030.firmament.NodeReplyType"
    "\"=\n\023NodeRemovedResponse\022&\n\004type\030\001 \001(\0162\030."
    "firmament.NodeReplyType\"<\n\022NodeFailedRes"
    "ponse\022&\n\004type\030\001 \001(\0162\030.firmament.NodeRepl"
    "yType\"=\n\023NodeUpdatedResponse\022&\n\004type\030\001 \001"
    "(\0162\030.firmament.NodeReplyType\";\n\021TaskStat"
    "sResponse\022&\n\004type\030\001 \001(\0162\030.firmament.Task"
    "ReplyType\"\?\n\025ResourceStatsResponse\022&\n\004ty"
    "pe\030\001 \001(\0162\030.firmament.NodeReplyType\"\033\n\007Ta"
    "skUID\022\020\n\010task_uid\030\001 \001(\004\"#\n\013ResourceUID\022\024"
    "\n\014resource_uid\030\001 \001(\t*\337\001\n\rTaskReplyType\022\025"
    "\n\021TASK_COMPLETED_OK\020\000\022\025\n\021TASK_SUBMITTED_"
    "OK\020\001\022\023\n\017TASK_REMOVED_OK\020\002\022\022\n\016TASK_FAILED"
    "_OK\020\003\022\023\n\017TASK_UPDATED_OK\020\004\022\022\n\016TASK_NOT_F"
    "OUND\020\005\022\026\n\022TASK_JOB_NOT_FOUND\020\006\022\032\n\026TASK_A"
    "LREADY_SUBMITTED\020\007\022\032\n\026TASK_STATE_NOT_CRE"
    "ATED\020\010*\215\001\n\rNodeReplyType\022\021\n\rNODE_ADDED_O"
    "K\020\000\022\022\n\016NODE_FAILED_OK\020\001\022\023\n\017NODE_REMOVED_"
    "OK\020\002\022\023\n\017NODE_UPDATED_OK\020\003\022\022\n\016NODE_NOT_FO"
    "UND\020\004\022\027\n\023NODE_ALREADY_EXISTS\020\0052\242\007\n\022Firma"
    "mentScheduler\022E\n\010Schedule\022\032.firmament.Sc"
    "heduleRequest\032\033.firmament.SchedulingDelt"
    "as\"\000\022G\n\rTaskCompleted\022\022.firmament.TaskUI"
    "D\032 .firmament.TaskCompletedResponse\"\000\022A\n"
    "\nTaskFailed\022\022.firmament.TaskUID\032\035.firmam"
    "ent.TaskFailedResponse\"\000\022C\n\013TaskRemoved\022"
    "\022.firmament.TaskUID\032\036.firmament.TaskRemo"
    "vedResponse\"\000\022O\n\rTaskSubmitted\022\032.firmame"
    "nt.TaskDescription\032 .firmament.TaskSubmi"
    "ttedResponse\"\000\022K\n\013TaskUpdated\022\032.firmamen"
    "t.TaskDescription\032\036.firmament.TaskUpdate"
    "dResponse\"\000\022V\n\tNodeAdded\022).firmament.Res"
    "ourceTopologyNodeDescriptor\032\034.firmament."
    "NodeAddedResponse\"\000\022E\n\nNodeFailed\022\026.firm"
    "ament.ResourceUID\032\035.firmament.NodeFailed"
    "Response\"\000\022G\n\013NodeRemoved\022\026.firmament.Re"
    "sourceUID\032\036.firmament.NodeRemovedRespons"
    "e\"\000\022Z\n\013NodeUpdated\022).firmament.ResourceT"
    "opologyNodeDescriptor\032\036.firmament.NodeUp"
    "datedResponse\"\000\022D\n\014AddTaskStats\022\024.firmam"
    "ent.TaskStats\032\034.firmament.TaskStatsRespo"
    "nse\"\000\022L\n\014AddNodeStats\022\030.firmament.Resour"
    "ceStats\032 .firmament.ResourceStatsRespons"
    "e\"\000b\006proto3", 2491);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "scheduling/firmament_scheduler.proto", &protobuf_RegisterTypes);
  ::firmament::protobuf_AddDesc_base_2fjob_5fdesc_2eproto();
  ::firmament::protobuf_AddDesc_base_2fresource_5fstats_2eproto();
  ::firmament::protobuf_AddDesc_base_2fresource_5ftopology_5fnode_5fdesc_2eproto();
  ::firmament::protobuf_AddDesc_base_2ftask_5fdesc_2eproto();
  ::firmament::protobuf_AddDesc_base_2ftask_5fstats_2eproto();
  ::firmament::protobuf_AddDesc_scheduling_2fscheduling_5fdelta_2eproto();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_scheduling_2ffirmament_5fscheduler_2eproto);
}

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_scheduling_2ffirmament_5fscheduler_2eproto_once_);
void protobuf_AddDesc_scheduling_2ffirmament_5fscheduler_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_scheduling_2ffirmament_5fscheduler_2eproto_once_,
                 &protobuf_AddDesc_scheduling_2ffirmament_5fscheduler_2eproto_impl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_scheduling_2ffirmament_5fscheduler_2eproto {
  StaticDescriptorInitializer_scheduling_2ffirmament_5fscheduler_2eproto() {
    protobuf_AddDesc_scheduling_2ffirmament_5fscheduler_2eproto();
  }
} static_descriptor_initializer_scheduling_2ffirmament_5fscheduler_2eproto_;
const ::google::protobuf::EnumDescriptor* TaskReplyType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskReplyType_descriptor_;
}
bool TaskReplyType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* NodeReplyType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NodeReplyType_descriptor_;
}
bool NodeReplyType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}


namespace {

static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN;
static void MergeFromFail(int line) {
  ::google::protobuf::internal::MergeFromFail(__FILE__, line);
}

}  // namespace


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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ScheduleRequest::ScheduleRequest()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.ScheduleRequest)
}

void ScheduleRequest::InitAsDefaultInstance() {
}

ScheduleRequest::ScheduleRequest(const ScheduleRequest& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.ScheduleRequest)
}

void ScheduleRequest::SharedCtor() {
  _cached_size_ = 0;
}

ScheduleRequest::~ScheduleRequest() {
  // @@protoc_insertion_point(destructor:firmament.ScheduleRequest)
  SharedDtor();
}

void ScheduleRequest::SharedDtor() {
}

void ScheduleRequest::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ScheduleRequest::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ScheduleRequest_descriptor_;
}

const ScheduleRequest& ScheduleRequest::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<ScheduleRequest> ScheduleRequest_default_instance_;

ScheduleRequest* ScheduleRequest::New(::google::protobuf::Arena* arena) const {
  ScheduleRequest* n = new ScheduleRequest;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ScheduleRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.ScheduleRequest)
}

bool ScheduleRequest::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.ScheduleRequest)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.ScheduleRequest)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.ScheduleRequest)
  return false;
#undef DO_
}

void ScheduleRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.ScheduleRequest)
  // @@protoc_insertion_point(serialize_end:firmament.ScheduleRequest)
}

::google::protobuf::uint8* ScheduleRequest::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.ScheduleRequest)
  // @@protoc_insertion_point(serialize_to_array_end:firmament.ScheduleRequest)
  return target;
}

size_t ScheduleRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.ScheduleRequest)
  size_t total_size = 0;

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ScheduleRequest::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.ScheduleRequest)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ScheduleRequest* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ScheduleRequest>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.ScheduleRequest)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.ScheduleRequest)
    UnsafeMergeFrom(*source);
  }
}

void ScheduleRequest::MergeFrom(const ScheduleRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.ScheduleRequest)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void ScheduleRequest::UnsafeMergeFrom(const ScheduleRequest& from) {
  GOOGLE_DCHECK(&from != this);
}

void ScheduleRequest::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.ScheduleRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ScheduleRequest::CopyFrom(const ScheduleRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.ScheduleRequest)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool ScheduleRequest::IsInitialized() const {

  return true;
}

void ScheduleRequest::Swap(ScheduleRequest* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ScheduleRequest::InternalSwap(ScheduleRequest* other) {
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ScheduleRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ScheduleRequest_descriptor_;
  metadata.reflection = ScheduleRequest_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ScheduleRequest

inline const ScheduleRequest* ScheduleRequest::internal_default_instance() {
  return &ScheduleRequest_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SchedulingDeltas::kDeltasFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SchedulingDeltas::SchedulingDeltas()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.SchedulingDeltas)
}

void SchedulingDeltas::InitAsDefaultInstance() {
}

SchedulingDeltas::SchedulingDeltas(const SchedulingDeltas& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.SchedulingDeltas)
}

void SchedulingDeltas::SharedCtor() {
  _cached_size_ = 0;
}

SchedulingDeltas::~SchedulingDeltas() {
  // @@protoc_insertion_point(destructor:firmament.SchedulingDeltas)
  SharedDtor();
}

void SchedulingDeltas::SharedDtor() {
}

void SchedulingDeltas::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SchedulingDeltas::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SchedulingDeltas_descriptor_;
}

const SchedulingDeltas& SchedulingDeltas::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<SchedulingDeltas> SchedulingDeltas_default_instance_;

SchedulingDeltas* SchedulingDeltas::New(::google::protobuf::Arena* arena) const {
  SchedulingDeltas* n = new SchedulingDeltas;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SchedulingDeltas::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.SchedulingDeltas)
  deltas_.Clear();
}

bool SchedulingDeltas::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.SchedulingDeltas)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .firmament.SchedulingDelta deltas = 1;
      case 1: {
        if (tag == 10) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_deltas:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
                input, add_deltas()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_loop_deltas;
        input->UnsafeDecrementRecursionDepth();
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.SchedulingDeltas)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.SchedulingDeltas)
  return false;
#undef DO_
}

void SchedulingDeltas::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.SchedulingDeltas)
  // repeated .firmament.SchedulingDelta deltas = 1;
  for (unsigned int i = 0, n = this->deltas_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->deltas(i), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.SchedulingDeltas)
}

::google::protobuf::uint8* SchedulingDeltas::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.SchedulingDeltas)
  // repeated .firmament.SchedulingDelta deltas = 1;
  for (unsigned int i = 0, n = this->deltas_size(); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        1, this->deltas(i), false, target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.SchedulingDeltas)
  return target;
}

size_t SchedulingDeltas::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.SchedulingDeltas)
  size_t total_size = 0;

  // repeated .firmament.SchedulingDelta deltas = 1;
  {
    unsigned int count = this->deltas_size();
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->deltas(i));
    }
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SchedulingDeltas::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.SchedulingDeltas)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const SchedulingDeltas* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SchedulingDeltas>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.SchedulingDeltas)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.SchedulingDeltas)
    UnsafeMergeFrom(*source);
  }
}

void SchedulingDeltas::MergeFrom(const SchedulingDeltas& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.SchedulingDeltas)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void SchedulingDeltas::UnsafeMergeFrom(const SchedulingDeltas& from) {
  GOOGLE_DCHECK(&from != this);
  deltas_.MergeFrom(from.deltas_);
}

void SchedulingDeltas::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.SchedulingDeltas)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SchedulingDeltas::CopyFrom(const SchedulingDeltas& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.SchedulingDeltas)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool SchedulingDeltas::IsInitialized() const {

  return true;
}

void SchedulingDeltas::Swap(SchedulingDeltas* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SchedulingDeltas::InternalSwap(SchedulingDeltas* other) {
  deltas_.UnsafeArenaSwap(&other->deltas_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SchedulingDeltas::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SchedulingDeltas_descriptor_;
  metadata.reflection = SchedulingDeltas_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// SchedulingDeltas

// repeated .firmament.SchedulingDelta deltas = 1;
int SchedulingDeltas::deltas_size() const {
  return deltas_.size();
}
void SchedulingDeltas::clear_deltas() {
  deltas_.Clear();
}
const ::firmament::SchedulingDelta& SchedulingDeltas::deltas(int index) const {
  // @@protoc_insertion_point(field_get:firmament.SchedulingDeltas.deltas)
  return deltas_.Get(index);
}
::firmament::SchedulingDelta* SchedulingDeltas::mutable_deltas(int index) {
  // @@protoc_insertion_point(field_mutable:firmament.SchedulingDeltas.deltas)
  return deltas_.Mutable(index);
}
::firmament::SchedulingDelta* SchedulingDeltas::add_deltas() {
  // @@protoc_insertion_point(field_add:firmament.SchedulingDeltas.deltas)
  return deltas_.Add();
}
::google::protobuf::RepeatedPtrField< ::firmament::SchedulingDelta >*
SchedulingDeltas::mutable_deltas() {
  // @@protoc_insertion_point(field_mutable_list:firmament.SchedulingDeltas.deltas)
  return &deltas_;
}
const ::google::protobuf::RepeatedPtrField< ::firmament::SchedulingDelta >&
SchedulingDeltas::deltas() const {
  // @@protoc_insertion_point(field_list:firmament.SchedulingDeltas.deltas)
  return deltas_;
}

inline const SchedulingDeltas* SchedulingDeltas::internal_default_instance() {
  return &SchedulingDeltas_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskCompletedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskCompletedResponse::TaskCompletedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskCompletedResponse)
}

void TaskCompletedResponse::InitAsDefaultInstance() {
}

TaskCompletedResponse::TaskCompletedResponse(const TaskCompletedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskCompletedResponse)
}

void TaskCompletedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

TaskCompletedResponse::~TaskCompletedResponse() {
  // @@protoc_insertion_point(destructor:firmament.TaskCompletedResponse)
  SharedDtor();
}

void TaskCompletedResponse::SharedDtor() {
}

void TaskCompletedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskCompletedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskCompletedResponse_descriptor_;
}

const TaskCompletedResponse& TaskCompletedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskCompletedResponse> TaskCompletedResponse_default_instance_;

TaskCompletedResponse* TaskCompletedResponse::New(::google::protobuf::Arena* arena) const {
  TaskCompletedResponse* n = new TaskCompletedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskCompletedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskCompletedResponse)
  type_ = 0;
}

bool TaskCompletedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskCompletedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.TaskReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::TaskReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskCompletedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskCompletedResponse)
  return false;
#undef DO_
}

void TaskCompletedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskCompletedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskCompletedResponse)
}

::google::protobuf::uint8* TaskCompletedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskCompletedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskCompletedResponse)
  return target;
}

size_t TaskCompletedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskCompletedResponse)
  size_t total_size = 0;

  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskCompletedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskCompletedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskCompletedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskCompletedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskCompletedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskCompletedResponse)
    UnsafeMergeFrom(*source);
  }
}

void TaskCompletedResponse::MergeFrom(const TaskCompletedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskCompletedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskCompletedResponse::UnsafeMergeFrom(const TaskCompletedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void TaskCompletedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskCompletedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskCompletedResponse::CopyFrom(const TaskCompletedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskCompletedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskCompletedResponse::IsInitialized() const {

  return true;
}

void TaskCompletedResponse::Swap(TaskCompletedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskCompletedResponse::InternalSwap(TaskCompletedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskCompletedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskCompletedResponse_descriptor_;
  metadata.reflection = TaskCompletedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskCompletedResponse

// optional .firmament.TaskReplyType type = 1;
void TaskCompletedResponse::clear_type() {
  type_ = 0;
}
::firmament::TaskReplyType TaskCompletedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.TaskCompletedResponse.type)
  return static_cast< ::firmament::TaskReplyType >(type_);
}
void TaskCompletedResponse::set_type(::firmament::TaskReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.TaskCompletedResponse.type)
}

inline const TaskCompletedResponse* TaskCompletedResponse::internal_default_instance() {
  return &TaskCompletedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskDescription::kTaskDescriptorFieldNumber;
const int TaskDescription::kJobDescriptorFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskDescription::TaskDescription()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskDescription)
}

void TaskDescription::InitAsDefaultInstance() {
  task_descriptor_ = const_cast< ::firmament::TaskDescriptor*>(
      ::firmament::TaskDescriptor::internal_default_instance());
  job_descriptor_ = const_cast< ::firmament::JobDescriptor*>(
      ::firmament::JobDescriptor::internal_default_instance());
}

TaskDescription::TaskDescription(const TaskDescription& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskDescription)
}

void TaskDescription::SharedCtor() {
  task_descriptor_ = NULL;
  job_descriptor_ = NULL;
  _cached_size_ = 0;
}

TaskDescription::~TaskDescription() {
  // @@protoc_insertion_point(destructor:firmament.TaskDescription)
  SharedDtor();
}

void TaskDescription::SharedDtor() {
  if (this != &TaskDescription_default_instance_.get()) {
    delete task_descriptor_;
    delete job_descriptor_;
  }
}

void TaskDescription::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskDescription::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskDescription_descriptor_;
}

const TaskDescription& TaskDescription::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskDescription> TaskDescription_default_instance_;

TaskDescription* TaskDescription::New(::google::protobuf::Arena* arena) const {
  TaskDescription* n = new TaskDescription;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskDescription::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskDescription)
  if (GetArenaNoVirtual() == NULL && task_descriptor_ != NULL) delete task_descriptor_;
  task_descriptor_ = NULL;
  if (GetArenaNoVirtual() == NULL && job_descriptor_ != NULL) delete job_descriptor_;
  job_descriptor_ = NULL;
}

bool TaskDescription::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskDescription)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.TaskDescriptor task_descriptor = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_task_descriptor()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_job_descriptor;
        break;
      }

      // optional .firmament.JobDescriptor job_descriptor = 2;
      case 2: {
        if (tag == 18) {
         parse_job_descriptor:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_job_descriptor()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskDescription)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskDescription)
  return false;
#undef DO_
}

void TaskDescription::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskDescription)
  // optional .firmament.TaskDescriptor task_descriptor = 1;
  if (this->has_task_descriptor()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->task_descriptor_, output);
  }

  // optional .firmament.JobDescriptor job_descriptor = 2;
  if (this->has_job_descriptor()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->job_descriptor_, output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskDescription)
}

::google::protobuf::uint8* TaskDescription::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskDescription)
  // optional .firmament.TaskDescriptor task_descriptor = 1;
  if (this->has_task_descriptor()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        1, *this->task_descriptor_, false, target);
  }

  // optional .firmament.JobDescriptor job_descriptor = 2;
  if (this->has_job_descriptor()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        2, *this->job_descriptor_, false, target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskDescription)
  return target;
}

size_t TaskDescription::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskDescription)
  size_t total_size = 0;

  // optional .firmament.TaskDescriptor task_descriptor = 1;
  if (this->has_task_descriptor()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->task_descriptor_);
  }

  // optional .firmament.JobDescriptor job_descriptor = 2;
  if (this->has_job_descriptor()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->job_descriptor_);
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskDescription::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskDescription)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskDescription* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskDescription>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskDescription)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskDescription)
    UnsafeMergeFrom(*source);
  }
}

void TaskDescription::MergeFrom(const TaskDescription& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskDescription)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskDescription::UnsafeMergeFrom(const TaskDescription& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.has_task_descriptor()) {
    mutable_task_descriptor()->::firmament::TaskDescriptor::MergeFrom(from.task_descriptor());
  }
  if (from.has_job_descriptor()) {
    mutable_job_descriptor()->::firmament::JobDescriptor::MergeFrom(from.job_descriptor());
  }
}

void TaskDescription::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskDescription)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskDescription::CopyFrom(const TaskDescription& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskDescription)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskDescription::IsInitialized() const {

  return true;
}

void TaskDescription::Swap(TaskDescription* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskDescription::InternalSwap(TaskDescription* other) {
  std::swap(task_descriptor_, other->task_descriptor_);
  std::swap(job_descriptor_, other->job_descriptor_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskDescription::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskDescription_descriptor_;
  metadata.reflection = TaskDescription_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskDescription

// optional .firmament.TaskDescriptor task_descriptor = 1;
bool TaskDescription::has_task_descriptor() const {
  return this != internal_default_instance() && task_descriptor_ != NULL;
}
void TaskDescription::clear_task_descriptor() {
  if (GetArenaNoVirtual() == NULL && task_descriptor_ != NULL) delete task_descriptor_;
  task_descriptor_ = NULL;
}
const ::firmament::TaskDescriptor& TaskDescription::task_descriptor() const {
  // @@protoc_insertion_point(field_get:firmament.TaskDescription.task_descriptor)
  return task_descriptor_ != NULL ? *task_descriptor_
                         : *::firmament::TaskDescriptor::internal_default_instance();
}
::firmament::TaskDescriptor* TaskDescription::mutable_task_descriptor() {
  
  if (task_descriptor_ == NULL) {
    task_descriptor_ = new ::firmament::TaskDescriptor;
  }
  // @@protoc_insertion_point(field_mutable:firmament.TaskDescription.task_descriptor)
  return task_descriptor_;
}
::firmament::TaskDescriptor* TaskDescription::release_task_descriptor() {
  // @@protoc_insertion_point(field_release:firmament.TaskDescription.task_descriptor)
  
  ::firmament::TaskDescriptor* temp = task_descriptor_;
  task_descriptor_ = NULL;
  return temp;
}
void TaskDescription::set_allocated_task_descriptor(::firmament::TaskDescriptor* task_descriptor) {
  delete task_descriptor_;
  task_descriptor_ = task_descriptor;
  if (task_descriptor) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:firmament.TaskDescription.task_descriptor)
}

// optional .firmament.JobDescriptor job_descriptor = 2;
bool TaskDescription::has_job_descriptor() const {
  return this != internal_default_instance() && job_descriptor_ != NULL;
}
void TaskDescription::clear_job_descriptor() {
  if (GetArenaNoVirtual() == NULL && job_descriptor_ != NULL) delete job_descriptor_;
  job_descriptor_ = NULL;
}
const ::firmament::JobDescriptor& TaskDescription::job_descriptor() const {
  // @@protoc_insertion_point(field_get:firmament.TaskDescription.job_descriptor)
  return job_descriptor_ != NULL ? *job_descriptor_
                         : *::firmament::JobDescriptor::internal_default_instance();
}
::firmament::JobDescriptor* TaskDescription::mutable_job_descriptor() {
  
  if (job_descriptor_ == NULL) {
    job_descriptor_ = new ::firmament::JobDescriptor;
  }
  // @@protoc_insertion_point(field_mutable:firmament.TaskDescription.job_descriptor)
  return job_descriptor_;
}
::firmament::JobDescriptor* TaskDescription::release_job_descriptor() {
  // @@protoc_insertion_point(field_release:firmament.TaskDescription.job_descriptor)
  
  ::firmament::JobDescriptor* temp = job_descriptor_;
  job_descriptor_ = NULL;
  return temp;
}
void TaskDescription::set_allocated_job_descriptor(::firmament::JobDescriptor* job_descriptor) {
  delete job_descriptor_;
  job_descriptor_ = job_descriptor;
  if (job_descriptor) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:firmament.TaskDescription.job_descriptor)
}

inline const TaskDescription* TaskDescription::internal_default_instance() {
  return &TaskDescription_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskSubmittedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskSubmittedResponse::TaskSubmittedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskSubmittedResponse)
}

void TaskSubmittedResponse::InitAsDefaultInstance() {
}

TaskSubmittedResponse::TaskSubmittedResponse(const TaskSubmittedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskSubmittedResponse)
}

void TaskSubmittedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

TaskSubmittedResponse::~TaskSubmittedResponse() {
  // @@protoc_insertion_point(destructor:firmament.TaskSubmittedResponse)
  SharedDtor();
}

void TaskSubmittedResponse::SharedDtor() {
}

void TaskSubmittedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskSubmittedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskSubmittedResponse_descriptor_;
}

const TaskSubmittedResponse& TaskSubmittedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskSubmittedResponse> TaskSubmittedResponse_default_instance_;

TaskSubmittedResponse* TaskSubmittedResponse::New(::google::protobuf::Arena* arena) const {
  TaskSubmittedResponse* n = new TaskSubmittedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskSubmittedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskSubmittedResponse)
  type_ = 0;
}

bool TaskSubmittedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskSubmittedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.TaskReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::TaskReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskSubmittedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskSubmittedResponse)
  return false;
#undef DO_
}

void TaskSubmittedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskSubmittedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskSubmittedResponse)
}

::google::protobuf::uint8* TaskSubmittedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskSubmittedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskSubmittedResponse)
  return target;
}

size_t TaskSubmittedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskSubmittedResponse)
  size_t total_size = 0;

  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskSubmittedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskSubmittedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskSubmittedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskSubmittedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskSubmittedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskSubmittedResponse)
    UnsafeMergeFrom(*source);
  }
}

void TaskSubmittedResponse::MergeFrom(const TaskSubmittedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskSubmittedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskSubmittedResponse::UnsafeMergeFrom(const TaskSubmittedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void TaskSubmittedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskSubmittedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskSubmittedResponse::CopyFrom(const TaskSubmittedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskSubmittedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskSubmittedResponse::IsInitialized() const {

  return true;
}

void TaskSubmittedResponse::Swap(TaskSubmittedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskSubmittedResponse::InternalSwap(TaskSubmittedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskSubmittedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskSubmittedResponse_descriptor_;
  metadata.reflection = TaskSubmittedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskSubmittedResponse

// optional .firmament.TaskReplyType type = 1;
void TaskSubmittedResponse::clear_type() {
  type_ = 0;
}
::firmament::TaskReplyType TaskSubmittedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.TaskSubmittedResponse.type)
  return static_cast< ::firmament::TaskReplyType >(type_);
}
void TaskSubmittedResponse::set_type(::firmament::TaskReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.TaskSubmittedResponse.type)
}

inline const TaskSubmittedResponse* TaskSubmittedResponse::internal_default_instance() {
  return &TaskSubmittedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskRemovedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskRemovedResponse::TaskRemovedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskRemovedResponse)
}

void TaskRemovedResponse::InitAsDefaultInstance() {
}

TaskRemovedResponse::TaskRemovedResponse(const TaskRemovedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskRemovedResponse)
}

void TaskRemovedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

TaskRemovedResponse::~TaskRemovedResponse() {
  // @@protoc_insertion_point(destructor:firmament.TaskRemovedResponse)
  SharedDtor();
}

void TaskRemovedResponse::SharedDtor() {
}

void TaskRemovedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskRemovedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskRemovedResponse_descriptor_;
}

const TaskRemovedResponse& TaskRemovedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskRemovedResponse> TaskRemovedResponse_default_instance_;

TaskRemovedResponse* TaskRemovedResponse::New(::google::protobuf::Arena* arena) const {
  TaskRemovedResponse* n = new TaskRemovedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskRemovedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskRemovedResponse)
  type_ = 0;
}

bool TaskRemovedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskRemovedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.TaskReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::TaskReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskRemovedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskRemovedResponse)
  return false;
#undef DO_
}

void TaskRemovedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskRemovedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskRemovedResponse)
}

::google::protobuf::uint8* TaskRemovedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskRemovedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskRemovedResponse)
  return target;
}

size_t TaskRemovedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskRemovedResponse)
  size_t total_size = 0;

  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskRemovedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskRemovedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskRemovedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskRemovedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskRemovedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskRemovedResponse)
    UnsafeMergeFrom(*source);
  }
}

void TaskRemovedResponse::MergeFrom(const TaskRemovedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskRemovedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskRemovedResponse::UnsafeMergeFrom(const TaskRemovedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void TaskRemovedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskRemovedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskRemovedResponse::CopyFrom(const TaskRemovedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskRemovedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskRemovedResponse::IsInitialized() const {

  return true;
}

void TaskRemovedResponse::Swap(TaskRemovedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskRemovedResponse::InternalSwap(TaskRemovedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskRemovedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskRemovedResponse_descriptor_;
  metadata.reflection = TaskRemovedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskRemovedResponse

// optional .firmament.TaskReplyType type = 1;
void TaskRemovedResponse::clear_type() {
  type_ = 0;
}
::firmament::TaskReplyType TaskRemovedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.TaskRemovedResponse.type)
  return static_cast< ::firmament::TaskReplyType >(type_);
}
void TaskRemovedResponse::set_type(::firmament::TaskReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.TaskRemovedResponse.type)
}

inline const TaskRemovedResponse* TaskRemovedResponse::internal_default_instance() {
  return &TaskRemovedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskFailedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskFailedResponse::TaskFailedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskFailedResponse)
}

void TaskFailedResponse::InitAsDefaultInstance() {
}

TaskFailedResponse::TaskFailedResponse(const TaskFailedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskFailedResponse)
}

void TaskFailedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

TaskFailedResponse::~TaskFailedResponse() {
  // @@protoc_insertion_point(destructor:firmament.TaskFailedResponse)
  SharedDtor();
}

void TaskFailedResponse::SharedDtor() {
}

void TaskFailedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskFailedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskFailedResponse_descriptor_;
}

const TaskFailedResponse& TaskFailedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskFailedResponse> TaskFailedResponse_default_instance_;

TaskFailedResponse* TaskFailedResponse::New(::google::protobuf::Arena* arena) const {
  TaskFailedResponse* n = new TaskFailedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskFailedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskFailedResponse)
  type_ = 0;
}

bool TaskFailedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskFailedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.TaskReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::TaskReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskFailedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskFailedResponse)
  return false;
#undef DO_
}

void TaskFailedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskFailedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskFailedResponse)
}

::google::protobuf::uint8* TaskFailedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskFailedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskFailedResponse)
  return target;
}

size_t TaskFailedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskFailedResponse)
  size_t total_size = 0;

  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskFailedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskFailedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskFailedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskFailedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskFailedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskFailedResponse)
    UnsafeMergeFrom(*source);
  }
}

void TaskFailedResponse::MergeFrom(const TaskFailedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskFailedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskFailedResponse::UnsafeMergeFrom(const TaskFailedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void TaskFailedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskFailedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskFailedResponse::CopyFrom(const TaskFailedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskFailedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskFailedResponse::IsInitialized() const {

  return true;
}

void TaskFailedResponse::Swap(TaskFailedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskFailedResponse::InternalSwap(TaskFailedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskFailedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskFailedResponse_descriptor_;
  metadata.reflection = TaskFailedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskFailedResponse

// optional .firmament.TaskReplyType type = 1;
void TaskFailedResponse::clear_type() {
  type_ = 0;
}
::firmament::TaskReplyType TaskFailedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.TaskFailedResponse.type)
  return static_cast< ::firmament::TaskReplyType >(type_);
}
void TaskFailedResponse::set_type(::firmament::TaskReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.TaskFailedResponse.type)
}

inline const TaskFailedResponse* TaskFailedResponse::internal_default_instance() {
  return &TaskFailedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskUpdatedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskUpdatedResponse::TaskUpdatedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskUpdatedResponse)
}

void TaskUpdatedResponse::InitAsDefaultInstance() {
}

TaskUpdatedResponse::TaskUpdatedResponse(const TaskUpdatedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskUpdatedResponse)
}

void TaskUpdatedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

TaskUpdatedResponse::~TaskUpdatedResponse() {
  // @@protoc_insertion_point(destructor:firmament.TaskUpdatedResponse)
  SharedDtor();
}

void TaskUpdatedResponse::SharedDtor() {
}

void TaskUpdatedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskUpdatedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskUpdatedResponse_descriptor_;
}

const TaskUpdatedResponse& TaskUpdatedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskUpdatedResponse> TaskUpdatedResponse_default_instance_;

TaskUpdatedResponse* TaskUpdatedResponse::New(::google::protobuf::Arena* arena) const {
  TaskUpdatedResponse* n = new TaskUpdatedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskUpdatedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskUpdatedResponse)
  type_ = 0;
}

bool TaskUpdatedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskUpdatedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.TaskReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::TaskReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskUpdatedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskUpdatedResponse)
  return false;
#undef DO_
}

void TaskUpdatedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskUpdatedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskUpdatedResponse)
}

::google::protobuf::uint8* TaskUpdatedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskUpdatedResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskUpdatedResponse)
  return target;
}

size_t TaskUpdatedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskUpdatedResponse)
  size_t total_size = 0;

  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskUpdatedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskUpdatedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskUpdatedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskUpdatedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskUpdatedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskUpdatedResponse)
    UnsafeMergeFrom(*source);
  }
}

void TaskUpdatedResponse::MergeFrom(const TaskUpdatedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskUpdatedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskUpdatedResponse::UnsafeMergeFrom(const TaskUpdatedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void TaskUpdatedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskUpdatedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskUpdatedResponse::CopyFrom(const TaskUpdatedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskUpdatedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskUpdatedResponse::IsInitialized() const {

  return true;
}

void TaskUpdatedResponse::Swap(TaskUpdatedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskUpdatedResponse::InternalSwap(TaskUpdatedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskUpdatedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskUpdatedResponse_descriptor_;
  metadata.reflection = TaskUpdatedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskUpdatedResponse

// optional .firmament.TaskReplyType type = 1;
void TaskUpdatedResponse::clear_type() {
  type_ = 0;
}
::firmament::TaskReplyType TaskUpdatedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.TaskUpdatedResponse.type)
  return static_cast< ::firmament::TaskReplyType >(type_);
}
void TaskUpdatedResponse::set_type(::firmament::TaskReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.TaskUpdatedResponse.type)
}

inline const TaskUpdatedResponse* TaskUpdatedResponse::internal_default_instance() {
  return &TaskUpdatedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NodeAddedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NodeAddedResponse::NodeAddedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.NodeAddedResponse)
}

void NodeAddedResponse::InitAsDefaultInstance() {
}

NodeAddedResponse::NodeAddedResponse(const NodeAddedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.NodeAddedResponse)
}

void NodeAddedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

NodeAddedResponse::~NodeAddedResponse() {
  // @@protoc_insertion_point(destructor:firmament.NodeAddedResponse)
  SharedDtor();
}

void NodeAddedResponse::SharedDtor() {
}

void NodeAddedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NodeAddedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NodeAddedResponse_descriptor_;
}

const NodeAddedResponse& NodeAddedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<NodeAddedResponse> NodeAddedResponse_default_instance_;

NodeAddedResponse* NodeAddedResponse::New(::google::protobuf::Arena* arena) const {
  NodeAddedResponse* n = new NodeAddedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NodeAddedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.NodeAddedResponse)
  type_ = 0;
}

bool NodeAddedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.NodeAddedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.NodeReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::NodeReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.NodeAddedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.NodeAddedResponse)
  return false;
#undef DO_
}

void NodeAddedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.NodeAddedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.NodeAddedResponse)
}

::google::protobuf::uint8* NodeAddedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.NodeAddedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.NodeAddedResponse)
  return target;
}

size_t NodeAddedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.NodeAddedResponse)
  size_t total_size = 0;

  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NodeAddedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.NodeAddedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const NodeAddedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NodeAddedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.NodeAddedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.NodeAddedResponse)
    UnsafeMergeFrom(*source);
  }
}

void NodeAddedResponse::MergeFrom(const NodeAddedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.NodeAddedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void NodeAddedResponse::UnsafeMergeFrom(const NodeAddedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void NodeAddedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.NodeAddedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NodeAddedResponse::CopyFrom(const NodeAddedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.NodeAddedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool NodeAddedResponse::IsInitialized() const {

  return true;
}

void NodeAddedResponse::Swap(NodeAddedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NodeAddedResponse::InternalSwap(NodeAddedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NodeAddedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = NodeAddedResponse_descriptor_;
  metadata.reflection = NodeAddedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// NodeAddedResponse

// optional .firmament.NodeReplyType type = 1;
void NodeAddedResponse::clear_type() {
  type_ = 0;
}
::firmament::NodeReplyType NodeAddedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.NodeAddedResponse.type)
  return static_cast< ::firmament::NodeReplyType >(type_);
}
void NodeAddedResponse::set_type(::firmament::NodeReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.NodeAddedResponse.type)
}

inline const NodeAddedResponse* NodeAddedResponse::internal_default_instance() {
  return &NodeAddedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NodeRemovedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NodeRemovedResponse::NodeRemovedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.NodeRemovedResponse)
}

void NodeRemovedResponse::InitAsDefaultInstance() {
}

NodeRemovedResponse::NodeRemovedResponse(const NodeRemovedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.NodeRemovedResponse)
}

void NodeRemovedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

NodeRemovedResponse::~NodeRemovedResponse() {
  // @@protoc_insertion_point(destructor:firmament.NodeRemovedResponse)
  SharedDtor();
}

void NodeRemovedResponse::SharedDtor() {
}

void NodeRemovedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NodeRemovedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NodeRemovedResponse_descriptor_;
}

const NodeRemovedResponse& NodeRemovedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<NodeRemovedResponse> NodeRemovedResponse_default_instance_;

NodeRemovedResponse* NodeRemovedResponse::New(::google::protobuf::Arena* arena) const {
  NodeRemovedResponse* n = new NodeRemovedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NodeRemovedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.NodeRemovedResponse)
  type_ = 0;
}

bool NodeRemovedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.NodeRemovedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.NodeReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::NodeReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.NodeRemovedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.NodeRemovedResponse)
  return false;
#undef DO_
}

void NodeRemovedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.NodeRemovedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.NodeRemovedResponse)
}

::google::protobuf::uint8* NodeRemovedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.NodeRemovedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.NodeRemovedResponse)
  return target;
}

size_t NodeRemovedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.NodeRemovedResponse)
  size_t total_size = 0;

  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NodeRemovedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.NodeRemovedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const NodeRemovedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NodeRemovedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.NodeRemovedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.NodeRemovedResponse)
    UnsafeMergeFrom(*source);
  }
}

void NodeRemovedResponse::MergeFrom(const NodeRemovedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.NodeRemovedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void NodeRemovedResponse::UnsafeMergeFrom(const NodeRemovedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void NodeRemovedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.NodeRemovedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NodeRemovedResponse::CopyFrom(const NodeRemovedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.NodeRemovedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool NodeRemovedResponse::IsInitialized() const {

  return true;
}

void NodeRemovedResponse::Swap(NodeRemovedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NodeRemovedResponse::InternalSwap(NodeRemovedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NodeRemovedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = NodeRemovedResponse_descriptor_;
  metadata.reflection = NodeRemovedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// NodeRemovedResponse

// optional .firmament.NodeReplyType type = 1;
void NodeRemovedResponse::clear_type() {
  type_ = 0;
}
::firmament::NodeReplyType NodeRemovedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.NodeRemovedResponse.type)
  return static_cast< ::firmament::NodeReplyType >(type_);
}
void NodeRemovedResponse::set_type(::firmament::NodeReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.NodeRemovedResponse.type)
}

inline const NodeRemovedResponse* NodeRemovedResponse::internal_default_instance() {
  return &NodeRemovedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NodeFailedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NodeFailedResponse::NodeFailedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.NodeFailedResponse)
}

void NodeFailedResponse::InitAsDefaultInstance() {
}

NodeFailedResponse::NodeFailedResponse(const NodeFailedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.NodeFailedResponse)
}

void NodeFailedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

NodeFailedResponse::~NodeFailedResponse() {
  // @@protoc_insertion_point(destructor:firmament.NodeFailedResponse)
  SharedDtor();
}

void NodeFailedResponse::SharedDtor() {
}

void NodeFailedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NodeFailedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NodeFailedResponse_descriptor_;
}

const NodeFailedResponse& NodeFailedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<NodeFailedResponse> NodeFailedResponse_default_instance_;

NodeFailedResponse* NodeFailedResponse::New(::google::protobuf::Arena* arena) const {
  NodeFailedResponse* n = new NodeFailedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NodeFailedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.NodeFailedResponse)
  type_ = 0;
}

bool NodeFailedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.NodeFailedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.NodeReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::NodeReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.NodeFailedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.NodeFailedResponse)
  return false;
#undef DO_
}

void NodeFailedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.NodeFailedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.NodeFailedResponse)
}

::google::protobuf::uint8* NodeFailedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.NodeFailedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.NodeFailedResponse)
  return target;
}

size_t NodeFailedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.NodeFailedResponse)
  size_t total_size = 0;

  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NodeFailedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.NodeFailedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const NodeFailedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NodeFailedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.NodeFailedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.NodeFailedResponse)
    UnsafeMergeFrom(*source);
  }
}

void NodeFailedResponse::MergeFrom(const NodeFailedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.NodeFailedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void NodeFailedResponse::UnsafeMergeFrom(const NodeFailedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void NodeFailedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.NodeFailedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NodeFailedResponse::CopyFrom(const NodeFailedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.NodeFailedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool NodeFailedResponse::IsInitialized() const {

  return true;
}

void NodeFailedResponse::Swap(NodeFailedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NodeFailedResponse::InternalSwap(NodeFailedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NodeFailedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = NodeFailedResponse_descriptor_;
  metadata.reflection = NodeFailedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// NodeFailedResponse

// optional .firmament.NodeReplyType type = 1;
void NodeFailedResponse::clear_type() {
  type_ = 0;
}
::firmament::NodeReplyType NodeFailedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.NodeFailedResponse.type)
  return static_cast< ::firmament::NodeReplyType >(type_);
}
void NodeFailedResponse::set_type(::firmament::NodeReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.NodeFailedResponse.type)
}

inline const NodeFailedResponse* NodeFailedResponse::internal_default_instance() {
  return &NodeFailedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int NodeUpdatedResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

NodeUpdatedResponse::NodeUpdatedResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.NodeUpdatedResponse)
}

void NodeUpdatedResponse::InitAsDefaultInstance() {
}

NodeUpdatedResponse::NodeUpdatedResponse(const NodeUpdatedResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.NodeUpdatedResponse)
}

void NodeUpdatedResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

NodeUpdatedResponse::~NodeUpdatedResponse() {
  // @@protoc_insertion_point(destructor:firmament.NodeUpdatedResponse)
  SharedDtor();
}

void NodeUpdatedResponse::SharedDtor() {
}

void NodeUpdatedResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* NodeUpdatedResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NodeUpdatedResponse_descriptor_;
}

const NodeUpdatedResponse& NodeUpdatedResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<NodeUpdatedResponse> NodeUpdatedResponse_default_instance_;

NodeUpdatedResponse* NodeUpdatedResponse::New(::google::protobuf::Arena* arena) const {
  NodeUpdatedResponse* n = new NodeUpdatedResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void NodeUpdatedResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.NodeUpdatedResponse)
  type_ = 0;
}

bool NodeUpdatedResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.NodeUpdatedResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.NodeReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::NodeReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.NodeUpdatedResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.NodeUpdatedResponse)
  return false;
#undef DO_
}

void NodeUpdatedResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.NodeUpdatedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.NodeUpdatedResponse)
}

::google::protobuf::uint8* NodeUpdatedResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.NodeUpdatedResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.NodeUpdatedResponse)
  return target;
}

size_t NodeUpdatedResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.NodeUpdatedResponse)
  size_t total_size = 0;

  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NodeUpdatedResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.NodeUpdatedResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const NodeUpdatedResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const NodeUpdatedResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.NodeUpdatedResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.NodeUpdatedResponse)
    UnsafeMergeFrom(*source);
  }
}

void NodeUpdatedResponse::MergeFrom(const NodeUpdatedResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.NodeUpdatedResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void NodeUpdatedResponse::UnsafeMergeFrom(const NodeUpdatedResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void NodeUpdatedResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.NodeUpdatedResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void NodeUpdatedResponse::CopyFrom(const NodeUpdatedResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.NodeUpdatedResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool NodeUpdatedResponse::IsInitialized() const {

  return true;
}

void NodeUpdatedResponse::Swap(NodeUpdatedResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void NodeUpdatedResponse::InternalSwap(NodeUpdatedResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata NodeUpdatedResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = NodeUpdatedResponse_descriptor_;
  metadata.reflection = NodeUpdatedResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// NodeUpdatedResponse

// optional .firmament.NodeReplyType type = 1;
void NodeUpdatedResponse::clear_type() {
  type_ = 0;
}
::firmament::NodeReplyType NodeUpdatedResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.NodeUpdatedResponse.type)
  return static_cast< ::firmament::NodeReplyType >(type_);
}
void NodeUpdatedResponse::set_type(::firmament::NodeReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.NodeUpdatedResponse.type)
}

inline const NodeUpdatedResponse* NodeUpdatedResponse::internal_default_instance() {
  return &NodeUpdatedResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskStatsResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskStatsResponse::TaskStatsResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskStatsResponse)
}

void TaskStatsResponse::InitAsDefaultInstance() {
}

TaskStatsResponse::TaskStatsResponse(const TaskStatsResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskStatsResponse)
}

void TaskStatsResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

TaskStatsResponse::~TaskStatsResponse() {
  // @@protoc_insertion_point(destructor:firmament.TaskStatsResponse)
  SharedDtor();
}

void TaskStatsResponse::SharedDtor() {
}

void TaskStatsResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskStatsResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskStatsResponse_descriptor_;
}

const TaskStatsResponse& TaskStatsResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskStatsResponse> TaskStatsResponse_default_instance_;

TaskStatsResponse* TaskStatsResponse::New(::google::protobuf::Arena* arena) const {
  TaskStatsResponse* n = new TaskStatsResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskStatsResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskStatsResponse)
  type_ = 0;
}

bool TaskStatsResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskStatsResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.TaskReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::TaskReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskStatsResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskStatsResponse)
  return false;
#undef DO_
}

void TaskStatsResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskStatsResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskStatsResponse)
}

::google::protobuf::uint8* TaskStatsResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskStatsResponse)
  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskStatsResponse)
  return target;
}

size_t TaskStatsResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskStatsResponse)
  size_t total_size = 0;

  // optional .firmament.TaskReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskStatsResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskStatsResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskStatsResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskStatsResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskStatsResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskStatsResponse)
    UnsafeMergeFrom(*source);
  }
}

void TaskStatsResponse::MergeFrom(const TaskStatsResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskStatsResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskStatsResponse::UnsafeMergeFrom(const TaskStatsResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void TaskStatsResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskStatsResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskStatsResponse::CopyFrom(const TaskStatsResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskStatsResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskStatsResponse::IsInitialized() const {

  return true;
}

void TaskStatsResponse::Swap(TaskStatsResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskStatsResponse::InternalSwap(TaskStatsResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskStatsResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskStatsResponse_descriptor_;
  metadata.reflection = TaskStatsResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskStatsResponse

// optional .firmament.TaskReplyType type = 1;
void TaskStatsResponse::clear_type() {
  type_ = 0;
}
::firmament::TaskReplyType TaskStatsResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.TaskStatsResponse.type)
  return static_cast< ::firmament::TaskReplyType >(type_);
}
void TaskStatsResponse::set_type(::firmament::TaskReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.TaskStatsResponse.type)
}

inline const TaskStatsResponse* TaskStatsResponse::internal_default_instance() {
  return &TaskStatsResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ResourceStatsResponse::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ResourceStatsResponse::ResourceStatsResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.ResourceStatsResponse)
}

void ResourceStatsResponse::InitAsDefaultInstance() {
}

ResourceStatsResponse::ResourceStatsResponse(const ResourceStatsResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.ResourceStatsResponse)
}

void ResourceStatsResponse::SharedCtor() {
  type_ = 0;
  _cached_size_ = 0;
}

ResourceStatsResponse::~ResourceStatsResponse() {
  // @@protoc_insertion_point(destructor:firmament.ResourceStatsResponse)
  SharedDtor();
}

void ResourceStatsResponse::SharedDtor() {
}

void ResourceStatsResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ResourceStatsResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ResourceStatsResponse_descriptor_;
}

const ResourceStatsResponse& ResourceStatsResponse::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<ResourceStatsResponse> ResourceStatsResponse_default_instance_;

ResourceStatsResponse* ResourceStatsResponse::New(::google::protobuf::Arena* arena) const {
  ResourceStatsResponse* n = new ResourceStatsResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ResourceStatsResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.ResourceStatsResponse)
  type_ = 0;
}

bool ResourceStatsResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.ResourceStatsResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .firmament.NodeReplyType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_type(static_cast< ::firmament::NodeReplyType >(value));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.ResourceStatsResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.ResourceStatsResponse)
  return false;
#undef DO_
}

void ResourceStatsResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.ResourceStatsResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.ResourceStatsResponse)
}

::google::protobuf::uint8* ResourceStatsResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.ResourceStatsResponse)
  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.ResourceStatsResponse)
  return target;
}

size_t ResourceStatsResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.ResourceStatsResponse)
  size_t total_size = 0;

  // optional .firmament.NodeReplyType type = 1;
  if (this->type() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ResourceStatsResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.ResourceStatsResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ResourceStatsResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ResourceStatsResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.ResourceStatsResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.ResourceStatsResponse)
    UnsafeMergeFrom(*source);
  }
}

void ResourceStatsResponse::MergeFrom(const ResourceStatsResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.ResourceStatsResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void ResourceStatsResponse::UnsafeMergeFrom(const ResourceStatsResponse& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.type() != 0) {
    set_type(from.type());
  }
}

void ResourceStatsResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.ResourceStatsResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResourceStatsResponse::CopyFrom(const ResourceStatsResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.ResourceStatsResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool ResourceStatsResponse::IsInitialized() const {

  return true;
}

void ResourceStatsResponse::Swap(ResourceStatsResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ResourceStatsResponse::InternalSwap(ResourceStatsResponse* other) {
  std::swap(type_, other->type_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ResourceStatsResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ResourceStatsResponse_descriptor_;
  metadata.reflection = ResourceStatsResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ResourceStatsResponse

// optional .firmament.NodeReplyType type = 1;
void ResourceStatsResponse::clear_type() {
  type_ = 0;
}
::firmament::NodeReplyType ResourceStatsResponse::type() const {
  // @@protoc_insertion_point(field_get:firmament.ResourceStatsResponse.type)
  return static_cast< ::firmament::NodeReplyType >(type_);
}
void ResourceStatsResponse::set_type(::firmament::NodeReplyType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:firmament.ResourceStatsResponse.type)
}

inline const ResourceStatsResponse* ResourceStatsResponse::internal_default_instance() {
  return &ResourceStatsResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TaskUID::kTaskUidFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TaskUID::TaskUID()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.TaskUID)
}

void TaskUID::InitAsDefaultInstance() {
}

TaskUID::TaskUID(const TaskUID& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.TaskUID)
}

void TaskUID::SharedCtor() {
  task_uid_ = GOOGLE_ULONGLONG(0);
  _cached_size_ = 0;
}

TaskUID::~TaskUID() {
  // @@protoc_insertion_point(destructor:firmament.TaskUID)
  SharedDtor();
}

void TaskUID::SharedDtor() {
}

void TaskUID::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* TaskUID::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return TaskUID_descriptor_;
}

const TaskUID& TaskUID::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<TaskUID> TaskUID_default_instance_;

TaskUID* TaskUID::New(::google::protobuf::Arena* arena) const {
  TaskUID* n = new TaskUID;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void TaskUID::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.TaskUID)
  task_uid_ = GOOGLE_ULONGLONG(0);
}

bool TaskUID::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.TaskUID)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 task_uid = 1;
      case 1: {
        if (tag == 8) {

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &task_uid_)));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.TaskUID)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.TaskUID)
  return false;
#undef DO_
}

void TaskUID::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.TaskUID)
  // optional uint64 task_uid = 1;
  if (this->task_uid() != 0) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->task_uid(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.TaskUID)
}

::google::protobuf::uint8* TaskUID::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.TaskUID)
  // optional uint64 task_uid = 1;
  if (this->task_uid() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->task_uid(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.TaskUID)
  return target;
}

size_t TaskUID::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.TaskUID)
  size_t total_size = 0;

  // optional uint64 task_uid = 1;
  if (this->task_uid() != 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt64Size(
        this->task_uid());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TaskUID::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.TaskUID)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const TaskUID* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TaskUID>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.TaskUID)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.TaskUID)
    UnsafeMergeFrom(*source);
  }
}

void TaskUID::MergeFrom(const TaskUID& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.TaskUID)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void TaskUID::UnsafeMergeFrom(const TaskUID& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.task_uid() != 0) {
    set_task_uid(from.task_uid());
  }
}

void TaskUID::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.TaskUID)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TaskUID::CopyFrom(const TaskUID& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.TaskUID)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool TaskUID::IsInitialized() const {

  return true;
}

void TaskUID::Swap(TaskUID* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TaskUID::InternalSwap(TaskUID* other) {
  std::swap(task_uid_, other->task_uid_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata TaskUID::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = TaskUID_descriptor_;
  metadata.reflection = TaskUID_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// TaskUID

// optional uint64 task_uid = 1;
void TaskUID::clear_task_uid() {
  task_uid_ = GOOGLE_ULONGLONG(0);
}
::google::protobuf::uint64 TaskUID::task_uid() const {
  // @@protoc_insertion_point(field_get:firmament.TaskUID.task_uid)
  return task_uid_;
}
void TaskUID::set_task_uid(::google::protobuf::uint64 value) {
  
  task_uid_ = value;
  // @@protoc_insertion_point(field_set:firmament.TaskUID.task_uid)
}

inline const TaskUID* TaskUID::internal_default_instance() {
  return &TaskUID_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ResourceUID::kResourceUidFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ResourceUID::ResourceUID()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:firmament.ResourceUID)
}

void ResourceUID::InitAsDefaultInstance() {
}

ResourceUID::ResourceUID(const ResourceUID& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:firmament.ResourceUID)
}

void ResourceUID::SharedCtor() {
  resource_uid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  _cached_size_ = 0;
}

ResourceUID::~ResourceUID() {
  // @@protoc_insertion_point(destructor:firmament.ResourceUID)
  SharedDtor();
}

void ResourceUID::SharedDtor() {
  resource_uid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void ResourceUID::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ResourceUID::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ResourceUID_descriptor_;
}

const ResourceUID& ResourceUID::default_instance() {
  protobuf_InitDefaults_scheduling_2ffirmament_5fscheduler_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<ResourceUID> ResourceUID_default_instance_;

ResourceUID* ResourceUID::New(::google::protobuf::Arena* arena) const {
  ResourceUID* n = new ResourceUID;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ResourceUID::Clear() {
// @@protoc_insertion_point(message_clear_start:firmament.ResourceUID)
  resource_uid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

bool ResourceUID::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:firmament.ResourceUID)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string resource_uid = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_resource_uid()));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            this->resource_uid().data(), this->resource_uid().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "firmament.ResourceUID.resource_uid"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:firmament.ResourceUID)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:firmament.ResourceUID)
  return false;
#undef DO_
}

void ResourceUID::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:firmament.ResourceUID)
  // optional string resource_uid = 1;
  if (this->resource_uid().size() > 0) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->resource_uid().data(), this->resource_uid().length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "firmament.ResourceUID.resource_uid");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->resource_uid(), output);
  }

  // @@protoc_insertion_point(serialize_end:firmament.ResourceUID)
}

::google::protobuf::uint8* ResourceUID::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:firmament.ResourceUID)
  // optional string resource_uid = 1;
  if (this->resource_uid().size() > 0) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->resource_uid().data(), this->resource_uid().length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "firmament.ResourceUID.resource_uid");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->resource_uid(), target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:firmament.ResourceUID)
  return target;
}

size_t ResourceUID::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:firmament.ResourceUID)
  size_t total_size = 0;

  // optional string resource_uid = 1;
  if (this->resource_uid().size() > 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->resource_uid());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ResourceUID::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:firmament.ResourceUID)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ResourceUID* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ResourceUID>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:firmament.ResourceUID)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:firmament.ResourceUID)
    UnsafeMergeFrom(*source);
  }
}

void ResourceUID::MergeFrom(const ResourceUID& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:firmament.ResourceUID)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void ResourceUID::UnsafeMergeFrom(const ResourceUID& from) {
  GOOGLE_DCHECK(&from != this);
  if (from.resource_uid().size() > 0) {

    resource_uid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.resource_uid_);
  }
}

void ResourceUID::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:firmament.ResourceUID)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ResourceUID::CopyFrom(const ResourceUID& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:firmament.ResourceUID)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool ResourceUID::IsInitialized() const {

  return true;
}

void ResourceUID::Swap(ResourceUID* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ResourceUID::InternalSwap(ResourceUID* other) {
  resource_uid_.Swap(&other->resource_uid_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ResourceUID::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ResourceUID_descriptor_;
  metadata.reflection = ResourceUID_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ResourceUID

// optional string resource_uid = 1;
void ResourceUID::clear_resource_uid() {
  resource_uid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
const ::std::string& ResourceUID::resource_uid() const {
  // @@protoc_insertion_point(field_get:firmament.ResourceUID.resource_uid)
  return resource_uid_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceUID::set_resource_uid(const ::std::string& value) {
  
  resource_uid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:firmament.ResourceUID.resource_uid)
}
void ResourceUID::set_resource_uid(const char* value) {
  
  resource_uid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:firmament.ResourceUID.resource_uid)
}
void ResourceUID::set_resource_uid(const char* value, size_t size) {
  
  resource_uid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:firmament.ResourceUID.resource_uid)
}
::std::string* ResourceUID::mutable_resource_uid() {
  
  // @@protoc_insertion_point(field_mutable:firmament.ResourceUID.resource_uid)
  return resource_uid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ResourceUID::release_resource_uid() {
  // @@protoc_insertion_point(field_release:firmament.ResourceUID.resource_uid)
  
  return resource_uid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResourceUID::set_allocated_resource_uid(::std::string* resource_uid) {
  if (resource_uid != NULL) {
    
  } else {
    
  }
  resource_uid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), resource_uid);
  // @@protoc_insertion_point(field_set_allocated:firmament.ResourceUID.resource_uid)
}

inline const ResourceUID* ResourceUID::internal_default_instance() {
  return &ResourceUID_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace firmament

// @@protoc_insertion_point(global_scope)
