Parameters.h

Go to the documentation of this file.

/*
 * Parameter.h
 *
 *  Created on: Jul 22, 2010
 *      Author: marco
 */

#ifndef PARAMETER_H_
#define PARAMETER_H_

#include <cstdio>
#include <iostream>
#include <fstream>
#include <map>
#include <string.h>

#include "easylocal/utils/Definitions.h"

enum ParamType {
    PARAMTYPE_BOOL = 0, 
    PARAMTYPE_INT = 1, 
    PARAMTYPE_LONGINT = 2, 
    PARAMTYPE_REAL = 3, 
    PARAMTYPE_CHAR = 4, 
    PARAMTYPE_STRING = 5,
    PARAMTYPE_SHORTINT = 6 
};
typedef enum ParamType PARAMTYPE;

typedef struct Param PARAM; 
typedef struct ParamData PARAMDATA; 
struct boolParam {
    Bool* valueptr; 
    Bool curvalue; 
    Bool defaultvalue; 
};
typedef struct boolParam BOOLPARAM;

struct ShortintParam {
    Shortint* valueptr; 
    Shortint curvalue; 
    Shortint defaultvalue; 
    Shortint minvalue; 
    Shortint maxvalue; 
};
typedef struct ShortintParam SHORTINTPARAM;


struct IntParam {
    Int* valueptr; 
    Int curvalue; 
    Int defaultvalue; 
    Int minvalue; 
    Int maxvalue; 
};
typedef struct IntParam INTPARAM;

struct LongintParam {
    Longint curvalue; 
    Longint defaultvalue; 
    Longint minvalue; 
    Longint maxvalue; 
    Longint* valueptr; 
};
typedef struct LongintParam LONGINTPARAM;

struct RealParam {
    Real curvalue; 
    Real defaultvalue; 
    Real minvalue; 
    Real maxvalue; 
    Real* valueptr; 
};
typedef struct RealParam REALPARAM;

struct CharParam {
    char* valueptr; 
    char* allowedvalues; 
    char curvalue; 
    char defaultvalue; 
};
typedef struct CharParam CHARPARAM;

struct StringParam {
    char** valueptr; 
    char* curvalue; 
    char* defaultvalue; 
};
typedef struct StringParam STRINGPARAM;

struct Param {
    union {
        BOOLPARAM boolparam; 
        SHORTINTPARAM shortintparam; 
        INTPARAM intparam; 
        LONGINTPARAM longintparam; 
        REALPARAM realparam; 
        CHARPARAM charparam; 
        STRINGPARAM stringparam; 
    } data;
    char* name; 
    char* desc; 
    PARAMDATA* paramdata; 
    bool isadvanced; 
    PARAMTYPE paramtype; 
};

struct strCmp {
    bool operator()(const char* s1, const char* s2) const {
        return strcmp(s1, s2) < 0;
    }
};

class Parameters {

public:

    Parameters() {
        paramsetCreate();
    }
    ;
    ~Parameters() {
        paramsetDelete();
    }
    ;

    std::map<const char *, PARAM *, strCmp> paramset; 
    RETCODE paramsetSetToDefault();

    RETCODE paramSetToDefault(PARAM* param 
    );

    void paramsetRead(const char* filename 
    );

    RETCODE paramsetWrite(const char* filename, 
    bool comments, 
    bool onlychanged 
    );

    RETCODE paramsetAddBool(const char* name, 
    const char* desc, 
    Bool* valueptr, 
    Bool isadvanced, 
    Bool defaultvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramsetAddInt(const char* name, 
    const char* desc, 
    Int* valueptr, 
    Bool isadvanced, 
    Int defaultvalue, 
    Int minvalue, 
    Int maxvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramsetAddShortint(const char* name, 
    const char* desc, 
    Shortint* valueptr, 
    Bool isadvanced, 
    Shortint defaultvalue, 
    Shortint minvalue, 
    Shortint maxvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramsetAddLongint(const char* name, 
    const char* desc, 
    Longint* valueptr, 
    Bool isadvanced, 
    Longint defaultvalue, 
    Longint minvalue, 
    Longint maxvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramsetAddReal(const char* name, 
    const char* desc, 
    Real* valueptr, 
    Bool isadvanced, 
    Real defaultvalue, 
    Real minvalue, 
    Real maxvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramsetAddChar(const char* name, 
    const char* desc, 
    char* valueptr, 
    Bool isadvanced, 
    char defaultvalue, 
    const char* allowedvalues, 
    PARAMDATA* paramdata 
    );

    RETCODE paramsetAddString(const char* name, 
    const char* desc, 
    char** valueptr, 
    Bool isadvanced, 
    const char* defaultvalue, 
    PARAMDATA* paramdata 
    );

private:

    RETCODE paramsetCreate();

    RETCODE paramCreate(PARAM** param, 
    const char* name, 
    const char* desc, 
    PARAMDATA* paramdata 
    );

    RETCODE paramCreateBool(PARAM** param, 
    const char* name, 
    const char* desc, 
    Bool* valueptr, 
    Bool isadvanced, 
    Bool defaultvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramCreateInt(PARAM** param, 
    const char* name, 
    const char* desc, 
    int* valueptr, 
    Bool isadvanced, 
    int defaultvalue, 
    int minvalue, 
    int maxvalue, 
    PARAMDATA* paramdata 
    );


    RETCODE paramCreateShortint(PARAM** param, 
    const char* name, 
    const char* desc, 
    Shortint* valueptr, 
    Bool isadvanced, 
    Shortint defaultvalue, 
    Shortint minvalue, 
    Shortint maxvalue, 
    PARAMDATA* paramdata 
    );


    RETCODE paramCreateChar(PARAM** param, 
    const char* name, 
    const char* desc, 
    char* valueptr, 
    Bool isadvanced, 
    char defaultvalue, 
    const char* allowedvalues, 
    PARAMDATA* paramdata 
    );

    RETCODE paramCreateString(PARAM** param, 
    const char* name, 
    const char* desc, 
    char** valueptr, 
    Bool isadvanced, 
    const char* defaultvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramCreateLongint(PARAM** param, 
    const char* name, 
    const char* desc, 
    Longint* valueptr, 
    Bool isadvanced, 
    Longint defaultvalue, 
    Longint minvalue, 
    Longint maxvalue, 
    PARAMDATA* paramdata 
    );
    RETCODE paramCreateReal(PARAM** param, 
    const char* name, 
    const char* desc, 
    Real* valueptr, 
    Bool isadvanced, 
    Real defaultvalue, 
    Real minvalue, 
    Real maxvalue, 
    PARAMDATA* paramdata 
    );

    RETCODE paramsetAdd(PARAM* param 
    );

    const char* paramtypeGetName(PARAMTYPE paramtype 
    );

    RETCODE paramsetGetBool(const char* name, 
    Bool* value 
    );

    RETCODE paramsetGetbool(const char* name, 
    bool* value 
    );

    RETCODE paramsetGetInt(const char* name, 
    Int* value 
    );

    RETCODE paramsetGetShortint(const char* name, 
    Int* value 
    );


    RETCODE paramsetGetLongint(const char* name, 
    Longint* value 
    );

    RETCODE paramsetGetReal(const char* name, 
    Real* value 
    );

    RETCODE paramsetGetChar(const char* name, 
    char* value 
    );

    RETCODE paramsetGetString(const char* name, 
    char** value 
    );

    RETCODE paramsetSetBool(const char* name, 
    Bool value 
    );

    RETCODE paramsetSetInt(const char* name, 
    int value 
    );


    RETCODE paramsetSetShortint(const char* name, 
    int value 
    );


    RETCODE paramsetSetLongint(const char* name, 
    Longint value 
    );

    RETCODE paramsetSetReal(const char* name, 
    Real value 
    );

    RETCODE paramsetSetChar(const char* name, 
    char value 
    );

    RETCODE paramsetSetString(const char* name, 
    const char* value 
    );

    RETCODE paramSetBool(PARAM* param, 
    Bool value 
    );


    RETCODE paramSetShortint(PARAM* param, 
    Shortint value 
    );


    RETCODE paramSetInt(PARAM* param, 
    Int value 
    );

    RETCODE paramSetLongint(PARAM* param, 
    Longint value 
    );

    RETCODE paramSetReal(PARAM* param, 
    Real value 
    );

    RETCODE paramSetChar(PARAM* param, 
    char value 
    );

    RETCODE paramSetString(PARAM* param, 
    const char* value 
    );

    PARAM** paramsetGetParams();

    int paramsetGetNParams();

    RETCODE paramsetParse(char* line 
    );

    RETCODE paramParseInt(PARAM* param, 
    char* valuestr 
    );

    RETCODE paramParseBool(PARAM* param, 
    char* valuestr 
    );

    RETCODE paramParseLongint(PARAM* param, 
    char* valuestr 
    );

    RETCODE paramParseReal(PARAM* param, 
    char* valuestr 
    );

    RETCODE paramParseChar(PARAM* param, 
    char* valuestr 
    );

    RETCODE paramParseString(PARAM* param, 
    char* valuestr 
    );

    RETCODE paramWrite(PARAM* param, 
    std::ostream &file, 
    Bool comments, 
    Bool onlychanged 
    );

    RETCODE paramsetDelete();
    RETCODE paramDelete(PARAM** param 
    );

    PARAM* hashtableRetrieve(const char * paramname);

};

#endif /* PARAMETER_H_ */