vsnet_notify.h

Go to the documentation of this file.

#ifndef VSNET_DLOADITEM_H
#define VSNET_DLOADITEM_H

#include <config.h>

#include <string>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <iostream>

#include "vsnet_dloadenum.h"

#include "boost/shared_ptr.hpp"
#include "boost/shared_array.hpp"

#include "vsnet_socket.h"

#include "vsfilesystem.h"

namespace VsnetDownload
{
namespace Client
{
//forward declaration
class Manager;

class Notify;

class Item;

class NotifyMe;

class Notify_f;

class Notify_fp;

class File;

class Buffer;

class TestItem;

class NoteFile;

class FileSet;

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::Notify
*------------------------------------------------------------*/

class Notify
{
public:
    virtual void notify( State s, VSError e ) = 0;
    virtual void setTotalBytes( int sz ) {}
    virtual void addBytes( int sz ) {}
};

typedef boost::shared_ptr< Notify >NotifyPtr;

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::NotifyMe
*------------------------------------------------------------*/

class NotifyMe : public Notify
{
public: NotifyMe();
    virtual ~NotifyMe() {}

    virtual void notify( State s, VSError e );
    virtual void setTotalBytes( int sz );
    virtual void addBytes( int sz );

    inline bool done() const
    {
        return _state == Completed;
    }

    inline bool ok() const
    {
        return _error == Ok;
    }

    inline int total() const
    {
        return _total;
    }

    inline int offset() const
    {
        return _offset;
    }

private:
    State   _state;
    VSError _error;
    int     _total;
    int     _offset;
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::Item
*------------------------------------------------------------*/

class Item
{
public: Item( SOCKETALT sock, const std::string &filename, VSFileSystem::VSFileType = VSFileSystem::UnknownFile,
             NotifyPtr notify = NotifyPtr() );
    virtual ~Item();

    State state() const;
    VSError error() const;

    void changeState( State s );
    void changeState( State s, VSError e );

    void setFileType( VSFileSystem::VSFileType ft );
    VSFileSystem::VSFileType getFileType();

    void setSize( int len );
    void append( unsigned char *buffer, int bufsize );

    const std::string& getFilename() const;
    SOCKETALT getSock() const;
    int get_fd() const;

protected:
    virtual void childSetSize( int len ) = 0;
    virtual void childAppend( unsigned char *buffer, int bufsize ) = 0;

    void protected_replace_notifier( NotifyPtr ptr );
    VSFileSystem::VSFileType _filetype;

private:
    SOCKETALT _sock;
    const std::string _filename;

    mutable VSMutex   _mx;
    State     _state;
    VSError   _error;
    NotifyPtr _notify;
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::File
*------------------------------------------------------------*/

class File : public Item
{
public: File( SOCKETALT sock, const std::string &filename, std::string localbasepath, VSFileSystem::VSFileType ft,
             NotifyPtr notify = NotifyPtr() );

    File( const std::string &destfile, SOCKETALT sock, const std::string &filename, std::string localbasepath,
         VSFileSystem::VSFileType ft,
         NotifyPtr notify = NotifyPtr() );

    virtual ~File();

protected:
    virtual void childSetSize( int len );
    virtual void childAppend( unsigned char *buffer, int bufsize );

private:
    std::string _destfile;
    std::string _localbasepath;
    VSFileSystem::VSFile *_of;
    int _len;
    int _offset;
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::NoteFile
*------------------------------------------------------------*/

class NoteFile : public File
{
private:
    NotifyPtr _me;

    inline const NotifyMe * me() const
    {
        return (NotifyMe*) _me.get();
    }

public: NoteFile( SOCKETALT sock, const std::string &filename, VSFileSystem::VSFileType ft, std::string localbasepath );
    NoteFile( SOCKETALT sock, const std::string &filename, VSFileSystem::VSFileType ft );
    NoteFile( const std::string &destfile, SOCKETALT sock, const std::string &filename, VSFileSystem::VSFileType ft );

    virtual ~NoteFile();

    inline bool done() const
    {
        return me()->done();
    }

    inline bool ok() const
    {
        return me()->ok();
    }

    inline int total() const
    {
        return me()->total();
    }

    inline int offset() const
    {
        return me()->offset();
    }
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::Buffer
*------------------------------------------------------------*/

class Buffer : public Item
{
    typedef unsigned char uchar;
    NotifyPtr _me;

    inline const NotifyMe * me() const
    {
        return (NotifyMe*) _me.get();
    }

public: Buffer( SOCKETALT sock, const std::string &filename, VSFileSystem::VSFileType ft );

    virtual ~Buffer();

    boost::shared_array< uchar >getBuffer() const;
    int getSize()
    {
        return this->_len;
    }

    inline bool done() const
    {
        return me()->done();
    }

    inline bool ok() const
    {
        return me()->ok();
    }

    inline int total() const
    {
        return me()->total();
    }

    inline int offset() const
    {
        return me()->offset();
    }

protected:
    virtual void childSetSize( int len );
    virtual void childAppend( unsigned char *buffer, int bufsize );

private:
    boost::shared_array< uchar >_buf;
    int _len;
    int _offset;
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::TestItem
*------------------------------------------------------------*/

class TestItem : public Item
    , public NotifyMe
{
public: TestItem( SOCKETALT sock, const std::string &filename );

    virtual ~TestItem() {}

protected:
    virtual void childSetSize( int len ) {}
    virtual void childAppend( unsigned char *buffer, int bufsize ) {}
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::FileSet
*------------------------------------------------------------*/

class FileSet
{
public: FileSet( boost::shared_ptr< Manager >mgr, SOCKETALT sock, std::list< std::string >filesnames, std::string localbasepath );

    bool isDone() const;
    void update( std::string s, bool v );

private:
    std::map< std::string, int >_files;
    int _to_go;

private:
    class NotifyConclusion;
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::Notify_f
*------------------------------------------------------------*/

class Notify_f : public Notify
{
public:
    typedef void (*NotifyFunction)( std::string str, State s, VSError e, int total, int offset );

public: Notify_f( std::string filename, NotifyFunction fun );
    virtual ~Notify_f();

    virtual void notify( State s, VSError e );
    virtual void setTotalBytes( int sz );
    virtual void addBytes( int sz );

private:
    std::string    _filename;
    NotifyFunction _fun;
    int _total;
    int _offset;
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::Notify_fp
*------------------------------------------------------------*/

struct Notify_fp : public NotifyPtr
{
    Notify_fp( std::string filename, Notify_f::NotifyFunction fun ) :
        NotifyPtr( new Notify_f( filename, fun ) )
    {}
};

/*------------------------------------------------------------*
* declaration VsnetDownload::Client::VSNotify
*------------------------------------------------------------*/

class VSNotify : public Notify
{
public:
    void notify( State s, VSError e );
    void setTotalBytes( int sz );
    void addBytes( int sz );
};
}; //namespace Client
}; //namespace VsnetDownload

#endif /* VSNET_DLOADITEM_H */