Environment.h

Go to the documentation of this file.

/* 
 *  Copyright (c) 2013, FI MUNI CZ
 *  All rights reserved.
 *  
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *      * Redistributions of source code must retain the above copyright
 *        notice, this list of conditions and the following disclaimer.
 *      * Redistributions in binary form must reproduce the above copyright
 *        notice, this list of conditions and the following disclaimer in the
 *        documentation and/or other materials provided with the distribution.
 *      * Neither the name of the <organization> nor the
 *        names of its contributors may be used to endorse or promote products
 *        derived from this software without specific prior written permission.
 *  
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
 *  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 *  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  Authors:
 *  Vilem Otte <vilem.otte@post.cz>
 *
 */

#ifndef __ENVIRONMENT_H__
#define __ENVIRONMENT_H__

#include <iostream>
#include <string>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <fstream>
#include <string.h>

using namespace std;

enum OptionType {
  optInt,           // Integer env-var
  optFloat,         // Floating point env-var
  optBool,          // Boolean env-var
  optString         // String env-var
};

class Option
{
public:

    OptionType type;        //< Option type
    char* name;             //< Option name
    char* value;            //< Option value
    char* abbrev;           //< Option Abbreviation
    char* defaultValue;     //< Option default value

    char* description;      //< Option description
    void* pointer;          //< TODO: Whats this for? (search in Minimax)
    

    Option()
    {
        name = NULL;
        value = NULL;
        abbrev = NULL;
        defaultValue = NULL;
        description = NULL;
        pointer = NULL;
    }
    

    virtual ~Option()
    {
        if(name) delete [] name;
        if(value) delete [] value;
        if(abbrev) delete [] abbrev;
        if(defaultValue) delete [] defaultValue;
        if(description) delete [] description;
    }
    

    friend ostream& operator<<(ostream& s, const Option& o)
    {
        // Ouptut name, abbrevation, value, default value and description
        // Ideally resulting in string:
        // > option_small_x  opt_x   12.45   [1.0] 
        // > Small x option
        s << o.name << "\t";

        if(o.abbrev)
            s << o.abbrev;
        else
            s << "no abbrev";
        s << "\t";

        if(o.value)
            s << o.value;
        else
            s << "not set";
        s << "\t";

        if(o.defaultValue)
            s << "[" << o.defaultValue << "]";
        else
            s << "[not set]";
        s << "\t";

        if(o.description)
            s << endl << o.description;

        return s;
    }
};

class Environment
{
private:

    int maxOptions;                             //< Maximal number of options
    int numParams;                              //< Number of columns in parameter table
    int paramRows;                              //< Number of rows in parameter table
    char* optionalParams;                       //< String with prefixes with non-optional parameters
    int curRow;                                 //< Current row in parameter table
    char*** params;                             //< Parameter table. 2D array of strings, first column are parameters, next are options
                                                //< prefixed by char passed to function GetCmdlineParams paired with corresponding parameters.
    int numOptions;                             //< Number of registered options
    Option* options;                            //< Options table


    bool CheckVariableType(const char* value, const OptionType type) const;

    char* ParseString(char* buffer, char* str) const;

    bool ParseBool(const char* valueString) const;

    int FindOption(const char* name, const bool isFatal = false) const;

public:
    static Environment* GetSingleton();

    static void SetSingleton(Environment* e);

    static void DeleteSingleton();
    
    virtual void PrintUsage(ostream &s) const;
    
    virtual void SetStaticOptions();

    void RegisterOption(const char *name, const OptionType type, const char *abbrev, const char *defValue = NULL);
    
    void SetInt(const char *name, const int value);
    
    void SetFloat(const char *name, const float value);
    
    void SetBool(const char *name, const bool value);
    
    void SetString(const char *name, const char *value);
    
    bool GetBool(const char *name, const bool isFatal = false) const;
  
    int GetInt(const char *name,const bool isFatal = false) const;
    
    float GetFloat(const char *name,const bool isFatal = false) const;
    
    double GetDouble(const char *name,const bool isFatal = false) const;
    
    bool GetIntValue(const char *name, int &value, const bool isFatal = false) const;
  
    bool GetDoubleValue(const char *name, double &value, const bool isFatal = false) const;
    
    bool GetFloatValue(const char *name, float &value, const bool isFatal = false) const;
    
    bool GetBoolValue(const char *name, bool &value, const bool isFatal = false) const;
    
    bool GetStringValue(const char *name, char *value, const bool isFatal = false) const;
    
    bool GetStringValue(const char *name, string &value, const bool isFatal = false) const; 
    
    bool CheckForSwitch(const int argc, char **argv, const char swtch) const;
    
    void ReadCmdlineParams(const int argc, char **argv, const char *optParams);
    
    bool ReadEnvFile(const char *filename);

    void ParseCmdline(const int argc, char **argv, const int index);
    
    int GetParamNum() const { return paramRows; }

    bool GetParam(const char name, const int index, char *value) const;
    
    bool OptionPresent(const char *name) const;
    
    static Environment* mEnvironment;           //< Singleton pointer to Environment instance

public:

    Environment();


    virtual ~Environment();
};


  /*bool Parse(const int argc, char **argv, bool useExePath, char* overridePath = NULL, const char* overrideDefault = "default.env");

  void
  CodeString(char *buff, int max);

  void
  DecodeString(char *buff, int max);

  void
  SaveCodedFile(char *filenameText,
        char *filenameCoded);

  
  virtual void RegisterOptions() = 0;*/
  
#endif