transfer.h

Go to the documentation of this file.

#ifndef TRANSFER_H
#define TRANSFER_H

#include "iberbox/config.h"
#include <stdint.h>
#include <memory>

#include "iberbox/node.h"
#include "iberbox/error.h"

#ifdef USE_SCAPIX
#include <scapix/bridge/object.h>
#endif

namespace iberbox {

class TransferData
#ifdef USE_SCAPIX
    : public scapix::bridge::object<TransferData>
#endif
{
public:
    enum TransferType
    {
        UPLOAD,
        DOWNLOAD,
        METADATA_UPLOAD,
        METADATA_DOWNLOAD,
        LAST_TYPE
    };

    enum TransferStatus
    {
        STARTING,
        QUEUED,
        RETRYING,
        ACTIVE,
        FINISHED,
        LAST_STATUS
    };

    static const char *getTypeName(unsigned type)
    {
        static const char *sTransferNames[] =
        {
           "UPLOAD",
           "DOWNLOAD",
           "METADATA_UPLOAD",
           "METADATA_DOWNLOAD"
        };
        static_assert((sizeof(sTransferNames) / sizeof(sTransferNames[0]) == TransferData::LAST_TYPE), "Invalid number of transfer names");
        return type < TransferData::LAST_TYPE ? sTransferNames[type] : "INVALID";
    }

    static const std::string getTypeNameString(unsigned type)
    {
        return getTypeName(type);
    }

    static const char *getStatusName(unsigned type)
    {
        static const char *sTransferStatusNames[] =
        {
           "STARTING",
           "QUEUED",
           "RETRYING",
           "ACTIVE",
           "FINISHED"
        };
        static_assert((sizeof(sTransferStatusNames) / sizeof(sTransferStatusNames[0]) == TransferData::LAST_STATUS), "Invalid number of transfer status names");
        return type < TransferData::LAST_STATUS ? sTransferStatusNames[type] : "INVALID";
    }

    static const std::string getStatusNameString(unsigned type)
    {
        return getStatusName(type);
    }

    virtual ~TransferData();

    int getTag() const;
    int getType() const;
    unsigned getCrypto() const;
    int getStatus() const;
    int getNodeType() const;
    uint64_t getPriority() const;
    const char* getFile() const;
    const char* getSession() const;
    const std::string getFileString() const;
    std::vector<uint8_t>* getKey() const;
    std::vector<uint8_t>* getFullHash() const;
    std::vector<uint8_t>* getSparseHash() const;
    uint64_t getNodeId() const;
    Node getNode() const;
    uint64_t getProgress() const;
    uint64_t getPreviousProgress() const;
    uint64_t getSize() const;
    uint64_t getStartPosition() const;
    uint64_t getEndPosition() const;
    uint64_t getRetryTime() const;
    uint8_t getRetries() const;
    uint64_t getModificationTime() const;
    std::vector<uint8_t>* getData();
    uint64_t getSpeed() const;

    int getErrorType() const;
    const char* getErrorName() const;
    const std::string getErrorNameString() const;
#ifndef USE_SCAPIX
    Error getError() const;
#endif

    bool isFinished() const;
    bool isRetrying() const;

protected:
    TransferData();

    int mTag;
    int mType;
    int mStatus;
    int mNodeType;
    uint8_t mCrypto;
    uint64_t mPriority;
    char *mFile;
    char *mSession;
    uint64_t mNodeId;
    uint64_t mProgress;
    uint64_t mPreviousProgress;
    uint64_t mSize;
    uint64_t mStartPosition;
    uint64_t mEndPosition;
    uint64_t mRetryTime;
    uint8_t mRetries;
    uint64_t mModificationTime;
    std::vector<uint8_t> *mKey;
    std::vector<uint8_t> *mFullHash;
    std::vector<uint8_t> *mSparseHash;
    std::vector<uint8_t> mData;
    uint64_t mSpeed;
    Error mError;
    Node mNode;
};

typedef std::shared_ptr<TransferData> Transfer;
typedef std::vector<Transfer> TransferDataList;
typedef std::shared_ptr<TransferDataList> TransferList;

}

#endif // TRANSFER_H