Buffer.h

Go to the documentation of this file.

/* Copyright 2006 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_SPREAD_DETAIL_BUFFER_H
#define __SSRC_SPREAD_DETAIL_BUFFER_H

#include <cstring>
#include <iterator>

#include <ssrc/libssrcspread-packages.h>

__BEGIN_NS_SSRC_SPREAD

namespace detail {

  template<typename type>
  class Buffer {

    unsigned int _capacity;
    unsigned int _size;
    type * _data;
    
  public:
    typedef type value_type;
    typedef value_type & reference;
    typedef const reference const_reference;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef pointer iterator;
    typedef const_pointer const_iterator;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    explicit Buffer(const unsigned int capacity) :
      _capacity(capacity), _size(0), _data(new value_type[capacity])
    { }

    ~Buffer() { delete[] _data; }

    unsigned int capacity() const {
      return _capacity;
    }

    reference operator[](const unsigned int index) {
      return _data[index];
    }

    const_reference operator[](const unsigned int index) const {
      return _data[index];
    }

    iterator begin() {
      return _data;
    }

    const_iterator begin() const {
      return _data;
    }

    iterator end() {
      return (_data + _size);
    }

    const_iterator end() const {
      return (_data + _size);
    }

    reverse_iterator rbegin() {
      return reverse_iterator(end());
    }

    const_reverse_iterator rbegin() const {
      return const_reverse_iterator(end());
    }

    reverse_iterator rend() {
      return reverse_iterator(begin());
    }

    const_reverse_iterator rend() const {
      return const_reverse_iterator(begin());
    }

    void reserve(const unsigned int capacity) {
      if(capacity > _capacity) {
        pointer new_data = new value_type[capacity];
        std::memcpy(new_data, _data, _size*sizeof(value_type));
        delete[] _data;
        _data = new_data;
        _capacity = capacity;
      }
    }

    void resize(const unsigned int size) {
      reserve(size);
      _size = size;
    }

    unsigned int size() const {
      return _size;
    }

    void clear() {
      resize(0);
    }

    void add(const type & value) {
      if(capacity() <= _size) {
        reserve(_size << 1);
      }
      _data[_size++] = value;
    }
  };
}

__END_NS_SSRC_SPREAD

#endif