src/mockactor.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/>.             **
\*                                                                            */

#include "mockactor.hpp"

#include <boost/thread.hpp>

#include "actor.hpp"

namespace acedia
{
    namespace details
    {
        struct MockActorPrivate : public AbstractActor
        {
            typedef boost::unique_lock<boost::mutex> ScopedLock;

            typedef std::list<Message> Mailbox;
            typedef Mailbox::iterator MailboxIterator;

            typedef std::list<ActorRef> LinkList;
            typedef LinkList::iterator LinkListIterator;

            Message m_lrm;

            Mailbox m_mailbox;
            boost::mutex m_mailboxMutex;
            boost::condition_variable m_mailboxCondition;

            LinkList m_links;
            boost::mutex m_linksMutex;

            void doExit(boost::int32_t exitReason)
            {
                ScopedLock lock(m_linksMutex);
                m_exitReason = exitReason;
                Any exitTuple = Exit(exitReason);
                for (LinkListIterator i = m_links.begin(); i != m_links.end(); ++i)
                {
                    (*i).send(Message(self(), *i, exitTuple));
                }
                m_links.clear();
            }

            virtual void enqueue(const Message &msg)
            {
                boost::mutex::scoped_lock lock(m_mailboxMutex);
                m_mailbox.push_back(msg);
                m_mailboxCondition.notify_all();
            }

            bool tryDequeue(Message &msg, bool withTimeout = false, boost::uint16_t msTimeout = 0)
            {
                ScopedLock lock(m_mailboxMutex);
                if (!withTimeout)
                {
                    if (!m_mailbox.empty())
                    {
                        msg = m_mailbox.front();
                        m_mailbox.pop_front();
                        return true;
                    }
                }
                else
                {
                    boost::system_time timeout;
                    if (withTimeout)
                    {
                        timeout = boost::get_system_time();
                        timeout += boost::posix_time::milliseconds(msTimeout);
                    }
                    while (m_mailbox.empty())
                    {
                        if (!m_mailboxCondition.timed_wait(lock, timeout))
                        {
                            return false;
                        }
                    }
                    msg = m_mailbox.front();
                    m_mailbox.pop_front();
                    return true;
                }
                return false;
            }

            Message dequeue()
            {
                ScopedLock lock(m_mailboxMutex);
                while (m_mailbox.empty())
                {
                    m_mailboxCondition.wait(lock);
                }
                Message result = m_mailbox.front();
                m_mailbox.pop_front();
                return result;
            }

            bool invoke(Invoker &inv, bool withTimeout = false, boost::uint16_t msTimeout = 0)
            {
                boost::system_time timeout;
                if (withTimeout)
                {
                    timeout = boost::get_system_time();
                    timeout += boost::posix_time::milliseconds(msTimeout);
                }
                ScopedLock lock(m_mailboxMutex);
                while (m_mailbox.empty())
                {
                    m_mailboxCondition.wait(lock);
                }
                MailboxIterator i = m_mailbox.begin();
                for (;;)
                {
                    if (inv(*i, true))
                    {
                        // success
                        m_mailbox.erase(i);
                        return true;
                    }
                    else
                    {
                        // try if there is a next element in the mailbox
                        // and wait if not
                        MailboxIterator next = i;
                        ++next;
                        while (next == m_mailbox.end())
                        {
                            if (withTimeout)
                            {
                                if (!m_mailboxCondition.timed_wait(lock, timeout))
                                {
                                    return false;
                                }
                            }
                            else m_mailboxCondition.wait(lock);
                            next = i;
                            ++next;
                        }
                    }
                }
            }

            bool tryInvoke(Invoker &inv)
            {
                ScopedLock lock(m_mailboxMutex);
                for (MailboxIterator i = m_mailbox.begin(); i != m_mailbox.end(); ++i)
                {
                    if (inv(*i, true))
                    {
                        m_mailbox.erase(i);
                        return true;
                    }
                }
                return false;
            }

            void linkTo(const ActorRef& who)
            {
                if (who == self()) return;
                ScopedLock lock(m_linksMutex);
                ActorRef s = self();
                if (m_exitReason != exit_reasons::NOT_EXITED)
                {
                    ActorRef receiver = who;
                    send(receiver, Exit(m_exitReason));
                }
                else if (who.actor->backlinkTo(s))
                {
                    m_links.push_back(who);
                }
            }

            // add who to the link-list and return true
            bool backlinkTo(ActorRef& who)
            {
                if (who == self()) return false;
                else
                {
                    ScopedLock lock(m_linksMutex);
                    if (m_exitReason != exit_reasons::NOT_EXITED)
                    {
                        send(who, Exit(m_exitReason));
                    }
                    else m_links.push_back(who);
                }
                return true;
            }
        };
    }

    MockActor::MockActor() : d(new details::MockActorPrivate)
    {
        m_self = ActorRef(d);
    }

    MockActor::~MockActor()
    {
        d->doExit(m_exitReason);
    }

    void MockActor::setExitReason(boost::int32_t reason)
    {
        m_exitReason = reason;
    }

    void MockActor::receiveAndInvoke(Invoker &imp)
    {
        (void) d->invoke(imp);
    }

    bool MockActor::tryReceiveAndInvoke(Invoker &imp)
    {
        return d->tryInvoke(imp);
    }

    bool MockActor::receiveAndInvokeWithin(Invoker &imp, boost::uint16_t msTimeout)
    {
        return d->invoke(imp, true, msTimeout);
    }

    Message MockActor::receive()
    {
        return d->dequeue();
    }

    bool MockActor::tryReceive(Message &storage)
    {
        return d->tryDequeue(storage);
    }

    bool MockActor::receiveWithin(Message &storage, boost::uint16_t msTimeout)
    {
        return d->tryDequeue(storage, true, msTimeout);
    }

    void MockActor::send(ActorRef& receiver, const Any& v1)
    {
        d->send(receiver,v1);
    }

    void MockActor::send(ActorRef& receiver, const Any& v1, const Any& v2)
    {
        d->send(receiver,v1,v2);
    }

    void MockActor::send(ActorRef& receiver, const Any& v1, const Any& v2,
              const Any& v3)
    {
        d->send(receiver,v1,v2,v3);
    }

    void MockActor::send(ActorRef& receiver,
              const Any& v1, const Any& v2, const Any& v3, const Any& v4)
    {
        d->send(receiver,v1,v2,v3,v4);
    }

    void MockActor::send(ActorRef& receiver,
              const Any& v1, const Any& v2, const Any& v3, const Any& v4,
              const Any& v5)
    {
        d->send(receiver,v1,v2,v3,v4,v5);
    }

    void MockActor::send(ActorRef& receiver,
              const Any& v1, const Any& v2, const Any& v3, const Any& v4,
              const Any& v5, const Any& v6)
    {
        d->send(receiver,v1,v2,v3,v4,v5,v6);
    }

    void MockActor::send(ActorRef& receiver,
              const Any& v1, const Any& v2, const Any& v3, const Any& v4,
              const Any& v5, const Any& v6, const Any& v7)
    {
        d->send(receiver,v1,v2,v3,v4,v5,v6,v7);
    }

    void MockActor::send(ActorRef& receiver,
              const Any& v1, const Any& v2, const Any& v3, const Any& v4,
              const Any& v5, const Any& v6, const Any& v7, const Any& v8)
    {
        d->send(receiver,v1,v2,v3,v4,v5,v6,v7,v8);
    }

    void MockActor::send(ActorRef& receiver,
              const Any& v1, const Any& v2, const Any& v3, const Any& v4,
              const Any& v5, const Any& v6, const Any& v7, const Any& v8,
              const Any& v9)
    {
        d->send(receiver,v1,v2,v3,v4,v5,v6,v7,v8,v9);
    }

}

---