fd_table.h

Go to the documentation of this file.

#ifndef CVMFS_FD_TABLE_H_
#define CVMFS_FD_TABLE_H_

#include <errno.h>
#include <inttypes.h>
#include <stdint.h>

#include <cassert>
#include <vector>

#include "util/single_copy.h"

template<class HandleT>
class FdTable : SingleCopy {
 public:
  FdTable(unsigned max_open_fds, const HandleT &invalid_handle)
      : invalid_handle_(invalid_handle)
      , fd_pivot_(0)
      , fd_index_(max_open_fds)
      , open_fds_(max_open_fds, FdWrapper(invalid_handle_, 0)) {
    assert(max_open_fds > 0);
    for (unsigned i = 0; i < max_open_fds; ++i) {
      fd_index_[i] = i;
      open_fds_[i].index = i;
    }
  }

  void AssignFrom(const FdTable<HandleT> &other) {
    invalid_handle_ = other.invalid_handle_;
    fd_pivot_ = other.fd_pivot_;
    fd_index_.resize(other.fd_index_.size());
    open_fds_.resize(other.open_fds_.size(), FdWrapper(invalid_handle_, 0));
    for (unsigned i = 0; i < fd_index_.size(); ++i) {
      fd_index_[i] = other.fd_index_[i];
      open_fds_[i] = other.open_fds_[i];
    }
  }

  FdTable<HandleT> *Clone() {
    FdTable<HandleT> *result = new FdTable<HandleT>(open_fds_.size(),
                                                    invalid_handle_);
    result->fd_pivot_ = fd_pivot_;
    for (unsigned i = 0; i < fd_index_.size(); ++i) {
      result->fd_index_[i] = fd_index_[i];
      result->open_fds_[i] = open_fds_[i];
    }
    return result;
  }


  int OpenFd(const HandleT &handle) {
    if (handle == invalid_handle_)
      return -EINVAL;
    if (fd_pivot_ >= fd_index_.size())
      return -ENFILE;

    size_t next_fd = fd_index_[fd_pivot_];
    assert(next_fd < open_fds_.size());
    assert(open_fds_[next_fd].handle == invalid_handle_);
    open_fds_[next_fd] = FdWrapper(handle, fd_pivot_);
    ++fd_pivot_;
    return next_fd;
  }

  HandleT GetHandle(int fd) {
    return IsValid(fd) ? open_fds_[fd].handle : invalid_handle_;
  }


  int CloseFd(int fd) {
    if (!IsValid(fd))
      return -EBADF;

    unsigned index = open_fds_[fd].index;
    assert(index < fd_index_.size());
    assert(fd_pivot_ <= fd_index_.size());
    assert(fd_pivot_ > 0);
    open_fds_[fd].handle = invalid_handle_;
    --fd_pivot_;
    if (index < fd_pivot_) {
      unsigned other = fd_index_[fd_pivot_];
      assert(other < open_fds_.size());
      assert(open_fds_[other].handle != invalid_handle_);
      open_fds_[other].index = index;
      fd_index_[index] = other;
      fd_index_[fd_pivot_] = fd;
    }
    return 0;
  }

  unsigned GetMaxFds() const { return fd_index_.size(); }

 private:
  struct FdWrapper {
    FdWrapper(HandleT h, unsigned i) : handle(h), index(i) { }

    HandleT handle;
    unsigned index;
  };


  inline bool IsValid(int fd) {
    if ((fd < 0) || (static_cast<unsigned>(fd) >= open_fds_.size()))
      return false;
    return open_fds_[fd].handle != invalid_handle_;
  }

  HandleT invalid_handle_;
  unsigned fd_pivot_;
  std::vector<unsigned> fd_index_;
  std::vector<FdWrapper> open_fds_;
};  // class FdTable

#endif  // CVMFS_FD_TABLE_H_