include/xdispatch/source.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_SOURCE_H_
#define XDISPATCH_SOURCE_H_

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

#include <typeinfo>

__XDISPATCH_BEGIN_NAMESPACE

class source;

struct any {

       any() : stored(0) {}
       template<typename Type> any(const Type& val) : stored(new holder<Type>(val)) {}
       any(const any& other) : stored(other.stored ? other.stored->clone() : 0 ) {}
       ~any() { delete stored; }

       any & swap(any & v)
       {
              std::swap(stored, v.stored);
              return *this;
       }

       template<typename OtherType>
       any & operator=(const OtherType & v)
       {
              any(v).swap(*this);
              return *this;
       }

       any & operator=(any v)
       {
              v.swap(*this);
              return *this;
       }

       template<typename TargetType>
       TargetType cast() const {
              if(stored->type() == typeid(TargetType))
                     return static_cast< holder<TargetType>* >(stored)->value;
              else
                     throw std::bad_cast();
       }

private:

       struct place_holder {
              virtual place_holder * clone() const = 0;
              virtual const std::type_info & type() const = 0;
       };

       template <typename Type>
       struct holder : public place_holder {
              holder (const Type& val) : value(val) {}

              virtual place_holder * clone() const {
                     return new holder(value);
              }

              virtual const std::type_info & type() const {
                     return typeid(Type);
              }

              Type value;

       private:
              holder & operator=(const holder&);
       };

       place_holder* stored;
};

class XDISPATCH_EXPORT sourcetype {

protected:
       sourcetype();

       void ready(const any& = any());
       virtual dispatch_source_t native();

private:
       void set_cb(source*);
       friend class source;
       source* cb;
};

class XDISPATCH_EXPORT source : public object {

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

       void resume();
       void suspend();

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

       void handler(dispatch_block_t);
#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;

private:
       source(const source&);
       source& operator=(const source&);
       class pdata;
       pdata* d;

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

__XDISPATCH_END_NAMESPACE

#endif /* XDISPATCH_SOURCE_H_ */