Utils.hpp

Go to the documentation of this file.

// Copyright (c) 2019 Chris Ohk, Youngjoong Kim, SeungHyun Jeon

// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.

#ifndef ROSETTASTONE_UTILS_HPP
#define ROSETTASTONE_UTILS_HPP

#include <cstddef>

template <typename T>
constexpr bool AllCondIsTrue(const T& t)
{
    return t == true;
}

template <typename T, typename... Others>
constexpr bool AllCondIsTrue(const T& t, Others const&... args)
{
    return (t == true) && AllCondIsTrue(args...);
}

template <typename T>
class SizedPtr
{
 public:
    using value_type = T;
    using size_type = std::size_t;

    using reference = T&;
    using const_reference = const T&;

    using pointer = T*;
    using const_pointer = const T*;

    using iterator = pointer;
    using const_iterator = const_pointer;

    SizedPtr() : m_size(0), m_ptr(nullptr)
    {
        // Do nothing
    }

    explicit SizedPtr(std::size_t size) : m_size(size), m_ptr(new T[m_size])
    {
        // Do nothing
    }

    SizedPtr(T* ptr, std::size_t size) : m_size(size), m_ptr(ptr)
    {
        // Do nothing
    }

    ~SizedPtr()
    {
        reset();
    }

    SizedPtr(const SizedPtr& ptr) : m_size(ptr.size()), m_ptr(new T[m_size])
    {
        for (size_t i = 0; i < m_size; ++i)
        {
            m_ptr[i] = ptr[i];
        }
    }

    SizedPtr(SizedPtr&& ptr) noexcept : m_size(ptr.size()), m_ptr(ptr.get())
    {
        ptr.m_ptr = nullptr;
        ptr.m_size = 0;
    }

    SizedPtr& operator=(const SizedPtr& ptr)
    {
        reset(new T[ptr.size()], ptr.size());
        for (std::size_t i = 0; i < m_size; ++i)
        {
            m_ptr[i] = ptr[i];
        }
        return *this;
    }

    SizedPtr& operator=(SizedPtr&& ptr) noexcept
    {
        reset(ptr.get(), ptr.size());

        ptr.m_ptr = nullptr;
        ptr.m_size = 0;

        return *this;
    }

    void reset() noexcept
    {
        if (m_ptr != nullptr)
        {
            delete[] m_ptr;
        }

        m_ptr = nullptr;
        m_size = 0;
    }

    void reset(T* other, std::size_t size) noexcept
    {
        if (m_ptr != nullptr)
        {
            delete[] m_ptr;
        }

        m_ptr = other;
        m_size = size;
    }

    operator bool()
    {
        return m_ptr != nullptr;
    }

    T* get()
    {
        return m_ptr;
    }

    const T* get() const
    {
        return m_ptr;
    }

    std::size_t size() const
    {
        return m_size;
    }

    T& operator*()
    {
        return *m_ptr;
    }

    const T& operator*() const
    {
        return *m_ptr;
    }

    T& operator[](std::size_t idx)
    {
        return m_ptr[idx];
    }

    const T& operator[](std::size_t idx) const
    {
        return m_ptr[idx];
    }

    bool operator==(const SizedPtr& other) const
    {
        if (m_size != other.size())
        {
            return false;
        }

        for (std::size_t i = 0; i < m_size; ++i)
        {
            if (m_ptr[i] != other[i])
            {
                return false;
            }
        }

        return true;
    }

    bool operator!=(const SizedPtr& other) const
    {
        return !operator==(other);
    }

    bool operator==(std::nullptr_t) const
    {
        return m_ptr == nullptr;
    }

    bool operator!=(std::nullptr_t) const
    {
        return m_ptr != nullptr;
    }

    iterator begin()
    {
        return m_ptr;
    }

    const_iterator begin() const
    {
        return m_ptr;
    }

    const_iterator cbegin() const
    {
        return m_ptr;
    }

    iterator end()
    {
        return m_ptr + m_size;
    }

    const_iterator end() const
    {
        return m_ptr + m_size;
    }

    const_iterator cend() const
    {
        return m_ptr + m_size;
    }

 private:
    std::size_t m_size;
    T* m_ptr;
};

#endif  // ROSETTASTONE_UTILS_HPP