gclientptr.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// 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 G_SMTP_CLIENT_PTR_H
#define G_SMTP_CLIENT_PTR_H

#include "gdef.h"
#include "gnet.h"
#include "gclient.h"
#include "gexception.h"
#include "gassert.h"
#include "gslot.h"
#include <memory>

namespace GNet
{

template <typename TClient>
class ClientPtr 
{
public:
        G_EXCEPTION( InvalidState , "invalid state of smtp client" ) ;

        explicit ClientPtr( TClient * p = NULL , bool preserve_resolver_info = false ) ;

        ~ClientPtr() ;

        bool busy() const ;

        void reset( TClient * p = NULL ) ;

        TClient * get() ;

        TClient * operator->() ;

        const TClient * operator->() const ;

        G::Signal2<std::string,bool> & doneSignal() ;

        G::Signal2<std::string,std::string> & eventSignal() ;

        G::Signal0 & connectedSignal() ;

        ResolverInfo resolverInfo() const ;

        void releaseForExit() ;

        void cleanupForExit() ;

private:
        ClientPtr( const ClientPtr & ) ; // not implemented
        void operator=( const ClientPtr & ) ; // not implemented
        void doneSlot( std::string , bool ) ;
        void eventSlot( std::string , std::string ) ;
        void connectedSlot() ;
        void connectSignalsToSlots() ;
        void disconnectSignals() ;

private:
        TClient * m_p ;
        bool m_update ;
        ResolverInfo m_resolver_info ;
        G::Signal2<std::string,bool> m_done_signal ;
        G::Signal2<std::string,std::string> m_event_signal ;
        G::Signal0 m_connected_signal ;
} ;

template <typename TClient>
ClientPtr<TClient>::ClientPtr( TClient * p , bool update ) :
        m_p(p) ,
        m_update(update) ,
        m_resolver_info(std::string(),std::string())
{
        try
        {
                if( m_p != NULL )
                {
                        m_resolver_info = m_p->resolverInfo() ;
                }
                connectSignalsToSlots() ;
        }
        catch(...)
        {
                throw ;
        }
}

template <typename TClient>
ClientPtr<TClient>::~ClientPtr()
{
        if( m_p != NULL )
        {
                disconnectSignals() ;
                m_p->doDelete(std::string()) ;
        }
}

template <typename TClient>
void ClientPtr<TClient>::releaseForExit()
{
        if( m_p != NULL )
        {
                disconnectSignals() ;
                m_p = NULL ;
        }
}

template <typename TClient>
void ClientPtr<TClient>::cleanupForExit()
{
        if( m_p != NULL )
        {
                disconnectSignals() ;
                TClient * p = m_p ;
                m_p = NULL ;
                p->doDeleteForExit() ;
        }
}

template <typename TClient>
void ClientPtr<TClient>::connectSignalsToSlots()
{
        if( m_p != NULL )
        {
                m_p->doneSignal().connect( G::slot(*this,&ClientPtr::doneSlot) ) ;
                m_p->eventSignal().connect( G::slot(*this,&ClientPtr::eventSlot) ) ;
                m_p->connectedSignal().connect( G::slot(*this,&ClientPtr::connectedSlot) ) ;
        }
}

template <typename TClient>
void ClientPtr<TClient>::reset( TClient * p )
{
        disconnectSignals() ;

        TClient * old = m_p ;
        m_p = p ;
        if( old != NULL )
        {
                old->doDelete(std::string()) ;
        }

        if( m_p != NULL && m_update )
        {
                m_p->updateResolverInfo( m_resolver_info ) ; // if host() and service() match
        }

        connectSignalsToSlots() ;
}

template <typename TClient>
G::Signal2<std::string,bool> & ClientPtr<TClient>::doneSignal()
{
        return m_done_signal ;
}

template <typename TClient>
G::Signal2<std::string,std::string> & ClientPtr<TClient>::eventSignal()
{
        return m_event_signal ;
}

template <typename TClient>
G::Signal0 & ClientPtr<TClient>::connectedSignal()
{
        return m_connected_signal ;
}

template <typename TClient>
void ClientPtr<TClient>::doneSlot( std::string reason , bool retry )
{
        G_ASSERT( m_p != NULL ) ;
        disconnectSignals() ;
        m_p = NULL ;
        m_done_signal.emit( reason , retry ) ;
}

template <typename TClient>
void ClientPtr<TClient>::disconnectSignals()
{
        if( m_p != NULL )
        {
                m_p->doneSignal().disconnect() ;
                m_p->eventSignal().disconnect() ;
                m_p->connectedSignal().disconnect() ;
        }
}

template <typename TClient>
void ClientPtr<TClient>::connectedSlot()
{
        G_ASSERT( m_p != NULL ) ;
        m_resolver_info = m_p->resolverInfo() ;
        m_connected_signal.emit() ;
}

template <typename TClient>
void ClientPtr<TClient>::eventSlot( std::string s1 , std::string s2 )
{
        m_event_signal.emit( s1 , s2 ) ;
}

template <typename TClient>
TClient * ClientPtr<TClient>::get()
{
        return m_p ;
}

template <typename TClient>
bool ClientPtr<TClient>::busy() const
{
        return m_p != NULL ;
}

template <typename TClient>
TClient * ClientPtr<TClient>::operator->()
{
        if( m_p == NULL )
                throw InvalidState() ;
        return m_p ;
}

template <typename TClient>
const TClient * ClientPtr<TClient>::operator->() const
{
        if( m_p == NULL )
                throw InvalidState() ;
        return m_p ;
}

template <typename TClient>
ResolverInfo ClientPtr<TClient>::resolverInfo() const
{
        return m_resolver_info ;
}

}

#endif