bittrexconfig.h

#pragma once 


namespace trader {

    class BittrexConfig :  public Poco::RefCountedObject {
    public:
        
        BittrexConfig();
        
        ~BittrexConfig();
        
        void readFile(const std::string& _fileName);
        
        void read(Poco::Dynamic::Var val);
        
        struct DataArray {
            
            void SetApi_key(std::string val)
            {
                api_key = val;
            }
            
            bool isSetApi_key() {
                return (api_key != "Empty");
            }
            
            std::string api_key;
            
            void SetApi_secret(std::string val)
            {
                api_secret = val;
            }
            
            bool isSetApi_secret() {
                return (api_secret != "Empty");
            }
            
            std::string api_secret;
            
            void SetName(std::string val)
            {
                name = val;
            }
            
            bool isSetName() {
                return (name != "Empty");
            }
            
            std::string name;
            
            void SetRead_info(bool val)
            {
                read_info = val;
                read_infoSet = true;
            }
            
            bool isSetRead_info() {
                return (read_infoSet != false);
            }
            
            bool    read_info;
            bool    read_infoSet;
            
            void SetRequests_per_minute(Poco::Int32 val)
            {
                requests_per_minute = val;
            }
            
            bool isSetRequests_per_minute() {
                return (requests_per_minute != std::numeric_limits<Poco::Int32>::max());
            }
            
            Poco::Int32 requests_per_minute;
            
            void SetTrade_limit(bool val)
            {
                trade_limit = val;
                trade_limitSet = true;
            }
            
            bool isSetTrade_limit() {
                return (trade_limitSet != false);
            }
            
            bool    trade_limit;
            bool    trade_limitSet;
            
            void SetTrade_market(bool val)
            {
                trade_market = val;
                trade_marketSet = true;
            }
            
            bool isSetTrade_market() {
                return (trade_marketSet != false);
            }
            
            bool    trade_market;
            bool    trade_marketSet;
            
            void SetWithdraw(bool val)
            {
                withdraw = val;
                withdrawSet = true;
            }
            
            bool isSetWithdraw() {
                return (withdrawSet != false);
            }
            
            bool    withdraw;
            bool    withdrawSet;
            
            DataArray()
            : api_key("Empty")
            , api_secret("Empty")
            , name("Empty")
            , read_info(false)
            , read_infoSet(false)
            , requests_per_minute(std::numeric_limits<Poco::Int32>::max())
            , trade_limit(false)
            , trade_limitSet(false)
            , trade_market(false)
            , trade_marketSet(false)
            , withdraw(false)
            , withdrawSet(false)
            {
            }
        
        };
        
        typedef std::vector<DataArray> Data;
        Data    data;
    }; //BittrexConfig
    
} //trader