Async.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef COIL_ASYNC_H
#define COIL_ASYNC_H

#include <coil/Task.h>
#include <coil/Guard.h>
#include <iostream>

namespace coil
{
  class Async
    : public coil::Task
  {
  public:
    Async() {}

    virtual ~Async(){}

    virtual void invoke() = 0;

    virtual bool finished() = 0;
  };
  
  template <typename Object, typename Func>
  class Async_t
    : public Async
  {
  public:

    Async_t(Object* obj, Func func, bool auto_delete = false)
      : m_obj(obj), m_func(func), m_finished(false), m_autodelete(auto_delete)
    {
    }

    virtual ~Async_t()
    {
    }
    
    virtual int svc()
    {
      m_func(m_obj);
      {
        Guard<Mutex> guard(m_mutex);
        m_finished = true;
      }
      
      return 0;
    }

    virtual void finalize()
    {
      Task::finalize();
      if (m_autodelete) delete this;
    }

    virtual void invoke()
    {
      activate();
    }

    virtual bool finished()
    {
      Guard<Mutex> guard(m_mutex);
      return m_finished;
    }
  private:
    Object* m_obj;
    Func m_func;
    bool m_finished;
    const bool m_autodelete;
    Mutex m_mutex;
  };
  
  template <typename Object, typename Func>
  class Async_ref_t
    : public Async
  {
  public:

    Async_ref_t(Object* obj, Func& func, bool auto_delete = false)
      : m_obj(obj), m_func(func), m_finished(false), m_autodelete(auto_delete)
    {
    }

    virtual ~Async_ref_t()
    {
    }
    
    virtual int svc()
    {
      m_func(m_obj);
      m_finished = true;
      return 0;
    }

    virtual void invoke()
    {
      activate();
    }

    virtual bool finished()
    {
      return m_finished;
    }

    virtual void finalize()
    {
      Task::finalize();
      if (m_autodelete) delete this;
    }
  private:
    Object* m_obj;
    Func& m_func;
    bool m_finished;
    bool m_autodelete;
    
  };
  
  template <typename Object, typename Func>
  inline Async_t<Object, Func>*
  AsyncInvoker(Object* obj, Func func, bool auto_delete = false)
  {
    return new Async_t<Object, Func>(obj, func, auto_delete);
  }

  template <typename Object, typename Func>
  inline Async_ref_t<Object, Func>*
  AsyncInvoker(Object* obj, Func* func, bool auto_delete = false)
  {
    return new Async_ref_t<Object, Func>(obj, *func, auto_delete);
  }


};

#endif // COIL_ASYNC_H