include/xdispatch/base.h

Go to the documentation of this file.

/*
* Copyright (c) 2011 MLBA. 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 set_auto_delete(bool a){ auto_del = a; }
    virtual bool auto_delete(){ 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 set_auto_delete(bool a){ auto_del = a; }
    virtual bool auto_delete(){ 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) : block(XDISPATCH_BLOCK_PERSIST(b)) {}
    block_operation(const block_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;
};
#endif

class XDISPATCH_EXPORT object {

public:
       virtual void resume() = 0;
       virtual void suspend() = 0;
       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;

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 dispatch_time_t as_dispatch_time(struct tm*);
XDISPATCH_EXPORT struct tm as_struct_tm(dispatch_time_t t);
XDISPATCH_EXPORT dispatch_time_t as_delayed_time(uint64_t delay, dispatch_time_t base = DISPATCH_TIME_NOW);
XDISPATCH_EXPORT void exec();

__XDISPATCH_END_NAMESPACE

#endif /* XDISPATCH_BASE_H_ */