dataPointPath.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP
#define RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP
 
#include <algorithm>
#include <iostream>
#include <regex>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <fmt/format.h>
#include <mal/utility/Uri.hpp>
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/jsonPayload.hpp>
 
namespace rtctk::componentFramework {
 
class DataPointPath {
public:
    class InvalidPathException : public RtctkException {
    public:
        explicit InvalidPathException(const std::string& path);
    };
 
    DataPointPath() = default;
    DataPointPath(const DataPointPath&) = default;
    DataPointPath& operator=(const DataPointPath&) = default;
    DataPointPath(DataPointPath&&) = default;
    DataPointPath& operator=(DataPointPath&&) = default;
    virtual ~DataPointPath() = default;
 
    explicit DataPointPath(const std::string& new_path);
 
    explicit DataPointPath(std::string&& new_path);
 
    explicit DataPointPath(const char* const new_path) : DataPointPath(std::string(new_path)) {
    }
 
    const std::string& ToString() const noexcept;
 
    DataPointPath& operator=(const std::string& new_path);
 
    DataPointPath& operator=(std::string&& new_path);
 
    operator std::string() const noexcept;
 
    // Append Operators
    DataPointPath& operator+=(const DataPointPath& rhs);
    DataPointPath& operator/=(const DataPointPath& rhs);
 
    friend DataPointPath operator+(DataPointPath lhs, const DataPointPath& rhs);
 
    friend DataPointPath operator/(DataPointPath lhs, const DataPointPath& rhs);
 
    friend std::ostream& operator<<(std::ostream& out, const DataPointPath& rhs);
 
    // Comparison operators for DataPointPath, char * and string
    friend bool operator==(const DataPointPath& lhs, const char* rhs) noexcept;
    friend bool operator!=(const DataPointPath& lhs, const char* rhs) noexcept {
        return !(lhs == rhs);
    }
    friend bool operator<(const DataPointPath& lhs, const char* rhs) noexcept;
    friend bool operator<=(const DataPointPath& lhs, const char* rhs) noexcept;
    friend bool operator>(const DataPointPath& lhs, const char* rhs) noexcept;
    friend bool operator>=(const DataPointPath& lhs, const char* rhs) noexcept;
 
    friend bool operator==(const DataPointPath& lhs, const std::string& rhs) noexcept;
    friend bool operator!=(const DataPointPath& lhs, const std::string& rhs) noexcept {
        return !(lhs == rhs);
    }
    friend bool operator<(const DataPointPath& lhs, const std::string& rhs) noexcept;
    friend bool operator<=(const DataPointPath& lhs, const std::string& rhs) noexcept;
    friend bool operator>(const DataPointPath& lhs, const std::string& rhs) noexcept;
    friend bool operator>=(const DataPointPath& lhs, const std::string& rhs) noexcept;
 
    friend bool operator==(const DataPointPath& lhs, const DataPointPath& rhs) noexcept;
    friend bool operator!=(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
        return !(lhs == rhs);
    }
    friend bool operator<(const DataPointPath& lhs, const DataPointPath& rhs) noexcept;
    friend bool operator<=(const DataPointPath& lhs, const DataPointPath& rhs) noexcept;
    friend bool operator>(const DataPointPath& lhs, const DataPointPath& rhs) noexcept;
    friend bool operator>=(const DataPointPath& lhs, const DataPointPath& rhs) noexcept;
 
    // symmetry
    friend bool operator==(const char* lhs, const DataPointPath& rhs) noexcept {
        return rhs == lhs;
    }
    friend bool operator!=(const char* lhs, const DataPointPath& rhs) noexcept {
        return !(rhs == lhs);
    }
    friend bool operator<(const char* lhs, const DataPointPath& rhs) noexcept {
        return rhs > lhs;
    }
    friend bool operator<=(const char* lhs, const DataPointPath& rhs) noexcept {
        return rhs >= lhs;
    }
    friend bool operator>(const char* lhs, const DataPointPath& rhs) noexcept {
        return rhs < lhs;
    }
    friend bool operator>=(const char* lhs, const DataPointPath& rhs) noexcept {
        return rhs <= lhs;
    }
 
    friend bool operator==(const std::string& lhs, const DataPointPath& rhs) noexcept {
        return rhs == lhs;
    }
    friend bool operator!=(const std::string& lhs, const DataPointPath& rhs) noexcept {
        return !(rhs == lhs);
    }
    friend bool operator<(const std::string& lhs, const DataPointPath& rhs) noexcept {
        return rhs > lhs;
    }
    friend bool operator<=(const std::string& lhs, const DataPointPath& rhs) noexcept {
        return rhs >= lhs;
    }
    friend bool operator>(const std::string& lhs, const DataPointPath& rhs) noexcept {
        return rhs < lhs;
    }
    friend bool operator>=(const std::string& lhs, const DataPointPath& rhs) noexcept {
        return rhs <= lhs;
    }
 
    friend std::istream& operator>>(std::istream& input, DataPointPath& path);
    elt::mal::Uri ToRepositoryURI(const elt::mal::Uri& base_uri) const;
 
    std::pair<DataPointPath, DataPointPath> Split() const;
 
    DataPointPath BasePath() const;
 
    DataPointPath LastComponent() const;
 
    std::vector<DataPointPath> SplitAll() const;
 
    static elt::mal::Uri AppendSuffixToUriPath(const std::string& suffix, const elt::mal::Uri& uri);
 
private:
    static bool ValidPath(const std::string& path);
 
    std::string m_path;
 
    const static char VALID_CHARACTERS[];
 
    const static std::regex REGEX_VALID_CHARS;
};  // class DataPointPath
 
DataPointPath operator"" _dppath(const char* str, std::size_t len);
 
// inline implementations
 
inline bool operator==(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.m_path == rhs;
}
 
inline bool operator<(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.m_path < rhs;
}
 
inline bool operator<=(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.m_path <= rhs;
}
 
inline bool operator>(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.m_path > rhs;
}
 
inline bool operator>=(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.m_path >= rhs;
}
 
inline bool operator==(const DataPointPath& lhs, const std::string& rhs) noexcept {
    return lhs.m_path == rhs;
}
 
inline bool operator<(const DataPointPath& lhs, const std::string& rhs) noexcept {
    return lhs.m_path < rhs;
}
 
inline bool operator<=(const DataPointPath& lhs, const std::string& rhs) noexcept {
    return lhs.m_path <= rhs;
}
 
inline bool operator>(const DataPointPath& lhs, const std::string& rhs) noexcept {
    return lhs.m_path > rhs;
}
 
inline bool operator>=(const DataPointPath& lhs, const std::string& rhs) noexcept {
    return lhs.m_path >= rhs;
}
 
inline bool operator==(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.m_path == rhs.m_path;
}
 
inline bool operator<(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.m_path < rhs.m_path;
}
 
inline bool operator<=(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.m_path <= rhs.m_path;
}
 
inline bool operator>(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.m_path > rhs.m_path;
}
 
inline bool operator>=(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.m_path >= rhs.m_path;
}
 
inline DataPointPath operator+(DataPointPath lhs, const DataPointPath& rhs) {
    lhs += rhs;
    if (not DataPointPath::ValidPath(lhs)) {
        CII_THROW(DataPointPath::InvalidPathException, lhs);
    }
    return lhs;
}
 
inline DataPointPath operator/(DataPointPath lhs, const DataPointPath& rhs) {
    lhs /= rhs;
    return lhs;
}
 
inline const std::string& DataPointPath::ToString() const noexcept {
    return this->m_path;
}
 
inline DataPointPath& DataPointPath::operator+=(const DataPointPath& rhs) {
    this->m_path += rhs.m_path;
    if (not DataPointPath::ValidPath(*this)) {
        CII_THROW(DataPointPath::InvalidPathException, *this);
    }
    return *this;
}
 
inline DataPointPath& DataPointPath::operator/=(const DataPointPath& rhs) {
    std::string::value_type this_path_back = this->m_path.empty() ? '0' : this->m_path.back();
    std::string::value_type rhs_path_front = rhs.m_path.empty() ? '0' : rhs.m_path.front();
    if (this_path_back != '/' and rhs_path_front != '/') {
        // If we do not end or start with a slash then add one.
        this->m_path += "/" + rhs.m_path;
    } else if (this_path_back == '/' and rhs_path_front == '/') {
        // If we end and start with a slash then ignore one of them.
        this->m_path.append(rhs.m_path, 1);
    } else {
        this->m_path += rhs.m_path;
    }
    return *this;
}
 
inline DataPointPath operator"" _dppath(const char* str, std::size_t len) {
    return DataPointPath(std::string(str));
}
 
inline DataPointPath::operator std::string() const noexcept {
    return m_path;
}
 
inline std::ostream& operator<<(std::ostream& out, const DataPointPath& rhs) {
    out << rhs.m_path;
    return out;
}
 
}  // namespace rtctk::componentFramework
 
template <>
struct fmt::formatter<rtctk::componentFramework::DataPointPath> : fmt::formatter<std::string> {
    auto format(const rtctk::componentFramework::DataPointPath& path, fmt::format_context& ctx)
        -> fmt::format_context::iterator;
};
 
namespace rtctk::componentFramework {
// The naming convention for the following two helper functions is defined by the nlohmann_json
// library.
// NOLINTNEXTLINE(readability-identifier-naming)
inline void to_json(JsonPayload& j, const std::vector<DataPointPath>& v) {
    std::vector<std::string> string_vec;
    string_vec.reserve(v.size());
    for (auto& path : v) {
        string_vec.emplace_back(path.ToString());
    }
    j = JsonPayload{string_vec};
}
 
// NOLINTNEXTLINE(readability-identifier-naming)
inline void from_json(const JsonPayload& j, std::vector<DataPointPath>& v) {
    auto string_vec = j.get<std::vector<std::string>>();
    v.reserve(string_vec.size());
    for (auto& str : string_vec) {
        v.emplace_back(str);
    }
}
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP