fsfw/src/fsfw/housekeeping/HousekeepingSet.cpp

#include "HousekeepingSet.h"

#include <fsfw/datapool/DatasetEntryIF.h>

#include "GeneratesHousekeepingIF.h"

#ifdef FSFW_INTROSPECTION
HousekeepingSet::HousekeepingSet(GeneratesHousekeepingIF* owner, const EnumIF &id) {
  if (owner != nullptr) {
    helper = owner->getHousekeepingHelper();
    helper->registerSet(this);
  }
  this->id = id.getValue();
  description = id.getDescription();
}

const char* HousekeepingSet::getDescription() const { return description; }
#else
HousekeepingSet::HousekeepingSet(GeneratesHousekeepingIF* owner, HousekeepingSetId_t id) : id(id) {
  if (owner != nullptr) {
    helper = owner->getHousekeepingHelper();
    helper->registerSet(this);
  }
}
#endif

HousekeepingSet::~HousekeepingSet() {}

void HousekeepingSet::report(const Action* action) {
  if (helper != nullptr) {
    helper->reportHousekeeping(this, action);
  }
}

ReturnValue_t HousekeepingSet::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                                         Endianness streamEndianness) const {
  ReturnValue_t result = SerializeAdapter::serialize(&id, buffer, size, maxSize, streamEndianness);
  if (result != returnvalue::OK) {
    return result;
  }
  for (auto parameter : parameterList) {
    result = parameter->serialize(buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
  }

  // Fill valid flags
  size_t index = 0;
  for (auto parameter : parameterList) {
    size_t byteIndex = index / 8;
    size_t bitIndex = index % 8;
    if (*size + byteIndex > maxSize) {  // TODO audition me
      return SerializeIF::STREAM_TOO_SHORT;
    }

    /**
     * check if the parameter is a datasetParameter which knows its validity
     * If not, just set to valid
     */
    DatasetEntryIF* dataSetParameter = dynamic_cast<DatasetEntryIF*>(parameter);
    if (dataSetParameter != nullptr) {
      if (dataSetParameter->getValid()) {
        (*buffer)[byteIndex] |= (1 << bitIndex);
      } else {
        (*buffer)[byteIndex] &= ~(1 << bitIndex);
      }
    } else {
      (*buffer)[byteIndex] |= (1 << bitIndex);
    }
    index++;
  }

  *size += (parameterList.size() - 1) / 8 + 1;
  if (*size > maxSize) {
    // how did we end up here
    return SerializeIF::STREAM_TOO_SHORT;
  }
  *buffer += (parameterList.size() - 1) / 8 + 1;

  return returnvalue::OK;
}

size_t HousekeepingSet::getSerializedSize() const {
  size_t size = SerializeAdapter::getSerializedSize(&id);
  for (auto parameter : parameterList) {
    size += parameter->getSerializedSize();
  }
  const size_t validBytes = (parameterList.size() - 1) / 8 + 1;
  size += validBytes;
  return size;
}

ReturnValue_t HousekeepingSet::deSerialize(const uint8_t** buffer, size_t* size,
                                           Endianness streamEndianness) {
  ReturnValue_t result = returnvalue::OK;

  /**
   * When deserializing, the id needs to be deserialized first, to find the correct class to
   * deserialize with. Consequentely, it is assumed, that the pointer was already advanced
   *
   * SerializeAdapter::deSerialize(&id, buffer, size, streamEndianness); if (result !=
   */
  for (auto parameter : *getParameters()) {
    result = parameter->deSerialize(buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
  }

  // read valid flags
  size_t index = 0;
  for (auto parameter : parameterList) {
    size_t byteIndex = index / 8;
    size_t bitIndex = index % 8;
    if (byteIndex > *size) {  // TODO audition me
      return SerializeIF::BUFFER_TOO_SHORT;
    }

    /**
     * check if the parameter is a datasetParameter which knows its validity
     * If not, just set to valid
     */
    DatasetEntryIF* dataSetParameter = dynamic_cast<DatasetEntryIF*>(parameter);
    if (dataSetParameter != nullptr) {
      bool valid = ((*buffer)[byteIndex] & (1 << bitIndex)) != 0;
      dataSetParameter->setValid(valid);
    }
    index++;
  }

  if (*size < (parameterList.size() - 1) / 8 + 1) {
    // how did we end up here
    return SerializeIF::BUFFER_TOO_SHORT;
  }
  *size -= (parameterList.size() - 1) / 8 + 1;
  *buffer += (parameterList.size() - 1) / 8 + 1;

  return returnvalue::OK;
}

void HousekeepingSet::registerParameter(ParameterIF* parameter) {
  parameterList.push_back(parameter);
}

std::vector<ParameterIF*> const* HousekeepingSet::getParameters() const { return &parameterList; }