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 <mal/utility/Uri.hpp>
 
#include <rtctk/componentFramework/exceptions.hpp>
 
namespace rtctk::componentFramework {
 
class DataPointPath {
public:
    class InvalidPathException : public elt::error::CiiBaseException {
    public:
        using elt::error::CiiBaseException::CiiBaseException;
        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 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 DataPointPath& rhs) noexcept;
    friend bool operator!=(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
        return !(lhs == rhs);
    }
 
    // 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 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;
 
private:
    const static std::regex REGEX_VALID_CHARS;
 
    static bool ValidPath(const std::string& path);
 
    std::string path;
 
    const static char VALID_CHARACTERS[];
};  // class RepositoryPath
 
DataPointPath operator"" _dppath(const char* str, std::size_t len);
 
// inline implementations
 
inline bool operator==(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.path == rhs;
}
 
inline bool operator==(const DataPointPath& lhs, const std::string& rhs) noexcept {
    return lhs.path == rhs;
}
 
inline bool operator==(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.path == rhs.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->path;
}
 
inline DataPointPath& DataPointPath::operator+=(const DataPointPath& rhs) {
    this->path += rhs.path;
    return *this;
}
 
inline DataPointPath& DataPointPath::operator/=(const DataPointPath& rhs) {
    this->path += "/" + rhs.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 path;
}
 
inline std::ostream& operator<<(std::ostream& out, const DataPointPath& rhs) {
    out << rhs.path;
    return out;
}
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP