/**************************************************************************** Copyright (c) 2009, Radon Labs GmbH Copyright (c) 2011-2013,WebJet Business Division,CYOU http://www.genesis-3d.com.cn Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ****************************************************************************/ #include "stdneb.h" #include "messaging/handlerthreadbase.h" #include "messaging/batchmessage.h" namespace Messaging { __ImplementClass(Messaging::HandlerThreadBase, 'HTBS', Threading::Thread); using namespace Util; using namespace Threading; //------------------------------------------------------------------------------ /** */ HandlerThreadBase::HandlerThreadBase() { // empty } //------------------------------------------------------------------------------ /** Attach a message handler to the port. This method may be called from any thread. */ void HandlerThreadBase::AttachHandler(const GPtr& h) { n_assert(h.isvalid()); this->handlersCritSect.Enter(); n_assert(InvalidIndex == this->handlers.FindIndex(h)); this->handlers.Append(h); this->handlersCritSect.Leave(); } //------------------------------------------------------------------------------ /** Remove a message handler. This method may be called form any thread. */ void HandlerThreadBase::RemoveHandler(const GPtr& h) { n_assert(h.isvalid()); this->handlersCritSect.Enter(); IndexT index = this->handlers.FindIndex(h); this->handlers.EraseIndex(index); this->handlersCritSect.Leave(); } //------------------------------------------------------------------------------ /** This clears all attached message handlers. */ void HandlerThreadBase::ClearHandlers() { this->handlersCritSect.Enter(); this->handlers.Clear(); this->handlersCritSect.Leave(); } //------------------------------------------------------------------------------ /** Wait on the handlers-opened event (will be signalled by the ThreadOpenHandlers method. */ void HandlerThreadBase::WaitForHandlersOpened() { n_assert(this->IsRunning()); this->handlersOpenedEvent.Wait(); } //------------------------------------------------------------------------------ /** This adds a new message to the thread's message queue. In the base class this message is empty and must be implemented in a subclass. */ void HandlerThreadBase::AddMessage(const GPtr& msg) { // empty, override in subclass! } //------------------------------------------------------------------------------ /** This removes a message from the thread's message queue, regardless of its state. Override this method in a subclass. */ void HandlerThreadBase::CancelMessage(const GPtr& msg) { // empty, override in subclass! } //------------------------------------------------------------------------------ /** This waits until the message given as argument has been handled. In order for this message to work, the ThreadSignalMessageHandled() must be called from within the handler thread context. Note that subclasses may override this method if they need to. */ void HandlerThreadBase::WaitForMessage(const GPtr& msg) { while (!msg->Handled()) { this->msgHandledEvent.Wait(); } } //------------------------------------------------------------------------------ /** Open attached message handlers. This method must be called at the start of the handler thread. */ void HandlerThreadBase::ThreadOpenHandlers() { this->handlersCritSect.Enter(); Array >::Iterator iter; for (iter = this->handlers.Begin(); iter < this->handlers.End(); iter++) { (*iter)->Open(); } this->handlersCritSect.Leave(); this->handlersOpenedEvent.Signal(); } //------------------------------------------------------------------------------ /** Close attached message handlers. This method must be called right before the handler thread shuts down. */ void HandlerThreadBase::ThreadCloseHandlers() { this->handlersCritSect.Enter(); Array >::Iterator iter; for (iter = this->handlers.Begin(); iter < this->handlers.End(); iter++) { (*iter)->Close(); } this->handlersCritSect.Leave(); } //------------------------------------------------------------------------------ /** Do per-frame update of attached handlers. This will open handlers which have been added late, and call the DoWork() method on handlers from within the thread context. */ void HandlerThreadBase::ThreadUpdateHandlers() { this->handlersCritSect.Enter(); Array >::Iterator iter; for (iter = this->handlers.Begin(); iter < this->handlers.End(); iter++) { // make sure the handler is open, it may happen that handlers // are added as the result of a message, and such a handler // may not have been opened yet if (!(*iter)->IsOpen()) { (*iter)->Open(); } (*iter)->DoWork(); } this->handlersCritSect.Leave(); } //------------------------------------------------------------------------------ /** This checks every message in the deferred message array whether it has been handled yet, if yes, the message's actual handled flag will be set, and the message will be removed from the deferred handled array. If at least one message has been handled, the method will return true, if no message has been handled, the method returns false. If message have been handled, don't forget to call ThreadSignalMessageHandled() later! */ bool HandlerThreadBase::ThreadUpdateDeferredMessages() { bool msgHandled = false; IndexT deferredIndex; for (deferredIndex = this->deferredMessages.Size() - 1; deferredIndex != InvalidIndex; deferredIndex--) { GPtr msg = this->deferredMessages[deferredIndex]; if (msg->DeferredHandled()) { this->deferredMessages.EraseIndex(deferredIndex); msg->SetHandled(true); msgHandled = true; } } return msgHandled; } //------------------------------------------------------------------------------ /** This clears any leftover deferred messages. Call right before shutdown of the handler thread. */ void HandlerThreadBase::ThreadDiscardDeferredMessages() { this->deferredMessages.Clear(); } //------------------------------------------------------------------------------ /** Handle all message in the provided message array. Supports batched and deferred messages. Calls ThreadHandleSingleMessage(). If at least one message has been handled, the method returns true. */ bool HandlerThreadBase::ThreadHandleMessages(const Array >& msgArray) { this->handlersCritSect.Enter(); bool msgHandled = false; IndexT msgIdx; for (msgIdx = 0; msgIdx < msgArray.Size(); ++msgIdx) { const GPtr& msg = msgArray[msgIdx]; // special case: batch message? if (msg->CheckId(BatchMessage::Id)) { // process batched messages const Array >& msgBatch = msg.cast()->GetMessages(); IndexT msgBatchIndex; for (msgBatchIndex = 0; msgBatchIndex < msgBatch.Size(); msgBatchIndex++) { msgHandled |= this->ThreadHandleSingleMessage(msgBatch[msgBatchIndex]); } msg->SetHandled(true); msgHandled = true; } else { // a normal message msgHandled |= this->ThreadHandleSingleMessage(msg); } } this->handlersCritSect.Leave(); return msgHandled; } //------------------------------------------------------------------------------ /** Handle a single message, called by ThreadHandleMessages(). Return true if message has been handled. This method MUST be called from ThreadHandleMessages(), since this method will not explicitely take the handlers array critical section. */ bool HandlerThreadBase::ThreadHandleSingleMessage(const GPtr& msg) { bool msgHandled = false; // let each handler look at the message IndexT i; for (i = 0; i < this->handlers.Size(); i++) { const GPtr& curHandler = this->handlers[i]; // open handler on demand (a handler may have // been added as the result of a message call, // so let's make sure it will be able to handle // message as soon as possible if (!curHandler->IsOpen()) { curHandler->Open(); } // let handler handle the current message if (curHandler->HandleMessage(msg)) { // message has been accepted by this handler if (msg->IsDeferred()) { // message has been defered by the handler // and will be handled at some later time, // put the message into the deferred queue // and handle at a later time this->deferredMessages.Append(msg); } else { // message has been handled normally msg->SetHandled(true); msgHandled = true; } // break after the first handler accepts the message break; } } return msgHandled; } //------------------------------------------------------------------------------ /** Signal the message-handled flag. Call this method once per handler-loop if either ThreadUpdateDeferredMessages or ThreadHandleMessages returns true! */ void HandlerThreadBase::ThreadSignalMessageHandled() { this->msgHandledEvent.Signal(); } } // namespace Messaging