src/message.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 "acedia_config.hpp"

#ifdef ACEDIA_WINDOWS
#pragma warning( disable : 4099 )

#endif

#include "message.hpp"
#include "actorref.hpp"
#include "referencecounted.hpp"

#include <sstream>

#include <iostream>
using std::cout;
using std::endl;

namespace acedia
{
    namespace details
    {
        class MessageData : public ReferenceCounted
        {

            friend class acedia::util::Singleton<acedia::details::MessageData>;

            MessageData() :
                    ReferenceCounted(10), length(0), arr(NULL),
                    sender(), receiver()
            {
            }

         public:

            boost::uint32_t length;

            Any *arr;

            ActorRef sender;
            ActorRef receiver;


            MessageData(boost::uint32_t len, const ActorRef &msgSender,
                        const ActorRef &msgReceiver) :
                    ReferenceCounted(1), length(len), arr(NULL),
                    sender(msgSender), receiver(msgReceiver)
            {
                if (len > 0) arr = new Any[len];
            }

            virtual ~MessageData()
            {
                if (arr) delete[] arr;
            }

        };

        ProxyFactory::~ProxyFactory() { }
    }
}

static acedia::util::Singleton<acedia::details::MessageData> m_dummyMessageData;

namespace acedia
{

    void Message::set(int N, const Any **values, const ActorRef &msgSender, const ActorRef &msgReceiver)
    {
        data = new details::MessageData(N, msgSender, msgReceiver);
        for (int i = 0; i < N; ++i)
        {
            data->arr[i] = *(values[i]);
        }
    }

    Message::Message() : data(m_dummyMessageData.instance())
    {
        data->ref();
    }

    Message::Message(details::MessageData *mdata) : data(mdata)
    {
        data->ref();
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver) :
            data(NULL)
    {
        set(0, NULL, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1)
     : data(NULL)
    {
        const Any *arr[] = { &v1 };
        set(1, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1, const Any &v2)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2 };
        set(2, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1, const Any &v2, const Any &v3)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2, &v3 };
        set(3, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1, const Any &v2, const Any &v3, const Any &v4)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2, &v3, &v4 };
        set(4, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2, &v3, &v4, &v5 };
        set(5, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5, const Any &v6)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2, &v3, &v4, &v5, &v6 };
        set(6, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5, const Any &v6, const Any &v7)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2, &v3, &v4, &v5, &v6, &v7 };
        set(7, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, const Any &v1, const Any &v2, const Any &v3, const Any &v4, const Any &v5, const Any &v6, const Any &v7, const Any &v8)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8 };
        set(8, arr, msgSender, msgReceiver);
    }

    Message::Message(const ActorRef &msgSender, const ActorRef &msgReceiver, 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)
     : data(NULL)
    {
        const Any *arr[] = { &v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8, &v9 };
        set(9, arr, msgSender, msgReceiver);
    }


    Message::Message(const Message &other) : AnyArray(), data(other.data)
    {
        data->ref();
    }

    Message::~Message()
    {
        if (!data->deref())
        {
            delete data;
        }
    }

    ActorRef &Message::sender() const
    {
        return data->sender;
    }

    ActorRef &Message::receiver() const
    {
        return data->receiver;
    }

    Message &Message::operator=(const Message &other)
    {
        if (!data->deref()) delete data;
        other.data->ref();
        data = other.data;
        return *this;
    }

    boost::uint32_t Message::length() const
    {
        return data->length;
    }

    const Any &Message::at(boost::uint32_t pos) const
    {
        if (pos >= length()) throw IndexOutOfBoundsException("acedia::Message out of bounds");
        return data->arr[pos];
    }

    bool Message::operator==(const Message &other) const
    {
        if (length() == other.length())
        {
            if (isEmpty()) return true;
            for (boost::uint32_t i = 0; i < length(); ++i)
            {
                if (at(i) != other.at(i)) return false;
            }
            return true;
        }
        return false;
    }

    String Message::serializeToString()
    {
        static String verificator("acedia::NetworkMessage");
        std::ostringstream ostr;
        boost::archive::text_oarchive oar(ostr);
        boost::uint32_t sndr = sender().realActorId();
        boost::uint32_t rcvr = receiver().realActorId();
        boost::uint32_t lngt = length();
        oar << verificator;
        oar << sndr;
        oar << rcvr;
        oar << lngt;
        for (boost::uint32_t i = 0; i < length(); ++i)
        {
            at(i).val->serialize(oar);
        }
        // done
        return ostr.str();
    }

    Message Message::deserializeFrom(const char* str, details::ProxyFactory* factory)
    {
        std::istringstream istr(str);
        boost::archive::text_iarchive iar(istr);
        String verification;
        boost::uint32_t rcver, snder, len;
        iar >> verification;
        if (verification != "acedia::NetworkMessage")
        {
            ACEDIA_THROW(NotDeserializableException, "Received string not deserializable (verification failed)");
        }
        iar >> snder;
        iar >> rcver;
        iar >> len;
        // sender is a remote actor
        ActorRef senderRef;
        if (snder != 0) senderRef = factory->get(snder);
        // receiver is a local actor
        ActorRef receiverRef;
        if (rcver != 0) receiverRef = details::getInstanceById(rcver);
        details::MessageData *mdata = new details::MessageData(len, senderRef, receiverRef);
        for (boost::uint32_t i = 0; i < len; ++i)
        {
            String className;
            iar >> className;

            MetaClass* mc = getMetaClass(className);
            if (!mc || mc == details::MetaClassImpl<void>::instance())
            {
                ACEDIA_THROW(NotDeserializableException, "Could not load meta class for requestet class");
            }
            mdata->arr[i].val = mc->deserialize(iar);
        }
        return Message(mdata);
    }

    String Message::toString(bool verbose) const
    {
        std::ostringstream ostr;
        ostr << "Message";
        if (verbose)
        {
            ostr << "[sender="
                 << util::AsString<ActorRef>::get(sender()).const_str()
                 << ",receiver="
                 << util::AsString<ActorRef>::get(receiver()).const_str()
                 << "]";
        }
        ostr << "(";
        for (::size_t i = 0; i < length(); ++i)
        {
            if (i > 0) ostr << ", ";
            ostr << at(i).toString(verbose).const_str();
        }
        ostr << ")";
        return ostr.str();
    }

    bool Message::isMessage() const { return true; }

} // namespace acedia

---