Active Object 中的 C++例子

Active Object 中的 C++例子

下面是AcitveObject中的C++例子， 整理出來方面閱讀：

 

class MQ_Servant
{
public:
    void put_i(const Message &msg);
    Message get_i(void);

    bool empty_i() const;
    bool full_i() const;
private:
     ....
}

class MQ_Proxy
{
public:
    enum {MAX_SIZE = 100};

    MQ_Proxy(size_t size = MAX_SIZE):scheduler_(new MQ_Scheduler(size)), servant_(new MQ_Servant(size))
    {
    }

    void put(const Message &m)
    {
         Method_request * method_request = new Put(servant_, m);
        scheduler_->enqueue(method_request);
    }

    Message_Future get()
    {
         Message_Future result;

        Method_Request * method_request * new Get(servant_, result);
        scheduler_->enqueue(method_request);

        return result;
    }
protected:
    MQ_Servant * servant_;
    MQ_Scheduler * scheduler_;
}

 

class Method_Request
{
public:
    virtual bool guard() const = 0;
    virtual void call() = 0;
}

class Put: public Method_Request
{
public:
    Put (MQ_Servant* req, message arg): servant_(rep), arg_(arg)
    {}

    bool guard() const
    {
        return !servant_ -> full_i();
    }
    
    void call()
    {
        servant_ -> put_i(arg_);
    }

private:

    MQ_Servant * servant_;
    Message arg_;
}

 

class Get: public Method_Request
{
public:
    Get (MQ_Servant* rep, const Message_Futrue &f) : servant_(req), result_(f)
    {}

    bool guard() const
    {
        return !servant_ ->empty_i();
    }

    void call()
    {
        result_ = servant_ ->get_i();
    }

private:

    MQ_Servant * servant_;
    Message_Future result_;
}

 

class Activation_Queue
{
public:
    const int INFINITE = -1;

    typedef Activation_Queue_Iterator iterator;

    Activation_Queue(size_t high_water_mark);

    void enqueue(Method_request * method_request, long msec_timeout = INFINITE);

     void dequeue(Method_Request * method_request, long msec_timeout = INFINITE);

private:
     ...

}

 

class MQ_Scheduler
{
public:

    MQ_Scheduler(size_t high_water_mark);

    void enqueue (Method_Request* method_request)
    {
        act_queue_ -> enqueue (method_request);
    }

    virtual void dispatch();

protected:
    Activation_Queue * act_queue_;
    static void * svc_run(void * arg);
}

MQ_Scheduler (size_t high_water_mark) : act_queue_ (new Activation_Queue(high_water_mark))
{
    Thread_Manager::instance() -> spawn(svc_run, this);
}

void* MQ_Scheduler::svc_run(void* args)
{
    MQ_Scheduler * this_obj = reinterpret_cast<MQ_Scheduler*>(args);

    this_obj ->dispatch();
}

virtual void MQ_Scheduler::dispatch()
{
    for(;;)
    {
        Activation_Queue::iterator i;
    
        for(i = act_queue_ -> begin(); i != act_queue_ ->end(); i++)
        {
            Method_Request * mr = *i;

            if(mr->guard())
            {
                act-queue_ ->dequeue(mr);
                mr -> call();
                delete mr;
            }
        }
    }
}

class Message_Future
{
public:
    Message_Future (const Message_Future &f);

    Message_Future (const Message &m);

    void operator = (const Message_Futrue &f);

    operator Message();
}