cryptowatchapi.h

#pragma once 
#include "app.h"
#include "api.h"
#include "helper.h"


namespace trader {

    namespace CryptowatchApi {
    
        class Allowance :  public Poco::RefCountedObject {
        public:
            
            Allowance();
            
            ~Allowance();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                void SetCost(Poco::Int64 val)
                {
                    cost = val;
                }
                
                bool isSetCost() {
                    return (cost != std::numeric_limits<Poco::Int64>::max());
                }
                
                Poco::Int64 cost;
                
                void SetRemaining(Poco::Int64 val)
                {
                    remaining = val;
                }
                
                bool isSetRemaining() {
                    return (remaining != std::numeric_limits<Poco::Int64>::max());
                }
                
                Poco::Int64 remaining;
                
                DataObject()
                : cost(std::numeric_limits<Poco::Int64>::max())
                , remaining(std::numeric_limits<Poco::Int64>::max())
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //Allowance
        
        class AllowanceIntrospector :  public Poco::RefCountedObject {
        public:
            
            AllowanceIntrospector();
            
            ~AllowanceIntrospector();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct AllowanceObject {
                    
                    void SetCost(Poco::Int64 val)
                    {
                        cost = val;
                    }
                    
                    bool isSetCost() {
                        return (cost != std::numeric_limits<Poco::Int64>::max());
                    }
                    
                    Poco::Int64 cost;
                    
                    void SetRemaining(Poco::Int64 val)
                    {
                        remaining = val;
                    }
                    
                    bool isSetRemaining() {
                        return (remaining != std::numeric_limits<Poco::Int64>::max());
                    }
                    
                    Poco::Int64 remaining;
                    
                    AllowanceObject()
                    : cost(std::numeric_limits<Poco::Int64>::max())
                    , remaining(std::numeric_limits<Poco::Int64>::max())
                    {
                    }
                
                };
                
                AllowanceObject allowanceObject;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AllowanceIntrospector
        
        class AssetList :  public Poco::RefCountedObject {
        public:
            
            AssetList();
            
            ~AssetList();
            
            void readFile(const std::string& _fileName);
            
            void read(Poco::Dynamic::Var val);
            
            struct DataObject {
                
                struct ResultArray {
                    
                    void SetFiat(bool val)
                    {
                        fiat = val;
                        fiatSet = true;
                    }
                    
                    bool isSetFiat() {
                        return (fiatSet != false);
                    }
                    
                    bool    fiat;
                    bool    fiatSet;
                    
                    void SetId(std::string val)
                    {
                        id = val;
                    }
                    
                    bool isSetId() {
                        return (id != "Empty");
                    }
                    
                    std::string id;
                    
                    void SetName(std::string val)
                    {
                        name = val;
                    }
                    
                    bool isSetName() {
                        return (name != "Empty");
                    }
                    
                    std::string name;
                    
                    void SetRoute(std::string val)
                    {
                        route = val;
                    }
                    
                    bool isSetRoute() {
                        return (route != "Empty");
                    }
                    
                    std::string route;
                    
                    ResultArray()
                    : fiat(false)
                    , fiatSet(false)
                    , id("Empty")
                    , name("Empty")
                    , route("Empty")
                    {
                    }
                
                };
                
                typedef std::vector<ResultArray> Result;
                Result  result;
                DataObject()
                {
                }
            
            };
            
            DataObject  dataObject;
        }; //AssetList
        
        class EndPoints {
        public:
            
            EndPoints(Poco::AutoPtr<trader::App> app, Api* api);
            
            ~EndPoints();
            
            
            // Returns all assets (in no particular order).
            Poco::AutoPtr<AssetList> GetAssetList();
            
            // Get remaining rest call allowance
            Poco::AutoPtr<Allowance> GetAllowance();
            
            Poco::AutoPtr<trader::App>  _app;
            Api*    _api;
            std::string _uri;
        }; //EndPoints
        
    } //CryptowatchApi
} //trader