opengris-scaler 1.12.7__cp38-cp38-manylinux_2_28_x86_64.whl

scaler/object_storage/message.cpp

@@ -0,0 +1,56 @@
+#include "scaler/object_storage/message.h"
+
+namespace scaler {
+namespace object_storage {
+
+kj::Array<const capnp::word> ObjectID::toBuffer() const
+{
+    capnp::MallocMessageBuilder returnMsg;
+    auto objectIDRoot = returnMsg.initRoot<scaler::protocol::ObjectID>();
+
+    objectIDRoot.setField0(value[0]);
+    objectIDRoot.setField1(value[1]);
+    objectIDRoot.setField2(value[2]);
+    objectIDRoot.setField3(value[3]);
+
+    return capnp::messageToFlatArray(returnMsg);
+}
+
+kj::Array<const capnp::word> ObjectRequestHeader::toBuffer() const
+{
+    capnp::MallocMessageBuilder returnMsg;
+    auto reqRoot = returnMsg.initRoot<scaler::protocol::ObjectRequestHeader>();
+
+    auto reqRootObjectID = reqRoot.initObjectID();
+    reqRootObjectID.setField0(objectID[0]);
+    reqRootObjectID.setField1(objectID[1]);
+    reqRootObjectID.setField2(objectID[2]);
+    reqRootObjectID.setField3(objectID[3]);
+
+    reqRoot.setPayloadLength(payloadLength);
+    reqRoot.setRequestID(requestID);
+    reqRoot.setRequestType(requestType);
+
+    return capnp::messageToFlatArray(returnMsg);
+}
+
+kj::Array<const capnp::word> ObjectResponseHeader::toBuffer() const
+{
+    capnp::MallocMessageBuilder returnMsg;
+    auto respRoot = returnMsg.initRoot<scaler::protocol::ObjectResponseHeader>();
+
+    auto respRootObjectID = respRoot.initObjectID();
+    respRootObjectID.setField0(objectID[0]);
+    respRootObjectID.setField1(objectID[1]);
+    respRootObjectID.setField2(objectID[2]);
+    respRootObjectID.setField3(objectID[3]);
+
+    respRoot.setPayloadLength(payloadLength);
+    respRoot.setResponseID(responseID);
+    respRoot.setResponseType(responseType);
+
+    return capnp::messageToFlatArray(returnMsg);
+}
+
+};  // namespace object_storage
+};  // namespace scaler

scaler/object_storage/message.h

@@ -0,0 +1,130 @@
+#pragma once
+
+#include <capnp/serialize.h>
+
+#include <array>
+#include <cstdio>
+#include <vector>
+
+#include "../protocol/capnp/object_storage.capnp.h"
+
+namespace scaler {
+namespace object_storage {
+
+static constexpr size_t CAPNP_HEADER_SIZE = 80;
+static constexpr size_t CAPNP_WORD_SIZE   = sizeof(capnp::word);
+
+template <typename T>
+concept ObjectStorageMessage = requires(const T obj, std::vector<capnp::word> buffer) {
+    { T::bufferSize() } -> std::same_as<size_t>;
+
+    { obj.toBuffer() } -> std::same_as<kj::Array<const capnp::word>>;
+
+    { T::fromBuffer(buffer) } -> std::same_as<T>;
+};
+
+struct ObjectID {
+    std::array<uint64_t, 4> value;
+
+    constexpr ObjectID() {};
+
+    constexpr ObjectID(uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3): value({v0, v1, v2, v3}) {};
+
+    constexpr uint64_t& operator[](size_t index) { return value[index]; }
+
+    constexpr const uint64_t& operator[](size_t index) const { return value[index]; }
+
+    constexpr std::strong_ordering operator<=>(const ObjectID& other) const = default;
+
+    static constexpr size_t bufferSize() { return 48; }
+
+    kj::Array<const capnp::word> toBuffer() const;
+
+    template <typename Buffer>
+    static ObjectID fromBuffer(const Buffer& buffer)
+    {
+        capnp::FlatArrayMessageReader reader(
+            kj::ArrayPtr<const capnp::word>((const capnp::word*)buffer.data(), bufferSize() / CAPNP_WORD_SIZE));
+
+        auto objectIDRoot = reader.getRoot<scaler::protocol::ObjectID>();
+
+        return {objectIDRoot.getField0(), objectIDRoot.getField1(), objectIDRoot.getField2(), objectIDRoot.getField3()};
+    }
+};
+
+static_assert(ObjectStorageMessage<ObjectID>);
+
+struct ObjectRequestHeader {
+    ObjectID objectID;
+    uint64_t payloadLength;
+    uint64_t requestID;
+    scaler::protocol::ObjectRequestHeader::ObjectRequestType requestType;
+
+    static constexpr size_t bufferSize() { return CAPNP_HEADER_SIZE; }
+
+    kj::Array<const capnp::word> toBuffer() const;
+
+    template <typename Buffer>
+    static ObjectRequestHeader fromBuffer(const Buffer& buffer)
+    {
+        capnp::FlatArrayMessageReader reader(
+            kj::ArrayPtr<const capnp::word>((const capnp::word*)buffer.data(), bufferSize() / CAPNP_WORD_SIZE));
+
+        auto requestRoot  = reader.getRoot<scaler::protocol::ObjectRequestHeader>();
+        auto objectIDRoot = requestRoot.getObjectID();
+
+        return ObjectRequestHeader {
+            .objectID =
+                {
+                    objectIDRoot.getField0(),
+                    objectIDRoot.getField1(),
+                    objectIDRoot.getField2(),
+                    objectIDRoot.getField3(),
+                },
+            .payloadLength = requestRoot.getPayloadLength(),
+            .requestID     = requestRoot.getRequestID(),
+            .requestType   = requestRoot.getRequestType(),
+        };
+    }
+};
+
+static_assert(ObjectStorageMessage<ObjectRequestHeader>);
+
+struct ObjectResponseHeader {
+    ObjectID objectID;
+    uint64_t payloadLength;
+    uint64_t responseID;
+    scaler::protocol::ObjectResponseHeader::ObjectResponseType responseType;
+
+    static constexpr size_t bufferSize() { return CAPNP_HEADER_SIZE; }
+
+    kj::Array<const capnp::word> toBuffer() const;
+
+    template <typename Buffer>
+    static ObjectResponseHeader fromBuffer(const Buffer& buffer)
+    {
+        capnp::FlatArrayMessageReader reader(
+            kj::ArrayPtr<const capnp::word>((const capnp::word*)buffer.data(), bufferSize() / CAPNP_WORD_SIZE));
+
+        auto responseRoot = reader.getRoot<scaler::protocol::ObjectResponseHeader>();
+        auto objectIDRoot = responseRoot.getObjectID();
+
+        return ObjectResponseHeader {
+            .objectID =
+                {
+                    objectIDRoot.getField0(),
+                    objectIDRoot.getField1(),
+                    objectIDRoot.getField2(),
+                    objectIDRoot.getField3(),
+                },
+            .payloadLength = responseRoot.getPayloadLength(),
+            .responseID    = responseRoot.getResponseID(),
+            .responseType  = responseRoot.getResponseType(),
+        };
+    }
+};
+
+static_assert(ObjectStorageMessage<ObjectResponseHeader>);
+
+};  // namespace object_storage
+};  // namespace scaler

scaler/object_storage/object_manager.cpp

@@ -0,0 +1,126 @@
+#include "scaler/object_storage/object_manager.h"
+
+#include <algorithm>
+
+template <>
+struct std::hash<scaler::object_storage::ObjectPayload> {
+    std::size_t operator()(const scaler::object_storage::ObjectPayload& payload) const noexcept
+    {
+        return std::hash<std::string_view> {}({reinterpret_cast<const char*>(payload.data()), payload.size()});
+    }
+};
+
+namespace scaler {
+namespace object_storage {
+
+ObjectManager::ObjectManager()
+{
+}
+
+std::shared_ptr<const ObjectPayload> ObjectManager::setObject(
+    const ObjectID& objectID, ObjectPayload&& payload) noexcept
+{
+    if (hasObject(objectID)) {
+        // Overriding object: delete old first
+        deleteObject(objectID);
+    }
+
+    ObjectHash hash = std::hash<ObjectPayload> {}(payload);
+
+    objectIDToHash[objectID] = hash;
+
+    auto objectIt = hashToObject.find(hash);
+
+    if (objectIt == hashToObject.end()) {
+        // New object payload
+        objectIt = hashToObject
+                       .emplace(
+                           hash,
+                           ManagedObject {
+                               .useCount = 1,
+                               .payload  = std::make_shared<const ObjectPayload>(std::move(payload)),
+                           })
+                       .first;
+    } else {
+        // Known object payload
+        ++(objectIt->second.useCount);
+    }
+
+    return objectIt->second.payload;
+}
+
+std::shared_ptr<const ObjectPayload> ObjectManager::getObject(const ObjectID& objectID) const noexcept
+{
+    auto hashIt = objectIDToHash.find(objectID);
+
+    if (hashIt == objectIDToHash.end()) {
+        return SharedObjectPayload(nullptr);
+    }
+
+    return hashToObject.at(hashIt->second).payload;
+}
+
+bool ObjectManager::deleteObject(const ObjectID& objectID) noexcept
+{
+    auto hashIt = objectIDToHash.find(objectID);
+
+    if (hashIt == objectIDToHash.end()) {
+        return false;
+    }
+
+    const ObjectHash& hash = hashIt->second;
+
+    auto objectIt = hashToObject.find(hash);
+
+    --objectIt->second.useCount;
+    if (objectIt->second.useCount < 1) {
+        hashToObject.erase(objectIt);
+    }
+
+    objectIDToHash.erase(hashIt);
+
+    return true;
+}
+
+std::shared_ptr<const ObjectPayload> ObjectManager::duplicateObject(
+    const ObjectID& originalObjectID, const ObjectID& newObjectID) noexcept
+{
+    auto hashIt = objectIDToHash.find(originalObjectID);
+
+    if (hashIt == objectIDToHash.end()) {
+        return nullptr;
+    }
+
+    if (hasObject(newObjectID)) {
+        // Overriding object: delete old first
+        deleteObject(newObjectID);
+    }
+
+    auto hash = hashIt->second;
+
+    ManagedObject& object = hashToObject[hash];
+
+    ++(object.useCount);
+
+    objectIDToHash[newObjectID] = hash;
+
+    return object.payload;
+}
+
+bool ObjectManager::hasObject(const ObjectID& objectID) const noexcept
+{
+    return objectIDToHash.contains(objectID);
+}
+
+size_t ObjectManager::size() const noexcept
+{
+    return objectIDToHash.size();
+}
+
+size_t ObjectManager::sizeUnique() const noexcept
+{
+    return hashToObject.size();
+}
+
+};  // namespace object_storage
+};  // namespace scaler

scaler/object_storage/object_manager.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <map>
+#include <memory>
+
+#include "scaler/object_storage/defs.h"
+#include "scaler/object_storage/message.h"
+
+namespace scaler {
+namespace object_storage {
+
+class ObjectManager {
+public:
+    ObjectManager();
+
+    // Returns the pointer to the created (and moved) object.
+    std::shared_ptr<const ObjectPayload> setObject(const ObjectID& objectID, ObjectPayload&& payload) noexcept;
+
+    // Returns `nullptr` if the object does not exist.
+    std::shared_ptr<const ObjectPayload> getObject(const ObjectID& objectID) const noexcept;
+
+    // Returns `true` if the deleted object existed, otherwise returns `false`.
+    bool deleteObject(const ObjectID& objectID) noexcept;
+
+    // Creates a new `ObjectID` referencing the same object's content as `originalObjectID`. Overrides `newObjectID` if
+    // it already exist.
+    // Returns `nullptr` if `originalObjectID` does not exist, otherwise returns the object's content.
+    std::shared_ptr<const ObjectPayload> duplicateObject(
+        const ObjectID& originalObjectID, const ObjectID& newObjectID) noexcept;
+
+    bool hasObject(const ObjectID& objectID) const noexcept;
+
+    // Returns the total number of objects stored.
+    size_t size() const noexcept;
+
+    // Returns the total number of unique objects stored (i.e. only count duplicate payloads once).
+    size_t sizeUnique() const noexcept;
+
+private:
+    using ObjectHash = std::size_t;
+
+    struct ManagedObject {
+        size_t useCount;
+        std::shared_ptr<const ObjectPayload> payload;
+    };
+
+    std::map<ObjectID, ObjectHash> objectIDToHash;
+    std::map<ObjectHash, ManagedObject> hashToObject;
+};
+
+};  // namespace object_storage
+};  // namespace scaler