variable.h

Go to the documentation of this file.

/*
    Philote C++ Bindings
 
    Copyright 2022-2025 Christopher A. Lupp
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
        http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
 
    This work has been cleared for public release, distribution unlimited, case
    number: AFRL-2023-5716.
 
    The views expressed are those of the authors and do not reflect the
    official guidance or position of the United States Government, the
    Department of Defense or of the United States Air Force.
 
    Statement from DoD: The Appearance of external hyperlinks does not
    constitute endorsement by the United States Department of Defense (DoD) of
    the linked websites, of the information, products, or services contained
    therein. The DoD does not exercise any editorial, security, or other
    control over the information you may find at these locations.
*/
#pragma once
 
#include <string>
#include <map>
#include <vector>
 
#include <data.pb.h>
#include <disciplines.grpc.pb.h>
 
namespace philote
{
    class Variable
    {
    public:
        Variable() = default;
 
        Variable(const philote::VariableType &type,
                 const std::vector<size_t> &shape);
 
        explicit Variable(const philote::VariableMetaData &meta);
 
        explicit Variable(const philote::PartialsMetaData &meta);
 
        ~Variable() noexcept = default;
 
        void Segment(const size_t &start, const size_t &end,
                     const std::vector<double> &data);
 
        std::vector<double> Segment(const size_t &start, const size_t &end) const;
 
        std::vector<size_t> Shape() const noexcept;
 
        size_t Size() const noexcept;
 
        double operator()(const size_t &i) const;
 
        double &operator()(const size_t &i);
 
        philote::Array CreateChunk(const size_t &start, const size_t &end) const;
 
        void Send(std::string name,
                  std::string subname,
                  grpc::ClientReaderWriter<::philote::Array, ::philote::Array> *stream,
                  const size_t &chunk_size) const;
 
        void Send(std::string name,
                  std::string subname,
                  grpc::ServerReaderWriterInterface<::philote::Array, ::philote::Array> *stream,
                  const size_t &chunk_size,
                  grpc::ServerContext* context = nullptr) const;
 
        void Send(std::string name,
                  std::string subname,
                  grpc::ClientReaderWriterInterface<::philote::Array, ::philote::Array> *stream,
                  const size_t &chunk_size) const;
 
        void AssignChunk(const Array &data);
 
    private:
        philote::VariableType type_;
 
        std::vector<size_t> shape_;
 
        std::vector<double> data_;
 
        std::vector<int64_t> discrete_data_;
    };
 
    template<typename T>
    class PairDict
    {
    public:
        PairDict() = default;
 
        PairDict(const PairDict&) = default;
 
        PairDict& operator=(const PairDict&) = default;
 
        PairDict(PairDict&&) noexcept = default;
 
        PairDict& operator=(PairDict&&) noexcept = default;
 
        ~PairDict() noexcept = default;
 
        T& operator()(const std::string& key1, const std::string& key2)
        {
            return data_[std::make_pair(key1, key2)];
        }
 
        const T& operator()(const std::string& key1, const std::string& key2) const
        {
            return data_.at(std::make_pair(key1, key2));
        }
 
        bool contains(const std::string& key1, const std::string& key2) const noexcept
        {
            return data_.find(std::make_pair(key1, key2)) != data_.end();
        }
 
        size_t size() const noexcept
        {
            return data_.size();
        }
 
        bool empty() const noexcept
        {
            return data_.empty();
        }
 
        void clear()
        {
            data_.clear();
        }
 
        auto begin() { return data_.begin(); }
        auto begin() const { return data_.begin(); }
 
        auto end() { return data_.end(); }
        auto end() const { return data_.end(); }
 
    private:
        std::map<std::pair<std::string, std::string>, T> data_;
    };
 
    typedef std::map<std::string, philote::Variable> Variables;
    typedef std::map<std::pair<std::string, std::string>, philote::Variable> Partials;
    typedef PairDict<philote::Variable> PartialsPairDict;
}