tec_net_data.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-16 15:42:51 by magnolia>
/*----------------------------------------------------------------------
------------------------------------------------------------------------
Copyright (c) 2020-2026 The Emacs Cat (https://github.com/olddeuteronomy/tec).
 
   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.
------------------------------------------------------------------------
----------------------------------------------------------------------*/
 
#pragma once
 
#include <cstddef>
#include <cstdio>
#include <string>
#include <type_traits>
 
#include "tec/tec_def.hpp" // IWYU pragma: keep
#include "tec/tec_memfile.hpp"
#include "tec/tec_container.hpp"
#include "tec/tec_serialize.hpp"
#include "tec/net/tec_nd_types.hpp"
 
 
namespace tec {
 
class NetData: public NdTypes {
public:
    Header header;
 
protected:
    Bytes data_;
 
public:
    NetData() = default;
 
    NetData(const NetData&) = delete;
 
    NetData(NetData&&) = delete;
 
    virtual ~NetData() = default;
 
    const Bytes& bytes() const {
        return data_;
    }
 
    const void* data() const {
        return data_.data();
    }
 
    void copy_from(const NetData& src) {
        header = src.header;
        data_.copy_from(src.bytes());
    }
 
    void move_from(NetData&& src, size_t size_to_shrink = 0) {
        header = src.header;
        data_.move_from(std::move(src.bytes()), size_to_shrink);
    }
 
    void rewind() {
        data_.rewind();
    }
 
    size_t size() const {
        return header.size;
    }
 
    size_t capacity() const {
        return data_.capacity();
    }
 
    Bytes& bytes() {
        return data_;
    }
 
public:
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                            STORE
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    template <typename T>
    NetData& operator << (const T& val) {
        ElemHeader hdr = get_info<T>(val);
        if( hdr.tag & Meta::Sequence ) {
            write_sequence(&hdr, &val);
        }
        else if(hdr.tag & Meta::Scalar) {
            write_scalar(&hdr, &val);
        }
        else if(hdr.tag == Tags::Object) {
            write_object(&hdr, val);
        }
        else if(hdr.tag == Tags::Map) {
            write_map(&hdr, val);
        }
        else if(hdr.tag == Tags::Container) {
            write_container(&hdr, val);
        }
 
        header.size = data_.size();
        return *this;
    }
 
protected:
 
    template <typename TMap>
    size_t write_map(ElemHeader* hdr, const TMap& map) {
        if constexpr (is_map_v<TMap>) {
            ElemHeader* hdr_ptr = (ElemHeader*)data_.ptr(data_.tell());
            // Write the map header.
            data_.write(hdr, sizeof(ElemHeader));
            size_t cur_pos = data_.tell();
            // Write all elements of a container.
            for( const auto& [key, value]: map ) {
                *this << key << value;
            }
            // Set actual container size.
            auto bytes_written = data_.tell() - cur_pos;
            hdr_ptr->size = bytes_written;
            return bytes_written;
        }
        return 0;
    }
 
    template <typename TContainer>
    size_t write_container(ElemHeader* hdr, const TContainer& container) {
        if constexpr (is_container_v<TContainer>) {
            ElemHeader* hdr_ptr = (ElemHeader*)data_.ptr(data_.tell());
            // Write the container header.
            data_.write(hdr, sizeof(ElemHeader));
            size_t cur_pos = data_.tell();
            // Write all elements of a container.
            for( const auto& e: container ) {
                *this << e;
            }
            // Set actual container size.
            auto bytes_written = data_.tell() - cur_pos;
            hdr_ptr->size = bytes_written;
            return bytes_written;
        }
        return 0;
    }
 
    template <typename TObject>
    size_t write_object(ElemHeader* hdr, const TObject& obj) {
        if constexpr (is_serializable_v<TObject>) {
            if constexpr (is_root_v<TObject>) {
                    header.id = obj.id();
            }
            ElemHeader* hdr_ptr = (ElemHeader*)data_.ptr(data_.tell());
            // Write the object header.
            data_.write(hdr, sizeof(ElemHeader));
            size_t cur_pos = data_.tell();
            // Write an object
            obj.store(std::ref(*this));
            // Set actual object size.
            auto bytes_written = data_.tell() - cur_pos;
            hdr_ptr->size = bytes_written;
            return bytes_written;
        }
        return 0;
    }
 
    virtual size_t write_long_double_64(ElemHeader* hdr, const double* d64) {
        double dst[2]{*d64, 0.0};
        data_.write(dst, hdr->size);
        return hdr->size;
    }
 
    virtual size_t write_scalar(ElemHeader* hdr, const void* p) {
        data_.write(hdr, sizeof(ElemHeader));
        if(sizeof(long double) == 8 && hdr->tag == Tags::F128) {
            // On Windows, sizeof(long double) == sizeof(double) == 8,
            // but we always use 16-byte for storing long double.
            return write_long_double_64(hdr, static_cast<const double*>(p));
        }
        data_.write(p, hdr->size);
        return hdr->size;
    }
 
    virtual size_t write_sequence(ElemHeader* hdr, const void* p) {
        // Write the sequence header.
        data_.write(hdr, sizeof(ElemHeader));
        if (hdr->size) {
            if( hdr->tag == Tags::SChar ) {
                const std::string* s = static_cast<const std::string*>(p);
                data_.write(s->data(), hdr->size);
            }
            else if( hdr->tag == Tags::SByte ) {
                const Blob* bs = static_cast<const Blob*>(p);
                data_.write(bs->data(), hdr->size);
            }
        }
        return hdr->size;
    }
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                            LOAD
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
public:
 
    template <typename T>
    NetData& operator >> (T& val) {
        ElemHeader hdr;
        data_.read(&hdr, sizeof(ElemHeader));
        // Object.
        if (hdr.tag == Tags::Object) {
            if constexpr(is_serializable_v<T>) {
                val.load(std::ref(*this));
            }
        }
        // Map.
        else if (hdr.tag == Tags::Map) {
            read_map(&hdr, val);
        }
        // Container (but not a String!).
        else if (hdr.tag == Tags::Container) {
            read_container(&hdr, val);
        }
        // Scalar (including sequences).
        else {
            read(&hdr, &val);
        }
        return *this;
    }
 
protected:
 
    template <typename TMap>
    void read_map(ElemHeader* hdr, TMap& map) {
        if constexpr(is_map_v<TMap>) {
            for( size_t n = 0 ; n < hdr->count ; ++n ) {
                typename TMap::key_type k;
                typename TMap::mapped_type e;
                *this >> k >> e;
                map[k] = e;
            }
        }
    }
 
    template <typename TContainer>
    void read_container(ElemHeader* hdr, TContainer& c) {
        if constexpr(
            is_container_v<TContainer>  &&
            !is_map_v<TContainer> &&
            !std::is_same_v<TContainer, String>
            ) {
            for( size_t n = 0 ; n < hdr->count ; ++n ) {
                typename TContainer::value_type e;
                *this >> e;
                c.push_back(e);
            }
        }
    }
 
    virtual void read(ElemHeader* hdr, void* dst) {
        if( hdr->tag & Meta::Scalar) {
            if( hdr->tag & Meta::Sequence ) {
                read_sequence(hdr, dst);
            }
            else {
                read_scalar(hdr, dst);
            }
        }
        else {
            // Skip unknown element.
            data_.seek(hdr->size, SEEK_CUR);
        }
    }
 
    virtual void read_long_double_64(const ElemHeader* hdr, double* d64) {
        double d[2]{0.0, 0.0};
        data_.read(d, hdr->size);
        *d64 = d[0];
    }
 
    virtual void read_scalar(const ElemHeader* hdr, void* dst) {
        if(sizeof(long double) == 8 && hdr->tag == Tags::F128) {
            // On Windows, sizeof(long double) == sizeof(double) == 8
            read_long_double_64(hdr, static_cast<double*>(dst));
        }
        else {
            data_.read(dst, hdr->size);
        }
    }
 
    virtual void read_sequence(const ElemHeader* hdr, void* dst) {
        if (hdr->size) {
            if( hdr->tag == Tags::SChar ) {
                std::string* str = static_cast<String*>(dst);
                str->resize(hdr->size);
                // To avoid silly GCC warning.
                data_.read(&str->at(0), hdr->size);
            }
            else if( hdr->tag == Tags::SByte ) {
                Blob* bytes = static_cast<Blob*>(dst);
                bytes->resize(hdr->size);
                data_.read(bytes->data(), hdr->size);
            }
        }
    }
 
public:
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                         NetData streams
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    struct StreamIn {
        NetData* nd;
 
        StreamIn()
            : nd{nullptr}
            {}
 
        explicit StreamIn(NetData* _nd)
            : nd{_nd}
            {}
    };
 
    struct StreamOut {
        NetData* nd;
 
        StreamOut()
            : nd{nullptr}
            {}
 
        explicit StreamOut(NetData* _nd)
            : nd{_nd}
            {}
    };
 
 
}; // class NetData
 
 
} // namespace tec