new object ID type

src/fsfw/objectmanager/SystemObjectIF.h

@@ -16,7 +16,7 @@
  * This is the typedef for object identifiers.
  * @ingroup system_objects
  */
-typedef uint32_t object_id_t;
+using object_id_t = uint32_t;
 
 /**
  * This interface allows a class to be included in the object manager

src/fsfw/util/ObjectId.h

@@ -0,0 +1,57 @@
+#ifndef FSFW_UTIL_OBJECTID_H
+#define FSFW_UTIL_OBJECTID_H
+
+#include "fsfw/objectmanager.h"
+#include "UnsignedByteField.h"
+
+#include <functional>
+
+class ObjectId: public UnsignedByteField<object_id_t> {
+ public:
+  ObjectId(object_id_t id, const char* name): UnsignedByteField<object_id_t>(id), name_(name) {}
+
+  [[nodiscard]] const char* name() const {
+    return name_;
+  }
+
+  [[nodiscard]] object_id_t id() const {
+    return getValue();
+  }
+
+  bool operator==(const ObjectId& other) const {
+    return id() == other.id();
+  }
+
+  bool operator!=(const ObjectId& other) const {
+    return id() != other.id();
+  }
+
+  bool operator<(const ObjectId& other) const {
+    return id() < other.id();
+  }
+
+  bool operator>(const ObjectId& other) const {
+    return id() > other.id();
+  }
+
+  bool operator>=(const ObjectId& other) const {
+    return id() >= other.id();
+  }
+
+  bool operator<=(const ObjectId& other) const {
+    return id() <= other.id();
+  }
+ private:
+  const char* name_;
+};
+
+template<>
+struct std::hash<ObjectId>
+{
+  std::size_t operator()(ObjectId const& s) const noexcept
+  {
+    return std::hash<uint32_t>{}(s.id());
+  }
+};
+
+#endif  // FSFW_UTIL_OBJECTID_H

src/fsfw/util/UnsignedByteField.h

@@ -0,0 +1,52 @@
+#ifndef FSFW_UTIL_UNSIGNEDBYTEFIELD_H
+#define FSFW_UTIL_UNSIGNEDBYTEFIELD_H
+
+#include "fsfw/serialize.h"
+
+template<typename T>
+class UnsignedByteField: public SerializeIF {
+ public:
+  static_assert(std::is_unsigned<T>::value);
+
+  explicit UnsignedByteField(T value): value(value) {}
+  [[nodiscard]] ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                                Endianness streamEndianness) const override {
+    return SerializeAdapter::serialize(&value, buffer, size, maxSize, streamEndianness);
+  }
+
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                                    Endianness streamEndianness) override {
+    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+  }
+
+  [[nodiscard]] size_t getSerializedSize() const override {
+    return sizeof(T);
+  }
+
+  [[nodiscard]] T getValue() const {
+    return value;
+  }
+
+  void setValue(T value_) {
+    value = value_;
+  }
+ private:
+  T value;
+};
+
+class U32ByteField: public UnsignedByteField<uint32_t> {
+ public:
+  explicit U32ByteField(uint32_t value): UnsignedByteField<uint32_t>(value) {}
+};
+
+class U16ByteField: public UnsignedByteField<uint16_t> {
+ public:
+  explicit U16ByteField(uint16_t value): UnsignedByteField<uint16_t>(value) {}
+};
+
+class U8ByteField: public UnsignedByteField<uint8_t> {
+ public:
+  explicit U8ByteField(uint8_t value): UnsignedByteField<uint8_t>(value) {}
+};
+
+#endif  // FSFW_UTIL_UNSIGNEDBYTEFIELD_H