serialize changes. #35
@ -12,7 +12,7 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
|
||||
}
|
||||
|
||||
ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
|
||||
uint32_t* size, const uint32_t max_size, bool bigEndian) const {
|
||||
size_t* size, const size_t max_size, bool bigEndian) const {
|
||||
ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
|
||||
buffer, size, max_size, bigEndian);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
@ -26,12 +26,12 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
|
||||
return data->serialize(buffer, size, max_size, bigEndian);
|
||||
}
|
||||
|
||||
uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
|
||||
size_t DeviceTmReportingWrapper::getSerializedSize() const {
|
||||
return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
|
||||
}
|
||||
|
||||
ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
|
||||
int32_t* size, bool bigEndian) {
|
||||
size_t* size, bool bigEndian) {
|
||||
ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
|
||||
buffer, size, bigEndian);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
|
@ -11,15 +11,16 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
|
||||
public:
|
||||
EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) { }
|
||||
virtual ~EventRangeMatcherBase() { }
|
||||
|
||||
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
const size_t max_size, bool bigEndian) const override {
|
||||
return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
|
||||
}
|
||||
size_t getSerializedSize() const {
|
||||
size_t getSerializedSize() const override {
|
||||
return rangeMatcher.getSerializedSize();
|
||||
}
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
bool bigEndian) override {
|
||||
return rangeMatcher.deSerialize(buffer, size, bigEndian);
|
||||
}
|
||||
protected:
|
||||
|
@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
uint8_t ptc;
|
||||
uint8_t pfc;
|
||||
ReturnValue_t result = getPtcPfc(&ptc, &pfc);
|
||||
@ -81,12 +81,12 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
|
||||
|
||||
}
|
||||
|
||||
uint32_t Type::getSerializedSize() const {
|
||||
size_t Type::getSerializedSize() const {
|
||||
uint8_t dontcare = 0;
|
||||
return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
|
||||
}
|
||||
|
||||
ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
uint8_t ptc;
|
||||
uint8_t pfc;
|
||||
|
@ -63,9 +63,9 @@ bool HealthTable::hasHealth(object_id_t object) {
|
||||
return exits;
|
||||
}
|
||||
|
||||
void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
|
||||
void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
|
||||
mutex->lockMutex(MutexIF::NO_TIMEOUT);
|
||||
uint32_t size = 0;
|
||||
size_t size = 0;
|
||||
uint16_t count = healthMap.size();
|
||||
ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
|
||||
&pointer, &size, maxSize, true);
|
||||
|
@ -21,7 +21,7 @@ public:
|
||||
virtual HasHealthIF::HealthState getHealth(object_id_t);
|
||||
|
||||
virtual uint32_t getPrintSize();
|
||||
virtual void printAll(uint8_t *pointer, uint32_t maxSize);
|
||||
virtual void printAll(uint8_t *pointer, size_t maxSize);
|
||||
|
||||
protected:
|
||||
MutexIF* mutex;
|
||||
|
@ -17,7 +17,7 @@ public:
|
||||
HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
|
||||
|
||||
virtual uint32_t getPrintSize() = 0;
|
||||
virtual void printAll(uint8_t *pointer, uint32_t maxSize) = 0;
|
||||
virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
|
||||
|
||||
protected:
|
||||
virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;
|
||||
|
@ -26,7 +26,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
uint32_t size = 0;
|
||||
size_t size = 0;
|
||||
result = data->serialize(&dataTarget, &size, maxSize, true);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
|
@ -94,7 +94,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
|
||||
return result;
|
||||
}
|
||||
|
||||
uint32_t storeElementSize = 0;
|
||||
size_t storeElementSize = 0;
|
||||
|
||||
result = description->serialize(&storeElement, &storeElementSize,
|
||||
serializedSize, true);
|
||||
|
@ -77,8 +77,8 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
|
||||
return result;
|
||||
}
|
||||
|
||||
uint32_t ParameterWrapper::getSerializedSize() const {
|
||||
uint32_t serializedSize = 0;
|
||||
size_t ParameterWrapper::getSerializedSize() const {
|
||||
size_t serializedSize = 0;
|
||||
serializedSize += type.getSerializedSize();
|
||||
serializedSize += sizeof(rows);
|
||||
serializedSize += sizeof(columns);
|
||||
@ -112,7 +112,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
|
||||
|
||||
//treat from as a continuous Stream as we copy all of it
|
||||
const uint8_t *fromAsStream = (const uint8_t *) from;
|
||||
int32_t streamSize = fromRows * fromColumns * sizeof(T);
|
||||
size_t streamSize = fromRows * fromColumns * sizeof(T);
|
||||
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
|
||||
|
@ -86,8 +86,8 @@ ReturnValue_t Fuse::check() {
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
ReturnValue_t result = RETURN_FAILED;
|
||||
for (DeviceList::const_iterator iter = devices.begin();
|
||||
iter != devices.end(); iter++) {
|
||||
@ -99,7 +99,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
uint32_t Fuse::getSerializedSize() const {
|
||||
size_t Fuse::getSerializedSize() const {
|
||||
uint32_t size = 0;
|
||||
for (DeviceList::const_iterator iter = devices.begin();
|
||||
iter != devices.end(); iter++) {
|
||||
@ -108,7 +108,7 @@ uint32_t Fuse::getSerializedSize() const {
|
||||
return size;
|
||||
}
|
||||
|
||||
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
ReturnValue_t result = RETURN_FAILED;
|
||||
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
|
||||
|
15
power/Fuse.h
15
power/Fuse.h
@ -18,7 +18,8 @@ void setStaticFrameworkObjectIds();
|
||||
class Fuse: public SystemObject,
|
||||
public HasHealthIF,
|
||||
public HasReturnvaluesIF,
|
||||
public ReceivesParameterMessagesIF {
|
||||
public ReceivesParameterMessagesIF,
|
||||
public SerializeIF {
|
||||
friend void (Factory::setStaticFrameworkObjectIds)();
|
||||
private:
|
||||
static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
|
||||
@ -49,11 +50,13 @@ public:
|
||||
uint8_t getFuseId() const;
|
||||
ReturnValue_t initialize();
|
||||
DeviceList devices;
|
||||
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const;
|
||||
uint32_t getSerializedSize() const;
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
bool bigEndian);
|
||||
|
||||
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const override;
|
||||
size_t getSerializedSize() const override;
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) override;
|
||||
|
||||
void setAllMonitorsToUnchecked();
|
||||
ReturnValue_t performOperation(uint8_t opCode);
|
||||
MessageQueueId_t getCommandQueue() const;
|
||||
|
@ -17,8 +17,8 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
|
||||
twoSwitches), min(min), max(max), moduleId(moduleId) {
|
||||
}
|
||||
|
||||
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
|
||||
size, max_size, bigEndian);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
@ -28,7 +28,7 @@ ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
|
||||
bigEndian);
|
||||
}
|
||||
|
||||
uint32_t PowerComponent::getSerializedSize() const {
|
||||
size_t PowerComponent::getSerializedSize() const {
|
||||
return sizeof(min) + sizeof(max);
|
||||
}
|
||||
|
||||
@ -56,7 +56,7 @@ float PowerComponent::getMax() {
|
||||
return max;
|
||||
}
|
||||
|
||||
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
|
||||
size, bigEndian);
|
||||
|
@ -19,13 +19,13 @@ public:
|
||||
float getMin();
|
||||
float getMax();
|
||||
|
||||
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const;
|
||||
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const override;
|
||||
|
||||
uint32_t getSerializedSize() const;
|
||||
size_t getSerializedSize() const override;
|
||||
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
bool bigEndian);
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) override;
|
||||
|
||||
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
|
@ -23,7 +23,7 @@ SerialBufferAdapter<T>::~SerialBufferAdapter() {
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
uint32_t serializedLength = bufferLength;
|
||||
if (serializeLength) {
|
||||
serializedLength += AutoSerializeAdapter::getSerializedSize(
|
||||
|
@ -42,19 +42,18 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
|
||||
ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
|
||||
if (size != 4 * sizeof(parameters.lowerOpLimit)) {
|
||||
return MonitoringIF::INVALID_SIZE;
|
||||
}
|
||||
int32_t readSize = size;
|
||||
SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
|
||||
&readSize, true);
|
||||
&size, true);
|
||||
SerializeAdapter<float>::deSerialize(¶meters.lowerOpLimit, &data,
|
||||
&readSize, true);
|
||||
&size, true);
|
||||
SerializeAdapter<float>::deSerialize(¶meters.upperOpLimit, &data,
|
||||
&readSize, true);
|
||||
&size, true);
|
||||
SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
|
||||
&readSize, true);
|
||||
&size, true);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
|
@ -29,7 +29,7 @@ public:
|
||||
|
||||
ReturnValue_t setTargetState(int8_t newState);
|
||||
|
||||
virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
|
||||
virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
|
||||
|
||||
virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
|
@ -22,16 +22,18 @@ public:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
|
||||
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const override {
|
||||
return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size,
|
||||
max_size, bigEndian);
|
||||
}
|
||||
uint32_t getSerializedSize() const {
|
||||
size_t getSerializedSize() const override {
|
||||
return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
|
||||
}
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
bool bigEndian) {
|
||||
return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) override {
|
||||
return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer,
|
||||
size, bigEndian);
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -22,16 +22,18 @@ public:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
|
||||
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
return SerializeAdapter<uint8_t>::serialize(&service, buffer, size,
|
||||
max_size, bigEndian);
|
||||
}
|
||||
uint32_t getSerializedSize() const {
|
||||
size_t getSerializedSize() const {
|
||||
return SerializeAdapter<uint8_t>::getSerializedSize(&service);
|
||||
}
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
|
||||
return SerializeAdapter<uint8_t>::deSerialize(&service, buffer,
|
||||
size, bigEndian);
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -20,16 +20,18 @@ public:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
|
||||
const uint32_t max_size, bool bigEndian) const {
|
||||
return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
|
||||
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
const size_t max_size, bool bigEndian) const {
|
||||
return SerializeAdapter<uint8_t>::serialize(&subService, buffer,
|
||||
size, max_size, bigEndian);
|
||||
}
|
||||
uint32_t getSerializedSize() const {
|
||||
size_t getSerializedSize() const {
|
||||
return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
|
||||
}
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
|
||||
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
bool bigEndian) {
|
||||
return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
|
||||
return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer,
|
||||
size, bigEndian);
|
||||
}
|
||||
private:
|
||||
uint8_t subService;
|
||||
|
@ -57,7 +57,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
|
||||
setData(p_data);
|
||||
initializeTmPacket(apid, service, subservice, packetSubcounter);
|
||||
uint8_t* putDataHere = getSourceData();
|
||||
uint32_t size = 0;
|
||||
size_t size = 0;
|
||||
if (header != NULL) {
|
||||
header->serialize(&putDataHere, &size, sourceDataSize, true);
|
||||
}
|
||||
|
@ -235,7 +235,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
|
||||
object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
|
||||
uint8_t buffer[sizeof(object_id_t)];
|
||||
uint8_t* pBuffer = buffer;
|
||||
uint32_t size = 0;
|
||||
size_t size = 0;
|
||||
SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
|
||||
sizeof(object_id_t), true);
|
||||
TmPacketStored tmPacketStored(this->apid, this->service, subservice,
|
||||
|
@ -49,7 +49,7 @@ class PusSuccessReport {
|
||||
private:
|
||||
static const uint16_t MAX_SIZE = 7;
|
||||
uint8_t reportBuffer[MAX_SIZE];
|
||||
uint32_t reportSize;
|
||||
size_t reportSize;
|
||||
uint8_t * pBuffer;
|
||||
public:
|
||||
PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
|
||||
@ -63,7 +63,7 @@ class PusFailureReport {
|
||||
private:
|
||||
static const uint16_t MAX_SIZE = 16;
|
||||
uint8_t reportBuffer[MAX_SIZE];
|
||||
uint32_t reportSize;
|
||||
size_t reportSize;
|
||||
uint8_t * pBuffer;
|
||||
public:
|
||||
PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
|
||||
|
Loading…
Reference in New Issue
Block a user