src/native_client_sdk/src/libraries/nacl_io/fifo_char.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "nacl_io/fifo_char.h"
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include <algorithm>
  11
  12 namespace nacl_io {
  13
  14 FIFOChar::FIFOChar(size_t size)
  15     : buffer_(NULL),
  16       size_(size),
  17       avail_(0),
  18       tail_(0) {
  19   if (size)
  20     buffer_ = new char[size];
  21 }
  22
  23 FIFOChar::~FIFOChar() {
  24   delete[] buffer_;
  25 }
  26
  27 bool FIFOChar::IsEmpty() {
  28   return avail_ == 0;
  29 }
  30
  31 bool FIFOChar::IsFull() {
  32   return avail_ >= size_;
  33 }
  34
  35 bool FIFOChar::Resize(size_t len) {
  36   // Can not resize smaller than the current size
  37   if (len < avail_)
  38     return false;
  39
  40   // Read current data into new buffer
  41   char* data = new char[len];
  42   avail_ = Read(data, avail_);
  43
  44   // Replace buffer
  45   delete[] buffer_;
  46   buffer_ = data;
  47   size_ = len;
  48   return true;
  49 }
  50
  51 size_t FIFOChar::ReadAvailable() {
  52   return avail_;
  53 }
  54
  55 size_t FIFOChar::WriteAvailable() {
  56   return size_ - avail_;
  57 }
  58
  59 size_t FIFOChar::Peek(void* buf, size_t len) {
  60   char* ptr = static_cast<char*>(buf);
  61
  62   size_t out = 0;
  63   len = std::min(len, avail_);
  64
  65   size_t offs = tail_;
  66   while (len > 0) {
  67     size_t read_len = std::min(len, size_ - offs);
  68     memcpy(ptr, &buffer_[offs], read_len);
  69
  70     ptr += read_len;
  71     offs += read_len;
  72
  73     if (offs == size_)
  74       offs = 0;
  75
  76     out += read_len;
  77     len -= read_len;
  78   }
  79
  80   return out;
  81 }
  82
  83 size_t FIFOChar::Read(void* buf, size_t len) {
  84   size_t read_len = Peek(buf, len);
  85   if (read_len > 0) {
  86     avail_ -= read_len;
  87     tail_ = (tail_ + read_len) % size_;
  88   }
  89   return read_len;
  90 }
  91
  92 size_t FIFOChar::Write(const void* buf, size_t len) {
  93   const char* ptr = static_cast<const char*>(buf);
  94   size_t out = 0;
  95   size_t room = size_ - avail_;
  96   len = std::min(len, room);
  97
  98   size_t offs = (tail_ + avail_) % size_;
  99   while (len > 0) {
 100     size_t write_len = std::min(len, size_ - offs);
 101     memcpy(&buffer_[offs], ptr, write_len);
 102
 103     ptr += write_len;
 104     offs += write_len;
 105     if (offs == size_)
 106       offs = 0;
 107
 108     out += write_len;
 109     len -= write_len;
 110   }
 111
 112   avail_ += out;
 113   return out;
 114 }
 115
 116 }  // namespace nacl_io