libs2opc_new_client.h

Go to the documentation of this file.

/*
 * Licensed to Systerel under one or more contributor license
 * agreements. See the NOTICE file distributed with this work
 * for additional information regarding copyright ownership.
 * Systerel licenses this file to you under the Apache
 * License, Version 2.0 (the "License"); you may not use this
 * file except in compliance with the License. You may obtain
 * a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef LIBS2OPC_NEW_CLIENT_H_
#define LIBS2OPC_NEW_CLIENT_H_
 
#include <stdbool.h>
#include <stdint.h>
 
#include "sopc_types.h"
 
#include "libs2opc_client_config.h"
 
typedef struct SOPC_ClientConnection SOPC_ClientConnection;
 
typedef enum
{
    SOPC_ClientConnectionEvent_Disconnected, 
    SOPC_ClientConnectionEvent_Connected,    
    SOPC_ClientConnectionEvent_Reconnecting, 
} SOPC_ClientConnectionEvent;
 
typedef void SOPC_ClientConnectionEvent_Fct(SOPC_ClientConnection* config,
                                            SOPC_ClientConnectionEvent event,
                                            SOPC_StatusCode status);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_DiscoveryServiceAsync(SOPC_SecureConnection_Config* secConnConfig,
                                                             void* request,
                                                             uintptr_t userContext);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_DiscoveryServiceSync(SOPC_SecureConnection_Config* secConnConfig,
                                                            void* request,
                                                            void** response);
SOPC_ReturnStatus SOPC_ClientHelperNew_Connect(SOPC_SecureConnection_Config* secConnConfig,
                                               SOPC_ClientConnectionEvent_Fct* connectEventCb,
                                               SOPC_ClientConnection** secureConnection);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_Disconnect(SOPC_ClientConnection** secureConnection);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_ServiceAsync(SOPC_ClientConnection* secureConnection,
                                                    void* request,
                                                    uintptr_t userContext);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_ServiceSync(SOPC_ClientConnection* secureConnection,
                                                   void* request,
                                                   void** response);
 
typedef struct SOPC_ClientHelper_Subscription SOPC_ClientHelper_Subscription;
 
typedef void SOPC_ClientSubscriptionNotification_Fct(const SOPC_ClientHelper_Subscription* subscription,
                                                     SOPC_StatusCode status,
                                                     SOPC_EncodeableType* notificationType,
                                                     uint32_t nbNotifElts,
                                                     const void* notification,
                                                     uintptr_t* monitoredItemCtxArray);
 
SOPC_ClientHelper_Subscription* SOPC_ClientHelperNew_CreateSubscription(
    SOPC_ClientConnection* secureConnection,
    OpcUa_CreateSubscriptionRequest* subParams,
    SOPC_ClientSubscriptionNotification_Fct* subNotifCb,
    uintptr_t userParam);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_DeleteSubscription(SOPC_ClientHelper_Subscription** subscription);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_Subscription_SetAvailableTokens(SOPC_ClientHelper_Subscription* subscription,
                                                                       uint32_t nbPublishTokens);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_Subscription_GetRevisedParameters(SOPC_ClientHelper_Subscription* subscription,
                                                                         double* revisedPublishingInterval,
                                                                         uint32_t* revisedLifetimeCount,
                                                                         uint32_t* revisedMaxKeepAliveCount);
 
uintptr_t SOPC_ClientHelperNew_Subscription_GetUserParam(const SOPC_ClientHelper_Subscription* subscription);
 
SOPC_ClientConnection* SOPC_ClientHelperNew_GetSecureConnection(const SOPC_ClientHelper_Subscription* subscription);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_Subscription_CreateMonitoredItems(
    const SOPC_ClientHelper_Subscription* subscription,
    OpcUa_CreateMonitoredItemsRequest* monitoredItemsReq,
    const uintptr_t* monitoredItemCtxArray,
    OpcUa_CreateMonitoredItemsResponse* monitoredItemsResp);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_Subscription_DeleteMonitoredItems(
    const SOPC_ClientHelper_Subscription* subscription,
    OpcUa_DeleteMonitoredItemsRequest* delMonitoredItemsReq,
    OpcUa_DeleteMonitoredItemsResponse* delMonitoredItemsResp);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_Subscription_SyncService(const SOPC_ClientHelper_Subscription* subscription,
                                                                void* subOrMIrequest,
                                                                void** subOrMIresponse);
 
SOPC_ReturnStatus SOPC_ClientHelperNew_Subscription_AsyncService(const SOPC_ClientHelper_Subscription* subscription,
                                                                 void* subOrMIrequest,
                                                                 uintptr_t userContext);
 
#endif