mqtt::mqttstore::lib::StoragePlan Class Reference

#include <StoragePlan.h>

Collaboration diagram for mqtt::mqttstore::lib::StoragePlan:

Classes
struct	ColumnMapping
struct	Projection

Public Member Functions
const std::vector< Projection > &	getProjections () const
std::vector< const Projection * >	match (const std::string &topic) const

Static Public Member Functions
static StoragePlan	fromFile (const std::string &fileName)
static StoragePlan	fromJson (const nlohmann::json &json)

Static Private Member Functions
static bool	topicMatches (const std::string &filter, const std::string &topic)

Private Attributes
std::vector< Projection >	projections

Detailed Description

Definition at line 28 of file StoragePlan.h.

Member Function Documentation

fromFile()

StoragePlan mqtt::mqttstore::lib::StoragePlan::fromFile ( const std::string & fileName )

staticnodiscard

Definition at line 106 of file StoragePlan.cpp.

                                                               {
        if (fileName.empty()) {
            return {};
        }
 
        std::ifstream planFile(fileName);
        if (!planFile.is_open()) {
            throw std::runtime_error("Cannot open mqttstore projection file '" + fileName + "'");
        }
 
        nlohmann::json planJson;
        try {
            planJson = nlohmann::json::parse(std::string(std::istreambuf_iterator<char>(planFile), std::istreambuf_iterator<char>()));
        } catch (const nlohmann::json::parse_error& exception) {
            throw std::runtime_error("Cannot parse mqttstore projection file '" + fileName + "': " + exception.what());
        }
 
        try {
            return fromJson(planJson);
        } catch (const std::exception& exception) {
            throw std::runtime_error("Cannot load mqttstore projection file '" + fileName + "': " + exception.what());
        }
    }

References fromJson().

Referenced by mqtt::mqttstore::SocketContextFactory::create(), and mqtt::mqttstore::websocket::SubProtocolFactory::create().

Here is the call graph for this function:

Here is the caller graph for this function:

fromJson()

StoragePlan mqtt::mqttstore::lib::StoragePlan::fromJson ( const nlohmann::json & json )

staticnodiscard

Definition at line 130 of file StoragePlan.cpp.

                                                              {
        validateProjectionConfiguration(json);
 
        StoragePlan plan;
 
        const nlohmann::json& projectionsJson = json.contains("projections") ? json.at("projections") : json;
        if (!projectionsJson.is_array()) {
            throw std::runtime_error("mqttstore projection configuration must be an array or contain a projections array");
        }
 
        for (const nlohmann::json& projectionJson : projectionsJson) {
            Projection projection;
            projection.name = projectionJson.value("name", "");
            projection.topic = projectionJson.at("topic").get<std::string>();
            projection.table = projectionJson.at("table").get<std::string>();
 
            const nlohmann::json& columnsJson = projectionJson.at("columns");
            if (!columnsJson.is_object()) {
                throw std::runtime_error("mqttstore projection columns must be an object");
            }
 
            for (auto columnIterator = columnsJson.begin(); columnIterator != columnsJson.end(); ++columnIterator) {
                ColumnMapping mapping;
                mapping.column = columnIterator.key();
 
                if (columnIterator.value().is_string()) {
                    mapping.jsonPointer = columnIterator.value().get<std::string>();
                } else {
                    const nlohmann::json& mappingJson = columnIterator.value();
                    mapping.jsonPointer = mappingJson.value("json_pointer", "");
                    mapping.required = mappingJson.value("required", false);
 
                    if (mappingJson.contains("topic_level")) {
                        mapping.topicLevel = mappingJson.at("topic_level").get<std::size_t>();
                    }
                    if (mappingJson.contains("literal")) {
                        mapping.literal = mappingJson.at("literal").get<std::string>();
                    }
                }
 
                projection.columns.push_back(mapping);
            }
 
            plan.projections.push_back(projection);
        }
 
        return plan;
    }

References mqtt::mqttstore::lib::anonymous_namespace{StoragePlan.cpp}::validateProjectionConfiguration().

Referenced by fromFile().

Here is the call graph for this function:

Here is the caller graph for this function:

getProjections()

const std::vector< StoragePlan::Projection > & mqtt::mqttstore::lib::StoragePlan::getProjections ( ) const

nodiscard

Definition at line 179 of file StoragePlan.cpp.

                                                                              {
        return projections;
    }

References projections.

match()

std::vector< const StoragePlan::Projection * > mqtt::mqttstore::lib::StoragePlan::match ( const std::string & topic ) const

nodiscard

Definition at line 183 of file StoragePlan.cpp.

                                                                                           {
        std::vector<const Projection*> matches;
 
        for (const Projection& projection : projections) {
            if (topicMatches(projection.topic, topic)) {
                matches.push_back(&projection);
            }
        }
 
        return matches;
    }

topicMatches()

bool mqtt::mqttstore::lib::StoragePlan::topicMatches ( const std::string & filter, const std::string & topic )

staticprivate

Definition at line 195 of file StoragePlan.cpp.

                                                                                  {
        const std::vector<std::string> filterLevels = splitTopic(filter);
        const std::vector<std::string> topicLevels = splitTopic(topic);
 
        for (std::size_t level = 0; level < filterLevels.size(); ++level) {
            if (filterLevels[level] == "#") {
                return level + 1 == filterLevels.size();
            }
 
            if (level >= topicLevels.size()) {
                return false;
            }
 
            if (filterLevels[level] != "+" && filterLevels[level] != topicLevels[level]) {
                return false;
            }
        }
 
        return filterLevels.size() == topicLevels.size();
    }

Member Data Documentation

projections

std::vector<Projection> mqtt::mqttstore::lib::StoragePlan::projections

private

Definition at line 53 of file StoragePlan.h.

Referenced by getProjections().

---

The documentation for this class was generated from the following files:

• mqttstore/lib/StoragePlan.h
• mqttstore/lib/StoragePlan.cpp