Input.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_INPUT_HPP_
#define HELICS_CPP98_INPUT_HPP_
#pragma once
 
#include "DataBuffer.hpp"
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <complex>
#include <string>
#include <vector>
 
namespace helicscpp {
class Input {
  public:
    explicit Input(HelicsInput hsub) HELICS_NOTHROW: inp(hsub) {}
    Input() HELICS_NOTHROW: inp(HELICS_NULL_POINTER) {}
    Input(const Input& inputs) HELICS_NOTHROW: inp(inputs.inp) {}
    Input& operator=(const Input& input)
    {
        inp = input.inp;
        return *this;
    }
    operator HelicsInput() const { return inp; }
    HelicsInput baseObject() const { return inp; }
    bool isValid() const { return (helicsInputIsValid(inp) == HELICS_TRUE); }
    void addTarget(const std::string& target)
    {
        helicsInputAddTarget(inp, target.c_str(), HELICS_IGNORE_ERROR);
    }
    void setDefault(const char* data, int len)
    {
        helicsInputSetDefaultBytes(inp, data, len, HELICS_IGNORE_ERROR);
    }
    void setDefault(const std::string& str)
    {
        helicsInputSetDefaultString(inp, str.c_str(), HELICS_IGNORE_ERROR);
    }
    void setDefault(int64_t val) { helicsInputSetDefaultInteger(inp, val, HELICS_IGNORE_ERROR); }
    void setDefault(bool val)
    {
        helicsInputSetDefaultBoolean(inp, val ? HELICS_TRUE : HELICS_FALSE, HELICS_IGNORE_ERROR);
    }
    void setDefault(double val) { helicsInputSetDefaultDouble(inp, val, HELICS_IGNORE_ERROR); }
    void setDefault(const std::complex<double>& cmplx)
    {
        helicsInputSetDefaultComplex(inp, cmplx.real(), cmplx.imag(), HELICS_IGNORE_ERROR);
    }
 
    void setDefault(const std::vector<double>& data)
    {
        helicsInputSetDefaultVector(inp,
                                    data.data(),
                                    static_cast<int>(data.size()),
                                    HELICS_IGNORE_ERROR);
    }
 
#if defined(__GNUC__)
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wstrict-aliasing"
    // std::complex is explicitly allowed to alias like this in the standard
#endif
    void setDefault(const std::vector<std::complex<double> >& data)
    {
        helicsInputSetDefaultComplexVector(inp,
                                           reinterpret_cast<const double*>(data.data()),
                                           static_cast<int>(data.size()),
                                           HELICS_IGNORE_ERROR);
    }
#if defined(__GNUC__)
#    pragma GCC diagnostic pop
#endif
    int getBytes(std::vector<char>& data)
    {
        int size = helicsInputGetByteCount(inp);
        data.resize(size);
        helicsInputGetBytes(
            inp, data.data(), static_cast<int>(data.size()), &size, HELICS_IGNORE_ERROR);
        return size;
    }
    int getByteCount() { return helicsInputGetByteCount(inp); }
 
    int getStringSize()
    {
        //-1 is for the null character which needs to be counted in C but not in a C++ string
        return helicsInputGetStringSize(inp) - 1;
    }
 
    std::string getString()
    {
        int size = helicsInputGetStringSize(inp);
        std::string result;
 
        result.resize(static_cast<size_t>(size) + 1);
        // this function results in a null terminated string
        helicsInputGetString(inp, &result[0], size + 1, &size, HELICS_IGNORE_ERROR);
        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 getString(std::string& str)
    {
        int size = helicsInputGetStringSize(inp);
        str.resize(static_cast<size_t>(size) + 1);
        // this function results in a null terminated string
        helicsInputGetString(inp, &str[0], size + 1, &size, HELICS_IGNORE_ERROR);
        if (!(str.empty()) && (str[static_cast<size_t>(size) - 1] == '\0')) {
            str.resize(static_cast<size_t>(size) - 1);
        } else {
            str.resize(size);
        }
    }
 
    void getNamedPoint(std::string& name, double* val)
    {
        int size = helicsInputGetStringSize(inp);
 
        name.resize(static_cast<size_t>(size) + 1);
        // this function results in a null terminated string
        helicsInputGetNamedPoint(inp, &name[0], size + 1, &size, val, HELICS_IGNORE_ERROR);
        name.resize(size);
    }
    int64_t getInteger() { return helicsInputGetInteger(inp, HELICS_IGNORE_ERROR); }
    bool getBoolean()
    {
        HelicsBool val = helicsInputGetBoolean(inp, HELICS_IGNORE_ERROR);
        return (val == HELICS_TRUE);
    }
    double getDouble() { return helicsInputGetDouble(inp, HELICS_IGNORE_ERROR); }
    std::complex<double> getComplex()
    {
        HelicsComplex hc = helicsInputGetComplexObject(inp, HELICS_IGNORE_ERROR);
        std::complex<double> result(hc.real, hc.imag);
        return result;
    }
    int getVector(double* data, int maxlen)
    {
        helicsInputGetVector(inp, data, maxlen, &maxlen, hThrowOnError());
        // maxlen contains the actual length now
        return maxlen;
    }
    void getVector(std::vector<double>& data)
    {
        int actualSize = helicsInputGetVectorSize(inp);
        data.resize(actualSize);
        helicsInputGetVector(inp, data.data(), actualSize, HELICS_NULL_POINTER, hThrowOnError());
    }
 
    int getComplexVector(double* data, int maxlen)
    {
        helicsInputGetComplexVector(inp, data, maxlen, &maxlen, hThrowOnError());
        // maxlen contains the actual length now
        return maxlen;
    }
#if defined(__GNUC__)
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wstrict-aliasing"
    // std::complex is explicitly allowed to alias like this in the standard
#endif
    void getComplexVector(std::vector<std::complex<double> >& data)
    {
        int actualSize = helicsInputGetVectorSize(inp);
        data.resize(actualSize);
        helicsInputGetComplexVector(inp,
                                    reinterpret_cast<double*>(data.data()),
                                    actualSize,
                                    HELICS_NULL_POINTER,
                                    hThrowOnError());
    }
#if defined(__GNUC__)
#    pragma GCC diagnostic pop
#endif
    DataBuffer getDataBuffer()
    {
        return DataBuffer(helicsInputGetDataBuffer(inp, hThrowOnError()));
    }
    bool isUpdated() const { return (helicsInputIsUpdated(inp) > 0); }
 
    HelicsTime getLastUpdateTime() const { return helicsInputLastUpdateTime(inp); }
 
    void clearUpdate() { helicsInputClearUpdate(inp); }
    // call helicsInputIsUpdated for each inp
 
    const char* getName() const { return helicsInputGetName(inp); }
    const char* getUnits() const { return helicsInputGetExtractionUnits(inp); }
    const char* getInjectionUnits() const { return helicsInputGetInjectionUnits(inp); }
    const char* getPublicationType() const { return helicsInputGetPublicationType(inp); }
    const char* getType() const { return helicsInputGetType(inp); }
    const char* getTarget() const { return helicsInputGetTarget(inp); }
    const char* getInfo() const { return helicsInputGetInfo(inp); }
    void setInfo(const std::string& info)
    {
        helicsInputSetInfo(inp, info.c_str(), HELICS_IGNORE_ERROR);
    }
    const char* getTag(const std::string& tagname) const
    {
        return helicsInputGetTag(inp, tagname.c_str());
    }
    void setTag(const std::string& tagname, const std::string& tagvalue)
    {
        helicsInputSetTag(inp, tagname.c_str(), tagvalue.c_str(), HELICS_IGNORE_ERROR);
    }
    void setOption(int32_t option, int32_t value = 1)
    {
        helicsInputSetOption(inp, option, value, HELICS_IGNORE_ERROR);
    }
    int32_t getOption(int32_t option) { return helicsInputGetOption(inp, option); }
 
  private:
    HelicsInput inp;  
};
 
}  // namespace helicscpp
#endif