blob: 43dd7eb18b4064932fef98bd02444a292ee31414 [file] [log] [blame]
/*
* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_DEFINITION_H_
#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_DEFINITION_H_
#include <memory>
#include <string>
#include <vector>
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/units/timestamp.h"
#include "logging/rtc_event_log/events/rtc_event_field_encoding.h"
#include "logging/rtc_event_log/events/rtc_event_field_encoding_parser.h"
#include "logging/rtc_event_log/events/rtc_event_field_extraction.h"
#include "rtc_base/logging.h"
namespace webrtc {
template <typename EventType, typename LoggedType, typename T>
struct RtcEventFieldDefinition {
const T EventType::*event_member;
T LoggedType::*logged_member;
FieldParameters params;
};
// Base case
template <typename EventType, typename LoggedType, typename... Ts>
class RtcEventDefinitionImpl {
public:
void EncodeImpl(EventEncoder&, rtc::ArrayView<const RtcEvent*>) const {}
RtcEventLogParseStatus ParseImpl(EventParser&,
rtc::ArrayView<LoggedType>) const {
return RtcEventLogParseStatus::Success();
}
};
// Recursive case
template <typename EventType, typename LoggedType, typename T, typename... Ts>
class RtcEventDefinitionImpl<EventType, LoggedType, T, Ts...> {
public:
constexpr RtcEventDefinitionImpl(
RtcEventFieldDefinition<EventType, LoggedType, T> field,
RtcEventFieldDefinition<EventType, LoggedType, Ts>... rest)
: field_(field), rest_(rest...) {}
void EncodeImpl(EventEncoder& encoder,
rtc::ArrayView<const RtcEvent*> batch) const {
auto values = ExtractRtcEventMember(batch, field_.event_member);
encoder.EncodeField(field_.params, values);
rest_.EncodeImpl(encoder, batch);
}
RtcEventLogParseStatus ParseImpl(
EventParser& parser,
rtc::ArrayView<LoggedType> output_batch) const {
RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>> result =
parser.ParseNumericField(field_.params);
if (!result.ok())
return result.status();
PopulateRtcEventMember(result.value(), field_.logged_member, output_batch);
return rest_.ParseImpl(parser, output_batch);
}
private:
RtcEventFieldDefinition<EventType, LoggedType, T> field_;
RtcEventDefinitionImpl<EventType, LoggedType, Ts...> rest_;
};
// The RtcEventDefinition sets up a mapping between the fields
// in an RtcEvent and the corresponding fields in the parsed struct.
// For example, an RtcFoo class containing two fields; `uint32_t bar`
// and `bool baz` (a log timestamp is always implicitly added)
// might have a definition
// RtcEventDefinition<RtcFoo, LoggedFoo, uint32_t, bool>(
// {"foo", RtcFoo::Type},
// {&RtcFoo::bar_, &LoggedFoo::bar, {"bar", 1, FieldType::kVarInt, 32}},
// {&RtcFoo::baz_, &LoggedFoo::baz, {"baz", 2, FieldType::kFixed8, 1}},
// );
// In addition to defining string names to aid debugging,
// this specifies that
// * RtcFoo::Type uniquely identifies an RtcFoo in the encoded stream
// * The `bar` field has ID 1, is encoded as a VarInt
// (when not delta compressed), and wraps around after 32 bits.
// * The `baz` field has ID 2, is encoded as an 8-bit field
// (when not delta compressed), and wraps around after 1 bit.
// Note that the numerical field and event IDs can't be changed since
// that would break compatibility with old logs.
// In most cases (including all cases where wrap around isn't
// expected), the wrap around should be equal to the bitwidth of
// the field.
template <typename EventType, typename LoggedType, typename... Ts>
class RtcEventDefinition {
public:
constexpr RtcEventDefinition(
EventParameters params,
RtcEventFieldDefinition<EventType, LoggedType, Ts>... fields)
: params_(params), fields_(fields...) {}
std::string EncodeBatch(rtc::ArrayView<const RtcEvent*> batch) const {
EventEncoder encoder(params_, batch);
fields_.EncodeImpl(encoder, batch);
return encoder.AsString();
}
RtcEventLogParseStatus ParseBatch(absl::string_view s,
bool batched,
std::vector<LoggedType>& output) const {
EventParser parser;
auto status = parser.Initialize(s, batched);
if (!status.ok())
return status;
rtc::ArrayView<LoggedType> output_batch =
ExtendLoggedBatch(output, parser.NumEventsInBatch());
constexpr FieldParameters timestamp_params{"timestamp_ms",
FieldParameters::kTimestampField,
FieldType::kVarInt, 64};
RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>> result =
parser.ParseNumericField(timestamp_params);
if (!result.ok())
return result.status();
PopulateRtcEventTimestamp(result.value(), &LoggedType::timestamp,
output_batch);
return fields_.ParseImpl(parser, output_batch);
return RtcEventLogParseStatus::Success();
}
private:
EventParameters params_;
RtcEventDefinitionImpl<EventType, LoggedType, Ts...> fields_;
};
} // namespace webrtc
#endif // LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_DEFINITION_H_