cryptowatchdatabase.h

#pragma once 


namespace trader {

    namespace CryptowatchDatabase {
    
        class Api_Cost :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Current Unix Timestamp
                Poco::Int32 timeStamp;
                
                bool isSetTimeStamp() {
                    return (timeStamp != std::numeric_limits<Poco::Int32>::max());
                }
                
                // URL of REST Call
                std::string method;
                
                bool isSetMethod() {
                    return (method != "Empty");
                }
                
                // Cost
                double  cost;
                
                bool isSetCost() {
                    return (cost != std::numeric_limits<double>::max());
                }
                
                Record()
                : timeStamp(std::numeric_limits<Poco::Int32>::max())
                , method("Empty")
                , cost(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Current Unix Timestamp
                Poco::Int32 timeStamp;
                
                bool isSetTimeStamp() {
                    return (timeStamp != std::numeric_limits<Poco::Int32>::max());
                }
                
                // URL of REST Call
                std::string method;
                
                bool isSetMethod() {
                    return (method != "Empty");
                }
                
                // Cost
                double  cost;
                
                bool isSetCost() {
                    return (cost != std::numeric_limits<double>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : timeStamp(std::numeric_limits<Poco::Int32>::max())
                , method("Empty")
                , cost(std::numeric_limits<double>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            Api_Cost(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~Api_Cost();
            
            void init();
            
            void clear();
            
            void insert(Api_Cost::Record& record);
            
            void insertOnce(Api_Cost::Record& record);
            
            void insertMultiple(std::vector<Api_Cost::Record>& records);
            
            void insertMultiple(std::vector<Api_Cost::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<Api_Cost::Record>& records);
            
            void deleteMultiple(std::vector<Api_Cost::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(Api_Cost::Record& record);
            
            void insertUnique(Api_Cost::Record& record);
            
            void getLatest(Api_Cost::RecordWithId& rec);
            
            std::size_t getAll(std::vector<Api_Cost::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //Api_Cost
        
        class Tables :  public Poco::RefCountedObject {
        public:
            
            Tables(Poco::Data::Session* _db);
            
            ~Tables();
            
            void init();
            
            void clear();
            
            Poco::Data::Session* db;
            
            Poco::AutoPtr<Api_Cost> api_CostTable;
            
        }; //Tables
        
    } //CryptowatchDatabase
} //trader

template <>
class Poco::Data::TypeHandler<trader::CryptowatchDatabase::Api_Cost::Record>
{
    public:
    static std::size_t size()
    {
        return 3;
    }
    
    static void bind(std::size_t pos, const trader::CryptowatchDatabase::Api_Cost::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.timeStamp , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.method , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.cost , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::CryptowatchDatabase::Api_Cost::Record& record, trader::CryptowatchDatabase::Api_Cost::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.timeStamp, deflt.timeStamp, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.method, deflt.method, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.cost, deflt.cost, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::CryptowatchDatabase::Api_Cost::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.timeStamp, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.method, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.cost, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::CryptowatchDatabase::Api_Cost::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::CryptowatchDatabase::Api_Cost::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.timeStamp , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.method , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.cost , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::CryptowatchDatabase::Api_Cost::RecordWithId& record, trader::CryptowatchDatabase::Api_Cost::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.timeStamp, deflt.timeStamp, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.method, deflt.method, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.cost, deflt.cost, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::CryptowatchDatabase::Api_Cost::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.timeStamp, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.method, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.cost, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;