source: issm/oecreview/Archive/24684-25833/ISSM-25506-25507.diff

Last change on this file was 25834, checked in by Mathieu Morlighem, 4 years ago

CHG: added 24684-25833
File size: 144.9 KB

  • ../trunk-jpl/src/c/classes/Segment.h

     
    6464                /*}}}*/
    6565                int    Id(void){ return eid; }/*{{{*/
    6666                /*}}}*/
    67                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    68                         _error_("not implemented yet!");
    69                 }
    70                 /*}}}*/
    7167                void Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    7268                        _error_("not implemented yet!");
    7369                }

  • ../trunk-jpl/src/c/classes/Nodes.cpp

     
    102102        return output;
    103103}
    104104/*}}}*/
    105 void  Nodes::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    106 
    107         int num_procs=IssmComm::GetSize();
    108         int test = num_procs;
    109         MARSHALLING_ENUM(NodesEnum);
    110         MARSHALLING(numberofnodes);
    111         MARSHALLING(numberofnodes_local);
    112         MARSHALLING(numberofmasters_local);
    113 
    114         MARSHALLING(test);
    115         if(test!=num_procs) _error_("number of cores is not the same as before");
    116 
    117         DataSet::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    118 
    119         if(marshall_direction == MARSHALLING_LOAD){
    120                 this->common_recv_ids = xNew<int*>(num_procs);
    121                 this->common_send_ids = xNew<int*>(num_procs);
    122                 for(int i=0;i<num_procs;i++){
    123                         this->common_recv_ids[i] = NULL;
    124                         this->common_send_ids[i] = NULL;
    125                 }
    126         }
    127 
    128         /*Stop here if no nodes*/
    129         if(this->Size()==0) return;
    130 
    131         MARSHALLING_DYNAMIC(this->common_recv,int,num_procs);
    132         MARSHALLING_DYNAMIC(this->common_send,int,num_procs);
    133         for(int i=0;i<num_procs;i++){
    134                 if(this->common_recv[i]) MARSHALLING_DYNAMIC(this->common_recv_ids[i],int,this->common_recv[i]);
    135                 if(this->common_send[i]) MARSHALLING_DYNAMIC(this->common_send_ids[i],int,this->common_send[i]);
    136         }
    137 }
    138 /*}}}*/
    139105void  Nodes::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    140106
    141107        int object_enum = NodesEnum;

  • ../trunk-jpl/src/c/classes/Cfdragcoeffabsgrad.cpp

     
    7272        return -1;
    7373}
    7474/*}}}*/
    75 void Cfdragcoeffabsgrad::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    76         _error_("not implemented yet!");
    77 }
    78 /*}}}*/
    7975void Cfdragcoeffabsgrad::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    8076        _error_("not implemented yet!");
    8177}

  • ../trunk-jpl/src/c/classes/Vertex.cpp

     
    113113/*}}}*/
    114114int Vertex::Id(void){ return id; }/*{{{*/
    115115/*}}}*/
    116 void Vertex::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    117 
    118         MARSHALLING_ENUM(VertexEnum);
    119         MARSHALLING(clone);
    120         MARSHALLING(domaintype);
    121         MARSHALLING(id);
    122         MARSHALLING(sid);
    123         MARSHALLING(pid);
    124         MARSHALLING(lid);
    125         MARSHALLING(x);
    126         MARSHALLING(y);
    127         MARSHALLING(z);
    128         MARSHALLING(sigma);
    129         MARSHALLING(connectivity);
    130 
    131 }
    132 /*}}}*/
    133116void Vertex::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    134117
    135118        int object_enum = VertexEnum;

  • ../trunk-jpl/src/c/classes/Cfsurfacelogvel.h

     
    3333                void DeepEcho(void);
    3434                void Echo(void);
    3535                int Id(void);
    36                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3736                void Marshall2(MarshallHandle* marshallhandle);
    3837                int ObjectEnum(void);
    3938               

  • ../trunk-jpl/src/c/classes/Profiler.cpp

     
    6363        return -1;
    6464}
    6565/*}}}*/
    66 void Profiler::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    67 
    68         IssmPDouble* pointer = NULL;
    69         bool*       bpointer = NULL;
    70 
    71         MARSHALLING_ENUM(ProfilerEnum);
    72         pointer = &this->time[0];
    73         MARSHALLING_DYNAMIC(pointer,IssmPDouble,MAXPROFSIZE);
    74         pointer = &this->flops[0];
    75         MARSHALLING_DYNAMIC(pointer,IssmPDouble,MAXPROFSIZE);
    76         pointer = &this->memory[0];
    77         MARSHALLING_DYNAMIC(pointer,IssmPDouble,MAXPROFSIZE);
    78         bpointer = &this->running[0];
    79         MARSHALLING_DYNAMIC(bpointer,bool,MAXPROFSIZE);
    80 
    81 } /*}}}*/
    8266void Profiler::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8367
    8468        IssmPDouble* pointer = NULL;

  • ../trunk-jpl/src/c/classes/Constraints/SpcDynamic.h

     
    3333                void    DeepEcho();
    3434                void    Echo();
    3535                int     Id();
    36                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3736                void    Marshall2(MarshallHandle* marshallhandle);
    3837                int     ObjectEnum();
    3938

  • ../trunk-jpl/src/c/classes/Constraints/SpcStatic.h

     
    3232                void  DeepEcho();
    3333                void  Echo();
    3434                int   Id();
    35                 void  Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3635                void  Marshall2(MarshallHandle* marshallhandle);
    3736                int   ObjectEnum();
    3837                /*}}}*/

  • ../trunk-jpl/src/c/classes/Constraints/SpcTransient.h

     
    3434                void    DeepEcho();
    3535                void    Echo();
    3636                int     Id();
    37                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3837                void    Marshall2(MarshallHandle* marshallhandle);
    3938                int     ObjectEnum();
    4039                /*}}}*/

  • ../trunk-jpl/src/c/classes/Constraints/SpcDynamic.cpp

     
    7070/*}}}*/
    7171int     SpcDynamic::Id(void){ return id; }/*{{{*/
    7272/*}}}*/
    73 void    SpcDynamic::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    74 
    75         MARSHALLING_ENUM(SpcDynamicEnum);
    76 
    77         MARSHALLING(id);
    78         MARSHALLING(nodeid);
    79         MARSHALLING(dof);
    80         MARSHALLING(value);
    81         MARSHALLING(analysis_type);
    82         MARSHALLING(isset);
    83         MARSHALLING(penalty);
    84 
    85 }
    86 /*}}}*/
    8773void    SpcDynamic::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8874
    8975        int object_enum = SpcDynamicEnum;

  • ../trunk-jpl/src/c/classes/Constraints/SpcStatic.cpp

     
    7272/*}}}*/
    7373int     SpcStatic::Id(void){ return id; }/*{{{*/
    7474/*}}}*/
    75 void    SpcStatic::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    76 
    77         MARSHALLING_ENUM(SpcStaticEnum);
    78 
    79         MARSHALLING(id);
    80         MARSHALLING(nodeid);
    81         MARSHALLING(dof);
    82         MARSHALLING(value);
    83         MARSHALLING(analysis_type);
    84         MARSHALLING(penalty);
    85 
    86 }
    87 /*}}}*/
    8875void    SpcStatic::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8976
    9077        int object_enum = SpcStaticEnum;

  • ../trunk-jpl/src/c/classes/Constraints/SpcTransient.cpp

     
    7878        return id;
    7979}
    8080/*}}}*/
    81 void    SpcTransient::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    82 
    83         MARSHALLING_ENUM(SpcTransientEnum);
    84 
    85         MARSHALLING(id);
    86         MARSHALLING(nodeid);
    87         MARSHALLING(dof);
    88         MARSHALLING(analysis_type);
    89         MARSHALLING(penalty);
    90         MARSHALLING(nsteps);
    91         if(nsteps){
    92                 MARSHALLING_DYNAMIC(values,IssmDouble,nsteps);
    93                 MARSHALLING_DYNAMIC(times,IssmDouble,nsteps);
    94         }
    95         else{
    96                 values=NULL;
    97                 times=NULL;
    98         }
    99 
    100 }
    101 /*}}}*/
    10281void    SpcTransient::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    10382
    10483        int object_enum = SpcTransientEnum;

  • ../trunk-jpl/src/c/classes/Regionaloutput.h

     
    3232        void DeepEcho(void);
    3333        void Echo(void);
    3434        int Id(void);
    35         void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3635        void Marshall2(MarshallHandle* marshallhandle);
    3736        int ObjectEnum(void);
    3837

  • ../trunk-jpl/src/c/classes/Cfsurfacesquare.h

     
    3838                void DeepEcho(void);
    3939                void Echo(void);
    4040                int Id(void);
    41                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4241                void Marshall2(MarshallHandle* marshallhandle);
    4342                int ObjectEnum(void);
    4443               

  • ../trunk-jpl/src/c/classes/FemModel.cpp

     
    259259        femmodel_buffer_ini=femmodel_buffer;
    260260
    261261        /*Marshall:*/
    262         //this->Marshall(&femmodel_buffer,NULL,MARSHALLING_WRITE);
    263262   WriteCheckpointFunctor* marshallhandle = new WriteCheckpointFunctor(&femmodel_buffer);
    264263   this->Marshall2(marshallhandle);
    265264        delete marshallhandle;
    … …  
    484483        /*Clean up*/
    485484        delete iomodel;
    486485}/*}}}*/
    487 void FemModel::Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    488 
    489         int       i;
    490         int       analysis_type;
    491 
    492         if(marshall_direction==MARSHALLING_LOAD){
    493                 delete this->materials;
    494                 delete this->parameters;
    495                 delete this->inputs;
    496                 if(this->constraints_list && this->nummodels){
    497                         for(i=0;i<this->nummodels;i++) delete this->constraints_list[i];
    498                         xDelete<Constraints*>(constraints_list);
    499                 }
    500                 if(this->loads_list && this->nummodels){
    501                         for(i=0;i<this->nummodels;i++) delete this->loads_list[i];
    502                         xDelete<Loads*>(loads_list);
    503                 }
    504                 if(this->nodes_list && this->nummodels){
    505                         for(i=0;i<this->nummodels;i++) delete this->nodes_list[i];
    506                         xDelete<Nodes*>(nodes_list);
    507                 }
    508                 delete this->results;
    509                 delete this->vertices;
    510                 delete this->elements;
    511                 xDelete<int>(this->analysis_type_list);
    512 
    513                 this->materials   = new Materials();
    514                 this->parameters  = new Parameters();
    515                 this->inputs     = new Inputs();
    516                 this->results     = new Results();
    517                 this->nodes       = new Nodes();
    518                 this->vertices    = new Vertices();
    519                 this->elements    = new Elements();
    520         }
    521 
    522         MARSHALLING_ENUM(FemModelEnum);
    523 
    524         MARSHALLING(solution_type);
    525         MARSHALLING(analysis_counter);
    526         MARSHALLING(nummodels);
    527         MARSHALLING_DYNAMIC(analysis_type_list,int,nummodels);
    528 
    529         this->materials->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    530         this->parameters->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    531         this->inputs->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    532         this->results->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    533         this->vertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    534         this->elements->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    535 
    536         if(marshall_direction==MARSHALLING_LOAD){
    537                 this->constraints_list = xNew<Constraints*>(this->nummodels);
    538                 for(i=0;i<nummodels;i++) this->constraints_list[i] = new Constraints();
    539                 this->loads_list = xNew<Loads*>(this->nummodels);
    540                 for(i=0;i<nummodels;i++) this->loads_list[i] = new Loads();
    541                 this->nodes_list = xNew<Nodes*>(this->nummodels);
    542                 for(i=0;i<nummodels;i++) this->nodes_list[i] = new Nodes();
    543         }
    544 
    545         for(i=0;i<nummodels;i++){
    546                 this->constraints_list[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    547                 this->loads_list[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    548                 this->nodes_list[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    549         }
    550 
    551         if(marshall_direction==MARSHALLING_LOAD){
    552                 /*reset hooks for elements, loads and nodes:*/
    553                 this->elements->ResetHooks();
    554                 this->materials->ResetHooks();
    555 
    556                 /*do the post-processing of the datasets to get an FemModel that can actually run analyses:*/
    557                 for(i=0;i<nummodels;i++){
    558                         this->loads_list[i]->ResetHooks();
    559                         analysis_type=this->analysis_type_list[i];
    560                         SetCurrentConfiguration(analysis_type);
    561                         SpcNodesx(this->nodes_list[i],this->constraints_list[i],this->parameters);
    562                         NodesDofx(this->nodes_list[i],this->parameters);
    563                         ConfigureObjectsx(this->elements,this->loads_list[i],this->nodes_list[i],this->vertices,this->materials,this->parameters,this->inputs);
    564                 }
    565 
    566                 //Reset current configuration:
    567                 analysis_type=this->analysis_type_list[analysis_counter];
    568                 SetCurrentConfiguration(analysis_type);
    569         }
    570 }
    571 /*}}}*/
    572486void FemModel::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    573487
    574488        /*Allocate new fields if necessary*/
    … …  
    692606        femmodel_buffer_ini=femmodel_buffer; //keep track of the initial position, so as to free later.
    693607
    694608        /*Create new FemModel by demarshalling the buffer: */
    695         //this->Marshall(&femmodel_buffer,NULL,MARSHALLING_LOAD);
    696609   LoadCheckpointFunctor* marshallhandle = new LoadCheckpointFunctor(&femmodel_buffer);
    697610   this->Marshall2(marshallhandle);
    698611        delete marshallhandle;

  • ../trunk-jpl/src/c/classes/Vertices.h

     
    3030
    3131                /*Objects virtual functions*/
    3232                Vertices* Copy();
    33                 void      Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3433                void      Marshall2(MarshallHandle* marshallhandle);
    3534
    3635                /*numerics:*/

  • ../trunk-jpl/src/c/classes/Node.h

     
    7575                void    DeepEcho();
    7676                void    Echo();
    7777                int     Id();
    78                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    7978                void    Marshall2(MarshallHandle* marshallhandle);
    8079                int     ObjectEnum();
    8180

  • ../trunk-jpl/src/c/classes/Elements/Penta.cpp

     
    140140
    141141}
    142142/*}}}*/
    143 void Penta::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    144 
    145         MARSHALLING_ENUM(PentaEnum);
    146         MARSHALLING(this->isonsurface);
    147         MARSHALLING(this->isonbase);
    148 
    149         /*Call parent classes: */
    150         ElementHook::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    151         Element::MarshallElement(pmarshalled_data,pmarshalled_data_size,marshall_direction,this->numanalyses);
    152         PentaRef::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    153 
    154         vertices = (Vertex**)this->hvertices->deliverp();
    155         material = (Material*)this->hmaterial->delivers();
    156         verticalneighbors = (Penta**)this->hneighbors->deliverp();
    157 
    158 }
    159 /*}}}*/
    160143void Penta::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    161144
    162145        int object_enum = PentaEnum;

  • ../trunk-jpl/src/c/classes/Elements/PentaRef.h

     
    2828                void GetSegmentJacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);
    2929                void GetTriaJacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);
    3030                void VerticalSegmentIndicesBase(int** pindices,int* pnumseg,int finiteelement);
    31                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*do nothing */};
    3231                void Marshall2(MarshallHandle* marshallhandle){ /*do nothing */};
    3332                int  NumberofNodes(int finiteelement);
    3433                int  PressureInterpolation(int fe_stokes);

  • ../trunk-jpl/src/c/classes/Elements/ElementHook.cpp

     
    6464
    6565}
    6666/*}}}*/
    67 void ElementHook::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    68 
    69         int i;
    70         bool* hnodesi_null=NULL; /*intermediary needed*/
    71         bool  hnodes_null=true; /*this could be NULL on empty constructor*/
    72         bool  hneighbors_null=true; /*don't deal with hneighbors, unless explicitely asked to*/
    73 
    74         _assert_(this);
    75 
    76         /*preliminary, before marshall starts: */
    77         if(marshall_direction==MARSHALLING_WRITE || marshall_direction==MARSHALLING_SIZE){
    78                 if(this->hneighbors)hneighbors_null=false;
    79                 if(this->hnodes){
    80                         hnodes_null=false;
    81                         hnodesi_null=xNew<bool>(numanalyses);
    82                         for(i=0;i<numanalyses;i++){
    83                                 if(this->hnodes[i])hnodesi_null[i]=false;
    84                                 else hnodesi_null[i]=true;
    85                         }
    86                 }
    87         }
    88 
    89         /*ok, marshall operations: */
    90         MARSHALLING_ENUM(ElementHookEnum);
    91         MARSHALLING(numanalyses);
    92         MARSHALLING(hneighbors_null);
    93         MARSHALLING(hnodes_null);
    94         MARSHALLING_DYNAMIC(hnodesi_null,bool,numanalyses);
    95 
    96         if(marshall_direction==MARSHALLING_LOAD){
    97 
    98                 if (!hnodes_null)this->hnodes = new Hook*[numanalyses];
    99                 else this->hnodes=NULL;
    100                 this->hvertices   = new Hook();
    101                 this->hmaterial   = new Hook();
    102                 if(!hneighbors_null)this->hneighbors  = new Hook();
    103                 else this->hneighbors=NULL;
    104 
    105                 /*Initialize hnodes: */
    106                 if (this->hnodes){
    107                         for(int i=0;i<this->numanalyses;i++){
    108                                 if(!hnodesi_null[i])this->hnodes[i]=new Hook();
    109                                 else this->hnodes[i]=NULL;
    110                         }
    111                 }
    112         }
    113 
    114         if (this->hnodes){
    115                 for (i=0;i<numanalyses;i++) if(this->hnodes[i])this->hnodes[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    116         }
    117         this->hvertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    118         this->hmaterial->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    119         if(this->hneighbors)this->hneighbors->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    120 
    121         /*Free ressources: */
    122         if(hnodesi_null) xDelete<bool>(hnodesi_null);
    123 
    124 }
    125 /*}}}*/
    12667void ElementHook::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    12768
    12869        int i;

  • ../trunk-jpl/src/c/classes/Elements/Penta.h

     
    3939                /*}}}*/
    4040                /*Object virtual functions definitions: {{{*/
    4141                Object *copy();
    42                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4342                void    Marshall2(MarshallHandle* marshallhandle);
    4443                int     ObjectEnum();
    4544                /*}}}*/

  • ../trunk-jpl/src/c/classes/Elements/Seg.cpp

     
    119119
    120120}
    121121/*}}}*/
    122 void Seg::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    123 
    124         MARSHALLING_ENUM(SegEnum);
    125         MARSHALLING(this->iscollapsed);
    126         MARSHALLING(this->isonsurface);
    127         MARSHALLING(this->isonbase);
    128         MARSHALLING(this->collapsed_ids[0]);
    129         MARSHALLING(this->collapsed_ids[1]);
    130 
    131         /*Call parent classes: */
    132         ElementHook::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    133         Element::MarshallElement(pmarshalled_data,pmarshalled_data_size,marshall_direction,this->numanalyses);
    134         SegRef::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    135 
    136         vertices = (Vertex**)this->hvertices->deliverp();
    137         material = (Material*)this->hmaterial->delivers();
    138 
    139 }
    140 /*}}}*/
    141122void Seg::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    142123
    143124        int object_enum = SegEnum;

  • ../trunk-jpl/src/c/classes/Elements/ElementHook.h

     
    2121                ElementHook();
    2222                ElementHook(int in_numanalyses,int material_id,int numvertices,IoModel* iomodel);
    2323                ~ElementHook();
    24                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2524                void Marshall2(MarshallHandle* marshallhandle);
    2625               
    2726                void DeepEcho();

  • ../trunk-jpl/src/c/classes/Elements/Tetra.cpp

     
    117117        return tetra;
    118118}
    119119/*}}}*/
    120 void Tetra::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    121 
    122         MARSHALLING_ENUM(TetraEnum);
    123         MARSHALLING(this->isonsurface);
    124         MARSHALLING(this->isonbase);
    125 
    126         /*Call parent classes: */
    127         ElementHook::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    128         Element::MarshallElement(pmarshalled_data,pmarshalled_data_size,marshall_direction,this->numanalyses);
    129         TetraRef::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    130 
    131         vertices = (Vertex**)this->hvertices->deliverp();
    132         material = (Material*)this->hmaterial->delivers();
    133 
    134 }
    135 /*}}}*/
    136120void Tetra::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    137121
    138122        int object_enum = TetraEnum;

  • ../trunk-jpl/src/c/classes/Elements/SegRef.h

     
    2323                void GetNodalFunctions(IssmDouble* basis,GaussSeg* gauss,int finiteelement);
    2424                void GetNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list, GaussSeg* gauss,int finiteelement);
    2525                void GetNodalFunctionsDerivativesReference(IssmDouble* dbasis,GaussSeg* gauss,int finiteelement);
    26                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*do nothing */};
    2726                void Marshall2(MarshallHandle* marshallhandle){ /*do nothing */};
    2827                int  NumberofNodes(int finiteelement);
    2928};

  • ../trunk-jpl/src/c/classes/Elements/TetraRef.h

     
    2424                void GetNodalFunctions(IssmDouble* basis,Gauss* gauss_in,int finiteelement);
    2525                void GetNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list, GaussTetra* gauss,int finiteelement);
    2626                void GetNodalFunctionsDerivativesReference(IssmDouble* dbasis,GaussTetra* gauss,int finiteelement);
    27                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*do nothing */};
    2827                void Marshall2(MarshallHandle* marshallhandle){ /*do nothing */};
    2928                int  NumberofNodes(int finiteelement);
    3029                int  PressureInterpolation(int fe_stokes);

  • ../trunk-jpl/src/c/classes/Elements/Seg.h

     
    3737                /*}}}*/
    3838                /*Object virtual functions definitions:{{{ */
    3939                Object *copy();
    40                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4140                void    Marshall2(MarshallHandle* marshallhandle);
    4241                int     ObjectEnum();
    4342                /*}}}*/

  • ../trunk-jpl/src/c/classes/Elements/Tetra.h

     
    3535                /*}}}*/
    3636                /*Object virtual functions definitions:{{{ */
    3737                Object *copy();
    38                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void    Marshall2(MarshallHandle* marshallhandle);
    4039                int     ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Elements/Element.cpp

     
    22392239        xDelete<IssmDouble>(values);
    22402240
    22412241}/*}}}*/
    2242 void       Element::MarshallElement(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction,int numanalyses){/*{{{*/
    2243 
    2244         _assert_(this);
    2245         if(marshall_direction==MARSHALLING_LOAD){
    2246                 nodes = NULL;
    2247         }
    2248 
    2249         MARSHALLING_ENUM(ElementEnum);
    2250 
    2251         MARSHALLING(id);
    2252         MARSHALLING(sid);
    2253         MARSHALLING(lid);
    2254         MARSHALLING(element_type);
    2255         MARSHALLING_DYNAMIC(element_type_list,int,numanalyses);
    2256 }
    2257 /*}}}*/
    22582242void       Element::MarshallElement2(MarshallHandle* marshallhandle,int numanalyses){/*{{{*/
    22592243
    22602244        _assert_(this);

  • ../trunk-jpl/src/c/classes/Elements/Element.h

     
    146146                void               LinearFloatingiceMeltingRate();
    147147                void               SpatialLinearFloatingiceMeltingRate();
    148148                void               MantlePlumeGeothermalFlux();
    149                 void               MarshallElement(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction,int numanalyses);
    150149                void               MarshallElement2(MarshallHandle* marshallhandle,int numanalyses);
    151150                void               MigrateGroundingLine(IssmDouble* sheet_ungrounding);
    152151                void               MismipFloatingiceMeltingRate();
    … …  
    290289                virtual void       JacobianDeterminantLine(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss)=0;
    291290                virtual void       JacobianDeterminantSurface(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss)=0;
    292291                virtual void       JacobianDeterminantTop(IssmDouble* Jdet,IssmDouble* xyz_list_base,Gauss* gauss)=0;
    293                 virtual void       Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction)=0;
    294292                virtual void       Marshall2(MarshallHandle* marshallhandle)=0;
    295293                virtual IssmDouble Masscon(IssmDouble* levelset)=0;
    296294                virtual IssmDouble MassFlux(IssmDouble* segment)=0;

  • ../trunk-jpl/src/c/classes/Elements/Tria.cpp

     
    143143        return tria;
    144144}
    145145/*}}}*/
    146 void Tria::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    147 
    148         MARSHALLING_ENUM(TriaEnum);
    149         MARSHALLING(this->iscollapsed);
    150         MARSHALLING(this->isonsurface);
    151         MARSHALLING(this->isonbase);
    152 
    153         /*Call parent classes: */
    154         ElementHook::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    155         Element::MarshallElement(pmarshalled_data,pmarshalled_data_size,marshall_direction,this->numanalyses);
    156         TriaRef::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    157 
    158         vertices = (Vertex**)this->hvertices->deliverp();
    159         material = (Material*)this->hmaterial->delivers();
    160 
    161 }
    162 /*}}}*/
    163146void Tria::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    164147
    165148        int object_enum = TriaEnum;

  • ../trunk-jpl/src/c/classes/Elements/TriaRef.h

     
    2727                void GetSegmentJacobianDeterminant(IssmDouble* Jdet, IssmDouble* xyz_list,Gauss* gauss);
    2828                void GetSegmentNodalFunctions(IssmDouble* basis,Gauss* gauss, int index1,int index2,int finiteelement);
    2929                void GetSegmentNodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list_tria,Gauss* gauss, int index1,int index2,int finiteelement);
    30                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*do nothing */};
    3130                void Marshall2(MarshallHandle* marshallhandle){ /*do nothing */};
    3231                void NodeOnEdgeIndices(int* pnumindices,int** pindices,int index,int finiteelement);
    3332                int  NumberofNodes(int finiteelement);

  • ../trunk-jpl/src/c/classes/Elements/Tria.h

     
    3838                /*}}}*/
    3939                /*Object virtual functions definitions:{{{ */
    4040                Object *copy();
    41                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4241                void    Marshall2(MarshallHandle* marshallhandle);
    4342                int     ObjectEnum();
    4443                /*}}}*/

  • ../trunk-jpl/src/c/classes/Radar.h

     
    2828                void DeepEcho(void);
    2929                void Echo(void);
    3030                int  Id(void);
    31                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3231                void Marshall2(MarshallHandle* marshallhandle);
    3332                int ObjectEnum(void);
    3433               

  • ../trunk-jpl/src/c/classes/Contour.h

     
    7878                        return id;
    7979                }
    8080                /*}}}*/
    81                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    82                         _error_("not implemented yet!");
    83                 }
    84                 /*}}}*/
    8581                void Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    8682                        _error_("not implemented yet!");
    8783                }

  • ../trunk-jpl/src/c/classes/Nodalvalue.h

     
    3333                void DeepEcho(void);
    3434                void Echo(void);
    3535                int Id(void);
    36                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3736                void Marshall2(MarshallHandle* marshallhandle);
    3837                int ObjectEnum(void);
    3938

  • ../trunk-jpl/src/c/classes/Materials/Matestar.cpp

     
    100100/*}}}*/
    101101int       Matestar::Id(void){ return mid; }/*{{{*/
    102102/*}}}*/
    103 void      Matestar::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    104 
    105         if(marshall_direction==MARSHALLING_LOAD)helement=new Hook();
    106 
    107         MARSHALLING_ENUM(MatestarEnum);
    108         MARSHALLING(mid);
    109         this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    110         this->element=(Element*)this->helement->delivers();
    111 
    112 }
    113 /*}}}*/
    114103void      Matestar::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    115104
    116105        if(marshallhandle->OperationNumber()==MARSHALLING_LOAD)helement=new Hook();

  • ../trunk-jpl/src/c/classes/Materials/Matlitho.cpp

     
    144144/*}}}*/
    145145int  Matlitho::Id(void){ return mid; }/*{{{*/
    146146/*}}}*/
    147 void Matlitho::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    148 
    149         MARSHALLING_ENUM(MatlithoEnum);
    150 
    151         MARSHALLING(numlayers);
    152         if(numlayers) {
    153                 MARSHALLING_DYNAMIC(radius,IssmDouble,numlayers+1);
    154                 MARSHALLING_DYNAMIC(viscosity,IssmDouble,numlayers);
    155                 MARSHALLING_DYNAMIC(lame_lambda,IssmDouble,numlayers);
    156                 MARSHALLING_DYNAMIC(lame_mu,IssmDouble,numlayers);
    157                 MARSHALLING_DYNAMIC(burgers_viscosity,IssmDouble,numlayers);
    158                 MARSHALLING_DYNAMIC(burgers_mu,IssmDouble,numlayers);
    159                 MARSHALLING_DYNAMIC(density,IssmDouble,numlayers);
    160                 MARSHALLING_DYNAMIC(isburgers,IssmDouble,numlayers);
    161                 MARSHALLING_DYNAMIC(issolid,IssmDouble,numlayers);
    162         }
    163         else{
    164                 radius=NULL;
    165                 viscosity=NULL;
    166                 lame_lambda=NULL;
    167                 lame_mu=NULL;
    168                 burgers_viscosity=NULL;
    169                 burgers_mu=NULL;
    170                 density=NULL;
    171                 isburgers=NULL;
    172                 issolid=NULL;
    173         }
    174 
    175 }
    176 /*}}}*/
    177147void Matlitho::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    178148
    179149        int object_enum = MatlithoEnum;

  • ../trunk-jpl/src/c/classes/Materials/Matice.cpp

     
    158158/*}}}*/
    159159int       Matice::Id(void){ return mid; }/*{{{*/
    160160/*}}}*/
    161 void      Matice::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    162 
    163         if(marshall_direction==MARSHALLING_LOAD)helement=new Hook();
    164 
    165         MARSHALLING_ENUM(MaticeEnum);
    166         MARSHALLING(mid);
    167         MARSHALLING(isdamaged);
    168         MARSHALLING(isenhanced);
    169         this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    170         this->element=(Element*)this->helement->delivers();
    171 
    172 }
    173 /*}}}*/
    174161void      Matice::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    175162
    176163        if(marshallhandle->OperationNumber()==MARSHALLING_LOAD)helement=new Hook();

  • ../trunk-jpl/src/c/classes/Materials/Matestar.h

     
    4040                void  DeepEcho();
    4141                void  Echo();
    4242                int   Id();
    43                 void  Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4443                void  Marshall2(MarshallHandle* marshallhandle);
    4544                int   ObjectEnum();
    4645                /*}}}*/

  • ../trunk-jpl/src/c/classes/Materials/Matlitho.h

     
    3636                void    DeepEcho();
    3737                void    Echo();
    3838                int     Id();
    39                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4039                void    Marshall2(MarshallHandle* marshallhandle);
    4140                int     ObjectEnum();
    4241                /*}}}*/

  • ../trunk-jpl/src/c/classes/Materials/Matice.h

     
    4444                void  DeepEcho();
    4545                void  Echo();
    4646                int   Id();
    47                 void  Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4847                void  Marshall2(MarshallHandle* marshallhandle);
    4948                int   ObjectEnum();
    5049                /*}}}*/

  • ../trunk-jpl/src/c/classes/Hook.cpp

     
    119119        }
    120120}
    121121/*}}}*/
    122 void Hook::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    123 
    124         if(marshall_direction==MARSHALLING_LOAD) reset();
    125 
    126         MARSHALLING_ENUM(HookEnum);
    127         MARSHALLING(num);
    128         if (num<=0){
    129                 /*Empty hook*/
    130                 this->ids     = NULL;
    131                 this->objects = NULL;
    132                 this->offsets = NULL;
    133                 this->num = 0;
    134         }
    135         else{
    136                 MARSHALLING_DYNAMIC(ids,int,num);
    137                 MARSHALLING_DYNAMIC(offsets,int,num);
    138                 MARSHALLING_DYNAMIC(objects,Object*,num);
    139         }
    140 
    141 }
    142 /*}}}*/
    143122void Hook::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    144123
    145124        if(marshallhandle->OperationNumber()==MARSHALLING_LOAD) reset();

  • ../trunk-jpl/src/c/classes/Misfit.h

     
    3737                void DeepEcho(void);
    3838                void Echo(void);
    3939                int Id(void);
    40                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4140                void Marshall2(MarshallHandle* marshallhandle);
    4241                int ObjectEnum(void);
    4342               

  • ../trunk-jpl/src/c/classes/Inputs/DatasetInput.h

     
    3333                void    DeepEcho();
    3434                void    Echo();
    3535                int     Id();
    36                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3736                void    Marshall2(MarshallHandle* marshallhandle);
    3837                int     ObjectEnum();
    3938                void    SetTriaInput(int interp_in,int numinds,int* rows,IssmDouble* values_in);

  • ../trunk-jpl/src/c/classes/Inputs/IntInput.cpp

     
    5353/*}}}*/
    5454int  IntInput::Id(void){ return -1; }/*{{{*/
    5555/*}}}*/
    56 void IntInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    57 
    58         MARSHALLING_ENUM(IntInputEnum);
    59 
    60         MARSHALLING(this->size);
    61         if(this->size > 0){
    62                 MARSHALLING_DYNAMIC(this->values,int,this->size)
    63         }
    64         else this->values = NULL;
    65 
    66 }
    67 /*}}}*/
    6856void IntInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6957
    7058        int object_enum = IntInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/BoolInput.cpp

     
    5454/*}}}*/
    5555int  BoolInput::Id(void){ return -1; }/*{{{*/
    5656/*}}}*/
    57 void BoolInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    58 
    59         MARSHALLING_ENUM(BoolInputEnum);
    60         MARSHALLING(this->size);
    61         if(this->size > 0){
    62                 MARSHALLING_DYNAMIC(this->values,bool,this->size)
    63         }
    64         else this->values = NULL;
    65 
    66 }
    67 /*}}}*/
    6857void BoolInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6958
    7059        int object_enum = BoolInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/ElementInput.h

     
    2828                virtual void    DeepEcho()=0;
    2929                virtual void    Echo()=0;
    3030                virtual int     Id()=0;
    31                 virtual void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction)=0;
    3231                virtual void    Marshall2(MarshallHandle* marshallhandle)=0;
    3332                virtual int     ObjectEnum()=0;
    3433                /*Other*/

  • ../trunk-jpl/src/c/classes/Inputs/TriaInput.cpp

     
    111111int  TriaInput::Id(void){/*{{{*/
    112112        return -1;
    113113}/*}}}*/
    114 void TriaInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    115 
    116         MARSHALLING_ENUM(TriaInputEnum);
    117         MARSHALLING(this->numberofelements_local);
    118         MARSHALLING(this->numberofvertices_local);
    119         MARSHALLING(this->interpolation);
    120         MARSHALLING(this->M);
    121         MARSHALLING(this->N);
    122         this->isserved = false;
    123         this->isserved_collapsed = 0;
    124         if(this->M*this->N){
    125                 MARSHALLING_DYNAMIC(this->values,IssmDouble,this->M*this->N);
    126         }
    127         else this->values = NULL;
    128 
    129         if(marshall_direction == MARSHALLING_LOAD){
    130                 this->element_values = xNewZeroInit<IssmDouble>(TriaRef::NumberofNodes(this->interpolation));
    131         }
    132 
    133 }
    134 /*}}}*/
    135114void TriaInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    136115
    137116        int object_enum = TriaInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/IntInput.h

     
    2121                void    DeepEcho();
    2222                void    Echo();
    2323                int     Id();
    24                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2524                void    Marshall2(MarshallHandle* marshallhandle);
    2625                int     ObjectEnum();
    2726                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/BoolInput.h

     
    2121                void    DeepEcho();
    2222                void    Echo();
    2323                int     Id();
    24                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2524                void    Marshall2(MarshallHandle* marshallhandle);
    2625                int     ObjectEnum();
    2726                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/Inputs.cpp

     
    7878        return;
    7979}
    8080/*}}}*/
    81 void Inputs::Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    82 
    83         int obj_enum=-1;
    84         int num_inputs=0;
    85         int index;
    86 
    87         MARSHALLING_ENUM(InputsEnum);
    88 
    89         if(marshall_direction==MARSHALLING_WRITE || marshall_direction==MARSHALLING_SIZE){
    90 
    91                 /*Marshall num_inputs first*/
    92                 for(int i=0;i<NUMINPUTS;i++){
    93                         if(this->inputs[i]) num_inputs++;
    94                 }
    95                 MARSHALLING(num_inputs);
    96 
    97                 /*Marshall Parameters one by one now*/
    98                 for(int i=0;i<NUMINPUTS;i++){
    99                         if(this->inputs[i]){
    100                                 obj_enum = this->inputs[i]->ObjectEnum();
    101                                 MARSHALLING(i);
    102                                 MARSHALLING(obj_enum);
    103                                 this->inputs[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    104                         }
    105                 }
    106         }
    107         else{
    108 
    109                 /*Get number of inputs marshalled*/
    110                 MARSHALLING(num_inputs);
    111 
    112                 /*Recover input2eters one by one*/
    113                 for(int i=0;i<num_inputs;i++){
    114 
    115                         /*Recover enum of object first: */
    116                         MARSHALLING(index);
    117                         MARSHALLING(obj_enum);
    118 
    119                         if(obj_enum==BoolInputEnum){
    120                                 BoolInput* boolinput2=new BoolInput();
    121                                 boolinput2->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    122                                 this->inputs[index]=boolinput2;
    123                         }
    124                         else if(obj_enum==IntInputEnum){
    125                                 IntInput* intinput2=new IntInput();
    126                                 intinput2->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    127                                 this->inputs[index]=intinput2;
    128                         }
    129                         else if(obj_enum==TriaInputEnum){
    130                                 TriaInput* triainput2=new TriaInput();
    131                                 triainput2->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    132                                 this->inputs[index]=triainput2;
    133                         }
    134                         else if(obj_enum==PentaInputEnum){
    135                                 PentaInput* pentainput2=new PentaInput();
    136                                 pentainput2->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    137                                 this->inputs[index]=pentainput2;
    138                         }
    139                         else{
    140                                 _error_("input "<<EnumToStringx(obj_enum)<<" not supported");
    141                         }
    142                 }
    143         }
    144 }
    145 /*}}}*/
    14681void Inputs::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    14782
    14883        int num_inputs=0;

  • ../trunk-jpl/src/c/classes/Inputs/TriaInput.h

     
    2121                void    DeepEcho();
    2222                void    Echo();
    2323                int     Id();
    24                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2524                void    Marshall2(MarshallHandle* marshallhandle);
    2625                int     ObjectEnum();
    2726                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/TransientInput.cpp

     
    116116/*}}}*/
    117117int  TransientInput::Id(void){ return -1; }/*{{{*/
    118118/*}}}*/
    119 void TransientInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    120 
    121         if (marshall_direction == MARSHALLING_LOAD){
    122                 _error_("not implmented");
    123                 //inputs = new Inputs();
    124         }
    125 
    126         MARSHALLING_ENUM(TransientInputEnum);
    127 
    128         MARSHALLING(enum_type);
    129         MARSHALLING(numtimesteps);
    130         MARSHALLING_DYNAMIC(this->timesteps,IssmDouble,numtimesteps);
    131         //inputs->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    132         _error_("not implemented");
    133 }
    134 /*}}}*/
    135119void TransientInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    136120
    137121        if (marshallhandle->OperationNumber() == MARSHALLING_LOAD){

  • ../trunk-jpl/src/c/classes/Inputs/PentaInput.cpp

     
    125125int  PentaInput::Id(void){/*{{{*/
    126126        return -1;
    127127}/*}}}*/
    128 void PentaInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    129 
    130         MARSHALLING_ENUM(PentaInputEnum);
    131         MARSHALLING(this->numberofelements_local);
    132         MARSHALLING(this->numberofvertices_local);
    133         MARSHALLING(this->interpolation);
    134         MARSHALLING(this->M);
    135         MARSHALLING(this->N);
    136         this->isserved = false;
    137         this->isserved_collapsed = 0;
    138         if(this->M*this->N){
    139                 MARSHALLING_DYNAMIC(this->values,IssmDouble,this->M*this->N);
    140         }
    141         else this->values = NULL;
    142 
    143         if(marshall_direction == MARSHALLING_LOAD){
    144                 this->element_values = xNewZeroInit<IssmDouble>(PentaRef::NumberofNodes(this->interpolation));
    145         }
    146 }
    147 /*}}}*/
    148128void PentaInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    149129
    150130        int object_enum = PentaInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/Inputs.h

     
    6262                ElementInput*   GetControlInputData(int enum_type,const char* data);
    6363                DatasetInput*   GetDatasetInput(int enum_type);
    6464                ControlInput*   GetControlInput(int enum_type);
    65                 void  Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction);
    6665                void  Marshall2(MarshallHandle* marshallhandle);
    6766                int   GetInputObjectEnum(int enum_type);
    6867                void  GetInputValue(bool* pvalue,int enum_in,int index);

  • ../trunk-jpl/src/c/classes/Inputs/DoubleInput.cpp

     
    5353/*}}}*/
    5454int  DoubleInput::Id(void){ return -1; }/*{{{*/
    5555/*}}}*/
    56 void DoubleInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    57 
    58         MARSHALLING_ENUM(DoubleInputEnum);
    59 
    60         MARSHALLING(this->size);
    61         if(this->size > 0){
    62                 MARSHALLING_DYNAMIC(this->values,IssmDouble,this->size)
    63         }
    64         else this->values = NULL;
    65 
    66 }
    67 /*}}}*/
    6856void DoubleInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6957
    7058        int object_enum = DoubleInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/TransientInput.h

     
    4242                void    DeepEcho();
    4343                void    Echo();
    4444                int     Id();
    45                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4645                void    Marshall2(MarshallHandle* marshallhandle);
    4746                int     ObjectEnum();
    4847                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/PentaInput.h

     
    2020                void    DeepEcho();
    2121                void    Echo();
    2222                int     Id();
    23                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2423                void    Marshall2(MarshallHandle* marshallhandle);
    2524                int     ObjectEnum();
    2625                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/ArrayInput.cpp

     
    7575int  ArrayInput::Id(void){/*{{{*/
    7676        return -1;
    7777}/*}}}*/
    78 void ArrayInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    79 
    80         MARSHALLING_ENUM(ArrayInputEnum);
    81         MARSHALLING(this->numberofelements_local);
    82         if(this->numberofelements_local){
    83                 MARSHALLING_DYNAMIC(this->N,int,this->numberofelements_local);
    84                 for(int i=0;i<this->numberofelements_local;i++){
    85                         if(this->values[i]){
    86                                 MARSHALLING_DYNAMIC(this->values[i],IssmDouble,this->N[i]);
    87                         }
    88                 }
    89         }
    90         else{
    91                 this->N      = NULL;
    92                 this->values = NULL;
    93         }
    94 
    95 }
    96 /*}}}*/
    9778void ArrayInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    9879
    9980        int object_enum = ArrayInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/SegInput.cpp

     
    107107int  SegInput::Id(void){/*{{{*/
    108108        return -1;
    109109}/*}}}*/
    110 void SegInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    111 
    112         MARSHALLING_ENUM(SegInputEnum);
    113         MARSHALLING(this->numberofelements_local);
    114         MARSHALLING(this->numberofvertices_local);
    115         MARSHALLING(this->interpolation);
    116         MARSHALLING(this->M);
    117         MARSHALLING(this->N);
    118         this->isserved = false;
    119         if(this->M*this->N){
    120                 MARSHALLING_DYNAMIC(this->values,IssmDouble,this->M*this->N);
    121         }
    122         else this->values = NULL;
    123 
    124         if(marshall_direction == MARSHALLING_LOAD){
    125                 this->element_values = xNewZeroInit<IssmDouble>(SegRef::NumberofNodes(this->interpolation));
    126         }
    127 
    128 }
    129 /*}}}*/
    130110void SegInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    131111
    132112        int object_enum = SegInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/DoubleInput.h

     
    2121                void    DeepEcho();
    2222                void    Echo();
    2323                int     Id();
    24                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2524                void    Marshall2(MarshallHandle* marshallhandle);
    2625                int     ObjectEnum();
    2726                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/ControlInput.cpp

     
    117117/*}}}*/
    118118int  ControlInput::Id(void){ return -1; }/*{{{*/
    119119/*}}}*/
    120 void ControlInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    121 
    122         MARSHALLING_ENUM(ControlInputEnum);
    123         _error_("Not implemented");
    124 }
    125 /*}}}*/
    126120void ControlInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    127121
    128122        int object_enum = ControlInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/ArrayInput.h

     
    2222                void    DeepEcho();
    2323                void    Echo();
    2424                int     Id();
    25                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2625                void    Marshall2(MarshallHandle* marshallhandle);
    2726                int     ObjectEnum();
    2827                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/SegInput.h

     
    1818                void    DeepEcho();
    1919                void    Echo();
    2020                int     Id();
    21                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2221                void    Marshall2(MarshallHandle* marshallhandle);
    2322                int     ObjectEnum();
    2423                /*}}}*/

  • ../trunk-jpl/src/c/classes/Inputs/Input.h

     
    22 * \brief abstract class for Input object
    33 */
    44
    5 #ifndef _INPUT2_H_
    6 #define _INPUT2_H_
     5#ifndef _INPUT_H_
     6#define _INPUT_H_
    77
    88/*Headers:*/
    99#include "../../shared/shared.h"

  • ../trunk-jpl/src/c/classes/Inputs/DatasetInput.cpp

     
    8080/*}}}*/
    8181int  DatasetInput::Id(void){ return -1; }/*{{{*/
    8282/*}}}*/
    83 void DatasetInput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    84 
    85         MARSHALLING_ENUM(DatasetInputEnum);
    86 
    87         MARSHALLING(numids);
    88         MARSHALLING(this->numberofelements_local);
    89         MARSHALLING(this->numberofvertices_local);
    90         MARSHALLING_DYNAMIC(ids,int,numids);
    91         //if (marshall_direction == MARSHALLING_LOAD) inputs = new Inputs();
    92         //inputs->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    93         _error_("not implemented");
    94 
    95 }
    96 /*}}}*/
    9783void DatasetInput::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    9884
    9985        int object_enum = DatasetInputEnum;

  • ../trunk-jpl/src/c/classes/Inputs/ControlInput.h

     
    3535                void   DeepEcho();
    3636                void   Echo();
    3737                int    Id();
    38                 void   Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void   Marshall2(MarshallHandle* marshallhandle);
    4039                int    ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/DependentObject.h

     
    3333                void  Echo();
    3434                int   Id();
    3535                int   ObjectEnum();
    36                 void  Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){_error_("not implemented yet!"); };
    3736                void  Marshall2(MarshallHandle* marshallhandle){_error_("not implemented yet!"); };
    3837
    3938                /*DependentObject methods: */

  • ../trunk-jpl/src/c/classes/Numberedcostfunction.h

     
    3131                void            DeepEcho(void);
    3232                void            Echo(void);
    3333                int             Id(void);
    34                 void            Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3534                void            Marshall2(MarshallHandle* marshallhandle);
    3635                int             ObjectEnum(void);
    3736

  • ../trunk-jpl/src/c/classes/Masscon.h

     
    7272                        return -1;
    7373                }
    7474                /*}}}*/
    75                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    76                         _error_("not implemented yet!");
    77                 }
    78                 /*}}}*/
    7975                void Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    8076                        _error_("not implemented yet!");
    8177                }

  • ../trunk-jpl/src/c/classes/kriging/PowerVariogram.h

     
    2525                void  DeepEcho(){_error_("Not implemented yet");};
    2626                void  Echo();
    2727                int   Id(){_error_("Not implemented yet");};
    28                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    2928                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!"); };
    3029                int   ObjectEnum(){_error_("Not implemented yet");};
    3130

  • ../trunk-jpl/src/c/classes/kriging/Quadtree.h

     
    2929                                void    DeepEcho()  {_error_("not implemented yet"); };
    3030                                void    Echo();
    3131                                int     Id()        {_error_("not implemented yet"); };
    32                                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
    3332                                void    Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3433                                int     ObjectEnum(){_error_("not implemented yet"); };
    3534

  • ../trunk-jpl/src/c/classes/kriging/GaussianVariogram.h

     
    2626                void  DeepEcho(){_error_("Not implemented yet");};
    2727                void  Echo();
    2828                int   Id(){_error_("Not implemented yet");};
    29                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    3029                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!"); };
    3130                int   ObjectEnum(){_error_("Not implemented yet");};
    3231

  • ../trunk-jpl/src/c/classes/kriging/SphericalVariogram.h

     
    2525                void  DeepEcho(){_error_("Not implemented yet");};
    2626                void  Echo();
    2727                int   Id(){_error_("Not implemented yet");};
    28                 void  Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    2928                void  Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!"); };
    3029                int   ObjectEnum(){_error_("Not implemented yet");};
    3130

  • ../trunk-jpl/src/c/classes/kriging/Observation.h

     
    3030                void    Echo();
    3131                int     Id()        {_error_("Not implemented yet"); };
    3232                void    print() const;
    33                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
    3433                void    Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3534                int     ObjectEnum(){_error_("Not implemented yet"); };
    3635

  • ../trunk-jpl/src/c/classes/kriging/ExponentialVariogram.h

     
    2525                void  DeepEcho(){_error_("Not implemented yet");};
    2626                void  Echo();
    2727                int   Id(){_error_("Not implemented yet");};
    28                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    2928                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!"); };
    3029                int   ObjectEnum(){_error_("Not implemented yet");};
    3130

  • ../trunk-jpl/src/c/classes/Options/Option.h

     
    2424                virtual void  DeepEcho(char  *indent)=0;
    2525                virtual void  Echo()= 0;
    2626                int           Id(){_error_("Not implemented yet"); };
    27                 void          Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    2827                void          Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!"); };
    2928                int           ObjectEnum(){return OptionEnum;};
    3029

  • ../trunk-jpl/src/c/classes/Cfsurfacelogvel.cpp

     
    7373        return -1;
    7474}
    7575/*}}}*/
    76 void Cfsurfacelogvel::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    77         _error_("not implemented yet!");
    78 }
    79 /*}}}*/
    8076void Cfsurfacelogvel::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    8177        _error_("not implemented yet!");
    8278}

  • ../trunk-jpl/src/c/classes/Massconaxpby.h

     
    8383                        return -1;
    8484                }
    8585                /*}}}*/
    86                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    87                         _error_("not implemented yet!");
    88                 }
    89                 /*}}}*/
    9086                void Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    9187                        _error_("not implemented yet!");
    9288                }

  • ../trunk-jpl/src/c/classes/Nodes.h

     
    3535
    3636                /*Objects virtual functions*/
    3737                Nodes* Copy();
    38                 void   Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void   Marshall2(MarshallHandle* marshallhandle);
    4039
    4140                /*numerics*/

  • ../trunk-jpl/src/c/classes/Regionaloutput.cpp

     
    6262        return -1;
    6363}
    6464/*}}}*/
    65 void Regionaloutput::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    66         _error_("not implemented yet!");
    67 }
    68 /*}}}*/
    6965void Regionaloutput::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    7066        _error_("not implemented yet!");
    7167}

  • ../trunk-jpl/src/c/classes/Loads/Riftfront.h

     
    5959                void     DeepEcho();
    6060                void     Echo();
    6161                int      Id();
    62                 void            Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    6362                void            Marshall2(MarshallHandle* marshallhandle);
    6463                int      ObjectEnum();
    6564                /*}}}*/

  • ../trunk-jpl/src/c/classes/Loads/Numericalflux.h

     
    4343                void    DeepEcho();
    4444                void    Echo();
    4545                int     Id();
    46                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4746                void    Marshall2(MarshallHandle* marshallhandle);
    4847                int     ObjectEnum();
    4948                /*}}}*/

  • ../trunk-jpl/src/c/classes/Loads/Pengrid.cpp

     
    118118/*}}}*/
    119119int     Pengrid::Id(void){ return id; }/*{{{*/
    120120/*}}}*/
    121 void    Pengrid::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    122 
    123         _assert_(this);
    124 
    125         /*ok, marshall operations: */
    126         MARSHALLING_ENUM(PengridEnum);
    127         MARSHALLING(id);
    128 
    129         if(marshall_direction==MARSHALLING_LOAD){
    130                 this->hnode      = new Hook();
    131                 this->helement   = new Hook();
    132         }
    133 
    134         this->hnode->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    135         this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    136 
    137         /*corresponding fields*/
    138         node   =(Node*)this->hnode->delivers();
    139         element=(Element*)this->helement->delivers();
    140 
    141         MARSHALLING(active);
    142         MARSHALLING(zigzag_counter);
    143 
    144 }
    145 /*}}}*/
    146121void    Pengrid::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    147122
    148123        _assert_(this);

  • ../trunk-jpl/src/c/classes/Loads/Pengrid.h

     
    5050                void  DeepEcho();
    5151                void  Echo();
    5252                int   Id();
    53                 void  Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    5453                void  Marshall2(MarshallHandle* marshallhandle);
    5554                int   ObjectEnum();
    5655                /*}}}*/

  • ../trunk-jpl/src/c/classes/Loads/Penpair.cpp

     
    8383/*}}}*/
    8484int     Penpair::Id(void){ return id; }/*{{{*/
    8585/*}}}*/
    86 void    Penpair::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    87 
    88         _assert_(this);
    89 
    90         /*ok, marshall operations: */
    91         MARSHALLING_ENUM(PenpairEnum);
    92         MARSHALLING(id);
    93 
    94         if(marshall_direction==MARSHALLING_LOAD){
    95                 this->hnodes = new Hook();
    96         }
    97         this->hnodes->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    98 
    99         /*corresponding fields*/
    100         nodes = (Node**)this->hnodes->deliverp();
    101 
    102 }
    103 /*}}}*/
    10486void    Penpair::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    10587
    10688        _assert_(this);

  • ../trunk-jpl/src/c/classes/Loads/Neumannflux.cpp

     
    124124        return id;
    125125}
    126126/*}}}*/
    127 void    Neumannflux::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    128 
    129         _assert_(this);
    130 
    131         /*ok, marshall operations: */
    132         MARSHALLING_ENUM(NeumannfluxEnum);
    133         MARSHALLING(id);
    134 
    135         if(marshall_direction==MARSHALLING_LOAD){
    136                 this->hnodes      = new Hook();
    137                 this->hvertices   = new Hook();
    138                 this->helement    = new Hook();
    139         }
    140 
    141         this->hnodes->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    142         this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    143         this->hvertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    144 
    145         /*corresponding fields*/
    146         nodes    =(Node**)this->hnodes->deliverp();
    147         vertices =(Vertex**)this->hvertices->deliverp();
    148         element  =(Element*)this->helement->delivers();
    149 
    150 }
    151 /*}}}*/
    152127void    Neumannflux::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    153128
    154129        _assert_(this);

  • ../trunk-jpl/src/c/classes/Loads/Loads.cpp

     
    7272        return output;
    7373}
    7474/*}}}*/
    75 void  Loads::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    76 
    77         int num_procs=IssmComm::GetSize();
    78         int test = num_procs;
    79         MARSHALLING_ENUM(LoadsEnum);
    80         MARSHALLING(numrifts);
    81         MARSHALLING(numpenalties);
    82 
    83         DataSet::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    84 }
    85 /*}}}*/
    8675void  Loads::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8776
    8877        int object_enum = LoadsEnum;

  • ../trunk-jpl/src/c/classes/Loads/Moulin.cpp

     
    108108/*}}}*/
    109109int     Moulin::Id(void){ return id; }/*{{{*/
    110110/*}}}*/
    111 void    Moulin::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    112 
    113         _assert_(this);
    114 
    115         /*ok, marshall operations: */
    116         MARSHALLING_ENUM(MoulinEnum);
    117         MARSHALLING(id);
    118 
    119         if(marshall_direction==MARSHALLING_LOAD){
    120                 this->hnode      = new Hook();
    121                 this->hvertex      = new Hook();
    122                 this->helement   = new Hook();
    123         }
    124 
    125         this->hnode->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    126         this->hvertex->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    127         this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    128 
    129         /*corresponding fields*/
    130         node   =(Node*)this->hnode->delivers();
    131         vertex =(Vertex*)this->hvertex->delivers();
    132         element=(Element*)this->helement->delivers();
    133 }
    134 /*}}}*/
    135111void    Moulin::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    136112
    137113        _assert_(this);

  • ../trunk-jpl/src/c/classes/Loads/Penpair.h

     
    3333                void     DeepEcho();
    3434                void     Echo();
    3535                int      Id();
    36                 void     Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3736                void     Marshall2(MarshallHandle* marshallhandle);
    3837                int      ObjectEnum();
    3938                /*}}}*/

  • ../trunk-jpl/src/c/classes/Loads/Neumannflux.h

     
    4141                void    DeepEcho();
    4242                void    Echo();
    4343                int     Id();
    44                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4544                void    Marshall2(MarshallHandle* marshallhandle);
    4645                int     ObjectEnum();
    4746                /*}}}*/

  • ../trunk-jpl/src/c/classes/Loads/Loads.h

     
    2626
    2727                /*Objects virtual functions*/
    2828                Loads* Copy();
    29                 void   Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3029                void   Marshall2(MarshallHandle* marshallhandle);
    3130
    3231                /*numerics*/

  • ../trunk-jpl/src/c/classes/Loads/Channel.cpp

     
    145145        return id;
    146146}
    147147/*}}}*/
    148 void    Channel::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    149 
    150         _assert_(this);
    151 
    152         /*ok, marshall operations: */
    153         MARSHALLING_ENUM(ChannelEnum);
    154         MARSHALLING(id);
    155         MARSHALLING(S);
    156 
    157         if(marshall_direction==MARSHALLING_LOAD){
    158                 this->hnodes      = new Hook();
    159                 this->hvertices   = new Hook();
    160                 this->helement    = new Hook();
    161         }
    162 
    163         this->hnodes->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    164         this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    165         this->hvertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    166 
    167         /*corresponding fields*/
    168         nodes    =(Node**)this->hnodes->deliverp();
    169         vertices =(Vertex**)this->hvertices->deliverp();
    170         element  =(Element*)this->helement->delivers();
    171 
    172 }
    173 /*}}}*/
    174148void    Channel::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    175149
    176150        _assert_(this);

  • ../trunk-jpl/src/c/classes/Loads/Moulin.h

     
    4848                void  DeepEcho();
    4949                void  Echo();
    5050                int   Id();
    51                 void  Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    5251                void  Marshall2(MarshallHandle* marshallhandle);
    5352                int   ObjectEnum();
    5453                /*}}}*/

  • ../trunk-jpl/src/c/classes/Loads/Riftfront.cpp

     
    186186/*}}}*/
    187187int     Riftfront::Id(void){ return id; }/*{{{*/
    188188/*}}}*/
    189 void    Riftfront::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    190 
    191         _assert_(this);
    192 
    193         /*ok, marshall operations: */
    194         MARSHALLING_ENUM(RiftfrontEnum);
    195         MARSHALLING(id);
    196         MARSHALLING(type);
    197         MARSHALLING(fill);
    198         MARSHALLING(friction);
    199         MARSHALLING(fractionincrement);
    200         MARSHALLING(shelf);
    201 
    202         if(marshall_direction==MARSHALLING_LOAD){
    203                 this->hnodes      = new Hook();
    204                 this->hvertices      = new Hook();
    205                 this->helements   = new Hook();
    206         }
    207 
    208         this->hnodes->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    209         this->hvertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    210         this->helements->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    211 
    212         /*corresponding fields*/
    213         nodes     =(Node**)this->hnodes->deliverp();
    214         vertices  =(Vertex**)this->hvertices->deliverp();
    215         elements  =(Element**)this->helements->deliverp();
    216 
    217         MARSHALLING(penalty_lock);
    218         MARSHALLING(active);
    219         MARSHALLING(frozen);
    220         MARSHALLING(state);
    221         MARSHALLING(counter);
    222         MARSHALLING(prestable);
    223         MARSHALLING(material_converged);
    224         MARSHALLING(normal[0]);
    225         MARSHALLING(normal[1]);
    226         MARSHALLING(length);
    227         MARSHALLING(fraction);
    228 
    229 }
    230 /*}}}*/
    231189void    Riftfront::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    232190
    233191        _assert_(this);

  • ../trunk-jpl/src/c/classes/Loads/Channel.h

     
    4848                void    DeepEcho();
    4949                void    Echo();
    5050                int     Id();
    51                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    5251                void    Marshall2(MarshallHandle* marshallhandle);
    5352                int     ObjectEnum();
    5453                /*}}}*/

  • ../trunk-jpl/src/c/classes/Loads/Numericalflux.cpp

     
    200200        return id;
    201201}
    202202/*}}}*/
    203 void    Numericalflux::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    204 
    205         _assert_(this);
    206 
    207         /*ok, marshall operations: */
    208         MARSHALLING_ENUM(NumericalfluxEnum);
    209         MARSHALLING(id);
    210         MARSHALLING(flux_type);
    211         MARSHALLING(flux_degree);
    212 
    213         if(marshall_direction==MARSHALLING_LOAD){
    214                 this->hnodes      = new Hook();
    215                 this->hvertices   = new Hook();
    216                 this->helement    = new Hook();
    217         }
    218 
    219         this->hnodes->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    220         this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    221         this->hvertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    222 
    223         /*corresponding fields*/
    224         nodes    =(Node**)this->hnodes->deliverp();
    225         vertices =(Vertex**)this->hvertices->deliverp();
    226         element  =(Element*)this->helement->delivers();
    227 
    228 }
    229 /*}}}*/
    230203void    Numericalflux::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    231204
    232205        _assert_(this);

  • ../trunk-jpl/src/c/classes/Cfdragcoeffabsgrad.h

     
    3333                void DeepEcho(void);
    3434                void Echo(void);
    3535                int Id(void);
    36                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3736                void Marshall2(MarshallHandle* marshallhandle);
    3837                int ObjectEnum(void);
    3938               

  • ../trunk-jpl/src/c/classes/Vertex.h

     
    4545                int   Id();
    4646                int   ObjectEnum();
    4747                Object* copy();
    48                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4948                void Marshall2(MarshallHandle* marshallhandle);
    5049
    5150                /*}}}*/

  • ../trunk-jpl/src/c/classes/Cfsurfacesquare.cpp

     
    8181        return -1;
    8282}
    8383/*}}}*/
    84 void Cfsurfacesquare::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    85         _error_("not implemented yet!");
    86 }
    87 /*}}}*/
    8884void Cfsurfacesquare::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    8985        _error_("not implemented yet!");
    9086}

  • ../trunk-jpl/src/c/classes/ExternalResults/GenericExternalResult.h

     
    5252                        fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
    5353                        fwrite(&step,sizeof(int),1,fid);
    5454                } /*}}}*/
    55                 void GenericMarshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     55                void GenericMarshall(MarshallHandle* marshallhandle){/*{{{*/
    5656
    57                         MARSHALLING_ENUM(this->ObjectEnum());
    58                         MARSHALLING(id);
    59                         MARSHALLING(step);
    60                         MARSHALLING(time);
     57                        int object_enum = this->ObjectEnum();
     58                        marshallhandle->call(object_enum);
     59                        marshallhandle->call(this->id);
     60                        marshallhandle->call(this->step);
     61                        marshallhandle->call(this->time);
    6162
    6263                        /*Marshal result name*/
    6364                        int size = 0;
    64                         if(marshall_direction==MARSHALLING_WRITE || marshall_direction == MARSHALLING_SIZE) size=strlen(result_name)+1;
    65                         MARSHALLING(size);
    66                         MARSHALLING_DYNAMIC(result_name,char,size);
     65                        if(marshallhandle->OperationNumber()==MARSHALLING_WRITE || marshallhandle->OperationNumber() == MARSHALLING_SIZE) size=strlen(result_name)+1;
     66                        marshallhandle->call(size);
     67                        marshallhandle->call(this->result_name,size);
    6768
    6869                        /*Marshall value*/
    6970                        this->value=0;
    7071                        bool isnull=true;
    71                         if(marshall_direction==MARSHALLING_WRITE || marshall_direction == MARSHALLING_SIZE){
     72                        if(marshallhandle->OperationNumber()==MARSHALLING_WRITE || marshallhandle->OperationNumber() == MARSHALLING_SIZE){
    7273                                if(value) isnull=false;
    7374                        }
    74                         MARSHALLING(isnull);
    75                         if(!isnull){MARSHALLING(value);}
     75                        marshallhandle->call(isnull);
     76                        if(!isnull){
     77                                marshallhandle->call(this->value);
     78                        }
    7679                }  /*}}}*/
    7780
    7881                /*GenericExternalResult constructors and  destructors*/
    … …  
    166169                int ObjectEnum(void){ /*{{{*/
    167170                        _error_("template ObjectEnum not implemented for this ResultType\n");
    168171                } /*}}}*/
    169                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    170                         _error_("not implemented yet!");
    171                 }
    172                 /*}}}*/
    173172                void Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    174173                        _error_("not implemented yet!");
    175174                }
    … …  
    238237template <> inline int GenericExternalResult<bool>::ObjectEnum(void){ /*{{{*/
    239238        return BoolExternalResultEnum;
    240239} /*}}}*/
    241 template <> inline void GenericExternalResult<bool>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     240template <> inline void GenericExternalResult<bool>::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    242241
    243         this->GenericMarshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     242        this->GenericMarshall(marshallhandle);
    244243
    245244}  /*}}}*/
    246245
    … …  
    255254template <> inline int GenericExternalResult<int>::ObjectEnum(void){ /*{{{*/
    256255        return IntExternalResultEnum;
    257256} /*}}}*/
    258 template <> inline void GenericExternalResult<int>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    259 
    260         this->GenericMarshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    261 
     257template <> inline void GenericExternalResult<int>::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
     258        this->GenericMarshall(marshallhandle);
    262259}  /*}}}*/
    263260
    264261/*Specific instantiations for double: */
    … …  
    275272template <> inline double GenericExternalResult<double>::GetValue(void){ /*{{{*/
    276273        return value;
    277274} /*}}}*/
    278 template <> inline void GenericExternalResult<double>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    279 
    280         this->GenericMarshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    281 
     275template <> inline void GenericExternalResult<double>::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
     276        this->GenericMarshall(marshallhandle);
    282277}  /*}}}*/
    283278
    284279/*Specific instantiations for char*: */
    … …  
    346341template <> inline int GenericExternalResult<char*>::ObjectEnum(void){ /*{{{*/
    347342        return StringExternalResultEnum;
    348343} /*}}}*/
    349 template <> inline void GenericExternalResult<char*>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     344template <> inline void GenericExternalResult<char*>::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    350345
    351346        int size = 0;
    352347
    353         if(marshall_direction==MARSHALLING_WRITE || marshall_direction == MARSHALLING_SIZE)size=strlen(value)+1;
     348        if(marshallhandle->OperationNumber()==MARSHALLING_WRITE || marshallhandle->OperationNumber() == MARSHALLING_SIZE)size=strlen(value)+1;
    354349
    355         MARSHALLING(id);
    356         MARSHALLING(result_name);
    357         MARSHALLING(size);
    358         MARSHALLING_DYNAMIC(value,char,size);
    359         MARSHALLING(step);
    360         MARSHALLING(time);
     350        marshallhandle->call(this->id);
     351        marshallhandle->call(this->result_name);
     352        marshallhandle->call(size);
     353        marshallhandle->call(this->value,size);
     354        marshallhandle->call(this->step);
     355        marshallhandle->call(this->time);
    361356
    362357}  /*}}}*/
    363358
    … …  
    476471template <> inline int GenericExternalResult<int*>::ObjectEnum(void){ /*{{{*/
    477472        return IntMatExternalResultEnum;
    478473} /*}}}*/
    479 template <> inline void GenericExternalResult<int*>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     474template <> inline void GenericExternalResult<int*>::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    480475
    481         MARSHALLING_ENUM(this->ObjectEnum());
     476        int object_enum = this->ObjectEnum();
     477        marshallhandle->call(object_enum);
    482478
    483         MARSHALLING(id);
    484         MARSHALLING(result_name);
    485         MARSHALLING(M);
    486         MARSHALLING(N);
    487         MARSHALLING_DYNAMIC(value,int,M*N);
    488         MARSHALLING(step);
    489         MARSHALLING(time);
     479        marshallhandle->call(this->id);
     480        marshallhandle->call(this->result_name);
     481        marshallhandle->call(this->M);
     482        marshallhandle->call(this->N);
     483        marshallhandle->call(this->value,M*N);
     484        marshallhandle->call(this->step);
     485        marshallhandle->call(this->time);
    490486
    491487}  /*}}}*/
    492488
    … …  
    608604template <> inline double* GenericExternalResult<IssmPDouble*>::GetValues(void){ /*{{{*/
    609605        return value;
    610606} /*}}}*/
    611 template <> inline void GenericExternalResult<IssmPDouble*>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     607template <> inline void GenericExternalResult<IssmPDouble*>::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    612608
    613         MARSHALLING_ENUM(this->ObjectEnum());
     609        int object_enum = this->ObjectEnum();
     610        marshallhandle->call(object_enum);
    614611
    615         MARSHALLING(id);
    616         MARSHALLING(result_name);
    617         MARSHALLING(M);
    618         MARSHALLING(N);
    619         MARSHALLING_DYNAMIC(value,IssmPDouble,M*N);
    620         MARSHALLING(step);
    621         MARSHALLING(time);
     612        marshallhandle->call(this->id);
     613        marshallhandle->call(this->result_name);
     614        marshallhandle->call(this->M);
     615        marshallhandle->call(this->N);
     616        marshallhandle->call(this->value,M*N);
     617        marshallhandle->call(this->step);
     618        marshallhandle->call(this->time);
    622619
    623620}  /*}}}*/
    624621template <> inline void GenericExternalResult<IssmPDouble*>::Transpose(void){/*{{{*/
    … …  
    830827                xDelete<IssmDouble>(serialvalues);
    831828        }
    832829        /*}}}*/
    833         template <> inline void GenericExternalResult<Vector<IssmDouble>*>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     830        template <> inline void GenericExternalResult<Vector<IssmDouble>*>::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    834831
    835832                _error_("GenericExternalResult instantiated for type Vector<IssmDouble>* called " << result_name << " not implemented yet");
    836833

  • ../trunk-jpl/src/c/classes/Vertices.cpp

     
    109109        return output;
    110110}
    111111/*}}}*/
    112 void Vertices::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    113 
    114         int num_procs=IssmComm::GetSize();
    115         int test = num_procs;
    116         MARSHALLING_ENUM(VerticesEnum);
    117         MARSHALLING(numberofvertices);
    118         MARSHALLING(numberofvertices_local);
    119         MARSHALLING(numberofmasters_local);
    120         MARSHALLING(test);
    121         if(test!=num_procs) _error_("number of cores is not the same as before");
    122         MARSHALLING_DYNAMIC(this->common_recv,int,num_procs);
    123         MARSHALLING_DYNAMIC(this->common_send,int,num_procs);
    124         if(marshall_direction == MARSHALLING_LOAD){
    125                 this->common_recv_ids = xNew<int*>(num_procs);
    126                 this->common_send_ids = xNew<int*>(num_procs);
    127         }
    128         for(int i=0;i<num_procs;i++){
    129                 MARSHALLING_DYNAMIC(this->common_recv_ids[i],int,this->common_recv[i]);
    130                 MARSHALLING_DYNAMIC(this->common_send_ids[i],int,this->common_send[i]);
    131         }
    132         DataSet::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    133 }
    134 /*}}}*/
    135112void Vertices::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    136113
    137114        int object_enum = VerticesEnum;

  • ../trunk-jpl/src/c/classes/Node.cpp

     
    248248        return (Object*)output;
    249249}
    250250/*}}}*/
    251 void Node::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    252 
    253         MARSHALLING_ENUM(NodeEnum);
    254         MARSHALLING(id);
    255         MARSHALLING(sid);
    256         MARSHALLING(lid);
    257         MARSHALLING(pid);
    258         MARSHALLING(indexingupdate);
    259         MARSHALLING(analysis_enum);
    260        
    261         for(int k=0;k<3;k++) for(int l=0;l<3;l++) MARSHALLING(coord_system[k][l]);
    262 
    263         MARSHALLING(gsize);
    264         MARSHALLING(fsize);
    265         MARSHALLING(ssize);
    266         MARSHALLING(clone);
    267         MARSHALLING(active);
    268         MARSHALLING(freeze);
    269         MARSHALLING_DYNAMIC(f_set,bool,gsize);
    270         MARSHALLING_DYNAMIC(s_set,bool,gsize);
    271         MARSHALLING_DYNAMIC(svalues,IssmDouble,gsize);
    272         MARSHALLING_DYNAMIC(doftype,int,gsize);
    273         MARSHALLING_DYNAMIC(gdoflist,int,gsize);
    274         MARSHALLING_DYNAMIC(fdoflist,int,fsize);
    275         MARSHALLING_DYNAMIC(sdoflist,int,ssize);
    276         MARSHALLING_DYNAMIC(gdoflist_local,int,gsize);
    277         MARSHALLING_DYNAMIC(fdoflist_local,int,fsize);
    278         MARSHALLING_DYNAMIC(sdoflist_local,int,ssize);
    279 } /*}}}*/
    280251void Node::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    281252
    282253        int object_enum = NodeEnum;

  • ../trunk-jpl/src/c/classes/Profiler.h

     
    5151                void    DeepEcho();
    5252                void    Echo();
    5353                int     Id();
    54                 void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    5554                void    Marshall2(MarshallHandle* marshallhandle);
    5655                int     ObjectEnum();
    5756

  • ../trunk-jpl/src/c/classes/Radar.cpp

     
    5757        return -1;
    5858}
    5959/*}}}*/
    60 void Radar::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    61         _error_("not implemented yet!");
    62 }
    63 /*}}}*/
    6460void Radar::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    6561        _error_("not implemented yet!");
    6662}

  • ../trunk-jpl/src/c/classes/Nodalvalue.cpp

     
    6262        return -1;
    6363}
    6464/*}}}*/
    65 void Nodalvalue::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    66         _error_("not implemented yet!");
    67 }
    68 /*}}}*/
    6965void Nodalvalue::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    7066        _error_("not implemented yet!");
    7167}

  • ../trunk-jpl/src/c/classes/Misfit.cpp

     
    8888        return -1;
    8989}
    9090/*}}}*/
    91 void Misfit::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    92         _error_("not implemented yet!");
    93 }
    94 /*}}}*/
    9591void Misfit::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    9692        _error_("not implemented yet!");
    9793}

  • ../trunk-jpl/src/c/classes/Massfluxatgate.h

     
    122122                        return MassfluxatgateEnum;
    123123                }
    124124                /*}}}*/
    125                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    126                         _error_("not implemented yet!");
    127                 }
    128                 /*}}}*/
    129125                void Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    130126
    131127                        int object_enum = MassfluxatgateEnum;

  • ../trunk-jpl/src/c/classes/FemModel.h

     
    8080                int  GetElementsWidth(){return 3;};//just tria elements in this first version
    8181                void InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* petscfilename, char* lockfilename, char* restartfilename, const int solution_type,bool trace,IssmPDouble* X=NULL);
    8282                void InitFromFids(char* rootpath, FILE* IOMODEL, FILE* toolkitsoptionsfid, int in_solution_type, bool trace, IssmPDouble* X=NULL);
    83                 void Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction);
    8483                void Marshall2(MarshallHandle* marshallhandle);
    8584                void Restart(void);
    8685                void RestartAD(int step);

  • ../trunk-jpl/src/c/classes/Numberedcostfunction.cpp

     
    8585        return -1;
    8686}
    8787/*}}}*/
    88 void Numberedcostfunction::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    89         _error_("not implemented yet!");
    90 }
    91 /*}}}*/
    9288void Numberedcostfunction::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    9389        _error_("not implemented yet!");
    9490}

  • ../trunk-jpl/src/c/classes/Params/Parameters.cpp

     
    110110        return;
    111111}
    112112/*}}}*/
    113 void Parameters::Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    114 
    115         int obj_enum=-1;
    116         int num_params=0;
    117 
    118         MARSHALLING_ENUM(ParametersEnum);
    119 
    120         if(marshall_direction==MARSHALLING_WRITE || marshall_direction==MARSHALLING_SIZE){
    121 
    122                 /*Marshall num_params first*/
    123                 for(int i=0;i<NUMPARAMS;i++){
    124                         if(this->params[i]) num_params++;
    125                 }
    126                 MARSHALLING(num_params);
    127 
    128                 /*Marshall Parameters one by one now*/
    129                 for(int i=0;i<NUMPARAMS;i++){
    130                         if(this->params[i]){
    131                                 obj_enum = this->params[i]->ObjectEnum();
    132                                 MARSHALLING(obj_enum);
    133                                 this->params[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    134                         }
    135                 }
    136         }
    137         else{
    138 
    139                 /*Get number of params marshalled*/
    140                 MARSHALLING(num_params);
    141 
    142                 /*Recover parameters one by one*/
    143                 for(int i=0;i<num_params;i++){
    144 
    145                         /*Recover enum of object first: */
    146                         MARSHALLING(obj_enum);
    147 
    148                         if(obj_enum==DoubleParamEnum){
    149                                 DoubleParam* doubleparam=NULL;
    150                                 doubleparam=new DoubleParam();
    151                                 doubleparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    152                                 this->AddObject(doubleparam);
    153                         }
    154                         else if(obj_enum==IntParamEnum){
    155                                 IntParam* intparam=NULL;
    156                                 intparam=new IntParam();
    157                                 intparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    158                                 this->AddObject(intparam);
    159                         }
    160                         else if(obj_enum==IntMatParamEnum){
    161                                 IntMatParam* intmparam=NULL;
    162                                 intmparam=new IntMatParam();
    163                                 intmparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    164                                 this->AddObject(intmparam);
    165                         }
    166                         else if(obj_enum==IntVecParamEnum){
    167                                 IntVecParam* intvparam=NULL;
    168                                 intvparam=new IntVecParam();
    169                                 intvparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    170                                 this->AddObject(intvparam);
    171                         }
    172                         else if(obj_enum==BoolParamEnum){
    173                                 BoolParam* boolparam=NULL;
    174                                 boolparam=new BoolParam();
    175                                 boolparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    176                                 this->AddObject(boolparam);
    177                         }
    178                         else if(obj_enum==DataSetParamEnum){
    179                                 DataSetParam* dsparam=NULL;
    180                                 dsparam=new DataSetParam();
    181                                 dsparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    182                                 this->AddObject(dsparam);
    183                         }
    184                         else if(obj_enum==DoubleMatArrayParamEnum){
    185                                 DoubleMatArrayParam* dmaparam=NULL;
    186                                 dmaparam=new DoubleMatArrayParam();
    187                                 dmaparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    188                                 this->AddObject(dmaparam);
    189                         }
    190                         else if(obj_enum==DoubleMatParamEnum){
    191                                 DoubleMatParam* dmparam=NULL;
    192                                 dmparam=new DoubleMatParam();
    193                                 dmparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    194                                 this->AddObject(dmparam);
    195                         }
    196                         else if(obj_enum==DoubleVecParamEnum){
    197                                 DoubleVecParam* dvparam=NULL;
    198                                 dvparam=new DoubleVecParam();
    199                                 dvparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    200                                 this->AddObject(dvparam);
    201                         }
    202                         else if(obj_enum==FileParamEnum){
    203                                 FileParam* fileparam=NULL;
    204                                 fileparam=new FileParam();
    205                                 fileparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    206                                 delete fileparam;
    207                                 /* No need to add this object, the pointer is not valid
    208                                         The FemModel should reset all FileParams in the restart function */
    209                         }
    210                         else if(obj_enum==StringParamEnum){
    211                                 StringParam* sparam=NULL;
    212                                 sparam=new StringParam();
    213                                 sparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    214                                 this->AddObject(sparam);
    215                         }
    216                         else if(obj_enum==StringArrayParamEnum){
    217                                 StringArrayParam* saparam=NULL;
    218                                 saparam=new StringArrayParam();
    219                                 saparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    220                                 this->AddObject(saparam);
    221                         }
    222                         else if(obj_enum==TransientParamEnum){
    223                                 TransientParam* transparam=NULL;
    224                                 transparam=new TransientParam();
    225                                 transparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    226                                 this->AddObject(transparam);
    227                         }
    228                         else if(obj_enum==TransientArrayParamEnum){
    229                                 TransientArrayParam* transarrayparam=NULL;
    230                                 transarrayparam=new TransientArrayParam();
    231                                 transarrayparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    232                                 this->AddObject(transarrayparam);
    233                         }
    234                         else if(obj_enum==GenericParamEnum){
    235                                 /*Skip for now (we don't want to Marhsall Comms)*/
    236                         }
    237                 }
    238         }
    239 }
    240 /*}}}*/
    241113void Parameters::Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    242114
    243115        int num_params=0;

  • ../trunk-jpl/src/c/classes/Params/FileParam.h

     
    3434                void  DeepEcho();
    3535                void  Echo();
    3636                int   Id();
    37                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3837                void Marshall2(MarshallHandle* marshallhandle);
    3938                int   ObjectEnum();
    4039                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/Param.h

     
    4444                virtual void  GetParameterValue(FILE** pfid)=0;
    4545                virtual void  GetParameterValue(DataSet** pdataset)=0;
    4646                virtual int   InstanceEnum()=0;
    47                 virtual void  Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction)=0;
    4847                virtual void  Marshall2(MarshallHandle* marshallhandle)=0;
    4948                virtual int   ObjectEnum()=0;
    5049

  • ../trunk-jpl/src/c/classes/Params/DataSetParam.cpp

     
    5151/*}}}*/
    5252int    DataSetParam::Id(void){ return -1; }/*{{{*/
    5353/*}}}*/
    54 void DataSetParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    55 
    56         if(marshall_direction==MARSHALLING_LOAD)value=new DataSet();
    57 
    58         MARSHALLING_ENUM(DataSetParamEnum);
    59         MARSHALLING(enum_type);
    60         value->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    61 
    62 }
    63 /*}}}*/
    6454void DataSetParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6555
    6656        if(marshallhandle->OperationNumber()==MARSHALLING_LOAD)value=new DataSet();

  • ../trunk-jpl/src/c/classes/Params/IntVecParam.cpp

     
    6969/*}}}*/
    7070int  IntVecParam::Id(void){ return -1; }/*{{{*/
    7171/*}}}*/
    72 void IntVecParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    73 
    74         MARSHALLING_ENUM(IntVecParamEnum);
    75 
    76         MARSHALLING(enum_type);
    77         MARSHALLING(M);
    78         if(M) {
    79                 MARSHALLING_DYNAMIC(values,int,M);
    80         }
    81         else values=NULL;
    82 
    83 }
    84 /*}}}*/
    8572void IntVecParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8673
    8774        int object_enum = IntVecParamEnum;

  • ../trunk-jpl/src/c/classes/Params/IntParam.cpp

     
    4848/*}}}*/
    4949int  IntParam::Id(void){ return -1; }/*{{{*/
    5050/*}}}*/
    51 void IntParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    52 
    53         MARSHALLING_ENUM(IntParamEnum);
    54 
    55         MARSHALLING(enum_type);
    56         MARSHALLING(value);
    57 
    58 }
    59 /*}}}*/
    6051void IntParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6152
    6253        int object_enum = IntParamEnum;

  • ../trunk-jpl/src/c/classes/Params/BoolParam.cpp

     
    4747/*}}}*/
    4848int    BoolParam::Id(void){ return -1; }/*{{{*/
    4949/*}}}*/
    50 void BoolParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    51 
    52         MARSHALLING_ENUM(BoolParamEnum);
    53 
    54         MARSHALLING(enum_type);
    55         MARSHALLING(value);
    56 
    57 }
    58 /*}}}*/
    5950void BoolParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6051
    6152        int object_enum = BoolParamEnum;

  • ../trunk-jpl/src/c/classes/Params/IntMatParam.cpp

     
    6666/*}}}*/
    6767int  IntMatParam::Id(void){ return -1; }/*{{{*/
    6868/*}}}*/
    69 void IntMatParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    70 
    71         MARSHALLING_ENUM(IntMatParamEnum);
    72 
    73         MARSHALLING(enum_type);
    74         MARSHALLING(M);
    75         MARSHALLING(N);
    76         MARSHALLING_DYNAMIC(value,int,M*N);
    77 }
    78 /*}}}*/
    7969void IntMatParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8070
    8171        int object_enum = IntMatParamEnum;

  • ../trunk-jpl/src/c/classes/Params/StringArrayParam.cpp

     
    7272/*}}}*/
    7373int    StringArrayParam::Id(void){ return -1; }/*{{{*/
    7474/*}}}*/
    75 void StringArrayParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    76 
    77         int* sizes=NULL;
    78 
    79         if(marshall_direction==MARSHALLING_WRITE || marshall_direction==MARSHALLING_SIZE){
    80                 if(numstrings)sizes=xNew<int>(numstrings);
    81                 for(int i=0;i<numstrings;i++)sizes[i]=strlen(value[i])+1;
    82         }       
    83 
    84         MARSHALLING_ENUM(StringArrayParamEnum);
    85 
    86         MARSHALLING(enum_type);
    87         MARSHALLING(numstrings);
    88 
    89         if(numstrings){
    90                 MARSHALLING_DYNAMIC(sizes,int,numstrings);
    91                 if(marshall_direction==MARSHALLING_LOAD) value=xNew<char*>(numstrings);
    92                 for(int i=0;i<numstrings;i++)MARSHALLING_DYNAMIC(value[i],char,sizes[i]);
    93         }
    94         else value=NULL;
    95 
    96         //cleanup sizes array
    97         if(sizes) xDelete<int>(sizes);
    98 
    99 }
    100 /*}}}*/
    10175void StringArrayParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    10276
    10377        int* sizes=NULL;

  • ../trunk-jpl/src/c/classes/Params/StringParam.cpp

     
    4949/*}}}*/
    5050int    StringParam::Id(void){ return -1; }/*{{{*/
    5151/*}}}*/
    52 void StringParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    53 
    54         int size = 0;
    55 
    56         if(marshall_direction==MARSHALLING_WRITE || marshall_direction == MARSHALLING_SIZE)size=strlen(value)+1;
    57 
    58         MARSHALLING_ENUM(StringParamEnum);
    59         MARSHALLING(enum_type);
    60         MARSHALLING(size);
    61         MARSHALLING_DYNAMIC(value,char,size);
    62 
    63 }
    64 /*}}}*/
    6552void StringParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6653
    6754        int size = 0;

  • ../trunk-jpl/src/c/classes/Params/TransientParam.cpp

     
    6767/*}}}*/
    6868int  TransientParam::Id(void){ return -1; }/*{{{*/
    6969/*}}}*/
    70 void TransientParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    71 
    72         MARSHALLING_ENUM(TransientParamEnum);
    73 
    74         MARSHALLING(enum_type);
    75         MARSHALLING(interpolation);
    76         MARSHALLING(N);
    77         if(marshall_direction==MARSHALLING_LOAD){
    78                 values=xNew<IssmDouble>(N);
    79                 timesteps=xNew<IssmDouble>(N);
    80         }
    81         MARSHALLING_DYNAMIC(values,IssmDouble,N);
    82         MARSHALLING_DYNAMIC(timesteps,IssmDouble,N);
    83 
    84 }
    85 /*}}}*/
    8670void TransientParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8771
    8872        int object_enum = TransientParamEnum;

  • ../trunk-jpl/src/c/classes/Params/VectorParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    3938                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!"); };
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/MatrixParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    3938                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!"); };
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/TransientArrayParam.h

     
    3838                void  DeepEcho();
    3939                void  Echo();
    4040                int   Id();
    41                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4241                void Marshall2(MarshallHandle* marshallhandle);
    4342                int   ObjectEnum();
    4443                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/DoubleVecParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void Marshall2(MarshallHandle* marshallhandle);
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/DoubleParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void Marshall2(MarshallHandle* marshallhandle);
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/FileParam.cpp

     
    4848/*}}}*/
    4949int  FileParam::Id(void){ return -1; }/*{{{*/
    5050/*}}}*/
    51 void FileParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    52 
    53         MARSHALLING_ENUM(FileParamEnum);
    54         MARSHALLING(enum_type);
    55         MARSHALLING(value);
    56 
    57         if(marshall_direction==MARSHALLING_LOAD) value=NULL; //meaningless file pointer!
    58 
    59 }
    60 /*}}}*/
    6151void FileParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    6252
    6353        int object_enum = FileParamEnum;

  • ../trunk-jpl/src/c/classes/Params/DoubleMatArrayParam.h

     
    3737                void  DeepEcho();
    3838                void  Echo();
    3939                int   Id();
    40                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4140                void Marshall2(MarshallHandle* marshallhandle);
    4241                int   ObjectEnum();
    4342                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/DoubleMatParam.h

     
    3737                int   Id();
    3838                int   ObjectEnum();
    3939                Param* copy();
    40                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4140                void Marshall2(MarshallHandle* marshallhandle);
    4241                /*}}}*/
    4342                /*Param vritual function definitions: {{{*/

  • ../trunk-jpl/src/c/classes/Params/GenericParam.h

     
    5151                // but I would prefer to drop this not to hide a "new" in here because
    5252                // it does not clarify  ownership of the newed up instance...
    5353                // use the default copy constructor instead
    54                                          void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){
    55                                                  _printf_("   WARNING: parameter "<<EnumToStringx(this->myEnumVal)<<" is a GenericParam and cannot be marshalled\n");
    56                                                  /*Nothing for now*/
    57                                          }
    5854                                         void Marshall2(MarshallHandle* marshallhandle){
    5955                                                 _printf_("   WARNING: parameter "<<EnumToStringx(this->myEnumVal)<<" is a GenericParam and cannot be marshalled\n");
    6056                                                 /*Nothing for now*/

  • ../trunk-jpl/src/c/classes/Params/Parameters.h

     
    3434                void  Echo();
    3535                void  Delete(int enum_type);
    3636                bool  Exist(int enum_type);
    37                 void  Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction);
    3837                void  Marshall2(MarshallHandle* marshallhandle);
    3938
    4039                void  FindParam(bool* pinteger,int enum_type);

  • ../trunk-jpl/src/c/classes/Params/DataSetParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void Marshall2(MarshallHandle* marshallhandle);
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/IntVecParam.h

     
    3636                void  DeepEcho();
    3737                void  Echo();
    3838                int   Id();
    39                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4039                void Marshall2(MarshallHandle* marshallhandle);
    4140                int   ObjectEnum();
    4241                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/IntParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void Marshall2(MarshallHandle* marshallhandle);
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/BoolParam.h

     
    3434                void  DeepEcho();
    3535                void  Echo();
    3636                int   Id();
    37                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3837                void Marshall2(MarshallHandle* marshallhandle);
    3938                int   ObjectEnum();
    4039                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/IntMatParam.h

     
    3636                void  DeepEcho();
    3737                void  Echo();
    3838                int   Id();
    39                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4039                void Marshall2(MarshallHandle* marshallhandle);
    4140                int   ObjectEnum();
    4241                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/TransientArrayParam.cpp

     
    7272/*}}}*/
    7373int  TransientArrayParam::Id(void){ return -1; }/*{{{*/
    7474/*}}}*/
    75 void TransientArrayParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    76 
    77         MARSHALLING_ENUM(TransientArrayParamEnum);
    78 
    79         MARSHALLING(enum_type);
    80         MARSHALLING(interpolation);
    81         MARSHALLING(M);
    82         MARSHALLING(N);
    83         if(marshall_direction==MARSHALLING_LOAD){
    84                 values    = xNew<IssmDouble>(M*N);
    85                 timesteps = xNew<IssmDouble>(N);
    86         }
    87         MARSHALLING_DYNAMIC(values,IssmDouble,M*N);
    88         MARSHALLING_DYNAMIC(timesteps,IssmDouble,N);
    89 
    90 }/*}}}*/
    9175void TransientArrayParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    9276
    9377        int object_enum = TransientArrayParamEnum;

  • ../trunk-jpl/src/c/classes/Params/DoubleVecParam.cpp

     
    5858/*}}}*/
    5959int    DoubleVecParam::Id(void){ return -1; }/*{{{*/
    6060/*}}}*/
    61 void DoubleVecParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    62 
    63         MARSHALLING_ENUM(DoubleVecParamEnum);
    64 
    65         MARSHALLING(enum_type);
    66         MARSHALLING(M);
    67         MARSHALLING_DYNAMIC(values,IssmDouble,M);
    68 
    69 }
    70 /*}}}*/
    7161void DoubleVecParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    7262
    7363        int object_enum = DoubleVecParamEnum;

  • ../trunk-jpl/src/c/classes/Params/DoubleParam.cpp

     
    4545/*}}}*/
    4646int  DoubleParam::Id(void){ return -1; }/*{{{*/
    4747/*}}}*/
    48 void DoubleParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    49 
    50         MARSHALLING_ENUM(DoubleParamEnum);
    51 
    52         MARSHALLING(enum_type);
    53         MARSHALLING(value);
    54 
    55 }
    56 /*}}}*/
    5748void DoubleParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    5849
    5950        int object_enum = DoubleParamEnum;

  • ../trunk-jpl/src/c/classes/Params/StringArrayParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void Marshall2(MarshallHandle* marshallhandle);
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/DoubleMatArrayParam.cpp

     
    115115/*}}}*/
    116116int    DoubleMatArrayParam::Id(void){ return -1; }/*{{{*/
    117117/*}}}*/
    118 void DoubleMatArrayParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    119 
    120         MARSHALLING_ENUM(DoubleMatArrayParamEnum);
    121 
    122         MARSHALLING(enum_type);
    123         MARSHALLING(M);
    124         if(M){
    125                 MARSHALLING_DYNAMIC(mdim_array,int,M);
    126                 MARSHALLING_DYNAMIC(ndim_array,int,M);
    127                 if(marshall_direction==MARSHALLING_LOAD && M) array=xNew<IssmDouble*>(M);
    128                 for(int i=0;i<M;i++){
    129                         MARSHALLING_DYNAMIC(array[i],IssmDouble,mdim_array[i]*ndim_array[i]);
    130                 }
    131         }
    132         else{
    133                 array=NULL;
    134                 mdim_array=NULL;
    135                 ndim_array=NULL;
    136         }
    137 
    138 }
    139 /*}}}*/
    140118void DoubleMatArrayParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    141119
    142120        int object_enum = DoubleMatArrayParamEnum;

  • ../trunk-jpl/src/c/classes/Params/StringParam.h

     
    3535                void  DeepEcho();
    3636                void  Echo();
    3737                int   Id();
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3938                void Marshall2(MarshallHandle* marshallhandle);
    4039                int   ObjectEnum();
    4140                /*}}}*/

  • ../trunk-jpl/src/c/classes/Params/DoubleMatParam.cpp

     
    7272
    7373}
    7474/*}}}*/
    75 void DoubleMatParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    76 
    77         MARSHALLING_ENUM(DoubleMatParamEnum);
    78 
    79         MARSHALLING(enum_type);
    80         MARSHALLING(M);
    81         MARSHALLING(N);
    82         MARSHALLING_DYNAMIC(value,IssmDouble,M*N);
    83 }
    84 /*}}}*/
    8575void DoubleMatParam::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    8676
    8777        int object_enum = DoubleMatParamEnum;

  • ../trunk-jpl/src/c/classes/Params/TransientParam.h

     
    3737                void  DeepEcho();
    3838                void  Echo();
    3939                int   Id();
    40                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4140                void Marshall2(MarshallHandle* marshallhandle);
    4241                int   ObjectEnum();
    4342                /*}}}*/

  • ../trunk-jpl/src/c/classes/Hook.h

     
    3333                Object*    copy(void);
    3434                void       DeepEcho(void);
    3535                void       Echo(void);
    36                 void       Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3736                void       Marshall2(MarshallHandle* marshallhandle);
    3837                /*}}}*/
    3938                /*Hook management: {{{*/

  • ../trunk-jpl/src/c/datastructures/DataSet.h

     
    3333                DataSet();
    3434                DataSet(int enum_type);
    3535                ~DataSet();
    36                 void  Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction);
    3736                void  Marshall2(MarshallHandle* marshallhandle);
    3837
    3938                /*management*/

  • ../trunk-jpl/src/c/datastructures/Object.h

     
    2020                virtual int   Id()=0;
    2121                virtual int   ObjectEnum()=0;
    2222                virtual Object* copy()=0;
    23                 virtual void Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction)=0;
    2423                virtual void Marshall2(MarshallHandle* marshallhandle)=0;
    2524
    2625};

  • ../trunk-jpl/src/c/datastructures/DataSet.cpp

     
    9090/*}}}*/
    9191
    9292/*Specific methods*/
    93 void  DataSet::Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
    94 
    95         vector<Object*>::iterator obj;
    96         int obj_size=0;
    97         int obj_enum=0;
    98         int i;
    99 
    100         if(marshall_direction==MARSHALLING_WRITE || marshall_direction==MARSHALLING_SIZE){
    101                 obj_size=objects.size();
    102         }
    103         else{
    104                 clear();
    105         }
    106 
    107         MARSHALLING_ENUM(DataSetEnum);
    108         MARSHALLING(enum_type);
    109         MARSHALLING(sorted);
    110         MARSHALLING(presorted);
    111         MARSHALLING(numsorted);
    112 
    113         /*Now branch according to direction of marshalling: */
    114         if(marshall_direction==MARSHALLING_WRITE || marshall_direction==MARSHALLING_SIZE){
    115                 if(!(this->sorted && numsorted>0 && this->id_offsets)){
    116                         sorted_ids=NULL;
    117                         id_offsets=NULL;
    118                   }
    119                 MARSHALLING_DYNAMIC(sorted_ids,int,numsorted);
    120                 MARSHALLING_DYNAMIC(id_offsets,int,numsorted);
    121                 MARSHALLING(obj_size);
    122 
    123                 /*Go through our objects, and marshall them into the buffer: */
    124                 for( obj=this->objects.begin() ; obj < this->objects.end(); obj++ ){
    125                         obj_enum=(*obj)->ObjectEnum();
    126                         MARSHALLING(obj_enum);
    127                         (*obj)->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    128                 }
    129         }
    130         else{
    131 
    132                 MARSHALLING_DYNAMIC(sorted_ids,int,numsorted);
    133                 MARSHALLING_DYNAMIC(id_offsets,int,numsorted);
    134                 if (!(this->sorted && numsorted>0)){
    135                  sorted_ids=NULL;
    136                  id_offsets=NULL;
    137                 }
    138                 MARSHALLING(obj_size);
    139 
    140                 /*This is the heart of the demashalling method. We have a buffer coming
    141                  in, and we are supposed to create a dataset out of it. No such thing
    142                  as class orientation for buffers, we need to key off the enum of each
    143                  object stored in the buffer. */
    144                 for(i=0;i<obj_size;i++){
    145 
    146                         /*Recover enum of object first: */
    147                         MARSHALLING(obj_enum);
    148 
    149                         /*Giant case statement to spin-up the right object, and demarshall into it the information
    150                          *stored in the buffer: */
    151                         if(obj_enum==NodeEnum){
    152                                 Node* node=NULL;
    153                                 node=new Node();
    154                                 node->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    155                                 this->AddObject(node);
    156                         }
    157                         else if(obj_enum==VertexEnum){
    158                                 Vertex* vertex=NULL;
    159                                 vertex=new Vertex();
    160                                 vertex->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    161                                 this->AddObject(vertex);
    162                         }
    163                         else if(obj_enum==MaticeEnum){
    164                                 Matice* matice=NULL;
    165                                 matice=new Matice();
    166                                 matice->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    167                                 this->AddObject(matice);
    168                         }
    169                         else if(obj_enum==MatestarEnum){
    170                                 Matestar* matestar=NULL;
    171                                 matestar=new Matestar();
    172                                 matestar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    173                                 this->AddObject(matestar);
    174                         }
    175                         else if(obj_enum==SpcStaticEnum){
    176                                 SpcStatic* spcstatic=NULL;
    177                                 spcstatic=new SpcStatic();
    178                                 spcstatic->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    179                                 this->AddObject(spcstatic);
    180                         }
    181                         else if(obj_enum==SpcDynamicEnum){
    182                                 SpcDynamic* spcdynamic=NULL;
    183                                 spcdynamic=new SpcDynamic();
    184                                 spcdynamic->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    185                                 this->AddObject(spcdynamic);
    186                         }
    187                         else if(obj_enum==SpcTransientEnum){
    188                                 SpcTransient* spctransient=NULL;
    189                                 spctransient=new SpcTransient();
    190                                 spctransient->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    191                                 this->AddObject(spctransient);
    192                         }
    193                         else if(obj_enum==TriaEnum){
    194                                 Tria* tria=NULL;
    195                                 tria=new Tria();
    196                                 tria->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    197                                 this->AddObject(tria);
    198                         }
    199                         else if(obj_enum==PentaEnum){
    200                                 Penta* penta=NULL;
    201                                 penta=new Penta();
    202                                 penta->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    203                                 this->AddObject(penta);
    204                         }
    205                         else if(obj_enum==TetraEnum){
    206                                 Tetra* tetra=NULL;
    207                                 tetra=new Tetra();
    208                                 tetra->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    209                                 this->AddObject(tetra);
    210                         }
    211                         else if(obj_enum==SegEnum){
    212                                 Seg* seg=NULL;
    213                                 seg=new Seg();
    214                                 seg->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    215                                 this->AddObject(seg);
    216                         }
    217                         else if(obj_enum==RiftfrontEnum){
    218                                 Riftfront* rift=NULL;
    219                                 rift=new Riftfront();
    220                                 rift->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    221                                 this->AddObject(rift);
    222                         }
    223                         else if(obj_enum==NumericalfluxEnum){
    224                                 Numericalflux* numflux=NULL;
    225                                 numflux=new Numericalflux();
    226                                 numflux->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    227                                 this->AddObject(numflux);
    228                         }
    229                         else if(obj_enum==PengridEnum){
    230                                 Pengrid* pengrid=NULL;
    231                                 pengrid=new Pengrid();
    232                                 pengrid->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    233                                 this->AddObject(pengrid);
    234                         }
    235                         else if(obj_enum==PenpairEnum){
    236                                 Penpair* penpair=NULL;
    237                                 penpair=new Penpair();
    238                                 penpair->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    239                                 this->AddObject(penpair);
    240                         }
    241                         else if(obj_enum==DoubleExternalResultEnum){
    242                                 GenericExternalResult<double>* result=new GenericExternalResult<double>();
    243                                 result->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    244                                 this->AddObject(result);
    245                         }
    246                         else _error_("could not recognize enum type: " << obj_enum << ": " << EnumToStringx(obj_enum) );
    247                 }
    248         }
    249 }
    250 /*}}}*/
    25193void  DataSet::Marshall2(MarshallHandle* marshallhandle){ /*{{{*/
    25294
    25395        vector<Object*>::iterator obj;

  • ../trunk-jpl/src/c/kml/KML_Object.h

     
    2929                int   Id(){_error_("Not implemented yet.");};
    3030                int   ObjectEnum(){_error_("Not implemented yet.");};
    3131                Object* copy(){_error_("Not implemented yet.");};
    32                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     32                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3333                /*}}}*/
    3434
    3535                /*virtual functions: */

  • ../trunk-jpl/src/c/kml/KML_SubStyle.h

     
    2828                int   Id(){_error_("Not implemented yet.");};
    2929                int   ObjectEnum(){_error_("Not implemented yet.");};
    3030                Object* copy(){_error_("Not implemented yet.");};
    31                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     31                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3232                /*}}}*/
    3333
    3434};

  • ../trunk-jpl/src/c/kml/KML_LineString.h

     
    3737                int   Id(){_error_("Not implemented yet.");};
    3838                int   ObjectEnum(){_error_("Not implemented yet.");};
    3939                Object* copy(){_error_("Not implemented yet.");};
    40                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     40                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    4141                /*}}}*/
    4242
    4343};

  • ../trunk-jpl/src/c/kml/KML_Overlay.h

     
    3535                int   Id(){_error_("Not implemented yet.");};
    3636                int   ObjectEnum(){_error_("Not implemented yet.");};
    3737                Object* copy(){_error_("Not implemented yet.");};
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     38                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3939                /*}}}*/
    4040
    4141};

  • ../trunk-jpl/src/c/kml/KML_Container.h

     
    3232                int   Id(){_error_("Not implemented yet.");};
    3333                int   ObjectEnum(){_error_("Not implemented yet.");};
    3434                Object* copy(){_error_("Not implemented yet.");};
    35                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     35                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3636                /*}}}*/
    3737
    3838};

  • ../trunk-jpl/src/c/kml/KML_Polygon.h

     
    3939                int   Id(){_error_("Not implemented yet.");};
    4040                int   ObjectEnum(){_error_("Not implemented yet.");};
    4141                Object* copy(){_error_("Not implemented yet.");};
    42                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     42                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    4343                /*}}}*/
    4444
    4545};

  • ../trunk-jpl/src/c/kml/KML_Geometry.h

     
    2828                int   Id(){_error_("Not implemented yet.");};
    2929                int   ObjectEnum(){_error_("Not implemented yet.");};
    3030                Object* copy(){_error_("Not implemented yet.");};
    31                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     31                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3232                /*}}}*/
    3333
    3434};

  • ../trunk-jpl/src/c/kml/KML_ColorStyle.h

     
    3535                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet.");};
    3636                int   ObjectEnum(){_error_("Not implemented yet.");};
    3737                Object* copy(){_error_("Not implemented yet.");};
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     38                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3939                /*}}}*/
    4040
    4141};

  • ../trunk-jpl/src/c/kml/KML_Placemark.h

     
    3333                int   Id(){_error_("Not implemented yet.");};
    3434                int   ObjectEnum(){_error_("Not implemented yet.");};
    3535                Object* copy(){_error_("Not implemented yet.");};
    36                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     36                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3737                /*}}}*/
    3838
    3939};

  • ../trunk-jpl/src/c/kml/KML_Unknown.h

     
    3131                int   Id(){_error_("Not implemented yet.");};
    3232                int   ObjectEnum(){_error_("Not implemented yet.");};
    3333                Object* copy(){_error_("Not implemented yet.");};
    34                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     34                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3535                /*}}}*/
    3636
    3737};

  • ../trunk-jpl/src/c/kml/KML_GroundOverlay.h

     
    3535                int   Id(){_error_("Not implemented yet.");};
    3636                int   ObjectEnum(){_error_("Not implemented yet.");};
    3737                Object* copy(){_error_("Not implemented yet.");};
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     38                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3939                /*}}}*/
    4040
    4141};

  • ../trunk-jpl/src/c/kml/KML_Style.h

     
    3737                int   Id(){_error_("Not implemented yet.");};
    3838                int   ObjectEnum(){_error_("Not implemented yet.");};
    3939                Object* copy(){_error_("Not implemented yet.");};
    40                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     40                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    4141                /*}}}*/
    4242
    4343};

  • ../trunk-jpl/src/c/kml/KML_Comment.h

     
    2929                int   Id(){_error_("Not implemented yet.");};
    3030                int   ObjectEnum(){_error_("Not implemented yet.");};
    3131                Object* copy(){_error_("Not implemented yet.");};
    32                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     32                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3333                /*}}}*/
    3434
    3535                /*virtual functions: */

  • ../trunk-jpl/src/c/kml/KML_MultiGeometry.h

     
    3333                int   Id(){_error_("Not implemented yet.");};
    3434                int   ObjectEnum(){_error_("Not implemented yet.");};
    3535                Object* copy(){_error_("Not implemented yet.");};
    36                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     36                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3737                /*}}}*/
    3838
    3939};

  • ../trunk-jpl/src/c/kml/KML_LineStyle.h

     
    3030                int   Id(){_error_("Not implemented yet.");};
    3131                int   ObjectEnum(){_error_("Not implemented yet.");};
    3232                Object* copy(){_error_("Not implemented yet.");};
    33                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     33                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3434                /*}}}*/
    3535
    3636};

  • ../trunk-jpl/src/c/kml/KML_Folder.h

     
    2929                int   Id(){_error_("Not implemented yet.");};
    3030                int   ObjectEnum(){_error_("Not implemented yet.");};
    3131                Object* copy(){_error_("Not implemented yet.");};
    32                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     32                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3333                /*}}}*/
    3434
    3535};

  • ../trunk-jpl/src/c/kml/KML_Document.h

     
    2929                int   Id(){_error_("Not implemented yet.");};
    3030                int   ObjectEnum(){_error_("Not implemented yet.");};
    3131                Object* copy(){_error_("Not implemented yet.");};
    32                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     32                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3333                /*}}}*/
    3434
    3535};

  • ../trunk-jpl/src/c/kml/KML_File.h

     
    3131                int   Id(){_error_("Not implemented yet.");};
    3232                int   ObjectEnum(){_error_("Not implemented yet.");};
    3333                Object* copy(){_error_("Not implemented yet.");};
    34                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     34                void Marshall2(MarshallHandle* marshallhandle);
    3535                /*}}}*/
    3636
    3737};

  • ../trunk-jpl/src/c/kml/KML_Icon.h

     
    4343                int   Id(){_error_("Not implemented yet.");};
    4444                int   ObjectEnum(){_error_("Not implemented yet.");};
    4545                Object* copy(){_error_("Not implemented yet.");};
    46                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     46                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    4747                /*}}}*/
    4848
    4949};

  • ../trunk-jpl/src/c/kml/KML_Point.h

     
    3535                int   Id(){_error_("Not implemented yet.");};
    3636                int   ObjectEnum(){_error_("Not implemented yet.");};
    3737                Object* copy(){_error_("Not implemented yet.");};
    38                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     38                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3939                /*}}}*/
    4040
    4141};

  • ../trunk-jpl/src/c/kml/KML_LinearRing.h

     
    3737                int   Id(){_error_("Not implemented yet.");};
    3838                int   ObjectEnum(){_error_("Not implemented yet.");};
    3939                Object* copy(){_error_("Not implemented yet.");};
    40                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     40                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    4141                /*}}}*/
    4242
    4343};

  • ../trunk-jpl/src/c/kml/KML_Feature.h

     
    4343                int   Id(){_error_("Not implemented yet.");};
    4444                int   ObjectEnum(){_error_("Not implemented yet.");};
    4545                Object* copy(){_error_("Not implemented yet.");};
    46                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     46                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    4747                /*}}}*/
    4848
    4949};

  • ../trunk-jpl/src/c/kml/KML_StyleSelector.h

     
    2828                int   Id(){_error_("Not implemented yet.");};
    2929                int   ObjectEnum(){_error_("Not implemented yet.");};
    3030                Object* copy(){_error_("Not implemented yet.");};
    31                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     31                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3232                /*}}}*/
    3333
    3434};

  • ../trunk-jpl/src/c/kml/KML_LatLonBox.h

     
    3434                int   Id(){_error_("Not implemented yet.");};
    3535                int   ObjectEnum(){_error_("Not implemented yet.");};
    3636                Object* copy(){_error_("Not implemented yet.");};
    37                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     37                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3838                /*}}}*/
    3939
    4040};

  • ../trunk-jpl/src/c/kml/KML_Attribute.h

     
    2828                int   Id(){_error_("Not implemented yet.");};
    2929                int   ObjectEnum(){_error_("Not implemented yet.");};
    3030                Object* copy(){_error_("Not implemented yet.");};
    31                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     31                void Marshall2(MarshallHandle* marshallhandle);
    3232                /*}}}*/
    3333
    3434                /*virtual functions: */

  • ../trunk-jpl/src/c/kml/KML_PolyStyle.h

     
    3131                int   Id(){_error_("Not implemented yet.");};
    3232                int   ObjectEnum(){_error_("Not implemented yet.");};
    3333                Object* copy(){_error_("Not implemented yet.");};
    34                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
     34                void Marshall2(MarshallHandle* marshallhandle){ _error_("not implemented yet!");};
    3535                /*}}}*/
    3636
    3737};

  • ../trunk-jpl/src/c/shared/io/Marshalling/Marshalling.h

     
    118118        }
    119119}
    120120
    121 #define MARSHALLING_ENUM(EN)\
    122         int type_enum=EN;\
    123         if(marshall_direction==MARSHALLING_WRITE){\
    124                 memcpy(*pmarshalled_data,&type_enum,sizeof(int));\
    125                 *pmarshalled_data+=sizeof(int);\
    126         }\
    127         else if(marshall_direction==MARSHALLING_SIZE){\
    128                 *pmarshalled_data_size+=sizeof(int);\
    129         }\
    130         else if(marshall_direction==MARSHALLING_LOAD){\
    131                 *pmarshalled_data+=sizeof(int);\
    132         }\
    133         else _error_("Wrong direction during the Marshall process");\
    134 
    135 
    136 #define MARSHALLING(FIELD)\
    137         \
    138         if(marshall_direction==MARSHALLING_WRITE){\
    139                 memcpy(*pmarshalled_data,&FIELD,sizeof(FIELD));\
    140                 *pmarshalled_data+=sizeof(FIELD);\
    141         }\
    142         else if(marshall_direction==MARSHALLING_SIZE){\
    143                 *pmarshalled_data_size+=sizeof(FIELD);\
    144         }\
    145         else if(marshall_direction==MARSHALLING_LOAD){\
    146                 memcpy(&FIELD,*pmarshalled_data,sizeof(FIELD));\
    147                 *pmarshalled_data+=sizeof(FIELD);\
    148         }\
    149         else _error_("Wrong direction during the Marshall process");
    150 
    151 
    152 #define MARSHALLING_DYNAMIC(FIELD,TYPE,SIZE) \
    153         \
    154         {\
    155                 bool field_null=true;\
    156                 if (FIELD)field_null=false;\
    157                 MARSHALLING(field_null);\
    158                 \
    159                 if(!field_null){\
    160                         if(marshall_direction==MARSHALLING_WRITE){\
    161                                         memcpy(*pmarshalled_data,FIELD,SIZE*sizeof(TYPE));\
    162                                         *pmarshalled_data+=SIZE*sizeof(TYPE);\
    163                         }\
    164                         else if(marshall_direction==MARSHALLING_SIZE){\
    165                                 *pmarshalled_data_size+=SIZE*sizeof(TYPE);\
    166                         }\
    167                         else if(marshall_direction==MARSHALLING_LOAD){\
    168                                 FIELD=xNew<TYPE>(SIZE);\
    169                                 memcpy(FIELD,*pmarshalled_data,SIZE*sizeof(TYPE));\
    170                                 *pmarshalled_data+=SIZE*sizeof(TYPE);\
    171                         }\
    172                         else _error_("Wrong direction during the Marshall process");\
    173                 }\
    174         }
    175 
    176121#endif 

  • ../trunk-jpl/src/c/toolkits/issm/Bucket.h

     
    128128                        else if (this->type==VECTOR_BUCKET) return new Bucket(this->m,this->idxm,this->values,this->mode);
    129129                        else _error_("No Copy of Bucket because its type is invalid."); };
    130130                /*}}}*/
    131                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
    132                         _error_("not implemented yet!");
    133                 }
    134                 /*}}}*/
    135131                void Marshall2(MarshallHandle* marshallhandle){/*{{{*/
    136132                        _error_("not implemented yet!");
    137133                }
Note: See TracBrowser for help on using the repository browser.