127 lines
3.4 KiB
C++
127 lines
3.4 KiB
C++
// Copyright 2017 Google Inc. All Rights Reserved.
|
|
//
|
|
// This file contains the declarations for the Metric class and related
|
|
// types.
|
|
#ifndef WVCDM_METRICS_VALUE_METRIC_H_
|
|
#define WVCDM_METRICS_VALUE_METRIC_H_
|
|
|
|
#include <stdint.h>
|
|
#include <mutex>
|
|
#include <string>
|
|
|
|
#include "wv_metrics.pb.h"
|
|
|
|
namespace wvcdm {
|
|
namespace metrics {
|
|
|
|
// Internal namespace for helper methods.
|
|
namespace impl {
|
|
|
|
// Helper function for setting a value in the proto.
|
|
template <typename T>
|
|
void SetValue(drm_metrics::ValueMetric *value_proto, const T &value);
|
|
|
|
} // namespace impl
|
|
|
|
// The ValueMetric class supports storing a single, overwritable value or an
|
|
// error code. This class can be serialized to a drm_metrics::ValueMetric proto.
|
|
// If an error or value was not provided, this metric will serialize to nullptr.
|
|
//
|
|
// Example Usage:
|
|
// Metric<string> cdm_version().Record("a.b.c.d");
|
|
// std::unique_ptr<drm_metrics::ValueMetric> mymetric(
|
|
// cdm_version.ToProto());
|
|
//
|
|
// Example Error Usage:
|
|
//
|
|
// Metric<string> cdm_version().SetError(error_code);
|
|
// std::unique_ptr<drm_metrics::ValueMetric> mymetric(
|
|
// cdm_version.ToProto());
|
|
//
|
|
template <typename T>
|
|
class ValueMetric {
|
|
public:
|
|
// Constructs a metric with the given metric name.
|
|
explicit ValueMetric()
|
|
: error_code_(0), has_error_(false), has_value_(false) {}
|
|
|
|
// Record the value of the metric.
|
|
void Record(const T &value) {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
value_ = value;
|
|
has_value_ = true;
|
|
has_error_ = false;
|
|
}
|
|
|
|
// Set the error code if an error was encountered.
|
|
void SetError(int error_code) {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
error_code_ = error_code;
|
|
has_value_ = false;
|
|
has_error_ = true;
|
|
}
|
|
|
|
bool HasValue() const {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
return has_value_;
|
|
}
|
|
const T &GetValue() const {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
return value_;
|
|
}
|
|
|
|
bool HasError() const {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
return has_error_;
|
|
}
|
|
int GetError() const {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
return error_code_;
|
|
}
|
|
|
|
// Clears the indicators that the metric or error was set.
|
|
void Clear() {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
has_value_ = false;
|
|
has_error_ = false;
|
|
}
|
|
|
|
// Returns a new ValueMetric proto containing the metric value or the
|
|
// error code. If neither the error or value are set, it returns nullptr.
|
|
drm_metrics::ValueMetric *ToProto() const {
|
|
std::unique_lock<std::mutex> lock(internal_lock_);
|
|
if (has_error_) {
|
|
drm_metrics::ValueMetric *value_proto = new drm_metrics::ValueMetric;
|
|
value_proto->set_error_code(error_code_);
|
|
return value_proto;
|
|
} else if (has_value_) {
|
|
drm_metrics::ValueMetric *value_proto = new drm_metrics::ValueMetric;
|
|
impl::SetValue(value_proto, value_);
|
|
return value_proto;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
private:
|
|
T value_;
|
|
int error_code_;
|
|
bool has_error_;
|
|
bool has_value_;
|
|
|
|
/*
|
|
* This locks the internal state of the value metric to ensure safety
|
|
* across multiple threads preventing the caller from worrying about
|
|
* locking.
|
|
*
|
|
* This field must be declared mutable because the lock must be takeable even
|
|
* in const methods.
|
|
*/
|
|
mutable std::mutex internal_lock_;
|
|
};
|
|
|
|
} // namespace metrics
|
|
} // namespace wvcdm
|
|
|
|
#endif // WVCDM_METRICS_VALUE_METRIC_H_
|