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

#include "erpc_PLCObject_server.hpp"

     9

#if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC

    10

#include <new>

    11

#include "erpc_port.h"

    12

#endif

    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

#if ERPC_NESTED_CALLS_DETECTION

    24

extern bool nestingDetection;

    25

#endif

    26

    27

    28

//! @brief Function to read struct binary_t

    29

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

    30

    31

//! @brief Function to read struct extra_file

    32

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

    33

    34

//! @brief Function to read struct list_extra_file_1_t

    35

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

    36

    37

//! @brief Function to read struct trace_order

    38

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

    39

    40

//! @brief Function to read struct list_trace_order_1_t

    41

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

    42

    43

    44

// Read struct binary_t function implementation

    45

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

    46

{

    47

    if(NULL == data)

    48

    {

    49

        return;

    50

    }

    51

    52

    uint8_t * data_local;

    53

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

    54

    if (data->dataLength > 0)

    55

    {

    56

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

    57

        if (data->data == NULL)

    58

        {

    59

            codec->updateStatus(kErpcStatus_MemoryError);

    60

        }

    61

        else

    62

        {

    63

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

    64

        }

    65

    }

    66

    else

    67

    {

    68

        data->data = NULL;

    69

    }

    70

}

    71

    72

// Read struct extra_file function implementation

    73

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

    74

{

    75

    if(NULL == data)

    76

    {

    77

        return;

    78

    }

    79

    80

    {

    81

        uint32_t fname_len;

    82

        char * fname_local;

    83

        codec->readString(fname_len, &fname_local);

    84

        data->fname = (char*) erpc_malloc((fname_len + 1) * sizeof(char));

    85

        if ((data->fname == NULL) || (fname_local == NULL))

    86

        {

    87

            codec->updateStatus(kErpcStatus_MemoryError);

    88

        }

    89

        else

    90

        {

    91

            memcpy(data->fname, fname_local, fname_len);

    92

            (data->fname)[fname_len] = 0;

    93

        }

    94

    }

    95

    96

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

    97

}

    98

    99

// Read struct list_extra_file_1_t function implementation

   100

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

   101

{

   102

    if(NULL == data)

   103

    {

   104

        return;

   105

    }

   106

   107

    codec->startReadList(data->elementsCount);

   108

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

   109

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

   110

    {

   111

        codec->updateStatus(kErpcStatus_MemoryError);

   112

    }

   113

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

   114

    {

   115

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

   116

    }

   117

}

   118

   119

// Read struct trace_order function implementation

   120

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

   121

{

   122

    if(NULL == data)

   123

    {

   124

        return;

   125

    }

   126

   127

    codec->read(data->idx);

   128

   129

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

   130

}

   131

   132

// Read struct list_trace_order_1_t function implementation

   133

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

   134

{

   135

    if(NULL == data)

   136

    {

   137

        return;

   138

    }

   139

   140

    codec->startReadList(data->elementsCount);

   141

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

   142

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

   143

    {

   144

        codec->updateStatus(kErpcStatus_MemoryError);

   145

    }

   146

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

   147

    {

   148

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

   149

    }

   150

}

   151

   152

   153

//! @brief Function to write struct binary_t

   154

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

   155

   156

//! @brief Function to write struct log_message

   157

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

   158

   159

//! @brief Function to write struct PSKID

   160

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

   161

   162

//! @brief Function to write struct PLCstatus

   163

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

   164

   165

//! @brief Function to write struct trace_sample

   166

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

   167

   168

//! @brief Function to write struct TraceVariables

   169

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

   170

   171

//! @brief Function to write struct list_trace_sample_1_t

   172

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

   173

   174

   175

// Write struct binary_t function implementation

   176

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

   177

{

   178

    if(NULL == data)

   179

    {

   180

        return;

   181

    }

   182

   183

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

   184

}

   185

   186

// Write struct log_message function implementation

   187

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

   188

{

   189

    if(NULL == data)

   190

    {

   191

        return;

   192

    }

   193

   194

    {

   195

        uint32_t msg_len = strlen((const char*)data->msg);

   196

   197

        codec->writeString(msg_len, (const char*)data->msg);

   198

    }

   199

   200

    codec->write(data->tick);

   201

   202

    codec->write(data->sec);

   203

   204

    codec->write(data->nsec);

   205

}

   206

   207

// Write struct PSKID function implementation

   208

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

   209

{

   210

    if(NULL == data)

   211

    {

   212

        return;

   213

    }

   214

   215

    {

   216

        uint32_t ID_len = strlen((const char*)data->ID);

   217

   218

        codec->writeString(ID_len, (const char*)data->ID);

   219

    }

   220

   221

    {

   222

        uint32_t PSK_len = strlen((const char*)data->PSK);

   223

   224

        codec->writeString(PSK_len, (const char*)data->PSK);

   225

    }

   226

}

   227

   228

// Write struct PLCstatus function implementation

   229

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

   230

{

   231

    if(NULL == data)

   232

    {

   233

        return;

   234

    }

   235

   236

    codec->write(static_cast<int32_t>(data->PLCstatus));

   237

   238

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

   239

    {

   240

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

   241

    }

   242

}

   243

   244

// Write struct trace_sample function implementation

   245

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

   246

{

   247

    if(NULL == data)

   248

    {

   249

        return;

   250

    }

   251

   252

    codec->write(data->tick);

   253

   254

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

   255

}

   256

   257

// Write struct TraceVariables function implementation

   258

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

   259

{

   260

    if(NULL == data)

   261

    {

   262

        return;

   263

    }

   264

   265

    codec->write(static_cast<int32_t>(data->PLCstatus));

   266

   267

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

   268

}

   269

   270

// Write struct list_trace_sample_1_t function implementation

   271

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

   272

{

   273

    if(NULL == data)

   274

    {

   275

        return;

   276

    }

   277

   278

    codec->startWriteList(data->elementsCount);

   279

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

   280

    {

   281

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

   282

    }

   283

}

   284

   285

   286

//! @brief Function to free space allocated inside struct binary_t

   287

static void free_binary_t_struct(binary_t * data);

   288

   289

//! @brief Function to free space allocated inside struct log_message

   290

static void free_log_message_struct(log_message * data);

   291

   292

//! @brief Function to free space allocated inside struct PSKID

   293

static void free_PSKID_struct(PSKID * data);

   294

   295

//! @brief Function to free space allocated inside struct trace_sample

   296

static void free_trace_sample_struct(trace_sample * data);

   297

   298

//! @brief Function to free space allocated inside struct TraceVariables

   299

static void free_TraceVariables_struct(TraceVariables * data);

   300

   301

//! @brief Function to free space allocated inside struct list_trace_sample_1_t

   302

static void free_list_trace_sample_1_t_struct(list_trace_sample_1_t * data);

   303

   304

//! @brief Function to free space allocated inside struct extra_file

   305

static void free_extra_file_struct(extra_file * data);

   306

   307

//! @brief Function to free space allocated inside struct list_extra_file_1_t

   308

static void free_list_extra_file_1_t_struct(list_extra_file_1_t * data);

   309

   310

//! @brief Function to free space allocated inside struct trace_order

   311

static void free_trace_order_struct(trace_order * data);

   312

   313

//! @brief Function to free space allocated inside struct list_trace_order_1_t

   314

static void free_list_trace_order_1_t_struct(list_trace_order_1_t * data);

   315

   316

   317

// Free space allocated inside struct binary_t function implementation

   318

static void free_binary_t_struct(binary_t * data)

   319

{

   320

    erpc_free(data->data);

   321

}

   322

   323

// Free space allocated inside struct log_message function implementation

   324

static void free_log_message_struct(log_message * data)

   325

{

   326

    erpc_free(data->msg);

   327

}

   328

   329

// Free space allocated inside struct PSKID function implementation

   330

static void free_PSKID_struct(PSKID * data)

   331

{

   332

    erpc_free(data->ID);

   333

   334

    erpc_free(data->PSK);

   335

}

   336

   337

// Free space allocated inside struct trace_sample function implementation

   338

static void free_trace_sample_struct(trace_sample * data)

   339

{

   340

    free_binary_t_struct(&data->TraceBuffer);

   341

}

   342

   343

// Free space allocated inside struct TraceVariables function implementation

   344

static void free_TraceVariables_struct(TraceVariables * data)

   345

{

   346

    free_list_trace_sample_1_t_struct(&data->traces);

   347

}

   348

   349

// Free space allocated inside struct list_trace_sample_1_t function implementation

   350

static void free_list_trace_sample_1_t_struct(list_trace_sample_1_t * data)

   351

{

   352

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

   353

    {

   354

        free_trace_sample_struct(&data->elements[listCount]);

   355

    }

   356

   357

    erpc_free(data->elements);

   358

}

   359

   360

// Free space allocated inside struct extra_file function implementation

   361

static void free_extra_file_struct(extra_file * data)

   362

{

   363

    erpc_free(data->fname);

   364

   365

    free_binary_t_struct(&data->blobID);

   366

}

   367

   368

// Free space allocated inside struct list_extra_file_1_t function implementation

   369

static void free_list_extra_file_1_t_struct(list_extra_file_1_t * data)

   370

{

   371

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

   372

    {

   373

        free_extra_file_struct(&data->elements[listCount]);

   374

    }

   375

   376

    erpc_free(data->elements);

   377

}

   378

   379

// Free space allocated inside struct trace_order function implementation

   380

static void free_trace_order_struct(trace_order * data)

   381

{

   382

    free_binary_t_struct(&data->force);

   383

}

   384

   385

// Free space allocated inside struct list_trace_order_1_t function implementation

   386

static void free_list_trace_order_1_t_struct(list_trace_order_1_t * data)

   387

{

   388

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

   389

    {

   390

        free_trace_order_struct(&data->elements[listCount]);

   391

    }

   392

   393

    erpc_free(data->elements);

   394

}

   395

   396

   397

   398

BeremizPLCObjectService_service::BeremizPLCObjectService_service(BeremizPLCObjectService_interface *_BeremizPLCObjectService_interface)

   399

    : erpc::Service(BeremizPLCObjectService_interface::m_serviceId)

   400

    , m_handler(_BeremizPLCObjectService_interface)

   401

{

   402

}

   403

   404

BeremizPLCObjectService_service::~BeremizPLCObjectService_service()

   405

{

   406

}

   407

   408

// return service interface handler.

   409

BeremizPLCObjectService_interface* BeremizPLCObjectService_service::getHandler(void)

   410

{

   411

    return m_handler;

   412

}

   413

   414

// Call the correct server shim based on method unique ID.

   415

erpc_status_t BeremizPLCObjectService_service::handleInvocation(uint32_t methodId, uint32_t sequence, Codec * codec, MessageBufferFactory *messageFactory, Transport * transport)

   416

{

   417

    erpc_status_t erpcStatus;

   418

    switch (methodId)

   419

    {

   420

        case BeremizPLCObjectService_interface::m_AppendChunkToBlobId:

   421

        {

   422

            erpcStatus = AppendChunkToBlob_shim(codec, messageFactory, transport, sequence);

   423

            break;

   424

        }

   425

   426

        case BeremizPLCObjectService_interface::m_GetLogMessageId:

   427

        {

   428

            erpcStatus = GetLogMessage_shim(codec, messageFactory, transport, sequence);

   429

            break;

   430

        }

   431

   432

        case BeremizPLCObjectService_interface::m_GetPLCIDId:

   433

        {

   434

            erpcStatus = GetPLCID_shim(codec, messageFactory, transport, sequence);

   435

            break;

   436

        }

   437

   438

        case BeremizPLCObjectService_interface::m_GetPLCstatusId:

   439

        {

   440

            erpcStatus = GetPLCstatus_shim(codec, messageFactory, transport, sequence);

   441

            break;

   442

        }

   443

   444

        case BeremizPLCObjectService_interface::m_GetTraceVariablesId:

   445

        {

   446

            erpcStatus = GetTraceVariables_shim(codec, messageFactory, transport, sequence);

   447

            break;

   448

        }

   449

   450

        case BeremizPLCObjectService_interface::m_MatchMD5Id:

   451

        {

   452

            erpcStatus = MatchMD5_shim(codec, messageFactory, transport, sequence);

   453

            break;

   454

        }

   455

   456

        case BeremizPLCObjectService_interface::m_NewPLCId:

   457

        {

   458

            erpcStatus = NewPLC_shim(codec, messageFactory, transport, sequence);

   459

            break;

   460

        }

   461

   462

        case BeremizPLCObjectService_interface::m_PurgeBlobsId:

   463

        {

   464

            erpcStatus = PurgeBlobs_shim(codec, messageFactory, transport, sequence);

   465

            break;

   466

        }

   467

   468

        case BeremizPLCObjectService_interface::m_RepairPLCId:

   469

        {

   470

            erpcStatus = RepairPLC_shim(codec, messageFactory, transport, sequence);

   471

            break;

   472

        }

   473

   474

        case BeremizPLCObjectService_interface::m_ResetLogCountId:

   475

        {

   476

            erpcStatus = ResetLogCount_shim(codec, messageFactory, transport, sequence);

   477

            break;

   478

        }

   479

   480

        case BeremizPLCObjectService_interface::m_SeedBlobId:

   481

        {

   482

            erpcStatus = SeedBlob_shim(codec, messageFactory, transport, sequence);

   483

            break;

   484

        }

   485

   486

        case BeremizPLCObjectService_interface::m_SetTraceVariablesListId:

   487

        {

   488

            erpcStatus = SetTraceVariablesList_shim(codec, messageFactory, transport, sequence);

   489

            break;

   490

        }

   491

   492

        case BeremizPLCObjectService_interface::m_StartPLCId:

   493

        {

   494

            erpcStatus = StartPLC_shim(codec, messageFactory, transport, sequence);

   495

            break;

   496

        }

   497

   498

        case BeremizPLCObjectService_interface::m_StopPLCId:

   499

        {

   500

            erpcStatus = StopPLC_shim(codec, messageFactory, transport, sequence);

   501

            break;

   502

        }

   503

   504

        default:

   505

        {

   506

            erpcStatus = kErpcStatus_InvalidArgument;

   507

            break;

   508

        }

   509

    }

   510

   511

    return erpcStatus;

   512

}

   513

   514

// Server shim for AppendChunkToBlob of BeremizPLCObjectService interface.

   515

erpc_status_t BeremizPLCObjectService_service::AppendChunkToBlob_shim(Codec * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence)

   516

{

   517

    erpc_status_t err = kErpcStatus_Success;

   518

   519

    binary_t *data = NULL;

   520

    data = (binary_t *) erpc_malloc(sizeof(binary_t));

   521

    if (data == NULL)

   522

    {

   523

        codec->updateStatus(kErpcStatus_MemoryError);

   524

    }

   525

    binary_t *blobID = NULL;

   526

    blobID = (binary_t *) erpc_malloc(sizeof(binary_t));

   527

    if (blobID == NULL)

   528

    {

   529

        codec->updateStatus(kErpcStatus_MemoryError);

   530