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

#include "sct_audit_report.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_sct_5faudit_5freport_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SCTWithSourceAndVerifyStatus_sct_5faudit_5freport_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_sct_5faudit_5freport_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TLSConnectionContext_sct_5faudit_5freport_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_sct_5faudit_5freport_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TLSConnectionContext_Origin_sct_5faudit_5freport_2eproto;
namespace sct_auditing {
class TLSConnectionReportDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TLSConnectionReport> _instance;
} _TLSConnectionReport_default_instance_;
class TLSConnectionContext_OriginDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TLSConnectionContext_Origin> _instance;
} _TLSConnectionContext_Origin_default_instance_;
class TLSConnectionContextDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TLSConnectionContext> _instance;
} _TLSConnectionContext_default_instance_;
class SCTWithSourceAndVerifyStatusDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SCTWithSourceAndVerifyStatus> _instance;
} _SCTWithSourceAndVerifyStatus_default_instance_;
}  // namespace sct_auditing
static void InitDefaultsscc_info_SCTWithSourceAndVerifyStatus_sct_5faudit_5freport_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::sct_auditing::_SCTWithSourceAndVerifyStatus_default_instance_;
    new (ptr) ::sct_auditing::SCTWithSourceAndVerifyStatus();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::sct_auditing::SCTWithSourceAndVerifyStatus::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SCTWithSourceAndVerifyStatus_sct_5faudit_5freport_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_SCTWithSourceAndVerifyStatus_sct_5faudit_5freport_2eproto}, {}};

static void InitDefaultsscc_info_TLSConnectionContext_sct_5faudit_5freport_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::sct_auditing::_TLSConnectionContext_default_instance_;
    new (ptr) ::sct_auditing::TLSConnectionContext();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::sct_auditing::TLSConnectionContext::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TLSConnectionContext_sct_5faudit_5freport_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TLSConnectionContext_sct_5faudit_5freport_2eproto}, {
      &scc_info_TLSConnectionContext_Origin_sct_5faudit_5freport_2eproto.base,}};

static void InitDefaultsscc_info_TLSConnectionContext_Origin_sct_5faudit_5freport_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::sct_auditing::_TLSConnectionContext_Origin_default_instance_;
    new (ptr) ::sct_auditing::TLSConnectionContext_Origin();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::sct_auditing::TLSConnectionContext_Origin::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TLSConnectionContext_Origin_sct_5faudit_5freport_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_TLSConnectionContext_Origin_sct_5faudit_5freport_2eproto}, {}};

static void InitDefaultsscc_info_TLSConnectionReport_sct_5faudit_5freport_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::sct_auditing::_TLSConnectionReport_default_instance_;
    new (ptr) ::sct_auditing::TLSConnectionReport();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::sct_auditing::TLSConnectionReport::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TLSConnectionReport_sct_5faudit_5freport_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_TLSConnectionReport_sct_5faudit_5freport_2eproto}, {
      &scc_info_TLSConnectionContext_sct_5faudit_5freport_2eproto.base,
      &scc_info_SCTWithSourceAndVerifyStatus_sct_5faudit_5freport_2eproto.base,}};

namespace sct_auditing {
bool SCTWithSourceAndVerifyStatus_SctVerifyStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SCTWithSourceAndVerifyStatus_SctVerifyStatus_strings[5] = {};

static const char SCTWithSourceAndVerifyStatus_SctVerifyStatus_names[] =
  "INVALID_SIGNATURE"
  "INVALID_TIMESTAMP"
  "LOG_UNKNOWN"
  "NONE"
  "OK";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SCTWithSourceAndVerifyStatus_SctVerifyStatus_entries[] = {
  { {SCTWithSourceAndVerifyStatus_SctVerifyStatus_names + 0, 17}, 4 },
  { {SCTWithSourceAndVerifyStatus_SctVerifyStatus_names + 17, 17}, 5 },
  { {SCTWithSourceAndVerifyStatus_SctVerifyStatus_names + 34, 11}, 1 },
  { {SCTWithSourceAndVerifyStatus_SctVerifyStatus_names + 45, 4}, 0 },
  { {SCTWithSourceAndVerifyStatus_SctVerifyStatus_names + 49, 2}, 3 },
};

static const int SCTWithSourceAndVerifyStatus_SctVerifyStatus_entries_by_number[] = {
  3, // 0 -> NONE
  2, // 1 -> LOG_UNKNOWN
  4, // 3 -> OK
  0, // 4 -> INVALID_SIGNATURE
  1, // 5 -> INVALID_TIMESTAMP
};

const std::string& SCTWithSourceAndVerifyStatus_SctVerifyStatus_Name(
    SCTWithSourceAndVerifyStatus_SctVerifyStatus value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SCTWithSourceAndVerifyStatus_SctVerifyStatus_entries,
          SCTWithSourceAndVerifyStatus_SctVerifyStatus_entries_by_number,
          5, SCTWithSourceAndVerifyStatus_SctVerifyStatus_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SCTWithSourceAndVerifyStatus_SctVerifyStatus_entries,
      SCTWithSourceAndVerifyStatus_SctVerifyStatus_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     SCTWithSourceAndVerifyStatus_SctVerifyStatus_strings[idx].get();
}
bool SCTWithSourceAndVerifyStatus_SctVerifyStatus_Parse(
    const std::string& name, SCTWithSourceAndVerifyStatus_SctVerifyStatus* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      SCTWithSourceAndVerifyStatus_SctVerifyStatus_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<SCTWithSourceAndVerifyStatus_SctVerifyStatus>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr SCTWithSourceAndVerifyStatus_SctVerifyStatus SCTWithSourceAndVerifyStatus::NONE;
constexpr SCTWithSourceAndVerifyStatus_SctVerifyStatus SCTWithSourceAndVerifyStatus::LOG_UNKNOWN;
constexpr SCTWithSourceAndVerifyStatus_SctVerifyStatus SCTWithSourceAndVerifyStatus::OK;
constexpr SCTWithSourceAndVerifyStatus_SctVerifyStatus SCTWithSourceAndVerifyStatus::INVALID_SIGNATURE;
constexpr SCTWithSourceAndVerifyStatus_SctVerifyStatus SCTWithSourceAndVerifyStatus::INVALID_TIMESTAMP;
constexpr SCTWithSourceAndVerifyStatus_SctVerifyStatus SCTWithSourceAndVerifyStatus::SctVerifyStatus_MIN;
constexpr SCTWithSourceAndVerifyStatus_SctVerifyStatus SCTWithSourceAndVerifyStatus::SctVerifyStatus_MAX;
constexpr int SCTWithSourceAndVerifyStatus::SctVerifyStatus_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool SCTWithSourceAndVerifyStatus_Source_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SCTWithSourceAndVerifyStatus_Source_strings[4] = {};

static const char SCTWithSourceAndVerifyStatus_Source_names[] =
  "EMBEDDED"
  "OCSP_RESPONSE"
  "SOURCE_UNSPECIFIED"
  "TLS_EXTENSION";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SCTWithSourceAndVerifyStatus_Source_entries[] = {
  { {SCTWithSourceAndVerifyStatus_Source_names + 0, 8}, 1 },
  { {SCTWithSourceAndVerifyStatus_Source_names + 8, 13}, 3 },
  { {SCTWithSourceAndVerifyStatus_Source_names + 21, 18}, 0 },
  { {SCTWithSourceAndVerifyStatus_Source_names + 39, 13}, 2 },
};

static const int SCTWithSourceAndVerifyStatus_Source_entries_by_number[] = {
  2, // 0 -> SOURCE_UNSPECIFIED
  0, // 1 -> EMBEDDED
  3, // 2 -> TLS_EXTENSION
  1, // 3 -> OCSP_RESPONSE
};

const std::string& SCTWithSourceAndVerifyStatus_Source_Name(
    SCTWithSourceAndVerifyStatus_Source value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SCTWithSourceAndVerifyStatus_Source_entries,
          SCTWithSourceAndVerifyStatus_Source_entries_by_number,
          4, SCTWithSourceAndVerifyStatus_Source_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SCTWithSourceAndVerifyStatus_Source_entries,
      SCTWithSourceAndVerifyStatus_Source_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     SCTWithSourceAndVerifyStatus_Source_strings[idx].get();
}
bool SCTWithSourceAndVerifyStatus_Source_Parse(
    const std::string& name, SCTWithSourceAndVerifyStatus_Source* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      SCTWithSourceAndVerifyStatus_Source_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<SCTWithSourceAndVerifyStatus_Source>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr SCTWithSourceAndVerifyStatus_Source SCTWithSourceAndVerifyStatus::SOURCE_UNSPECIFIED;
constexpr SCTWithSourceAndVerifyStatus_Source SCTWithSourceAndVerifyStatus::EMBEDDED;
constexpr SCTWithSourceAndVerifyStatus_Source SCTWithSourceAndVerifyStatus::TLS_EXTENSION;
constexpr SCTWithSourceAndVerifyStatus_Source SCTWithSourceAndVerifyStatus::OCSP_RESPONSE;
constexpr SCTWithSourceAndVerifyStatus_Source SCTWithSourceAndVerifyStatus::Source_MIN;
constexpr SCTWithSourceAndVerifyStatus_Source SCTWithSourceAndVerifyStatus::Source_MAX;
constexpr int SCTWithSourceAndVerifyStatus::Source_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)

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

void TLSConnectionReport::InitAsDefaultInstance() {
  ::sct_auditing::_TLSConnectionReport_default_instance_._instance.get_mutable()->context_ = const_cast< ::sct_auditing::TLSConnectionContext*>(
      ::sct_auditing::TLSConnectionContext::internal_default_instance());
}
class TLSConnectionReport::_Internal {
 public:
  static const ::sct_auditing::TLSConnectionContext& context(const TLSConnectionReport* msg);
};

const ::sct_auditing::TLSConnectionContext&
TLSConnectionReport::_Internal::context(const TLSConnectionReport* msg) {
  return *msg->context_;
}
TLSConnectionReport::TLSConnectionReport()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:sct_auditing.TLSConnectionReport)
}
TLSConnectionReport::TLSConnectionReport(const TLSConnectionReport& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      included_scts_(from.included_scts_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_context()) {
    context_ = new ::sct_auditing::TLSConnectionContext(*from.context_);
  } else {
    context_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:sct_auditing.TLSConnectionReport)
}

void TLSConnectionReport::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TLSConnectionReport_sct_5faudit_5freport_2eproto.base);
  context_ = nullptr;
}

TLSConnectionReport::~TLSConnectionReport() {
  // @@protoc_insertion_point(destructor:sct_auditing.TLSConnectionReport)
  SharedDtor();
}

void TLSConnectionReport::SharedDtor() {
  if (this != internal_default_instance()) delete context_;
}

void TLSConnectionReport::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const TLSConnectionReport& TLSConnectionReport::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TLSConnectionReport_sct_5faudit_5freport_2eproto.base);
  return *internal_default_instance();
}


void TLSConnectionReport::Clear() {
// @@protoc_insertion_point(message_clear_start:sct_auditing.TLSConnectionReport)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  included_scts_.Clear();
  if (GetArenaNoVirtual() == nullptr && context_ != nullptr) {
    delete context_;
  }
  context_ = nullptr;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* TLSConnectionReport::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .sct_auditing.TLSConnectionContext context = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(mutable_context(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .sct_auditing.SCTWithSourceAndVerifyStatus included_scts = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_included_scts(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool TLSConnectionReport::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:sct_auditing.TLSConnectionReport)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .sct_auditing.TLSConnectionContext context = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_context()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .sct_auditing.SCTWithSourceAndVerifyStatus included_scts = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_included_scts()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sct_auditing.TLSConnectionReport)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sct_auditing.TLSConnectionReport)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void TLSConnectionReport::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sct_auditing.TLSConnectionReport)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .sct_auditing.TLSConnectionContext context = 1;
  if (this->has_context()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      1, _Internal::context(this), output);
  }

  // repeated .sct_auditing.SCTWithSourceAndVerifyStatus included_scts = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->included_scts_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      2,
      this->included_scts(static_cast<int>(i)),
      output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sct_auditing.TLSConnectionReport)
}

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .sct_auditing.SCTWithSourceAndVerifyStatus included_scts = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->included_scts_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->included_scts(static_cast<int>(i)));
    }
  }

  // .sct_auditing.TLSConnectionContext context = 1;
  if (this->has_context()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *context_);
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TLSConnectionReport::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TLSConnectionReport*>(
      &from));
}

void TLSConnectionReport::MergeFrom(const TLSConnectionReport& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sct_auditing.TLSConnectionReport)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  included_scts_.MergeFrom(from.included_scts_);
  if (from.has_context()) {
    mutable_context()->::sct_auditing::TLSConnectionContext::MergeFrom(from.context());
  }
}

void TLSConnectionReport::CopyFrom(const TLSConnectionReport& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sct_auditing.TLSConnectionReport)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TLSConnectionReport::IsInitialized() const {
  return true;
}

void TLSConnectionReport::InternalSwap(TLSConnectionReport* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  CastToBase(&included_scts_)->InternalSwap(CastToBase(&other->included_scts_));
  swap(context_, other->context_);
}

std::string TLSConnectionReport::GetTypeName() const {
  return "sct_auditing.TLSConnectionReport";
}


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

void TLSConnectionContext_Origin::InitAsDefaultInstance() {
}
class TLSConnectionContext_Origin::_Internal {
 public:
};

TLSConnectionContext_Origin::TLSConnectionContext_Origin()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:sct_auditing.TLSConnectionContext.Origin)
}
TLSConnectionContext_Origin::TLSConnectionContext_Origin(const TLSConnectionContext_Origin& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  hostname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from.hostname().empty()) {
    hostname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.hostname_);
  }
  port_ = from.port_;
  // @@protoc_insertion_point(copy_constructor:sct_auditing.TLSConnectionContext.Origin)
}

void TLSConnectionContext_Origin::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TLSConnectionContext_Origin_sct_5faudit_5freport_2eproto.base);
  hostname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  port_ = 0;
}

TLSConnectionContext_Origin::~TLSConnectionContext_Origin() {
  // @@protoc_insertion_point(destructor:sct_auditing.TLSConnectionContext.Origin)
  SharedDtor();
}

void TLSConnectionContext_Origin::SharedDtor() {
  hostname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void TLSConnectionContext_Origin::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const TLSConnectionContext_Origin& TLSConnectionContext_Origin::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TLSConnectionContext_Origin_sct_5faudit_5freport_2eproto.base);
  return *internal_default_instance();
}


void TLSConnectionContext_Origin::Clear() {
// @@protoc_insertion_point(message_clear_start:sct_auditing.TLSConnectionContext.Origin)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  hostname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  port_ = 0;
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* TLSConnectionContext_Origin::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // string hostname = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_hostname(), ptr, ctx, nullptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // int32 port = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool TLSConnectionContext_Origin::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:sct_auditing.TLSConnectionContext.Origin)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // string hostname = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_hostname()));
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            this->hostname().data(), static_cast<int>(this->hostname().length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
            "sct_auditing.TLSConnectionContext.Origin.hostname"));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // int32 port = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &port_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sct_auditing.TLSConnectionContext.Origin)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sct_auditing.TLSConnectionContext.Origin)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void TLSConnectionContext_Origin::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sct_auditing.TLSConnectionContext.Origin)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // string hostname = 1;
  if (this->hostname().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->hostname().data(), static_cast<int>(this->hostname().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "sct_auditing.TLSConnectionContext.Origin.hostname");
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->hostname(), output);
  }

  // int32 port = 2;
  if (this->port() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(2, this->port(), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sct_auditing.TLSConnectionContext.Origin)
}

size_t TLSConnectionContext_Origin::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sct_auditing.TLSConnectionContext.Origin)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string hostname = 1;
  if (this->hostname().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->hostname());
  }

  // int32 port = 2;
  if (this->port() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->port());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TLSConnectionContext_Origin::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TLSConnectionContext_Origin*>(
      &from));
}

void TLSConnectionContext_Origin::MergeFrom(const TLSConnectionContext_Origin& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sct_auditing.TLSConnectionContext.Origin)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.hostname().size() > 0) {

    hostname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.hostname_);
  }
  if (from.port() != 0) {
    set_port(from.port());
  }
}

void TLSConnectionContext_Origin::CopyFrom(const TLSConnectionContext_Origin& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sct_auditing.TLSConnectionContext.Origin)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TLSConnectionContext_Origin::IsInitialized() const {
  return true;
}

void TLSConnectionContext_Origin::InternalSwap(TLSConnectionContext_Origin* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  hostname_.Swap(&other->hostname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(port_, other->port_);
}

std::string TLSConnectionContext_Origin::GetTypeName() const {
  return "sct_auditing.TLSConnectionContext.Origin";
}


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

void TLSConnectionContext::InitAsDefaultInstance() {
  ::sct_auditing::_TLSConnectionContext_default_instance_._instance.get_mutable()->origin_ = const_cast< ::sct_auditing::TLSConnectionContext_Origin*>(
      ::sct_auditing::TLSConnectionContext_Origin::internal_default_instance());
}
class TLSConnectionContext::_Internal {
 public:
  static const ::sct_auditing::TLSConnectionContext_Origin& origin(const TLSConnectionContext* msg);
};

const ::sct_auditing::TLSConnectionContext_Origin&
TLSConnectionContext::_Internal::origin(const TLSConnectionContext* msg) {
  return *msg->origin_;
}
TLSConnectionContext::TLSConnectionContext()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:sct_auditing.TLSConnectionContext)
}
TLSConnectionContext::TLSConnectionContext(const TLSConnectionContext& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      certificate_chain_(from.certificate_chain_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_origin()) {
    origin_ = new ::sct_auditing::TLSConnectionContext_Origin(*from.origin_);
  } else {
    origin_ = nullptr;
  }
  time_seen_ = from.time_seen_;
  // @@protoc_insertion_point(copy_constructor:sct_auditing.TLSConnectionContext)
}

void TLSConnectionContext::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TLSConnectionContext_sct_5faudit_5freport_2eproto.base);
  ::memset(&origin_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&time_seen_) -
      reinterpret_cast<char*>(&origin_)) + sizeof(time_seen_));
}

TLSConnectionContext::~TLSConnectionContext() {
  // @@protoc_insertion_point(destructor:sct_auditing.TLSConnectionContext)
  SharedDtor();
}

void TLSConnectionContext::SharedDtor() {
  if (this != internal_default_instance()) delete origin_;
}

void TLSConnectionContext::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const TLSConnectionContext& TLSConnectionContext::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TLSConnectionContext_sct_5faudit_5freport_2eproto.base);
  return *internal_default_instance();
}


void TLSConnectionContext::Clear() {
// @@protoc_insertion_point(message_clear_start:sct_auditing.TLSConnectionContext)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  certificate_chain_.Clear();
  if (GetArenaNoVirtual() == nullptr && origin_ != nullptr) {
    delete origin_;
  }
  origin_ = nullptr;
  time_seen_ = PROTOBUF_LONGLONG(0);
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* TLSConnectionContext::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // int64 time_seen = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          time_seen_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .sct_auditing.TLSConnectionContext.Origin origin = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_origin(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated bytes certificate_chain = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(add_certificate_chain(), ptr, ctx);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool TLSConnectionContext::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:sct_auditing.TLSConnectionContext)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // int64 time_seen = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {

          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 input, &time_seen_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .sct_auditing.TLSConnectionContext.Origin origin = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_origin()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated bytes certificate_chain = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->add_certificate_chain()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sct_auditing.TLSConnectionContext)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sct_auditing.TLSConnectionContext)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void TLSConnectionContext::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sct_auditing.TLSConnectionContext)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // int64 time_seen = 1;
  if (this->time_seen() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->time_seen(), output);
  }

  // .sct_auditing.TLSConnectionContext.Origin origin = 2;
  if (this->has_origin()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      2, _Internal::origin(this), output);
  }

  // repeated bytes certificate_chain = 3;
  for (int i = 0, n = this->certificate_chain_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytes(
      3, this->certificate_chain(i), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sct_auditing.TLSConnectionContext)
}

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated bytes certificate_chain = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->certificate_chain_size());
  for (int i = 0, n = this->certificate_chain_size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
      this->certificate_chain(i));
  }

  // .sct_auditing.TLSConnectionContext.Origin origin = 2;
  if (this->has_origin()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *origin_);
  }

  // int64 time_seen = 1;
  if (this->time_seen() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->time_seen());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TLSConnectionContext::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const TLSConnectionContext*>(
      &from));
}

void TLSConnectionContext::MergeFrom(const TLSConnectionContext& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sct_auditing.TLSConnectionContext)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  certificate_chain_.MergeFrom(from.certificate_chain_);
  if (from.has_origin()) {
    mutable_origin()->::sct_auditing::TLSConnectionContext_Origin::MergeFrom(from.origin());
  }
  if (from.time_seen() != 0) {
    set_time_seen(from.time_seen());
  }
}

void TLSConnectionContext::CopyFrom(const TLSConnectionContext& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sct_auditing.TLSConnectionContext)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TLSConnectionContext::IsInitialized() const {
  return true;
}

void TLSConnectionContext::InternalSwap(TLSConnectionContext* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  certificate_chain_.InternalSwap(CastToBase(&other->certificate_chain_));
  swap(origin_, other->origin_);
  swap(time_seen_, other->time_seen_);
}

std::string TLSConnectionContext::GetTypeName() const {
  return "sct_auditing.TLSConnectionContext";
}


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

void SCTWithSourceAndVerifyStatus::InitAsDefaultInstance() {
}
class SCTWithSourceAndVerifyStatus::_Internal {
 public:
};

SCTWithSourceAndVerifyStatus::SCTWithSourceAndVerifyStatus()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:sct_auditing.SCTWithSourceAndVerifyStatus)
}
SCTWithSourceAndVerifyStatus::SCTWithSourceAndVerifyStatus(const SCTWithSourceAndVerifyStatus& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  sct_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from.sct().empty()) {
    sct_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sct_);
  }
  ::memcpy(&status_, &from.status_,
    static_cast<size_t>(reinterpret_cast<char*>(&source_) -
    reinterpret_cast<char*>(&status_)) + sizeof(source_));
  // @@protoc_insertion_point(copy_constructor:sct_auditing.SCTWithSourceAndVerifyStatus)
}

void SCTWithSourceAndVerifyStatus::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SCTWithSourceAndVerifyStatus_sct_5faudit_5freport_2eproto.base);
  sct_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&status_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&source_) -
      reinterpret_cast<char*>(&status_)) + sizeof(source_));
}

SCTWithSourceAndVerifyStatus::~SCTWithSourceAndVerifyStatus() {
  // @@protoc_insertion_point(destructor:sct_auditing.SCTWithSourceAndVerifyStatus)
  SharedDtor();
}

void SCTWithSourceAndVerifyStatus::SharedDtor() {
  sct_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void SCTWithSourceAndVerifyStatus::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const SCTWithSourceAndVerifyStatus& SCTWithSourceAndVerifyStatus::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SCTWithSourceAndVerifyStatus_sct_5faudit_5freport_2eproto.base);
  return *internal_default_instance();
}


void SCTWithSourceAndVerifyStatus::Clear() {
// @@protoc_insertion_point(message_clear_start:sct_auditing.SCTWithSourceAndVerifyStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  sct_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&status_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&source_) -
      reinterpret_cast<char*>(&status_)) + sizeof(source_));
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* SCTWithSourceAndVerifyStatus::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // .sct_auditing.SCTWithSourceAndVerifyStatus.SctVerifyStatus status = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_status(static_cast<::sct_auditing::SCTWithSourceAndVerifyStatus_SctVerifyStatus>(val));
        } else goto handle_unusual;
        continue;
      // .sct_auditing.SCTWithSourceAndVerifyStatus.Source source = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          set_source(static_cast<::sct_auditing::SCTWithSourceAndVerifyStatus_Source>(val));
        } else goto handle_unusual;
        continue;
      // bytes sct = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_sct(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool SCTWithSourceAndVerifyStatus::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:sct_auditing.SCTWithSourceAndVerifyStatus)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // .sct_auditing.SCTWithSourceAndVerifyStatus.SctVerifyStatus status = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_status(static_cast< ::sct_auditing::SCTWithSourceAndVerifyStatus_SctVerifyStatus >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // .sct_auditing.SCTWithSourceAndVerifyStatus.Source source = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          set_source(static_cast< ::sct_auditing::SCTWithSourceAndVerifyStatus_Source >(value));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // bytes sct = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_sct()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sct_auditing.SCTWithSourceAndVerifyStatus)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sct_auditing.SCTWithSourceAndVerifyStatus)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void SCTWithSourceAndVerifyStatus::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sct_auditing.SCTWithSourceAndVerifyStatus)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // .sct_auditing.SCTWithSourceAndVerifyStatus.SctVerifyStatus status = 1;
  if (this->status() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      1, this->status(), output);
  }

  // .sct_auditing.SCTWithSourceAndVerifyStatus.Source source = 2;
  if (this->source() != 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->source(), output);
  }

  // bytes sct = 3;
  if (this->sct().size() > 0) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->sct(), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sct_auditing.SCTWithSourceAndVerifyStatus)
}

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // bytes sct = 3;
  if (this->sct().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->sct());
  }

  // .sct_auditing.SCTWithSourceAndVerifyStatus.SctVerifyStatus status = 1;
  if (this->status() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->status());
  }

  // .sct_auditing.SCTWithSourceAndVerifyStatus.Source source = 2;
  if (this->source() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->source());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SCTWithSourceAndVerifyStatus::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const SCTWithSourceAndVerifyStatus*>(
      &from));
}

void SCTWithSourceAndVerifyStatus::MergeFrom(const SCTWithSourceAndVerifyStatus& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sct_auditing.SCTWithSourceAndVerifyStatus)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.sct().size() > 0) {

    sct_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.sct_);
  }
  if (from.status() != 0) {
    set_status(from.status());
  }
  if (from.source() != 0) {
    set_source(from.source());
  }
}

void SCTWithSourceAndVerifyStatus::CopyFrom(const SCTWithSourceAndVerifyStatus& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sct_auditing.SCTWithSourceAndVerifyStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SCTWithSourceAndVerifyStatus::IsInitialized() const {
  return true;
}

void SCTWithSourceAndVerifyStatus::InternalSwap(SCTWithSourceAndVerifyStatus* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  sct_.Swap(&other->sct_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(status_, other->status_);
  swap(source_, other->source_);
}

std::string SCTWithSourceAndVerifyStatus::GetTypeName() const {
  return "sct_auditing.SCTWithSourceAndVerifyStatus";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace sct_auditing
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sct_auditing::TLSConnectionReport* Arena::CreateMaybeMessage< ::sct_auditing::TLSConnectionReport >(Arena* arena) {
  return Arena::CreateInternal< ::sct_auditing::TLSConnectionReport >(arena);
}
template<> PROTOBUF_NOINLINE ::sct_auditing::TLSConnectionContext_Origin* Arena::CreateMaybeMessage< ::sct_auditing::TLSConnectionContext_Origin >(Arena* arena) {
  return Arena::CreateInternal< ::sct_auditing::TLSConnectionContext_Origin >(arena);
}
template<> PROTOBUF_NOINLINE ::sct_auditing::TLSConnectionContext* Arena::CreateMaybeMessage< ::sct_auditing::TLSConnectionContext >(Arena* arena) {
  return Arena::CreateInternal< ::sct_auditing::TLSConnectionContext >(arena);
}
template<> PROTOBUF_NOINLINE ::sct_auditing::SCTWithSourceAndVerifyStatus* Arena::CreateMaybeMessage< ::sct_auditing::SCTWithSourceAndVerifyStatus >(Arena* arena) {
  return Arena::CreateInternal< ::sct_auditing::SCTWithSourceAndVerifyStatus >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
