WasmSequencer_StatusEnumAc.cpp

Go to the documentation of this file.

// ======================================================================
// \title  WasmSequencer_StatusEnumAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for WasmSequencer_Status enum
// ======================================================================

#include <cstring>
#include <limits>

#include "Svc/WasmSequencer/WasmSequencer_StatusEnumAc.hpp"

namespace Svc {

  // ----------------------------------------------------------------------
  // Operators
  // ----------------------------------------------------------------------

  WasmSequencer_Status& WasmSequencer_Status ::
    operator=(const WasmSequencer_Status& obj)
  {
    this->e = obj.e;
#ifdef BUILD_UT
    this->m_serializeValueIsSet = obj.m_serializeValueIsSet;
    this->m_serializeValue = obj.m_serializeValue;
#endif
    return *this;
  }

  WasmSequencer_Status& WasmSequencer_Status ::
    operator=(SerialType e1)
  {
    FW_ASSERT(isValid(e1), static_cast<FwAssertArgType>(e1));
    this->e = static_cast<enum T>(e1);
#ifdef BUILD_UT
    this->m_serializeValueIsSet = false;
    this->m_serializeValue = 0;
#endif
    return *this;
  }

  WasmSequencer_Status& WasmSequencer_Status ::
    operator=(enum T e1)
  {
    FW_ASSERT(isValid(e1), static_cast<FwAssertArgType>(e1));
    this->e = e1;
#ifdef BUILD_UT
    this->m_serializeValueIsSet = false;
    this->m_serializeValue = 0;
#endif
    return *this;
  }

#ifdef BUILD_UT

  std::ostream& operator<<(std::ostream& os, const WasmSequencer_Status& obj) {
    Fw::String s;
    obj.toString(s);
    os << s;
    return os;
  }

#endif

  // ----------------------------------------------------------------------
  // Member functions
  // ----------------------------------------------------------------------

  bool WasmSequencer_Status ::
    isValid() const
  {
    return WasmSequencer_Status::isValid(this->e);
  }

  Fw::SerializeStatus WasmSequencer_Status ::
    serializeTo(
        Fw::SerialBufferBase& buffer,
        Fw::Endianness mode
    ) const
  {
    SerialType es = static_cast<SerialType>(this->e);
#ifdef BUILD_UT
    // Unit testing only: On request, override the enum value
    // with the numeric value, which is allowed to be invalid
    if (this->m_serializeValueIsSet) {
      es = this->m_serializeValue;
    }
#endif
    const Fw::SerializeStatus status = buffer.serializeFrom(es, mode);
    return status;
  }

  Fw::SerializeStatus WasmSequencer_Status ::
    deserializeFrom(
        Fw::SerialBufferBase& buffer,
        Fw::Endianness mode
    )
  {
    SerialType es;
    Fw::SerializeStatus status = buffer.deserializeTo(es, mode);
    if ((status == Fw::FW_SERIALIZE_OK) && !WasmSequencer_Status::isValid(es)) {
      status = Fw::FW_DESERIALIZE_FORMAT_ERROR;
    }
    if (status == Fw::FW_SERIALIZE_OK) {
      this->e = static_cast<enum T>(es);
    }
    return status;
  }

#if FW_SERIALIZABLE_TO_STRING

  void WasmSequencer_Status ::
    toString(Fw::StringBase& sb) const
  {
    Fw::String s;
    switch (e) {
      case OK:
        s = "OK";
        break;
      case ERR_NULL_ARG:
        s = "ERR_NULL_ARG";
        break;
      case ERR_BAD_ARG:
        s = "ERR_BAD_ARG";
        break;
      case ERR_BAD_UTF8:
        s = "ERR_BAD_UTF8";
        break;
      case ERR_NAME_TOO_LONG:
        s = "ERR_NAME_TOO_LONG";
        break;
      case ERR_BAD_SIGNATURE:
        s = "ERR_BAD_SIGNATURE";
        break;
      case ERR_CAPACITY:
        s = "ERR_CAPACITY";
        break;
      case ERR_NOT_FOUND:
        s = "ERR_NOT_FOUND";
        break;
      case ERR_WRONG_STATE:
        s = "ERR_WRONG_STATE";
        break;
      case ERR_GUEST_MEMORY_ALLOC_FAILED:
        s = "ERR_GUEST_MEMORY_ALLOC_FAILED";
        break;
      case ERR_ALLOC_FAILED:
        s = "ERR_ALLOC_FAILED";
        break;
      case ERR_OUT_OF_MEMORY:
        s = "ERR_OUT_OF_MEMORY";
        break;
      case ERR_PAGE_TOO_SMALL:
        s = "ERR_PAGE_TOO_SMALL";
        break;
      case ERR_MEM_OUT_OF_BOUNDS:
        s = "ERR_MEM_OUT_OF_BOUNDS";
        break;
      case ERR_PARAM_LEN_MISMATCH:
        s = "ERR_PARAM_LEN_MISMATCH";
        break;
      case ERR_PARAM_TYPE_MISMATCH:
        s = "ERR_PARAM_TYPE_MISMATCH";
        break;
      case ERR_STACK_OVERFLOW:
        s = "ERR_STACK_OVERFLOW";
        break;
      case ERR_EOF:
        s = "ERR_EOF";
        break;
      case ERR_MALFORMED_INTEGER:
        s = "ERR_MALFORMED_INTEGER";
        break;
      case ERR_I33_IS_NEGATIVE:
        s = "ERR_I33_IS_NEGATIVE";
        break;
      case ERR_MALFORMED_MAGIC:
        s = "ERR_MALFORMED_MAGIC";
        break;
      case ERR_MALFORMED_VERSION:
        s = "ERR_MALFORMED_VERSION";
        break;
      case ERR_MALFORMED_UTF8:
        s = "ERR_MALFORMED_UTF8";
        break;
      case ERR_DUPLICATE_MODULE_NAME:
        s = "ERR_DUPLICATE_MODULE_NAME";
        break;
      case ERR_DUPLICATE_EXPORT_NAME:
        s = "ERR_DUPLICATE_EXPORT_NAME";
        break;
      case ERR_MALFORMED_SECTION_ID:
        s = "ERR_MALFORMED_SECTION_ID";
        break;
      case ERR_MALFORMED_VALUE_TYPE:
        s = "ERR_MALFORMED_VALUE_TYPE";
        break;
      case ERR_MALFORMED_FUNCTION:
        s = "ERR_MALFORMED_FUNCTION";
        break;
      case ERR_MALFORMED_LIMIT:
        s = "ERR_MALFORMED_LIMIT";
        break;
      case ERR_MALFORMED_ELEM_TYPE:
        s = "ERR_MALFORMED_ELEM_TYPE";
        break;
      case ERR_MALFORMED_SECTION_SIZE:
        s = "ERR_MALFORMED_SECTION_SIZE";
        break;
      case ERR_EXPECTED_CONST_OR_VAR:
        s = "ERR_EXPECTED_CONST_OR_VAR";
        break;
      case ERR_MALFORMED_IMPORT_EXPORT_DESC:
        s = "ERR_MALFORMED_IMPORT_EXPORT_DESC";
        break;
      case ERR_MALFORMED_MEM_TYPE:
        s = "ERR_MALFORMED_MEM_TYPE";
        break;
      case ERR_INVALID_PAGE_SIZE:
        s = "ERR_INVALID_PAGE_SIZE";
        break;
      case ERR_INVALID_SECTION_ORDERING:
        s = "ERR_INVALID_SECTION_ORDERING";
        break;
      case ERR_DUPLICATE_SECTION:
        s = "ERR_DUPLICATE_SECTION";
        break;
      case ERR_INVALID_MAX_LIMIT:
        s = "ERR_INVALID_MAX_LIMIT";
        break;
      case ERR_EXPECTED_TERMINAL:
        s = "ERR_EXPECTED_TERMINAL";
        break;
      case ERR_INVALID_OPCODE:
        s = "ERR_INVALID_OPCODE";
        break;
      case ERR_MALFORMED_CODE_SIZE:
        s = "ERR_MALFORMED_CODE_SIZE";
        break;
      case ERR_INVALID_CODE_SECTION_FUNCTION_COUNT:
        s = "ERR_INVALID_CODE_SECTION_FUNCTION_COUNT";
        break;
      case ERR_VEC_TOO_LONG:
        s = "ERR_VEC_TOO_LONG";
        break;
      case ERR_IDX_TOO_LARGE:
        s = "ERR_IDX_TOO_LARGE";
        break;
      case ERR_MODULE_IDX_TOO_LARGE:
        s = "ERR_MODULE_IDX_TOO_LARGE";
        break;
      case ERR_MEMORY_TOO_LARGE:
        s = "ERR_MEMORY_TOO_LARGE";
        break;
      case ERR_MEMORY_IMPORT_TOO_LARGE:
        s = "ERR_MEMORY_IMPORT_TOO_LARGE";
        break;
      case ERR_MEM_ALIGN_TOO_LARGE:
        s = "ERR_MEM_ALIGN_TOO_LARGE";
        break;
      case ERR_TABLE_TOO_LARGE:
        s = "ERR_TABLE_TOO_LARGE";
        break;
      case ERR_CONTROL_FLOW_TOO_DEEP:
        s = "ERR_CONTROL_FLOW_TOO_DEEP";
        break;
      case ERR_STACK_UNDERFLOW:
        s = "ERR_STACK_UNDERFLOW";
        break;
      case ERR_STACK_TOO_LARGE:
        s = "ERR_STACK_TOO_LARGE";
        break;
      case ERR_LABEL_STACK_JUMP_TOO_DEEP:
        s = "ERR_LABEL_STACK_JUMP_TOO_DEEP";
        break;
      case ERR_LABEL_JUMP_TOO_LARGE:
        s = "ERR_LABEL_JUMP_TOO_LARGE";
        break;
      case ERR_TYPE_MISMATCH:
        s = "ERR_TYPE_MISMATCH";
        break;
      case ERR_BLOCK_RESULT_TYPE_MISMATCH:
        s = "ERR_BLOCK_RESULT_TYPE_MISMATCH";
        break;
      case ERR_FUNCTION_RESULT_TYPE_MISMATCH:
        s = "ERR_FUNCTION_RESULT_TYPE_MISMATCH";
        break;
      case ERR_BR_TABLE_RESULT_TYPE_MISMATCH:
        s = "ERR_BR_TABLE_RESULT_TYPE_MISMATCH";
        break;
      case ERR_ILLEGAL_MEMORY_GROW:
        s = "ERR_ILLEGAL_MEMORY_GROW";
        break;
      case ERR_INVALID_ELEMENT_OFFSET:
        s = "ERR_INVALID_ELEMENT_OFFSET";
        break;
      case ERR_INVALID_ELEMENT_OUT_OF_BOUNDS:
        s = "ERR_INVALID_ELEMENT_OUT_OF_BOUNDS";
        break;
      case ERR_INVALID_TABLE_INDEX:
        s = "ERR_INVALID_TABLE_INDEX";
        break;
      case ERR_TABLE_NOT_DEFINED:
        s = "ERR_TABLE_NOT_DEFINED";
        break;
      case ERR_INVALID_ELEMENT_COUNT:
        s = "ERR_INVALID_ELEMENT_COUNT";
        break;
      case ERR_INVALID_MEM_INDEX:
        s = "ERR_INVALID_MEM_INDEX";
        break;
      case ERR_MEMORY_NOT_DEFINED:
        s = "ERR_MEMORY_NOT_DEFINED";
        break;
      case ERR_INVALID_MEM_OFFSET_TYPE:
        s = "ERR_INVALID_MEM_OFFSET_TYPE";
        break;
      case ERR_INVALID_NEGATIVE_MEM_OFFSET:
        s = "ERR_INVALID_NEGATIVE_MEM_OFFSET";
        break;
      case ERR_INVALID_MEM_OFFSET:
        s = "ERR_INVALID_MEM_OFFSET";
        break;
      case ERR_MULTIPLE_MEMORIES:
        s = "ERR_MULTIPLE_MEMORIES";
        break;
      case ERR_MULTIPLE_TABLES:
        s = "ERR_MULTIPLE_TABLES";
        break;
      case ERR_INVALID_LABEL_INDEX:
        s = "ERR_INVALID_LABEL_INDEX";
        break;
      case ERR_INVALID_ELSE_BLOCK:
        s = "ERR_INVALID_ELSE_BLOCK";
        break;
      case ERR_INVALID_END_BLOCK:
        s = "ERR_INVALID_END_BLOCK";
        break;
      case ERR_INSTRUCTION_OUTSIDE_OF_FUNCTION:
        s = "ERR_INSTRUCTION_OUTSIDE_OF_FUNCTION";
        break;
      case ERR_LOCAL_IDX_OUT_OF_RANGE:
        s = "ERR_LOCAL_IDX_OUT_OF_RANGE";
        break;
      case ERR_FUNCTION_IDX_OUT_OF_RANGE:
        s = "ERR_FUNCTION_IDX_OUT_OF_RANGE";
        break;
      case ERR_TYPE_IDX_OUT_OF_RANGE:
        s = "ERR_TYPE_IDX_OUT_OF_RANGE";
        break;
      case ERR_FUNCTION_TEXT_OUT_OF_RANGE:
        s = "ERR_FUNCTION_TEXT_OUT_OF_RANGE";
        break;
      case ERR_GLOBAL_IDX_OUT_OF_RANGE:
        s = "ERR_GLOBAL_IDX_OUT_OF_RANGE";
        break;
      case ERR_FUNCTION_IMPORT_NOT_FOUND:
        s = "ERR_FUNCTION_IMPORT_NOT_FOUND";
        break;
      case ERR_GLOBAL_IMPORT_NOT_FOUND:
        s = "ERR_GLOBAL_IMPORT_NOT_FOUND";
        break;
      case ERR_MEMORY_IMPORT_NOT_FOUND:
        s = "ERR_MEMORY_IMPORT_NOT_FOUND";
        break;
      case ERR_TABLE_IMPORT_NOT_FOUND:
        s = "ERR_TABLE_IMPORT_NOT_FOUND";
        break;
      case ERR_FUNCTION_IMPORT_OUT_OF_RANGE:
        s = "ERR_FUNCTION_IMPORT_OUT_OF_RANGE";
        break;
      case ERR_FUNCTION_IMPORT_TYPE_MISMATCH:
        s = "ERR_FUNCTION_IMPORT_TYPE_MISMATCH";
        break;
      case ERR_GLOBAL_NOT_MUTABLE:
        s = "ERR_GLOBAL_NOT_MUTABLE";
        break;
      case ERR_GLOBAL_IMPORT_TYPE_MISMATCH:
        s = "ERR_GLOBAL_IMPORT_TYPE_MISMATCH";
        break;
      case ERR_MEMORY_IMPORT_TYPE_MISMATCH:
        s = "ERR_MEMORY_IMPORT_TYPE_MISMATCH";
        break;
      case ERR_TABLE_IMPORT_TYPE_MISMATCH:
        s = "ERR_TABLE_IMPORT_TYPE_MISMATCH";
        break;
      case ERR_TABLE_IMPORT_INCOMPATIBLE_SIZE:
        s = "ERR_TABLE_IMPORT_INCOMPATIBLE_SIZE";
        break;
      case ERR_TABLE_REF_NOT_UNIQUE:
        s = "ERR_TABLE_REF_NOT_UNIQUE";
        break;
      case ERR_FUNCTION_PARAMETERS_TOO_LARGE:
        s = "ERR_FUNCTION_PARAMETERS_TOO_LARGE";
        break;
      case ERR_FUNCTION_RETURNS_TOO_LARGE:
        s = "ERR_FUNCTION_RETURNS_TOO_LARGE";
        break;
      case ERR_TOO_MANY_LOCALS:
        s = "ERR_TOO_MANY_LOCALS";
        break;
      case ERR_INVALID_CONST_INSTRUCTION:
        s = "ERR_INVALID_CONST_INSTRUCTION";
        break;
      case ERR_GLOBAL_TYPE_MISMATCH:
        s = "ERR_GLOBAL_TYPE_MISMATCH";
        break;
      case ERR_ALIGNMENT_LARGER_THAN_TYPE:
        s = "ERR_ALIGNMENT_LARGER_THAN_TYPE";
        break;
      case ERR_INVALID_START_FUNCTION_SIGNATURE:
        s = "ERR_INVALID_START_FUNCTION_SIGNATURE";
        break;
      case ERR_INVALID_HOST_START_FUNCTION:
        s = "ERR_INVALID_HOST_START_FUNCTION";
        break;
      case ERR_CONST_ALREADY_HAS_VALUE:
        s = "ERR_CONST_ALREADY_HAS_VALUE";
        break;
      case ERR_CONST_NO_VALUE:
        s = "ERR_CONST_NO_VALUE";
        break;
      case ERR_CONST_INVALID_GLOBAL:
        s = "ERR_CONST_INVALID_GLOBAL";
        break;
      case ERR_POSSIBLE_BACKPATCH_CYCLE:
        s = "ERR_POSSIBLE_BACKPATCH_CYCLE";
        break;
      case ERR_PAGE_FAULT:
        s = "ERR_PAGE_FAULT";
        break;
      case ERR_READER_ERROR:
        s = "ERR_READER_ERROR";
        break;
      default:
        s = "[invalid]";
        break;
    }
    sb.format("%s (%" PRIi32 ")", s.toChar(), e);
  }

#endif

#ifdef BUILD_UT

  void WasmSequencer_Status ::
    setSerializeValue(SerialType serializeValue)
  {
    this->m_serializeValue = serializeValue;
    this->m_serializeValueIsSet = true;
  }

#endif

  // ----------------------------------------------------------------------
  // Static functions
  // ----------------------------------------------------------------------

  bool WasmSequencer_Status ::
    isValid(SerialType serialTypeValue)
  {
    return ((serialTypeValue >= OK) && (serialTypeValue <= ERR_WRONG_STATE))
      || ((serialTypeValue >= ERR_GUEST_MEMORY_ALLOC_FAILED) && (serialTypeValue <= ERR_PAGE_TOO_SMALL))
      || (serialTypeValue == ERR_MEM_OUT_OF_BOUNDS)
      || ((serialTypeValue >= ERR_PARAM_LEN_MISMATCH) && (serialTypeValue <= ERR_STACK_OVERFLOW))
      || ((serialTypeValue >= ERR_EOF) && (serialTypeValue <= ERR_BR_TABLE_RESULT_TYPE_MISMATCH))
      || ((serialTypeValue >= ERR_ILLEGAL_MEMORY_GROW) && (serialTypeValue <= ERR_MULTIPLE_TABLES))
      || ((serialTypeValue >= ERR_INVALID_LABEL_INDEX) && (serialTypeValue <= ERR_GLOBAL_IDX_OUT_OF_RANGE))
      || ((serialTypeValue >= ERR_FUNCTION_IMPORT_NOT_FOUND) && (serialTypeValue <= ERR_TABLE_REF_NOT_UNIQUE))
      || ((serialTypeValue >= ERR_FUNCTION_PARAMETERS_TOO_LARGE) && (serialTypeValue <= ERR_INVALID_HOST_START_FUNCTION))
      || ((serialTypeValue >= ERR_CONST_ALREADY_HAS_VALUE) && (serialTypeValue <= ERR_CONST_INVALID_GLOBAL))
      || ((serialTypeValue >= ERR_POSSIBLE_BACKPATCH_CYCLE) && (serialTypeValue <= ERR_READER_ERROR));
  }

}