src/invoker.cpp

/*                                                                            *\
**                          Copyright (C) 2009-2010                           **
**       Dominik Charousset < Dominik.Charousset (at) haw-hamburg.de >        **
**                                                                            **
**            MMM       MMMMMM   MMMMMMMMM MMMMMMM   MMM       MMM            **
**           MMMMM     MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM      MMMMM           **
**          MMM MMM   MMM        MMMM      MMM   MMM MMM     MMM MMM          **
**         MMM   MMM  MMM        MMMMMMMMM MMM   MMM MMM    MMM   MMM         **
**        MMMMMMMMMMM MMMM   MMM MMMM      MMM   MMM MMM   MMMMMMMMMMM        **
**       MMM       MMM MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM  MMM       MMM       **
**      MMM         MMM MMMMMM   MMMMMMMMM MMMMMMM   MMM MMM         MMM      **
**                                                                            **
**                                                                            **
** This file is part of the acedia library.                                   **
**                                                                            **
** This library is free software: you can redistribute it and/or modify       **
** it under the terms of the GNU Lesser General Public License as published   **
** by the Free Software Foundation, either version 3 of the License, or       **
** (at your option) any later version.                                        **
**                                                                            **
** This library is distributed in the hope that it will be useful,            **
** but WITHOUT ANY WARRANTY; without even the implied warranty of             **
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the               **
** GNU Lesser General Public License for more details.                        **
**                                                                            **
** You should have received a copy of the GNU Lesser General Public License   **
** along with acedia. If not, see <http://www.gnu.org/licenses/>.             **
\*                                                                            */

#define ACEDIA_REDUCED_ANNOUNCE

#include "invoker.hpp"
#include "actor.hpp"

namespace acedia
{
    struct DefaultExitProcessor : public details::AnyArrayProcessor
    {
        virtual bool operator()(const AnyArray &arr)
        {
            if (arr.match<Exit>())
            {
                const Exit &e = arr.uncheckedValueAt<Exit>(0);
                if (e.reason() != 0)
                    throw ActorKilledException(exit_reasons::LINK_EXITED);
            }
            return false;
        }

        virtual details::ContinuationInvoker *matchingInvoker(const AnyArray &arr)
        {
            if (arr.match<Exit>())
            {
                const Exit &e = arr.uncheckedValueAt<Exit>(0);
                if (e.reason() != 0)
                    return new details::ContinuationInvoker(this, &arr);
            }
            return NULL;
        }
    };
}

static acedia::DefaultExitProcessor m_d_e_p;

namespace acedia
{
    typedef std::list<details::AnyArrayProcessor*>::const_iterator iter;

    Invoker::Invoker() { }

    Invoker::Invoker(details::AnyArrayProcessor *proc)
    {
        m_processors.push_back(proc);
    }

    Invoker::~Invoker()
    {
        details::AnyArrayProcessor *p;
        // pop other processors
        while (!m_processors.empty())
        {
            p = m_processors.front();
            delete p;
            m_processors.pop_front();
        }
    }

    void Invoker::pop_back()
    {
        if (!m_processors.empty())
        {
            details::AnyArrayProcessor *aap = m_processors.back();
            m_processors.pop_back();
            delete aap;
        }
    }

    Invoker &Invoker::add(details::AnyArrayProcessor* proc)
    {
        m_processors.push_back(proc);
        return *this;
    }

    Invoker &Invoker::prepend(details::AnyArrayProcessor* proc)
    {
        m_processors.push_front(proc);
        return *this;
    }

    void Invoker::pop_front()
    {
        if (!m_processors.empty())
        {
            details::AnyArrayProcessor* aap = m_processors.front();
            m_processors.pop_front();
            delete aap;
        }
    }

    bool Invoker::operator()(const Message &msg, bool trapExit)
    {
        m_lcm = msg;
        // check for Exit messages
        if (!trapExit) { (void) m_d_e_p(m_lcm); }
        for (iter i = m_processors.begin(); i != m_processors.end(); ++i)
        {
            if ((*(*i))(m_lcm)) return true;
        }
        return false;
    }

    details::ContinuationInvoker *Invoker::matchingInvokerTo(Message msg, bool trapExit)
    {
        m_lcm = msg;
        details::ContinuationInvoker *result = NULL;
        // check for Exit messages
        if (!trapExit)
        {
            result = m_d_e_p.matchingInvoker(m_lcm);
            if (result) return result;
        }
        for (iter i = m_processors.begin(); i != m_processors.end(); ++i)
        {
            result = (*i)->matchingInvoker(m_lcm);
            if (result) return result;
        }
        return NULL;
    }

} // namespace acedia

---