dataPointPath.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP
#define RTCTK_COMPONENTFRAMEWORK_DATAPOINTPATH_HPP
 
#include <stdexcept>
#include <iostream>
#include <string>
#include <regex>
#include <algorithm>
#include <string_view>
#include <type_traits>
#include <regex>
#include <mal/utility/Uri.hpp>
#include "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