podarray.h

Go to the documentation of this file.

 
#ifndef _RWSTD_PODARRAY_H_INCLUDED
#define _RWSTD_PODARRAY_H_INCLUDED
 
 
#if __GNUG__ >= 3
#  pragma GCC system_header
#endif   // gcc >= 3
 
 
#include <string.h>
#include <rw/_traits.h>
#include <rw/_defs.h>
 
 
_RWSTD_NAMESPACE (__rw) { 
 
 
// __rw_aligned_buffer specializations should be objects with static
// storage duration that must "survive" all other static objects and
// that do not need to be destroyed; this is a POD
template <class _TypeT>
struct __rw_aligned_buffer
{
    union {
#ifndef _RWSTD_NO_LONG_DOUBLE
        long double _C_pad;                     // guarantee suitable alignment
#else
        double      _C_pad;
#endif   // _RWSTD_NO_LONG_DOUBLE
        void       *_C_void_pad;
        void      (*_C_pfn_pad)();
        char        _C_data [sizeof (_TypeT)];  // data to back _TypeT up with 
    } _C_buf;
 
    void* _C_store () {
        return _C_buf._C_data;
    }
 
    _TypeT* _C_data () {
        return _RWSTD_REINTERPRET_CAST (_TypeT*, _C_buf._C_data);
    }
};
 
 
// typedef prevents an MSVC 6.0 ICE
typedef _RWSTD_SIZE_T _SizeT;
 
_EXPORT template <class _TypeT, _SizeT _Size>
class __rw_pod_array
{
    _SizeT  _C_len;
    _TypeT *_C_pbuf;
    _TypeT  _C_buffer [_Size];
 
public:
 
    __rw_pod_array (): _C_len (0), _C_pbuf (_C_buffer) {
        *_C_pbuf = _TypeT ();
    }
 
    explicit __rw_pod_array (const _TypeT *__a)
        : _C_len (_C_length (__a))
        // , _C_pbuf (_C_len < _Size ? _C_buffer : new _TypeT [_C_len + 1])
        {
            // initialze _C_pbuf here in order to prevent HP aCC 3.70
            // ICE: see http://issues.apache.org/jira/browse/STDCXX-276
            if (_C_len < _Size)
                _C_pbuf = _C_buffer;
            else
                _C_pbuf = new _TypeT [_C_len + 1];
            memcpy (_C_pbuf, __a, (_C_len + 1) * sizeof *__a);
        }
 
    __rw_pod_array (const _TypeT *__a, _SizeT __len)
        : _C_len (__len) {
        // initialze _C_pbuf here in order to prevent HP aCC 3.70
        // ICE: see http://issues.apache.org/jira/browse/STDCXX-276
        if (__len < _Size)
            _C_pbuf = _C_buffer;
        else
            _C_pbuf = new _TypeT [__len + 1];
        memcpy (_C_pbuf, __a, __len * sizeof *__a);
        _C_pbuf [_C_len] = _TypeT ();
    }
 
    __rw_pod_array (const __rw_pod_array &__rhs)
        : _C_len (__rhs._C_len) {
        // initialze _C_pbuf here in order to prevent HP aCC 3.70
        // ICE: see http://issues.apache.org/jira/browse/STDCXX-276
        if (_C_len < _Size)
            _C_pbuf = _C_buffer;
        else
            _C_pbuf = new _TypeT [_C_len + 1];
        memcpy (_C_pbuf, __rhs._C_pbuf,
                (_C_len + !!__rhs._C_pbuf) * sizeof *_C_pbuf);
    }
 
    ~__rw_pod_array () {
        if (_C_pbuf != _C_buffer)
            delete[] _C_pbuf;
    }
 
    _TypeT* data () {
        return _C_pbuf;
    }
 
    const _TypeT* data () const {
        return _C_pbuf;
    }
 
    _TypeT* acquire (_TypeT *__a, _SizeT __len) {
        _TypeT *__pbuf = _C_pbuf;
        _C_pbuf = __a;
        _C_len  = __len;
        return __pbuf;
    }
 
    _TypeT* acquire (_TypeT *__a) {
        return acquire (__a, _C_length (__a));
    }
 
    _TypeT* release () {
        _TypeT* const __pbuf = _C_pbuf;
        _C_pbuf = _C_buffer;
        return __pbuf;
    }
 
    static _SizeT max_size () {
        return _Size;
    }
 
    _SizeT size () const {
        return _C_len;
    }
 
    __rw_pod_array& append (const _TypeT*, _SizeT);
 
    __rw_pod_array& append (const _TypeT *__a) {
        _RWSTD_ASSERT (__a);
        return append (__a, _C_length (__a));
    }
 
    __rw_pod_array& operator+= (const _TypeT *__a) {
        _RWSTD_ASSERT (__a);
        return append (__a);
    }
 
 
    __rw_pod_array& assign (const _TypeT *__a, _SizeT __len) {
        return (_C_len = 0), append (__a, __len);
    }
 
    __rw_pod_array& assign (const _TypeT *__a) {
        _RWSTD_ASSERT (__a);
        return assign (__a, _C_length (__a));
    }
 
    __rw_pod_array& operator= (const _TypeT *__a) {
        _RWSTD_ASSERT (__a);
        return assign (__a);
    }
 
    __rw_pod_array& operator= (const __rw_pod_array &__rhs) {
        return assign (__rhs._C_pbuf, __rhs._C_len);
    }
 
private:
 
    static _RWSTD_SIZE_T _C_length (const _TypeT *__a) {
#ifndef _RWSTD_NO_EXT_CHAR_TRAITS_PRIMARY
        return _STD::char_traits<_TypeT>::length (__a);
#else    // #ifdef _RWSTD_NO_EXT_CHAR_TRAITS_PRIMARY
        _RWSTD_SIZE_T __len = 0;
        for (; _TypeT () != *__a; ++__a, ++__len) ;
        return __len;
#endif   // _RWSTD_NO_EXT_CHAR_TRAITS_PRIMARY
    }
};
 
 
typedef __rw_pod_array<char, 256> __rw_chararray;
 
 
}   // namespace __rw
 
 
#if _RWSTD_DEFINE_TEMPLATE_FIRST (_POD_ARRAY)
#  include "podarray.cc"
#endif   // _RWSTD_DEFINE_TEMPLATE_FIRST (_POD_ARRAY)
 
 
_RWSTD_NAMESPACE (__rw) { 
 
#if _RWSTD_INSTANTIATE (_POD_ARRAY, _CHAR)
 
// used throughout locale
_RWSTD_INSTANTIATE_2 (class __rw_pod_array<char, 256>);
 
#endif   // _RWSTD_INSTANTIATE (_POD_ARRAY, _CHAR)
 
#if _RWSTD_INSTANTIATE (_POD_ARRAY, _UINT)
 
// used in collate.cpp
_RWSTD_INSTANTIATE_2 (class __rw_pod_array<const unsigned int*, 1024>);
 
#endif   // _RWSTD_INSTANTIATE (_POD_ARRAY, _UINT)
 
}   // namespace __rw
 
 
#if _RWSTD_DEFINE_TEMPLATE_LAST (_POD_ARRAY)
#  include "podarray.cc"
#endif   // _RWSTD_DEFINE_TEMPLATE_LAST (_POD_ARRAY)
 
 
#endif   // _RWSTD_PODARRAY_H_INCLUDED