threaduface.hh

Go to the documentation of this file.

#ifndef _DRAMA2_THREADUFACE_INC
#define _DRAMA2_THREADUFACE_INC
/*
 * History:
     07-Apr-2014 - TJF - Original version
     18-Jan-2018 - TJF - TUface constructor now takes a name for log entries associated
                         with the thread running the uface context.
 
 
 * The above ID is for Doxygen, this one has the format ACMM is looking for.
 * "@(#) $Id$"
 */
#include "drama/messagehandler.hh"
#include "drama/thread.hh"
#include <thread>
#include <queue>
#include <deque>
#include <map>
#include <chrono>
#include <future>
#include <condition_variable>
namespace drama { 
 
    namespace thread {
 
        void SignalDramaToExit(std::weak_ptr<Task> dramaTask, 
                               StatusType exitStatus=STATUS__OK);
        // TMessHandler and RunDramaExitNotifier are abstract only.
        class TUface : public TMessHandler, public RunDramaExitNotifier  {
 
        private:
            /*
             * Pointer to the DRAMA task we are part of.
             * The pointer is const - we never change it after the constructor.
             *  The task pointed to is NOT const - since we can operate on it.
             */
            std::weak_ptr<Task> _theTask;
            EntryInfo _entryInfo;      // UFACE entry details.
 
            /*
             * A set of points to UFACE which are used by the logger only
             * via RegisterThreadNoDramaCtx()
             */
            static std::set<TUface *> _loggerOnly;
 
        public:
 
            TUface(std::weak_ptr<Task> dramaTask,
                   const std::string &logThreadName="TUface::TUface");
            virtual ~TUface();
 
 
            virtual int RunDramaHasExited() override;
            virtual bool JoinThreads(std::chrono::steady_clock::time_point until) override;
 
        public:
 
            std::shared_ptr<Task>  GetTask() const override {
                return std::shared_ptr<Task>(_theTask);
            }
 
            void MessageUser(const std::string &text) const override;
 
            template<typename... Types>
            void MessageUser(const char *format, Types... args) {
                
                /*
                 * Our approach is to write the output to a string, via
                 * SafePrintf(), then output that in one operation.  Since
                 * std::ostream devices will then do the output in one operation.
                 */
                std::stringstream sstrm;
                drama::SafePrintf(sstrm, format, args...);
                MessageUser(sstrm.str());
 
 
            }
 
 
            void SetupWaitEvent(DitsTransIdType tid, drama::Path *pathObj) override;
 
 
            Task::mutexType & Lock() const override;
        
            Dits___CurActType GetMessageContext() const override;
            
            virtual const EntryInfo & GetEntry() const {
                return _entryInfo;
            }
 
            void ___SetLoggerOnlyUFACEItem() {
 
                /*
                 * We save the address in a set.
                 */
                if (! ___LoggerOnlyUFACEItem(this))
                    _loggerOnly.insert(this);
            }
            static bool ___LoggerOnlyUFACEItem(TUface *pnt);
 
        private:
            Dits___CurActType _ufaceCtxDetails;
 
            /*
             * A map which contains all the events we are waiting on.
             *  (one per subsidiary thread).
             */
            WaitEventMapType _waitEventMap;
 
 
            void MessageReceived();
            void ProcessSubsidiaryMessage();
            /*
             * Invoked by DRAMA when a UFACE message is received.
             */
            static void UfaceMessageHandler(StatusType *);
 
            /*
             * Invoke when the thread is ending (TUface destructor invoked
             * - will make any outstanding events into orphans.
             */
            void OrphanOutstandingEvents();
 
 
    protected:
            void GrabEntryInfo() {
                _entryInfo.SetFromDits();
            }
 
 
            void ClearWait(bool complete) override;
 
            /*
             * Return a pointer to the event details for the specified thread.
             */
             WaitEventDetails *FindWaitEventDetails(std::thread::id) 
                override;
 
 
            WaitEventDetails * WaitForTransactionStart() {
                std::thread::id  threadId(std::this_thread::get_id());
                auto mapItem = _waitEventMap.find(threadId);
                assert (mapItem != _waitEventMap.end());
                return (&(mapItem->second));
            }
                
            void WaitForTransactionFinish(
                const WaitEventData &details,
                TransEvtInfo * const eventInfo,
                sds::IdPtr * const arg) {
 
 
                *eventInfo = details.eventInfo;
                /*
                 * If the user wants the argument, return it.
                 */
                if (arg)
                {
                    *arg = details.arg;
                }
                // Should complain here (throw exception?) if queue not empty
                ClearWait(details.eventInfo.complete);
 
            }
 
 
        };
        
    } // namespace thread
} // namespace drama
 
#endif