src/services/fbf/write-context.h

   1 /*
   2     Fail game engine
   3     Copyright 2007 Antoine Chavasse <a.chavasse@gmail.com>
   4
   5     This file is part of Fail.
   6
   7     Fail is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License version 3
   9     as published by the Free Software Foundation.
  10
  11     Fail is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 #ifndef FAIL_FBF_WRITE_CONTEXT_H
  20 #define FAIL_FBF_WRITE_CONTEXT_H
  21
  22 #include <map>
  23
  24 namespace fail { namespace fbf { namespace Impl
  25 {
  26         template< class C, bool bStorable = flags::Storable< C >::value > struct VisitSuperClassIfStorable
  27         {
  28                 template< class V > static void Visit( V& v )
  29                 {
  30                         class_traits< C >::template VisitSuperClasses( v );
  31                         class_traits< C >::template VisitAttributes( v );
  32                 }
  33         };
  34
  35         template< class C > struct VisitSuperClassIfStorable< C, false >
  36         {
  37                 template< class V > static void Visit( V& v )
  38                 {
  39
  40                 }
  41         };
  42
  43         template< typename AttrTag, bool bStorable = flags::Storable< AttrTag >::value > struct WriteAttrIfStorable
  44         {
  45                 template< class C, class WCT > static void Write( C* pObj, WCT& wct )
  46                 {
  47                         typedef attribute_traits< C, AttrTag > traits;
  48                         typedef TypeMarshaler< C, typename traits::category, typename traits::type > tm;
  49                         tm::write( pObj, wct, pObj->*( traits::MemberPointer() ) );
  50                 }
  51         };
  52
  53         template< typename AttrTag > struct WriteAttrIfStorable< AttrTag, false >
  54         {
  55                 template< class C, class WCT > static void Write( C* pObj, WCT& wct ) {}
  56         };
  57
  58         template< class WCT, class C > struct WriteObjVisitor
  59         {
  60                 WriteObjVisitor( WCT& wct_, const C* pObj_ ) :
  61                                 wct( wct_ ),
  62                                 pObj( pObj_ )
  63                 {
  64                 }
  65
  66                 template< class SC > void declSuperClass()
  67                 {
  68                         VisitSuperClassIfStorable< SC >::Visit( *this );
  69                 }
  70
  71                 template< typename AttrTag > void declAttribute()
  72                 {
  73                         WriteAttrIfStorable< AttrTag >::Write( pObj, wct );
  74                 }
  75
  76                 WCT&            wct;
  77                 const C*        pObj;
  78         };
  79
  80         template< class stream_type > template< class C > void WriteContext< stream_type >::
  81                 writeObject( const Pointer< C >& pObj_ )
  82         {
  83                 if( !flags::Storable< C >::value )
  84                         return;
  85
  86                 const RefCounted* pObjBase = static_cast< RefCounted* >( pObj_ );
  87                 addObject( pObjBase );
  88
  89                 WriteObjVisitor< WriteContext< stream_type >, C > wov( *this, pObj_ );
  90                 class_traits< C >::template VisitSuperClasses( wov );
  91                 class_traits< C >::template VisitAttributes( wov );
  92         }
  93 }}}
  94
  95 #endif