root/lang/c/mpio/trunk/mp/byte_array.pre.h @ 18301

//
// mp::byte_array
//
// Copyright (C) 2008 FURUHASHI Sadayuki
//
//    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.apache.org/licenses/LICENSE-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 MP_BYTE_ARRAY_H__
#define MP_BYTE_ARRAY_H__

#include <stddef.h>
#include <memory>

#ifndef MP_BYTE_ARRAY_DEFAULT_INITIAL_ALLOCATION_SIZE
#define MP_BYTE_ARRAY_DEFAULT_INITIAL_ALLOCATION_SIZE 4096
#endif

namespace mp {

static const size_t BYTE_ARRAY_DEFAULT_INITIAL_ALLOCATION_SIZE = MP_BYTE_ARRAY_DEFAULT_INITIAL_ALLOCATION_SIZE;

template <typename Allocator = std::allocator<char> >
class byte_array {
public:
        typedef char value_type;
        typedef size_t size_type;
        typedef char* iterator;
        typedef const char* const_iterator;
        typedef char& reference;
        typedef const char& const_reference;
        typedef ptrdiff_t difference_type;
        typedef Allocator allocator_type;

public:
        byte_array(size_type initial_size=BYTE_ARRAY_DEFAULT_INITIAL_ALLOCATION_SIZE);
        ~byte_array();

        iterator begin();
        const_iterator begin() const;

        iterator end();
        const_iterator end() const;

        bool empty() const;
        size_type size() const;
        size_type capacity() const;
        size_type space() const;

        void produced(size_type produced_size);
        void consumed(size_type consumed_size);
        void clear();

        void reserve(size_type new_size);
        void reserve_space(size_type required_size);

        void swap(byte_array& other);

public:
        void read(void* buffer, size_type size);

        void write(const void* buffer, size_type size);

MP_ARGS_BEGIN
        template <MP_ARGS_TEMPLATE>
        void read(MP_ARGS_PARAMS_PTR);
MP_ARGS_END

MP_ARGS_BEGIN
        template <MP_ARGS_TEMPLATE>
        void write(MP_ARGS_PARAMS);
MP_ARGS_END

private:
        char* storage;
        char* start;
        char* finish;
        char* allocated_end;

private:
        size_type allocated_size() const;
        allocator_type get_allocator() const;

private:
        byte_array(const byte_array<Allocator>&);
};


}  // namespace mp

#include "mp/byte_array_impl.h"

#endif /* mp/byte_array.h */