---

at_twin_basic.h

Go to the documentation of this file.

//
// The Austria library is copyright (c) Gianni Mariani 2004.
// 
// Grant Of License.  Grants to LICENSEE the non-exclusive right to use the Austria
// library subject to the terms of the LGPL.
// 
// A copy of the license is available in this directory or one may be found at this URL:
//      http://www.gnu.org/copyleft/lesser.txt
// 
#ifndef x_at_twin_basic_h_x
#define x_at_twin_basic_h_x 1

#include "at_exports.h"
#include "at_twin.h"
#include "at_assert.h"

// Austria namespace
namespace at
{

// ======== AppLeadTwin_EmptyTraits =====================================
template<
        typename        w_aide_twin_interface,
        typename        w_lead_interface
>
class AppLeadTwin_EmptyTraits
{
        public:

        typedef LeadTwin< w_aide_twin_interface, w_lead_interface >     t_LeadTwinInterface;


        // ======== AppLeadCompletedNotify ================================
        static inline void AppLeadCompletedNotify( t_LeadTwinInterface * i_lead )
        {
                //
                // DO NOTHING HERE : the EmptyTraits version does not
                // inform an application.
                //

                return;
                
        } // end AppLeadCompletedNotify 

};


// ======== AppLeadTwin_ForwardTraits =====================================
template<
        typename        w_aide_twin_interface,
        typename        w_lead_interface
>
class AppLeadTwin_ForwardTraits
{
        public:

        // ======== t_LeadTwinInterface ===================================
        class t_LeadTwinInterface
          : public LeadTwin< w_aide_twin_interface, w_lead_interface >
        {
                public:

                // ======== AppLeadCompleted ==================================
                virtual void AppLeadCompleted( TwinTraits::TwinCode i_competion_code )
        {
            
        }

        };

        // ======== AppLeadCompletedNotify ================================
        static inline void AppLeadCompletedNotify(
                t_LeadTwinInterface                                                       * i_lead,
                TwinTraits::TwinCode                                                    i_competion_code
        ) {

                i_lead->AppLeadCompleted( i_competion_code );

                return;

        } // end AppLeadCompletedNotify 

};



// ======== LeadTwin_Basic =========================================
template<
        typename        w_aide_twin_interface,
        typename        w_lead_interface,
        typename        w_app_lead_twin_interface = AppLeadTwin_ForwardTraits< w_aide_twin_interface, w_lead_interface >
>
class LeadTwin_Basic
  : public w_app_lead_twin_interface::t_LeadTwinInterface
{
public:
        typedef w_aide_twin_interface                           * t_AidePointer;
        
private:
        // ======== LeadBasicCancel =======================================
        inline void LeadBasicCancel()
        {
                w_aide_twin_interface                                   * l_aide( m_aide );

                if ( l_aide != 0 )
                {
                        //
                        // Before cacellation is done, the aide pointer
                        // must be removed.
                        //
                        m_aide = 0;

                        l_aide->AideCancel();
                }

                return;
                
        } // end LeadBasicCancel

        public:

        //
        // described in LeadTwin
        //
        virtual bool LeadAssociate( w_aide_twin_interface * i_aide )
        {
                LeadBasicCancel();

                AT_Assert( m_aide == 0 );

                m_aide = i_aide;

                return true;
        }

        //
        // described in LeadTwin - to be called ONLY from
        // Aide when completed.
        //
        virtual void LeadCompleted( TwinTraits::TwinCode i_competion_code )
        {
                //
                // 
                m_aide = 0;

                //
                // perform application specific notification
                w_app_lead_twin_interface::AppLeadCompletedNotify( this, i_competion_code );
        }


        //
        // described in LeadTwin
        //
        virtual void LeadCancel()
        {
                LeadBasicCancel();
        }


        LeadTwin_Basic()
          : m_aide( 0 )
        {
        }

        ~LeadTwin_Basic()
        {
        // calling LeadBasicCancel here is the same as
        // calling LeadCancel.
        LeadBasicCancel();
        }


        // ======== GetAide ===============================================
        inline void GetAide( t_AidePointer & o_aide_ptr )
        {
                o_aide_ptr = m_aide;

        } // end GetAide

        protected:
        t_AidePointer                                                             m_aide;

};



// ======== AppAideTwinTraits_EmptyTraits ==========================
template<
        typename        w_aide_twin_interface
>
class AppAideTwinTraits_EmptyTraits
{
        public:

        typedef w_aide_twin_interface                                   t_AideTwinInterface;



        // ======== AppAideCloseNotify_Internal ==============================
        inline static void AppAideCloseNotify_Internal(
                t_AideTwinInterface             * i_aide_ptr,
                TwinTraits::TwinCode              i_competion_code
        ) {

                //
                // EmptyTraits does no notifications
                //

                return;

        } // end AppAideCloseNotify

        

};


// ======== AppAideTwinTraits_ForwardTraits ==========================
template<
        typename        w_aide_twin_interface
>
class AppAideTwinTraits_ForwardTraits
{
        public:


    // ======== t_AideTwinInterface ===================================
    class t_AideTwinInterface
      : public w_aide_twin_interface
    {
        public:
        
        // ======== AppAideCloseNotify ======================================
        virtual void    AppAideCloseNotify(
            TwinTraits::TwinCode              i_competion_code
        ) {
        }

    };

        // ======== AppAideCloseNotify_Internal =============================
        inline static void AppAideCloseNotify_Internal(
                t_AideTwinInterface             * i_aide_ptr,
                TwinTraits::TwinCode              i_competion_code
        ) {

        i_aide_ptr->AppAideCloseNotify( i_competion_code );

                return;

        } // end AppAideCloseNotify

        

};


// ======== AideTwin_Basic =========================================
template<
        typename        w_aide_interface,
        typename        w_lead_interface,
        typename        w_app_aide_twin_traits = AppAideTwinTraits_ForwardTraits< AideTwin<w_aide_interface> >,
        typename        w_lead_twin_interface = LeadTwin<
                AideTwin<w_aide_interface>,
                w_lead_interface
        >
>
class AideTwin_Basic
  : public w_app_aide_twin_traits::t_AideTwinInterface
{
        public:

        typedef w_lead_twin_interface                                      * t_LeadPointer;

        ~AideTwin_Basic()
        {
                AideClose( TwinTraits::AideDelete );
        }


        // ======== AideAssociate =========================================
        void    AideAssociate(
                t_LeadPointer                                                                     i_lead
        )
        {
                AideClose( TwinTraits::AideGrabbed );

                m_lead = i_lead;

                WrapLeadAssociate( i_lead );

                return;

        } // end AideAssociate

        

        // ======== AideClose =============================================
        void    AideClose(
                TwinTraits::TwinCode i_competion_code
        )
        {
                t_LeadPointer                   l_lead = m_lead;

                if ( l_lead != 0 )
                {
                        m_lead = 0;
                        w_app_aide_twin_traits::AppAideCloseNotify_Internal( this, i_competion_code );
                        
                        WrapLeadCompleted( l_lead, i_competion_code );
                }

                return;

        } // end AideClose
        
        //
        // defined in AideTwin
        // 
        virtual void AideCancel()
        {

                AideClose( TwinTraits::CancelRequested );
        }

        inline void GetLead( t_LeadPointer & o_lead_ptr )
        {
                o_lead_ptr = m_lead;
        }

        AideTwin_Basic()
          : m_lead( 0 )
        {
        }

        protected:

        t_LeadPointer                                                                           m_lead;

};



// ======== NotifyLeadInterface ====================================
class NotifyLeadInterface
{
        protected:

        virtual ~NotifyLeadInterface() {}
        
        public:


        // ======== Notify ================================================
        virtual void Notify( int i_code ) = 0;
};



// ======== NullTwinInterface ======================================
class NullTwinInterface
{
        protected:

        virtual ~NullTwinInterface() {}

};

}; // namespace

#endif // x_at_twin_basic_h_x

Generated for Austria by and MakeXS at Sun Oct 24 17:35:34 PDT 2004