disk_vector.h

Go to the documentation of this file.

#ifndef META_DISK_VECTOR_H_
#define META_DISK_VECTOR_H_

#include <type_traits>
#include <string>
#include <fcntl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include "meta.h"

namespace meta
{
namespace util
{

template <class T>
class disk_vector
{
    static_assert(std::is_integral<T>::value || std::is_floating_point<T>::value
                  || std::is_base_of<util::numeric, T>::value,
                  "disk_vector templated types must be integral types");

  public:
    disk_vector(const std::string& path, uint64_t size = 0);

    disk_vector(disk_vector&&);

    disk_vector& operator=(disk_vector&&);

    ~disk_vector();

    T& operator[](uint64_t idx);

    const T& operator[](uint64_t idx) const;

    T& at(uint64_t idx);

    const T& at(uint64_t idx) const;

    uint64_t size() const;

    class iterator : public std::iterator<std::random_access_iterator_tag, T>
    {
        friend disk_vector;

      private:
        uint64_t idx_;

        T* data_;

        iterator(uint64_t idx, T* data) : idx_{idx}, data_{data}
        {
            /* nothing */
        }

      public:
        iterator() : idx_{0}, data_{nullptr}
        {
            /* nothing */
        }

        iterator(const iterator& other) : idx_{other.idx_}, data_{other.data_}
        {
            /* nothing */
        }

        iterator& operator=(iterator other)
        {
            std::swap(*this, other);
            return *this;
        }

        iterator& operator++()
        {
            ++idx_;
            return *this;
        }

        iterator operator++(int)
        {
            iterator save{*this};
            ++idx_;
            return save;
        }

        iterator& operator--()
        {
            --idx_;
            return *this;
        }

        iterator operator--(int)
        {
            iterator save{*this};
            --idx_;
            return *this;
        }

        bool operator==(const iterator& other)
        {
            return other.idx_ == idx_ && other.data_ == data_;
        }

        bool operator!=(const iterator& other)
        {
            return !(*this == other);
        }

        T& operator*()
        {
            return data_[idx_];
        }

        const T* operator->()
        {
            return &data_[idx_];
        }

        bool operator<(const iterator& other) const
        {
            return idx_ < other.idx_;
        }

        bool operator>(const iterator& other) const
        {
            return idx_ > other.idx_;
        }

        bool operator<=(const iterator& other) const
        {
            return idx_ <= other.idx_;
        }

        bool operator>=(const iterator& other) const
        {
            return idx_ >= other.idx_;
        }
    };

    iterator begin() const;

    iterator end() const;

  private:
    std::string path_;

    T* start_;

    uint64_t size_;

    int file_desc_;

  public:
    class disk_vector_exception : public std::runtime_error
    {
      public:
        using std::runtime_error::runtime_error;
    };
};
}
}

#include "disk_vector.tcc"
#endif