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

Go to the documentation of this file.

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

   Core memory buffer.
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: Mon, 17 Mar 2008 23:07:21 +0100

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

   See LICENSE file for licensing details.
*/

#ifndef flc_membuf_H
#define flc_membuf_H

#include <falcon/setup.h>
#include <falcon/types.h>
#include <falcon/garbageable.h>
#include <falcon/deepitem.h>
#include <falcon/error.h>

namespace Falcon {

class VMachine;
class Stream;
class CoreObject;

class FALCON_DYN_CLASS MemBuf: public DeepItem, public Garbageable
{
public:
   typedef void (*tf_deletor)( void* memory );
   enum {
      INVALID_MARK = 0xFFFFFFFF,
      MAX_LEN = 0xFFFFFFFF
   } t_enum_mark;

protected:
   byte *m_memory;

   uint32 m_length;
   uint32 m_mark;
   uint32 m_limit;
   uint32 m_position;

   uint16 m_wordSize;
   uint16 m_byteOrder;

   CoreObject *m_dependant;
   tf_deletor m_deletor;

public:

   MemBuf( uint32 ws, uint32 length );

   MemBuf( uint32 ws, byte *data, uint32 length );

   MemBuf( uint32 ws, byte *data, uint32 length, tf_deletor deletor );

   virtual ~MemBuf();

   uint16 wordSize() const { return m_wordSize; }
   uint32 length() const { return m_length; }

   virtual uint32 get( uint32 pos ) const = 0;
   virtual void set( uint32 pos, uint32 value ) = 0;

   uint32 position() const { return m_position; }
   uint32 getMark() const { return m_mark; }
   uint32 limit() const { return m_limit; }

   void put( uint32 data )
   {
      if ( m_position >= length() )
         throw new AccessError( ErrorParam( e_arracc, __LINE__ ).module( __FILE__ ).symbol( "put" ).extra( "MemBuf" ) );

      set( m_position++, data );
   }

   uint32 get()
   {
      if ( m_position >= m_limit )
         throw new AccessError( ErrorParam( e_arracc, __LINE__ ).module( __FILE__ ).symbol( "get" ).extra( "MemBuf" ) );

      return get( m_position++ );
   }

   uint32 size() const { return m_length * m_wordSize; }

   void resize( uint32 newSize );

   byte *data() const { return m_memory; }

   void limit( uint32 l )
   {
      if ( l > length() )
         throw new AccessError( ErrorParam( e_arracc, __LINE__ ).module( __FILE__ ).symbol( "limit" ).extra( "MemBuf" ) );

      m_limit = l;
      if ( l < m_position )
         m_position = l;
   }

   void position( uint32 p )
   {
      if ( p > m_limit )
         throw new AccessError( ErrorParam( e_arracc, __LINE__ ).module( __FILE__ ).symbol( "position" ).extra( "MemBuf" ) );

      m_position = p;
      if ( m_mark < m_position )
         m_mark = INVALID_MARK;
   }

   void placeMark( uint32 m )
   {
      if ( m > m_position )
         throw new AccessError( ErrorParam( e_arracc, __LINE__ ).module( __FILE__ ).symbol( "mark" ).extra( "MemBuf" ) );

      m_mark = m;
   }

   void placeMark()
   {
      m_mark = m_position;
   }

   void reset()
   {
      if ( m_mark == INVALID_MARK )
         throw new AccessError( ErrorParam( e_arracc, __LINE__ ).module( __FILE__ ).symbol( "reset" ).extra( "MemBuf" ) );

      m_position = m_mark;
   }

   void rewind()
   {
      m_position = 0;
      m_mark = INVALID_MARK;
   }


   void clear()
   {
      m_position = 0;
      m_limit = m_length;
      m_mark = INVALID_MARK;
   }

   void flip()
   {
      m_limit = m_position;
      m_position = 0;
      m_mark = INVALID_MARK;
   }

   void compact();

   uint32 remaining() const {
      return m_limit - m_position;
   }

   void length( uint32 s ) { m_length = s; }
   void setData( byte *data, uint32 length, tf_deletor deletor = 0 );

   CoreObject *dependant() const { return m_dependant; }

   void dependant( CoreObject *g ) { m_dependant = g; }

   virtual bool serialize( Stream *stream, bool bLive = false ) const;

   static MemBuf *deserialize( VMachine *vm, Stream *stream );

   static MemBuf *create( int nWordSize, uint32 length );

   virtual MemBuf* clone() const;
   virtual void gcMark( uint32 gen );

   virtual void readProperty( const String &, Item &item );
   virtual void writeProperty( const String &, const Item &item );
   virtual void readIndex( const Item &pos, Item &target );
   virtual void writeIndex( const Item &pos, const Item &target );
};

class FALCON_DYN_CLASS MemBuf_1: public virtual MemBuf
{
public:
   MemBuf_1( uint32 length ):
      MemBuf( 1, length )
   {}

   MemBuf_1( byte *data, uint32 length, tf_deletor deletor = 0 ):
      MemBuf( 1, data, length, deletor )
   {}

   virtual uint32 get( uint32 pos ) const;
   virtual void set( uint32 pos, uint32 value );
};

class FALCON_DYN_CLASS MemBuf_2: public virtual MemBuf
{
public:
   MemBuf_2( uint32 length ):
      MemBuf( 2, length )
   {}

   MemBuf_2( byte *data, uint32 length, tf_deletor deletor = 0 ):
      MemBuf( 2, data, length, deletor )
   {}

   virtual uint32 get( uint32 pos ) const;
   virtual void set( uint32 pos, uint32 value );
};

class FALCON_DYN_CLASS MemBuf_3: public virtual MemBuf
{
public:
   MemBuf_3( uint32 length ):
      MemBuf( 3, length )
   {}

   MemBuf_3( byte *data, uint32 length, tf_deletor deletor = 0 ):
      MemBuf( 3, data, length, deletor )
   {}

   virtual uint32 get( uint32 pos ) const;
   virtual void set( uint32 pos, uint32 deletor );
};

class FALCON_DYN_CLASS MemBuf_4: public virtual MemBuf
{
public:
   MemBuf_4( uint32 length ):
      MemBuf( 4, length )
   {}

   MemBuf_4( byte *data, uint32 length, tf_deletor deletor = 0 ):
      MemBuf( 4, data, length, deletor )
   {}

   virtual uint32 get( uint32 pos ) const;
   virtual void set( uint32 pos, uint32 value );
};


}

#endif

/* end of membuf.h */

---