leveldb::anonymous_namespace{memenv.cc}::FileState Class Reference

Public Member Functions
	FileState ()
void	Ref ()
void	Unref ()
uint64_t	Size () const
Status	Read (uint64_t offset, size_t n, Slice *result, char *scratch) const
Status	Append (const Slice &data)

Private Types
enum	{ kBlockSize = 8 * 1024 }

Private Member Functions
	~FileState ()
	FileState (const FileState &)
void	operator= (const FileState &)

Private Attributes
port::Mutex	refs_mutex_
int	refs_
std::vector< char * >	blocks_
uint64_t	size_

Detailed Description

Definition at line 20 of file memenv.cc.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
kBlockSize

Definition at line 146 of file memenv.cc.

{ kBlockSize = 8 * 1024 };

Constructor & Destructor Documentation

FileState() [1/2]

leveldb::anonymous_namespace{memenv.cc}::FileState::FileState ( )

inline

Definition at line 24 of file memenv.cc.

: refs_(0), size_(0) {}

~FileState()

leveldb::anonymous_namespace{memenv.cc}::FileState::~FileState ( )

inlineprivate

Definition at line 126 of file memenv.cc.

               {
    for (std::vector<char*>::iterator i = blocks_.begin(); i != blocks_.end();
         ++i) {
      delete [] *i;
    }
  }

FileState() [2/2]

leveldb::anonymous_namespace{memenv.cc}::FileState::FileState ( const FileState &  )

private

Member Function Documentation

Append()

Status leveldb::anonymous_namespace{memenv.cc}::FileState::Append ( const Slice &  data )

inline

Definition at line 95 of file memenv.cc.

                                   {
    const char* src = data.data();
    size_t src_len = data.size();

    while (src_len > 0) {
      size_t avail;
      size_t offset = size_ % kBlockSize;

      if (offset != 0) {
        // There is some room in the last block.
        avail = kBlockSize - offset;
      } else {
        // No room in the last block; push new one.
        blocks_.push_back(new char[kBlockSize]);
        avail = kBlockSize;
      }

      if (avail > src_len) {
        avail = src_len;
      }
      memcpy(blocks_.back() + offset, src, avail);
      src_len -= avail;
      src += avail;
      size_ += avail;
    }

    return Status::OK();
  }

Here is the call graph for this function:

operator=()

void leveldb::anonymous_namespace{memenv.cc}::FileState::operator= ( const FileState &  )

private

Read()

Status leveldb::anonymous_namespace{memenv.cc}::FileState::Read ( uint64_t  offset, size_t  n, Slice *  result, char *  scratch  ) const

inline

Definition at line 52 of file memenv.cc.

                                                                             {
    if (offset > size_) {
      return Status::IOError("Offset greater than file size.");
    }
    const uint64_t available = size_ - offset;
    if (n > available) {
      n = static_cast<size_t>(available);
    }
    if (n == 0) {
      *result = Slice();
      return Status::OK();
    }

    assert(offset / kBlockSize <= SIZE_MAX);
    size_t block = static_cast<size_t>(offset / kBlockSize);
    size_t block_offset = offset % kBlockSize;

    if (n <= kBlockSize - block_offset) {
      // The requested bytes are all in the first block.
      *result = Slice(blocks_[block] + block_offset, n);
      return Status::OK();
    }

    size_t bytes_to_copy = n;
    char* dst = scratch;

    while (bytes_to_copy > 0) {
      size_t avail = kBlockSize - block_offset;
      if (avail > bytes_to_copy) {
        avail = bytes_to_copy;
      }
      memcpy(dst, blocks_[block] + block_offset, avail);

      bytes_to_copy -= avail;
      dst += avail;
      block++;
      block_offset = 0;
    }

    *result = Slice(scratch, n);
    return Status::OK();
  }

Here is the call graph for this function:

Ref()

void leveldb::anonymous_namespace{memenv.cc}::FileState::Ref ( )

inline

Definition at line 27 of file memenv.cc.

             {
    MutexLock lock(&refs_mutex_);
    ++refs_;
  }

Here is the caller graph for this function:

Size()

uint64_t leveldb::anonymous_namespace{memenv.cc}::FileState::Size ( ) const

inline

Definition at line 50 of file memenv.cc.

{ return size_; }

Unref()

void leveldb::anonymous_namespace{memenv.cc}::FileState::Unref ( )

inline

Definition at line 33 of file memenv.cc.

               {
    bool do_delete = false;

    {
      MutexLock lock(&refs_mutex_);
      --refs_;
      assert(refs_ >= 0);
      if (refs_ <= 0) {
        do_delete = true;
      }
    }

    if (do_delete) {
      delete this;
    }
  }

Member Data Documentation

blocks_

std::vector<char*> leveldb::anonymous_namespace{memenv.cc}::FileState::blocks_

private

Definition at line 143 of file memenv.cc.

refs_

int leveldb::anonymous_namespace{memenv.cc}::FileState::refs_

private

Definition at line 138 of file memenv.cc.

refs_mutex_

port::Mutex leveldb::anonymous_namespace{memenv.cc}::FileState::refs_mutex_

private

Definition at line 137 of file memenv.cc.

size_

uint64_t leveldb::anonymous_namespace{memenv.cc}::FileState::size_

private

Definition at line 144 of file memenv.cc.

---

The documentation for this class was generated from the following file:

• helpers/memenv/memenv.cc