DataBuffer.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
*/
#ifndef HELICS_CPP98_DATABUFFER_HPP_
#define HELICS_CPP98_DATABUFFER_HPP_
 
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <complex>
#include <string>
#include <vector>
 
namespace helicscpp {
class DataBuffer {
  public:
    DataBuffer() HELICS_NOTHROW: buff(helicsCreateDataBuffer(0)) {}
    explicit DataBuffer(int capacity): buff(helicsCreateDataBuffer(capacity)) {}
    explicit DataBuffer(HelicsDataBuffer buffer): buff(buffer) {}
    DataBuffer(void* buffer, int32_t datasize, int32_t capacity):
        buff(helicsWrapDataInBuffer(buffer, datasize, capacity))
    {
    }
    ~DataBuffer() { helicsDataBufferFree(buff); }
    void fill(double val) { helicsDataBufferFillFromDouble(buff, val); }
    void fill(int64_t val) { helicsDataBufferFillFromInteger(buff, val); }
    void fill(const std::string& val) { helicsDataBufferFillFromString(buff, val.c_str()); }
    void fill(const char* val) { helicsDataBufferFillFromString(buff, val); }
    void fill(const std::vector<double>& val)
    {
        helicsDataBufferFillFromVector(buff, val.data(), static_cast<int>(val.size()));
    }
    void fill(const std::complex<double> val)
    {
        helicsDataBufferFillFromComplex(buff, val.real(), val.imag());
    }
    void fill(const double* vals, int size) { helicsDataBufferFillFromVector(buff, vals, size); }
    void fill(const std::string& name, double val)
    {
        helicsDataBufferFillFromNamedPoint(buff, name.c_str(), val);
    }
    void fill(bool val) { helicsDataBufferFillFromBoolean(buff, val ? HELICS_TRUE : HELICS_FALSE); }
    void fill(char val) { helicsDataBufferFillFromChar(buff, val); }
    DataBuffer clone() { return DataBuffer(helicsDataBufferClone(buff)); }
    int size() { return helicsDataBufferSize(buff); }
 
    int capacity() { return helicsDataBufferCapacity(buff); }
    void* data() { return helicsDataBufferData(buff); }
    bool reserve(int32_t newCapacity)
    {
        return helicsDataBufferReserve(buff, newCapacity) == HELICS_TRUE;
    }
    int stringSize() { return helicsDataBufferStringSize(buff); }
    int vectorSize() { return helicsDataBufferVectorSize(buff); }
    int type() const { return helicsDataBufferType(buff); }
    bool isValid() const { return (helicsDataBufferIsValid(buff) == HELICS_TRUE); }
    std::string toString()
    {
        int size = stringSize();
        std::string result;
 
        result.resize(static_cast<size_t>(size) + 1);
        // this function results in a null terminated string
        helicsDataBufferToString(buff, &result[0], size + 1, &size);
        if (!(result.empty()) && (result[static_cast<size_t>(size) - 1] == '\0')) {
            result.resize(static_cast<size_t>(size) - 1);
        } else {
            result.resize(size);
        }
        return result;
    }
 
    void toString(std::string& str)
    {
        int size = stringSize();
        str.resize(static_cast<size_t>(size) + 1);
        // this function results in a null terminated string
        helicsDataBufferToString(buff, &str[0], size + 1, &size);
        if (!(str.empty()) && (str[static_cast<size_t>(size) - 1] == '\0')) {
            str.resize(static_cast<size_t>(size) - 1);
        } else {
            str.resize(size);
        }
    }
 
    void toNamedPoint(std::string& name, double* val)
    {
        int size = helicsDataBufferStringSize(buff);
 
        name.resize(static_cast<size_t>(size) + 1);
        // this function results in a null terminated string
        helicsDataBufferToNamedPoint(buff, &name[0], size + 1, &size, val);
        name.resize(size);
    }
    int64_t toInt() { return helicsDataBufferToInteger(buff); }
    bool toBoolean()
    {
        HelicsBool val = helicsDataBufferToBoolean(buff);
        return (val == HELICS_TRUE);
    }
    double toDouble() { return helicsDataBufferToDouble(buff); }
    std::complex<double> toComplex()
    {
        HelicsComplex hc = helicsDataBufferToComplexObject(buff);
        std::complex<double> result(hc.real, hc.imag);
        return result;
    }
    int toVector(double* data, int maxlen)
    {
        helicsDataBufferToVector(buff, data, maxlen, &maxlen);
        // maxlen contains the actual length now
        return maxlen;
    }
    void toVector(std::vector<double>& data)
    {
        int actualSize = helicsDataBufferVectorSize(buff);
        data.resize(actualSize);
        helicsDataBufferToVector(buff, data.data(), actualSize, HELICS_NULL_POINTER);
    }
 
    int toComplexVector(double* data, int maxlen)
    {
        helicsDataBufferToComplexVector(buff, data, maxlen, &maxlen);
        // maxlen contains the actual length now
        return maxlen;
    }
    bool convertToType(int newDataType)
    {
        return (helicsDataBufferConvertToType(buff, newDataType) == HELICS_TRUE);
    }
    HelicsDataBuffer getHelicsDataBuffer() { return buff; }
 
  private:
    HelicsDataBuffer buff;
};
}  // namespace helicscpp
#endif