v 0. Pasted by Anonymous as cpp at 2011-07-01 19:55:18 MSK and set expiration to never.

Paste will expire never.

  1. #include "stdafx.h"
  2. #include <assert.h>
  3. #include <string.h> // strstr
  4. #include <stdio.h// sprintf
  5. #include "scriptreloader.h"
  6. #include "scriptstring.h"
  7. #include "scriptarray.h"
  8.  
  9. using namespace std;
  10.  
  11. BEGIN_AS_NAMESPACE
  12.  
  13.  
  14. void CScriptReloaderVariable::Store(void *ref, int _typeId)
  15. {
  16.     is_init = true;
  17.     setType( _typeId );
  18.     ptr = ref;
  19.  
  20.     if( type_id & asTYPEID_OBJHANDLE )
  21.     {
  22.         handle_ptr = *(void**)ref;
  23.     }
  24.     else if( type_id & asTYPEID_SCRIPTOBJECT )
  25.     {
  26.         asIScriptObject *obj = (asIScriptObject *)ref;
  27.         asIObjectType *type = obj->GetObjectType();
  28.         setType(  type->GetTypeId() );
  29.  
  30.         // Store childs
  31.         for(int i =0; i < type->GetPropertyCount(); i++ )
  32.         {   
  33.             int child_id;
  34.             const char *child_name;
  35.             type->GetProperty( i, &child_name, &child_id );
  36.  
  37.             childs.push_back( CScriptReloaderVariable( this, child_name, obj->GetAddressOfProperty( i ), child_id ) );
  38.         }   
  39.     }
  40.     else
  41.     {
  42.         int size = reloader->engine->GetSizeOfPrimitiveType( type_id );
  43.        
  44.         if( size == 0 )
  45.         {           
  46.             if( type_id_str== "string" )
  47.             {
  48.                 CScriptString *txt_ref = ((CScriptString*)ref);
  49.                 txt_val = txt_ref->buffer;
  50.             }
  51.             else if( type_id_str == "array" )
  52.             {
  53.                 CScriptArray *array = (CScriptArray*)ref;
  54.  
  55.                 for( int i =0; i < array->GetSize(); i++ )
  56.                     childs.push_back( CScriptReloaderVariable( this, "", array->At( i ), array->GetElementTypeId() ) );
  57.             }
  58.             else if( getType() )
  59.             {
  60.                 size = getType()->GetSize();   
  61.             }
  62.         }
  63.  
  64.         if( size )
  65.         {
  66.             mem.resize( size );
  67.             memcpy(&mem[0], ref, size);
  68.         }
  69.     }
  70. }
  71.  
  72. void CScriptReloaderVariable::Restore(void *ref)
  73. {
  74.     if( !this || !is_init || !ref )
  75.         return;
  76.  
  77.     restore_ptr = ref;
  78.  
  79.     if( type_id  & asTYPEID_OBJHANDLE )
  80.     {
  81.         // if need create objects
  82.         if( childs.size() == 1 )
  83.         {
  84.             asIObjectType *type = childs[0].getType();
  85.  
  86.             void *new_obejct = reloader->engine->CreateScriptObject( type->GetTypeId() );
  87.  
  88.             childs[0].Restore( new_obejct );   
  89.         }
  90.     }
  91.     else if( type_id & asTYPEID_SCRIPTOBJECT )
  92.     {
  93.         asIScriptObject *obj = (asIScriptObject *)ref;
  94.         asIObjectType *type = getType();
  95.  
  96.         // Retrieve children s
  97.         for( int i =0; i < type->GetPropertyCount() ; i++ )
  98.         {   
  99.             const char *name_property;
  100.             type->GetProperty(i, &name_property );
  101.            
  102.             child( name_property )->Restore( obj->GetAddressOfProperty( i ) );     
  103.         }
  104.     }
  105.     else
  106.     {
  107.         if( mem.size() )
  108.             memcpy( ref, &mem[0], mem.size());
  109.         else
  110.         {
  111.             if( type_id_str == "string" )
  112.             {
  113.                 CScriptString *ref_txt = ((CScriptString*)ref);         
  114.                 ref_txt->buffer = txt_val;
  115.             }
  116.             else if( type_id_str == "array" )
  117.             {
  118.                 CScriptArray *array = (CScriptArray*)ref;
  119.                 array->Resize( childs.size() );
  120.  
  121.                 for( size_t i =0; i < childs.size(); ++i ) 
  122.                     childs[i].Restore( array->At(i) );
  123.             }
  124.         }
  125.     }
  126. }
  127.  
  128. void CScriptReloaderVariable::canselDublicate( CScriptReloaderVariable *from )
  129. {
  130.     std::vector<void*> ptrs;
  131.     from->childsPtr( &ptrs );
  132.  
  133.     for( size_t i=0; i < ptrs.size(); ++i )
  134.     {
  135.         CScriptReloaderVariable *find = reloader->root.findByPtrInCreated( ptrs[i] );
  136.  
  137.         while( find )
  138.         {
  139.             // cancel create object
  140.             find->childs.clear();
  141.  
  142.             // Find next link to this ptr
  143.             find = reloader->root.findByPtrInCreated( ptrs[i] );
  144.         }
  145.     }
  146. }
  147.  
  148. void CScriptReloaderVariable::StoreHandle()
  149. {
  150.     // Find to
  151.     if( handle_ptr )
  152.     {
  153.         CScriptReloaderVariable *handle_to = reloader->root.findByPtr( handle_ptr );
  154.        
  155.         // if handle is not found in global space...
  156.         if( handle_to == nullptr )
  157.         {
  158.             asIObjectType *type = getType();
  159.  
  160.             CScriptReloaderVariable need_create = CScriptReloaderVariable( this, name, handle_ptr, type->GetTypeId() );
  161.  
  162.             canselDublicate( &need_create );
  163.  
  164.             childs.push_back( need_create );
  165.         }
  166.     }
  167.     // Childs...
  168.     for( size_t i=0; i < childs.size(); ++i )
  169.         childs[i].StoreHandle();
  170. }
  171.  
  172. void CScriptReloaderVariable::RestoreHandle()
  173. {
  174.     CScriptReloaderVariable *handle_to = reloader->root.findByPtr( handle_ptr );
  175.  
  176.     // Restore handle!
  177.     if( restore_ptr && handle_to && handle_to->restore_ptr )
  178.         *(void**)restore_ptr = handle_to->restore_ptr;
  179.    
  180.     // Childs...
  181.     for( size_t i=0; i < childs.size(); ++i )
  182.         childs[i].RestoreHandle();
  183. }
  184.  
  185.  
  186. void CScriptReloaderVariable::setType(  int _typeId )
  187. {
  188.     type_id = _typeId;
  189.  
  190.     asIObjectType *type = reloader->engine->GetObjectTypeById( type_id  );
  191.  
  192.     if( type )
  193.         type_id_str = type->GetName();
  194. }
  195.  
  196. asIObjectType *CScriptReloaderVariable::getType()
  197. {
  198.     if( !type_id_str.empty() )
  199.     {
  200.         int new_type_id = reloader->mod->GetTypeIdByDecl( type_id_str.c_str() );
  201.         return reloader->engine->GetObjectTypeById( new_type_id );
  202.     }   
  203.  
  204.     return nullptr;
  205. }
  206.  
  207.  
  208.  
  209.  
  210. END_AS_NAMESPACE