zircon/system/ulib/inspect-vmo/types.cpp

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "fbl/string_piece.h"
#include <lib/inspect-vmo/state.h>
#include <lib/inspect-vmo/types.h>

namespace inspect {
namespace vmo {

template <>
internal::NumericMetric<int64_t>::~NumericMetric<int64_t>() {
    if (state_) {
        state_->FreeIntMetric(this);
    }
}

template <>
internal::NumericMetric<int64_t>& internal::NumericMetric<int64_t>::
operator=(internal::NumericMetric<int64_t>&& other) {
    if (state_) {
        state_->FreeIntMetric(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

template <>
void internal::NumericMetric<int64_t>::Set(int64_t value) {
    if (state_) {
        state_->SetIntMetric(this, value);
    }
}

template <>
void internal::NumericMetric<int64_t>::Add(int64_t value) {
    if (state_) {
        state_->AddIntMetric(this, value);
    }
}

template <>
void internal::NumericMetric<int64_t>::Subtract(int64_t value) {
    if (state_) {
        state_->SubtractIntMetric(this, value);
    }
}

template <>
internal::NumericMetric<uint64_t>::~NumericMetric<uint64_t>() {
    if (state_) {
        state_->FreeUintMetric(this);
    }
}

template <>
internal::NumericMetric<uint64_t>& internal::NumericMetric<uint64_t>::
operator=(internal::NumericMetric<uint64_t>&& other) {
    if (state_) {
        state_->FreeUintMetric(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

template <>
void internal::NumericMetric<uint64_t>::Set(uint64_t value) {
    if (state_) {
        state_->SetUintMetric(this, value);
    }
}

template <>
void internal::NumericMetric<uint64_t>::Add(uint64_t value) {
    if (state_) {
        state_->AddUintMetric(this, value);
    }
}

template <>
void internal::NumericMetric<uint64_t>::Subtract(uint64_t value) {
    if (state_) {
        state_->SubtractUintMetric(this, value);
    }
}

template <>
internal::NumericMetric<double>::~NumericMetric<double>() {
    if (state_) {
        state_->FreeDoubleMetric(this);
    }
}

template <>
internal::NumericMetric<double>& internal::NumericMetric<double>::
operator=(internal::NumericMetric<double>&& other) {
    if (state_) {
        state_->FreeDoubleMetric(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

template <>
void internal::NumericMetric<double>::Set(double value) {
    if (state_) {
        state_->SetDoubleMetric(this, value);
    }
}

template <>
void internal::NumericMetric<double>::Add(double value) {
    if (state_) {
        state_->AddDoubleMetric(this, value);
    }
}

template <>
void internal::NumericMetric<double>::Subtract(double value) {
    if (state_) {
        state_->SubtractDoubleMetric(this, value);
    }
}

template <>
internal::ArrayValue<int64_t>::~ArrayValue<int64_t>() {
    if (state_) {
        state_->FreeIntArray(this);
    }
}

template <>
internal::ArrayValue<int64_t>& internal::ArrayValue<int64_t>::
operator=(internal::ArrayValue<int64_t>&& other) {
    if (state_) {
        state_->FreeIntArray(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

template <>
void internal::ArrayValue<int64_t>::Set(size_t index, int64_t value) {
    if (state_) {
        state_->SetIntArray(this, index, value);
    }
}

template <>
void internal::ArrayValue<int64_t>::Add(size_t index, int64_t value) {
    if (state_) {
        state_->AddIntArray(this, index, value);
    }
}

template <>
void internal::ArrayValue<int64_t>::Subtract(size_t index, int64_t value) {
    if (state_) {
        state_->SubtractIntArray(this, index, value);
    }
}

template <>
internal::ArrayValue<uint64_t>::~ArrayValue<uint64_t>() {
    if (state_) {
        state_->FreeUintArray(this);
    }
}

template <>
internal::ArrayValue<uint64_t>& internal::ArrayValue<uint64_t>::
operator=(internal::ArrayValue<uint64_t>&& other) {
    if (state_) {
        state_->FreeUintArray(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

template <>
void internal::ArrayValue<uint64_t>::Set(size_t index, uint64_t value) {
    if (state_) {
        state_->SetUintArray(this, index, value);
    }
}

template <>
void internal::ArrayValue<uint64_t>::Add(size_t index, uint64_t value) {
    if (state_) {
        state_->AddUintArray(this, index, value);
    }
}

template <>
void internal::ArrayValue<uint64_t>::Subtract(size_t index, uint64_t value) {
    if (state_) {
        state_->SubtractUintArray(this, index, value);
    }
}

template <>
internal::ArrayValue<double>::~ArrayValue<double>() {
    if (state_) {
        state_->FreeDoubleArray(this);
    }
}

template <>
internal::ArrayValue<double>& internal::ArrayValue<double>::
operator=(internal::ArrayValue<double>&& other) {
    if (state_) {
        state_->FreeDoubleArray(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

template <>
void internal::ArrayValue<double>::Set(size_t index, double value) {
    if (state_) {
        state_->SetDoubleArray(this, index, value);
    }
}

template <>
void internal::ArrayValue<double>::Add(size_t index, double value) {
    if (state_) {
        state_->AddDoubleArray(this, index, value);
    }
}

template <>
void internal::ArrayValue<double>::Subtract(size_t index, double value) {
    if (state_) {
        state_->SubtractDoubleArray(this, index, value);
    }
}

Property::~Property() {
    if (state_) {
        state_->FreeProperty(this);
    }
}

Property& Property::operator=(Property&& other) {
    if (state_) {
        state_->FreeProperty(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

void Property::Set(fbl::StringPiece value) {
    if (state_) {
        state_->SetProperty(this, value);
    }
}

Object::~Object() {
    if (state_) {
        state_->FreeObject(this);
    }
}

Object& Object::operator=(Object&& other) {
    if (state_) {
        state_->FreeObject(this);
    }
    state_ = std::move(other.state_);
    name_index_ = std::move(other.name_index_);
    value_index_ = std::move(other.value_index_);
    return *this;
}

Object Object::CreateChild(fbl::StringPiece name) {
    if (state_) {
        return state_->CreateObject(name, value_index_);
    }
    return Object();
}

IntMetric Object::CreateIntMetric(fbl::StringPiece name, int64_t value) {
    if (state_) {
        return state_->CreateIntMetric(name, value_index_, value);
    }
    return IntMetric();
}

UintMetric Object::CreateUintMetric(fbl::StringPiece name, uint64_t value) {
    if (state_) {
        return state_->CreateUintMetric(name, value_index_, value);
    }
    return UintMetric();
}

DoubleMetric Object::CreateDoubleMetric(fbl::StringPiece name, double value) {
    if (state_) {
        return state_->CreateDoubleMetric(name, value_index_, value);
    }
    return DoubleMetric();
}

Property Object::CreateProperty(fbl::StringPiece name, fbl::StringPiece value, PropertyFormat format) {
    if (state_) {
        return state_->CreateProperty(name, value_index_, value, format);
    }
    return Property();
}

IntArray Object::CreateIntArray(fbl::StringPiece name, size_t slots, ArrayFormat format) {
    if (state_) {
        return state_->CreateIntArray(name, value_index_, slots, format);
    }
    return IntArray();
}

UintArray Object::CreateUintArray(fbl::StringPiece name, size_t slots, ArrayFormat format) {
    if (state_) {
        return state_->CreateUintArray(name, value_index_, slots, format);
    }
    return UintArray();
}

DoubleArray Object::CreateDoubleArray(fbl::StringPiece name, size_t slots, ArrayFormat format) {
    if (state_) {
        return state_->CreateDoubleArray(name, value_index_, slots, format);
    }
    return DoubleArray();
}

namespace {
const size_t kExtraSlotsForLinearHistogram = 4;
const size_t kExtraSlotsForExponentialHistogram = 5;
} // namespace

LinearIntHistogram Object::CreateLinearIntHistogram(
    fbl::StringPiece name, int64_t floor, int64_t step_size, size_t buckets) {
    if (state_) {
        const size_t slots = buckets + kExtraSlotsForLinearHistogram;
        auto array = state_->CreateIntArray(
            name, value_index_, slots, ArrayFormat::kLinearHistogram);
        return LinearIntHistogram(floor, step_size, slots, std::move(array));
    }
    return LinearIntHistogram();
}

LinearUintHistogram Object::CreateLinearUintHistogram(
    fbl::StringPiece name, uint64_t floor, uint64_t step_size, size_t buckets) {
    if (state_) {
        const size_t slots = buckets + kExtraSlotsForLinearHistogram;
        auto array = state_->CreateUintArray(
            name, value_index_, slots, ArrayFormat::kLinearHistogram);
        return LinearUintHistogram(floor, step_size, slots, std::move(array));
    }
    return LinearUintHistogram();
}

LinearDoubleHistogram Object::CreateLinearDoubleHistogram(
    fbl::StringPiece name, double floor, double step_size, size_t buckets) {
    if (state_) {
        const size_t slots = buckets + kExtraSlotsForLinearHistogram;
        auto array = state_->CreateDoubleArray(
            name, value_index_, slots, ArrayFormat::kLinearHistogram);
        return LinearDoubleHistogram(floor, step_size, slots, std::move(array));
    }
    return LinearDoubleHistogram();
}

ExponentialIntHistogram Object::CreateExponentialIntHistogram(
    fbl::StringPiece name, int64_t floor, int64_t initial_step, int64_t step_multiplier, size_t buckets) {
    if (state_) {
        const size_t slots = buckets + kExtraSlotsForExponentialHistogram;
        auto array = state_->CreateIntArray(
            name, value_index_, slots, ArrayFormat::kExponentialHistogram);
        return ExponentialIntHistogram(floor, initial_step, step_multiplier, slots, std::move(array));
    }
    return ExponentialIntHistogram();
}

ExponentialUintHistogram Object::CreateExponentialUintHistogram(
    fbl::StringPiece name, uint64_t floor, uint64_t initial_step, uint64_t step_multiplier, size_t buckets) {
    if (state_) {
        const size_t slots = buckets + kExtraSlotsForExponentialHistogram;
        auto array = state_->CreateUintArray(
            name, value_index_, slots, ArrayFormat::kExponentialHistogram);
        return ExponentialUintHistogram(floor, initial_step, step_multiplier, slots, std::move(array));
    }
    return ExponentialUintHistogram();
}

ExponentialDoubleHistogram Object::CreateExponentialDoubleHistogram(
    fbl::StringPiece name, double floor, double initial_step, double step_multiplier, size_t buckets) {
    if (state_) {
        const size_t slots = buckets + kExtraSlotsForExponentialHistogram;
        auto array = state_->CreateDoubleArray(
            name, value_index_, slots, ArrayFormat::kExponentialHistogram);
        return ExponentialDoubleHistogram(floor, initial_step, step_multiplier, slots, std::move(array));
    }
    return ExponentialDoubleHistogram();
}

} // namespace vmo
} // namespace inspect