source: GTP/trunk/Lib/Vis/Preprocessing/src/mixkit/MxBlock.h @ 1097

#ifndef MXBLOCK_INCLUDED // -*- C++ -*-
#define MXBLOCK_INCLUDED
#if !defined(__GNUC__)
#  pragma once
#endif

/************************************************************************

  MxBlock provides typed access a contiguous block of elements.

  Copyright (C) 1998 Michael Garland.  See "COPYING.txt" for details.
  
  $Id: MxBlock.h,v 1.1 2002/09/24 16:53:54 wimmer Exp $

 ************************************************************************/
#include "stdmix.h"
template<class T>
class MxBlock : public MxEQ
{
private:
    uint N;
    T *block;

protected:
    MxBlock() { }
    void init_block(uint n)
        {
            // Allocate memory for block
            N=n; block = (T *)malloc(sizeof(T)*n);

            // Initialize each entry
            for(uint i=0; i<n; i++) new((void *)&block[i], MX_ALLOC_INPLACE) T;
        }
    void resize_block(uint n)
        {
            T *old = block;

            // Allocate new block
            block = (T *)realloc(old, sizeof(T)*n);

            // Initialize all the newly allocated entries
            for(uint i=N; i<n; i++) new((void *)&block[i], MX_ALLOC_INPLACE) T;

            N = n;
        }
    void free_block()
        {
#ifdef WIN32
            // The Microsoft compiler has a problem with the 
            // standard syntax below.  For some reason,
            // expanding it into the following pointer-based
            // version makes it work.  Don't ask me why.
            //
            for(uint i=0; i<N; i++)  { T *p = &block[i]; p->~T(); }
            free(block);
#else
            // Call the relevant destructors for each element before
            // freeing the block.  Has now effect for types like 'int'.
            //
            for(uint i=0; i<N; i++)  block[i].~T();
            free(block);
#endif
        }

    T&       raw(uint i)       { return block[i]; }
    const T& raw(uint i) const { return block[i]; }


public:
    MxBlock(uint n) { init_block(n); }
    ~MxBlock() { free_block(); }

    // Standard accessors
    //
    T&       ref(uint i)              { AssertBound(i<N);return block[i]; }
    const T& ref(uint i) const        { AssertBound(i<N);return block[i]; }
    T&       operator()(uint i)       { return ref(i);   }
    const T& operator()(uint i) const { return ref(i);   }
#ifdef __GNUC__
    // Most compilers can apply the casting operators and then use the
    // standard array [].  GCC (2.7.2) seems to need explicit operators.
    //
    T&       operator[](uint i)       { return block[i]; }
    const T& operator[](uint i) const { return block[i]; }
#endif

    operator const T*() const { return block; }
    operator       T*()       { return block; }
    uint length() const { return N; }

    // Primitive methods for altering the data block
    //
    void resize(uint n) { resize_block(n); }
    void bitcopy(const T *array, uint n) // copy bits directly
        { memcpy(block, array, MIN(n,N)*sizeof(T)); }
    void copy(const T *array, const uint n) // copy using assignment operator
        { for(uint i=0; i<MIN(n,N); i++) block[i] = array[i]; }
    void bitcopy(const MxBlock<T>& b) { bitcopy(b, b.length()); }
    void copy(const MxBlock<T>& b) { copy(b, b.length()); }
};

// MXBLOCK_INCLUDED
#endif