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;
    }
 
    gsOptionList() {}
 
    // Copy constructor
    gsOptionList(const gsOptionList & other) :
        m_strings(other.m_strings),
        m_ints(other.m_ints),
        m_reals(other.m_reals),
        m_switches(other.m_switches) { }
 
#if EIGEN_HAS_RVALUE_REFERENCES
    // Note: functions cannot be defaulted/deleted in VS2013 or older
    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