1

/*

     2

 * Generated by erpcgen 1.12.0 on Mon May 20 17:54:19 2024.

     3

 *

     4

 * AUTOGENERATED - DO NOT EDIT

     5

 */

     6

     7

     8

#include <new>

     9

#include "c_erpc_PLCObject_server.h"

    10

#include "erpc_PLCObject_server.hpp"

    11

#include "erpc_manually_constructed.hpp"

    12

    13

using namespace erpc;

    14

using namespace std;

    15

using namespace erpcShim;

    16

    17

    18

class BeremizPLCObjectService_server: public BeremizPLCObjectService_interface

    19

{

    20

    public:

    21

        virtual ~BeremizPLCObjectService_server() {};

    22

    23

    24

        uint32_t AppendChunkToBlob(const binary_t * data, const binary_t * blobID, binary_t * newBlobID)

    25

        {

    26

            uint32_t result;

    27

            result = ::AppendChunkToBlob(data, blobID, newBlobID);

    28

    29

            return result;

    30

        }

    31

    32

        uint32_t GetLogMessage(uint8_t level, uint32_t msgID, log_message * message)

    33

        {

    34

            uint32_t result;

    35

            result = ::GetLogMessage(level, msgID, message);

    36

    37

            return result;

    38

        }

    39

    40

        uint32_t GetPLCID(PSKID * plcID)

    41

        {

    42

            uint32_t result;

    43

            result = ::GetPLCID(plcID);

    44

    45

            return result;

    46

        }

    47

    48

        uint32_t GetPLCstatus(PLCstatus * status)

    49

        {

    50

            uint32_t result;

    51

            result = ::GetPLCstatus(status);

    52

    53

            return result;

    54

        }

    55

    56

        uint32_t GetTraceVariables(uint32_t debugToken, TraceVariables * traces)

    57

        {

    58

            uint32_t result;

    59

            result = ::GetTraceVariables(debugToken, traces);

    60

    61

            return result;

    62

        }

    63

    64

        uint32_t MatchMD5(const char * MD5, bool * match)

    65

        {

    66

            uint32_t result;

    67

            result = ::MatchMD5(MD5, match);

    68

    69

            return result;

    70

        }

    71

    72

        uint32_t NewPLC(const char * md5sum, const binary_t * plcObjectBlobID, const list_extra_file_1_t * extrafiles, bool * success)

    73

        {

    74

            uint32_t result;

    75

            result = ::NewPLC(md5sum, plcObjectBlobID, extrafiles, success);

    76

    77

            return result;

    78

        }

    79

    80

        uint32_t PurgeBlobs(void)

    81

        {

    82

            uint32_t result;

    83

            result = ::PurgeBlobs();

    84

    85

            return result;

    86

        }

    87

    88

        uint32_t RepairPLC(void)

    89

        {

    90

            uint32_t result;

    91

            result = ::RepairPLC();

    92

    93

            return result;

    94

        }

    95

    96

        uint32_t ResetLogCount(void)

    97

        {

    98

            uint32_t result;

    99

            result = ::ResetLogCount();

   100

   101

            return result;

   102

        }

   103

   104

        uint32_t SeedBlob(const binary_t * seed, binary_t * blobID)

   105

        {

   106

            uint32_t result;

   107

            result = ::SeedBlob(seed, blobID);

   108

   109

            return result;

   110

        }

   111

   112

        uint32_t SetTraceVariablesList(const list_trace_order_1_t * orders, int32_t * debugtoken)

   113

        {

   114

            uint32_t result;

   115

            result = ::SetTraceVariablesList(orders, debugtoken);

   116

   117

            return result;

   118

        }

   119

   120

        uint32_t StartPLC(void)

   121

        {

   122

            uint32_t result;

   123

            result = ::StartPLC();

   124

   125

            return result;

   126

        }

   127

   128

        uint32_t StopPLC(bool * success)

   129

        {

   130

            uint32_t result;

   131

            result = ::StopPLC(success);

   132

   133

            return result;

   134

        }

   135

};

   136

   137

ERPC_MANUALLY_CONSTRUCTED_STATIC(BeremizPLCObjectService_service, s_BeremizPLCObjectService_service);

   138

ERPC_MANUALLY_CONSTRUCTED_STATIC(BeremizPLCObjectService_server, s_BeremizPLCObjectService_server);

   139

   140

erpc_service_t create_BeremizPLCObjectService_service(void)

   141

{

   142

    erpc_service_t service;

   143

   144

#if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC

   145

    service = new (nothrow) BeremizPLCObjectService_service(new (nothrow)BeremizPLCObjectService_server());

   146

#else

   147

    if (s_BeremizPLCObjectService_service.isUsed())

   148

    {

   149

        service = NULL;

   150

    }

   151

    else

   152

    {

   153

        s_BeremizPLCObjectService_server.construct();

   154

        s_BeremizPLCObjectService_service.construct(s_BeremizPLCObjectService_server.get());

   155

        service = s_BeremizPLCObjectService_service.get();

   156

    }

   157

#endif

   158

   159

    return service;

   160

}

   161

   162

void destroy_BeremizPLCObjectService_service(erpc_service_t service)

   163

{

   164

#if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC

   165

    if (service)

   166

    {

   167

        delete (BeremizPLCObjectService_server *)(((BeremizPLCObjectService_service *)service)->getHandler());

   168

        delete (BeremizPLCObjectService_service *)service;

   169

    }

   170

#else

   171

    (void)service;

   172

    erpc_assert(service == s_BeremizPLCObjectService_service.get());

   173

    s_BeremizPLCObjectService_service.destroy();

   174

    s_BeremizPLCObjectService_server.destroy();

   175

#endif

   176

}

   177