options.h

Go to the documentation of this file.

/*
  * The GURLS Package in C++
  *
  * Copyright (C) 2011-1013, IIT@MIT Lab
  * All rights reserved.
  *
  * author:  M. Santoro
  * email:   msantoro@mit.edu
  * website: http://cbcl.mit.edu/IIT@MIT/IIT@MIT.html
  *
  * 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(s) of the copyright holders nor the names
  *       of its contributors or of the Massacusetts Institute of
  *       Technology or of the Italian Institute of Technology 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 THE
  * COPYRIGHT OWNER OR CONTRIBUTORS 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.
  */

#ifndef _GURLS_OPT_H_
#define _GURLS_OPT_H_

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <typeinfo>

#include "gurls++/exports.h"
#include "gurls++/gmat2d.h"
#include "gurls++/gvec.h"
#include "gurls++/exceptions.h"


namespace gurls
{


enum OptTypes   {GenericOption, StringOption, NumberOption,
                 StringListOption, NumberListOption, FunctionOption,
                 MatrixOption, VectorOption,
                OptListOption, TaskSequenceOption, TaskIDOption, OptArrayOption, ProcessOption};



class GURLS_EXPORT GurlsOption
{
protected:
    OptTypes type; 

public:

    GurlsOption(OptTypes t);

    OptTypes getType() const;

    virtual ~GurlsOption();

    virtual bool isA(OptTypes id) const;

    const virtual std::type_info& getDataID();

    friend GURLS_EXPORT std::ostream& operator<<(std::ostream& os, const GurlsOption& opt);

    virtual std::ostream& operator<<(std::ostream& os) const = 0;
};

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4251)
#endif

class GURLS_EXPORT OptString: public GurlsOption
{

protected:
    std::string value; 

public:

    typedef std::string ValueType;

    OptString();

//    OptString(const char* str);

    OptString(const std::string& str);

    OptString(const std::wstring& str);

    OptString& operator=(const OptString& other);

    ~OptString();

    OptString& operator=(const std::string& other);

    void setValue(const std::string& newvalue);

    std::string& getValue();

    const std::string& getValue() const;

    virtual bool isA(OptTypes id) const;

    static OptString* dynacast(GurlsOption* opt);

    static const OptString* dynacast(const GurlsOption* opt);

    virtual std::ostream& operator<<(std::ostream& os) const;

};

#ifdef _WIN32
#pragma warning(pop)
#endif

class GURLS_EXPORT OptStringList: public GurlsOption
{
protected:
    std::vector<std::string>* value; 

public:

    typedef std::vector<std::string> ValueType;

    OptStringList();

    OptStringList(const std::vector<std::string>& vec);

    OptStringList(std::string& str);

    OptStringList& operator=(const OptStringList& other);

    ~OptStringList();

    void setValue(const std::vector<std::string> newvalue);

    void add(const std::string str);

    const std::vector<std::string>& getValue() const;

    virtual bool isA(OptTypes id) const;

    static OptStringList* dynacast(GurlsOption* opt);

    static const OptStringList* dynacast(const GurlsOption* opt);

    virtual std::ostream& operator<<(std::ostream& os) const;

    void clear();

    OptStringList& operator<<(std::string& str);

    OptStringList& operator<<(const char* str);

};


class GURLS_EXPORT OptNumber: public GurlsOption
{
protected:
    double value; 

public:

    typedef double ValueType;

    OptNumber();

    OptNumber(double v);

    OptNumber& operator=(const OptNumber& other);

//    ~OptNumber(){}

    OptNumber& operator=(double other);

    void setValue(double newvalue);

    const double& getValue() const;

    double& getValue();

    virtual bool isA(OptTypes id) const;

    static OptNumber* dynacast(GurlsOption* opt);

    static const OptNumber* dynacast(const GurlsOption* opt);

    virtual std::ostream& operator<<(std::ostream& os) const;

};

//#ifdef GURLS_DEPRECATED

class GURLS_EXPORT OptNumberList: public GurlsOption
{
private:
    std::vector<double>* value; 

public:

    typedef std::vector<double> ValueType;

    OptNumberList();

    OptNumberList(const std::vector<double>& vec);

    OptNumberList(double v);

    OptNumberList(double *v, int n);

    OptNumberList& operator=(const OptNumberList& other);

    ~OptNumberList();

    void setValue(const std::vector<double> newvalue);

    void add(const double d);

    std::vector<double>& getValue();

    const std::vector<double>& getValue() const;

    virtual bool isA(OptTypes id) const;

    static OptNumberList* dynacast(GurlsOption* opt);

    static const OptNumberList* dynacast(const GurlsOption* opt);

    virtual std::ostream& operator<<(std::ostream& os) const;

    void clear();

    OptNumberList& operator<<(double& d);
}

//#ifdef __GNUC__
//    __attribute__ ((deprecated))
//#endif
;

//#ifdef _WIN32
//#pragma deprecated( OptNumberList )
//#endif

//#endif


static const std::string TASKDESC_SEPARATOR(":");

class GURLS_EXPORT OptTaskSequence: public OptStringList
{
protected:
    bool isValid(const std::string & str, std::string& type, std::string& name);

public:

    typedef OptStringList::ValueType ValueType;

    OptTaskSequence();

    OptTaskSequence(const char* str);

    OptTaskSequence(std::string &str);

    OptTaskSequence(const std::vector<std::string>& data);

    OptTaskSequence& operator=(const OptTaskSequence& other);

    void addTask(const std::string newtask);

    virtual bool isA(OptTypes id) const;

    static OptTaskSequence* dynacast(GurlsOption* opt);

    static const OptTaskSequence* dynacast(const GurlsOption* opt);

    void getTaskAt(int index, std::string& taskdesc, std::string& taskname);

    unsigned long size();

};

class GURLS_EXPORT OptProcess: public GurlsOption
{
public:
    enum Action {ignore, compute, computeNsave, load, remove};

    typedef std::vector<Action> ValueType;

protected:

    ValueType* value;   

    static std::vector<std::string>& actionNames();

public:

    OptProcess();

    OptProcess(const OptProcess& other);

    ~OptProcess();

    void addAction(const Action action);

    OptProcess& operator<<(const Action action);

    const ValueType& getValue() const;

    Action operator[](unsigned long index);

    void clear();

    unsigned long size();

    virtual bool isA(OptTypes id) const;

    static OptProcess* dynacast(GurlsOption* opt);

    static const OptProcess* dynacast(const GurlsOption* opt);

    virtual std::ostream& operator<<(std::ostream& os) const;

};

}

#endif // _GURLS_OPT_H_