sess-manager-impl.cpp

Go to the documentation of this file.

/*
  SessManagerImpl  -  global session access and lifecycle
 
   Copyright (C)
     2008,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
 
#include "lib/error.hpp"
#include "steam/mobject/session.hpp"
#include "steam/mobject/session/sess-manager-impl.hpp"
#include "steam/mobject/session/lifecycle-advisor.hpp"
#include "steam/control/steam-dispatcher.hpp"
#include "steam/config-resolver.hpp"
#include "steam/asset/timeline.hpp"
#include "common/query/defs-manager.hpp"
#include "common/query.hpp"
 
#include <memory>
#include <exception>
 
 
 
 
namespace steam {
namespace mobject {
namespace session {
  
  LUMIERA_ERROR_DEFINE (CREATE_SESSION, "unable to create basic session");
  
  SessionImplAPI*
  SessManagerImpl::operator-> ()  noexcept
  {
    if (!pSess_)
      try
        { // create empty default configured session
          this->reset();
        }
      catch (...)
        {
          ERROR (progress, "Unrecoverable Failure while creating the empty default session. System halted.");
          std::terminate();
        }
    
    
    return pSess_.get();
  }
  
  
  
  
  
  
  
  namespace { // defining details of the Session Lifecycle
    
    using SessionPImpl = std::unique_ptr<SessionImplAPI>;
    
    class SessionLifecycleDetails
      : public LifecycleAdvisor
      {
        SessionPImpl & session_;
        bool shall_load_;         
        
        
        
        void
        createSessionFacilities()  override
          {
            INFO (session, "Initialising new Session....");
            SessionPImpl tmpS (new SessionImplAPI);
            session_.swap (tmpS);
          }
        
        
        void
        injectSessionContent()  override
          {
            if (shall_load_)
              {
                UNIMPLEMENTED ("loading session from persistent storage");
              }
            else
              { // inject some default session content
                REQUIRE (0 == session_->timelines.size(), "injecting default timeline, but session isn't pristine");
                
                // issue a default query to retrieve or create a Timeline and a default Sequence
                asset::PTimeline initialTimeline = session_->defaults (lumiera::Query<asset::Timeline> (""));
                
                // these got registered automatically
                ENSURE (1  == session_->timelines.size());
                ENSURE (initialTimeline == session_->timelines[0]);
              }
          }
        
        
        void
        getSessionReady()  override
          {
            INFO (session, "Session ready for use.");
          }
        
        
        void
        openSessionInterface()  override
          {
            control::SteamDispatcher::instance().activate();
          }
        
        
        void
        closeSessionInterface()  override
          {
            control::SteamDispatcher::instance().deactivate();
          }
        
        
        void
        disconnectRenderProcesses()  override
          {
            TODO ("halt rendering");   
            TODO ("possibly terminate builder"); 
          }
        
        
        void
        commandLogCheckpoint()  override
          {                            
            control::SteamDispatcher::instance().awaitDeactivation();
            INFO (command, " Session shutdown. Command processing stopped.");
          }
        
        
        void
        deconfigure()  override
          {
            session_->defaults.clear();
            ConfigResolver::instance().reset();    // forget any configuration rules
            AssetManager::instance().clear();
          }
        
        
        
        
      public:
        SessionLifecycleDetails(SessionPImpl& currentSessionAccessPoint)
          : session_(currentSessionAccessPoint)
          , shall_load_(false)
          { }
      };
    
  }//(End) details of Session Lifecycle
  
  
  
  SessManagerImpl::SessManagerImpl ()
    : pSess_{}
    , lifecycle_{new SessionLifecycleDetails(pSess_)}
  {
    Session::initFlag = true;  
  }
  
  
  SessManagerImpl::~SessManagerImpl ()
  {
    Session::initFlag = false;
  }
  
  
  
  bool
  SessManagerImpl::isUp()
  {
    Lock sync{this};
    return bool(pSess_);                          
  }
  
  void
  SessManagerImpl::clear()
  {
    Lock sync{this};
    pSess_->clear();
  }
  
  
  void
  SessManagerImpl::close()
  {
    Lock sync{this};
    if (isUp())
      lifecycle_->shutDown();
    pSess_.reset();
  }
  
  
  void
  SessManagerImpl::reset()
  {
    Lock sync{this};
    if (isUp())
      lifecycle_->shutDown();
    lifecycle_->pullUp();
  }
  
  void
  SessManagerImpl::load()
  {
    UNIMPLEMENTED ("load serialised session");
    Lock sync{this};
    if (isUp())
      lifecycle_->shutDown();
    lifecycle_->pullUp();
  }
  
  
  void
  SessManagerImpl::save (string snapshotID)
  {
    UNIMPLEMENTED ("save session (serialised)");
  }
  
  
  
}}} // namespace steam::mobject::session