include/propertized.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  *
 ********************************************************************************/

#ifndef PROPERTIZED_H
#define PROPERTIZED_H

#include "types.h"
#include "clonable.h"
#include <map>
#include <string>

namespace nnfw {

class OutputFunction;
class Propertized;
class AbstractPropertyAccess;

typedef VectorData<AbstractPropertyAccess*> PropertyAccessVec;

class NNFW_API Variant {
public:
    typedef enum { t_null=0, t_real, t_int, t_uint, t_char, t_uchar, t_bool, t_string,
                t_realvec, t_realmat, t_outfunction, t_cluster, t_linker, t_propertized,
                t_dataptr } types;

    Variant();
    Variant( const Variant& src );
    Variant( Real d );
    Variant( int d );
    Variant( u_int d );
    Variant( char d );
    Variant( unsigned char d );
    Variant( bool d );
    Variant( const char* d );
    Variant( char* d );
    Variant( RealVec* d );
    Variant( RealMat* d );
    Variant( OutputFunction* d );
    Variant( Cluster* d );
    Variant( Linker* d );
    Variant( Propertized* d );
    template<typename T>
    Variant( T* d ) {
        dtype = t_dataptr;
        ddataptr = d;
    };

    Variant& operator=( const Variant& src );

    types type() const;
    const char* typeName() const;
    bool isNull();

    Real getReal() const;
    int getInt() const;
    u_int getUInt() const;
    char getChar() const;
    unsigned char getUChar() const;
    bool getBool() const;
    const char* getString() const;
    RealVec* getRealVec() const;
    RealMat* getRealMat() const;
    OutputFunction* getOutputFunction() const;
    Cluster* getCluster() const;
    Linker* getLinker() const;
    Propertized* getPropertized() const;
    template<typename T>
    T* getDataPtr() const {
        checkType( t_dataptr );
        T* r = static_cast<T*>( ddataptr );
        if ( r == 0 ) {
            nError() << "Called getDataPtr with wrong type; returning NULL pointer ";
        }
        return r;
    };

    static const char* typeName( types t );

private:
    types dtype;
    static const char* typen[ t_dataptr+1 ];
    Real    dreal;
    int     dint;
    u_int   duint;
    char    dchar;
    unsigned char   duchar;
    bool            dbool;
    char*           dstring;
    RealVec*         drealvec;
    RealMat*         drealmat;
    OutputFunction*  doutfun;
    Cluster*         dcluster;
    Linker*          dlinker;
    Propertized*     dprop;
    void*            ddataptr;

    void checkType( types t ) const;
};

class NNFW_API AbstractPropertyAccess : public Clonable {
public:
    AbstractPropertyAccess( const char* name ) {
        u_int size = strlen(name);
        this->namep = new char[size+1];
        strcpy( this->namep, name );
    };
    virtual ~AbstractPropertyAccess() {
        delete []namep;
    };

    virtual bool set( const Variant& data ) = 0;
    virtual Variant get() const = 0;

    virtual bool set( u_int i, const Variant& data ) = 0;
    virtual Variant get( u_int i ) const = 0;

    const char* name() const {
        return namep;
    };
    bool isWritable() const {
        return writable;
    };
    bool isVector() const {
        return vectorv;
    };
    Variant::types type() const {
        return typep;
    };
    virtual Propertized* object() = 0;
    virtual AbstractPropertyAccess* clone() const = 0;

protected:
    char* namep;
    Variant::types typep;
    bool writable;
    bool vectorv;
};

template<class T>
class NNFW_TEMPLATE PropertyAccess : public AbstractPropertyAccess {
public:
    PropertyAccess( const char* name, Variant::types t, T* o, Variant (T::*g)(), bool (T::*s)( const Variant& ) = 0 )
        : AbstractPropertyAccess( name ) {
        typep = t;
        obj = o;
        vectorv = false;
        if ( s == 0 ) {
            writable = false;
            setPtm = 0;
        } else {
            writable = true;
            setPtm = s;
        }
        getPtm = g;
    };

    virtual Variant get() const {
        return (obj->*getPtm)();
    };
    virtual bool set( const Variant& data ) {
        return (obj->*setPtm)( data );
    };
    virtual bool set( u_int, const Variant& ) {
        return false;
    };
    virtual Variant get( u_int ) const {
        return Variant();
    };

    virtual Propertized* object() {
        return obj;
    };
    virtual PropertyAccess* clone() const {
        return new PropertyAccess( name(), type(), obj, getPtm, setPtm );
    };
private:
    T* obj;
    bool (T::*setPtm)( const Variant& );
    Variant (T::*getPtm)();
};

template<class T>
class NNFW_TEMPLATE VectorPropertyAccess : public AbstractPropertyAccess {
public:
    VectorPropertyAccess( const char* name, Variant::types t, T* o, Variant (T::*g)(u_int), bool (T::*s)(u_int, const Variant&) = 0 )
        : AbstractPropertyAccess( name ) {
        typep = t;
        obj = o;
        vectorv = true;
        if ( s == 0 ) {
            writable = false;
            setPtm = 0;
        } else {
            writable = true;
            setPtm = s;
        }
        getPtm = g;
    };

    virtual bool set( const Variant& ) {
        return false;
    };
    virtual Variant get() const {
        return Variant();
    };
    virtual Variant get( u_int i ) const {
        return (obj->*getPtm)(i);
    };
    virtual bool set( u_int i, const Variant& data ) {
        return (obj->*setPtm)( i, data );
    };
    virtual Propertized* object() {
        return obj;
    };
    virtual VectorPropertyAccess* clone() const {
        return new VectorPropertyAccess( name(), type(), obj, getPtm, setPtm );
    };
private:
    T* obj;
    bool (T::*setPtm)( u_int i, const Variant& );
    Variant (T::*getPtm)( u_int i );
};

class NNFW_API PropertyData {
public:
    PropertyData( const Variant& v ) {
        data = v; isVector = false; index = -1;
    };
    PropertyData( const Variant& v, int id ) {
        data = v; isVector = true; index = id;
    };
    Variant data;
    bool isVector;
    int index;
};
typedef std::map< std::string, Variant > PropertySettings;

class NNFW_API Propertized : public Clonable {
public:
    Propertized();
    ~Propertized();



    template<class T>
    void addProperty( const char* name, Variant::types t, T* obj, Variant (T::*read)(), bool (T::*write)( const Variant& ) = 0 ) {
        PropertyAccess<T>* access = new PropertyAccess<T>( name, t, obj, read, write );
        props[name] = access;
        vecProps.append( access );
    };

    template<class T>
    void addVectorProperty( const char* name, Variant::types t, T* obj, Variant (T::*read)(u_int i), bool (T::*write)(u_int i, const Variant&) = 0 ) {
        VectorPropertyAccess<T>* access = new VectorPropertyAccess<T>( name, t, obj, read, write );
        props[name] = access;
        vecProps.append( access );
    };

    Variant property( const char* name ) {
        return props[name]->get();
    };

    bool setProperty( const char* name, const Variant& data ) {
        if ( props.count( name ) == 0 ) return false;
        AbstractPropertyAccess& p = *(props[name]);
        return ( p.isWritable() ? p.set(data) : false );
    };

    bool setVectorProperty( const char* name, u_int i, const Variant& data ) {
        if ( props.count( name ) == 0 ) return false;
        AbstractPropertyAccess& p = *(props[name]);
        return ( p.isWritable() ? p.set(i, data) : false );
    };

    void setProperties( PropertySettings& prop );

    PropertyAccessVec& properties() const {
        return (PropertyAccessVec&)vecProps;
    };

    void propertySettings( PropertySettings& prop ) const {
        for( int i=0; i<(int)vecProps.size(); i++ ) {
            if ( vecProps[i]->isVector() ) {
                nWarning() << "propertySettings doesn't handle Vector-Property yet";
                continue;
            }
            prop[ vecProps[i]->name() ] = vecProps[i]->get();
        }
    };

    AbstractPropertyAccess* propertySearch( const char* name ) const {
        if ( props.count( name ) > 0 ) {
            return ((std::map< std::string, AbstractPropertyAccess* >) props)[name];
        }
        return 0;
    };

    Variant getTypename() const {
        return Variant( vtypename );
    };

    Variant getTypename() {
        return Variant( vtypename );
    };

    Variant convertStringTo( const Variant& str, Variant::types t );

    virtual Propertized* clone() const;


protected:
    void setTypename( const char* type );

private:
    std::map< std::string, AbstractPropertyAccess* > props;
    PropertyAccessVec vecProps;
    char* vtypename;
};

}

#endif

Copyright © 2005-2008 G. Massera

Contact: emmegian (at) yahoo (dot) it

  Documentation generated by