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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "metrics.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.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 io {
namespace prometheus {
namespace client {

namespace {

const ::google::protobuf::Descriptor* LabelPair_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  LabelPair_reflection_ = NULL;
const ::google::protobuf::Descriptor* Gauge_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Gauge_reflection_ = NULL;
const ::google::protobuf::Descriptor* Counter_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Counter_reflection_ = NULL;
const ::google::protobuf::Descriptor* Quantile_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Quantile_reflection_ = NULL;
const ::google::protobuf::Descriptor* Summary_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Summary_reflection_ = NULL;
const ::google::protobuf::Descriptor* Untyped_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Untyped_reflection_ = NULL;
const ::google::protobuf::Descriptor* Histogram_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Histogram_reflection_ = NULL;
const ::google::protobuf::Descriptor* Bucket_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Bucket_reflection_ = NULL;
const ::google::protobuf::Descriptor* Metric_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Metric_reflection_ = NULL;
const ::google::protobuf::Descriptor* MetricFamily_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  MetricFamily_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* MetricType_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_metrics_2eproto() {
  protobuf_AddDesc_metrics_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "metrics.proto");
  GOOGLE_CHECK(file != NULL);
  LabelPair_descriptor_ = file->message_type(0);
  static const int LabelPair_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LabelPair, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LabelPair, value_),
  };
  LabelPair_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      LabelPair_descriptor_,
      LabelPair::default_instance_,
      LabelPair_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LabelPair, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LabelPair, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(LabelPair));
  Gauge_descriptor_ = file->message_type(1);
  static const int Gauge_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Gauge, value_),
  };
  Gauge_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Gauge_descriptor_,
      Gauge::default_instance_,
      Gauge_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Gauge, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Gauge, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Gauge));
  Counter_descriptor_ = file->message_type(2);
  static const int Counter_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Counter, value_),
  };
  Counter_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Counter_descriptor_,
      Counter::default_instance_,
      Counter_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Counter, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Counter, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Counter));
  Quantile_descriptor_ = file->message_type(3);
  static const int Quantile_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Quantile, quantile_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Quantile, value_),
  };
  Quantile_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Quantile_descriptor_,
      Quantile::default_instance_,
      Quantile_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Quantile, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Quantile, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Quantile));
  Summary_descriptor_ = file->message_type(4);
  static const int Summary_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Summary, sample_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Summary, sample_sum_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Summary, quantile_),
  };
  Summary_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Summary_descriptor_,
      Summary::default_instance_,
      Summary_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Summary, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Summary, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Summary));
  Untyped_descriptor_ = file->message_type(5);
  static const int Untyped_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Untyped, value_),
  };
  Untyped_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Untyped_descriptor_,
      Untyped::default_instance_,
      Untyped_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Untyped, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Untyped, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Untyped));
  Histogram_descriptor_ = file->message_type(6);
  static const int Histogram_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Histogram, sample_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Histogram, sample_sum_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Histogram, bucket_),
  };
  Histogram_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Histogram_descriptor_,
      Histogram::default_instance_,
      Histogram_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Histogram, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Histogram, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Histogram));
  Bucket_descriptor_ = file->message_type(7);
  static const int Bucket_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Bucket, cumulative_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Bucket, upper_bound_),
  };
  Bucket_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Bucket_descriptor_,
      Bucket::default_instance_,
      Bucket_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Bucket, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Bucket, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Bucket));
  Metric_descriptor_ = file->message_type(8);
  static const int Metric_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, label_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, gauge_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, counter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, summary_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, untyped_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, histogram_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, timestamp_ms_),
  };
  Metric_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Metric_descriptor_,
      Metric::default_instance_,
      Metric_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metric, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Metric));
  MetricFamily_descriptor_ = file->message_type(9);
  static const int MetricFamily_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricFamily, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricFamily, help_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricFamily, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricFamily, metric_),
  };
  MetricFamily_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      MetricFamily_descriptor_,
      MetricFamily::default_instance_,
      MetricFamily_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricFamily, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MetricFamily, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(MetricFamily));
  MetricType_descriptor_ = file->enum_type(0);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    LabelPair_descriptor_, &LabelPair::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Gauge_descriptor_, &Gauge::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Counter_descriptor_, &Counter::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Quantile_descriptor_, &Quantile::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Summary_descriptor_, &Summary::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Untyped_descriptor_, &Untyped::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Histogram_descriptor_, &Histogram::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Bucket_descriptor_, &Bucket::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Metric_descriptor_, &Metric::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    MetricFamily_descriptor_, &MetricFamily::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_metrics_2eproto() {
  delete LabelPair::default_instance_;
  delete LabelPair_reflection_;
  delete Gauge::default_instance_;
  delete Gauge_reflection_;
  delete Counter::default_instance_;
  delete Counter_reflection_;
  delete Quantile::default_instance_;
  delete Quantile_reflection_;
  delete Summary::default_instance_;
  delete Summary_reflection_;
  delete Untyped::default_instance_;
  delete Untyped_reflection_;
  delete Histogram::default_instance_;
  delete Histogram_reflection_;
  delete Bucket::default_instance_;
  delete Bucket_reflection_;
  delete Metric::default_instance_;
  delete Metric_reflection_;
  delete MetricFamily::default_instance_;
  delete MetricFamily_reflection_;
}

void protobuf_AddDesc_metrics_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\rmetrics.proto\022\024io.prometheus.client\"(\n"
    "\tLabelPair\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\""
    "\026\n\005Gauge\022\r\n\005value\030\001 \001(\001\"\030\n\007Counter\022\r\n\005va"
    "lue\030\001 \001(\001\"+\n\010Quantile\022\020\n\010quantile\030\001 \001(\001\022"
    "\r\n\005value\030\002 \001(\001\"e\n\007Summary\022\024\n\014sample_coun"
    "t\030\001 \001(\004\022\022\n\nsample_sum\030\002 \001(\001\0220\n\010quantile\030"
    "\003 \003(\0132\036.io.prometheus.client.Quantile\"\030\n"
    "\007Untyped\022\r\n\005value\030\001 \001(\001\"c\n\tHistogram\022\024\n\014"
    "sample_count\030\001 \001(\004\022\022\n\nsample_sum\030\002 \001(\001\022,"
    "\n\006bucket\030\003 \003(\0132\034.io.prometheus.client.Bu"
    "cket\"7\n\006Bucket\022\030\n\020cumulative_count\030\001 \001(\004"
    "\022\023\n\013upper_bound\030\002 \001(\001\"\276\002\n\006Metric\022.\n\005labe"
    "l\030\001 \003(\0132\037.io.prometheus.client.LabelPair"
    "\022*\n\005gauge\030\002 \001(\0132\033.io.prometheus.client.G"
    "auge\022.\n\007counter\030\003 \001(\0132\035.io.prometheus.cl"
    "ient.Counter\022.\n\007summary\030\004 \001(\0132\035.io.prome"
    "theus.client.Summary\022.\n\007untyped\030\005 \001(\0132\035."
    "io.prometheus.client.Untyped\0222\n\thistogra"
    "m\030\007 \001(\0132\037.io.prometheus.client.Histogram"
    "\022\024\n\014timestamp_ms\030\006 \001(\003\"\210\001\n\014MetricFamily\022"
    "\014\n\004name\030\001 \001(\t\022\014\n\004help\030\002 \001(\t\022.\n\004type\030\003 \001("
    "\0162 .io.prometheus.client.MetricType\022,\n\006m"
    "etric\030\004 \003(\0132\034.io.prometheus.client.Metri"
    "c*M\n\nMetricType\022\013\n\007COUNTER\020\000\022\t\n\005GAUGE\020\001\022"
    "\013\n\007SUMMARY\020\002\022\013\n\007UNTYPED\020\003\022\r\n\tHISTOGRAM\020\004"
    "B\026\n\024io.prometheus.client", 1024);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "metrics.proto", &protobuf_RegisterTypes);
  LabelPair::default_instance_ = new LabelPair();
  Gauge::default_instance_ = new Gauge();
  Counter::default_instance_ = new Counter();
  Quantile::default_instance_ = new Quantile();
  Summary::default_instance_ = new Summary();
  Untyped::default_instance_ = new Untyped();
  Histogram::default_instance_ = new Histogram();
  Bucket::default_instance_ = new Bucket();
  Metric::default_instance_ = new Metric();
  MetricFamily::default_instance_ = new MetricFamily();
  LabelPair::default_instance_->InitAsDefaultInstance();
  Gauge::default_instance_->InitAsDefaultInstance();
  Counter::default_instance_->InitAsDefaultInstance();
  Quantile::default_instance_->InitAsDefaultInstance();
  Summary::default_instance_->InitAsDefaultInstance();
  Untyped::default_instance_->InitAsDefaultInstance();
  Histogram::default_instance_->InitAsDefaultInstance();
  Bucket::default_instance_->InitAsDefaultInstance();
  Metric::default_instance_->InitAsDefaultInstance();
  MetricFamily::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_metrics_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_metrics_2eproto {
  StaticDescriptorInitializer_metrics_2eproto() {
    protobuf_AddDesc_metrics_2eproto();
  }
} static_descriptor_initializer_metrics_2eproto_;
const ::google::protobuf::EnumDescriptor* MetricType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MetricType_descriptor_;
}
bool MetricType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int LabelPair::kNameFieldNumber;
const int LabelPair::kValueFieldNumber;
#endif  // !_MSC_VER

LabelPair::LabelPair()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.LabelPair)
}

void LabelPair::InitAsDefaultInstance() {
}

LabelPair::LabelPair(const LabelPair& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.LabelPair)
}

void LabelPair::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LabelPair::~LabelPair() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.LabelPair)
  SharedDtor();
}

void LabelPair::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete value_;
  }
  if (this != default_instance_) {
  }
}

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

const LabelPair& LabelPair::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

LabelPair* LabelPair::default_instance_ = NULL;

LabelPair* LabelPair::New() const {
  return new LabelPair;
}

void LabelPair::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
    if (has_value()) {
      if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        value_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool LabelPair::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.LabelPair)
  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 name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_value;
        break;
      }

      // optional string value = 2;
      case 2: {
        if (tag == 18) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->value().data(), this->value().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.LabelPair)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.LabelPair)
  return false;
#undef DO_
}

void LabelPair::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.LabelPair)
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional string value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "value");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.LabelPair)
}

::google::protobuf::uint8* LabelPair::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.LabelPair)
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional string value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "value");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.LabelPair)
  return target;
}

int LabelPair::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string value = 2;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->value());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LabelPair::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const LabelPair* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const LabelPair*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void LabelPair::MergeFrom(const LabelPair& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void LabelPair::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LabelPair::CopyFrom(const LabelPair& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LabelPair::IsInitialized() const {

  return true;
}

void LabelPair::Swap(LabelPair* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(value_, other->value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata LabelPair::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = LabelPair_descriptor_;
  metadata.reflection = LabelPair_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Gauge::kValueFieldNumber;
#endif  // !_MSC_VER

Gauge::Gauge()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Gauge)
}

void Gauge::InitAsDefaultInstance() {
}

Gauge::Gauge(const Gauge& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Gauge)
}

void Gauge::SharedCtor() {
  _cached_size_ = 0;
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Gauge::~Gauge() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Gauge)
  SharedDtor();
}

void Gauge::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const Gauge& Gauge::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Gauge* Gauge::default_instance_ = NULL;

Gauge* Gauge::New() const {
  return new Gauge;
}

void Gauge::Clear() {
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Gauge::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Gauge)
  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 double value = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &value_)));
          set_has_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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Gauge)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Gauge)
  return false;
#undef DO_
}

void Gauge::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Gauge)
  // optional double value = 1;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Gauge)
}

::google::protobuf::uint8* Gauge::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Gauge)
  // optional double value = 1;
  if (has_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Gauge)
  return target;
}

int Gauge::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional double value = 1;
    if (has_value()) {
      total_size += 1 + 8;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Gauge::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Gauge* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Gauge*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Gauge::MergeFrom(const Gauge& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Gauge::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Gauge::CopyFrom(const Gauge& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Gauge::IsInitialized() const {

  return true;
}

void Gauge::Swap(Gauge* other) {
  if (other != this) {
    std::swap(value_, other->value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Gauge::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Gauge_descriptor_;
  metadata.reflection = Gauge_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Counter::kValueFieldNumber;
#endif  // !_MSC_VER

Counter::Counter()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Counter)
}

void Counter::InitAsDefaultInstance() {
}

Counter::Counter(const Counter& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Counter)
}

void Counter::SharedCtor() {
  _cached_size_ = 0;
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Counter::~Counter() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Counter)
  SharedDtor();
}

void Counter::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const Counter& Counter::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Counter* Counter::default_instance_ = NULL;

Counter* Counter::New() const {
  return new Counter;
}

void Counter::Clear() {
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Counter::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Counter)
  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 double value = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &value_)));
          set_has_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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Counter)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Counter)
  return false;
#undef DO_
}

void Counter::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Counter)
  // optional double value = 1;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Counter)
}

::google::protobuf::uint8* Counter::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Counter)
  // optional double value = 1;
  if (has_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Counter)
  return target;
}

int Counter::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional double value = 1;
    if (has_value()) {
      total_size += 1 + 8;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Counter::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Counter* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Counter*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Counter::MergeFrom(const Counter& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Counter::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Counter::CopyFrom(const Counter& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Counter::IsInitialized() const {

  return true;
}

void Counter::Swap(Counter* other) {
  if (other != this) {
    std::swap(value_, other->value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Counter::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Counter_descriptor_;
  metadata.reflection = Counter_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Quantile::kQuantileFieldNumber;
const int Quantile::kValueFieldNumber;
#endif  // !_MSC_VER

Quantile::Quantile()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Quantile)
}

void Quantile::InitAsDefaultInstance() {
}

Quantile::Quantile(const Quantile& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Quantile)
}

void Quantile::SharedCtor() {
  _cached_size_ = 0;
  quantile_ = 0;
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Quantile::~Quantile() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Quantile)
  SharedDtor();
}

void Quantile::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const Quantile& Quantile::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Quantile* Quantile::default_instance_ = NULL;

Quantile* Quantile::New() const {
  return new Quantile;
}

void Quantile::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<Quantile*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(quantile_, value_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Quantile::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Quantile)
  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 double quantile = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &quantile_)));
          set_has_quantile();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_value;
        break;
      }

      // optional double value = 2;
      case 2: {
        if (tag == 17) {
         parse_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &value_)));
          set_has_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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Quantile)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Quantile)
  return false;
#undef DO_
}

void Quantile::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Quantile)
  // optional double quantile = 1;
  if (has_quantile()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->quantile(), output);
  }

  // optional double value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Quantile)
}

::google::protobuf::uint8* Quantile::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Quantile)
  // optional double quantile = 1;
  if (has_quantile()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->quantile(), target);
  }

  // optional double value = 2;
  if (has_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Quantile)
  return target;
}

int Quantile::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional double quantile = 1;
    if (has_quantile()) {
      total_size += 1 + 8;
    }

    // optional double value = 2;
    if (has_value()) {
      total_size += 1 + 8;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Quantile::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Quantile* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Quantile*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Quantile::MergeFrom(const Quantile& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_quantile()) {
      set_quantile(from.quantile());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Quantile::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Quantile::CopyFrom(const Quantile& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Quantile::IsInitialized() const {

  return true;
}

void Quantile::Swap(Quantile* other) {
  if (other != this) {
    std::swap(quantile_, other->quantile_);
    std::swap(value_, other->value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Quantile::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Quantile_descriptor_;
  metadata.reflection = Quantile_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Summary::kSampleCountFieldNumber;
const int Summary::kSampleSumFieldNumber;
const int Summary::kQuantileFieldNumber;
#endif  // !_MSC_VER

Summary::Summary()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Summary)
}

void Summary::InitAsDefaultInstance() {
}

Summary::Summary(const Summary& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Summary)
}

void Summary::SharedCtor() {
  _cached_size_ = 0;
  sample_count_ = GOOGLE_ULONGLONG(0);
  sample_sum_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Summary::~Summary() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Summary)
  SharedDtor();
}

void Summary::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const Summary& Summary::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Summary* Summary::default_instance_ = NULL;

Summary* Summary::New() const {
  return new Summary;
}

void Summary::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<Summary*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(sample_count_, sample_sum_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  quantile_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Summary::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Summary)
  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 sample_count = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &sample_count_)));
          set_has_sample_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_sample_sum;
        break;
      }

      // optional double sample_sum = 2;
      case 2: {
        if (tag == 17) {
         parse_sample_sum:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &sample_sum_)));
          set_has_sample_sum();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_quantile;
        break;
      }

      // repeated .io.prometheus.client.Quantile quantile = 3;
      case 3: {
        if (tag == 26) {
         parse_quantile:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_quantile()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_quantile;
        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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Summary)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Summary)
  return false;
#undef DO_
}

void Summary::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Summary)
  // optional uint64 sample_count = 1;
  if (has_sample_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->sample_count(), output);
  }

  // optional double sample_sum = 2;
  if (has_sample_sum()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->sample_sum(), output);
  }

  // repeated .io.prometheus.client.Quantile quantile = 3;
  for (int i = 0; i < this->quantile_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->quantile(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Summary)
}

::google::protobuf::uint8* Summary::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Summary)
  // optional uint64 sample_count = 1;
  if (has_sample_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->sample_count(), target);
  }

  // optional double sample_sum = 2;
  if (has_sample_sum()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->sample_sum(), target);
  }

  // repeated .io.prometheus.client.Quantile quantile = 3;
  for (int i = 0; i < this->quantile_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->quantile(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Summary)
  return target;
}

int Summary::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional uint64 sample_count = 1;
    if (has_sample_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->sample_count());
    }

    // optional double sample_sum = 2;
    if (has_sample_sum()) {
      total_size += 1 + 8;
    }

  }
  // repeated .io.prometheus.client.Quantile quantile = 3;
  total_size += 1 * this->quantile_size();
  for (int i = 0; i < this->quantile_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->quantile(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Summary::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Summary* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Summary*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Summary::MergeFrom(const Summary& from) {
  GOOGLE_CHECK_NE(&from, this);
  quantile_.MergeFrom(from.quantile_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_sample_count()) {
      set_sample_count(from.sample_count());
    }
    if (from.has_sample_sum()) {
      set_sample_sum(from.sample_sum());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Summary::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Summary::CopyFrom(const Summary& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Summary::IsInitialized() const {

  return true;
}

void Summary::Swap(Summary* other) {
  if (other != this) {
    std::swap(sample_count_, other->sample_count_);
    std::swap(sample_sum_, other->sample_sum_);
    quantile_.Swap(&other->quantile_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Summary::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Summary_descriptor_;
  metadata.reflection = Summary_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Untyped::kValueFieldNumber;
#endif  // !_MSC_VER

Untyped::Untyped()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Untyped)
}

void Untyped::InitAsDefaultInstance() {
}

Untyped::Untyped(const Untyped& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Untyped)
}

void Untyped::SharedCtor() {
  _cached_size_ = 0;
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Untyped::~Untyped() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Untyped)
  SharedDtor();
}

void Untyped::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const Untyped& Untyped::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Untyped* Untyped::default_instance_ = NULL;

Untyped* Untyped::New() const {
  return new Untyped;
}

void Untyped::Clear() {
  value_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Untyped::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Untyped)
  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 double value = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &value_)));
          set_has_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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Untyped)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Untyped)
  return false;
#undef DO_
}

void Untyped::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Untyped)
  // optional double value = 1;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Untyped)
}

::google::protobuf::uint8* Untyped::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Untyped)
  // optional double value = 1;
  if (has_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Untyped)
  return target;
}

int Untyped::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional double value = 1;
    if (has_value()) {
      total_size += 1 + 8;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Untyped::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Untyped* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Untyped*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Untyped::MergeFrom(const Untyped& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Untyped::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Untyped::CopyFrom(const Untyped& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Untyped::IsInitialized() const {

  return true;
}

void Untyped::Swap(Untyped* other) {
  if (other != this) {
    std::swap(value_, other->value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Untyped::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Untyped_descriptor_;
  metadata.reflection = Untyped_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Histogram::kSampleCountFieldNumber;
const int Histogram::kSampleSumFieldNumber;
const int Histogram::kBucketFieldNumber;
#endif  // !_MSC_VER

Histogram::Histogram()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Histogram)
}

void Histogram::InitAsDefaultInstance() {
}

Histogram::Histogram(const Histogram& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Histogram)
}

void Histogram::SharedCtor() {
  _cached_size_ = 0;
  sample_count_ = GOOGLE_ULONGLONG(0);
  sample_sum_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Histogram::~Histogram() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Histogram)
  SharedDtor();
}

void Histogram::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const Histogram& Histogram::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Histogram* Histogram::default_instance_ = NULL;

Histogram* Histogram::New() const {
  return new Histogram;
}

void Histogram::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<Histogram*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(sample_count_, sample_sum_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  bucket_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Histogram::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Histogram)
  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 sample_count = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &sample_count_)));
          set_has_sample_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_sample_sum;
        break;
      }

      // optional double sample_sum = 2;
      case 2: {
        if (tag == 17) {
         parse_sample_sum:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &sample_sum_)));
          set_has_sample_sum();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_bucket;
        break;
      }

      // repeated .io.prometheus.client.Bucket bucket = 3;
      case 3: {
        if (tag == 26) {
         parse_bucket:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_bucket()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_bucket;
        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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Histogram)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Histogram)
  return false;
#undef DO_
}

void Histogram::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Histogram)
  // optional uint64 sample_count = 1;
  if (has_sample_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->sample_count(), output);
  }

  // optional double sample_sum = 2;
  if (has_sample_sum()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->sample_sum(), output);
  }

  // repeated .io.prometheus.client.Bucket bucket = 3;
  for (int i = 0; i < this->bucket_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->bucket(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Histogram)
}

::google::protobuf::uint8* Histogram::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Histogram)
  // optional uint64 sample_count = 1;
  if (has_sample_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->sample_count(), target);
  }

  // optional double sample_sum = 2;
  if (has_sample_sum()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->sample_sum(), target);
  }

  // repeated .io.prometheus.client.Bucket bucket = 3;
  for (int i = 0; i < this->bucket_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->bucket(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Histogram)
  return target;
}

int Histogram::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional uint64 sample_count = 1;
    if (has_sample_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->sample_count());
    }

    // optional double sample_sum = 2;
    if (has_sample_sum()) {
      total_size += 1 + 8;
    }

  }
  // repeated .io.prometheus.client.Bucket bucket = 3;
  total_size += 1 * this->bucket_size();
  for (int i = 0; i < this->bucket_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->bucket(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Histogram::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Histogram* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Histogram*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Histogram::MergeFrom(const Histogram& from) {
  GOOGLE_CHECK_NE(&from, this);
  bucket_.MergeFrom(from.bucket_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_sample_count()) {
      set_sample_count(from.sample_count());
    }
    if (from.has_sample_sum()) {
      set_sample_sum(from.sample_sum());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Histogram::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Histogram::CopyFrom(const Histogram& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Histogram::IsInitialized() const {

  return true;
}

void Histogram::Swap(Histogram* other) {
  if (other != this) {
    std::swap(sample_count_, other->sample_count_);
    std::swap(sample_sum_, other->sample_sum_);
    bucket_.Swap(&other->bucket_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Histogram::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Histogram_descriptor_;
  metadata.reflection = Histogram_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Bucket::kCumulativeCountFieldNumber;
const int Bucket::kUpperBoundFieldNumber;
#endif  // !_MSC_VER

Bucket::Bucket()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Bucket)
}

void Bucket::InitAsDefaultInstance() {
}

Bucket::Bucket(const Bucket& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Bucket)
}

void Bucket::SharedCtor() {
  _cached_size_ = 0;
  cumulative_count_ = GOOGLE_ULONGLONG(0);
  upper_bound_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Bucket::~Bucket() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Bucket)
  SharedDtor();
}

void Bucket::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const Bucket& Bucket::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Bucket* Bucket::default_instance_ = NULL;

Bucket* Bucket::New() const {
  return new Bucket;
}

void Bucket::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<Bucket*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(cumulative_count_, upper_bound_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Bucket::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Bucket)
  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 cumulative_count = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &cumulative_count_)));
          set_has_cumulative_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_upper_bound;
        break;
      }

      // optional double upper_bound = 2;
      case 2: {
        if (tag == 17) {
         parse_upper_bound:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &upper_bound_)));
          set_has_upper_bound();
        } 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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Bucket)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Bucket)
  return false;
#undef DO_
}

void Bucket::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Bucket)
  // optional uint64 cumulative_count = 1;
  if (has_cumulative_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->cumulative_count(), output);
  }

  // optional double upper_bound = 2;
  if (has_upper_bound()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->upper_bound(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Bucket)
}

::google::protobuf::uint8* Bucket::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Bucket)
  // optional uint64 cumulative_count = 1;
  if (has_cumulative_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->cumulative_count(), target);
  }

  // optional double upper_bound = 2;
  if (has_upper_bound()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->upper_bound(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Bucket)
  return target;
}

int Bucket::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional uint64 cumulative_count = 1;
    if (has_cumulative_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->cumulative_count());
    }

    // optional double upper_bound = 2;
    if (has_upper_bound()) {
      total_size += 1 + 8;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Bucket::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Bucket* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Bucket*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Bucket::MergeFrom(const Bucket& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_cumulative_count()) {
      set_cumulative_count(from.cumulative_count());
    }
    if (from.has_upper_bound()) {
      set_upper_bound(from.upper_bound());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Bucket::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Bucket::CopyFrom(const Bucket& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Bucket::IsInitialized() const {

  return true;
}

void Bucket::Swap(Bucket* other) {
  if (other != this) {
    std::swap(cumulative_count_, other->cumulative_count_);
    std::swap(upper_bound_, other->upper_bound_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Bucket::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Bucket_descriptor_;
  metadata.reflection = Bucket_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Metric::kLabelFieldNumber;
const int Metric::kGaugeFieldNumber;
const int Metric::kCounterFieldNumber;
const int Metric::kSummaryFieldNumber;
const int Metric::kUntypedFieldNumber;
const int Metric::kHistogramFieldNumber;
const int Metric::kTimestampMsFieldNumber;
#endif  // !_MSC_VER

Metric::Metric()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.Metric)
}

void Metric::InitAsDefaultInstance() {
  gauge_ = const_cast< ::io::prometheus::client::Gauge*>(&::io::prometheus::client::Gauge::default_instance());
  counter_ = const_cast< ::io::prometheus::client::Counter*>(&::io::prometheus::client::Counter::default_instance());
  summary_ = const_cast< ::io::prometheus::client::Summary*>(&::io::prometheus::client::Summary::default_instance());
  untyped_ = const_cast< ::io::prometheus::client::Untyped*>(&::io::prometheus::client::Untyped::default_instance());
  histogram_ = const_cast< ::io::prometheus::client::Histogram*>(&::io::prometheus::client::Histogram::default_instance());
}

Metric::Metric(const Metric& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.Metric)
}

void Metric::SharedCtor() {
  _cached_size_ = 0;
  gauge_ = NULL;
  counter_ = NULL;
  summary_ = NULL;
  untyped_ = NULL;
  histogram_ = NULL;
  timestamp_ms_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Metric::~Metric() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.Metric)
  SharedDtor();
}

void Metric::SharedDtor() {
  if (this != default_instance_) {
    delete gauge_;
    delete counter_;
    delete summary_;
    delete untyped_;
    delete histogram_;
  }
}

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

const Metric& Metric::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

Metric* Metric::default_instance_ = NULL;

Metric* Metric::New() const {
  return new Metric;
}

void Metric::Clear() {
  if (_has_bits_[0 / 32] & 126) {
    if (has_gauge()) {
      if (gauge_ != NULL) gauge_->::io::prometheus::client::Gauge::Clear();
    }
    if (has_counter()) {
      if (counter_ != NULL) counter_->::io::prometheus::client::Counter::Clear();
    }
    if (has_summary()) {
      if (summary_ != NULL) summary_->::io::prometheus::client::Summary::Clear();
    }
    if (has_untyped()) {
      if (untyped_ != NULL) untyped_->::io::prometheus::client::Untyped::Clear();
    }
    if (has_histogram()) {
      if (histogram_ != NULL) histogram_->::io::prometheus::client::Histogram::Clear();
    }
    timestamp_ms_ = GOOGLE_LONGLONG(0);
  }
  label_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Metric::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.Metric)
  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 .io.prometheus.client.LabelPair label = 1;
      case 1: {
        if (tag == 10) {
         parse_label:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_label()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_label;
        if (input->ExpectTag(18)) goto parse_gauge;
        break;
      }

      // optional .io.prometheus.client.Gauge gauge = 2;
      case 2: {
        if (tag == 18) {
         parse_gauge:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gauge()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_counter;
        break;
      }

      // optional .io.prometheus.client.Counter counter = 3;
      case 3: {
        if (tag == 26) {
         parse_counter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_counter()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_summary;
        break;
      }

      // optional .io.prometheus.client.Summary summary = 4;
      case 4: {
        if (tag == 34) {
         parse_summary:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_summary()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_untyped;
        break;
      }

      // optional .io.prometheus.client.Untyped untyped = 5;
      case 5: {
        if (tag == 42) {
         parse_untyped:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_untyped()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_timestamp_ms;
        break;
      }

      // optional int64 timestamp_ms = 6;
      case 6: {
        if (tag == 48) {
         parse_timestamp_ms:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &timestamp_ms_)));
          set_has_timestamp_ms();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_histogram;
        break;
      }

      // optional .io.prometheus.client.Histogram histogram = 7;
      case 7: {
        if (tag == 58) {
         parse_histogram:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_histogram()));
        } 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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.Metric)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.Metric)
  return false;
#undef DO_
}

void Metric::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.Metric)
  // repeated .io.prometheus.client.LabelPair label = 1;
  for (int i = 0; i < this->label_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->label(i), output);
  }

  // optional .io.prometheus.client.Gauge gauge = 2;
  if (has_gauge()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->gauge(), output);
  }

  // optional .io.prometheus.client.Counter counter = 3;
  if (has_counter()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->counter(), output);
  }

  // optional .io.prometheus.client.Summary summary = 4;
  if (has_summary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->summary(), output);
  }

  // optional .io.prometheus.client.Untyped untyped = 5;
  if (has_untyped()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->untyped(), output);
  }

  // optional int64 timestamp_ms = 6;
  if (has_timestamp_ms()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->timestamp_ms(), output);
  }

  // optional .io.prometheus.client.Histogram histogram = 7;
  if (has_histogram()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, this->histogram(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.Metric)
}

::google::protobuf::uint8* Metric::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.Metric)
  // repeated .io.prometheus.client.LabelPair label = 1;
  for (int i = 0; i < this->label_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->label(i), target);
  }

  // optional .io.prometheus.client.Gauge gauge = 2;
  if (has_gauge()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->gauge(), target);
  }

  // optional .io.prometheus.client.Counter counter = 3;
  if (has_counter()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->counter(), target);
  }

  // optional .io.prometheus.client.Summary summary = 4;
  if (has_summary()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->summary(), target);
  }

  // optional .io.prometheus.client.Untyped untyped = 5;
  if (has_untyped()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->untyped(), target);
  }

  // optional int64 timestamp_ms = 6;
  if (has_timestamp_ms()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->timestamp_ms(), target);
  }

  // optional .io.prometheus.client.Histogram histogram = 7;
  if (has_histogram()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, this->histogram(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.Metric)
  return target;
}

int Metric::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    // optional .io.prometheus.client.Gauge gauge = 2;
    if (has_gauge()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gauge());
    }

    // optional .io.prometheus.client.Counter counter = 3;
    if (has_counter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->counter());
    }

    // optional .io.prometheus.client.Summary summary = 4;
    if (has_summary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->summary());
    }

    // optional .io.prometheus.client.Untyped untyped = 5;
    if (has_untyped()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->untyped());
    }

    // optional .io.prometheus.client.Histogram histogram = 7;
    if (has_histogram()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->histogram());
    }

    // optional int64 timestamp_ms = 6;
    if (has_timestamp_ms()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->timestamp_ms());
    }

  }
  // repeated .io.prometheus.client.LabelPair label = 1;
  total_size += 1 * this->label_size();
  for (int i = 0; i < this->label_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->label(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Metric::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Metric* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Metric*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Metric::MergeFrom(const Metric& from) {
  GOOGLE_CHECK_NE(&from, this);
  label_.MergeFrom(from.label_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_gauge()) {
      mutable_gauge()->::io::prometheus::client::Gauge::MergeFrom(from.gauge());
    }
    if (from.has_counter()) {
      mutable_counter()->::io::prometheus::client::Counter::MergeFrom(from.counter());
    }
    if (from.has_summary()) {
      mutable_summary()->::io::prometheus::client::Summary::MergeFrom(from.summary());
    }
    if (from.has_untyped()) {
      mutable_untyped()->::io::prometheus::client::Untyped::MergeFrom(from.untyped());
    }
    if (from.has_histogram()) {
      mutable_histogram()->::io::prometheus::client::Histogram::MergeFrom(from.histogram());
    }
    if (from.has_timestamp_ms()) {
      set_timestamp_ms(from.timestamp_ms());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Metric::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Metric::CopyFrom(const Metric& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Metric::IsInitialized() const {

  return true;
}

void Metric::Swap(Metric* other) {
  if (other != this) {
    label_.Swap(&other->label_);
    std::swap(gauge_, other->gauge_);
    std::swap(counter_, other->counter_);
    std::swap(summary_, other->summary_);
    std::swap(untyped_, other->untyped_);
    std::swap(histogram_, other->histogram_);
    std::swap(timestamp_ms_, other->timestamp_ms_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Metric::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Metric_descriptor_;
  metadata.reflection = Metric_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int MetricFamily::kNameFieldNumber;
const int MetricFamily::kHelpFieldNumber;
const int MetricFamily::kTypeFieldNumber;
const int MetricFamily::kMetricFieldNumber;
#endif  // !_MSC_VER

MetricFamily::MetricFamily()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:io.prometheus.client.MetricFamily)
}

void MetricFamily::InitAsDefaultInstance() {
}

MetricFamily::MetricFamily(const MetricFamily& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:io.prometheus.client.MetricFamily)
}

void MetricFamily::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  help_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

MetricFamily::~MetricFamily() {
  // @@protoc_insertion_point(destructor:io.prometheus.client.MetricFamily)
  SharedDtor();
}

void MetricFamily::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (help_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete help_;
  }
  if (this != default_instance_) {
  }
}

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

const MetricFamily& MetricFamily::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_metrics_2eproto();
  return *default_instance_;
}

MetricFamily* MetricFamily::default_instance_ = NULL;

MetricFamily* MetricFamily::New() const {
  return new MetricFamily;
}

void MetricFamily::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
    if (has_help()) {
      if (help_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        help_->clear();
      }
    }
    type_ = 0;
  }
  metric_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool MetricFamily::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:io.prometheus.client.MetricFamily)
  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 name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_help;
        break;
      }

      // optional string help = 2;
      case 2: {
        if (tag == 18) {
         parse_help:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_help()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->help().data(), this->help().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "help");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_type;
        break;
      }

      // optional .io.prometheus.client.MetricType type = 3;
      case 3: {
        if (tag == 24) {
         parse_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::io::prometheus::client::MetricType_IsValid(value)) {
            set_type(static_cast< ::io::prometheus::client::MetricType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_metric;
        break;
      }

      // repeated .io.prometheus.client.Metric metric = 4;
      case 4: {
        if (tag == 34) {
         parse_metric:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_metric()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_metric;
        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::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:io.prometheus.client.MetricFamily)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:io.prometheus.client.MetricFamily)
  return false;
#undef DO_
}

void MetricFamily::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:io.prometheus.client.MetricFamily)
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional string help = 2;
  if (has_help()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->help().data(), this->help().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "help");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->help(), output);
  }

  // optional .io.prometheus.client.MetricType type = 3;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->type(), output);
  }

  // repeated .io.prometheus.client.Metric metric = 4;
  for (int i = 0; i < this->metric_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->metric(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:io.prometheus.client.MetricFamily)
}

::google::protobuf::uint8* MetricFamily::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:io.prometheus.client.MetricFamily)
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional string help = 2;
  if (has_help()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->help().data(), this->help().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "help");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->help(), target);
  }

  // optional .io.prometheus.client.MetricType type = 3;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->type(), target);
  }

  // repeated .io.prometheus.client.Metric metric = 4;
  for (int i = 0; i < this->metric_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->metric(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:io.prometheus.client.MetricFamily)
  return target;
}

int MetricFamily::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional string help = 2;
    if (has_help()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->help());
    }

    // optional .io.prometheus.client.MetricType type = 3;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

  }
  // repeated .io.prometheus.client.Metric metric = 4;
  total_size += 1 * this->metric_size();
  for (int i = 0; i < this->metric_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->metric(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MetricFamily::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const MetricFamily* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const MetricFamily*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void MetricFamily::MergeFrom(const MetricFamily& from) {
  GOOGLE_CHECK_NE(&from, this);
  metric_.MergeFrom(from.metric_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_help()) {
      set_help(from.help());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void MetricFamily::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MetricFamily::CopyFrom(const MetricFamily& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MetricFamily::IsInitialized() const {

  return true;
}

void MetricFamily::Swap(MetricFamily* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(help_, other->help_);
    std::swap(type_, other->type_);
    metric_.Swap(&other->metric_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata MetricFamily::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = MetricFamily_descriptor_;
  metadata.reflection = MetricFamily_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace client
}  // namespace prometheus
}  // namespace io

// @@protoc_insertion_point(global_scope)
