span.hpp

Go to the documentation of this file.

/*
 * Copyright 2017, alex at staticlibs.net
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* 
 * File:   span.hpp
 * Author: alex
 *
 * Created on February 5, 2017, 4:41 PM
 */

#ifndef STATICLIB_SUPPORT_SPAN_HPP
#define STATICLIB_SUPPORT_SPAN_HPP

#include <cstdint>
#include <array>
#include <ios>
#include <string>
#include <vector>

#include "staticlib/config.hpp"
#include "staticlib/support.hpp"

namespace staticlib {
namespace io {

class bad_span_access_exception : public sl::support::exception {
public:

    bad_span_access_exception() = default;

    bad_span_access_exception(const std::string& msg) :
    sl::support::exception(msg) { }

};


template<typename T>
class span {
    T* first_ptr = nullptr;
    T* last_ptr = nullptr;

public:

    template<typename IntType>
    span(T* buffer, IntType length) :
    first_ptr(buffer),
    last_ptr(buffer) {
        if (nullptr != buffer) {
            // note: zero-length span is allowed
            if (/* length > 0 && */ sl::support::is_sizet(length) && sl::support::is_streamsize(length)) {
                last_ptr += static_cast<size_t> (length);
            } else {
                throw bad_span_access_exception(std::string() + "Invalid 'length' span parameter specified," +
                        " length: [" + sl::support::to_string(length) + "]");
            }
        } else if (0 != length) {
            throw bad_span_access_exception(std::string() + "Invalid 'null' data pointer specified to span," +
                    " length: [" + sl::support::to_string(length) + "]");
        }
    }

    template<typename Convertible, size_t Length>
    span(std::array<Convertible, Length>& buffer) :
    span(buffer.size() > 0 ? buffer.data() : nullptr, buffer.size()) { }

    span(std::vector<T>& buffer) :
    span(buffer.size() > 0 ? buffer.data() : nullptr, buffer.size()) { }

    template<typename Convertible>
    span(std::vector<Convertible>& buffer) :
    span(buffer.size() > 0 ? buffer.data() : nullptr, buffer.size()) { }

    span(std::string& buffer) :
    span(buffer.length() > 0 ? std::addressof(buffer.front()) : nullptr, buffer.length()) { }

    span(const std::string& buffer) :
    span(buffer.length() > 0 ? buffer.data() : nullptr, buffer.length()) { }

    template<size_t Size>
    span(const char (&buffer)[Size]) :
    span(Size > 1 ? static_cast<const char*>(buffer) : nullptr, Size - 1) { }

    span(const span<T>& other) :
    first_ptr(other.first_ptr),
    last_ptr(other.last_ptr) { }

    span<T>& operator=(const span<T>& other) {
        first_ptr = other.first_ptr;
        last_ptr = other.last_ptr;
        return *this;
    }

    T& operator[](size_t index) const {
        if (index < size()) {
            return *(first_ptr + index);
        } else {
            throw bad_span_access_exception(std::string() + "Invalid index access attempt," +
                    " span size: [" + sl::support::to_string(size()) + "],"
                    " index: [" + sl::support::to_string(index) + "]");
        }
    }

    T* data() const STATICLIB_NOEXCEPT {
        return first_ptr;
    }

    bool empty() const STATICLIB_NOEXCEPT {
        return 0 == size();
    }

    bool is_empty() const STATICLIB_NOEXCEPT {
        return empty();
    }

    bool is_null() const STATICLIB_NOEXCEPT {
        return nullptr == first_ptr;
    }

    size_t size() const STATICLIB_NOEXCEPT {
        return nullptr == first_ptr ? 0 : last_ptr - first_ptr;
    }

    std::streamsize size_signed() const STATICLIB_NOEXCEPT {
        return static_cast<std::streamsize>(size());
    }

    int size_int() const STATICLIB_NOEXCEPT {
        return static_cast<int>(size());
    }

    size_t size_bytes() const STATICLIB_NOEXCEPT {
        return (size()) * sizeof(T);
    }

    T* begin() const STATICLIB_NOEXCEPT {
        return first_ptr;
    }

    T* end() const STATICLIB_NOEXCEPT {
        return last_ptr;
    }

};

template<typename T, typename IntType>
span<T> make_span(T* buffer, IntType length) {
    return span<T>(buffer, length);
}

template<typename T, size_t Length>
span<T> make_span(std::array<T, Length>& buffer) {
    return span<T>(buffer.data(), buffer.size());
}

template<typename T>
span<T> make_span(std::vector<T>& buffer) {
    return span<T>(buffer.data(), buffer.size());
}

} // namespace
}

#endif /* STATICLIB_SUPPORT_SPAN_HPP */