cpp98/Core.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_CORE_HPP_
#define HELICS_CPP98_CORE_HPP_
#pragma once
 
#include "Filter.hpp"
#include "config.hpp"
#include "helics/helics.h"
 
#include <stdexcept>
#include <string>
 
namespace helicscpp {
class Core {
  public:
    Core() HELICS_NOTHROW: core(HELICS_NULL_POINTER) {}
    Core(const std::string& type, const std::string& name, const std::string& initString)
    {
        core = helicsCreateCore(type.c_str(), name.c_str(), initString.c_str(), hThrowOnError());
    }
    Core(const std::string& type, const std::string& name, int argc, char** argv)
    {
        core = helicsCreateCoreFromArgs(type.c_str(), name.c_str(), argc, argv, hThrowOnError());
    }
    explicit Core(HelicsCore cr) HELICS_NOTHROW: core(cr) {}
 
    ~Core() { helicsCoreFree(core); }
    operator HelicsCore() { return core; }
    HelicsCore baseObject() const { return core; }
    bool isConnected() const { return (helicsCoreIsConnected(core) != HELICS_FALSE); }
    Core(const Core& cr) { core = helicsCoreClone(cr.core, hThrowOnError()); }
    Core& operator=(const Core& cr)
    {
        core = helicsCoreClone(cr.core, hThrowOnError());
        return *this;
    }
#ifdef HELICS_HAS_RVALUE_REFS
    Core(Core&& cr) HELICS_NOTHROW: core(cr.core) { cr.core = HELICS_NULL_POINTER; }
    Core& operator=(Core&& cr) HELICS_NOTHROW
    {
        core = cr.core;
        cr.core = HELICS_NULL_POINTER;
        return *this;
    }
#endif
    void setReadyToInit() { helicsCoreSetReadyToInit(core, hThrowOnError()); }
 
    void disconnect() { helicsCoreDisconnect(core, hThrowOnError()); }
    bool waitForDisconnect(int msToWait = -1)
    {
        return (helicsCoreWaitForDisconnect(core, msToWait, hThrowOnError()) != HELICS_FALSE);
    }
    const char* getIdentifier() const { return helicsCoreGetIdentifier(core); }
    const char* getAddress() const { return helicsCoreGetAddress(core); }
    Filter registerFilter(HelicsFilterTypes type, const std::string& name = std::string())
    {
        return Filter(helicsCoreRegisterFilter(core, type, name.c_str(), hThrowOnError()));
    }
 
    CloningFilter registerCloningFilter(const std::string& deliveryEndpoint)
    {
        return CloningFilter(
            helicsCoreRegisterCloningFilter(core, deliveryEndpoint.c_str(), hThrowOnError()));
    }
 
    void setGlobal(const std::string& valueName, const std::string& value)
    {
        helicsCoreSetGlobal(core, valueName.c_str(), value.c_str(), hThrowOnError());
    }
 
    void addAlias(const std::string& interfaceName, const std::string& alias)
    {
        helicsCoreAddAlias(core, interfaceName.c_str(), alias.c_str(), hThrowOnError());
    }
 
    void globalError(int errorCode, const std::string& errorString)
    {
        helicsCoreGlobalError(core, errorCode, errorString.c_str(), HELICS_IGNORE_ERROR);
    }
    void sendCommand(const std::string& target, const std::string& command)
    {
        helicsCoreSendCommand(core, target.c_str(), command.c_str(), hThrowOnError());
    }
 
    std::string query(const std::string& target,
                      const std::string& queryStr,
                      HelicsSequencingModes mode = HELICS_SEQUENCING_MODE_FAST) const
    {
        // returns HelicsQuery
        HelicsQuery q = helicsCreateQuery(target.c_str(), queryStr.c_str());
        if (mode != HELICS_SEQUENCING_MODE_FAST) {
            helicsQuerySetOrdering(q, mode, HELICS_IGNORE_ERROR);
        }
        std::string result(helicsQueryCoreExecute(q, core, hThrowOnError()));
        helicsQueryFree(q);
        return result;
    }
 
  protected:
    HelicsCore core;  
};
 
}  // namespace helicscpp
#endif