include/vectordata.h

Go to the documentation of this file.

/********************************************************************************
 *  Neural Network Framework.                                                   *
 *  Copyright (C) 2005-2008 Gianluca Massera <emmegian@yahoo.it>                *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

// --- You can't include it directly
#ifndef TYPES_INCLUDES
#error "You can't include vectordata.h directly; Instead, You have to include types.h"
// --- follow define avoid to get a lot of understandable error !
#define VECTORDATA_H
#endif

#ifndef VECTORDATA_H
#define VECTORDATA_H

#include "memutils.h"
#include <vector>


namespace nnfw {

template<class T>
class NNFW_TEMPLATE VectorData : private Observer, public Observable {
public:
    typedef enum { datachanged = 1, datadestroying = 2 } t_notify;


    VectorData()
        : Observer(), Observable() {
        vsize = 0;
        allocated = 0;
        data = 0;
        view = false;
        observed = 0;
        idstart = 0;
        idend = 0;
    };

    VectorData( u_int size ) 
        : Observer(), Observable() {
        vsize = size;
        allocated = size;
        if ( vsize == 0 ) {
            data = 0;
        } else {
            data = new T[vsize];
            memoryZeroing( data, vsize );
        }
        // --- view attribute
        view = false;
        observed = 0;
        idstart = 0;
        idend = 0;
    };

    VectorData( u_int size, T& value )
        : Observer(), Observable() {
        vsize = size;
        allocated = size;
        (vsize==0) ? (data = 0) : (data = new T[vsize]);
        for(u_int i = 0; i<size; i++) {
            data[i] = value;
        }
        // --- view attribute
        view = false;
        observed = 0;
        idstart = 0;
        idend = 0;
    };
    
    VectorData( VectorData<T>& src, u_int idStart, u_int idEnd )
        : Observer(), Observable() {
        if ( idStart > src.vsize || idEnd > src.vsize || idStart >= idEnd ) {
            nError() << "Wrongs indexes specified in VectorData constructor; using 0 and src.size()" ;
            idstart = 0;
            idend = src.size();
        } else {
            idstart = idStart;
            idend = idEnd;
        }
        data = (src.data) + idstart;
        vsize = idend - idstart;
        allocated = 0;
        view = true;
        src.addObserver( this );
        observed = &src;
    };

    VectorData( const T* r, u_int dim )
        : Observer(), Observable() {
        data = new T[dim];
        vsize = dim;
        allocated = dim;
        memoryCopy( data, r, dim );
        // --- view attribute
        view = false;
        observed = 0;
        idstart = 0;
        idend = 0;
    };

    VectorData( const VectorData& src )
        : Observer(), Observable() {
        /* --- even if the source VectorData is a view,
           --- the copy-constructor create a new fresh copy of data */
        vsize = src.vsize;
        allocated = vsize;
        data = new T[allocated];
        memoryCopy( data, src.data, vsize );
        view = false;
        observed = 0;
    };

    VectorData& operator=( const VectorData& src ) {
        VectorData& self = *this;
        self.resize( src.size() );
        self.assign( src );
        return self;
    };

    ~VectorData() {
        notifyAll( NotifyEvent( datadestroying ) );
        if ( view ) {
            observed->delObserver( this );
        } else {
            delete []data;
        }
    };


    u_int size() const {
        return vsize;
    };

    bool isView() const {
        return view;
    };

    bool operator==( const VectorData<T>& b ) {
        if ( this->size() != b.size() ) return false;
        VectorData<T>& self = *this;
        for( u_int i=0; i<size(); i++ ) {
            if ( self[i] != b[i] ) {
                return false;
            }
        }
        return true;
    };

    bool operator!=( const VectorData<T>& b ) {
        return !( *this == b );
    };



    void zeroing() {
        memoryZeroing( data, vsize );
    };

    void setAll( const T& value ) {
        for( u_int i=0; i<vsize; i++ ) {
            data[i] = value;
        }
    };

    void erase( int id ) {
        if ( view ) {
            nError() << "you can't erase element from a VectorData view" ;
        } else {
            if ( id < 0 || id >= (int)vsize ) return;
            for( u_int i=(u_int)id; i<vsize-1; i++ ) {
                data[id] = data[id+1];
            }
            vsize = vsize-1;
            notifyAll( NotifyEvent( datachanged ) );
        }
    };

    VectorData<T>& assign( u_int num, const T& value ) {
#ifdef NNFW_DEBUG
        if ( num > vsize ) {
            nError() << "Wrong number of elements passed to assign method" ;
            num = vsize;
        }
#endif
        for( u_int i=0; i<num; i++ ) {
            data[i] = value;
        }
        return (*this);
    };

    VectorData<T>& assign( const VectorData<T>& src ) {
#ifdef NNFW_DEBUG
        if ( vsize != src.vsize ) {
            nError() << "Wrong number of elements between VectorData to assign method" ;
            return (*this);
        }
#endif
        memoryCopy( data, src.data, vsize );
        return (*this);
    };

    VectorData<T>& assign( const VectorData<T>& src, u_int sizec ) {
#ifdef NNFW_DEBUG
        if ( vsize < sizec || src.size() < sizec ) {
            nError() << "Wrong size specified in assign method" ;
            return (*this);
        }
#endif
        memoryCopy( data, src.data, sizec );
        return (*this);
    };

    VectorData<T>& assign_reverse( const VectorData<T>& src ) {
#ifdef NNFW_DEBUG
        if ( vsize != src.vsize ) {
            nError() << "Wrong number of elements between VectorData to assign method" ;
            return (*this);
        }
#endif
        for( u_int i=0, j=vsize-1; i<vsize; i++, j-- ) {
            data[i] = src.data[j];
        }
        return (*this);
    };

    VectorData<int>& compare( const VectorData<T>& b, VectorData<int>& comparison ) {
#ifdef NNFW_DEBUG
        if ( vsize != b.vsize ) {
            nError() << "Wrong number of elements between VectorData to compare method" ;
            return (*this);
        }
#endif
        VectorData<T>& self = *this;
        comparison.resize(size());
        for( u_int i=0; i<size(); i++ ) {
            if ( self[i] == b[i] ) {
                comparison[i] = true;
            }
            else {
                comparison[i] = false;
            }
        }
        return comparison;
    };

    T& operator[]( u_int index ) {
#ifdef NNFW_DEBUG
        if( index >= vsize ) {
            nError() << "Accessing elements outside boundary" ;
            return data[0];
        }
#endif
        return data[index];
    };

    const T& operator[]( u_int index ) const {
#ifdef NNFW_DEBUG
        if( index >= vsize ) {
            nError() << "Accessing elements outside boundary" ;
            return data[0];
        }
#endif
        return data[index];
    };

    T& at( u_int index ) {
#ifdef NNFW_DEBUG
        if( index >= vsize ) {
            nError() << "Accessing elements outside boundary" ;
            return data[0];
        }
#endif
        return data[index];
    };

    const T& at( u_int index ) const {
#ifdef NNFW_DEBUG
        if( index >= vsize ) {
            nError() << "Accessing elements outside boundary" ;
            return data[0];
        }
#endif
        return data[index];
    };

    void resize( u_int newsize ) {
        if ( view ) {
            nError() << "It's not possible resize RealVec views" ;
            return;
        }
        if ( allocated < newsize ) {
            if ( allocated == 0 ) {
                allocated = newsize+20;
                data = new T[allocated];
            } else {
                allocated = newsize+20;
                T* tmp = new T[allocated];
                memoryCopy( tmp, data, vsize );
                delete []data;
                data = tmp;
            }
        }
        if ( newsize > vsize ) {
            memoryZeroing( data+vsize, newsize-vsize );
        }
        vsize = newsize;
        // --- Notify the viewers
        notifyAll( NotifyEvent( datachanged ) );
    };

    void append( const T& value ) {
        resize( vsize+1 );
        data[vsize-1] = value;
    };

    VectorData<T>& operator<<( const T& value ) {
        append( value );
        return (*this);
    };


    void setView( u_int idStart, u_int idEnd ) {
        if ( !view ) {
            nError() << "setView can be called only if VectorData is a view" ;
            return;
        }
        if ( idStart > observed->vsize || idEnd > observed->vsize || idStart >= idEnd ) {
            nError() << "Wrongs indexes specified in VectorData setView; using 0 and observed->size()" ;
            idstart = 0;
            idend = observed->size();
        }
        idstart = idStart;
        idend = idEnd;
        data = (observed->data) + idstart;
        vsize = idend - idstart;
        // --- Propagate Notify to sub-viewers
        notifyAll( NotifyEvent( datachanged ) );
    };

    void convertToView( VectorData<T>& src, u_int idStart, u_int idEnd ) {
        if ( observed == (&src) ) {
            setView( idStart, idEnd );
            return;
        }
        if ( view ) {
            // detach previous view
            observed->delObserver( this );
        } else if ( allocated > 0 ) {
            // remove previous data allocated
            delete []data;
        }
    
        if ( idStart > src.vsize || idEnd > src.vsize || idStart >= idEnd ) {
            nError() << "Wrongs indexes specified in convertToView; using 0 and src.size()" ;
            idstart = 0;
            idend = src.size();
        } else {
            idstart = idStart;
            idend = idEnd;
        }
        data = (src.data) + idstart;
        vsize = idend - idstart;
        allocated = 0;
        view = true;
        observed = &src;
        observed->addObserver( this );
    };



    class vectordataIterator;
    friend class vectordataIterator;

    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef vectordataIterator iterator;
    typedef const vectordataIterator const_iterator;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    size_type max_size() {
        return 300000; // <- FIXME it must return the maximum space of memory allocable
    };

    bool empty() {
        return (vsize==0);
    };

    void push_back( const T& value ) {
        resize( vsize+1 );
        data[vsize-1] = value;
    };

    iterator begin() {
        return vectordataIterator( *this );
    };
    const_iterator begin() const {
        return vectordataIterator( ((VectorData&)*this) );
    };

    iterator end() {
        return vectordataIterator( *this, vsize );
    };
    const_iterator end() const {
        return vectordataIterator( ((VectorData&)*this), vsize );
    };

    iterator erase( iterator pos ) {
        if ( view ) {
            nError() << "you can't erase element from a VectorData view" ;
        } else {
            u_int id = pos.getIndex();
            for( u_int i=id; i<vsize-1; i++ ) {
                data[id] = data[id+1];
            }
            vsize = vsize-1;
            notifyAll( NotifyEvent( datachanged ) );
        }
        return (pos);
    };

    void clear() {
        if ( view ) {
            nError() << "you can't clear a VectorData view" ;
        } else {
            vsize = 0;
            notifyAll( NotifyEvent( datachanged ) );
        }
    };

    class vectordataIterator : public std::iterator<std::bidirectional_iterator_tag,T,ptrdiff_t> {
    public:
        vectordataIterator( VectorData& data, u_int startId = 0 ) : vecdata(data), id(startId) { /*nothing to do*/ };
        vectordataIterator( const vectordataIterator& src ) : vecdata(src.vecdata), id(src.id) { /* nothing to do */  };
        vectordataIterator& operator=( const vectordataIterator& src ) {
            vecdata = src.vecdata;
            id = src.id;
            return (*this);
        };
        bool operator==( const vectordataIterator& x ) const {
            return ( &vecdata == &(x.vecdata) && id == x.id );
        };
        bool operator!=( const vectordataIterator& x ) const {
            return ( &vecdata != &(x.vecdata) || id != x.id );
        };
        const T& operator*() const {
            return vecdata[id];
        };
        T& operator*() {
            return vecdata[id];
        };
        vectordataIterator& operator++() {
            id = (id < vecdata.size()) ? id+1 : vecdata.size();
            return (*this);
        };
        const vectordataIterator& operator++() const {
            id = (id < vecdata.size()) ? id+1 : vecdata.size();
            return (*this);
        };
        vectordataIterator& operator--() {
            id = ( id > 0 ) ? id-1 : 0;
            return (*this);
        };
        const vectordataIterator& operator--() const {
            id = ( id > 0 ) ? id-1 : 0;
            return (*this);
        };
        u_int getIndex() {
            return id;
        };
    private:
        VectorData& vecdata;
        u_int id;
    };

protected:

    T* rawdata() const {
        return data;
    };

    u_int vsize;
    u_int allocated;
    T* data;

    bool view;
    u_int idstart;
    u_int idend;
    VectorData* observed;

    virtual void notify( const NotifyEvent& event ) {
        switch( event.type() ) {
        case datachanged:
            if ( idstart > observed->vsize || idend > observed->vsize ) {
                nError() << "Indexes become invalid after data changing; using 0 and viewed->size()" ;
                idstart = 0;
                idend = observed->size();
            }
            data = (observed->data) + idstart;
            vsize = idend - idstart;
            allocated = 0;
            break;
        case datadestroying:
#ifdef NNFW_DEBUG
            nWarning() << "Destroying a VectorData before its views!!!" ;
#endif
            // --- reconvert to a regular VectorData with size zero
            view = false;
            data = 0;
            vsize = 0;
            allocated = 0;
            observed = 0;
            idstart = 0;
            idend = 0;
            break;
        default:
            break;
        }
        // --- Propagate Notify to sub-viewers
        notifyAll( NotifyEvent( datachanged ) );
    };

};

}

#endif

Copyright © 2005-2008 G. Massera

Contact: emmegian (at) yahoo (dot) it

  Documentation generated by