MessageFederate.h

Go to the documentation of this file.

/*
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_APISHARED_MESSAGE_FEDERATE_FUNCTIONS_H_
#define HELICS_APISHARED_MESSAGE_FEDERATE_FUNCTIONS_H_
 
#include "helicsCore.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* MessageFederate Calls*/
 
HELICS_EXPORT HelicsEndpoint helicsFederateRegisterEndpoint(HelicsFederate fed, const char* name, const char* type, HelicsError* err);
 
HELICS_EXPORT HelicsEndpoint helicsFederateRegisterGlobalEndpoint(HelicsFederate fed, const char* name, const char* type, HelicsError* err);
 
HELICS_EXPORT HelicsEndpoint helicsFederateRegisterTargetedEndpoint(HelicsFederate fed,
                                                                    const char* name,
                                                                    const char* type,
                                                                    HelicsError* err);
 
HELICS_EXPORT HelicsEndpoint helicsFederateRegisterGlobalTargetedEndpoint(HelicsFederate fed,
                                                                          const char* name,
                                                                          const char* type,
                                                                          HelicsError* err);
 
HELICS_EXPORT HelicsEndpoint helicsFederateGetEndpoint(HelicsFederate fed, const char* name, HelicsError* err);
 
HELICS_EXPORT HelicsEndpoint helicsFederateGetEndpointByIndex(HelicsFederate fed, int index, HelicsError* err);
 
HELICS_EXPORT HelicsBool helicsEndpointIsValid(HelicsEndpoint endpoint);
 
HELICS_EXPORT void helicsEndpointSetDefaultDestination(HelicsEndpoint endpoint, const char* dst, HelicsError* err);
 
HELICS_EXPORT const char* helicsEndpointGetDefaultDestination(HelicsEndpoint endpoint);
 
HELICS_EXPORT void helicsEndpointSendBytes(HelicsEndpoint endpoint, const void* data, int inputDataLength, HelicsError* err);
 
HELICS_EXPORT void
    helicsEndpointSendBytesTo(HelicsEndpoint endpoint, const void* data, int inputDataLength, const char* dst, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointSendBytesToAt(HelicsEndpoint endpoint,
                                               const void* data,
                                               int inputDataLength,
                                               const char* dst,
                                               HelicsTime time,
                                               HelicsError* err);
 
HELICS_EXPORT void
    helicsEndpointSendBytesAt(HelicsEndpoint endpoint, const void* data, int inputDataLength, HelicsTime time, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointSendMessage(HelicsEndpoint endpoint, HelicsMessage message, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointSendMessageZeroCopy(HelicsEndpoint endpoint, HelicsMessage message, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointSubscribe(HelicsEndpoint endpoint, const char* key, HelicsError* err);
 
HELICS_EXPORT HelicsBool helicsFederateHasMessage(HelicsFederate fed);
 
HELICS_EXPORT HelicsBool helicsEndpointHasMessage(HelicsEndpoint endpoint);
 
HELICS_EXPORT int helicsFederatePendingMessageCount(HelicsFederate fed);
 
HELICS_EXPORT int helicsEndpointPendingMessageCount(HelicsEndpoint endpoint);
 
HELICS_EXPORT HelicsMessage helicsEndpointGetMessage(HelicsEndpoint endpoint);
 
HELICS_EXPORT HelicsMessage helicsEndpointCreateMessage(HelicsEndpoint endpoint, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointClearMessages(HelicsEndpoint endpoint);
 
HELICS_EXPORT HelicsMessage helicsFederateGetMessage(HelicsFederate fed);
 
HELICS_EXPORT HelicsMessage helicsFederateCreateMessage(HelicsFederate fed, HelicsError* err);
 
HELICS_EXPORT void helicsFederateClearMessages(HelicsFederate fed);
 
HELICS_EXPORT const char* helicsEndpointGetType(HelicsEndpoint endpoint);
 
HELICS_EXPORT const char* helicsEndpointGetName(HelicsEndpoint endpoint);
 
HELICS_EXPORT int helicsFederateGetEndpointCount(HelicsFederate fed);
 
HELICS_EXPORT const char* helicsEndpointGetInfo(HelicsEndpoint end);
 
HELICS_EXPORT void helicsEndpointSetInfo(HelicsEndpoint endpoint, const char* info, HelicsError* err);
 
HELICS_EXPORT const char* helicsEndpointGetTag(HelicsEndpoint endpoint, const char* tagname);
 
HELICS_EXPORT void helicsEndpointSetTag(HelicsEndpoint endpoint, const char* tagname, const char* tagvalue, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointSetOption(HelicsEndpoint endpoint, int option, int value, HelicsError* err);
 
HELICS_EXPORT int helicsEndpointGetOption(HelicsEndpoint endpoint, int option);
 
HELICS_EXPORT void helicsEndpointAddSourceTarget(HelicsEndpoint endpoint, const char* targetEndpoint, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointAddDestinationTarget(HelicsEndpoint endpoint, const char* targetEndpoint, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointRemoveTarget(HelicsEndpoint endpoint, const char* targetEndpoint, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointAddSourceFilter(HelicsEndpoint endpoint, const char* filterName, HelicsError* err);
 
HELICS_EXPORT void helicsEndpointAddDestinationFilter(HelicsEndpoint endpoint, const char* filterName, HelicsError* err);
 
HELICS_EXPORT const char* helicsMessageGetSource(HelicsMessage message);
 
HELICS_EXPORT const char* helicsMessageGetDestination(HelicsMessage message);
 
HELICS_EXPORT const char* helicsMessageGetOriginalSource(HelicsMessage message);
 
HELICS_EXPORT const char* helicsMessageGetOriginalDestination(HelicsMessage message);
 
HELICS_EXPORT HelicsTime helicsMessageGetTime(HelicsMessage message);
 
HELICS_EXPORT const char* helicsMessageGetString(HelicsMessage message);
 
HELICS_EXPORT int helicsMessageGetMessageID(HelicsMessage message);
 
HELICS_EXPORT HelicsBool helicsMessageGetFlagOption(HelicsMessage message, int flag);
 
HELICS_EXPORT int helicsMessageGetByteCount(HelicsMessage message);
 
HELICS_EXPORT void helicsMessageGetBytes(HelicsMessage message, void* data, int maxMessageLength, int* actualSize, HelicsError* err);
 
HELICS_EXPORT void* helicsMessageGetBytesPointer(HelicsMessage message);
 
HELICS_EXPORT HelicsDataBuffer helicsMessageDataBuffer(HelicsMessage message, HelicsError* err);
 
HELICS_EXPORT HelicsBool helicsMessageIsValid(HelicsMessage message);
 
HELICS_EXPORT void helicsMessageSetSource(HelicsMessage message, const char* src, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetDestination(HelicsMessage message, const char* dst, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetOriginalSource(HelicsMessage message, const char* src, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetOriginalDestination(HelicsMessage message, const char* dst, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetTime(HelicsMessage message, HelicsTime time, HelicsError* err);
 
HELICS_EXPORT void helicsMessageResize(HelicsMessage message, int newSize, HelicsError* err);
 
HELICS_EXPORT void helicsMessageReserve(HelicsMessage message, int reserveSize, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetMessageID(HelicsMessage message, int32_t messageID, HelicsError* err);
 
HELICS_EXPORT void helicsMessageClearFlags(HelicsMessage message);
 
HELICS_EXPORT void helicsMessageSetFlagOption(HelicsMessage message, int flag, HelicsBool flagValue, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetString(HelicsMessage message, const char* data, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetData(HelicsMessage message, const void* data, int inputDataLength, HelicsError* err);
 
HELICS_EXPORT void helicsMessageSetDataBuffer(HelicsMessage message, HelicsDataBuffer data, HelicsError* err);
 
HELICS_EXPORT void helicsMessageAppendData(HelicsMessage message, const void* data, int inputDataLength, HelicsError* err);
 
HELICS_EXPORT void helicsMessageCopy(HelicsMessage src_message, HelicsMessage dst_message, HelicsError* err);
 
HELICS_EXPORT HelicsMessage helicsMessageClone(HelicsMessage message, HelicsError* err);
 
HELICS_EXPORT void helicsMessageFree(HelicsMessage message);
 
HELICS_EXPORT void helicsMessageClear(HelicsMessage message, HelicsError* err);
 
#ifdef __cplusplus
} /* end of extern "C" { */
#endif
 
#endif /*HELICS_APISHARED_MESSAGE_FEDERATE_FUNCTIONS_H_*/