source: source/ariba/utility/vtypes/varray.hpp@ 9964

// varray.hpp, created on 04.11.2008 by Sebastian Mies
//
// [The FreeBSD Licence]
// Copyright (c) 2008
// Sebastian Mies, Institute of Telematics, UniversitÀt Karlsruhe
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the distribution.
// * Neither the name of the author nor the names of its contributors may be
//   used to endorse or promote products derived from this software without
//   specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#ifndef VARRAY_HPP_
#define VARRAY_HPP_

#include "detail/helper.hpp"

#include <memory.h>

#include <boost/mpl/if.hpp>
#include <boost/mpl/placeholders.hpp>

/**
 * This class implements a variable or static sized bit container.
 * The difference to other array classes is that this class morphs between
 * static and dynamic object allocation.
 *
 * @author Sebastian Mies
 */
template<class item_type, size_t _size = 0, typename size_type = size_t>
class varray {
private:
        typedef varray<item_type, _size, size_type> _varray;

        /* dynamic array */
        class dynamic_array {
        private:
                /* array structure */
                typedef struct __array {
                        size_type size;
                        item_type arr[];
                } __array;
                __array *arr;

                /* returns the underlaying array size from a given length */
                finline size_t array_size(size_t new_size) const {
                        return (new_size / (sizeof(item_type) * 8)) + (((new_size
                                        % (sizeof(item_type) * 8)) == 0) ? 0 : 1);
                }

        public:
                finline dynamic_array() {
                        arr = 0;
                }

                finline ~dynamic_array() {
                        if (arr != 0) free(arr);
                }

                /* return size in bits */
                finline size_type size() const {
                        return (arr == 0) ? 0 : arr->size;
                }

                /* returns the underlaying array size */
                finline size_t array_size() const {
                        return array_size(size());
                }

                /* set size in bits */
                finline void resize(size_type new_size) {
                        size_t old_arr_size = array_size();
                        size_t new_arr_size = array_size(new_size);
                        if (old_arr_size != new_arr_size) {
                                size_t nbsize = sizeof(__array ) + new_arr_size
                                                * sizeof(item_type);
                                size_t obsize = sizeof(__array ) + old_arr_size
                                                * sizeof(item_type);
                                __array *new_array = (__array *) malloc(nbsize);
                                if (arr != 0) {
                                        size_t csize = std::min(nbsize, obsize);
                                        memcpy(new_array, arr, csize);
                                        if (nbsize > obsize) memset(
                                                        ((uint8_t*) new_array) + obsize, 0, nbsize
                                                                        - obsize);
                                        free(arr);
                                }
                                arr = new_array;
                        }
                        arr->size = new_size;
                }

                /* return the array */
                finline item_type* array() const {
                        return (item_type*) &arr->arr;
                }

                finline int get_memory_consumption() const {
                        return array_size() * sizeof(item_type) + sizeof(__array) +
                                sizeof(void*);
                }
        };

        /* static array */
        class static_array {
        private:
                static const size_t _array_size = (_size / (sizeof(item_type) * 8))
                + (((_size % (sizeof(item_type) * 8)) == 0) ? 0 : 1);
                                                item_type arr[_array_size];

        public:
                /* returns the number of bits in this array */
                finline size_type size() const {
                        return _size;
                }

                /* returns the underlaying array size */
                finline size_t array_size() const {
                        return _array_size;
                }

                /* resizes the array */
                finline void resize(size_type new_size) {
                }

                /* return the array */
                finline item_type* array() const {
                        return (item_type*) &arr;
                }

                finline int get_memory_consumption() const {
                        return _array_size * sizeof(item_type);
                }
        };

        /* selection of static or dynamic array */
        typename boost::mpl::if_<boost::mpl::bool_<_size == 0>,
        dynamic_array, static_array>::type _array;

public:
        finline bool is_static() const {
                return (_size != 0);
        }

        finline bool is_dynamic() const {
                return !is_static();
        }

        finline size_type size() const {
                return _array.size();
        }

        finline size_t array_size() const {
                return _array.array_size();
        }

        finline void resize(size_type newSize) {
                _array.resize(newSize);
        }

        finline item_type* array() {
                return _array.array();
        }

        finline const item_type* array_const() const {
                return _array.array();
        }

        finline operator item_type*() {
                return _array();
        }

        finline int get_memory_consumption() const {
                return _array.get_memory_consumption();
        }

        finline item_type& operator[] ( size_type index ) {
                return array()[index];
        }
};

#endif /* VARRAY_HPP_ */