DataFields.h

Go to the documentation of this file.

/**
 * @file    DataFields.h
 * @brief   
 *
 ****************************************************************************
 * @version 0.8.534 $Id: DataFields.h 3775 2011-01-01 16:38:17Z alex $
 * @author  Alessandro Polo
 ****************************************************************************/
/* Copyright (c) 2007-2011, WOSH - Wide Open Smart Home 
 * by Alessandro Polo - OpenSmartHome.com
 * 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 OpenSmartHome.com WOSH 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 Alessandro Polo ''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 Alessandro Polo 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 __WOSH_Core_DataFields_H__
 #define __WOSH_Core_DataFields_H__

 #include <woshDefs.h>
 #include <core/Permission.h>
 #include <core/Comparison.h>
 #include <core/Mutex.h>
 #include <core/DataWrappers.h>
 #include <vector>
 #include <algorithm>


namespace wosh {

class IDataFieldCollection;
class IObjectReader;
class IObjectWriter;

class ISerializable;
class SecurityToken;

///----------------------------------------------------------------------------------------------------------------------
/**
 * @class   wosh::IDataFieldHolder
 * @brief   interface to expose fields definition and their wrappers, support field-listing
 *
 * Most implementations refer to \def WOSH_DF_STATIC_MEYER
 * Convenient definitions provided by wosh::IDataFieldReadable and wosh::IDataFieldWritable
 * interfaces are based on this \c MACRO.
 *
 * @see     wosh::IDataFieldCollection
 ****************************************************************************/
 
 #define WOSH_DF_STATIC_MEYER(CLASSNAME, STATIC_NAME)                                                                       \
        public: static void initializeDataFields( wosh::DataFieldCollection<CLASSNAME>* fields);                            \
        public: static void retrieveDataFields( wosh::DataFieldCollection<CLASSNAME>** fields) {                            \
                    if ( fields == NULL ) return;                                                                           \
                    *fields = &getDataFieldsStatic_##STATIC_NAME();                                                         \
                 }                                                                                                          \
        public: static wosh::DataFieldCollection<CLASSNAME>& getDataFieldsStatic_##STATIC_NAME() {                          \
                    static wosh::DataFieldCollection<CLASSNAME> my_fields_##STATIC_NAME;                                    \
                    if ( !my_fields_##STATIC_NAME.isInitialized() ) initializeDataFields(&my_fields_##STATIC_NAME);         \
                    return my_fields_##STATIC_NAME;                                                                         \
                 }                                                                                                          \
        public: virtual inline const wosh::IDataFieldCollection* getDataFields() const { return &getDataFieldsStatic_##STATIC_NAME(); }


class IDataFieldHolder
 {
/** @name IDataFieldHolder Interface
 * @{
 ******************************************************************************/
    public:
        ///@brief  implementation should create a meyer singleton static proxy, so IDataFieldCollection object
        ///        is created once (static, meyer)
        ///@note   IDataFieldCollection has no references to current object and cannot be edited once created
        virtual const wosh::IDataFieldCollection* getDataFields() const = 0;
//@}
    public:
        virtual ~IDataFieldHolder() { }
}; // class def
///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------

///----------------------------------------------------------------------------------------------------------------------
/**
 * @class   wosh::IDataFieldReadable
 * @brief   interface to expose fields-reading support
 *
 * A generic client (such as a DataExtractor ) may read fields through the provided
 * wosh::IObjectReader interface. IObjectReader is created dynamically be the implementation
 * and associated with current object and its fields-collector.
 *
 * Implemented by the object itself, may provide a custom IObjectReader implementation.
 * Most implementations refer to \def WOSH_DF_READERT,
 * these MACRO definitions are based on WOSH_DF_STATIC_MEYER definition (it must be present).
 *
 * Example:
 * \code
public myObject : public IDataFieldReadable {
    WOSH_DF_STATIC_MEYER(myObject)
    WOSH_DF_READERT(myObject, getPermission)
 }
\endcode
 *
 * @see     wosh::IObjectReader
 * @see     wosh::IDataFieldHolder
 * @see     wosh::IDataFieldWritable
 ****************************************************************************/

 #define WOSH_DF_READERT(CLASSNAME, STATIC_NAME)                                                        \
        public: virtual inline wosh::IObjectReader* createObjectReader() const {                        \
                    return new wosh::ObjectReaderT<CLASSNAME>(this, &getDataFieldsStatic_##STATIC_NAME());  \
                 }

class IDataFieldReadable
 {
/** @name IDataFieldReadable Interface
 * @{
 ******************************************************************************/
    public:
        ///@brief a (custom) IObjectReader implementation is created on each call and bound to current object
        ///       reference is const, as this call against the object (inherited class)
        ///@see   \ref WOSH_DF_READERT
        virtual wosh::IObjectReader* createObjectReader() const = 0;
//@}
    public:
        virtual ~IDataFieldReadable() { }

}; // class def
///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------

///----------------------------------------------------------------------------------------------------------------------
/**
 * @class   wosh::IDataFieldWritable
 * @brief   interface to expose fields-writing support
 *
 * A generic client (such as a DataExtractor ) may write/update fields through the provided
 * wosh::IObjectWriter interface. IObjectWriter is created dynamically be the implementation
 * and associated with current object and its fields-collector.
 *
 * Implemented by the object itself, may provide a custom IObjectWriter implementation.
 * Most implementations refer to \def WOSH_DF_WRITERT,
 * these MACRO definitions are based on WOSH_DF_STATIC_MEYER definition (it must be present).
 *
 * Example:
 * \code
public myObject : public IDataFieldWritable {
    WOSH_DF_STATIC_MEYER(myObject)
    WOSH_DF_WRITERT(myObject, getPermission)
 }
\endcode
 *
 * @see     wosh::IObjectWriter
 * @see     wosh::IDataFieldHolder
 * @see     wosh::IDataFieldReadable
 ****************************************************************************/

 #define WOSH_DF_WRITERT(CLASSNAME, STATIC_NAME)                                                        \
        public: virtual inline wosh::IObjectWriter* createObjectWriter() {                                  \
                    return new wosh::ObjectWriterT<CLASSNAME>(this, &getDataFieldsStatic_##STATIC_NAME());  \
                 }

class IDataFieldWritable
 {
/** @name IDataFieldWritable Interface
 * @{
 ******************************************************************************/
    public:
        ///@brief a (custom) IObjectWriter implementation is created on each call and bound to current object
        ///@note  NOT const: since the object may be edited by writer
        ///@see   \ref WOSH_DF_WRITERT
        ///@warning IObjectWriter instance must be destroyed by the caller
        virtual wosh::IObjectWriter* createObjectWriter() = 0;
//@}
    public:
        virtual ~IDataFieldWritable() { }

}; // class def
///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------

 #define WOSH_DF_MEYER_RW(CLASSNAME, STATIC_NAME)       \
    WOSH_DF_STATIC_MEYER(CLASSNAME, STATIC_NAME)        \
    WOSH_DF_READERT(CLASSNAME, STATIC_NAME)             \
    WOSH_DF_WRITERT(CLASSNAME, STATIC_NAME)


class IDataFieldRW :    public virtual wosh::IDataFieldHolder,
                        public virtual wosh::IDataFieldReadable,
                        public virtual wosh::IDataFieldWritable
{
    public:
        virtual ~IDataFieldRW() { }

}; // class def

///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------
/**
 * @class   wosh::IObjectReader
 * @brief   data-field reading interface,  allow an external object to read object's fields
 *          in a standardized protocol based on wosh::ISerializable class.
 *
 * Implementations are able to read generic object's fields and convert them to a standard
 * interface (as wosh::ISerializable).
 * \c Fields are defined (in a IDataFieldCollection) and mapped to Read(/Write) wrappers
 * (function pointers) through a set of (template) adapters working as proxy.
 *
 * In short, once configured, the architecture is able to map:
 * \code
public myObject  {
    // [..]
        const std::string& getStringValue() const;
    // [..]
 }
\endcode
 * to
 * \code
void external_function( IDataFieldReadable* object ) {
    IObjectReader* tmpReader = object->createObjectReader();
    ISerializable* field_value = tmp_reader->read("MyStringField");
    if ( field_value->isKindOf<Variant>() )
        printf("Value= %s", field_value->as<Variant>()->toString().c_str() );
    delete field_value;
    delete tmpReader;
 }
\endcode
 * 
 * Configuration stands for 'field definition', the code required to enable previous example is:
 * \code
void myObject::initializeDataFields( DataFieldCollection<myObject>* fields ) {
    if ( fields == NULL ) return;
    DataFieldDefinitionT<myObject>* df_str = fields->add("MyStringField");
    df_str->setWrapperRead<const std::string&, Variant>(&myObject::getStringValue);
 }
\endcode
 *
 * This proxy-skeleton based architecture comes for two reasons:
 *  - Read/Write field-wrappers (class/instance which binds real object-function) requires
 *    information about the object's \c class (in other words must be a template or a custom implementation).
 *    That's why read-wrapper skeleton (IDataFieldWrapperRead) is a template <class OBJECT_TYPE>.
 *  - It allows object to provide or select their own custom implementation.
 *
 * Because of that, similar to IDataCollector case), the implementation of IObjectReader are \c compilation-dependent
 * to the object (we are accessing to), so the \c reader must be created by the object (class) itself (that's why common defines
 * MACROS are provided).
 * 
 * In order to expose a standard interface (not dependent on the object type/instance), the \c reader
 * must keep a must keep a (const) reference to the object (which owns real fields)
 * and a const reference to its IDataFieldCollection (casted-implementation/instance), collection
 * is required in order to recognize and access to the fields (though wrappers).
 *
 * In fact, since the \c reader implementation know the OBJECT_TYPE, it can (be initialized and) access
 * to the OBJECT_TYPE-related implementation (template) of fields-definition (DataFieldDefinitionT<OBJECT_TYPE>)
 * and so its wrappers. Again, as said, IDataFieldDefinition cannot store neither access to wrappers since they are
 * class dependent.
 *
 * \par Security
 *  wosh::IObjectReader implementation may enable \c security-checks when a valid security-session context (wosh::SecurityToken by caller)
 *  and a wosh::Permission reference for the object (by the wosh::IDataFieldReadable implementation) are provided.
 *
 * Refer to default imlementation wosh::ObjectReaderT.
 *
 * @see     wosh::IDataFieldReadable
 * @see     wosh::IDataFieldWrapperRead
 * @see     wosh::IDataFieldCollection
 * @see     wosh::IObjectWriter
 ****************************************************************************/
class IObjectReader
 {
    public:
        IObjectReader() { }
        virtual ~IObjectReader() { }

    public:
        virtual WRESULT setObject( const IReflection* ptr ) = 0;
    public:
        ///@brief read field and return a ISerializable representation, NULL on failure
        virtual ISerializable* read( const char* field_name ) const = 0;
    public:
        ///@brief allocate an empty object, able (used as default proxy) to store passed filed, NULL on failure
        virtual ISerializable* alloc( const char* field_name ) const = 0;
        ///@brief set the security token of the current operation, it may be validated against field/object permissions
        virtual void setSecurityToken( const SecurityToken* token ) = 0;

virtual void setMutex( MutexRW* access_mutex ) = 0;

    public:
        ///@brief Evaluate if Reader supports security check (SecurityToken vs. Permission)
        virtual bool isSecure() const = 0;

virtual bool isReentrant() const = 0;

        ///@brief Evaluate if Reader is properly configured and able to read fields
        virtual bool isReadable() const = 0;
        ///@brief Retrieve the pointer of current data-field collection, down-casted to base interface,
        ///       so its useful only for field(name-index) mapping, listing (but not for execution!)
        virtual const IDataFieldCollection* getFieldCollection() const = 0;
}; // class def
///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------

///----------------------------------------------------------------------------------------------------------------------
/**
 * @class   wosh::IObjectWriter
 * @brief   data-field writing interface,  allow an external object to write(update) object's fields
 *          in a standardized protocol based on wosh::ISerializable class.
 *
 * Implementations are able to write generic object's fields and convert them to a standard
 * interface (as wosh::ISerializable).
 * \c Fields are defined (in a IDataFieldCollection) and mapped to Write(/Read) wrappers
 * (function pointers) through a set of (template) adapters working as proxy.
 *
 * In short, once configured, the architecture is able to map:
 * \code
public myObject  {
    // [..]
        void setStringValue( const std::string& value );
    // [..]
 }
\endcode
 * to
 * \code
void external_function( IDataFieldWritable* object ) {
    Variant field_updated_value("my new string value");
    IObjectWriter* tmp_writer = object->createObjectWriter();
    tmp_writer->write("MyStringField", &field_updated_value );
    delete tmp_writer;
 }
\endcode
 * 
 * Configuration stands for 'field definition', the code required to enable previous example is:
 * \code
void myObject::initializeDataFields( DataFieldCollection<myObject>* fields ) {
    if ( fields == NULL ) return;
    DataFieldDefinitionT<myObject>* df_str = fields->add("MyStringField");
    df_str->setWrapperWrite<const std::string&, Variant, std::string>(&myObject::setStringValue, &Variant::toString );
 }
\endcode
 * 
 * In order to expose a standard interface (not dependent on the object type/instance), the \c writer
 * must keep a must keep a (non-const) reference to the object (which owns real fields)
 * and a const reference to its IDataFieldCollection (casted-implementation/instance), collection
 * is required in order to recognize and access to the fields (though wrappers).
 *
 * \par Security
 *  wosh::IObjectWriter implementation may enable \c security-checks when a valid security-session context (wosh::SecurityToken by caller)
 *  and a wosh::Permission reference for the object (by the wosh::IDataFieldWritable implementation) are provided.
 *
 * @see     wosh::IDataFieldWritable
 * @see     wosh::IDataFieldWrapperWriter
 * @see     wosh::IDataFieldCollection
 * @see     wosh::IObjectReader
 ****************************************************************************/
class IObjectWriter
 {
    public:
        IObjectWriter() { }
        virtual ~IObjectWriter() { }

    public:
        virtual WRESULT setObject( IReflection* ptr ) = 0;
    public:
        ///@brief write field converting(interpreting) ISerializable representation to real field-type
        virtual WRESULT write( const char* field_name, const ISerializable* data ) = 0;
    public:
        ///@brief allocate an empty object, able (used as default proxy) to store passed filed, NULL on failure
        virtual ISerializable* alloc( const char* field_name ) const = 0;
        ///@brief set the security token of the current operation, it may be validated against field/object permissions
        virtual void setSecurityToken( const SecurityToken* token ) = 0;

virtual void setMutex( MutexRW* access_mutex ) = 0;

    public:
        ///@brief Evaluate if Writer supports security check (SecurityToken vs. Permission)
        virtual bool isSecure() const = 0;

virtual bool isReentrant() const = 0;

        ///@brief Evaluate if Writer is properly configured and able to read fields
        virtual bool isWritable() const = 0;
        ///@brief Retrieve the pointer of current data-field collection, down-casted to base interface,
        ///       so its useful only for field(name-index) mapping, listing (but not for execution!)
        virtual const IDataFieldCollection* getFieldCollection() const = 0;
}; // class def
///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------


///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------
//
#define DataFieldDefinition_MinPriority     -254

class DataFieldDefinition
 {
    public:
        DataFieldDefinition( const char* _field_name = NULL, int index = -1 );
        DataFieldDefinition( const char* _field_name, int index, int uid, short priority );
        DataFieldDefinition( const DataFieldDefinition& m );
        virtual ~DataFieldDefinition();

    public:
        void setHeader( ISerializable* new_header );

    public:
        DataFieldDefinition& operator=(const DataFieldDefinition& m);
        bool operator==(const DataFieldDefinition &other) const;
        bool operator>(const DataFieldDefinition& other) const {
            return ( this->index>other.index );
         }
        bool operator<(const DataFieldDefinition& other) const {
            return ( this->index<other.index );
         }

    public:
        // after these calls fields will be ordered by INDEX
        static int filterFields( std::vector<DataFieldDefinition>& fields, short min_priority, int max_count = -1 );
        static int fixFieldsIndex( std::vector<DataFieldDefinition>& fields );

    public:
        int uid;
        std::string field_name;
        ISerializable* header;
        int index;
        short priority;
        short sort_mode;

}; // class def
bool DataFieldDefinition_compareIndex( const DataFieldDefinition* obj1, const DataFieldDefinition* obj2 );
bool DataFieldDefinition_comparePriority( const DataFieldDefinition& obj1, const DataFieldDefinition& obj2 );

///----------------------------------------------------------------------------------------------------------------------
//
template <class OBJECT_TYPE>
class DataFieldDefinitionT : public DataFieldDefinition {
    public:
        typedef IDataFieldWrapperRead<OBJECT_TYPE> tDataFieldWrapperRead;
        typedef IDataFieldWrapperWrite<OBJECT_TYPE> tDataFieldWrapperWrite;
        
    public:
        DataFieldDefinitionT( const char* _field_name = NULL )
            : DataFieldDefinition(_field_name), dw_reader(NULL), dw_writer(NULL), dw_allocator(NULL) {}
        virtual ~DataFieldDefinitionT() {
            if ( this->dw_reader != NULL ) delete this->dw_reader; this->dw_reader = NULL;
            if ( this->dw_writer != NULL ) delete this->dw_writer; this->dw_writer = NULL;
            if ( this->dw_allocator != NULL ) delete this->dw_allocator; this->dw_allocator = NULL;
         }

    public:
        template <class ALLOCATOR_TYPE>
        void setWrapperAlloc() {
            if ( this->dw_allocator != NULL ) delete this->dw_allocator; this->dw_allocator = NULL;
            this->dw_allocator = new DataFieldWrapperAllocT<ALLOCATOR_TYPE>();
         }

    public:
        inline void setWrapperRead( tDataFieldWrapperRead* reader )     { this->dw_reader = reader; }

        template <typename RETURN_TYPE, class ALLOCATOR_TYPE>
        void setWrapperRead( typename IDataFieldWrapperReadT<OBJECT_TYPE, RETURN_TYPE, ALLOCATOR_TYPE>::FieldReader fptr ) {
            if ( this->dw_reader != NULL ) delete this->dw_reader; this->dw_reader = NULL;
            IDataFieldWrapperReadT<OBJECT_TYPE, RETURN_TYPE, ALLOCATOR_TYPE>* dfw;
            dfw = new IDataFieldWrapperReadT<OBJECT_TYPE, RETURN_TYPE, ALLOCATOR_TYPE>(fptr);
            this->dw_reader = dfw;
            if ( this->dw_allocator == NULL )
                this->dw_allocator = new DataFieldWrapperAllocT<ALLOCATOR_TYPE>();
         }

    public:
        inline void setWrapperRead( tDataFieldWrapperWrite* writer )    { this->dw_writer = writer; }

        template <typename ARGUMENT_TYPE, class PROXY_TYPE>
        void setWrapperWrite( typename IDataFieldWrapperWriteT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE>::FieldWriter fptr ) {
            if ( this->dw_writer != NULL ) delete this->dw_writer; this->dw_writer = NULL;
            IDataFieldWrapperWriteT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE>* dfw;
            dfw = new IDataFieldWrapperWriteT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE>(fptr);
            this->dw_writer = dfw;
            if ( this->dw_allocator == NULL )
                this->dw_allocator = new DataFieldWrapperAllocT<PROXY_TYPE>();
         }

        template <typename ARGUMENT_TYPE, class PROXY_TYPE, class PROXY_RETURN_TYPE>
        void setWrapperWrite( typename IDataFieldWrapperWriteProxyT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE>::FieldWriter fptr,
                                typename IDataFieldWrapperWriteProxyT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE>::ArgumentWrapper fptr_arg ) {
            if ( this->dw_writer != NULL ) delete this->dw_writer; this->dw_writer = NULL;
            IDataFieldWrapperWriteProxyT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE>* dfw;
            dfw = new IDataFieldWrapperWriteProxyT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE>(fptr,fptr_arg);
            this->dw_writer = dfw;
            if ( this->dw_allocator == NULL )
                this->dw_allocator = new DataFieldWrapperAllocT<PROXY_TYPE>();
         }

        template <typename ARGUMENT_TYPE, class PROXY_TYPE, class PROXY_RETURN_TYPE, class PROXY_ARGUMENT_TYPE>
        void setWrapperWrite( typename IDataFieldWrapperWriteWithArgT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE, PROXY_ARGUMENT_TYPE>::FieldWriter fptr,
                                typename IDataFieldWrapperWriteWithArgT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE, PROXY_ARGUMENT_TYPE>::ArgumentWrapper fptr_arg,
                                const PROXY_ARGUMENT_TYPE& arg_value ) {
            if ( this->dw_writer != NULL ) delete this->dw_writer; this->dw_writer = NULL;
            IDataFieldWrapperWriteWithArgT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE, PROXY_ARGUMENT_TYPE>* dfw;
            dfw = new IDataFieldWrapperWriteWithArgT<OBJECT_TYPE, ARGUMENT_TYPE, PROXY_TYPE, PROXY_RETURN_TYPE, PROXY_ARGUMENT_TYPE>(fptr,fptr_arg, arg_value);
            this->dw_writer = dfw;
         }

    public:
        inline bool hasWrapperRead() const                  { return (this->dw_reader != NULL); }
        inline bool hasWrapperWrite() const                 { return (this->dw_writer != NULL); }
        inline bool hasWrapperAlloc() const                 { return (this->dw_allocator != NULL); }

        inline const tDataFieldWrapperRead* reader() const  { return this->dw_reader; }
        inline const tDataFieldWrapperWrite* writer() const { return this->dw_writer; }
        inline tDataFieldWrapperRead* reader()              { return this->dw_reader; }
        inline tDataFieldWrapperWrite* writer()             { return this->dw_writer; }
        inline IDataFieldWrapperAlloc* allocator() const    { return this->dw_allocator; }

    protected:
        mutable tDataFieldWrapperRead* dw_reader;
        mutable tDataFieldWrapperWrite* dw_writer;
        mutable IDataFieldWrapperAlloc* dw_allocator;

}; // class def


///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------
//
class IDataFieldCollection
 {
    public:
        IDataFieldCollection() : initialized(false) { }
        virtual ~IDataFieldCollection() { }
    public:
        virtual const DataFieldDefinition* getField( int index ) const = 0;
        virtual DataFieldDefinition* getField( int index ) = 0;
        virtual const DataFieldDefinition* getField( const char* field_name ) const = 0;
        virtual DataFieldDefinition* getField( const char* field_name ) = 0;

        virtual int getFields( std::vector<DataFieldDefinition>& fields_out ) const = 0;

        virtual WRESULT finalize() = 0;

    public:
        virtual bool isInitialized() const          { return this->initialized; }
//      virtual void setInitialized( bool value )   { this->initialized = value; }
    protected:
        bool initialized;

}; // class def
///----------------------------------------------------------------------------------------------------------------------
//
template <class OBJECT_TYPE>
class DataFieldCollection : public virtual IDataFieldCollection
 {
    public:
        typedef DataFieldDefinitionT<OBJECT_TYPE> tDataFieldDefinition;
    public:
        DataFieldCollection() : IDataFieldCollection() { }
        virtual ~DataFieldCollection() {
            clear();
         }

    public:
        int add( tDataFieldDefinition* dfw ) {
            if ( dfw == NULL ) return -1;
            dfw->uid = this->fields.size();
            this->fields.push_back(dfw);
            return this->fields.size();
         }
        tDataFieldDefinition* add( const char* field_name, short priority = 0, short force_index = -1 ) {
            tDataFieldDefinition* dfw = new tDataFieldDefinition(field_name);
            dfw->priority = priority;
            if ( force_index != -1 ) dfw->index = force_index;
            add(dfw);
            return dfw;
         }

    public:
        void clear() {
            typename std::vector<tDataFieldDefinition*>::iterator it;
            for( it=this->fields.begin(); it!=this->fields.end(); ++it ) {
                if ( *it == NULL ) continue;
                delete *it;
             }
            this->fields.clear();
         }

        inline const std::vector<tDataFieldDefinition*>& getFields() const  { return this->fields; }
        inline std::vector<tDataFieldDefinition*>& getFields()              { return this->fields; }

        virtual int getFields( std::vector<DataFieldDefinition>& fields_out ) const {
            typename std::vector<tDataFieldDefinition*>::const_iterator it;
            for( it=this->fields.begin(); it!=this->fields.end(); ++it ) {
                if ( *it == NULL ) continue;
                fields_out.push_back(DataFieldDefinition(*(*it)));
             }
            return fields_out.size();
         }

        virtual inline const tDataFieldDefinition* getField( int index ) const {
            if ( index < 0 || index > (int)this->fields.size() ) return NULL;
            return this->fields.at(index);
         }
        virtual inline tDataFieldDefinition* getField( int index ) {
            if ( index < 0 || index > (int)this->fields.size() ) return NULL;
            return this->fields.at(index);
         }

        virtual inline const tDataFieldDefinition* getField( const char* field_name ) const {
            if ( field_name == NULL ) return NULL;
            typename std::vector<tDataFieldDefinition*>::const_iterator it;
            for( it=this->fields.begin(); it!=this->fields.end(); ++it ) {
                if ( *it == NULL ) continue;
                if ( strcmp(field_name, (*it)->field_name.c_str()) == 0 ) return *it;
             }
            return NULL;
         }
        virtual inline tDataFieldDefinition* getField( const char* field_name ) {
            if ( field_name == NULL ) return NULL;
            typename std::vector<tDataFieldDefinition*>::const_iterator it;
            for( it=this->fields.begin(); it!=this->fields.end(); ++it ) {
                if ( *it == NULL ) continue;
                if ( strcmp(field_name, (*it)->field_name.c_str()) == 0 ) return *it;
             }
            return NULL;
         }

    public:
        virtual WRESULT finalize() {
            this->initialized = true;

            tDataFieldDefinition* cField = NULL;
            typename std::vector<tDataFieldDefinition*>::const_iterator it;
            for( int cIndex=0; cIndex<(int)this->fields.size(); ++cIndex ) {
                cField = NULL;
                for( it=this->fields.begin(); it!=this->fields.end(); ++it ) {
                    if ( *it == NULL ) continue;

                    if ( cField == NULL ) {
                        if ( (*it)->index == cIndex )
                            cField = *it;
                     }
                    else {
                        if ( (*it)->index == cIndex )
                            ++(*it)->index;
                     }
                 }
             }
            int offset = 0;
            std::sort(this->fields.begin(), this->fields.end(), DataFieldDefinition_compareIndex );
            for( it=this->fields.begin(); it!=this->fields.end(); ++it ) {
                if ( *it == NULL ) continue;
                if ( (*it)->index == -1 )
                    (*it)->index = this->fields.back()->index + ++offset;
             }
            std::sort(this->fields.begin(), this->fields.end(), DataFieldDefinition_compareIndex );
            int cIndex=0;
            for( it=this->fields.begin(); it!=this->fields.end(); ++it, ++cIndex ) {
                if ( *it == NULL ) continue;
                (*it)->index = cIndex;
             }

            return WRET_OK;
         }

    protected:
        std::vector<tDataFieldDefinition*> fields;

}; // class def




///----------------------------------------------------------------------------------------------------------------------
//
template <class OBJECT_TYPE>
class ObjectReaderT : public IObjectReader
 {
    public:
        typedef DataFieldCollection<OBJECT_TYPE> tDataFieldCollection;
    public:

    public:
        ObjectReaderT( const OBJECT_TYPE* obj = NULL, const tDataFieldCollection* fields_def = NULL, Permission* obj_permission = NULL )
            : IObjectReader(), object(obj), permission(obj_permission), fields(fields_def), access_token(NULL), access_mutex(NULL) { }
        virtual ~ObjectReaderT() {
            if ( this->permission != NULL ) delete this->permission;
         }

    public:
        virtual ISerializable* read( const char* field_name ) const {
            const typename tDataFieldCollection::tDataFieldDefinition* field_def;
            field_def = fields->getField(field_name);
            if ( field_def == NULL ) return NULL;
            if ( this->object == NULL ) return NULL;
            if ( !field_def->hasWrapperRead() ) return NULL;
            return field_def->reader()->read(this->object);
         }


    public:
        virtual WRESULT setObject( const IReflection* ptr ) {
            if ( ptr == NULL ) this->object = NULL;
            else {
                const OBJECT_TYPE* objTmp = dynamic_cast<const OBJECT_TYPE*>(ptr);
                if ( objTmp == NULL ) return WRET_ERR_PARAM;
                this->object = objTmp;
             }
            return WRET_OK;
         }

        virtual inline void setObjectT( const OBJECT_TYPE* ptr )                { this->object = ptr; }
        virtual inline void setSecurityToken( const SecurityToken* token )      { this->access_token = token; }
        virtual inline void setMutex( MutexRW* mutex )                          { this->access_mutex = mutex; }

        virtual ISerializable* alloc( const char* field_name ) const {
            const typename tDataFieldCollection::tDataFieldDefinition* field_def;
            field_def = fields->getField(field_name);
            if ( field_def == NULL ) return NULL;
            if ( !field_def->hasWrapperAlloc() ) return NULL;
            return field_def->allocator()->alloc();
         }
    public:
        virtual inline bool isSecure() const                                    { return ( this->permission != NULL ); }
        virtual inline bool isReentrant() const                                 { return ( this->access_mutex != NULL ); }
        virtual inline bool isReadable() const {
            if ( this->object == NULL || this->fields == NULL) return false;
            return true;
        }
        virtual inline const IDataFieldCollection* getFieldCollection() const   { return this->fields; }

    protected:
        const OBJECT_TYPE* object;
        Permission* permission;
        const tDataFieldCollection* fields;
        const SecurityToken* access_token;
        MutexRW* access_mutex;
}; // class def
///----------------------------------------------------------------------------------------------------------------------
//
template <class OBJECT_TYPE>
class ObjectWriterT : public IObjectWriter
 {
    public:
        typedef DataFieldCollection<OBJECT_TYPE> tDataFieldCollection;
    public:

    public:
        ObjectWriterT( OBJECT_TYPE* obj = NULL, const tDataFieldCollection* fields_def = NULL, Permission* obj_permission = NULL )
            : IObjectWriter(), object(obj), permission(obj_permission), fields(fields_def), access_token(NULL), access_mutex(NULL) { }
        virtual ~ObjectWriterT() { }

    public:
        virtual WRESULT write( const char* field_name, const ISerializable* data ) {
            const typename tDataFieldCollection::tDataFieldDefinition* field_def;
            field_def = fields->getField(field_name);
            if ( field_def == NULL ) return WRET_ERR_PARAM;
            if ( this->object == NULL ) return WRET_ERR_ILLEGAL_USE;
            if ( !field_def->hasWrapperWrite() ) return WRET_ERR_ILLEGAL_USE;
            return field_def->writer()->write(this->object, data);
        }

    public:
        virtual WRESULT setObject( IReflection* ptr ) {
            if ( ptr == NULL ) this->object = NULL;
            else {
                OBJECT_TYPE* objTmp = dynamic_cast<OBJECT_TYPE*>(ptr);
                if ( objTmp == NULL ) return WRET_ERR_PARAM;
                this->object = objTmp;
             }
            return WRET_OK;
         }
        virtual inline void setObjectT( OBJECT_TYPE* ptr )                      { this->object = ptr; }

        virtual inline void setSecurityToken( const SecurityToken* token )      { this->access_token = token; }
        virtual inline void setMutex( MutexRW* mutex )                          { this->access_mutex = mutex; }

        virtual ISerializable* alloc( const char* field_name ) const {
            const typename tDataFieldCollection::tDataFieldDefinition* field_def;
            field_def = fields->getField(field_name);
            if ( field_def == NULL ) return NULL;
            if ( !field_def->hasWrapperAlloc() ) return NULL;
            return field_def->allocator()->alloc();
         }

    public:
        virtual inline bool isSecure() const                                    { return ( this->permission != NULL ); }
        virtual inline bool isReentrant() const                                 { return ( this->access_mutex != NULL ); }
        virtual inline bool isWritable() const {
            if ( this->object == NULL || this->fields == NULL) return false;
            return true;
        }
        virtual inline const IDataFieldCollection* getFieldCollection() const   { return this->fields; }

    protected:
        OBJECT_TYPE* object;
        Permission* permission;
        const tDataFieldCollection* fields;
        const SecurityToken* access_token;
        MutexRW* access_mutex;
}; // class def


///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------
///----------------------------------------------------------------------------------------------------------------------




}; // namespace wosh

#endif //__WOSH_Core_DataFields_H__