certificate_transparency.pb.cc | Explore in Territory

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

#include "certificate_transparency.pb.h"

#include <algorithm>

#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>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace chrome_browser_certificate_transparency {
PROTOBUF_CONSTEXPR FinalTreeHead::FinalTreeHead(
    ::_pbi::ConstantInitialized): … { … }
struct FinalTreeHeadDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FinalTreeHeadDefaultTypeInternal _FinalTreeHead_default_instance_;
PROTOBUF_CONSTEXPR CTLog_Interval::CTLog_Interval(
    ::_pbi::ConstantInitialized): … { … }
struct CTLog_IntervalDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CTLog_IntervalDefaultTypeInternal _CTLog_Interval_default_instance_;
PROTOBUF_CONSTEXPR CTLog_State::CTLog_State(
    ::_pbi::ConstantInitialized): … { … }
struct CTLog_StateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CTLog_StateDefaultTypeInternal _CTLog_State_default_instance_;
PROTOBUF_CONSTEXPR CTLog_OperatorChange::CTLog_OperatorChange(
    ::_pbi::ConstantInitialized): … { … }
struct CTLog_OperatorChangeDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CTLog_OperatorChangeDefaultTypeInternal _CTLog_OperatorChange_default_instance_;
PROTOBUF_CONSTEXPR CTLog::CTLog(
    ::_pbi::ConstantInitialized): … { … }
struct CTLogDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CTLogDefaultTypeInternal _CTLog_default_instance_;
PROTOBUF_CONSTEXPR LogOperator::LogOperator(
    ::_pbi::ConstantInitialized): … { … }
struct LogOperatorDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LogOperatorDefaultTypeInternal _LogOperator_default_instance_;
PROTOBUF_CONSTEXPR CTLogList::CTLogList(
    ::_pbi::ConstantInitialized): … { … }
struct CTLogListDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CTLogListDefaultTypeInternal _CTLogList_default_instance_;
}  // namespace chrome_browser_certificate_transparency
namespace chrome_browser_certificate_transparency {
bool CTLog_Purpose_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CTLog_Purpose_strings[3] = …;

static const char CTLog_Purpose_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CTLog_Purpose_entries[] = …;

static const int CTLog_Purpose_entries_by_number[] = …;

const std::string& CTLog_Purpose_Name(
    CTLog_Purpose value) { … }
bool CTLog_Purpose_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CTLog_Purpose* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CTLog_Purpose CTLog::UNSET_PURPOSE;
constexpr CTLog_Purpose CTLog::PROD;
constexpr CTLog_Purpose CTLog::TEST;
constexpr CTLog_Purpose CTLog::Purpose_MIN;
constexpr CTLog_Purpose CTLog::Purpose_MAX;
constexpr int CTLog::Purpose_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool CTLog_CurrentState_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CTLog_CurrentState_strings[7] = …;

static const char CTLog_CurrentState_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CTLog_CurrentState_entries[] = …;

static const int CTLog_CurrentState_entries_by_number[] = …;

const std::string& CTLog_CurrentState_Name(
    CTLog_CurrentState value) { … }
bool CTLog_CurrentState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CTLog_CurrentState* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CTLog_CurrentState CTLog::UNSET_STATE;
constexpr CTLog_CurrentState CTLog::PENDING;
constexpr CTLog_CurrentState CTLog::QUALIFIED;
constexpr CTLog_CurrentState CTLog::USABLE;
constexpr CTLog_CurrentState CTLog::READ_ONLY;
constexpr CTLog_CurrentState CTLog::RETIRED;
constexpr CTLog_CurrentState CTLog::REJECTED;
constexpr CTLog_CurrentState CTLog::CurrentState_MIN;
constexpr CTLog_CurrentState CTLog::CurrentState_MAX;
constexpr int CTLog::CurrentState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class FinalTreeHead::_Internal { … };

FinalTreeHead::FinalTreeHead(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
FinalTreeHead::FinalTreeHead(const FinalTreeHead& from)
  : … { … }

inline void FinalTreeHead::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

FinalTreeHead::~FinalTreeHead() { … }

inline void FinalTreeHead::SharedDtor() { … }

void FinalTreeHead::SetCachedSize(int size) const { … }

void FinalTreeHead::Clear() { … }

const char* FinalTreeHead::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* FinalTreeHead::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t FinalTreeHead::ByteSizeLong() const { … }

void FinalTreeHead::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void FinalTreeHead::MergeFrom(const FinalTreeHead& from) { … }

void FinalTreeHead::CopyFrom(const FinalTreeHead& from) { … }

bool FinalTreeHead::IsInitialized() const { … }

void FinalTreeHead::InternalSwap(FinalTreeHead* other) { … }

std::string FinalTreeHead::GetTypeName() const { … }


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

class CTLog_Interval::_Internal { … };

const ::chrome_browser_certificate_transparency::CTTimestamp&
CTLog_Interval::_Internal::start(const CTLog_Interval* msg) { … }
const ::chrome_browser_certificate_transparency::CTTimestamp&
CTLog_Interval::_Internal::end(const CTLog_Interval* msg) { … }
void CTLog_Interval::clear_start() { … }
void CTLog_Interval::clear_end() { … }
CTLog_Interval::CTLog_Interval(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CTLog_Interval::CTLog_Interval(const CTLog_Interval& from)
  : … { … }

inline void CTLog_Interval::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CTLog_Interval::~CTLog_Interval() { … }

inline void CTLog_Interval::SharedDtor() { … }

void CTLog_Interval::SetCachedSize(int size) const { … }

void CTLog_Interval::Clear() { … }

const char* CTLog_Interval::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CTLog_Interval::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CTLog_Interval::ByteSizeLong() const { … }

void CTLog_Interval::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CTLog_Interval::MergeFrom(const CTLog_Interval& from) { … }

void CTLog_Interval::CopyFrom(const CTLog_Interval& from) { … }

bool CTLog_Interval::IsInitialized() const { … }

void CTLog_Interval::InternalSwap(CTLog_Interval* other) { … }

std::string CTLog_Interval::GetTypeName() const { … }


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

class CTLog_State::_Internal { … };

const ::chrome_browser_certificate_transparency::CTTimestamp&
CTLog_State::_Internal::state_start(const CTLog_State* msg) { … }
void CTLog_State::clear_state_start() { … }
CTLog_State::CTLog_State(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CTLog_State::CTLog_State(const CTLog_State& from)
  : … { … }

inline void CTLog_State::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CTLog_State::~CTLog_State() { … }

inline void CTLog_State::SharedDtor() { … }

void CTLog_State::SetCachedSize(int size) const { … }

void CTLog_State::Clear() { … }

const char* CTLog_State::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CTLog_State::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CTLog_State::ByteSizeLong() const { … }

void CTLog_State::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CTLog_State::MergeFrom(const CTLog_State& from) { … }

void CTLog_State::CopyFrom(const CTLog_State& from) { … }

bool CTLog_State::IsInitialized() const { … }

void CTLog_State::InternalSwap(CTLog_State* other) { … }

std::string CTLog_State::GetTypeName() const { … }


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

class CTLog_OperatorChange::_Internal { … };

const ::chrome_browser_certificate_transparency::CTTimestamp&
CTLog_OperatorChange::_Internal::operator_start(const CTLog_OperatorChange* msg) { … }
void CTLog_OperatorChange::clear_operator_start() { … }
CTLog_OperatorChange::CTLog_OperatorChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CTLog_OperatorChange::CTLog_OperatorChange(const CTLog_OperatorChange& from)
  : … { … }

inline void CTLog_OperatorChange::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CTLog_OperatorChange::~CTLog_OperatorChange() { … }

inline void CTLog_OperatorChange::SharedDtor() { … }

void CTLog_OperatorChange::SetCachedSize(int size) const { … }

void CTLog_OperatorChange::Clear() { … }

const char* CTLog_OperatorChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CTLog_OperatorChange::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CTLog_OperatorChange::ByteSizeLong() const { … }

void CTLog_OperatorChange::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CTLog_OperatorChange::MergeFrom(const CTLog_OperatorChange& from) { … }

void CTLog_OperatorChange::CopyFrom(const CTLog_OperatorChange& from) { … }

bool CTLog_OperatorChange::IsInitialized() const { … }

void CTLog_OperatorChange::InternalSwap(CTLog_OperatorChange* other) { … }

std::string CTLog_OperatorChange::GetTypeName() const { … }


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

class CTLog::_Internal { … };

const ::chrome_browser_certificate_transparency::CTLog_Interval&
CTLog::_Internal::temporal_interval(const CTLog* msg) { … }
const ::chrome_browser_certificate_transparency::FinalTreeHead&
CTLog::_Internal::read_only_info(const CTLog* msg) { … }
CTLog::CTLog(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CTLog::CTLog(const CTLog& from)
  : … { … }

inline void CTLog::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CTLog::~CTLog() { … }

inline void CTLog::SharedDtor() { … }

void CTLog::SetCachedSize(int size) const { … }

void CTLog::Clear() { … }

const char* CTLog::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CTLog::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CTLog::ByteSizeLong() const { … }

void CTLog::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CTLog::MergeFrom(const CTLog& from) { … }

void CTLog::CopyFrom(const CTLog& from) { … }

bool CTLog::IsInitialized() const { … }

void CTLog::InternalSwap(CTLog* other) { … }

std::string CTLog::GetTypeName() const { … }


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

class LogOperator::_Internal { … };

LogOperator::LogOperator(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
LogOperator::LogOperator(const LogOperator& from)
  : … { … }

inline void LogOperator::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

LogOperator::~LogOperator() { … }

inline void LogOperator::SharedDtor() { … }

void LogOperator::SetCachedSize(int size) const { … }

void LogOperator::Clear() { … }

const char* LogOperator::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* LogOperator::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t LogOperator::ByteSizeLong() const { … }

void LogOperator::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void LogOperator::MergeFrom(const LogOperator& from) { … }

void LogOperator::CopyFrom(const LogOperator& from) { … }

bool LogOperator::IsInitialized() const { … }

void LogOperator::InternalSwap(LogOperator* other) { … }

std::string LogOperator::GetTypeName() const { … }


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

class CTLogList::_Internal { … };

const ::chrome_browser_certificate_transparency::CTTimestamp&
CTLogList::_Internal::timestamp(const CTLogList* msg) { … }
void CTLogList::clear_timestamp() { … }
CTLogList::CTLogList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CTLogList::CTLogList(const CTLogList& from)
  : … { … }

inline void CTLogList::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CTLogList::~CTLogList() { … }

inline void CTLogList::SharedDtor() { … }

void CTLogList::SetCachedSize(int size) const { … }

void CTLogList::Clear() { … }

const char* CTLogList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CTLogList::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CTLogList::ByteSizeLong() const { … }

void CTLogList::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CTLogList::MergeFrom(const CTLogList& from) { … }

void CTLogList::CopyFrom(const CTLogList& from) { … }

bool CTLogList::IsInitialized() const { … }

void CTLogList::InternalSwap(CTLogList* other) { … }

std::string CTLogList::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace chrome_browser_certificate_transparency
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::chrome_browser_certificate_transparency::FinalTreeHead*
Arena::CreateMaybeMessage< ::chrome_browser_certificate_transparency::FinalTreeHead >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::chrome_browser_certificate_transparency::CTLog_Interval*
Arena::CreateMaybeMessage< ::chrome_browser_certificate_transparency::CTLog_Interval >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::chrome_browser_certificate_transparency::CTLog_State*
Arena::CreateMaybeMessage< ::chrome_browser_certificate_transparency::CTLog_State >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::chrome_browser_certificate_transparency::CTLog_OperatorChange*
Arena::CreateMaybeMessage< ::chrome_browser_certificate_transparency::CTLog_OperatorChange >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::chrome_browser_certificate_transparency::CTLog*
Arena::CreateMaybeMessage< ::chrome_browser_certificate_transparency::CTLog >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::chrome_browser_certificate_transparency::LogOperator*
Arena::CreateMaybeMessage< ::chrome_browser_certificate_transparency::LogOperator >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::chrome_browser_certificate_transparency::CTLogList*
Arena::CreateMaybeMessage< ::chrome_browser_certificate_transparency::CTLogList >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
chromium/out/Default/gen/components/certificate_transparency/certificate_transparency.pb.cc
