base.h

Go to the documentation of this file.

/*
* Copyright (c) 2011-2012 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_BASE_H_
#define XDISPATCH_BASE_H_

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

#include <string>

__XDISPATCH_BEGIN_NAMESPACE

class XDISPATCH_EXPORT operation
{
    public:
        operation() : auto_del(true){}
        virtual ~operation(){}

        virtual void operator()() = 0;

        virtual void auto_delete(bool a){ auto_del = a; }
        virtual bool auto_delete() const { return auto_del; }

    private:
        bool auto_del;
};

class XDISPATCH_EXPORT iteration_operation
{
    public:
        iteration_operation() : auto_del(true){}
        virtual ~iteration_operation(){}

        virtual void operator()(size_t index) = 0;
        virtual void auto_delete(bool a){ auto_del = a; }
        virtual bool auto_delete() const { return auto_del; }

    private:
        bool auto_del;
};

template <class T>  class ptr_operation : public operation
{
    public:
        ptr_operation(T* object, void(T::*function)())
            : obj(object), func(function) {}
        virtual void operator()() {
            (*obj.*func)();
        }

    private:
        T* obj;
        void (T::*func)();
};

template <class T> class  ptr_iteration_operation : public iteration_operation
{
    public:
        ptr_iteration_operation(T* object, void(T::*function)(size_t))
            : obj(object), func(function) {}
        virtual void operator()(size_t index) {
            (*obj.*func)(index);
        }

    private:
        T* obj;
        void (T::*func)(size_t);
};


#ifdef XDISPATCH_HAS_BLOCKS

class block_operation : public operation {
    public:
        block_operation(dispatch_block_t b)
            : operation(), block(XDISPATCH_BLOCK_PERSIST(b)) {}
        block_operation(const block_operation& other)
            : operation(other), block(XDISPATCH_BLOCK_COPY(other.block)) {}
        ~block_operation() {
            XDISPATCH_BLOCK_DELETE(block);
        }

        void operator ()(){
            XDISPATCH_BLOCK_EXEC(block)();
        };

    private:
        dispatch_block_store block;
};

class block_iteration_operation : public iteration_operation {
    public:
        block_iteration_operation(dispatch_iteration_block_t b)
            : iteration_operation(), block(XDISPATCH_BLOCK_PERSIST(b)) {}
        block_iteration_operation(const block_iteration_operation& other)
            : iteration_operation(other), block(XDISPATCH_BLOCK_COPY(other.block)) {}
        ~block_iteration_operation() { XDISPATCH_BLOCK_DELETE(block); }

        void operator ()(size_t index){
            XDISPATCH_BLOCK_EXEC(block)(index);
        };

    private:
        dispatch_iteration_block_store block;
};
#endif


class XDISPATCH_EXPORT queue;

class XDISPATCH_EXPORT object {

    protected:
        object();

    public:
        virtual ~object();
        virtual void resume();
        virtual void suspend();
        virtual void target_queue(const queue&);
        virtual dispatch_object_t native() const = 0;

        bool operator ==(const object&);
        bool operator !=(const object&);
        bool operator ==(const dispatch_object_t&);
        bool operator !=(const dispatch_object_t&);
};

XDISPATCH_EXPORT bool operator ==(const dispatch_object_t&, const object&);
XDISPATCH_EXPORT bool operator !=(const dispatch_object_t&, const object&);

class queue;

typedef dispatch_time_t time;
static const time time_now = DISPATCH_TIME_NOW;
static const time time_forever = DISPATCH_TIME_FOREVER;
static const uint64_t nsec_per_sec = NSEC_PER_SEC;
static const uint64_t nsec_per_msec = NSEC_PER_MSEC;
static const uint64_t nsec_per_usec = NSEC_PER_USEC;
static const uint64_t usec_per_sec = USEC_PER_SEC;
enum queue_priority { HIGH =2, DEFAULT =1, LOW =0 };
XDISPATCH_EXPORT queue main_queue();
XDISPATCH_EXPORT queue global_queue(queue_priority p = DEFAULT);
XDISPATCH_EXPORT queue current_queue();
XDISPATCH_EXPORT time as_dispatch_time(struct tm*);
inline dispatch_time_t as_native_dispatch_time(const time& t) {
    return t;
}

XDISPATCH_EXPORT struct tm as_struct_tm(const time& t);
XDISPATCH_EXPORT time as_delayed_time(uint64_t delay, time base = time_now);
XDISPATCH_EXPORT void exec();

__XDISPATCH_END_NAMESPACE

#endif /* XDISPATCH_BASE_H_ */