ConfirmSignal.h

#ifndef _MSGCONFIRMSIGNAL_H
#define _MSGCONFIRMSIGNAL_H
// -------------------------------------------------------------------------
#include <UniSetTypes.h>
#include <sigc++/sigc++.h>
#include <USignals.h>
#include <deque>
#include <set>
#include <USignals.h>
#include <time.h>
// -------------------------------------------------------------------------
class MsgConfirmConnection;
class GuiPM;
// -------------------------------------------------------------------------
typedef sigc::slot< void, UMessages::MessageId, time_t> MsgConfirmSlot;
typedef sigc::signal< void, UMessages::MessageId, time_t> MsgConfirmSignal;
enum MessageStatus {
             WAITS_CONFIRM  
             ,CONFIRMED     
             ,DROPPED       
           };
// -------------------------------------------------------------------------
struct MsgConfirmEntry
{
    MsgConfirmEntry( UMessages::MessageId id, MsgConfirmSignal* signal ):
        _id( id ), _signal( signal ) {}
    UMessages::MessageId _id;       
    MsgConfirmSignal* _signal;      
};
// -------------------------------------------------------------------------
typedef std::deque<MsgConfirmEntry> MsgConfirmContainer;
typedef std::set<UMessages::MessageId> MsgConfirmedContainer;
// -------------------------------------------------------------------------
class WaitsQueue_ConstIterator : public MsgConfirmContainer::const_iterator
{
public:
    typedef MsgConfirmContainer::const_iterator BaseIt;
    typedef MsgConfirmContainer::iterator NonConstBaseIt;
    WaitsQueue_ConstIterator( const BaseIt& iter ) : BaseIt(iter) {}
    WaitsQueue_ConstIterator( const NonConstBaseIt& iter ) : BaseIt(iter) {}
    const UMessages::MessageId& operator*() const 
    {
        return BaseIt::operator->()->_id;
    }
    const UMessages::MessageId* operator->() const
    {
        return &operator*();
    }
};
// -------------------------------------------------------------------------
class ConfirmSignal
{
friend class MsgConfirmConnection;
public:
    typedef WaitsQueue_ConstIterator const_iterator;
    ConfirmSignal( GuiPM* gpm );
    ~ConfirmSignal();
    MsgConfirmConnection connect( const MsgConfirmSlot&, UMessages::MessageId id);
    sigc::connection connect_msg_wait_confirm( sigc::slot<void, UMessages::MessageId>& slot );
    MessageStatus get_message_status(UMessages::MessageId id);

    const_iterator begin()
    {
        return mcc.begin(); 
    }
    const_iterator end()
    {
        return mcc.end();
    }
    void emit(time_t sec);

    void set_autoconfirm_time(int new_time)
    { _auto_confirm_time = new_time; }

private:
    void confirm(time_t);
    void on_disconnect();
    void drop_message(UMessages::MessageId id, USignals::VConn* conn);

    MsgConfirmContainer mcc;
    MsgConfirmedContainer mcedc;
    sigc::signal<void, UMessages::MessageId> signal_msg_wait_confirm;
    GuiPM* _gpm;

    int _auto_confirm_time;
    bool auto_confirm();
};
// -------------------------------------------------------------------------
class MsgConfirmConnection
{
public:
    MsgConfirmConnection(ConfirmSignal* sig, sigc::connection& conn, UMessages::MessageId id)
        :_id (id), _signal(sig), _connection(conn) {}
    MsgConfirmConnection():_signal(NULL) {}
    ~MsgConfirmConnection() {}
    void disconnect();

private:
    UMessages::MessageId _id;
    ConfirmSignal* _signal;
    sigc::connection _connection;

public:

};
#endif