glfield.h

/***************************************************************************
                          glfield.h  -  description
                             -------------------
    begin                : Wed Oct 29 2003
    copyright            : (C) 2003 by Jacques Gasselin de Richebourg
    email                : jacquesgasselin@hotmail.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef GLFIELD_H
#define GLFIELD_H

#include <map>
#include <fstream>
#include "referencecounted.h"

namespace GLScene
{  

   class GLFieldBase
   {
      std::string* name;
      
      public:

      GLFieldBase( std::string* const n = NULL)  { name = n; };
      virtual ~GLFieldBase() {};

      virtual void setName( std::string* const n ) { name = n; };
      virtual const char* getName( void ) const { return name->c_str(); }
      
      virtual const std::type_info& getType( ) = 0;
      virtual bool isOfType( std::type_info ) = 0;
      
      virtual bool loadFromStream( std::istream& in, std::string compareTo, const char* fieldName = NULL ) = 0;
      virtual void saveToStream( std::ostream& out, const char* fieldName = NULL ) = 0;
   };

   //typedef RCPointer<GLFieldBase> FieldBasePtr;
   typedef GLFieldBase* FieldBasePtr;

   // fields implement a simple reference count that is very small and quick
   template <class Type, short Size = 1>
   class GLField: public GLFieldBase
   {
      typedef std::pair< short unsigned, Type* > PairType;

      //Type* val;
      PairType* val;
//      Type* val;

      public:

      GLField( std::string* const n = NULL)
      :GLFieldBase(n), val(NULL)
      {
         if( Size > 1 )
            set( new Type[Size] );
         else
            set( new Type );
      }
      
      GLField( const GLField& fl, std::string* const n = NULL )
      :GLFieldBase(n), val(NULL)
      {
         set(fl);
      }
      
      explicit GLField( const Type* t, std::string* const n = NULL )
      :GLFieldBase(n), val(NULL)
      {
         set(t);
      }

      virtual ~GLField()
      {
         unref();
      }

      inline void unref( void )
      {
         if( !val )
            return;

         --(val->first);
         
         if( val->first == 0)
         {
            if( val->second )
            {
               if( Size > 1 )
                  delete [] val->second;
               else
                  delete val->second;
            }

            delete val;
         }

         val = NULL;
      }

      inline void ref( void )
      {
         if( !val )
            return;
         else
            ++(val->first);
      }
                  
      inline void set( const GLField& fl, std::string* const = NULL )
      {
         set( fl.val, n );
      }
         
      inline void set( const PairType* pt, std::string* const = NULL )
      {
         if( n != NULL )
            setName( n );

         if( pt == val )
           return; // no need to double copy

         unref();
            
         val = pt;

         ref();
      }
      
      inline void set( Type* const t, std::string* const n = NULL )
      {
         if( n != NULL )
            setName( n );
         
         if( val == NULL )
         {
            if( t == NULL )
               return;
               
            val = new PairType;
            val->first = 1;
            val->second = NULL;
         }
         else
         {
            if( val->second != NULL)
            {
               if( val->second != t )
               {
                  unref();

                  if( t == NULL )
                     return;
                     
                  val = new PairType;
                  val->first = 1;
                  val->second = NULL;
               }

            }
         }

         val->second = t;
      }

      inline void set( const Type& t)
      {
         if( val == NULL )
         {
            val = new PairType;
            val->first = 1;
            val->second = new Type(t);
         }
         else
         {
            if( val->second != NULL)
            {
               unref();


               val = new PairType;
               val->first = 1;
               val->second = new Type(t);
            }

         }
      }

      inline const Type* get( void ) const
      {
         if( val )
            return val->second;
         else
            return NULL;
      }
      
      inline bool operator == (FieldBasePtr ptr)
      {
         if( ptr == NULL )
         {
            if( val == NULL || val->second == NULL )
               return true;
         }
         
         if( GLField<Type, Size>* cast = dynamic_cast< GLField<Type, Size>* >(ptr) )
         { // they have the same value type
            if( cast->val == val )
              return true;
            else
              return false;
         }
         else
            return false;
      }

      inline operator Type* (void) const
      {
         if( val )
            return val->second;
         else
            return NULL;
      }

      inline operator Type (void) const
      {
         return *(val->second);
      }

      inline Type* operator -> (void) const
      {
         return val->second;
      }
      
      inline Type& operator * (void) const
      {
         return *(val->second);
      }

      inline const GLField& operator = ( Type* const t )
      {
         set( t );

         return *this;
      }

      inline const GLField& operator = ( const Type& t )
      {
         set( t );

         return *this;
      }
      
      virtual const std::type_info& getType( void )
      {
         return typeid( Type );
      }

      virtual bool isOfType( std::type_info t )
      {
         if( typeid( Type ) == t )
            return true;
         else
            return false;
      }

      virtual bool loadFromStream( std::istream& in, std::string compareTo, const char* fieldName = NULL)
      {
         bool match = false;
         
         if( getName() != NULL )
         {
            if( compareTo.compare( getName() ) == 0 )
               match = true;
         }
         else
         if( fieldName != NULL )
         {
            if( compareTo.compare( fieldName ) == 0)
               match = true;
         }

         if( match )
         { 
            char delim;
            in>>delim;//remove the " = "

            Type* newVal;
            
            if( Size > 1 )
            {
               newVal = new Type[Size];
            
               for( register short i = 0; i < Size; ++i )
                  in>>newVal[i];
            
            }
            else
            {
               newVal = new Type;

               in>>(*newVal);
            }

            set( newVal );
            
            return true;
         }
         else
            return false;
      }
      
      virtual void saveToStream( std::ostream& out, const char* fieldName = NULL)
      {
         if( val )
            if( val->second )
            {
               if( getName() != NULL )
                  out<<getName();
               else
                  out<<fieldName;

               out<<" =";

               if( Size > 1 )
               {
                  for( register short i = 0; i < Size; ++i )
                     out<<" "<<val->second[i];
               }
               else
               {
                  out<<" "<<(*(val->second));
               }

               out<<std::endl;
            }
      }

   };

   
   class GLFieldHolder
   {
      public:

      GLFieldHolder() {};
      virtual ~GLFieldHolder()
      {
      };

      virtual FieldBasePtr getFieldByIndex( short index ) = 0;

      virtual FieldBasePtr getField( std::string fieldName )
      {
         for( register short i = 0; true; ++i )
         {
            FieldBasePtr temp = getFieldByIndex( i );
            if( temp == NULL )
               break;
               
            if( fieldName.compare( temp->getName() ) == 0 )
               return temp;
         };
            
         return NULL;
      }

      virtual bool loadFieldsFromStream( std::istream& in, std::string compareTo )
      {
         register short i = 0;
         
         while( FieldBasePtr field = getFieldByIndex( i ) )
         {
            if( field->loadFromStream( in, compareTo ) )
               return true;
            ++i;
         };

         return false;
      }
      
      virtual void saveFieldsToStream( std::ostream& out )
      {
         register short i = 0;

         while( FieldBasePtr field = getFieldByIndex( i ) )
         {
            field->saveToStream( out );
            ++i;
         };
      }   
   };


}
#endif

---