wxcrypt.h

Go to the documentation of this file.

#ifndef wxcrypt_h
#define wxcrypt_h
 
// WarpX include
#include "warpxm/warpxm_config.h"
#include "wxany.h"
#include "wxdatatypes.h"
#include "wxexcept.h"
 
// std includes
#include <map>
#include <stdexcept>
#include <string>
#include <vector>
 
class WxCrypt
{
public:
    // types of string->WxAny map and pairs
    typedef std::map<std::string, WxAny, std::less<std::string>> AnyMap_t;
    typedef std::pair<std::string, WxAny> AnyPair_t;
 
    // these are the supported integer and floating point types since reading from a
    // string of digits does not explicitly define the precision
    typedef int crypt_signed_int_t;
 
    WxCrypt();
    virtual ~WxCrypt();
 
    WxCrypt(const WxCrypt& crypt);
 
    WxCrypt& operator=(const WxCrypt& rhs);
 
    template<typename VALUETYPE> bool add(const std::string& name, const VALUETYPE& value)
    {
        return _values.insert(AnyPair_t(name, value)).second;
    }
 
    bool has(const std::string& name) const;
 
    template<typename VALUETYPE> VALUETYPE get(const std::string& name) const
    {
        AnyMap_t::const_iterator i = _values.find(name);
        if (i != _values.end())
            return ((*i).second).to_value<VALUETYPE>();
        // value not found: throw an exception
        WxExcept wxe;
        wxe << "Value " << name << " not found";
        throw wxe;
    }
 
    template<typename VALUETYPE>
    VALUETYPE getWithDefault(const std::string& name, const VALUETYPE defaultValue) const
    {
        if (has(name))
        {
            return get<VALUETYPE>(name);
        }
        else
        {
            return defaultValue;
        }
    }
 
    const WxAny& get(const std::string& name) const
    {
        AnyMap_t::const_iterator i = _values.find(name);
        if (i != _values.end())
            return ((*i).second);
        // value not found: throw an exception
        WxExcept wxe;
        wxe << "Value " << name << " not found";
        throw wxe;
    }
 
    WxAny& get(const std::string& name)
    {
        return const_cast<WxAny&>(const_cast<const WxCrypt&>(*this).get(name));
    }
 
    void set(const std::string& name, const WxAny& val)
    {
        _values[name] = val;
    }
 
    void set(const std::string& name, WxAny&& val)
    {
        _values[name] = std::move(val);
    }
 
    template<class T> void set(const std::string& name, T val)
    {
        _values[name] = std::move(val);
    }
 
    template<typename VALUETYPE>
    std::vector<VALUETYPE> getVec(const std::string& name) const
    {
        return get(name).to_value<std::vector<VALUETYPE>>();
    }
 
private:
    AnyMap_t _values;
};
 
#endif // wxcrypt_h