/home/gian/Progetti/falcon/core/include/falcon/proptable.h

Go to the documentation of this file.

/*
   FALCON - The Falcon Programming Language.
   FILE: proptable.h

   Very simple double entry table for pure properties.
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: ven ott 14 2005

   -------------------------------------------------------------------
   (C) Copyright 2004: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

#ifndef flc_proptable_H
#define flc_proptable_H

#include <falcon/setup.h>
#include <falcon/types.h>
#include <falcon/string.h>
#include <falcon/item.h>
#include <falcon/basealloc.h>
#include <falcon/reflectfunc.h>


namespace Falcon
{

class CoreObject;

struct PropEntry
{
        enum {
                NO_OFFSET = 0xFFFFFFFF
        };

   const String *m_name;

   bool m_bReadOnly;

   bool isWriteOnly() const { 
           return m_eReflectMode == e_reflectSetGet && m_reflection.gs.m_getterId == NO_OFFSET; 
   }

   t_reflection m_eReflectMode;

   void *reflect_data;

   Item m_value;

   union {
      uint32 offset;
      struct {
         reflectionFunc to;
         reflectionFunc from;
      } rfunc;

      struct {
         uint32 m_getterId;
         uint32 m_setterId;
      } gs;
   } m_reflection;

   void reflectTo( CoreObject *instance, void *user_data, const Item &prop ) const;

   void reflectFrom( CoreObject *instance, void *user_data, Item &prop ) const;
};


class FALCON_DYN_CLASS PropertyTable: public BaseAlloc
{
public:
   uint32 m_size;
   uint32 m_added;
   bool m_bReflective;
   bool m_bStatic;
   PropEntry *m_entries;

public:

   PropertyTable( uint32 size );
   PropertyTable( const PropertyTable & );
   ~PropertyTable();

   uint32 size() const { return m_size; }
   uint32 added() const { return m_added; }

   bool isReflective() const { return m_bReflective; }
   bool isStatic() const { return m_bStatic; }

   void checkProperties();

   bool findKey( const String &key, uint32 &pos ) const;

   PropEntry &getEntry( uint32 pos ) { return m_entries[pos]; }
   const PropEntry &getEntry( uint32 pos ) const { return m_entries[pos]; }

   const Item *getValue( const String &key ) const
   {
       uint32 pos;
       if( findKey( key, pos ) )
         return getValue( pos );
      return 0;
   }

   Item *getValue( uint32 pos ) { return &m_entries[ pos ].m_value; }
   const Item *getValue( uint32 pos ) const { return &m_entries[ pos ].m_value; }
   const String *getKey( uint32 pos ) const { return m_entries[pos].m_name; }

   PropEntry &append( const String *name );

   bool append( const String *key, const Item &itm, bool bReadOnly = false )
   {
      if ( m_added <= m_size ) {
         PropEntry e = append( key );
         e.m_value = itm;
         e.m_bReadOnly = bReadOnly;
         e.m_eReflectMode = e_reflectNone;
         return true;
      }

      return false;
   }

   bool append( const String *key, const Item &itm, t_reflection mode, uint32 offset, bool bReadOnly = false )
   {
      if ( m_added <= m_size ) {
         PropEntry e = append( key );
         e.m_value = itm;
         e.m_bReadOnly = bReadOnly;
         e.m_eReflectMode = mode;
         e.m_reflection.offset = offset;
         return true;
      }

      return false;
   }

   bool append( const String *key, const Item &itm, reflectionFunc func_from, reflectionFunc func_to = 0 )
   {
      if ( m_added <= m_size ) {
         PropEntry e = append( key );
         e.m_value = itm;
         e.m_bReadOnly = func_to == 0;
         e.m_eReflectMode = e_reflectFunc;
         e.m_reflection.rfunc.from = func_from;
         e.m_reflection.rfunc.to = func_to;
         return true;
      }

      return false;
   }


   PropEntry &appendSafe( const String *key  )
   {
      m_entries[m_added].m_name = key;
      PropEntry *ret = m_entries + m_added;
      m_added++;
      return *ret;
   }

   void appendSafe( const String *key, const Item &itm, bool bReadOnly = false  )
   {
      m_entries[m_added].m_name = key;
      m_entries[m_added].m_value = itm;
      m_entries[m_added].m_bReadOnly = bReadOnly;
      m_entries[m_added].m_eReflectMode = e_reflectNone;
      m_added++;
   }

   void appendSafe( const String *key, const Item &itm, t_reflection mode, uint32 offset, bool bReadOnly = false  )
   {
      m_entries[m_added].m_name = key;
      m_entries[m_added].m_value = itm;
      m_entries[m_added].m_bReadOnly = bReadOnly;
      m_entries[m_added].m_eReflectMode = mode;
      m_entries[m_added].m_reflection.offset = offset;
      m_added++;
   }

   void appendSafe( const String *key, const Item &itm, reflectionFunc func_from, reflectionFunc func_to = 0  )
   {
      m_entries[m_added].m_name = key;
      m_entries[m_added].m_value = itm;
      m_entries[m_added].m_bReadOnly = func_to == 0;
      m_entries[m_added].m_eReflectMode = e_reflectFunc;
      m_entries[m_added].m_reflection.rfunc.from = func_from;
      m_entries[m_added].m_reflection.rfunc.to = func_to;
      m_added++;
   }
};

}

#endif

/* end of proptable.h */

---