ByteBuffer.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_BYTE_BUFFER_H
#define __SSRC_SPREAD_DETAIL_BYTE_BUFFER_H

#include <ssrc/spread/detail/Buffer.h>

__BEGIN_NS_SSRC_SPREAD

namespace detail {

  class ByteBuffer : public detail::Buffer<char> {
    typedef detail::Buffer<char> super;

    unsigned int _offset;

  public:

    explicit ByteBuffer(const unsigned int capacity) : super(0), _offset(0) {
      super::reserve(capacity);
    }

    ByteBuffer(const ByteBuffer & buffer) : super(0), _offset(0) {
      super::reserve(buffer.capacity());
      write(&buffer[0], buffer.size());
      seek(buffer.offset());
    }

    ByteBuffer & operator=(const ByteBuffer & buffer) {
      if(&buffer != this) {
        clear();
        write(&buffer[0], buffer.size());
        seek(buffer.offset());
      }
      return *this;
    }

    unsigned int offset() const {
      return _offset;
    }

    unsigned int seek(const unsigned int offset) {
      if(offset <= size())
        _offset = offset;
      return _offset;
    }

    void rewind() {
      seek(0);
    }

    void clear() {
      rewind();
      resize(0);
    }

    void write(const void *data, const unsigned int size) {
      unsigned int total = _offset + size;

      if(total > ByteBuffer::size())
        resize(total);

      std::memcpy(&(this->operator[](_offset)), data, size);

      _offset = total;
    }

    unsigned int read(void *data, unsigned int size) {
      if(_offset >= ByteBuffer::size())
        return 0;

      unsigned int total = _offset + size;

      if(total > ByteBuffer::size()) {
        total = ByteBuffer::size();
        size = total - _offset;
      }

      std::memcpy(data, &(this->operator[](_offset)), size);

      _offset = total;

      return size;
    }

  };

}

__END_NS_SSRC_SPREAD

#endif