StringUri.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_RESOURCE__STRING_URI
#define COM_BORA_SOFTWARE__BALAU_RESOURCE__STRING_URI

#include <Balau/Exception/ResourceExceptions.hpp>
#include <Balau/Resource/StringUriByteReadResource.hpp>
#include <Balau/Resource/StringUriByteWriteResource.hpp>
#include <Balau/Resource/StringUriUtf8To32ReadResource.hpp>
#include <Balau/Resource/StringUriUtf32To8WriteResource.hpp>
#include <Balau/Resource/Uri.hpp>
#include <Balau/Util/Strings.hpp>

namespace Balau::Resource {

class StringUri : public Uri {
    public: StringUri() = default;

    public: explicit StringUri(std::string data_)
        : data(std::move(data_)) {}

    public: StringUri(const StringUri & copy) = default;

    public: StringUri(StringUri && rhs) noexcept = default;

    public: StringUri & append(std::string_view text) {
        data.append(text.data(), text.length());
        return *this;
    }

    public: StringUri & append(char c) {
        data += c;
        return *this;
    }

    public: StringUri & append(char32_t c) {
        Util::Strings::append(data, c, 1);
        return *this;
    }

    public: const std::string & getString() const {
        return data;
    }

    public: bool isRegularDirectory() const override {
        return false;
    }

    public: bool isRegularFile() const override {
        return false;
    }

    public: std::string toUriString() const override {
        return "string:";
    }

    public: std::string toRawString() const override {
        return data;
    }

    public: size_t hashcode() const noexcept override {
        return std::hash<std::string>()(data);
    }

    public: std::unique_ptr<Uri> clone() const override {
        return std::unique_ptr<Uri>(new StringUri(*this));
    }

    public: std::unique_ptr<Uri> append(const std::string & pathComponent) const override {
        ThrowBalauException(Exception::UnsupportedOperationException, "StringUri does not support path appending.");
    }

    public: std::unique_ptr<Uri> resolve(std::string_view path) const override {
        static const std::regex scheme { "[a-zA-Z][a-zA-Z0-9+-\\.]*:" };

        auto cleanPath = Util::Strings::trim(path);
        auto str = std::string(cleanPath);

        if (Util::Strings::startsWithRegex(str, scheme)) {
            std::unique_ptr<Uri> uri;
            fromString(uri, str);
            return uri;
        }

        ThrowBalauException(
              Exception::IllegalArgumentException
            , "StringUri does not support calls to the resolve method without specifying a schema in the path."
        );
    }

    public: bool operator == (const Uri & rhs) const override {
        const auto * o = dynamic_cast<const StringUri *>(&rhs);
        return o != nullptr && data == o->data;
    }

    public: bool canReadFrom() const override {
        return true;
    }

    public: bool canWriteTo() const override {
        return false;
    }

    public: StringUriByteReadResource getByteReadResource() const {
        return StringUriByteReadResource(*this);
    }

    public: StringUriUtf8To32ReadResource getUtf8To32ReadResource() const {
        return StringUriUtf8To32ReadResource(*this);
    }

    public: std::unique_ptr<ByteReadResource> byteReadResource() const override {
        return std::unique_ptr<ByteReadResource>(new StringUriByteReadResource(*this));
    }

    public: std::unique_ptr<Utf8To32ReadResource> utf8To32ReadResource() const override {
        return std::unique_ptr<Utf8To32ReadResource>(new StringUriUtf8To32ReadResource(*this));
    }

    public: std::unique_ptr<ByteWriteResource> byteWriteResource() override {
        return std::unique_ptr<ByteWriteResource>(new StringUriByteWriteResource(*this));
    }

    public: std::unique_ptr<Utf32To8WriteResource> utf32To8WriteResource() override {
        return std::unique_ptr<Utf32To8WriteResource>(new StringUriUtf32To8WriteResource(*this));
    }

    public: bool isRecursivelyIterable() const override {
        return false;
    }

    public: bool isIterable() const override {
        return false;
    }

    public: std::unique_ptr<RecursiveUriIterator> recursiveIterator() const override {
        ThrowBalauException(Exception::NotImplementedException, "String URIs do not have recursive iterators.");
    }

    public: std::unique_ptr<UriIterator> iterator() const override {
        ThrowBalauException(Exception::NotImplementedException, "String URIs do not have iterators.");
    }

    public: void dispatch(UriDispatcher & dispatcher) const override {
        dispatcher.dispatch(*this);
    }

    private: std::string data;
};

} // namespace Balau::Resource

#endif // COM_BORA_SOFTWARE__BALAU_RESOURCE__STRING_URI