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 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;
 
    static elt::mal::Uri AppendSuffixToUriPath(const std::string& suffix, const elt::mal::Uri& uri);
 
private:
    static bool ValidPath(const std::string& path);
 
    std::string 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.path == rhs;
}
 
inline bool operator<(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.path < rhs;
}
 
inline bool operator<=(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.path <= rhs;
}
 
inline bool operator>(const DataPointPath& lhs, const char* rhs) noexcept {
    return lhs.path > rhs;
}
 
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 std::string& 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 std::string& 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 bool operator<(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.path < rhs.path;
}
 
inline bool operator<=(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.path <= rhs.path;
}
 
inline bool operator>(const DataPointPath& lhs, const DataPointPath& rhs) noexcept {
    return lhs.path > rhs.path;
}
 
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;
    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->path;
}
 
inline DataPointPath& DataPointPath::operator+=(const DataPointPath& rhs) {
    this->path += rhs.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->path.empty() ? '0' : this->path.back();
    std::string::value_type rhs_path_front = rhs.path.empty() ? '0' : rhs.path.front();
    if (this_path_back != '/' and rhs_path_front != '/') {
        // If we do not end or start with a slash then add one.
        this->path += "/" + rhs.path;
    } else if (this_path_back == '/' and rhs_path_front == '/') {
        // If we end and start with a slash then ignore one of them.
        this->path.append(rhs.path, 1);
    } else {
        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