timeseriesdata.hpp

// ---------------------------------------------------------------------
// This file is part of falcon-core.
//
// Copyright (C) 2021-present Neuro-Electronics Research Flanders
//
// Falcon-server is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Falcon-server is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with falcon-core. If not, see <http://www.gnu.org/licenses/>.
// ---------------------------------------------------------------------
 
#pragma once
 
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
 
#include "columnsdata/columnsdata.hpp"
#include "idata.hpp"
 
namespace nsTimeSeries {
 
struct Parameters : nsColumn::Parameters {
    Parameters(size_t nchan = 0, size_t nsamp = 0, double rate = 1.0)
        : nsColumn::Parameters(generate_labels(nchan), nsamp), sample_rate(rate) {}
 
    Parameters(const std::vector<std::string>& labels, size_t nsamp = 0, double rate = 1.0)
        : nsColumn::Parameters(labels, nsamp), sample_rate(rate) {}
 
    double sample_rate;
};
 
template <typename T>
using Base = ColumnsType<T>;
 
template <typename T>
class Data : public IData<Data<T>, Base<T>> {
    using BaseClass = IData<Data<T>, Base<T>>;
 
   public:
    typedef stride_iter<T*> column_iterator;
    typedef T* sample_iterator;

    Data(const std::vector<std::string>& labels, size_t nsamples, double sample_rate)
        : BaseClass(labels, nsamples) {
        if (sample_rate <= 0) {
            throw std::runtime_error(
                "Time Series Data::Data - sample rate "
                "needs to be larger than 0.");
        }
 
        sample_rate_ = sample_rate;
        timestamps_.resize(nsamples);
    }

    Data(size_t ncolumns, size_t nsamples, double sample_rate)
        : Data(generate_labels(ncolumns), ncolumns, nsamples, sample_rate) {}

    Data(const Parameters& parameters)
        : Data(parameters.labels, parameters.nsamples, parameters.sample_rate) {}
 
    static const std::string static_datatype() {
        return "time series [" + get_type_string<T>() + "]";
    }
    static const std::string static_dataname() { return "data"; }

    void ClearData() override {
        BaseClass::ClearData();
        std::fill(timestamps_.begin(), timestamps_.end(), 0);
    }
 
    Parameters parameters() const {
        return Parameters(this->labels_, this->nsamples_, sample_rate_);
    }
 
    double sample_rate() const { return sample_rate_; }

    uint64_t sample_timestamp(size_t sample = 0) const { return timestamps_[sample]; }

    const std::vector<uint64_t>& sample_timestamps() const { return timestamps_; }
    std::vector<uint64_t>& sample_timestamps() { return timestamps_; }

    void set_sample_timestamp(size_t sample, uint64_t t) {
        if (sample >= this->nsamples_) {
            throw std::out_of_range(". Sample index " + std::to_string(sample) +
                                    " out of range. Max index is " +
                                    std::to_string(this->nsamples_ - 1));
        } else {
            timestamps_[sample] = t;
        }
    }

    void set_sample_timestamps(const std::vector<uint64_t>& t) {
        if (t.size() != this->nsamples_) {
            throw std::length_error(
                ". the timestamps vector to set should have the same size as "
                "the number of samples (" +
                std::to_string(this->nsamples_) + " samples)");
        }
        timestamps_ = t;
    }

    void SerializeFlatBuffer(flexbuffers::Builder& flex_builder) override {
        BaseClass::SerializeFlatBuffer(flex_builder);
        flex_builder.TypedVector("timestamps", [&] {
            for (auto samples : timestamps_) flex_builder.Add(samples);
        });
    }

    void SerializeBinary(std::ostream& stream, Serialization::Format format =
                                                   Serialization::Format::FULL) const override {
        BaseClass::SerializeBinary(stream, format);
 
        if (format == Serialization::Format::FULL || format == Serialization::Format::COMPACT) {
            stream.write(reinterpret_cast<const char*>(timestamps_.data()),
                         timestamps_.size() * sizeof(uint64_t));
        }
    }
 
    std::string_view serialized_type_name() const override {
        if constexpr (std::is_same_v<T, double>) {
            return "TimeSeriesType<double>";
        } else if constexpr (std::is_same_v<T, float>) {
            return "TimeSeriesType<float>";
        } else if constexpr (std::is_same_v<T, uint8_t>) {
            return "TimeSeriesType<uint8_t>";
        } else {
            return "TimeSeriesType<Unknown>";
        }
    }

    void SerializeYAML(YAML::Node& node,
                       Serialization::Format format = Serialization::Format::FULL) const override {
        BaseClass::SerializeYAML(node, format);
 
        if (format == Serialization::Format::FULL || format == Serialization::Format::COMPACT) {
            node["timestamps"] = timestamps_;
        }
    }

    void YAMLDescription(YAML::Node& node, Serialization::Format format =
                                               Serialization::Format::FULL) const override {
        BaseClass::YAMLDescription(node, format);
 
        if (format == Serialization::Format::FULL) {
            node.push_back("timestamps uint64 (" + std::to_string(this->nsamples()) + ")");
        }
 
        if (format == Serialization::Format::COMPACT) {
            node.push_back("timestamps uint64 (1)");
        }
    }
 
   protected:
    double sample_rate_;
    std::vector<uint64_t> timestamps_;
};
 
using Capabilities = nsColumn::Capabilities;
}  // namespace nsTimeSeries
 
template <typename T>
using TimeSeriesType = DefineType<nsTimeSeries::Data<T>, ColumnsType<T>, false,
                                  nsTimeSeries::Capabilities, nsTimeSeries::Parameters>;