acedia/actorref.hpp

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

#ifndef ACEDIA_ACTOR_REF_H
#define ACEDIA_ACTOR_REF_H

#include "any.hpp"
#include "message.hpp"
#include "abstractactor.hpp"

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

namespace acedia
{

    // forward declaration
    namespace details { class Mailman; }

    class ActorRef
    {

        friend class boost::serialization::access;
        friend struct details::MockActorPrivate;
        friend class details::Mailman;
        friend class AbstractActor;
        friend class ActorProxy;
        friend class Actor;
        friend void link(ActorRef,ActorRef);

        AbstractActor *actor;

        // true if this reference is a weak reference (do not ref() and deref())
        bool m_weak;

    public:

        ActorRef() throw();

        inline ActorRef(AbstractActor *myActor, bool isWeakReference = false) :
                actor(myActor), m_weak(isWeakReference)
        {
            assert(actor != NULL);
            if (!m_weak) actor->ref();
        }

        ActorRef(const ActorRef &other);

        ~ActorRef();

        inline bool operator==(const ActorRef &other) const throw()
        {
            return actor == other.actor;
        }

        inline bool operator!=(const ActorRef &other) const throw()
        {
            return actor != other.actor;
        }

        inline void send(const Message &msg)
        {
            actor->enqueue(msg);
        }

        void linkExited(boost::int32_t why, const ActorRef &who) throw();

        ActorRef &operator=(const ActorRef &other);

        // true if the referenced actor is valid actor; otherwise false
        bool isValid() const;

        boost::uint32_t actorId() const;

        boost::uint32_t realActorId() const;

        inline bool isFarRef() const { return actor->isFarRef(); }

        // needed to store an ActorRef in a std::map
        inline bool operator<(const ActorRef &other) const
        {
            return actor < other.actor;
        }

    };

    namespace details { ActorRef getInstanceById(boost::uint32_t id); }

} // namespace acedia

/*               NOTE: It's not possible to serialize ActorRef.               */
namespace acedia
{
    namespace util
    {
        template<>
        struct AsString<ActorRef>
        {
            inline static String get(const ActorRef& value)
            {
                String result;
                if (value.isValid())
                {
                    if (value.isFarRef())
                    {
                        result += "RemoteActor(id=";
                        result += AsString<boost::int32_t>::get(value.realActorId());
                        result += ")";
                    }
                    else
                    {
                        result += "LocalActor(id=";
                        result += AsString<boost::int32_t>::get(value.actorId());
                        result += ")";
                    }
                }
                else
                {
                    result = "InvalidActor";
                }
                return result;
            }
        };
    }
}

#endif // ACEDIA_ACTOR_REF_H

---