gsOptionList.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsForwardDeclarations.h>
#include <gsIO/gsXml.h>

namespace gismo
{

class GISMO_EXPORT gsOptionList
{
public:
    typedef GISMO_COEFF_TYPE Real;

    std::string getString(const std::string & label) const;
    const index_t & getInt   (const std::string & label) const;
    Real      getReal  (const std::string & label) const;
    bool        getSwitch(const std::string & label) const;

    std::vector<std::string> getMultiString(const std::string & gn) const;
    std::vector<index_t>     getMultiInt   (const std::string & gn) const;
    std::vector<Real>      getMultiReal  (const std::string & gn) const;

    std::string askString(const std::string & label, const std::string & value = ""    ) const;
    index_t     askInt   (const std::string & label, const index_t &     value = 0     ) const;
    Real      askReal  (const std::string & label, const Real &      value = 0     ) const;
    bool        askSwitch(const std::string & label, const bool &        value = false ) const;

    /*/// \brief Reads values of an option-group \a gn into a std::vector.
    //std::vector<std::string> askMultiString(const std::string & gn, const std::vector<std::string> & values = std::vector<std::string>()) const;
    //std::vector<index_t>     askMultiInt   (const std::string & gn, const std::vector<index_t> &     values = std::vector<index_t>()    ) const;
    //std::vector<Real>      askMultiReal  (const std::string & gn, const std::vector<Real> &      values = std::vector<Real>()     ) const;*/

    void setString(const std::string & label, const std::string & value);
    void setInt   (const std::string & label, const index_t &     value);
    void setReal  (const std::string & label, const Real &      value);
    void setSwitch(const std::string & label, const bool &        value);
    void toggleSwitch( const std::string & label );

    /*/// \brief Sets values of option-group \a gn from values of a std::vector.
    //void setMultiString(const std::string & gn, const std::vector<std::string> & values );
    //void setMultiInt   (const std::string & gn, const std::vector<index_t> &     values );
    //void setMultiReal  (const std::string & gn, const std::vector<Real> &      values );*/

    void addString(const std::string & label, const std::string & desc, const std::string & value );
    void addInt   (const std::string & label, const std::string & desc, const index_t &     value );
    void addReal  (const std::string & label, const std::string & desc, const Real &      value );
    void addSwitch(const std::string & label, const std::string & desc, const bool &        value );

    /*/// \brief Adds an option-group \a gn containing values of a std::vector.
    //void addMultiString(const std::string & label, const std::string & desc, const std::vector<std::string> & values);
    void addMultiInt(const std::string & label, const std::string & desc, const std::vector<index_t> &  values);
    /*/// @copydoc gsOptionList::addMultiString()
    //void addMultiReal  (const std::string & label, const std::string & desc, const std::vector<Real> & values);*/

    void remove(const std::string& label);

    enum updateType {
        ignoreIfUnknown = 0,
        addIfUnknown = 1
    };

    void update(const gsOptionList& other, updateType type = ignoreIfUnknown);

    gsOptionList wrapIntoGroup(const std::string & gn) const;

    gsOptionList getGroup(const std::string & gn) const;

    bool hasGlobals() const;

    bool hasGroup(const std::string & gn) const;

    std::ostream & print(std::ostream & os) const;

    size_t size() const
    {return m_strings.size()+m_ints.size()+m_reals.size()+m_switches.size();}

    struct OptionListEntry {
        std::string type;                               
        std::string label;                              
        std::string desc;                               
        std::string val;                                
        std::ostream & print(std::ostream & os, index_t label_slot = 19) const;
    };

    std::vector<OptionListEntry> getAllEntries() const;

    gsOptionList& operator=(const gsOptionList & other)
    { // Note: implcitly degerated operator was buggy on some platforms
        if (this != &other)
        {
            m_strings  = other.m_strings;
            m_ints     = other.m_ints;
            m_reals    = other.m_reals;
            m_switches = other.m_switches;
        }
        return *this;
    }

#if EIGEN_HAS_RVALUE_REFERENCES
    // Note: functions cannot be defaulted/deleted in VS2013 or older

    gsOptionList() {}

    gsOptionList(const gsOptionList & other) :
        m_strings(other.m_strings), 
        m_ints(other.m_ints), 
        m_reals(other.m_reals), 
        m_switches(other.m_switches) { }

    gsOptionList(gsOptionList && other) :
        m_strings(std::move(other.m_strings)),
        m_ints(std::move(other.m_ints)), 
        m_reals(std::move(other.m_reals)), 
        m_switches(std::move(other.m_switches)) { }

    gsOptionList& operator=(gsOptionList && other)
    {
        m_strings  = std::move(other.m_strings);
        m_ints     = std::move(other.m_ints);
        m_reals    = std::move(other.m_reals);
        m_switches = std::move(other.m_switches);
        return *this;
    }
#endif

    void swap(gsOptionList& other)
    {
        m_strings .swap(other.m_strings );
        m_ints    .swap(other.m_ints    );
        m_reals   .swap(other.m_reals   );
        m_switches.swap(other.m_switches);
    }

protected:
    index_t & getIntRef(const std::string & label);
    
private:

    std::string getInfo(const std::string & label) const;

    bool exists(const std::string & label) const;

    bool isString(const std::string & label) const;
    bool isInt(const std::string & label) const;
    bool isReal(const std::string & label) const;
    bool isSwitch(const std::string & label) const;

private:
    friend class internal::gsXml<gsOptionList>;

    // Format: std::pair<Value,Description>
    typedef std::pair<std::string,std::string> StringOpt;
    typedef std::pair<index_t    ,std::string> IntOpt;
    typedef std::pair<Real     ,std::string> RealOpt;
    typedef std::pair<bool       ,std::string> SwitchOpt;

    // Format: std::map<Label, std::pair<Value,Description> >
    typedef std::map<std::string,StringOpt> StringTable;
    typedef std::map<std::string,IntOpt>    IntTable;
    typedef std::map<std::string,RealOpt>   RealTable;
    typedef std::map<std::string,SwitchOpt> SwitchTable;

    StringTable m_strings;  
    IntTable    m_ints;     
    RealTable   m_reals;    
    SwitchTable m_switches; 

}; // class gsOptionList

inline std::ostream &operator<<(std::ostream &os, const gsOptionList& b)
{ return b.print(os); }

inline std::ostream &operator<<(std::ostream &os, const gsOptionList::OptionListEntry& b)
{ return b.print(os); }

inline bool operator< ( const gsOptionList::OptionListEntry& a, const gsOptionList::OptionListEntry& b )
{ return a.label < b.label; }


namespace internal
{

template<>
class GISMO_EXPORT gsXml<gsOptionList>
{
private:
    gsXml();
public:
    GSXML_COMMON_FUNCTIONS(gsOptionList)
    GSXML_GET_POINTER(gsOptionList)
    static std::string tag () { return "OptionList"; }
    static std::string type() { return ""; }

    static void get_into(gsXmlNode * node, gsOptionList & result);
    static gsXmlNode * put (const gsOptionList & obj, gsXmlTree & data);
};

}

#ifdef GISMO_WITH_PYBIND11

  void pybind11_init_gsOptionList(pybind11::module &m);
  
#endif // GISMO_WITH_PYBIND11

} // namespace gismo