Changeset 7737


Ignore:
Timestamp:
03/31/11 16:12:40 (14 years ago)
Author:
Mathieu Morlighem
Message:

Cosmetics of new Options DataSet derived calss

  • moved OptionsObject to Option
  • Added check so that an option name is unique
Location:
issm/trunk/src/c
Files:
21 edited
2 moved

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Container/Container.h

    r4236 r7737  
    1313#include "./Materials.h"
    1414#include "./Nodes.h"
     15#include "./Options.h"
    1516#include "./Parameters.h"
    1617#include "./Results.h"
    … …  
    1819
    1920#endif //ifndef _CONTAINER_H_
    20 

  • issm/trunk/src/c/Makefile.am

    r7733 r7737  
    111111                                        ./objects/KML/KML_SubStyle.cpp\
    112112                                        ./objects/KML/KML_SubStyle.h\
    113                                         ./objects/Options/OptionsObject.cpp\
    114                                         ./objects/Options/OptionsObject.h\
     113                                        ./objects/Options/Option.cpp\
     114                                        ./objects/Options/Option.h\
    115115                                        ./objects/Options/OptionsDouble.cpp\
    116116                                        ./objects/Options/OptionsDouble.h\
    … …  
    270270                                        ./Container/Nodes.h\
    271271                                        ./Container/Nodes.cpp\
     272                                        ./Container/Options.h\
     273                                        ./Container/Options.cpp\
    272274                                        ./Container/Parameters.h\
    273275                                        ./Container/Parameters.cpp\
    … …  
    750752                                        ./objects/KML/KML_SubStyle.cpp\
    751753                                        ./objects/KML/KML_SubStyle.h\
    752                                         ./objects/Options/OptionsObject.cpp\
    753                                         ./objects/Options/OptionsObject.h\
     754                                        ./objects/Options/Option.cpp\
     755                                        ./objects/Options/Option.h\
    754756                                        ./objects/Options/OptionsDouble.cpp\
    755757                                        ./objects/Options/OptionsDouble.h\
    … …  
    863865                                        ./objects/Numerics/ElementVector.h\
    864866                                        ./objects/Numerics/ElementVector.cpp\
    865                                         ./shared/Numerics/PetscOptionsFromAnalysis.cpp\
    866867                                        ./objects/Params/Param.h\
    867868                                        ./objects/Params/BoolParam.cpp\
    … …  
    906907                                        ./Container/Nodes.h\
    907908                                        ./Container/Nodes.cpp\
     909                                        ./Container/Options.h\
     910                                        ./Container/Options.cpp\
    908911                                        ./Container/Parameters.h\
    909912                                        ./Container/Parameters.cpp\
    … …  
    941944                                        ./shared/Numerics/extrema.cpp\
    942945                                        ./shared/Numerics/UnitConversion.cpp\
     946                                        ./shared/Numerics/PetscOptionsFromAnalysis.cpp\
    943947                                        ./shared/Exceptions/exceptions.h\
    944948                                        ./shared/Exceptions/Exceptions.cpp\

  • issm/trunk/src/c/io/OptionsParse.cpp

    r7732 r7737  
    1515#include <mex.h>
    1616
    17 DataSet* OptionsParse( int istart, int nrhs, const mxArray* prhs[]){
    18 
    19         int   i;
    20         char* name=NULL;
    21         DataSet* options=NULL;
    22         OptionsObject* oobject=NULL;
    23 
    24         options=new DataSet;
    25 
    26 /*  loop over each name and value  */
    27 
    28         for (i=istart; i<nrhs; i=i+2) {
    29                 if (!mxIsChar(prhs[i]))
    30                         _error_("Argument %d must be name of option.",i+1);
    31 
    32                 FetchData(&name,prhs[i]);
    33                 if (i+1 == nrhs) {
    34                         _error_("Argument %d must exist and be value of option \"%s\".",i+2,name);
    35                 }
    36 
    37                 _printf_(true,"  Processing option \"%s\" of class \"%s\".\n",
    38                                  name,mxGetClassName(prhs[i+1]));
    39                 oobject=(OptionsObject*)OptionsObjectParse(name,&prhs[i+1]);
    40                 options->AddObject((Object*)oobject);
    41                 oobject=NULL;
    42         }
    43 
    44 /*  echo the dataset  */
    45 
    46         if (options->Size())
    47                 for (i=0; i<options->Size(); i++)
    48                         ((OptionsObject *)options->GetObjectByOffset(i))->Echo();
    49 
    50         return(options);
    51 }
    52 
    53 
    54 OptionsObject* OptionsObjectParse( char* name, const mxArray* prhs[]){
    55 
    56         OptionsObject* oobject=NULL;
    57         mxArray* lhs[1];
    58 
    59 /*  parse the value according to the matlab data type  */
    60 
     17/*FUNCTION OptionParse{{{1*/
     18Option* OptionParse(char* name, const mxArray* prhs[]){
     19
     20        Option *oobject = NULL;
     21        mxArray       *lhs[1];
     22
     23        /*parse the value according to the matlab data type  */
    6124        if      (mxIsDouble(prhs[0]))
    62                 oobject=(OptionsObject*)OptionsDoubleParse(name,prhs);
     25                oobject=(Option*)OptionsDoubleParse(name,prhs);
    6326        else if (mxIsLogical(prhs[0]))
    64                 oobject=(OptionsObject*)OptionsLogicalParse(name,prhs);
     27                oobject=(Option*)OptionsLogicalParse(name,prhs);
    6528        else if (mxIsChar(prhs[0]))
    66                 oobject=(OptionsObject*)OptionsCharParse(name,prhs);
     29                oobject=(Option*)OptionsCharParse(name,prhs);
    6730        else if (mxIsStruct(prhs[0]))
    68                 oobject=(OptionsObject*)OptionsStructParse(name,prhs);
     31                oobject=(Option*)OptionsStructParse(name,prhs);
    6932        else if (mxIsCell(prhs[0]))
    70                 oobject=(OptionsObject*)OptionsCellParse(name,prhs);
     33                oobject=(Option*)OptionsCellParse(name,prhs);
    7134        else {
    72                 _printf_(true,"  Converting value of option \"%s\" from unrecognized class \"%s\" to class \"%s\".\n",
    73                                  name,mxGetClassName(prhs[0]),"struct");
     35                _printf_(true,"  Converting value of option \"%s\" from unrecognized class \"%s\" to class \"%s\".\n",name,mxGetClassName(prhs[0]),"struct");
    7436                if (!mexCallMATLAB(1,lhs,1,(mxArray**)prhs,"struct")) {
    75                         oobject=(OptionsObject*)OptionsStructParse(name,(const mxArray**)lhs);
     37                        oobject=(Option*)OptionsStructParse(name,(const mxArray**)lhs);
    7638                        mxDestroyArray(lhs[0]);
    7739                }
    78                 else
    79                         _error_("Second argument value of option \"%s\" is of unrecognized class \"%s\".",
    80                                         name,mxGetClassName(prhs[0]));
     40                else _error_("Second argument value of option \"%s\" is of unrecognized class \"%s\".",name,mxGetClassName(prhs[0]));
    8141        }
    8242
    8343        return(oobject);
    84 }
    85 
    86 
     44}/*}}}*/
     45/*FUNCTION OptionsDoubleParse {{{1*/
    8746OptionsDouble* OptionsDoubleParse( char* name, const mxArray* prhs[]){
    8847
    89         int   i;
    90         OptionsDouble* odouble=NULL;
    91         const mwSize* ipt=NULL;
    92 
    93 /*  check and parse the name  */
    94 
     48        OptionsDouble *odouble = NULL;
     49        const mwSize  *ipt     = NULL;
     50
     51        /*check and parse the name  */
    9552        odouble=new OptionsDouble;
    9653        odouble->name =(char *) xmalloc((strlen(name)+1)*sizeof(char));
    9754        strcpy(odouble->name,name);
    9855
    99 /*  check and parse the value  */
    100 
    101         if (!mxIsDouble(prhs[0]))
    102                 _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",
    103                                 odouble->name,"double",odouble->name,mxGetClassName(prhs[0]));
     56        /*check and parse the value  */
     57        if (!mxIsDouble(prhs[0])){
     58                _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",odouble->name,"double",odouble->name,mxGetClassName(prhs[0]));
     59        }
    10460
    10561        odouble->numel=mxGetNumberOfElements(prhs[0]);
    … …  
    10763        ipt           =mxGetDimensions(prhs[0]);
    10864        odouble->size =(int *) xmalloc(odouble->ndims*sizeof(int));
    109         for (i=0; i<odouble->ndims; i++)
    110                 odouble->size[i]=(int)ipt[i];
    111 
    112 //  note that FetchData does not correctly handle ndims >= 3
     65        for (int i=0; i<odouble->ndims; i++) odouble->size[i]=(int)ipt[i];
     66
     67        //  note that FetchData does not correctly handle ndims >= 3
    11368        if (odouble->ndims > 2) {
    114                 _printf_(true,"WARNING -- option \"%s\" of class \"%s\" has ndims=%d and will be skipped.\n",
    115                                  odouble->name,mxGetClassName(prhs[0]),odouble->ndims);
    116         }
    117         else
    118                 FetchData(&odouble->values,NULL,NULL,prhs[0]);
    119 
    120         odouble->DeepEcho();
     69                _printf_(true,"WARNING -- option \"%s\" of class \"%s\" has ndims=%d and will be skipped.\n",odouble->name,mxGetClassName(prhs[0]),odouble->ndims);
     70        }
     71        else FetchData(&odouble->values,NULL,NULL,prhs[0]);
    12172
    12273        return(odouble);
    123 }
    124 
    125 
     74}/*}}}*/
     75/*FUNCTION OptionsLogicalParse {{{1*/
    12676OptionsLogical* OptionsLogicalParse( char* name, const mxArray* prhs[]){
    12777
    128         int   i;
    129         OptionsLogical* ological=NULL;
    130         const mwSize* ipt=NULL;
    131         bool  btemp;
    132 
    133 /*  check and parse the name  */
    134 
     78        OptionsLogical *ological = NULL;
     79        const mwSize   *ipt      = NULL;
     80        bool            btemp;
     81
     82        /*check and parse the name  */
    13583        ological=new OptionsLogical;
    13684        ological->name =(char *) xmalloc((strlen(name)+1)*sizeof(char));
    13785        strcpy(ological->name,name);
    13886
    139 /*  check and parse the value  */
    140 
    141         if (!mxIsLogical(prhs[0]))
    142                 _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",
    143                                 ological->name,"logical",ological->name,mxGetClassName(prhs[0]));
     87        /*check and parse the value  */
     88        if (!mxIsLogical(prhs[0])){
     89                _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ological->name,"logical",ological->name,mxGetClassName(prhs[0]));
     90        }
    14491
    14592        ological->numel=mxGetNumberOfElements(prhs[0]);
    … …  
    14794        ipt            =mxGetDimensions(prhs[0]);
    14895        ological->size =(int *) xmalloc(ological->ndims*sizeof(int));
    149         for (i=0; i<ological->ndims; i++)
    150                 ological->size[i]=(int)ipt[i];
    151 
    152 //  note that FetchData does not correctly handle non-scalar logicals
     96        for (int i=0; i<ological->ndims; i++) ological->size[i]=(int)ipt[i];
     97
     98        //  note that FetchData does not correctly handle non-scalar logicals
    15399        if (ological->ndims > 2 || ological->size[0] > 1 || ological->size[1] > 1) {
    154                 _printf_(true,"WARNING -- option \"%s\" of class \"%s\" is more than [1x1] and will be skipped.\n",
    155                                  ological->name,mxGetClassName(prhs[0]));
     100                _printf_(true,"WARNING -- option \"%s\" of class \"%s\" is more than [1x1] and will be skipped.\n",ological->name,mxGetClassName(prhs[0]));
    156101        }
    157102        else {
    158 //              FetchData(&ological->values,prhs[0]);
    159 //  could be memory leak until FetchData handles logical arrays
     103                //FetchData(&ological->values,prhs[0]);
     104                //could be memory leak until FetchData handles logical arrays
    160105                ological->values=(bool *) xmalloc(sizeof(bool));
    161106                FetchData(ological->values,prhs[0]);
    162107        }
    163108
    164         ological->DeepEcho();
    165 
    166109        return(ological);
    167 }
    168 
    169 
     110}/*}}}*/
     111/*FUNCTION OptionsCharParse {{{1*/
    170112OptionsChar* OptionsCharParse( char* name, const mxArray* prhs[]){
    171113
    172         int   i;
    173         OptionsChar* ochar=NULL;
    174         const mwSize* ipt=NULL;
    175 
    176 /*  check and parse the name  */
    177 
     114        OptionsChar  *ochar = NULL;
     115        const mwSize *ipt   = NULL;
     116
     117        /*check and parse the name  */
    178118        ochar=new OptionsChar;
    179119        ochar->name =(char *) xmalloc((strlen(name)+1)*sizeof(char));
    180120        strcpy(ochar->name,name);
    181121
    182 /*  check and parse the value  */
    183 
    184         if (!mxIsChar(prhs[0]))
    185                 _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",
    186                                 ochar->name,"char",ochar->name,mxGetClassName(prhs[0]));
     122        /*check and parse the value  */
     123        if (!mxIsChar(prhs[0])){
     124                _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ochar->name,"char",ochar->name,mxGetClassName(prhs[0]));
     125        }
    187126
    188127        ochar->numel=mxGetNumberOfElements(prhs[0]);
    … …  
    190129        ipt         =mxGetDimensions(prhs[0]);
    191130        ochar->size =(int *) xmalloc(ochar->ndims*sizeof(int));
    192         for (i=0; i<ochar->ndims; i++)
    193                 ochar->size[i]=(int)ipt[i];
    194 
    195 //  note that FetchData does not correctly handle ndims >= 2 or multiple rows
     131        for(int i=0; i<ochar->ndims; i++) ochar->size[i]=(int)ipt[i];
     132
     133        //note that FetchData does not correctly handle ndims >= 2 or multiple rows
    196134        if (ochar->ndims > 2 || ochar->size[0] > 1) {
    197                 _printf_(true,"WARNING -- option \"%s\" of class \"%s\" is more than [1xn] and will be skipped.\n",
    198                                  ochar->name,mxGetClassName(prhs[0]));
    199         }
    200         else
    201                 FetchData(&ochar->values,prhs[0]);
    202 
    203         ochar->DeepEcho();
     135                _printf_(true,"WARNING -- option \"%s\" of class \"%s\" is more than [1xn] and will be skipped.\n",ochar->name,mxGetClassName(prhs[0]));
     136        }
     137        else FetchData(&ochar->values,prhs[0]);
    204138
    205139        return(ochar);
    206 }
    207 
    208 
     140}/*}}}*/
     141/*FUNCTION OptionsStructParse {{{1*/
    209142OptionsStruct* OptionsStructParse( char* name, const mxArray* prhs[]){
    210143
    211         int   i;
    212         char  namei[161];
    213         OptionsStruct* ostruct=NULL;
    214         OptionsObject* oobject=NULL;
    215         const mwSize*  ipt=NULL;
    216         const mxArray* structi;
     144        int            i;
     145        char           namei[161];
     146        OptionsStruct *ostruct    = NULL;
     147        Option *oobject    = NULL;
     148        const mwSize  *ipt        = NULL;
     149        const mxArray *structi;
    217150        mwIndex        sindex;
    218151
    219 /*  check and parse the name  */
    220 
     152        /*check and parse the name  */
    221153        ostruct=new OptionsStruct;
    222154        ostruct->name =(char *) xmalloc((strlen(name)+1)*sizeof(char));
    223155        strcpy(ostruct->name,name);
    224156
    225 /*  check and parse the value  */
    226 
    227         if (!mxIsStruct(prhs[0]))
    228                 _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",
    229                                 ostruct->name,"struct",ostruct->name,mxGetClassName(prhs[0]));
     157        /*check and parse the value  */
     158        if (!mxIsStruct(prhs[0])){
     159                _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ostruct->name,"struct",ostruct->name,mxGetClassName(prhs[0]));
     160        }
    230161
    231162        ostruct->numel=mxGetNumberOfElements(prhs[0]);
    … …  
    233164        ipt           =mxGetDimensions(prhs[0]);
    234165        ostruct->size =(int *) xmalloc(ostruct->ndims*sizeof(int));
    235         for (i=0; i<ostruct->ndims; i++)
    236                 ostruct->size[i]=(int)ipt[i];
    237         if (ostruct->numel)
    238                 ostruct->values=(DataSet **) xmalloc(ostruct->numel*sizeof(DataSet *));
    239 
    240 /*  loop through and process each element of the struct array  */
    241 
     166        for (i=0; i<ostruct->ndims; i++) ostruct->size[i]=(int)ipt[i];
     167        if (ostruct->numel) ostruct->values=(Options**) xmalloc(ostruct->numel*sizeof(Options *));
     168
     169        /*loop through and process each element of the struct array  */
    242170        for (sindex=0; sindex<ostruct->numel; sindex++) {
    243                 ostruct->values[sindex]=new DataSet;
    244 
    245 /*  loop through and process each field for the element  */
    246 
     171                ostruct->values[sindex]=new Options;
     172
     173                /*loop through and process each field for the element  */
    247174                for (i=0; i<mxGetNumberOfFields(prhs[0]); i++) {
    248175                        sprintf(namei,"%s.%s",name,mxGetFieldNameByNumber(prhs[0],i));
    249176                        structi=mxGetFieldByNumber(prhs[0],sindex,i);
    250177
    251                         oobject=(OptionsObject*)OptionsObjectParse(namei,&structi);
     178                        oobject=(Option*)OptionParse(namei,&structi);
    252179                        ostruct->values[sindex]->AddObject((Object*)oobject);
    253180                        oobject=NULL;
    … …  
    255182        }
    256183
    257         ostruct->DeepEcho();
    258 
    259184        return(ostruct);
    260 }
    261 
    262 
     185}/*}}}*/
     186/*FUNCTION OptionsCellParse {{{1*/
    263187OptionsCell* OptionsCellParse( char* name, const mxArray* prhs[]){
    264188
    265         int   i;
    266         int*  dims;
    267         char  namei[161];
    268         char  cstr[81];
    269         OptionsCell*   ocell=NULL;
    270         OptionsObject* oobject=NULL;
    271         const mwSize*  ipt=NULL;
    272         const mxArray* celli;
     189        int            i;
     190        int           *dims;
     191        char           namei[161];
     192        char           cstr[81];
     193        OptionsCell   *ocell      = NULL;
     194        Option *oobject    = NULL;
     195        const mwSize  *ipt        = NULL;
     196        const mxArray *celli;
    273197        mwIndex        cindex;
    274198
    275 /*  check and parse the name  */
    276 
     199        /*check and parse the name  */
    277200        ocell=new OptionsCell;
    278201        ocell->name =(char *) xmalloc((strlen(name)+1)*sizeof(char));
    279202        strcpy(ocell->name,name);
    280203
    281 /*  check and parse the value  */
    282 
    283         if (!mxIsCell(prhs[0]))
    284                 _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",
    285                                 ocell->name,"cell",ocell->name,mxGetClassName(prhs[0]));
     204        /*check and parse the value  */
     205        if (!mxIsCell(prhs[0])){
     206                _error_("Value of option \"%s\" must be class \"%s\", not class \"%s\".",ocell->name,"cell",ocell->name,mxGetClassName(prhs[0]));
     207        }
    286208
    287209        ocell->numel=mxGetNumberOfElements(prhs[0]);
    … …  
    291213        for (i=0; i<ocell->ndims; i++)
    292214                ocell->size[i]=(int)ipt[i];
    293         ocell->values=new DataSet;
    294 
    295 /*  loop through and process each element of the cell array  */
    296 
     215        ocell->values=new Options;
     216
     217        /*loop through and process each element of the cell array  */
    297218        dims=(int *) xmalloc(ocell->ndims*sizeof(int));
    298219        for (cindex=0; cindex<ocell->numel; cindex++) {
    299                 ColumnWiseDimsFromIndex(dims,
    300                                                                 (int)cindex,
    301                                                                 ocell->size,
    302                                                                 ocell->ndims);
    303                 StringFromDims(cstr,
    304                                            dims,
    305                                            ocell->ndims);
     220                ColumnWiseDimsFromIndex(dims,(int)cindex,ocell->size,ocell->ndims);
     221                StringFromDims(cstr,dims,ocell->ndims);
    306222                sprintf(namei,"%s%s",name,cstr);
    307223                celli=mxGetCell(prhs[0],cindex);
    308224
    309                 oobject=(OptionsObject*)OptionsObjectParse(namei,&celli);
     225                oobject=(Option*)OptionParse(namei,&celli);
    310226                ocell->values->AddObject((Object*)oobject);
    311227                oobject=NULL;
    … …  
    313229        xfree((void**)&dims);
    314230
    315         ocell->DeepEcho();
    316 
    317231        return(ocell);
    318 }
     232}/*}}}*/
    319233
    320234#endif

  • issm/trunk/src/c/io/io.h

    r7732 r7737  
    5858void FetchParams(Parameters** pparameters, DataHandle dataref);
    5959
    60 DataSet* OptionsParse( int istart, int nrhs, const mxArray* prhs[]);
    61 OptionsObject* OptionsObjectParse( char* name, const mxArray* prhs[]);
    62 OptionsDouble* OptionsDoubleParse( char* name, const mxArray* prhs[]);
    63 OptionsLogical* OptionsLogicalParse( char* name, const mxArray* prhs[]);
    64 OptionsChar* OptionsCharParse( char* name, const mxArray* prhs[]);
    65 OptionsStruct* OptionsStructParse( char* name, const mxArray* prhs[]);
    66 OptionsCell* OptionsCellParse( char* name, const mxArray* prhs[]);
     60Option* OptionParse(char* name, const mxArray* prhs[]);
     61OptionsDouble*   OptionsDoubleParse( char* name, const mxArray* prhs[]);
     62OptionsLogical*  OptionsLogicalParse( char* name, const mxArray* prhs[]);
     63OptionsChar*     OptionsCharParse( char* name, const mxArray* prhs[]);
     64OptionsStruct*   OptionsStructParse( char* name, const mxArray* prhs[]);
     65OptionsCell*     OptionsCellParse( char* name, const mxArray* prhs[]);
    6766
    6867#endif

  • issm/trunk/src/c/modules/GroundingLineMigrationx/GroundingLineMigrationx.cpp

    r7323 r7737  
    2525        if(migration_style==AgressiveMigrationEnum) AgressiveMigration(elements,nodes, vertices,loads,materials, parameters);
    2626        else if(migration_style==SoftMigrationEnum) SoftMigration(elements,nodes, vertices,loads,materials, parameters);
    27         else if(migration_style==NoneEnum)_printf_("%s\n","NoneEnum supplied for migration style, doing nothing!");
     27        else if(migration_style==NoneEnum) _printf_(true,"%s\n","NoneEnum supplied for migration style, doing nothing!");
    2828        else _error_("%s not supported yet!",EnumToString(migration_style));
    2929

  • issm/trunk/src/c/objects/Options/Option.cpp

    r7733 r7737  
    1 /*!\file OptionsObject.cpp
     1/*!\file Option.cpp
    22 * \brief: implementation of the optionsobject abstract object
    33 */
    … …  
    2020
    2121/*Constructors/destructor/copy*/
    22 /*FUNCTION OptionsObject::OptionsObject(){{{1*/
    23 OptionsObject::OptionsObject(){
     22/*FUNCTION Option::Option(){{{1*/
     23Option::Option(){
    2424
    25         name      =NULL;
    26         numel     =0;
    27         ndims     =0;
    28         size      =NULL;
     25        name  =NULL;
     26        numel =0;
     27        ndims =0;
     28        size  =NULL;
    2929
    3030}
    3131/*}}}*/
    32 /*FUNCTION OptionsObject::~OptionsObject(){{{1*/
    33 OptionsObject::~OptionsObject(){
     32/*FUNCTION Option::~Option(){{{1*/
     33Option::~Option(){
    3434
    35         if (size) xfree((void**)&size);
    36         if (name) xfree((void**)&name);
     35        if(size) xfree((void**)&size);
     36        if(name) xfree((void**)&name);
    3737
    3838}
    … …  
    4040
    4141/*Other*/
    42 /*FUNCTION OptionsObject::Echo {{{1*/
    43 void  OptionsObject::Echo(){
     42/*FUNCTION Option::Echo {{{1*/
     43void  Option::Echo(){
    4444
    4545        char  cstr[81];
    … …  
    4949        _printf_(flag,"         numel: %d\n"     ,numel);
    5050        _printf_(flag,"         ndims: %d\n"     ,ndims);
    51         if (size) {
    52                 StringFromSize(cstr,
    53                                            size,
    54                                            ndims);
     51        if(size){
     52                StringFromSize(cstr,size,ndims);
    5553                _printf_(flag,"          size: %s\n" ,cstr);
    5654        }
    57         else
    58                 _printf_(flag,"          size: [empty]\n" );
     55        else _printf_(flag,"          size: [empty]\n" );
     56}
     57/*}}}*/
     58/*FUNCTION Option::DeepEcho() {{{1*/
     59void  Option::DeepEcho(){
     60
     61        char  indent[81]="";
     62
     63        Option::DeepEcho(indent);
    5964
    6065        return;
    6166}
    6267/*}}}*/
    63 
    64 /*FUNCTION OptionsObject::DeepEcho {{{1*/
    65 void  OptionsObject::DeepEcho(){
    66 
    67         char  indent[81]="";
    68 
    69         OptionsObject::DeepEcho(indent);
    70 
    71         return;
    72 }
    73 /*}}}*/
    74 
    75 /*FUNCTION OptionsObject::DeepEcho {{{1*/
    76 void  OptionsObject::DeepEcho(char* indent){
     68/*FUNCTION Option::DeepEcho(char* indent) {{{1*/
     69void  Option::DeepEcho(char* indent){
    7770
    7871        char  cstr[81];
    … …  
    8275        _printf_(flag,"%s         numel: %d\n"     ,indent,numel);
    8376        _printf_(flag,"%s         ndims: %d\n"     ,indent,ndims);
    84         if (size) {
    85                 StringFromSize(cstr,
    86                                            size,
    87                                            ndims);
     77        if(size){
     78                StringFromSize(cstr,size,ndims);
    8879                _printf_(flag,"%s          size: %s\n" ,indent,cstr);
    8980        }
    90         else
    91                 _printf_(flag,"%s          size: [empty]\n" ,indent);
    92 
    93         return;
     81        else _printf_(flag,"%s          size: [empty]\n" ,indent);
    9482}
    9583/*}}}*/
    96 
    97 /*FUNCTION OptionsObject::Name {{{1*/
    98 char* OptionsObject::Name(){
     84/*FUNCTION Option::Name {{{1*/
     85char* Option::Name(){
    9986
    10087        return(name);
    10188}
    10289/*}}}*/
    103 
    104 /*FUNCTION OptionsObject::NumEl {{{1*/
    105 int   OptionsObject::NumEl(){
     90/*FUNCTION Option::NumEl {{{1*/
     91int   Option::NumEl(){
    10692
    10793        return(numel);
    10894}
    10995/*}}}*/
    110 
    111 /*FUNCTION OptionsObject::NDims {{{1*/
    112 int   OptionsObject::NDims(){
     96/*FUNCTION Option::NDims {{{1*/
     97int   Option::NDims(){
    11398
    11499        return(ndims);
    115100}
    116101/*}}}*/
    117 
    118 /*FUNCTION OptionsObject::Size {{{1*/
    119 int*  OptionsObject::Size(){
     102/*FUNCTION Option::Size {{{1*/
     103int*  Option::Size(){
    120104
    121105        return(size);
    122106}
    123107/*}}}*/
    124 
    125 /*FUNCTION OptionsObject::Get {{{1*/
    126 //void* OptionsObject::Get(){
     108/*FUNCTION Option::Get {{{1*/
     109//void* Option::Get(){
    127110
    128111//      ;
    … …  
    131114//}
    132115/*}}}*/
    133 
    134 /*FUNCTION OptionsObject::Id {{{1*/
    135 int   OptionsObject::Id(){
    136 }
    137 /*}}}*/
    138 
    139 /*FUNCTION OptionsObject::MyRank {{{1*/
    140 int   OptionsObject::MyRank(){
    141 }
    142 /*}}}*/
    143 
    144 /*FUNCTION OptionsObject::Marshall {{{1*/
    145 void  OptionsObject::Marshall(char** pmarshalled_dataset){
    146 }
    147 /*}}}*/
    148 
    149 /*FUNCTION OptionsObject::MarshallSize {{{1*/
    150 int   OptionsObject::MarshallSize(){
    151 }
    152 /*}}}*/
    153 
    154 /*FUNCTION OptionsObject::Demarshall {{{1*/
    155 void  OptionsObject::Demarshall(char** pmarshalled_dataset){
    156 }
    157 /*}}}*/
    158 
    159 /*FUNCTION OptionsObject::Enum {{{1*/
    160 int   OptionsObject::Enum(){
    161 }
    162 /*}}}*/
    163 
    164 /*FUNCTION OptionsObject::copy {{{1*/
    165 Object* OptionsObject::copy(){
    166 }
    167 /*}}}*/
    168 

  • issm/trunk/src/c/objects/Options/Option.h

    r7733 r7737  
    1 /*! \file OptionsObject.h
     1/*! \file Option.h
    22 *  \brief: header file for optionsobject abstract object
    33 */
    … …  
    1414/*}}}*/
    1515
    16 class OptionsObject: public Object {
     16class Option: public Object {
    1717
    1818        public:
    … …  
    2323                int*  size;
    2424
    25                 /*OptionsObject constructors, destructors {{{1*/
    26                 OptionsObject();
    27                 ~OptionsObject();
     25                /*Option constructors, destructors {{{1*/
     26                Option();
     27                ~Option();
    2828                /*}}}*/
    2929                /*Object virtual functions definitions:{{{1*/
    … …  
    3131                void  DeepEcho();
    3232                void  DeepEcho(char* indent);
    33                 int   Id();
    34                 int   MyRank();
    35                 void  Marshall(char** pmarshalled_dataset);
    36                 int   MarshallSize();
    37                 void  Demarshall(char** pmarshalled_dataset);
    38                 int   Enum();
    39                 Object* copy();
     33                int   Id(){_error_("Not implemented yet");};
     34                int   MyRank(){_error_("Not implemented yet");};
     35                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     36                int   MarshallSize(){_error_("Not implemented yet");};
     37                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     38                int   Enum(){_error_("Not implemented yet");};
     39                Object* copy(){_error_("Not implemented yet");};
    4040                /*}}}*/
    4141

  • issm/trunk/src/c/objects/Options/OptionsCell.cpp

    r7731 r7737  
    3030OptionsCell::~OptionsCell(){
    3131
    32         if (values) {
     32        if (values){
    3333                delete values;
    3434                values    =NULL;
    … …  
    4242void  OptionsCell::Echo(){
    4343
    44         char  cstr[81];
    45         bool  flag=true;
     44        char cstr[81];
     45        bool flag     = true;
    4646
    4747        _printf_(flag,"OptionsCell Echo:\n");
    48         OptionsObject::Echo();
     48        Option::Echo();
    4949
    5050        if (values && size) {
    51                 StringFromSize(cstr,
    52                                            size,
    53                                            ndims);
     51                StringFromSize(cstr,size,ndims);
    5452                _printf_(flag,"        values: %s %s\n" ,cstr,"cell");
    5553        }
    56         else
    57                 _printf_(flag,"        values: [empty]\n" );
    58 
    59         return;
     54        else _printf_(flag,"        values: [empty]\n" );
    6055}
    6156/*}}}*/
    62 
    63 /*FUNCTION OptionsCell::DeepEcho {{{1*/
     57/*FUNCTION OptionsCell::DeepEcho() {{{1*/
    6458void  OptionsCell::DeepEcho(){
    6559
    … …  
    7165}
    7266/*}}}*/
    73 
    74 /*FUNCTION OptionsCell::DeepEcho {{{1*/
     67/*FUNCTION OptionsCell::DeepEcho(char* indent) {{{1*/
    7568void  OptionsCell::DeepEcho(char* indent){
    7669
    … …  
    8275
    8376        _printf_(flag,"%sOptionsCell DeepEcho:\n",indent);
    84         OptionsObject::DeepEcho(indent);
     77        Option::DeepEcho(indent);
    8578
    8679        strcpy(indent2,indent);
    … …  
    9083                dims=(int *) xmalloc(ndims*sizeof(int));
    9184                for (i=0; i<values->Size(); i++) {
    92                         ColumnWiseDimsFromIndex(dims,
    93                                                                         i,
    94                                                                         size,
    95                                                                         ndims);
    96                         StringFromDims(cstr,
    97                                                    dims,
    98                                                    ndims);
     85                        ColumnWiseDimsFromIndex(dims,i,size,ndims);
     86                        StringFromDims(cstr,dims,ndims);
    9987                        _printf_(flag,"%s        values: %s begin\n" ,indent,cstr);
    100                         ((OptionsObject *)values->GetObjectByOffset(i))->DeepEcho(indent2);
     88                        ((Option *)values->GetObjectByOffset(i))->DeepEcho(indent2);
    10189                        _printf_(flag,"%s        values: %s end\n"   ,indent,cstr);
    10290                }
    10391                xfree((void**)&dims);
    10492        }
    105         else
    106                 _printf_(flag,"%s        values: [empty]\n" ,indent);
    107 
    108         return;
     93        else _printf_(flag,"%s        values: [empty]\n" ,indent);
    10994}
    11095/*}}}*/
    111 
    11296/*FUNCTION OptionsCell::Name {{{1*/
    11397char* OptionsCell::Name(){
    11498
    115         return(OptionsObject::Name());
     99        return(Option::Name());
    116100}
    117101/*}}}*/
    118 
    119102/*FUNCTION OptionsCell::NumEl {{{1*/
    120103int   OptionsCell::NumEl(){
    121104
    122         return(OptionsObject::NumEl());
     105        return(Option::NumEl());
    123106}
    124107/*}}}*/
    125 
    126108/*FUNCTION OptionsCell::NDims {{{1*/
    127109int   OptionsCell::NDims(){
    128110
    129         return(OptionsObject::NDims());
     111        return(Option::NDims());
    130112}
    131113/*}}}*/
    132 
    133114/*FUNCTION OptionsCell::Size {{{1*/
    134115int*  OptionsCell::Size(){
    135116
    136         return(OptionsObject::Size());
     117        return(Option::Size());
    137118}
    138119/*}}}*/
    139 
    140120/*FUNCTION OptionsCell::Get {{{1*/
    141121//void* OptionsCell::Get(){
    … …  
    146126//}
    147127/*}}}*/
    148 
    149 /*FUNCTION OptionsCell::Id {{{1*/
    150 int   OptionsCell::Id(){
    151 }
    152 /*}}}*/
    153 
    154 /*FUNCTION OptionsCell::MyRank {{{1*/
    155 int   OptionsCell::MyRank(){
    156 }
    157 /*}}}*/
    158 
    159 /*FUNCTION OptionsCell::Marshall {{{1*/
    160 void  OptionsCell::Marshall(char** pmarshalled_dataset){
    161 }
    162 /*}}}*/
    163 
    164 /*FUNCTION OptionsCell::MarshallSize {{{1*/
    165 int   OptionsCell::MarshallSize(){
    166 }
    167 /*}}}*/
    168 
    169 /*FUNCTION OptionsCell::Demarshall {{{1*/
    170 void  OptionsCell::Demarshall(char** pmarshalled_dataset){
    171 }
    172 /*}}}*/
    173 
    174 /*FUNCTION OptionsCell::Enum {{{1*/
    175 int   OptionsCell::Enum(){
    176 }
    177 /*}}}*/
    178 
    179 /*FUNCTION OptionsCell::copy {{{1*/
    180 Object* OptionsCell::copy(){
    181 }
    182 /*}}}*/
    183 

  • issm/trunk/src/c/objects/Options/OptionsCell.h

    r7731 r7737  
    1111#include "../../EnumDefinitions/EnumDefinitions.h"
    1212
    13 #include "./OptionsObject.h"
     13#include "./Option.h"
    1414/*}}}*/
    1515
    16 class OptionsCell: public OptionsObject {
     16class OptionsCell: public Option {
    1717
    1818        public:
    1919
    20                 DataSet* values;
     20                Options* values;
    2121
    2222                /*OptionsCell constructors, destructors {{{1*/
    … …  
    2828                void  DeepEcho();
    2929                void  DeepEcho(char* indent);
    30                 int   Id();
    31                 int   MyRank();
    32                 void  Marshall(char** pmarshalled_dataset);
    33                 int   MarshallSize();
    34                 void  Demarshall(char** pmarshalled_dataset);
    35                 int   Enum();
    36                 Object* copy();
     30                int   Id(){_error_("Not implemented yet");};
     31                int   MyRank(){_error_("Not implemented yet");};
     32                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     33                int   MarshallSize(){_error_("Not implemented yet");};
     34                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     35                int   Enum(){_error_("Not implemented yet");};
     36                Object* copy(){_error_("Not implemented yet");};
    3737                /*}}}*/
    3838

  • issm/trunk/src/c/objects/Options/OptionsChar.cpp

    r7731 r7737  
    4343
    4444        _printf_(flag,"OptionsChar Echo:\n");
    45         OptionsObject::Echo();
     45        Option::Echo();
    4646
    4747        if (values && size) {
    … …  
    5252                }
    5353                else {
    54                         StringFromSize(cstr,
    55                                                    size,
    56                                                    ndims);
     54                        StringFromSize(cstr,size,ndims);
    5755                        _printf_(flag,"        values: %s %s\n" ,cstr,"char");
    5856                }
    5957        }
    60         else
    61                 _printf_(flag,"        values: [empty]\n" );
    62 
    63         return;
     58        else _printf_(flag,"        values: [empty]\n" );
    6459}
    6560/*}}}*/
    66 
    67 /*FUNCTION OptionsChar::DeepEcho {{{1*/
     61/*FUNCTION OptionsChar::DeepEcho() {{{1*/
    6862void  OptionsChar::DeepEcho(){
    6963
    … …  
    7569}
    7670/*}}}*/
    77 
    78 /*FUNCTION OptionsChar::DeepEcho {{{1*/
     71/*FUNCTION OptionsChar::DeepEcho(char* indent) {{{1*/
    7972void  OptionsChar::DeepEcho(char* indent){
    8073
    … …  
    8679
    8780        _printf_(flag,"%sOptionsChar DeepEcho:\n",indent);
    88         OptionsObject::DeepEcho(indent);
     81        Option::DeepEcho(indent);
    8982
    9083        strcpy(indent2,indent);
    … …  
    10093                        dims=(int *) xmalloc(ndims*sizeof(int));
    10194                        for (i=0; i<numel; i++) {
    102                                 RowWiseDimsFromIndex(dims,
    103                                                                          i,
    104                                                                          size,
    105                                                                          ndims);
    106                                 StringFromDims(cstr,
    107                                                            dims,
    108                                                            ndims);
     95                                RowWiseDimsFromIndex(dims,i,size,ndims);
     96                                StringFromDims(cstr,dims,ndims);
    10997                                _printf_(flag,"%s        values%s: \"%s\"\n" ,indent,cstr,values[i]);
    11098                        }
    … …  
    112100                }
    113101        }
    114         else
    115                 _printf_(flag,"%s        values: [empty]\n" ,indent);
    116 
    117         return;
     102        else _printf_(flag,"%s        values: [empty]\n" ,indent);
    118103}
    119104/*}}}*/
    120 
    121105/*FUNCTION OptionsChar::Name {{{1*/
    122106char* OptionsChar::Name(){
    123107
    124         return(OptionsObject::Name());
     108        return(Option::Name());
    125109}
    126110/*}}}*/
    127 
    128111/*FUNCTION OptionsChar::NumEl {{{1*/
    129112int   OptionsChar::NumEl(){
    130113
    131         return(OptionsObject::NumEl());
     114        return(Option::NumEl());
    132115}
    133116/*}}}*/
    134 
    135117/*FUNCTION OptionsChar::NDims {{{1*/
    136118int   OptionsChar::NDims(){
    137119
    138         return(OptionsObject::NDims());
     120        return(Option::NDims());
    139121}
    140122/*}}}*/
    141 
    142123/*FUNCTION OptionsChar::Size {{{1*/
    143124int*  OptionsChar::Size(){
    144125
    145         return(OptionsObject::Size());
     126        return(Option::Size());
    146127}
    147128/*}}}*/
    148 
    149129/*FUNCTION OptionsChar::Get {{{1*/
    150130//void* OptionsChar::Get(){
    … …  
    155135//}
    156136/*}}}*/
    157 
    158 /*FUNCTION OptionsChar::Id {{{1*/
    159 int   OptionsChar::Id(){
    160 }
    161 /*}}}*/
    162 
    163 /*FUNCTION OptionsChar::MyRank {{{1*/
    164 int   OptionsChar::MyRank(){
    165 }
    166 /*}}}*/
    167 
    168 /*FUNCTION OptionsChar::Marshall {{{1*/
    169 void  OptionsChar::Marshall(char** pmarshalled_dataset){
    170 }
    171 /*}}}*/
    172 
    173 /*FUNCTION OptionsChar::MarshallSize {{{1*/
    174 int   OptionsChar::MarshallSize(){
    175 }
    176 /*}}}*/
    177 
    178 /*FUNCTION OptionsChar::Demarshall {{{1*/
    179 void  OptionsChar::Demarshall(char** pmarshalled_dataset){
    180 }
    181 /*}}}*/
    182 
    183 /*FUNCTION OptionsChar::Enum {{{1*/
    184 int   OptionsChar::Enum(){
    185 }
    186 /*}}}*/
    187 
    188 /*FUNCTION OptionsChar::copy {{{1*/
    189 Object* OptionsChar::copy(){
    190 }
    191 /*}}}*/
    192 

  • issm/trunk/src/c/objects/Options/OptionsChar.h

    r7731 r7737  
    1111#include "../../EnumDefinitions/EnumDefinitions.h"
    1212
    13 #include "./OptionsObject.h"
     13#include "./Option.h"
    1414/*}}}*/
    1515
    16 class OptionsChar: public OptionsObject {
     16class OptionsChar: public Option {
    1717
    1818        public:
    … …  
    2828                void  DeepEcho();
    2929                void  DeepEcho(char* indent);
    30                 int   Id();
    31                 int   MyRank();
    32                 void  Marshall(char** pmarshalled_dataset);
    33                 int   MarshallSize();
    34                 void  Demarshall(char** pmarshalled_dataset);
    35                 int   Enum();
    36                 Object* copy();
     30                int   Id(){_error_("Not implemented yet");};
     31                int   MyRank(){_error_("Not implemented yet");};
     32                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     33                int   MarshallSize(){_error_("Not implemented yet");};
     34                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     35                int   Enum(){_error_("Not implemented yet");};
     36                Object* copy(){_error_("Not implemented yet");};
    3737                /*}}}*/
    3838

  • issm/trunk/src/c/objects/Options/OptionsDouble.cpp

    r7731 r7737  
    4343
    4444        _printf_(flag,"OptionsDouble Echo:\n");
    45         OptionsObject::Echo();
     45        Option::Echo();
    4646
    4747        if (values && size) {
    48                 if (numel == 1) {
    49                         _printf_(flag,"        values: %g\n" ,values[0]);
    50                 }
     48                if(numel == 1) _printf_(flag,"        values: %g\n" ,values[0]);
    5149                else {
    52                         StringFromSize(cstr,
    53                                                    size,
    54                                                    ndims);
     50                        StringFromSize(cstr,size,ndims);
    5551                        _printf_(flag,"        values: %s %s\n" ,cstr,"double");
    5652                }
    5753        }
    58         else
    59                 _printf_(flag,"        values: [empty]\n" );
    60 
    61         return;
     54        else _printf_(flag,"        values: [empty]\n" );
    6255}
    6356/*}}}*/
    64 
    65 /*FUNCTION OptionsDouble::DeepEcho {{{1*/
     57/*FUNCTION OptionsDouble::DeepEcho() {{{1*/
    6658void  OptionsDouble::DeepEcho(){
    6759
    … …  
    7365}
    7466/*}}}*/
    75 
    76 /*FUNCTION OptionsDouble::DeepEcho {{{1*/
     67/*FUNCTION OptionsDouble::DeepEcho(char* indent) {{{1*/
    7768void  OptionsDouble::DeepEcho(char* indent){
    7869
    … …  
    8475
    8576        _printf_(flag,"%sOptionsDouble DeepEcho:\n",indent);
    86         OptionsObject::DeepEcho(indent);
     77        Option::DeepEcho(indent);
    8778
    8879        strcpy(indent2,indent);
    … …  
    9182        if (values) {
    9283                dims=(int *) xmalloc(ndims*sizeof(int));
    93                 if (numel == 1) {
    94                         _printf_(flag,"%s        values: %g\n" ,indent,values[0]);
    95                 }
    96                 else {
     84                if(numel==1) _printf_(flag,"%s        values: %g\n" ,indent,values[0]);
     85                else{
    9786                        for (i=0; i<numel; i++) {
    98                                 RowWiseDimsFromIndex(dims,
    99                                                                          i,
    100                                                                          size,
    101                                                                          ndims);
    102                                 StringFromDims(cstr,
    103                                                            dims,
    104                                                            ndims);
     87                                RowWiseDimsFromIndex(dims,i,size,ndims);
     88                                StringFromDims(cstr,dims,ndims);
    10589                                _printf_(flag,"%s        values%s: %g\n" ,indent,cstr,values[i]);
    10690                        }
    … …  
    10892                xfree((void**)&dims);
    10993        }
    110         else
    111                 _printf_(flag,"%s        values: [empty]\n" ,indent);
    112 
    113         return;
     94        else _printf_(flag,"%s        values: [empty]\n" ,indent);
    11495}
    11596/*}}}*/
    116 
    11797/*FUNCTION OptionsDouble::Name {{{1*/
    11898char* OptionsDouble::Name(){
    11999
    120         return(OptionsObject::Name());
     100        return(Option::Name());
    121101}
    122102/*}}}*/
    123 
    124103/*FUNCTION OptionsDouble::NumEl {{{1*/
    125104int   OptionsDouble::NumEl(){
    126105
    127         return(OptionsObject::NumEl());
     106        return(Option::NumEl());
    128107}
    129108/*}}}*/
    130 
    131109/*FUNCTION OptionsDouble::NDims {{{1*/
    132110int   OptionsDouble::NDims(){
    133111
    134         return(OptionsObject::NDims());
     112        return(Option::NDims());
    135113}
    136114/*}}}*/
    137 
    138115/*FUNCTION OptionsDouble::Size {{{1*/
    139116int*  OptionsDouble::Size(){
    140117
    141         return(OptionsObject::Size());
     118        return(Option::Size());
    142119}
    143120/*}}}*/
    144 
    145121/*FUNCTION OptionsDouble::Get {{{1*/
    146122//void* OptionsDouble::Get(){
    … …  
    151127//}
    152128/*}}}*/
    153 
    154 /*FUNCTION OptionsDouble::Id {{{1*/
    155 int   OptionsDouble::Id(){
    156 }
    157 /*}}}*/
    158 
    159 /*FUNCTION OptionsDouble::MyRank {{{1*/
    160 int   OptionsDouble::MyRank(){
    161 }
    162 /*}}}*/
    163 
    164 /*FUNCTION OptionsDouble::Marshall {{{1*/
    165 void  OptionsDouble::Marshall(char** pmarshalled_dataset){
    166 }
    167 /*}}}*/
    168 
    169 /*FUNCTION OptionsDouble::MarshallSize {{{1*/
    170 int   OptionsDouble::MarshallSize(){
    171 }
    172 /*}}}*/
    173 
    174 /*FUNCTION OptionsDouble::Demarshall {{{1*/
    175 void  OptionsDouble::Demarshall(char** pmarshalled_dataset){
    176 }
    177 /*}}}*/
    178 
    179 /*FUNCTION OptionsDouble::Enum {{{1*/
    180 int   OptionsDouble::Enum(){
    181 }
    182 /*}}}*/
    183 
    184 /*FUNCTION OptionsDouble::copy {{{1*/
    185 Object* OptionsDouble::copy(){
    186 }
    187 /*}}}*/
    188 

  • issm/trunk/src/c/objects/Options/OptionsDouble.h

    r7731 r7737  
    1111#include "../../EnumDefinitions/EnumDefinitions.h"
    1212
    13 #include "./OptionsObject.h"
     13#include "./Option.h"
    1414/*}}}*/
    1515
    16 class OptionsDouble: public OptionsObject {
     16class OptionsDouble: public Option {
    1717
    1818        public:
    … …  
    2828                void  DeepEcho();
    2929                void  DeepEcho(char* indent);
    30                 int   Id();
    31                 int   MyRank();
    32                 void  Marshall(char** pmarshalled_dataset);
    33                 int   MarshallSize();
    34                 void  Demarshall(char** pmarshalled_dataset);
    35                 int   Enum();
    36                 Object* copy();
     30                int   Id(){_error_("Not implemented yet");};
     31                int   MyRank(){_error_("Not implemented yet");};
     32                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     33                int   MarshallSize(){_error_("Not implemented yet");};
     34                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     35                int   Enum(){_error_("Not implemented yet");};
     36                Object* copy(){_error_("Not implemented yet");};
    3737                /*}}}*/
    3838

  • issm/trunk/src/c/objects/Options/OptionsLogical.cpp

    r7731 r7737  
    4343
    4444        _printf_(flag,"OptionsLogical Echo:\n");
    45         OptionsObject::Echo();
     45        Option::Echo();
    4646
    4747        if (values && size) {
    48                 if (numel == 1) {
    49                         _printf_(flag,"        values: %s\n" ,(values[0] ? "true" : "false"));
    50                 }
    51                 else {
    52                         StringFromSize(cstr,
    53                                                    size,
    54                                                    ndims);
     48                if(numel == 1) _printf_(flag,"        values: %s\n" ,(values[0] ? "true" : "false"));
     49                else{
     50                        StringFromSize(cstr,size,ndims);
    5551                        _printf_(flag,"        values: %s %s\n" ,cstr,"logical");
    5652                }
    5753        }
    58         else
    59                 _printf_(flag,"        values: [empty]\n" );
    60 
    61         return;
     54        else _printf_(flag,"        values: [empty]\n" );
    6255}
    6356/*}}}*/
    64 
    65 /*FUNCTION OptionsLogical::DeepEcho {{{1*/
     57/*FUNCTION OptionsLogical::DeepEcho() {{{1*/
    6658void  OptionsLogical::DeepEcho(){
    6759
    … …  
    7365}
    7466/*}}}*/
    75 
    76 /*FUNCTION OptionsLogical::DeepEcho {{{1*/
     67/*FUNCTION OptionsLogical::DeepEcho(char* indent) {{{1*/
    7768void  OptionsLogical::DeepEcho(char* indent){
    7869
    … …  
    8475
    8576        _printf_(flag,"%sOptionsLogical DeepEcho:\n",indent);
    86         OptionsObject::DeepEcho(indent);
     77        Option::DeepEcho(indent);
    8778
    8879        strcpy(indent2,indent);
    … …  
    9081
    9182        if (values) {
    92                 if (numel == 1) {
    93                         _printf_(flag,"%s        values: %s\n" ,indent,(values[0] ? "true" : "false"));
    94                 }
    95                 else {
     83                if(numel==1) _printf_(flag,"%s        values: %s\n" ,indent,(values[0] ? "true" : "false"));
     84                else{
    9685                        dims=(int *) xmalloc(ndims*sizeof(int));
    9786                        for (i=0; i<numel; i++) {
    98                                 RowWiseDimsFromIndex(dims,
    99                                                                          i,
    100                                                                          size,
    101                                                                          ndims);
    102                                 StringFromDims(cstr,
    103                                                            dims,
    104                                                            ndims);
     87                                RowWiseDimsFromIndex(dims,i,size,ndims);
     88                                StringFromDims(cstr,dims,ndims);
    10589                                _printf_(flag,"%s        values%s: %s\n" ,indent,cstr,(values[i] ? "true" : "false"));
    10690                        }
    … …  
    10892                }
    10993        }
    110         else
    111                 _printf_(flag,"%s        values: [empty]\n" ,indent);
    112 
    113         return;
     94        else _printf_(flag,"%s        values: [empty]\n" ,indent);
    11495}
    11596/*}}}*/
    116 
    11797/*FUNCTION OptionsLogical::Name {{{1*/
    11898char* OptionsLogical::Name(){
    11999
    120         return(OptionsObject::Name());
     100        return(Option::Name());
    121101}
    122102/*}}}*/
    123 
    124103/*FUNCTION OptionsLogical::NumEl {{{1*/
    125104int   OptionsLogical::NumEl(){
    126105
    127         return(OptionsObject::NumEl());
     106        return(Option::NumEl());
    128107}
    129108/*}}}*/
    130 
    131109/*FUNCTION OptionsLogical::NDims {{{1*/
    132110int   OptionsLogical::NDims(){
    133111
    134         return(OptionsObject::NDims());
     112        return(Option::NDims());
    135113}
    136114/*}}}*/
    137 
    138115/*FUNCTION OptionsLogical::Size {{{1*/
    139116int*  OptionsLogical::Size(){
    140117
    141         return(OptionsObject::Size());
     118        return(Option::Size());
    142119}
    143120/*}}}*/
    144 
    145121/*FUNCTION OptionsLogical::Get {{{1*/
    146122//void* OptionsLogical::Get(){
    … …  
    151127//}
    152128/*}}}*/
    153 
    154 /*FUNCTION OptionsLogical::Id {{{1*/
    155 int   OptionsLogical::Id(){
    156 }
    157 /*}}}*/
    158 
    159 /*FUNCTION OptionsLogical::MyRank {{{1*/
    160 int   OptionsLogical::MyRank(){
    161 }
    162 /*}}}*/
    163 
    164 /*FUNCTION OptionsLogical::Marshall {{{1*/
    165 void  OptionsLogical::Marshall(char** pmarshalled_dataset){
    166 }
    167 /*}}}*/
    168 
    169 /*FUNCTION OptionsLogical::MarshallSize {{{1*/
    170 int   OptionsLogical::MarshallSize(){
    171 }
    172 /*}}}*/
    173 
    174 /*FUNCTION OptionsLogical::Demarshall {{{1*/
    175 void  OptionsLogical::Demarshall(char** pmarshalled_dataset){
    176 }
    177 /*}}}*/
    178 
    179 /*FUNCTION OptionsLogical::Enum {{{1*/
    180 int   OptionsLogical::Enum(){
    181 }
    182 /*}}}*/
    183 
    184 /*FUNCTION OptionsLogical::copy {{{1*/
    185 Object* OptionsLogical::copy(){
    186 }
    187 /*}}}*/
    188 

  • issm/trunk/src/c/objects/Options/OptionsLogical.h

    r7731 r7737  
    1111#include "../../EnumDefinitions/EnumDefinitions.h"
    1212
    13 #include "./OptionsObject.h"
     13#include "./Option.h"
    1414/*}}}*/
    1515
    16 class OptionsLogical: public OptionsObject {
     16class OptionsLogical: public Option {
    1717
    1818        public:
    … …  
    2828                void  DeepEcho();
    2929                void  DeepEcho(char* indent);
    30                 int   Id();
    31                 int   MyRank();
    32                 void  Marshall(char** pmarshalled_dataset);
    33                 int   MarshallSize();
    34                 void  Demarshall(char** pmarshalled_dataset);
    35                 int   Enum();
    36                 Object* copy();
     30                int   Id(){_error_("Not implemented yet");};
     31                int   MyRank(){_error_("Not implemented yet");};
     32                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     33                int   MarshallSize(){_error_("Not implemented yet");};
     34                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     35                int   Enum(){_error_("Not implemented yet");};
     36                Object* copy(){_error_("Not implemented yet");};
    3737                /*}}}*/
    3838

  • issm/trunk/src/c/objects/Options/OptionsStruct.cpp

    r7731 r7737  
    3232        int   i;
    3333
    34         if (values) {
    35                 for (i=0; i<numel; i++) {
     34        if(values){
     35                for(i=0; i<numel; i++) {
    3636                        delete values[i];
    3737                        values[i] =NULL;
    … …  
    5151
    5252        _printf_(flag,"OptionsStruct Echo:\n");
    53         OptionsObject::Echo();
     53        Option::Echo();
    5454
    5555        if (values && size) {
    56                 StringFromSize(cstr,
    57                                            size,
    58                                            ndims);
     56                StringFromSize(cstr,size,ndims);
    5957                _printf_(flag,"        values: %s %s\n" ,cstr,"struct");
    6058        }
    61         else
    62                 _printf_(flag,"        values: [empty]\n" );
    63 
    64         return;
     59        else _printf_(flag,"        values: [empty]\n" );
    6560}
    6661/*}}}*/
    67 
    68 /*FUNCTION OptionsStruct::DeepEcho {{{1*/
     62/*FUNCTION OptionsStruct::DeepEcho() {{{1*/
    6963void  OptionsStruct::DeepEcho(){
    7064
    … …  
    7670}
    7771/*}}}*/
    78 
    79 /*FUNCTION OptionsStruct::DeepEcho {{{1*/
     72/*FUNCTION OptionsStruct::DeepEcho(char* indent) {{{1*/
    8073void  OptionsStruct::DeepEcho(char* indent){
    8174
    … …  
    8780
    8881        _printf_(flag,"%sOptionsStruct DeepEcho:\n",indent);
    89         OptionsObject::DeepEcho(indent);
     82        Option::DeepEcho(indent);
    9083
    9184        strcpy(indent2,indent);
    … …  
    9386
    9487        if (values) {
    95                 dims=(int *) xmalloc(ndims*sizeof(int));
     88                dims=(int *)xmalloc(ndims*sizeof(int));
    9689                for (i=0; i<numel; i++) {
    97                         ColumnWiseDimsFromIndex(dims,
    98                                                                         i,
    99                                                                         size,
    100                                                                         ndims);
    101                         StringFromDims(cstr,
    102                                                    dims,
    103                                                    ndims);
    104                         if (values[i]->Size()) {
     90                        ColumnWiseDimsFromIndex(dims,i,size,ndims);
     91                        StringFromDims(cstr,dims,ndims);
     92                        if (values[i]->Size()){
    10593                                _printf_(flag,"%s        values: %s begin\n" ,indent,cstr);
    106                                 for (j=0; j<values[i]->Size(); j++)
    107                                         ((OptionsObject *)values[i]->GetObjectByOffset(j))->DeepEcho(indent2);
     94                                for (j=0; j<values[i]->Size(); j++) ((Option *)values[i]->GetObjectByOffset(j))->DeepEcho(indent2);
    10895                                _printf_(flag,"%s        values: %s end\n"   ,indent,cstr);
    10996                        }
    110                         else
    111                                 _printf_(flag,"%s        values: %s [empty]\n" ,indent,cstr);
     97                        else _printf_(flag,"%s        values: %s [empty]\n" ,indent,cstr);
    11298                }
    11399                xfree((void**)&dims);
    114100        }
    115         else
    116                 _printf_(flag,"%s        values: [empty]\n" ,indent);
    117 
    118         return;
     101        else _printf_(flag,"%s        values: [empty]\n" ,indent);
    119102}
    120103/*}}}*/
    121 
    122104/*FUNCTION OptionsStruct::Name {{{1*/
    123105char* OptionsStruct::Name(){
    124106
    125         return(OptionsObject::Name());
     107        return(Option::Name());
    126108}
    127109/*}}}*/
    128 
    129110/*FUNCTION OptionsStruct::NumEl {{{1*/
    130111int   OptionsStruct::NumEl(){
    131112
    132         return(OptionsObject::NumEl());
     113        return(Option::NumEl());
    133114}
    134115/*}}}*/
    135 
    136116/*FUNCTION OptionsStruct::NDims {{{1*/
    137117int   OptionsStruct::NDims(){
    138118
    139         return(OptionsObject::NDims());
     119        return(Option::NDims());
    140120}
    141121/*}}}*/
    142 
    143122/*FUNCTION OptionsStruct::Size {{{1*/
    144123int*  OptionsStruct::Size(){
    145124
    146         return(OptionsObject::Size());
     125        return(Option::Size());
    147126}
    148127/*}}}*/
    149 
    150128/*FUNCTION OptionsStruct::Get {{{1*/
    151129//void* OptionsStruct::Get(){
    … …  
    156134//}
    157135/*}}}*/
    158 
    159 /*FUNCTION OptionsStruct::Id {{{1*/
    160 int   OptionsStruct::Id(){
    161 }
    162 /*}}}*/
    163 
    164 /*FUNCTION OptionsStruct::MyRank {{{1*/
    165 int   OptionsStruct::MyRank(){
    166 }
    167 /*}}}*/
    168 
    169 /*FUNCTION OptionsStruct::Marshall {{{1*/
    170 void  OptionsStruct::Marshall(char** pmarshalled_dataset){
    171 }
    172 /*}}}*/
    173 
    174 /*FUNCTION OptionsStruct::MarshallSize {{{1*/
    175 int   OptionsStruct::MarshallSize(){
    176 }
    177 /*}}}*/
    178 
    179 /*FUNCTION OptionsStruct::Demarshall {{{1*/
    180 void  OptionsStruct::Demarshall(char** pmarshalled_dataset){
    181 }
    182 /*}}}*/
    183 
    184 /*FUNCTION OptionsStruct::Enum {{{1*/
    185 int   OptionsStruct::Enum(){
    186 }
    187 /*}}}*/
    188 
    189 /*FUNCTION OptionsStruct::copy {{{1*/
    190 Object* OptionsStruct::copy(){
    191 }
    192 /*}}}*/
    193 

  • issm/trunk/src/c/objects/Options/OptionsStruct.h

    r7731 r7737  
    1111#include "../../EnumDefinitions/EnumDefinitions.h"
    1212
    13 #include "./OptionsObject.h"
     13#include "./Option.h"
    1414/*}}}*/
    1515
    16 class OptionsStruct: public OptionsObject {
     16class OptionsStruct: public Option {
    1717
    1818        public:
    1919
    20                 DataSet** values;
     20                Options** values;
    2121
    2222                /*OptionsStruct constructors, destructors {{{1*/
    … …  
    2828                void  DeepEcho();
    2929                void  DeepEcho(char* indent);
    30                 int   Id();
    31                 int   MyRank();
    32                 void  Marshall(char** pmarshalled_dataset);
    33                 int   MarshallSize();
    34                 void  Demarshall(char** pmarshalled_dataset);
    35                 int   Enum();
    36                 Object* copy();
     30                int   Id(){_error_("Not implemented yet");};
     31                int   MyRank(){_error_("Not implemented yet");};
     32                void  Marshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     33                int   MarshallSize(){_error_("Not implemented yet");};
     34                void  Demarshall(char** pmarshalled_dataset){_error_("Not implemented yet");};
     35                int   Enum(){_error_("Not implemented yet");};
     36                Object* copy(){_error_("Not implemented yet");};
    3737                /*}}}*/
    3838

  • issm/trunk/src/c/objects/Options/OptionsUtilities.cpp

    r7731 r7737  
    1919/*}}}*/
    2020
    21 int ColumnWiseDimsFromIndex(int* dims,
    22                                                         int index,
    23                                                         int* size,
    24                                                         int ndims) {
     21/*FUNCTION ColumnWiseDimsFromIndex{{{1*/
     22int ColumnWiseDimsFromIndex(int* dims,int index,int* size,int ndims){
    2523
    2624        int   i;
    2725        int   aprod=1;
    2826
    29 /*  check for index too large  */
     27        /*check for index too large  */
     28        for (i=0;i<ndims;i++) aprod*=size[i];
     29        if (index >= aprod) _error_("Index %d exceeds number of elements %d.",index,aprod);
    3030
    31         for (i=0; i<ndims; i++)
    32                 aprod*=size[i];
    33 
    34         if (index >= aprod)
    35                 _error_("Index %d exceeds number of elements %d.",index,aprod);
    36 
    37 /*  calculate the dimensions (being careful of integer division)  */
    38 
     31        /*calculate the dimensions (being careful of integer division)  */
    3932        for (i=ndims-1; i>=0; i--) {
    4033                aprod=(int)(((double)aprod+0.5)/(double)size[i]);
    … …  
    4437
    4538        return(0);
    46 }
    47 
    48 int IndexFromColumnWiseDims(int* dims,
    49                                                         int* size,
    50                                                         int ndims) {
     39}/*}}}*/
     40/*FUNCTION IndexFromColumnWiseDims{{{1*/
     41int IndexFromColumnWiseDims(int* dims, int* size, int ndims) {
    5142
    5243        int   i;
    5344        int   index=0;
    5445
    55 /*  check for any dimension too large  */
     46        /*check for any dimension too large  */
     47        for (i=0;i<ndims;i++){
     48                if (dims[i] >= size[i]) _error_("Dimension %d of %d exceeds size of %d.",i,dims[i],size[i]);
     49        }
    5650
    57         for (i=0; i<ndims; i++)
    58                 if (dims[i] >= size[i])
    59                         _error_("Dimension %d of %d exceeds size of %d.",i,dims[i],size[i]);
    60 
    61 /*  calculate the index  */
    62 
    63         for (i=ndims-1; i>=0; i--) {
     51        /*calculate the index  */
     52        for (i=ndims-1; i>=0; i--){
    6453                index*=size[i];
    6554                index+=dims[i];
    … …  
    6756
    6857        return(index);
    69 }
    70 
    71 
    72 int RowWiseDimsFromIndex(int* dims,
    73                                                  int index,
    74                                                  int* size,
    75                                                  int ndims) {
     58}/*}}}*/
     59/*FUNCTION RowWiseDimsFromIndex{{{1*/
     60int RowWiseDimsFromIndex(int* dims, int index, int* size, int ndims) {
    7661
    7762        int   i;
    7863        int   aprod=1;
    7964
    80 /*  check for index too large  */
     65        /*check for index too large  */
     66        for (i=0; i<ndims; i++) aprod*=size[i];
     67        if (index >= aprod) _error_("Index %d exceeds number of elements %d.",index,aprod);
    8168
    82         for (i=0; i<ndims; i++)
    83                 aprod*=size[i];
    84 
    85         if (index >= aprod)
    86                 _error_("Index %d exceeds number of elements %d.",index,aprod);
    87 
    88 /*  calculate the dimensions (being careful of integer division)  */
    89 
     69        /*calculate the dimensions (being careful of integer division)  */
    9070        for (i=0; i<ndims; i++) {
    9171                aprod=(int)(((double)aprod+0.5)/(double)size[i]);
    … …  
    9575
    9676        return(0);
    97 }
    98 
    99 
    100 int IndexFromRowWiseDims(int* dims,
    101                                                  int* size,
    102                                                  int ndims) {
     77}/*}}}*/
     78/*FUNCTION IndexFromRowWiseDims{{{1*/
     79int IndexFromRowWiseDims(int* dims, int* size, int ndims) {
    10380
    10481        int   i;
    10582        int   index=0;
    10683
    107 /*  check for any dimension too large  */
     84        /*check for any dimension too large  */
     85        for (i=0; i<ndims; i++){
     86                if (dims[i] >= size[i]) _error_("Dimension %d of %d exceeds size of %d.",i,dims[i],size[i]);
     87        }
    10888
    109         for (i=0; i<ndims; i++)
    110                 if (dims[i] >= size[i])
    111                         _error_("Dimension %d of %d exceeds size of %d.",i,dims[i],size[i]);
    112 
    113 /*  calculate the index  */
    114 
     89        /*calculate the index  */
    11590        for (i=0; i<ndims; i++) {
    11691                index*=size[i];
    … …  
    11994
    12095        return(index);
    121 }
    122 
    123 
    124 int StringFromDims(char* cstr,
    125                                    int* dims,
    126                                    int ndims) {
    127 
    128         int   i;
     96}/*}}}*/
     97/*FUNCTION StringFromDims{{{1*/
     98int StringFromDims(char* cstr, int* dims, int ndims) {
    12999
    130100        sprintf(&cstr[0],"[");
    131         for (i=0; i<ndims-1; i++)
    132                 sprintf(&cstr[strlen(cstr)],"%d,",dims[i]);
     101        for(int i=0; i<ndims-1; i++) sprintf(&cstr[strlen(cstr)],"%d,",dims[i]);
    133102        sprintf(&cstr[strlen(cstr)],"%d]",dims[ndims-1]);
    134103
    135104        return(0);
    136 }
    137 
    138 
    139 int StringFromSize(char* cstr,
    140                                    int* size,
    141                                    int ndims) {
    142 
    143         int   i;
     105}/*}}}*/
     106/*FUNCTION StringFromSize{{{1*/
     107int StringFromSize(char* cstr, int* size, int ndims) {
    144108
    145109        sprintf(&cstr[0],"[");
    146         for (i=0; i<ndims-1; i++)
    147                 sprintf(&cstr[strlen(cstr)],"%dx",size[i]);
     110        for(int i=0; i<ndims-1; i++) sprintf(&cstr[strlen(cstr)],"%dx",size[i]);
    148111        sprintf(&cstr[strlen(cstr)],"%d]",size[ndims-1]);
    149112
    150113        return(0);
    151 }
    152 
     114}/*}}}*/

  • issm/trunk/src/c/objects/Options/OptionsUtilities.h

    r7731 r7737  
    1111#include "../../EnumDefinitions/EnumDefinitions.h"
    1212
    13 #include "./OptionsObject.h"
     13#include "./Option.h"
    1414/*}}}*/
    1515
    16 int ColumnWiseDimsFromIndex(int* dims,
    17                                                         int index,
    18                                                         int* size,
    19                                                         int ndims);
    20 int IndexFromColumnWiseDims(int* dims,
    21                                                         int* size,
    22                                                         int ndims);
    23 int RowWiseDimsFromIndex(int* dims,
    24                                                  int index,
    25                                                  int* size,
    26                                                  int ndims);
    27 int IndexFromRowWiseDims(int* dims,
    28                                                  int* size,
    29                                                  int ndims);
    30 int StringFromDims(char* cstr,
    31                                    int* dims,
    32                                    int ndims);
    33 int StringFromSize(char* cstr,
    34                                    int* size,
    35                                    int ndims);
     16int ColumnWiseDimsFromIndex(int* dims, int index, int* size, int ndims);
     17int IndexFromColumnWiseDims(int* dims, int* size, int ndims);
     18int RowWiseDimsFromIndex(int* dims, int index, int* size, int ndims);
     19int IndexFromRowWiseDims(int* dims, int* size, int ndims);
     20int StringFromDims(char* cstr, int* dims, int ndims);
     21int StringFromSize(char* cstr, int* size, int ndims);
    3622
    3723#endif  /* _OPTIONSUTILITIES_H */

  • issm/trunk/src/c/objects/Params/Param.h

    r6165 r7737  
    2727
    2828        public:
    29                
    3029                virtual        ~Param(){};
    3130

  • issm/trunk/src/c/objects/objects.h

    r7733 r7737  
    6464
    6565/*Option parsing objects: */
    66 #include "./Options/OptionsObject.h"
     66#include "./Options/Option.h"
    6767#include "./Options/OptionsDouble.h"
    6868#include "./Options/OptionsLogical.h"

  • issm/trunk/src/c/shared/Matlab/ModuleBoot.cpp

    r6014 r7737  
    1717int ModuleBoot(void){
    1818       
    19         /*Declare my_ rank and num_procs global variables!: */
     19        /*Declare my_rank and num_procs global variables!: */
    2020        my_rank=0;
    2121        num_procs=1;

  • issm/trunk/src/c/shared/Matlab/PrintfFunction.cpp

    r1439 r7737  
    2424        //First use vsprintf to get the whole input string.
    2525        va_start(ap,format);
    26          #ifndef WIN32
     26        #ifndef WIN32
    2727        string_size=vsprintf(string,format,ap); //printf style coding
    2828        #else
    … …  
    4040        return 1;
    4141}
    42 
    43 
Note: See TracChangeset for help on using the changeset viewer.