Changeset 19215


Ignore:
Timestamp:
03/20/15 15:57:29 (10 years ago)
Author:
Eric.Larour
Message:

CHG: going deeper in the low level objects to propagate the new MARSHALL capability.

Location:
issm/trunk-jpl/src
Files:
2 added
25 edited

Legend:

Unmodified
Added
Removed

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

    r19194 r19215  
    12641264
    12651265}/*}}}*/
     1266void       Element::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction,int numanalyses){/*{{{*/
     1267       
     1268        _assert_(this);
     1269        if(marshall_direction==MARSHALLING_BACKWARD) inputs=new Inputs();
     1270
     1271        MARSHALLING_ENUM(ElementEnum);
     1272       
     1273        MARSHALLING(id);
     1274        MARSHALLING(sid);
     1275        MARSHALLING(element_type);
     1276        MARSHALLING_DYNAMIC(element_type_list,int,numanalyses);
     1277
     1278}
     1279/*}}}*/
    12661280void       Element::MigrateGroundingLine(IssmDouble* phi_ungrounding){/*{{{*/
    12671281

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

    r19198 r19215  
    6767                void               DeleteMaterials(void);
    6868                IssmDouble         Divergence(void);
    69                 void               Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
    7069                void               dViscositydBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
    7170                void               dViscositydBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    … …  
    120119                void               LinearFloatingiceMeltingRate();
    121120                void               MigrateGroundingLine(IssmDouble* sheet_ungrounding);
     121                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction,int numanalyses);
     122
    122123                ElementMatrix*     NewElementMatrix(int approximation_enum=NoneApproximationEnum);
    123124                ElementMatrix*     NewElementMatrixCoupling(int number_nodes,int approximation_enum=NoneApproximationEnum);

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

    r18925 r19215  
    7474}
    7575/*}}}*/
     76void ElementHook::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
     77
     78        int i;
     79        bool* hnodes_null=NULL; /*intermediary needed*/
     80        bool  hneighbors_null=true; /*don't deal with hneighbors, unless explicitely asked to*/
     81
     82        _assert_(this);
     83
     84        /*preliminary, before marshall starts: */
     85        if(marshall_direction==MARSHALLING_FORWARD || marshall_direction==MARSHALLING_SIZE){
     86                if(this->hneighbors)hneighbors_null=false;
     87                hnodes_null=xNew<bool>(numanalyses);
     88                for(i=0;i<numanalyses;i++){
     89                        if(this->hnodes[i])hnodes_null[i]=false;
     90                        else hnodes_null[i]=true;
     91                }
     92        }
     93
     94        /*ok, marshall operations: */
     95        MARSHALLING_ENUM(ElementHookEnum);
     96        MARSHALLING(numanalyses);
     97        MARSHALLING(hneighbors_null);
     98        MARSHALLING_DYNAMIC(hnodes_null,bool,numanalyses);
     99
     100        if(marshall_direction==MARSHALLING_BACKWARD){
     101               
     102                this->hnodes      = new Hook*[numanalyses];
     103                this->hvertices   = new Hook();
     104                this->hmaterial   = new Hook();
     105                this->hmatpar     = new Hook();
     106                if(!hneighbors_null)this->hneighbors  = new Hook();
     107
     108                /*Initialize hnodes: */
     109                for(int i=0;i<this->numanalyses;i++){
     110                        if(!hnodes_null[i])this->hnodes[i]=new Hook();
     111                        else this->hnodes[i]=NULL;
     112                }
     113        }
     114
     115        for (i=0;i<numanalyses;i++) if(this->hnodes[i])this->hnodes[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     116        this->hvertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     117        this->hmatpar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     118        this->hmatpar->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        xDelete<bool>(hnodes_null);
     123
     124}
     125/*}}}*/
    76126
    77127void ElementHook::InitHookNeighbors(int* element_ids){/*{{{*/

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

    r18925 r19215  
    2323                ElementHook(int in_numanalyses,int material_id,int numvertices,IoModel* iomodel);
    2424                ~ElementHook();
     25                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    2526
    2627                void InitHookNeighbors(int* element_ids);               //3d only

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

    r19172 r19215  
    4242                Object *copy();
    4343                int     ObjectEnum();
     44                void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
    4445                /*}}}*/
    4546                /*Penta routines:{{{*/

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

    r19172 r19215  
    3838                int     ObjectEnum();
    3939                Object *copy();
     40                void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
    4041                /*}}}*/
    4142                /*Element virtual functions definitions: {{{*/

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

    r19172 r19215  
    3838                int     ObjectEnum();
    3939                Object *copy();
     40                void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!");};
    4041                /*}}}*/
    4142                /*Element virtual functions definitions: {{{*/

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

    r19172 r19215  
    115115}
    116116/*}}}*/
     117void Tria::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
     118       
     119        MARSHALLING_ENUM(TriaEnum);
     120       
     121        /*Call parent classes: */
     122        ElementHook::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     123        Element::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction,this->numanalyses);
     124        TriaRef::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     125
     126}
     127/*}}}*/
     128
    117129
    118130/*Other*/

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

    r19172 r19215  
    4040                int     ObjectEnum();
    4141                Object *copy();
     42                void    Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4243                /*}}}*/
    4344                /*Update virtual functions resolution: {{{*/

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

    r18925 r19215  
    3333                int  TensorInterpolation(int fe_stokes);
    3434                int  VelocityInterpolation(int fe_stokes);
     35                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
     36
    3537};
    3638#endif

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

    r19198 r19215  
    619619
    620620        /*Create buffer to hold marshalled femmodel: */
    621         this->Marshall(NULL,&femmodel_size,MARSHALLING_FORWARD);
     621        this->Marshall(NULL,&femmodel_size,MARSHALLING_SIZE);
    622622        femmodel_buffer=xNew<char>(femmodel_size);
    623623
    … …  
    648648        MARSHALLING_DYNAMIC(analysis_type_list,int,analysis_counter);
    649649
    650         if(marshall_direction==MARSHALLING_BACKWARDS){
     650        if(marshall_direction==MARSHALLING_BACKWARD){
    651651                profiler=new Profiler;
    652652                elements=new Elements();

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

    r18521 r19215  
    118118
    119119        return (Object*)output;
     120}
     121/*}}}*/
     122void Hook::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
     123
     124        MARSHALLING_ENUM(HookEnum);
     125        MARSHALLING(num);
     126        MARSHALLING_DYNAMIC(ids,int,num);
     127        MARSHALLING_DYNAMIC(offsets,int,num);
     128
    120129}
    121130/*}}}*/

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

    r18237 r19215  
    3434                void       DeepEcho(void);
    3535                Object*    copy(void);
     36                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3637                /*}}}*/
    3738                /*Hook management: {{{*/

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

    r18237 r19215  
    5252}
    5353/*}}}*/
     54void DoubleParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
     55
     56        MARSHALLING_ENUM(DoubleParamEnum);
     57
     58        MARSHALLING(enum_type);
     59        MARSHALLING(value);
     60
     61}
     62/*}}}*/
    5463
    5564/*DoubleParam virtual functions definitions: */

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

    r19198 r19215  
    3737                int   ObjectEnum();
    3838                Object* copy();
    39                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
     39                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/
    4141                /*Param vritual function definitions: {{{*/

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

    r18064 r19215  
    5555}
    5656/*}}}*/
     57void IntParam::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
     58
     59        MARSHALLING_ENUM(IntParamEnum);
     60
     61        MARSHALLING(enum_type);
     62        MARSHALLING(value);
     63
     64}
     65/*}}}*/
     66

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

    r19198 r19215  
    3737                int   ObjectEnum();
    3838                Object* copy();
    39                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
     39                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/
    4141                /*Param vritual function definitions: {{{*/

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

    r18237 r19215  
    6767
    6868        return ProfilerEnum;
     69
     70}
     71/*}}}*/
     72void Profiler::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ /*{{{*/
     73
     74        MARSHALLING_ENUM(ProfilerEnum);
     75
     76        if(marshall_direction==MARSHALLING_BACKWARD){
     77                this->time=new Parameters();
     78                this->flops=new Parameters();
     79                this->memory=new Parameters();
     80        }
     81       
     82        time->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     83        flops->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     84        memory->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     85
    6986
    7087}

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

    r19198 r19215  
    4343                int     ObjectEnum();
    4444                Object *copy();
    45                 void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
     45                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4646                /*}}}*/
    4747                /*Profiler routines {{{*/

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

    r19198 r19215  
    9393        int i;
    9494       
    95         if(marshall_direction==MARSHALLING_FORWARD){
     95        if(marshall_direction==MARSHALLING_FORWARD || marshall_direction==MARSHALLING_SIZE){
    9696                numsorted=objects.size();
    9797        }
    … …  
    106106
    107107        /*Now branch according to direction of marshalling: */
    108         if(marshall_direction==MARSHALLING_FORWARD){
     108        if(marshall_direction==MARSHALLING_FORWARD || marshall_direction==MARSHALLING_SIZE){
    109109                /*Go through our objects, and marshall them into the buffer: */
    110110                for ( obj=this->objects.begin() ; obj < this->objects.end(); obj++ ){
    … …  
    140140                                        this->AddObject(vertex);}
    141141                                        break;
     142                                case DoubleParamEnum:{
     143                                        DoubleParam* doubleparam=NULL;
     144                                        doubleparam=new DoubleParam();
     145                                        doubleparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     146                                        this->AddObject(doubleparam);}
     147                                        break;
     148                                case IntParamEnum:{
     149                                        IntParam* intparam=NULL;
     150                                        intparam=new IntParam();
     151                                        intparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     152                                        this->AddObject(intparam);}
     153                                        break;
    142154                                default:
    143155                                        _error_("could not recognize enum type: " << EnumToStringx(enum_type));

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

    r19200 r19215  
    484484        DoubleVecParamEnum,
    485485        ElementEnum,
     486        ElementHookEnum,
     487        HookEnum,
    486488        ExternalResultEnum,
    487489        FileParamEnum,

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

    r19200 r19215  
    479479                case DoubleVecParamEnum : return "DoubleVecParam";
    480480                case ElementEnum : return "Element";
     481                case ElementHookEnum : return "ElementHook";
     482                case HookEnum : return "Hook";
    481483                case ExternalResultEnum : return "ExternalResult";
    482484                case FileParamEnum : return "FileParam";

  • TabularUnified issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

    r19200 r19215  
    488488              else if (strcmp(name,"DoubleVecParam")==0) return DoubleVecParamEnum;
    489489              else if (strcmp(name,"Element")==0) return ElementEnum;
     490              else if (strcmp(name,"ElementHook")==0) return ElementHookEnum;
     491              else if (strcmp(name,"Hook")==0) return HookEnum;
    490492              else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum;
    491493              else if (strcmp(name,"FileParam")==0) return FileParamEnum;
    … …  
    504506              else if (strcmp(name,"Matpar")==0) return MatparEnum;
    505507              else if (strcmp(name,"Node")==0) return NodeEnum;
    506               else if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum;
    507               else if (strcmp(name,"NumericalfluxType")==0) return NumericalfluxTypeEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"Param")==0) return ParamEnum;
     511              if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum;
     512              else if (strcmp(name,"NumericalfluxType")==0) return NumericalfluxTypeEnum;
     513              else if (strcmp(name,"Param")==0) return ParamEnum;
    512514              else if (strcmp(name,"Pengrid")==0) return PengridEnum;
    513515              else if (strcmp(name,"Penpair")==0) return PenpairEnum;
    … …  
    627629              else if (strcmp(name,"StressTensorxz")==0) return StressTensorxzEnum;
    628630              else if (strcmp(name,"StressTensoryy")==0) return StressTensoryyEnum;
    629               else if (strcmp(name,"StressTensoryz")==0) return StressTensoryzEnum;
    630               else if (strcmp(name,"StressTensorzz")==0) return StressTensorzzEnum;
    631631         else stage=6;
    632632   }
    633633   if(stage==6){
    634               if (strcmp(name,"StressMaxPrincipal")==0) return StressMaxPrincipalEnum;
     634              if (strcmp(name,"StressTensoryz")==0) return StressTensoryzEnum;
     635              else if (strcmp(name,"StressTensorzz")==0) return StressTensorzzEnum;
     636              else if (strcmp(name,"StressMaxPrincipal")==0) return StressMaxPrincipalEnum;
    635637              else if (strcmp(name,"DeviatoricStress")==0) return DeviatoricStressEnum;
    636638              else if (strcmp(name,"DeviatoricStressxx")==0) return DeviatoricStressxxEnum;
    … …  
    750752              else if (strcmp(name,"Outputdefinition64")==0) return Outputdefinition64Enum;
    751753              else if (strcmp(name,"Outputdefinition65")==0) return Outputdefinition65Enum;
    752               else if (strcmp(name,"Outputdefinition66")==0) return Outputdefinition66Enum;
    753               else if (strcmp(name,"Outputdefinition67")==0) return Outputdefinition67Enum;
    754754         else stage=7;
    755755   }
    756756   if(stage==7){
    757               if (strcmp(name,"Outputdefinition68")==0) return Outputdefinition68Enum;
     757              if (strcmp(name,"Outputdefinition66")==0) return Outputdefinition66Enum;
     758              else if (strcmp(name,"Outputdefinition67")==0) return Outputdefinition67Enum;
     759              else if (strcmp(name,"Outputdefinition68")==0) return Outputdefinition68Enum;
    758760              else if (strcmp(name,"Outputdefinition69")==0) return Outputdefinition69Enum;
    759761              else if (strcmp(name,"Outputdefinition70")==0) return Outputdefinition70Enum;
    … …  
    873875              else if (strcmp(name,"Scaled")==0) return ScaledEnum;
    874876              else if (strcmp(name,"Separate")==0) return SeparateEnum;
    875               else if (strcmp(name,"Sset")==0) return SsetEnum;
    876               else if (strcmp(name,"Verbose")==0) return VerboseEnum;
    877877         else stage=8;
    878878   }
    879879   if(stage==8){
    880               if (strcmp(name,"TriangleInterp")==0) return TriangleInterpEnum;
     880              if (strcmp(name,"Sset")==0) return SsetEnum;
     881              else if (strcmp(name,"Verbose")==0) return VerboseEnum;
     882              else if (strcmp(name,"TriangleInterp")==0) return TriangleInterpEnum;
    881883              else if (strcmp(name,"BilinearInterp")==0) return BilinearInterpEnum;
    882884              else if (strcmp(name,"NearestInterp")==0) return NearestInterpEnum;

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

    r19198 r19215  
    88enum marshall_directions{
    99        MARSHALLING_FORWARD,
    10         MARSHALLING_BACKWARDS
     10        MARSHALLING_BACKWARD,
     11        MARSHALLING_SIZE
    1112};
    1213
    13 #define MARSHALLING_ENUM(EN) \
    14         int enum_type=EN; \
     14#define MARSHALLING_ENUM(EN)\
     15        int enum_type=EN;\
    1516        if(marshall_direction==MARSHALLING_FORWARD){\
    16                 if(pmarshalled_data){\
    17                         memcpy(*pmarshalled_data,&enum_type,sizeof(int));\
    18                         *pmarshalled_data+=sizeof(int);\
    19                 }\
     17                memcpy(*pmarshalled_data,&enum_type,sizeof(int));\
     18                *pmarshalled_data+=sizeof(int);\
    2019                *pmarshalled_data_size+=sizeof(int);\
    21         }
     20        }\
     21        else if(marshall_direction==MARSHALLING_SIZE){\
     22                *pmarshalled_data_size+=sizeof(int);\
     23        }\
     24        else if(marshall_direction==MARSHALLING_BACKWARD){\
     25        }\
     26        else _error_("Wrong direction during the Marshall process");\
    2227
    23 #define MARSHALLING(FIELD) \
    24 \
     28
     29#define MARSHALLING(FIELD)\
     30        \
    2531        if(marshall_direction==MARSHALLING_FORWARD){\
    26                 if(pmarshalled_data){\
    27                         memcpy(*pmarshalled_data,&FIELD,sizeof(FIELD));\
    28                         *pmarshalled_data+=sizeof(FIELD);\
    29                 }\
     32                memcpy(*pmarshalled_data,&FIELD,sizeof(FIELD));\
     33                *pmarshalled_data+=sizeof(FIELD);\
    3034                *pmarshalled_data_size+=sizeof(FIELD);\
    3135        }\
    32         else{\
     36        else if(marshall_direction==MARSHALLING_SIZE){\
     37                *pmarshalled_data_size+=sizeof(FIELD);\
     38        }\
     39        else if(marshall_direction==MARSHALLING_BACKWARD){\
    3340                memcpy(&FIELD,*pmarshalled_data,sizeof(FIELD));\
    3441                *pmarshalled_data+=sizeof(FIELD);\
    35         }
     42        }\
     43        else _error_("Wrong direction during the Marshall process");
     44
    3645
    3746#define MARSHALLING_ARRAY(FIELD,TYPE,SIZE) \
    38 \
     47        \
    3948        if(marshall_direction==MARSHALLING_FORWARD){\
    40                 if(pmarshalled_data){\
    41                         memcpy(*pmarshalled_data,FIELD,SIZE*sizeof(TYPE));\
    42                         *pmarshalled_data+=SIZE*sizeof(TYPE);\
    43                 }\
     49                memcpy(*pmarshalled_data,FIELD,SIZE*sizeof(TYPE));\
     50                *pmarshalled_data+=SIZE*sizeof(TYPE);\
    4451                *pmarshalled_data_size+=SIZE*sizeof(TYPE);\
    4552        }\
    46         else{\
     53        else if(marshall_direction==MARSHALLING_SIZE){\
     54                *pmarshalled_data_size+=SIZE*sizeof(TYPE);\
     55        }\
     56        else if(marshall_direction==MARSHALLING_BACKWARD){\
    4757                memcpy(FIELD,*pmarshalled_data,SIZE*sizeof(TYPE));\
    4858                *pmarshalled_data+=SIZE*sizeof(TYPE);\
    49         }
     59        }\
     60        else _error_("Wrong direction during the Marshall process");
     61
    5062
    5163#define MARSHALLING_DYNAMIC(FIELD,TYPE,SIZE) \
    52 \
     64        \
    5365        if(marshall_direction==MARSHALLING_FORWARD){\
    54                 if(pmarshalled_data){\
    55                         memcpy(*pmarshalled_data,FIELD,SIZE*sizeof(TYPE));\
    56                         *pmarshalled_data+=SIZE*sizeof(TYPE);\
    57                 }\
     66                memcpy(*pmarshalled_data,FIELD,SIZE*sizeof(TYPE));\
     67                *pmarshalled_data+=SIZE*sizeof(TYPE);\
    5868                *pmarshalled_data_size+=SIZE*sizeof(TYPE);\
    5969        }\
    60         else{\
     70        else if(marshall_direction==MARSHALLING_SIZE){\
     71                *pmarshalled_data_size+=SIZE*sizeof(TYPE);\
     72        }\
     73        else if(marshall_direction==MARSHALLING_BACKWARD){\
    6174                FIELD=xNew<TYPE>(SIZE);\
    6275                memcpy(FIELD,*pmarshalled_data,SIZE*sizeof(TYPE));\
    6376                *pmarshalled_data+=SIZE*sizeof(TYPE);\
    64         }
     77        }\
     78        else _error_("Wrong direction during the Marshall process");
    6579
    6680#endif 

  • TabularUnified issm/trunk-jpl/src/m/enum/EnumDefinitions.py

    r19200 r19215  
    471471def DoubleVecParamEnum(): return StringToEnum("DoubleVecParam")[0]
    472472def ElementEnum(): return StringToEnum("Element")[0]
     473def ElementHookEnum(): return StringToEnum("ElementHook")[0]
     474def HookEnum(): return StringToEnum("Hook")[0]
    473475def ExternalResultEnum(): return StringToEnum("ExternalResult")[0]
    474476def FileParamEnum(): return StringToEnum("FileParam")[0]
Note: See TracChangeset for help on using the changeset viewer.