source.h

Go to the documentation of this file.

/*
* Copyright (c) 2011-2013 MLBA-Team. All rights reserved.
*
* @MLBA_OPEN_LICENSE_HEADER_START@
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @MLBA_OPEN_LICENSE_HEADER_END@
*/


#ifndef XDISPATCH_SOURCE_H_
#define XDISPATCH_SOURCE_H_

#ifndef __XDISPATCH_INDIRECT__
#error "Please #include <xdispatch/dispatch.h> instead of this file directly."
#endif

#include "any.h"

__XDISPATCH_BEGIN_NAMESPACE

class source;


class XDISPATCH_EXPORT sourcetype {

    public:
            virtual ~sourcetype();

    protected:
            sourcetype();

            void ready(const any& = any());
            virtual dispatch_source_t native();
            virtual void on_cancel();
            virtual void on_resume();
            virtual void on_suspend();
            virtual bool propagate_targetqueue() const { return false; }

    private:
            sourcetype(const sourcetype&){}
            void set_cb(source*);
            friend class source;
            source* cb;
};


class native_source_wrapper;

class XDISPATCH_EXPORT native_source : public sourcetype {

    public:
        native_source(dispatch_source_t);
        ~native_source();

    protected:
        virtual dispatch_source_t native();
        void on_resume ();
        void on_suspend ();
        void on_cancel ();
        bool propagate_targetqueue () const;

        virtual void on_source_ready();

    private:
        pointer<native_source_wrapper>::shared _source;
};


class XDISPATCH_EXPORT source : public object {

    public:
            source(sourcetype*);
            ~source();

            void resume();
            void suspend();

            void handler(xdispatch::operation*);
    #if XDISPATCH_HAS_BLOCKS

            virtual inline void handler(dispatch_block_t b) {
                handler( new block_operation(b) );
            }
    #endif
    #if XDISPATCH_HAS_FUNCTION

            virtual inline void handler(const lambda_function& b) {
                handler( new function_operation(b) );
            }
    #endif

            void target_queue(const xdispatch::queue&);
            xdispatch::queue target_queue() const;
            template <typename T> static T data(){
                    return _data()->cast<T>();
            }

            virtual dispatch_object_t native() const;
            dispatch_source_t native_source() const;
            void cancel();
            void cancel_handler(xdispatch::operation*);
    #if XDISPATCH_HAS_BLOCKS

            virtual inline void cancel_handler(dispatch_block_t b) {
                cancel_handler( new block_operation(b) );
            }
    #endif
    #if XDISPATCH_HAS_FUNCTION

            virtual inline void cancel_handler(const lambda_function& b) {
                cancel_handler( new function_operation(b) );
            }
    #endif

    private:
            source(const source&);
            source& operator=(const source&);
            class pdata;
            pointer<pdata>::shared d;

            void notify(const any&);
            sourcetype* source_type();
            static const any* _data();
            friend class sourcetype;
            friend class timer;
};

__XDISPATCH_END_NAMESPACE

#endif /* XDISPATCH_SOURCE_H_ */