data_view.hpp

/*
Copyright (c) 2017-2024,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
Energy, LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "../core/core-data.hpp"
#include "../core/helicsTime.hpp"
#include "helics/helics-config.h"
#include "helicsTypes.hpp"
 
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace helics {
class data_view {
  private:
    std::string_view dblock;  
    std::shared_ptr<const SmallBuffer>
        ref;  
  public:
    data_view() = default;
    ~data_view() = default;
    data_view(std::shared_ptr<const SmallBuffer> dt):
        dblock(dt->to_string()), ref(std::move(dt)) {}  // NOLINT
    data_view(const SmallBuffer& dt) noexcept: dblock(dt.to_string()) {}  // NOLINT
    data_view(const data_view& dt) noexcept = default;
    data_view(data_view&& dv) noexcept: dblock(dv.dblock), ref(std::move(dv.ref)) {}
    template<typename U,
             typename T = std::enable_if_t<std::is_constructible_v<std::string_view, U>>>
    data_view(U&& u) noexcept: dblock(std::forward<U>(u))  // NOLINT
    {
    }
    data_view(const char* dt, size_t len) noexcept: dblock(dt, len) {}
    data_view(SmallBuffer&& sb):
        data_view(std::make_shared<SmallBuffer>(std::move(sb))) {}  // NOLINT
    data_view(const std::vector<char>& dvec) noexcept:
        dblock(dvec.data(), dvec.size()) {}  // NOLINT
 
    data_view(const std::vector<double>& dvec) noexcept:
        dblock(reinterpret_cast<const char*>(dvec.data()), dvec.size() * sizeof(double))
    {
    }  // NOLINT
    data_view& operator=(const data_view& dv) noexcept = default;
 
    data_view& operator=(data_view&& dv) noexcept
    {
        dblock = dv.dblock;
        ref = std::move(dv.ref);
        return *this;
    }
 
    data_view& operator=(std::shared_ptr<const SmallBuffer> dt) noexcept
    {
        dblock = dt->to_string();
        ref = std::move(dt);
        return *this;
    }
    data_view& operator=(const SmallBuffer& dt) noexcept
    {
        dblock = dt.to_string();
        ref = nullptr;
        return *this;
    }
    data_view& operator=(const std::string_view& str) noexcept
    {
        dblock = str;
        ref = nullptr;
        return *this;
    }
    data_view& operator=(const char* s) noexcept
    {
        dblock = s;
        ref = nullptr;
        return *this;
    }
    SmallBuffer to_buffer() const { return SmallBuffer(dblock); }
    void swap(data_view& dv2) noexcept
    {
        dblock.swap(dv2.dblock);
        ref.swap(dv2.ref);
    }
    const char* data() const noexcept { return dblock.data(); }
    const std::byte* bytes() const noexcept
    {
        return reinterpret_cast<const std::byte*>(dblock.data());
    }
    size_t size() const noexcept { return dblock.length(); }
    bool empty() const noexcept { return dblock.empty(); }
    std::string string() const { return std::string(dblock); }
    std::string_view string_view() const { return dblock; }
    char operator[](int index) const { return dblock[index]; }
    auto begin() { return dblock.begin(); }
    auto end() { return dblock.end(); }
    auto cbegin() const { return dblock.cbegin(); }
    auto cend() const { return dblock.cend(); }
};
 
constexpr auto bvecstr = "block_vector";
 
template<>
inline const char* typeNameString<std::vector<SmallBuffer>>()
{
    return bvecstr;
}
 
}  // namespace helics
 
namespace std {
template<>
inline void swap(helics::data_view& db1, helics::data_view& db2) noexcept
{
    db1.swap(db2);
}
}  // namespace std