cpp98/Broker.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_BROKER_HPP_
#define HELICS_CPP98_BROKER_HPP_
#pragma once
 
#include "config.hpp"
#include "helics/helics.h"
#include "helicsExceptions.hpp"
 
#include <stdexcept>
#include <string>
 
namespace helicscpp {
class Broker {
  public:
    Broker() HELICS_NOTHROW: broker(HELICS_NULL_POINTER) {}
    Broker(std::string type, std::string name, std::string initString)
    {
        broker =
            helicsCreateBroker(type.c_str(), name.c_str(), initString.c_str(), hThrowOnError());
        if (helicsBrokerIsConnected(broker) != HELICS_TRUE) {
            throw(std::runtime_error("broker creation failed"));
        }
    }
    Broker(std::string type, std::string name, int argc, char** argv)
    {
        broker =
            helicsCreateBrokerFromArgs(type.c_str(), name.c_str(), argc, argv, hThrowOnError());
    }
    Broker(const Broker& brk) { broker = helicsBrokerClone(brk.broker, hThrowOnError()); }
    Broker& operator=(const Broker& brk)
    {
        broker = helicsBrokerClone(brk.broker, hThrowOnError());
        return *this;
    }
#ifdef HELICS_HAS_RVALUE_REFS
    Broker(Broker&& brk) HELICS_NOTHROW: broker(brk.broker) { brk.broker = HELICS_NULL_POINTER; }
    Broker& operator=(Broker&& brk) HELICS_NOTHROW
    {
        broker = brk.broker;
        brk.broker = HELICS_NULL_POINTER;
        return *this;
    }
#endif
    virtual ~Broker()
    {
        if (broker != HELICS_NULL_POINTER) {
            helicsBrokerFree(broker);
        }
    }
    operator HelicsBroker() { return broker; }
    HelicsBroker baseObject() const { return broker; }
    bool isConnected() const { return (helicsBrokerIsConnected(broker) != HELICS_FALSE); }
    bool waitForDisconnect(int msToWait = -1)
    {
        return (helicsBrokerWaitForDisconnect(broker, msToWait, hThrowOnError()) != HELICS_FALSE);
    }
    void disconnect() { helicsBrokerDisconnect(broker, hThrowOnError()); }
    const char* getIdentifier() const { return helicsBrokerGetIdentifier(broker); }
    const char* getAddress() const { return helicsBrokerGetAddress(broker); }
 
    void setGlobal(const std::string& valueName, const std::string& value)
    {
        helicsBrokerSetGlobal(broker, valueName.c_str(), value.c_str(), hThrowOnError());
    }
    void addAlias(const std::string& interfaceName, const std::string& alias)
    {
        helicsBrokerAddAlias(broker, interfaceName.c_str(), alias.c_str(), hThrowOnError());
    }
    void dataLink(const std::string& source, const std::string& target)
    {
        helicsBrokerDataLink(broker, source.c_str(), target.c_str(), hThrowOnError());
    }
    void addSourceFilterToEndpoint(const std::string& filter, const std::string& target)
    {
        helicsBrokerAddSourceFilterToEndpoint(broker,
                                              filter.c_str(),
                                              target.c_str(),
                                              hThrowOnError());
    }
    void addDestinationFilterToEndpoint(const std::string& filter, const std::string& target)
    {
        helicsBrokerAddDestinationFilterToEndpoint(broker,
                                                   filter.c_str(),
                                                   target.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(helicsQueryBrokerExecute(q, broker, hThrowOnError()));
        helicsQueryFree(q);
        return result;
    }
 
    void sendCommand(const std::string& target, const std::string& command)
    {
        helicsBrokerSendCommand(broker, target.c_str(), command.c_str(), hThrowOnError());
    }
 
    void setTimeBarrier(HelicsTime barrierTime)
    {
        helicsBrokerSetTimeBarrier(broker, barrierTime, HELICS_IGNORE_ERROR);
    }
 
    void clearTimeBarrier() { helicsBrokerClearTimeBarrier(broker); }
 
    void globalError(int errorCode, const std::string& errorString)
    {
        helicsBrokerGlobalError(broker, errorCode, errorString.c_str(), HELICS_IGNORE_ERROR);
    }
 
  protected:
    HelicsBroker broker;  
};
 
}  // namespace helicscpp
#endif