Subversion Repositories DevTools

//---------------------------------------------------------------------------

#ifndef UdTransferManagerH

#define UdTransferManagerH

#include <vcl.h>

#include <map>

#include <vector>

#include <syncobjs.hpp>

#include "IDeviceFactory.h"

//---------------------------------------------------------------------------

typedef enum

{

    UdTransferCompleted = 0,

    UdTransferFailed = 1,

    UdTransferAborted = 2,

    UdTransferInProgress = 3,

    UdTransferPending = 4

} UdTransferTaskState;

typedef enum

{

    RampTestDisabled = 0,

    RampTestByDemand = 1,

    RampTestByRatio  = 2

} RampTestType;

typedef std::vector<int>        BatchSizeList;

typedef BatchSizeList::iterator BatchSizeItem;

struct UdTransferStatistics

{

    int     processedFiles;

    int     totalFiles;

    int     processedBytes;

    int     totalBytes;

    bool    completed;

    TDateTime startTime;

    TDateTime endTime;   

    BatchSizeList batches;    

};

struct UdFile

{

    AnsiString  name;

    int         size;

    TDateTime   time;

    UdFile() {}

    UdFile( const UdFile & rhs ) :

        name( rhs.name ), size( rhs.size ), time( rhs.time ) {}

    bool operator<( const UdFile & rhs ) const

    {

        return time < rhs.time;

    };

};

typedef std::vector<UdFile>     UdFileList;

typedef UdFileList::iterator    UdFileItem;

struct UdTransferTask

{

    int                 id;

    int                 batchSize;

    unsigned int        duration;

    int                 frequency;

    bool                recurring;

    AnsiString          sourcePath;

    AnsiString          destination;

    UdFileList          files;

    UdTransferTaskState state;

    RampTestType        rampType;

    double              gradient;

    TDateTime           rampTime;

    UdTransferTask() {}

    UdTransferTask( const UdTransferTask & rhs ) :

        id( rhs.id ), batchSize( rhs.batchSize ), duration( rhs.duration ),

        frequency( rhs.frequency ), recurring( rhs.recurring ), sourcePath( rhs.sourcePath ),

        destination( rhs.destination ), files( rhs.files ), state( rhs.state ),

        rampType( rhs.rampType ), gradient( rhs.gradient ), rampTime( rhs.rampTime ) {}

    bool operator!=( const UdTransferTask & rhs )

    {

        return (batchSize != rhs.batchSize &&

                duration  != rhs.duration &&

                frequency != rhs.frequency &&

                recurring != rhs.recurring &&

                sourcePath != rhs.sourcePath &&

                destination != rhs.destination &&

                state != rhs.state &&

                rampType != rhs.rampType &&

                gradient != rhs.gradient &&

                rampTime != rhs.rampTime);

    }

};

typedef std::vector<UdTransferTask>     UdTransferTaskList;

typedef UdTransferTaskList::iterator    UdTransferTaskItem;

class UdTransferThread;

typedef std::map<int, UdTransferThread *> UdTransferThreadMap;

typedef UdTransferThreadMap::iterator   UdTransferThreadItem;

//---------------------------------------------------------------------------

class UdTransferManager

{

public:

    UdTransferManager();

    virtual ~UdTransferManager();

    void AddNewTask( const UdTransferTask & task );

    void LoadPendingTasks();

    void UpdateTask( const UdTransferTask & task,

                     const AnsiString & comment = "" );

    bool GetTaskDetails( UdTransferTask & task );

    bool LaunchTask( const UdTransferTask & task );

    bool GetTaskStatistics( const int & taskId,

                            UdTransferStatistics & stats );

    void UpdateTaskStatistics( const int & taskId,

                               const UdTransferStatistics & stats );

    bool IsTaskRunning();

    AnsiString GetUsername() { return m_username; }

    AnsiString GetHostname() { return m_hostname; } 

private:

    AnsiString  m_username;

    AnsiString  m_hostname;

    UdTransferThreadMap m_threads;

    UdTransferTaskList  m_tasks;

    Syncobjs::TCriticalSection *  m_tasksLock;

    HINSTANCE           m_deviceSimulatorWrapperDll;

    getDeviceFactory_t  m_getDeviceFactory;

    IDeviceFactory *    m_deviceSimulatorFactory;

};

#endif