acedia/acedia.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_H
#define ACEDIA_H

#include "message.hpp"
#include "actorref.hpp"
#include "rulebuilder.hpp"

namespace acedia {

    // forward declaration
    namespace details { class AnyArrayProcessor; }

    struct MatchAllRuleBuilder
    {
        details::AnyArrayProcessor* operator>>(void (*voidFunction)());
        details::AnyArrayProcessor* operator>>(const boost::function0<void> &f);
    };

    class Actor;

    void waitForAllActorsDone();

    inline MatchAllRuleBuilder others() throw() { return MatchAllRuleBuilder(); }

    template<typename T1>
    inline SingleRuleBuilder<T1> on()
    {
        return SingleRuleBuilder<T1>(new details::PatternChecker<1,T1>);
    }

    template<typename T1, typename T2>
    inline RuleBuilder<2,0,T1,T2> on()
    {
        return RuleBuilder<2,0,T1,T2>(new details::PatternChecker<2,T1,T2>());
    }

    template<typename T1, typename T2, typename T3>
    inline RuleBuilder<3,0,T1,T2,T3> on()
    {
        return RuleBuilder<3,0,T1,T2,T3>(new details::PatternChecker<3,T1,T2,T3>());
    }

    template<typename T1, typename T2, typename T3, typename T4>
    inline RuleBuilder<4,0,T1,T2,T3,T4> on()
    {
        return RuleBuilder<4,0,T1,T2,T3,T4>(new details::PatternChecker<4,T1,T2,T3,T4>());
    }

    template<typename T1, typename T2, typename T3, typename T4, typename T5>
    inline RuleBuilder<5,0,T1,T2,T3,T4,T5> on()
    {
        return RuleBuilder<5,0,T1,T2,T3,T4,T5>(new details::PatternChecker<5,T1,T2,T3,T4,T5>());
    }

    void discard();

    namespace details { ActorRef doSpawn(Actor *actor); }

    void link(ActorRef actor1, ActorRef actor2);

    template<class A>
    inline ActorRef spawn()
    {
        return details::doSpawn(new A());
    }

    template<class A, typename T1>
    inline ActorRef spawn(const T1 &v1)
    {
        return details::doSpawn(new A(v1));
    }

    template<class A, typename T1, typename T2>
    inline ActorRef spawn(const T1 &v1, const T2 &v2)
    {
        return details::doSpawn(new A(v1,v2));
    }

    template<class A, typename T1, typename T2, typename T3>
    inline ActorRef spawn(const T1 &v1, const T2 &v2, const T3 &v3)
    {
        return details::doSpawn(new A(v1,v2,v3));
    }

    template<class A, typename T1, typename T2, typename T3, typename T4>
    inline ActorRef spawn(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
    {
        return details::doSpawn(new A(v1,v2,v3,v4));
    }

    bool registerName(const String &name, const ActorRef &actor);

    void unregisterName(const String &name);

    ActorRef whereisName(const String &name);

    StringList registeredNames();

    /**************************************************************************
     *                                guards                                  *
     **************************************************************************/

    template<typename T>
    GuardFunctor<T> *isEq(const T &x)
    {
        struct FuncImpl : public GuardFunctor<T>
        {
            T value;
            FuncImpl(const T &v) : value(v) { }
            virtual bool operator()(const T &what) { return what == value; }
        };
        return new FuncImpl(x);
    }

    template<typename T>
    GuardFunctor<T> *isNe(const T &x)
    {
        struct FuncImpl : public GuardFunctor<T>
        {
            T value;
            FuncImpl(const T &v) : value(v) { }
            virtual bool operator()(const T &what) { return what != value; }
        };
        return new FuncImpl(x);
    }

    template<typename T>
    GuardFunctor<T> *isGt(const T &x)
    {
        struct FuncImpl : public GuardFunctor<T>
        {
            T value;
            FuncImpl(const T &v) : value(v) { }
            virtual bool operator()(const T &what) { return what > value; }
        };
        return new FuncImpl(x);
    }

    template<typename T>
    GuardFunctor<T> *isLt(const T &x)
    {
        struct FuncImpl : public GuardFunctor<T>
        {
            T value;
            FuncImpl(const T &v) : value(v) { }
            virtual bool operator()(const T &what) { return what < value; }
        };
        return new FuncImpl(x);
    }

    void shutdown();

    namespace details { void enqueueToScheduler(Actor *a); }

    void setAppInfo(const char *appName,
                    boost::uint32_t majorVersion,
                    boost::uint32_t minorVersion,
                    boost::uint32_t minCompatibleMajorVersion,
                    boost::uint32_t minCompatibleMinorVersion,
                    bool allowNewerMinorVersion = false,
                    bool allowNewerMajorVersion = false);

    namespace details
    {
        // appIdentifier = "{appName} (Version {major}.{minor})
        const String &appIdentifier();
        const String &appName();
        boost::uint32_t appMajorVersion();
        boost::uint32_t appMinorVersion();
        // return true if the appName corresponds to the set application name
        // and {major.minor} >= {minCompatibleMajor.minCompatibleMinor}
        bool isCompatible(const String &appName,
                          boost::uint32_t major,
                          boost::uint32_t minor);
        ActorRef getInstanceById(boost::uint32_t id);
    }

} // namespace acedia

#endif // ACEDIA_H

---