Handler.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005 Palmsource, Inc.
 * 
 * This software is licensed as described in the file LICENSE, which
 * you should have received as part of this distribution. The terms
 * are also available at http://www.openbinder.org/license.html.
 * 
 * This software consists of voluntary contributions made by many
 * individuals. For the exact contribution history, see the revision
 * history and logs, available at http://www.openbinder.org
 */

#ifndef _SUPPORT_HANDLER_H
#define _SUPPORT_HANDLER_H

#include <support/Atom.h>
#include <support/Locker.h>
#include <support/Message.h>
#include <support/MessageList.h>
#include <support/SupportDefs.h>

// XXX remove
#include <support/Context.h>

#if _SUPPORTS_NAMESPACE
namespace palmos {
namespace support {
#endif

class BProcess;
class SHandler;

typedef SHandler BHandler;

nsecs_t approx_SysGetRunTime();
nsecs_t exact_SysGetRunTime();  

/*----------------------------------------------------------------*/
/*----- SHandler class --------------------------------------------*/


class SHandler : public virtual SAtom
{
public:
    // --------------------------------------------------------------
            
                            SHandler();
                            SHandler(SLocker* externalLock);

                            SHandler(const SContext& context);

protected:
    virtual                 ~SHandler();
public:


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

            enum {

                POST_REMOVE_DUPLICATES  = 0x0001,


                POST_KEEP_UNIQUE            = 0x0002
            };


            status_t        PostMessage(        const SMessage &message,
                                                uint32_t flags = 0);

            status_t        PostDelayedMessage( const SMessage &message,
                                                nsecs_t delay,
                                                uint32_t flags = 0);

            status_t        PostMessageAtTime(  const SMessage &message,
                                                nsecs_t absoluteTime,
                                                uint32_t flags = 0);

            status_t        EnqueueMessage(     const SMessage& message,
                                                nsecs_t time,
                                                uint32_t flags = 0);


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

    virtual status_t        HandleMessage(const SMessage &msg);


            void            ResumeScheduling();


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

            enum filter_action {
                FILTER_REMOVE           = 0,            
                FILTER_KEEP             = 1,            
                FILTER_STOP             = 2             
            };

            enum {
                FILTER_REVERSE_FLAG     = 0x0001,       
                FILTER_FUTURE_FLAG      = 0x0002        
            };


            typedef filter_action   (*filter_func)(const SMessage* message, void* data);


            class filter_functor_base
            {
            public:
                virtual filter_action operator()(const SMessage* message, void* user) const = 0;
                virtual ~filter_functor_base() { }
            };

            template<class T>
            class filter_functor : public filter_functor_base
            {
            public:
                typedef filter_action (T::*method_ptr_t)(const SMessage* message, void* user) const;
                filter_functor(const T& o, method_ptr_t m) : object(o), method(m) { }
                filter_functor(const T* o, method_ptr_t m) : object(*o), method(m) { }
                virtual filter_action operator()(const SMessage* message, void* user) const {
                    return (object.*method)(message, user);
                }
            private:
                const T&        object;
                method_ptr_t    method;
            };

        

            void            FilterMessages( filter_func func, uint32_t flags,
                                            void* data,
                                            SMessageList* outRemoved = NULL);

            void            FilterMessages( const filter_functor_base& functor, uint32_t flags,
                                            void* data,
                                            SMessageList* outRemoved = NULL);
            

            void            RemoveMessages( uint32_t what, uint32_t flags,
                                            SMessageList* outRemoved = NULL);
            

            void            RemoveAllMessages(SMessageList* outRemoved = NULL);

            int32_t         CountMessages(uint32_t what=B_ANY_WHAT);


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

            nsecs_t         NextMessageTime(int32_t* out_priority);
            

            SMessage*       DequeueMessage(uint32_t what);
            
            void            DispatchAllMessages();
            

private:
    friend  class           BProcess;

                            SHandler(const SHandler&);
            SHandler        operator=(const SHandler&);
    
            enum scheduling {
                CANCEL_SCHEDULE = 0,
                DO_SCHEDULE,
                DO_RESCHEDULE
            };

            status_t        enqueue_unique_message(const SMessage& message, nsecs_t time, uint32_t flags);

            void            defer_scheduling();
            void            unschedule();
            scheduling      start_schedule();
            void            done_schedule();

            status_t        dispatch_message();

            sptr<BProcess>  m_team;
            SLocker         m_lock;
            SMessageList    m_msgQueue;
            uint32_t        m_state;
            
            SHandler *      m_next;
            SHandler *      m_prev;

            SLocker*        m_externalLock;
};

enum {
    B_POST_REMOVE_DUPLICATES    = SHandler::POST_REMOVE_DUPLICATES, 
    B_POST_KEEP_UNIQUE          = SHandler::POST_KEEP_UNIQUE,       

    B_POST_UNIQUE_MESSAGE       = B_POST_REMOVE_DUPLICATES
};

enum {
    B_FILTER_REVERSE_FLAG       = SHandler::FILTER_REVERSE_FLAG,
    B_FILTER_FUTURE_FLAG        = SHandler::FILTER_FUTURE_FLAG  
};


/**************************************************************************************/

#if _SUPPORTS_NAMESPACE
} } // namespace palmos::support
#endif

#endif /* _SUPPORT_HANDLER_H */

---

Generated on Wed Dec 28 22:33:27 2005 by Doxygen 1.4.4 for OpenBinder Documentation Version 1.0

PalmSource, Inc. © 2005