downloadoptions.h

/*
 * ARIA2CPP: Basic CPP library to connect to an ARIA2 daemon 
 * via the RPC interface.
 *
 * *ALPHA VERSION!*
 *
 * Copyright (C) 2021  Dennis Katsonis dennisk@netspace.net.au
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef DOWNLOADOPTIONS_H_
#define DOWNLOADOPTIONS_H_
 
#include <string>
#include <memory>
#include <utility>
#include "client.h"
#include "func.h"
#include "download.h"
 
 
struct boolOption {
    bool first = false;
    bool second;
    std::string asJson()
    {
        return BoolToString(second);
    }
};
 
 
struct floatOption {
    bool first = false;
    float second;
    std::string asJson()
    {
        return std::to_string(second);
    }
};
 
struct intOption {
    bool first = false;
    int second;
    std::string asJson()
    {
        return std::to_string(second);
    }
};
 
 
struct size_tOption {
    bool first = false;
    size_t second;
    std::string asJson()
    {
        return std::to_string(second);
    }
};
 
struct stringOption {
    bool first = false;
    std::string second;
    std::string asJson()
    {
        return second;
    }
};
 
struct  URISelectorOption {
    bool first = false;
    URISelector second;
    std::string asJson()
        {
            if (second == URISelector::inorder) {
                return "inorder";
            } else if (second == URISelector::feedback) {
                return "feedback";
            } else if (second == URISelector::adaptive) {
                    return "adaptive";
                }
            return "inorder";
        }
};
 
struct  ProxyMethodOption {
    bool first = false;
    ProxyMethod second;
    std::string asJson()
        {
            if (second == ProxyMethod::get) {
                return "get";
            } else if (second == ProxyMethod::tunnel) {
                return "tunnel";
            }
            return "get";
        }
};
 
struct  CryptoLevelOption {
    bool first = false;
    CryptoLevel second;
    std::string asJson()
        {
            if (second == CryptoLevel::plain) {
                return "plain";
            } else if (second == CryptoLevel::arc4) {
                return "arc4";
            }
            return "plain";
        }
};
 
 
struct  MetalinkProtocolOption {
    bool first = false;
    MetalinkProtocol second;
    std::string asJson()
        {
            if (second == MetalinkProtocol::http) {
                return "http";
            } else if (second == MetalinkProtocol::https) {
                return "https";
            } else if (second == MetalinkProtocol::ftp) {
                return "ftp";
            } else if (second == MetalinkProtocol::none) {
                return "none";
            }
            return "none";
        }
};
 
 
struct  FileAllocationOption {
    bool first = false;
    FileAllocation second;
    std::string asJson()
        {
            if (second == FileAllocation::none) {
                return "none";
            } else if (second == FileAllocation::prealloc) {
                return "prealloc";
            } else if (second == FileAllocation::falloc) {
                return "falloc";
            } else if (second == FileAllocation::trunc) {
                return "trunc";
            }
            return "none";
        }
};
 
 
struct  FTPTypeOption {
    bool first = false;
    FTPType second;
    std::string asJson()
        {
            if (second == FTPType::binary) {
                return "binary";
            } else if (second == FTPType::ascii) {
                return "ascii";
            }
            return "binary";
        }
};
 
 
struct  PieceSelectionAlgorithmOption {
    bool first = false;
    PieceSelectionAlgorithm second;
    std::string asJson()
        {
            if (second == PieceSelectionAlgorithm::def) {
                return "default";
            } else if (second == PieceSelectionAlgorithm::inorder) {
                return "inorder";
            } else if (second == PieceSelectionAlgorithm::geom) {
                return "geom";
            } else if (second == PieceSelectionAlgorithm::random) {
                return "random";
            }
            return "default";
        }
};
 
 
struct  stringListOption {
    bool first = false;
    stringList second;
    Json::Value asJson()
        {
            Json::Value uris(Json::arrayValue);
            for(auto const &x : second) {
                uris.append(x.c_str());
            }
            return uris;
        }
};
 
//using boolOption = std::pair<bool, bool>;
//using floatOption = std::pair<bool, float>;
//using intOption = std::pair<bool, int>;
//using size_tOption = std::pair<bool, size_t>;
//using stringOption = std::pair<bool, std::string>;
//using stringListOption = std::pair<bool, stringList>;
 
 
using namespace jsonrpc;
class DownloadOptions
{
public:
    Json::Value m_options;
    DownloadOptions();
    bool update();
    Json::Value asJsonArray();
 
 
    /******************
     * SETTER METHODS
     ****************/
 
 
 
 
    void setBtMaxPeers(int value);
    void setBtRemoveUnselectedFile(bool value);
    void setForceSave(bool value);
    void setMaxDownloadLimit(int value);
    void setMaxUploadLimit(int value);
    void setPieceLength(int value);
    void setRpcSaveUploadMetadata(bool value);
    void setBtRequestPeerSpeedLimit(int value);
    void setDryRun(bool value);
    void setDir(std::string value);
    void setBtMinCryptoLevel(CryptoLevel value);
    void setFtpType(FTPType value);
    void setFileAllocation(FileAllocation value);
    void setMetalinkPreferredProtocol(MetalinkProtocol value);
    void setStreamPieceSelector(PieceSelectionAlgorithm value);
    void setProxyMethod(ProxyMethod value);
    void setUriSelector(URISelector value);
    void setAllowOverwrite(bool value);
    void setAllowPieceLengthChange(bool value);
    void setAlwaysResume(bool value);
    void setAsyncDns(bool value);
    void setAutoFileRenaming(bool value);
    void setBtEnableHookAfterHashCheck(bool value);
    void setBtEnablelpd(bool value);
    void setBtForceEncryption(bool value);
    void setBtHashCheckSeed(bool value);
    void setBtLoadSavedMetadata(bool value);
    void setBtMetadataOnly(bool value);
    void setBtRequireCrypto(bool value);
    void setBtSaveMetadata(bool value);
    void setBtSeedUnverified(bool value);
    void setBtStopTimeout(bool value);
    void setCheckIntegrity(bool value);
    void setConditionalGet(bool value);
    void setCont(bool value);
    void setEnableHttpKeepAlive(bool value);
    void setEnableHttpPipelining(bool value);
    void setEnableMmap(bool value);
    void setEnablePeerExchange(bool value);
    void setFollowMetalink(bool value);
    void setFollowTorrent(bool value);
    void setFtpPasv(bool value);
    void setFtpReuseConnection(bool value);
    void setHashCheckOnly(bool value);
    void setHttpAcceptGzip(bool value);
    void setHttpAuthChallenge(bool value);
    void setHttpNoCache(bool value);
    void setMetalinkEnableUniqueProtocol(bool value);
    void setNoNetrc(bool value);
    void setParameterizedUri(bool value);
    void setPause(bool value);
    void setPauseMetadata(bool value);
    void setRealtimeChunkChecksum(bool value);
    void setRemoteTime(bool value);
    void setRemoveControlFile(bool value);
    void setReuseUri(bool value);
    void setUseHead(bool value);
    void setSeedRatio(float value);
    void setSeedTime(float value);
    void setBtTrackerConnectTimeout(int value);
    void setBtTrackerInterval(int value);
    void setBtTrackerTimeout(int value);
    void setConnectTimeout(int value);
    void setLowestSpeedLimit(int value);
    void setMaxConnectionPerServer(int value);
    void setMaxResumeFailureTries(int value);
    void setMaxTries(int value);
    void setRetryWait(int value);
    void setSplit(int value);
    void setStop(int value);
    void setTimeout(int value);
    void setMaxMmapLimit(size_t value);
    void setMinSplitSize(size_t value);
    void setNoFileAllocationLimit(size_t value);
    void setBtTracker(stringList value);
    void setBtExternalIp(std::string value);
    void setFtpPasswd(std::string value);
    void setFtpProxy(std::string value);
    void setFtpProxyPasswd(std::string value);
    void setFtpProxyUser(std::string value);
    void setFtpUser(std::string value);
    void setGid(std::string value);
    void setHttpPasswd(std::string value);
    void setHttpProxy(std::string value);
    void setHttpProxyPasswd(std::string value);
    void setHttpProxyUser(std::string value);
    void setHttpUser(std::string value);
    void setHttpsProxy(std::string value);
    void setHttpsProxyPasswd(std::string value);
    void setHttpsProxyUser(std::string value);
    void setMetalinkLanguage(std::string value);
    void setMetalinkLocation(std::string value);
    void setMetalinkOs(std::string value);
    void setMetalinkVersion(std::string value);
    void setOut(std::string value);
    void setUserAgent(std::string value);
 
 
    
    /******************
     * GETTER METHODS
     ****************/
 
 
 
 
    bool getDryRun() const;
    bool getForceSave() const;
    bool getRpcSaveUploadMetadata() const;
    int getBtMaxPeers() const;
    int getBtRequestPeerSpeedLimit() const;
    int getMaxDownloadLimit() const;
    int getMaxUploadLimit() const;
    size_t getPieceLength() const;
    bool getBtRemoveUnselectedFile() const;
    std::string getDir() const;
 
    CryptoLevel getBtMinCryptoLevel() const;
    FTPType getFtpType() const;
    FileAllocation getFileAllocation() const;
    MetalinkProtocol getMetalinkPreferredProtocol() const;
    PieceSelectionAlgorithm getStreamPieceSelector() const;
    ProxyMethod getProxyMethod() const;
    URISelector getUriSelector() const;
    bool getAllowOverwrite() const;
    bool getAllowPieceLengthChange() const;
    bool getAlwaysResume() const;
    bool getAsyncDns() const;
    bool getAutoFileRenaming() const;
    bool getBtEnableHookAfterHashCheck() const;
    bool getBtEnablelpd() const;
    bool getBtForceEncryption() const;
    bool getBtHashCheckSeed() const;
    bool getBtLoadSavedMetadata() const;
    bool getBtMetadataOnly() const;
    bool getBtRequireCrypto() const;
    bool getBtSaveMetadata() const;
    bool getBtSeedUnverified() const;
    bool getBtStopTimeout() const;
    bool getCheckIntegrity() const;
    bool getConditionalGet() const;
    bool getCont() const;
    bool getEnableHttpKeepAlive() const;
    bool getEnableHttpPipelining() const;
    bool getEnableMmap() const;
    bool getEnablePeerExchange() const;
    bool getFollowMetalink() const;
    bool getFollowTorrent() const;
    bool getFtpPasv() const;
    bool getFtpReuseConnection() const;
    bool getHashCheckOnly() const;
    bool getHttpAcceptGzip() const;
    bool getHttpAuthChallenge() const;
    bool getHttpNoCache() const;
    bool getMetalinkEnableUniqueProtocol() const;
    bool getNoNetrc() const;
    bool getParameterizedUri() const;
    bool getPause() const;
    bool getPauseMetadata() const;
    bool getRealtimeChunkChecksum() const;
    bool getRemoteTime() const;
    bool getRemoveControlFile() const;
    bool getReuseUri() const;
    bool getUseHead() const;
    float getSeedRatio() const;
    float getSeedTime() const;
    int getBtTrackerConnectTimeout() const;
    int getBtTrackerInterval() const;
    int getBtTrackerTimeout() const;
    int getConnectTimeout() const;
    int getLowestSpeedLimit() const;
    int getMaxConnectionPerServer() const;
    int getMaxResumeFailureTries() const;
    int getMaxTries() const;
    int getRetryWait() const;
    int getSplit() const;
    int getStop() const;
    int getTimeout() const;
    size_t getMaxMmapLimit() const;
    size_t getMinSplitSize() const;
    size_t getNoFileAllocationLimit() const;
    std::string getBtExternalIp() const;
    std::string getFtpPasswd() const;
    std::string getFtpProxy() const;
    std::string getFtpProxyPasswd() const;
    std::string getFtpProxyUser() const;
    std::string getFtpUser() const;
    std::string getGid() const;
    std::string getHttpPasswd() const;
    std::string getHttpProxy() const;
    std::string getHttpProxyPasswd() const;
    std::string getHttpProxyUser() const;
    std::string getHttpUser() const;
    std::string getHttpsProxy() const;
    std::string getHttpsProxyPasswd() const;
    std::string getHttpsProxyUser() const;
    std::string getMetalinkLanguage() const;
    std::string getMetalinkLocation() const;
    std::string getMetalinkOs() const;
    std::string getMetalinkVersion() const;
    std::string getOut() const;
    std::string getUserAgent() const;
    stringList getBtTracker() const;
 
 
 
 
 
private:
    boolOption dryRun;
    boolOption forceSave;
    boolOption rpcSaveUploadMetadata;
    intOption btMaxPeers;
    intOption btRequestPeerSpeedLimit;
    intOption maxDownloadLimit;
    intOption maxUploadLimit;
    size_tOption pieceLength;
    boolOption btRemoveUnselectedFile;
    stringOption dir;
    // all-proxy
    //all-proxy-passwd
    //all-proxy-user
 
    boolOption allowOverwrite;
    boolOption allowPieceLengthChange;
    boolOption alwaysResume;
    boolOption asyncDns;
    boolOption autoFileRenaming;
    boolOption btEnablelpd;
    boolOption btForceEncryption;
    boolOption btHashCheckSeed;
    boolOption btLoadSavedMetadata;
    boolOption btMetadataOnly;
    boolOption btEnableHookAfterHashCheck;
    stringOption btExternalIp;
    CryptoLevelOption btMinCryptoLevel;
    //bt-prioritize-piece
    boolOption btRequireCrypto;
    boolOption btSaveMetadata;
    boolOption btSeedUnverified;
 
    boolOption btStopTimeout;
 
    stringListOption btTracker;
    intOption btTrackerConnectTimeout;
    intOption btTrackerInterval;
    intOption btTrackerTimeout;
    boolOption checkIntegrity;
    boolOption conditionalGet;
    intOption connectTimeout;
 
    boolOption cont;
    boolOption enableHttpKeepAlive;
    boolOption enableHttpPipelining;
    boolOption enableMmap;
    boolOption enablePeerExchange;
    
    FileAllocationOption fileAllocation;
 
    boolOption followMetalink;
    boolOption followTorrent;
 
    stringOption ftpUser;
    stringOption ftpPasswd;
    stringOption ftpProxy;
    stringOption ftpProxyPasswd;
    stringOption ftpProxyUser;
    boolOption ftpReuseConnection;
    FTPTypeOption ftpType;
    boolOption ftpPasv;
    stringOption gid;
    boolOption hashCheckOnly;
    boolOption httpAcceptGzip;
    boolOption httpAuthChallenge;
    boolOption httpNoCache;
    //header
    stringOption httpUser;
    stringOption httpPasswd;
    stringOption httpProxy;
    stringOption httpProxyPasswd;
    stringOption httpProxyUser;
    stringOption httpsProxy;
    stringOption httpsProxyPasswd;
    stringOption httpsProxyUser;
    //index-out
    intOption lowestSpeedLimit;
    intOption maxConnectionPerServer;
    size_tOption maxMmapLimit;
    intOption maxResumeFailureTries;
    intOption maxTries;
    //metalink-base-uri
    boolOption metalinkEnableUniqueProtocol;
    stringOption metalinkLanguage;
    stringOption metalinkLocation;
    stringOption metalinkOs;
    MetalinkProtocolOption metalinkPreferredProtocol;
    stringOption metalinkVersion;
    size_tOption minSplitSize;
    size_tOption noFileAllocationLimit;
    boolOption noNetrc;
    //no-proxy
    stringOption out;
    boolOption parameterizedUri;
    boolOption pause;
    boolOption pauseMetadata;
    ProxyMethodOption proxyMethod;
    boolOption realtimeChunkChecksum;
    //referer
    boolOption remoteTime;
    boolOption removeControlFile;
    intOption retryWait;
    boolOption reuseUri;
    floatOption seedRatio;
    floatOption seedTime;
    intOption stop;
    //select-file
    intOption split;
    //ssh-host-key-md
    PieceSelectionAlgorithmOption streamPieceSelector;
    intOption timeout;
    URISelectorOption uriSelector;
    boolOption useHead;
    stringOption userAgent;
 
 
    //  Json::Value m_options;
    Download *m_download = nullptr; // May point to an active download
    // otherwise, if nullptr, it is inactive.
    
};
#endif //DOWNLOADOPTIONS_H_