dataPointPath.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP
#define RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/jsonPayload.hpp>
#include <rtctk/config.hpp>
 
#include <fmt/format.h>
#include <mal/utility/Uri.hpp>
 
#include <algorithm>
#include <iostream>
#include <regex>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace rtctk::componentFramework {
 
class RTCTK_API DataPointPath final {
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;
 
    // This class cannot be inherited, therefore no need for a virtual destructor.
    ~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:
    RTCTK_LOCAL static bool ValidPath(const std::string& path);
 
    std::string m_path;
 
    RTCTK_LOCAL const static char VALID_CHARACTERS[];
 
    RTCTK_LOCAL const static std::regex REGEX_VALID_CHARS;
};  // class DataPointPath
 
RTCTK_API 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;
    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 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;
}
 
// The naming convention for the following two helper functions is defined by the nlohmann/json.hpp
// header library.
// NOLINTNEXTLINE(readability-identifier-naming)
RTCTK_API void to_json(JsonPayload& j, const std::vector<DataPointPath>& v);
 
// NOLINTNEXTLINE(readability-identifier-naming)
RTCTK_API void from_json(const JsonPayload& j, std::vector<DataPointPath>& v);
 
}  // namespace rtctk::componentFramework
 
template <>
struct RTCTK_API fmt::formatter<rtctk::componentFramework::DataPointPath>
    : fmt::formatter<std::string> {
    auto format(const rtctk::componentFramework::DataPointPath& path,
                fmt::format_context& ctx) -> fmt::format_context::iterator;
};
 
#endif  // RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP