MessageSubscriber.h

Go to the documentation of this file.

/*
 * i6engine
 * Copyright (2016) Daniel Bonrath, Michael Baer, All rights reserved.
 *
 * This file is part of i6engine; i6engine 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 2.1 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __I6ENGINE_CORE_MESSAGESUBSCRIBER_H__
#define __I6ENGINE_CORE_MESSAGESUBSCRIBER_H__

#include <set>
#include <vector>

#include "i6engine/core/messaging/Message.h"

#include "boost/function.hpp"
#include "boost/thread/mutex.hpp"

namespace i6e {
namespace core {

        class MessageTypeInfo;

        enum class IDStatus : uint16_t {
                NONE,           
                CREATED,        
                DELETED         
        };

        struct ReceivedMessage {
                Message::Ptr message;
                std::set<int64_t> waitingFor;

                ReceivedMessage(const Message::Ptr & msg) : message(msg), waitingFor() {
                }
        };
        typedef boost::shared_ptr<ReceivedMessage> ReceivedMessagePtr;

        typedef std::vector<ReceivedMessagePtr> MessageVector;

        class ISIXE_CORE_API MessageSubscriber {
        public:
                MessageSubscriber() : _objMessageVectorMutex(), _objMessageVectorA(), _objMessageVectorB(), _objActiveMessageVector(&_objMessageVectorA), _objInActiveMessageVector(&_objMessageVectorB), _ptrMessageMethod(), _newCreatedIDs(), _existingObjects(), _waitingMsgs(), _objMessageListMutex() {
                }

                virtual ~MessageSubscriber() {
                }

                void receiveMessage(const Message::Ptr & msg);

                virtual void processMessages();

                void notifyNewID(const int64_t id);

                void buffer(const ReceivedMessagePtr & msg);

                void reset();

                inline void addMethod(uint16_t msgType, const boost::function<void(const Message::Ptr &)> & ptrMessageMethod) {
                        _ptrMessageMethod[msgType] = ptrMessageMethod;
                }

                inline void removeMethod(uint16_t msgType) {
                        _ptrMessageMethod.erase(msgType);
                        boost::mutex::scoped_lock objScopeLock(_objMessageVectorMutex);
                        MessageVector result;
                        for (auto & rm : *_objActiveMessageVector) {
                                if (rm->message->getMessageType() != msgType) {
                                        result.push_back(rm);
                                }
                        }
                        _objActiveMessageVector->clear();
                        for (auto & rm : result) {
                                _objActiveMessageVector->push_back(rm);
                        }
                }

        protected:
                void swapMessageBuffer();

                bool updateBuffer();

                boost::mutex _objMessageVectorMutex;
                MessageVector _objMessageVectorA;
                MessageVector _objMessageVectorB;
                MessageVector * _objActiveMessageVector;
                MessageVector * _objInActiveMessageVector;

                std::map<uint16_t, boost::function<void(const Message::Ptr &)>> _ptrMessageMethod;

                virtual void deliverMessageInternal(const ReceivedMessagePtr & msg);

        private:

                std::vector<int64_t> _newCreatedIDs; // list of all IDs that got created since the last tick

                std::map<int64_t, IDStatus> _existingObjects; // map for all GameObjects and their status TODO: remove ids deleted long ago?

                std::map<int64_t, std::vector<ReceivedMessagePtr>> _waitingMsgs;

                mutable boost::mutex _objMessageListMutex;

                mutable boost::mutex _bufferLock;

                MessageSubscriber(const MessageSubscriber &) = delete;

                MessageSubscriber & operator=(const MessageSubscriber &) = delete;
        };

} /* namespace core */
} /* namespace i6e */

#endif /* __I6ENGINE_CORE_MESSAGESUBSCRIBER_H__ */