1

/*

     2

 * Generated by erpcgen 1.11.0 on Wed Mar 27 13:43:44 2024.

     3

 *

     4

 * AUTOGENERATED - DO NOT EDIT

     5

 */

     6

     7

     8

#if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC

     9

#include "erpc_port.h"

    10

#endif

    11

#include "erpc_codec.hpp"

    12

#include "erpc_PLCObject_client.hpp"

    13

#include "erpc_manually_constructed.hpp"

    14

    15

#if 11100 != ERPC_VERSION_NUMBER

    16

#error "The generated shim code version is different to the rest of eRPC code."

    17

#endif

    18

    19

using namespace erpc;

    20

using namespace std;

    21

using namespace erpcShim;

    22

    23

//! @brief Function to write struct binary_t

    24

static void write_binary_t_struct(erpc::Codec * codec, const binary_t * data);

    25

    26

//! @brief Function to write struct extra_file

    27

static void write_extra_file_struct(erpc::Codec * codec, const extra_file * data);

    28

    29

//! @brief Function to write struct list_extra_file_1_t

    30

static void write_list_extra_file_1_t_struct(erpc::Codec * codec, const list_extra_file_1_t * data);

    31

    32

//! @brief Function to write struct trace_order

    33

static void write_trace_order_struct(erpc::Codec * codec, const trace_order * data);

    34

    35

//! @brief Function to write struct list_trace_order_1_t

    36

static void write_list_trace_order_1_t_struct(erpc::Codec * codec, const list_trace_order_1_t * data);

    37

    38

    39

// Write struct binary_t function implementation

    40

static void write_binary_t_struct(erpc::Codec * codec, const binary_t * data)

    41

{

    42

    if(NULL == data)

    43

    {

    44

        return;

    45

    }

    46

    47

    codec->writeBinary(data->dataLength, data->data);

    48

}

    49

    50

// Write struct extra_file function implementation

    51

static void write_extra_file_struct(erpc::Codec * codec, const extra_file * data)

    52

{

    53

    if(NULL == data)

    54

    {

    55

        return;

    56

    }

    57

    58

    {

    59

        uint32_t fname_len = strlen((const char*)data->fname);

    60

    61

        codec->writeString(fname_len, (const char*)data->fname);

    62

    }

    63

    64

    write_binary_t_struct(codec, &(data->blobID));

    65

}

    66

    67

// Write struct list_extra_file_1_t function implementation

    68

static void write_list_extra_file_1_t_struct(erpc::Codec * codec, const list_extra_file_1_t * data)

    69

{

    70

    if(NULL == data)

    71

    {

    72

        return;

    73

    }

    74

    75

    codec->startWriteList(data->elementsCount);

    76

    for (uint32_t listCount = 0U; listCount < data->elementsCount; ++listCount)

    77

    {

    78

        write_extra_file_struct(codec, &(data->elements[listCount]));

    79

    }

    80

}

    81

    82

// Write struct trace_order function implementation

    83

static void write_trace_order_struct(erpc::Codec * codec, const trace_order * data)

    84

{

    85

    if(NULL == data)

    86

    {

    87

        return;

    88

    }

    89

    90

    codec->write(data->idx);

    91

    92

    write_binary_t_struct(codec, &(data->force));

    93

}

    94

    95

// Write struct list_trace_order_1_t function implementation

    96

static void write_list_trace_order_1_t_struct(erpc::Codec * codec, const list_trace_order_1_t * data)

    97

{

    98

    if(NULL == data)

    99

    {

   100

        return;

   101

    }

   102

   103

    codec->startWriteList(data->elementsCount);

   104

    for (uint32_t listCount = 0U; listCount < data->elementsCount; ++listCount)

   105

    {

   106

        write_trace_order_struct(codec, &(data->elements[listCount]));

   107

    }

   108

}

   109

   110

   111

//! @brief Function to read struct binary_t

   112

static void read_binary_t_struct(erpc::Codec * codec, binary_t * data);

   113

   114

//! @brief Function to read struct log_message

   115

static void read_log_message_struct(erpc::Codec * codec, log_message * data);

   116

   117

//! @brief Function to read struct PSKID

   118

static void read_PSKID_struct(erpc::Codec * codec, PSKID * data);

   119

   120

//! @brief Function to read struct PLCstatus

   121

static void read_PLCstatus_struct(erpc::Codec * codec, PLCstatus * data);

   122

   123

//! @brief Function to read struct trace_sample

   124

static void read_trace_sample_struct(erpc::Codec * codec, trace_sample * data);

   125

   126

//! @brief Function to read struct TraceVariables

   127

static void read_TraceVariables_struct(erpc::Codec * codec, TraceVariables * data);

   128

   129

//! @brief Function to read struct list_trace_sample_1_t

   130

static void read_list_trace_sample_1_t_struct(erpc::Codec * codec, list_trace_sample_1_t * data);

   131

   132

   133

// Read struct binary_t function implementation

   134

static void read_binary_t_struct(erpc::Codec * codec, binary_t * data)

   135

{

   136

    if(NULL == data)

   137

    {

   138

        return;

   139

    }

   140

   141

    uint8_t * data_local;

   142

    codec->readBinary(data->dataLength, &data_local);

   143

    if (data->dataLength > 0)

   144

    {

   145

    data->data = (uint8_t *) erpc_malloc(data->dataLength * sizeof(uint8_t));

   146

        if (data->data == NULL)

   147

        {

   148

            codec->updateStatus(kErpcStatus_MemoryError);

   149

        }

   150

        else

   151

        {

   152

            memcpy(data->data, data_local, data->dataLength);

   153

        }

   154

    }

   155

    else

   156

    {

   157

        data->data = NULL;

   158

    }

   159

}

   160

   161

// Read struct log_message function implementation

   162

static void read_log_message_struct(erpc::Codec * codec, log_message * data)

   163

{

   164

    if(NULL == data)

   165

    {

   166

        return;

   167

    }

   168

   169

    {

   170

        uint32_t msg_len;

   171

        char * msg_local;

   172

        codec->readString(msg_len, &msg_local);

   173

        data->msg = (char*) erpc_malloc((msg_len + 1) * sizeof(char));

   174

        if ((data->msg == NULL) || (msg_local == NULL))

   175

        {

   176

            codec->updateStatus(kErpcStatus_MemoryError);

   177

        }

   178

        else

   179

        {

   180

            memcpy(data->msg, msg_local, msg_len);

   181

            (data->msg)[msg_len] = 0;

   182

        }

   183

    }

   184

   185

    codec->read(data->tick);

   186

   187

    codec->read(data->sec);

   188

   189

    codec->read(data->nsec);

   190

}

   191

   192

// Read struct PSKID function implementation

   193

static void read_PSKID_struct(erpc::Codec * codec, PSKID * data)

   194

{

   195

    if(NULL == data)

   196

    {

   197

        return;

   198

    }

   199

   200

    {

   201

        uint32_t ID_len;

   202

        char * ID_local;

   203

        codec->readString(ID_len, &ID_local);

   204

        data->ID = (char*) erpc_malloc((ID_len + 1) * sizeof(char));

   205

        if ((data->ID == NULL) || (ID_local == NULL))

   206

        {

   207

            codec->updateStatus(kErpcStatus_MemoryError);

   208

        }

   209

        else

   210

        {

   211

            memcpy(data->ID, ID_local, ID_len);

   212

            (data->ID)[ID_len] = 0;

   213

        }

   214

    }

   215

   216

    {

   217

        uint32_t PSK_len;

   218

        char * PSK_local;

   219

        codec->readString(PSK_len, &PSK_local);

   220

        data->PSK = (char*) erpc_malloc((PSK_len + 1) * sizeof(char));

   221

        if ((data->PSK == NULL) || (PSK_local == NULL))

   222

        {

   223

            codec->updateStatus(kErpcStatus_MemoryError);

   224

        }

   225

        else

   226

        {

   227

            memcpy(data->PSK, PSK_local, PSK_len);

   228

            (data->PSK)[PSK_len] = 0;

   229

        }

   230

    }

   231

}

   232

   233

// Read struct PLCstatus function implementation

   234

static void read_PLCstatus_struct(erpc::Codec * codec, PLCstatus * data)

   235

{

   236

    int32_t _tmp_local_i32;

   237

   238

    if(NULL == data)

   239

    {

   240

        return;

   241

    }

   242

   243

    codec->read(_tmp_local_i32);

   244

    data->PLCstatus = static_cast<PLCstatus_enum>(_tmp_local_i32);

   245

   246

    for (uint32_t arrayCount0 = 0U; arrayCount0 < 4U; ++arrayCount0)

   247

    {

   248

        codec->read(data->logcounts[arrayCount0]);

   249

    }

   250

}

   251

   252

// Read struct trace_sample function implementation

   253

static void read_trace_sample_struct(erpc::Codec * codec, trace_sample * data)

   254

{

   255

    if(NULL == data)

   256

    {

   257

        return;

   258

    }

   259

   260

    codec->read(data->tick);

   261

   262

    read_binary_t_struct(codec, &(data->TraceBuffer));

   263

}

   264

   265

// Read struct TraceVariables function implementation

   266

static void read_TraceVariables_struct(erpc::Codec * codec, TraceVariables * data)

   267

{

   268

    int32_t _tmp_local_i32;

   269

   270

    if(NULL == data)

   271

    {

   272

        return;

   273

    }

   274

   275

    codec->read(_tmp_local_i32);

   276

    data->PLCstatus = static_cast<PLCstatus_enum>(_tmp_local_i32);

   277

   278

    read_list_trace_sample_1_t_struct(codec, &(data->traces));

   279

}

   280

   281

// Read struct list_trace_sample_1_t function implementation

   282

static void read_list_trace_sample_1_t_struct(erpc::Codec * codec, list_trace_sample_1_t * data)

   283

{

   284

    if(NULL == data)

   285

    {

   286

        return;

   287

    }

   288

   289

    codec->startReadList(data->elementsCount);

   290

    data->elements = (trace_sample *) erpc_malloc(data->elementsCount * sizeof(trace_sample));

   291

    if ((data->elements == NULL) && (data->elementsCount > 0))

   292

    {

   293

        codec->updateStatus(kErpcStatus_MemoryError);

   294

    }

   295

    for (uint32_t listCount = 0U; listCount < data->elementsCount; ++listCount)

   296

    {

   297

        read_trace_sample_struct(codec, &(data->elements[listCount]));

   298

    }

   299

}

   300

   301

   302

   303

   304

BeremizPLCObjectService_client::BeremizPLCObjectService_client(ClientManager *manager)

   305

:m_clientManager(manager)

   306

{

   307

}

   308

   309

BeremizPLCObjectService_client::~BeremizPLCObjectService_client()

   310

{

   311

}

   312

   313

// BeremizPLCObjectService interface AppendChunkToBlob function client shim.

   314

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

   315

{

   316

    erpc_status_t err = kErpcStatus_Success;

   317

   318

    uint32_t result;

   319

   320

#if ERPC_PRE_POST_ACTION

   321

    pre_post_action_cb preCB = m_clientManager->getPreCB();

   322

    if (preCB)

   323

    {

   324

        preCB();

   325

    }

   326

#endif

   327

   328

    // Get a new request.

   329

    RequestContext request = m_clientManager->createRequest(false);

   330

   331

    // Encode the request.

   332

    Codec * codec = request.getCodec();

   333

   334

    if (codec == NULL)

   335

    {

   336

        err = kErpcStatus_MemoryError;

   337

    }

   338

    else

   339

    {

   340

        codec->startWriteMessage(message_type_t::kInvocationMessage, m_serviceId, m_AppendChunkToBlobId, request.getSequence());

   341

   342

        write_binary_t_struct(codec, data);

   343

   344

        write_binary_t_struct(codec, blobID);

   345

   346

        // Send message to server

   347

        // Codec status is checked inside this function.

   348

        m_clientManager->performRequest(request);

   349

   350

        read_binary_t_struct(codec, newBlobID);

   351

   352

        codec->read(result);

   353

   354

        err = codec->getStatus();

   355

    }

   356

   357

    // Dispose of the request.

   358

    m_clientManager->releaseRequest(request);

   359

   360

    // Invoke error handler callback function

   361

    m_clientManager->callErrorHandler(err, m_AppendChunkToBlobId);

   362

   363

#if ERPC_PRE_POST_ACTION

   364

    pre_post_action_cb postCB = m_clientManager->getPostCB();

   365

    if (postCB)

   366

    {

   367

        postCB();

   368

    }

   369

#endif

   370

   371

   372

    if (err != kErpcStatus_Success)

   373

    {

   374

        result = 0xFFFFFFFFU;

   375

    }

   376

   377

    return result;

   378

}

   379

   380

// BeremizPLCObjectService interface GetLogMessage function client shim.

   381

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

   382

{

   383

    erpc_status_t err = kErpcStatus_Success;

   384

   385

    uint32_t result;

   386

   387

#if ERPC_PRE_POST_ACTION

   388

    pre_post_action_cb preCB = m_clientManager->getPreCB();

   389

    if (preCB)

   390

    {

   391

        preCB();

   392

    }

   393

#endif

   394

   395

    // Get a new request.

   396

    RequestContext request = m_clientManager->createRequest(false);

   397

   398

    // Encode the request.

   399

    Codec * codec = request.getCodec();

   400

   401

    if (codec == NULL)

   402

    {

   403

        err = kErpcStatus_MemoryError;

   404

    }

   405

    else

   406

    {

   407

        codec->startWriteMessage(message_type_t::kInvocationMessage, m_serviceId, m_GetLogMessageId, request.getSequence());

   408

   409

        codec->write(level);

   410

   411

        codec->write(msgID);

   412

   413

        // Send message to server

   414

        // Codec status is checked inside this function.

   415

        m_clientManager->performRequest(request);

   416

   417

        read_log_message_struct(codec, message);

   418

   419

        codec->read(result);

   420

   421

        err = codec->getStatus();

   422

    }

   423

   424

    // Dispose of the request.

   425

    m_clientManager->releaseRequest(request);

   426

   427

    // Invoke error handler callback function

   428

    m_clientManager->callErrorHandler(err, m_GetLogMessageId);

   429

   430

#if ERPC_PRE_POST_ACTION

   431

    pre_post_action_cb postCB = m_clientManager->getPostCB();

   432

    if (postCB)

   433

    {

   434

        postCB();

   435

    }

   436

#endif

   437

   438

   439

    if (err != kErpcStatus_Success)

   440

    {

   441

        result = 0xFFFFFFFFU;

   442

    }

   443

   444

    return result;

   445

}

   446

   447

// BeremizPLCObjectService interface GetPLCID function client shim.

   448

uint32_t BeremizPLCObjectService_client::GetPLCID(PSKID * plcID)

   449

{

   450

    erpc_status_t err = kErpcStatus_Success;

   451

   452

    uint32_t result;

   453

   454

#if ERPC_PRE_POST_ACTION

   455

    pre_post_action_cb preCB = m_clientManager->getPreCB();

   456

    if (preCB)

   457

    {

   458

        preCB();

   459

    }

   460

#endif

   461

   462

    // Get a new request.

   463

    RequestContext request = m_clientManager->createRequest(false);

   464

   465

    // Encode the request.

   466

    Codec * codec = request.getCodec();

   467

   468

    if (codec == NULL)

   469

    {

   470

        err = kErpcStatus_MemoryError;

   471

    }

   472

    else

   473

    {

   474

        codec->startWriteMessage(message_type_t::kInvocationMessage, m_serviceId, m_GetPLCIDId, request.getSequence());

   475

   476

        // Send message to server

   477

        // Codec status is checked inside this function.

   478

        m_clientManager->performRequest(request);

   479

   480

        read_PSKID_struct(codec, plcID);

   481

   482

        codec->read(result);

   483

   484

        err = codec->getStatus();

   485

    }

   486

   487

    // Dispose of the request.

   488

    m_clientManager->releaseRequest(request);

   489

   490

    // Invoke error handler callback function

   491

    m_clientManager->callErrorHandler(err, m_GetPLCIDId);

   492

   493

#if ERPC_PRE_POST_ACTION

   494

    pre_post_action_cb postCB = m_clientManager->getPostCB();

   495

    if (postCB)

   496

    {

   497

        postCB();

   498

    }

   499

#endif

   500

   501

   502

    if (err != kErpcStatus_Success)

   503

    {

   504

        result = 0xFFFFFFFFU;

   505

    }

   506

   507

    return result;

   508

}

   509

   510

// BeremizPLCObjectService interface GetPLCstatus function client shim.

   511

uint32_t BeremizPLCObjectService_client::GetPLCstatus(PLCstatus * status)

   512

{

   513

    erpc_status_t err = kErpcStatus_Success;

   514

   515

    uint32_t result;

   516

   517

#if ERPC_PRE_POST_ACTION

   518

    pre_post_action_cb preCB = m_clientManager->getPreCB();

   519

    if (preCB)

   520

    {

   521

        preCB();

   522

    }

   523

#endif

   524

   525

    // Get a new request.

   526

    RequestContext request = m_clientManager->createRequest(false);

   527

   528

    // Encode the request.

   529

    Codec * codec = request.getCodec();