model-port-registry.cpp

Go to the documentation of this file.

/*
  ModelPortRegistry  -  creating and organising and accessing model ports

   Copyright (C)
     2010,            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 "include/logging.h"
#include "lib/sync-classlock.hpp"
#include "steam/mobject/builderfacade.hpp"
#include "steam/mobject/model-port.hpp"
#include "steam/fixture/model-port-registry.hpp"

namespace steam {
namespace fixture {
    
    namespace error = lumiera::error;
    
    using mobject::LUMIERA_ERROR_BUILDER_LIFECYCLE;
    using mobject::LUMIERA_ERROR_INVALID_MODEL_PORT;
    using mobject::LUMIERA_ERROR_UNCONNECTED_MODEL_PORT;
    
    
    using MPDescriptor = ModelPortRegistry::ModelPortDescriptor const&;
    using LockRegistry = lib::ClassLock<ModelPortRegistry>;
    
    
    lib::OptionalRef<ModelPortRegistry> ModelPortRegistry::theGlobalRegistry;
    
    
    
    void
    ModelPortRegistry::shutdown ()
    {
      INFO (builder, "disabling ModelPort registry....");
      LockRegistry global_lock;
      theGlobalRegistry.clear(); 
    }
    
    
    ModelPortRegistry*
    ModelPortRegistry::setActiveInstance (ModelPortRegistry& newRegistry)
    {
      LockRegistry global_lock;
      ModelPortRegistry *previous = theGlobalRegistry.isValid()?
                                      &( theGlobalRegistry()) : 0;
      INFO_IF (!previous, builder, "activating new ModelPort registry.");
      WARN_IF ( previous, builder, "switching ModelPort registry instance.");
      theGlobalRegistry.link_to (newRegistry);
      return previous;
    }
    
    
    ModelPortRegistry&
    ModelPortRegistry::globalInstance()
    {
      LockRegistry global_lock;
      if (theGlobalRegistry.isValid())
        return theGlobalRegistry();
      
      throw error::State ("global model port registry is not accessible"
                         , LUMIERA_ERROR_BUILDER_LIFECYCLE); 
    }
    
    
    
    bool
    ModelPortRegistry::contains (ID<Pipe> key)  const
    {
      return bool(key)
          && util::contains (transaction_, key); 
    }
    
    
    bool
    ModelPortRegistry::isRegistered (ID<Pipe> key)  const
    {
      return bool(key)
          && util::contains (currentReg_, key); 
    }
    
    
    MPDescriptor
    ModelPortRegistry::get (ID<Pipe> key)  const
    {
      if (!key)
        throw error::State ("This model port is disconnected or NIL"
                           , LUMIERA_ERROR_UNCONNECTED_MODEL_PORT);
      if (!isRegistered (key))
        throw error::Logic ("Model port was never registered, or got unregistered meanwhile."
                           ,LUMIERA_ERROR_INVALID_MODEL_PORT);
      
      MPTable::const_iterator pos = currentReg_.find (key);
      ASSERT (pos != currentReg_.end());
      ASSERT (pos->second.isValid());
      return pos->second;
    }
    
    
    MPDescriptor
    ModelPortRegistry::accessDescriptor (ID<Pipe> key)
    {
      LockRegistry global_lock;
      return theGlobalRegistry().get(key);
    }
    
    
    /* === Mutations === */
    
    MPDescriptor
    ModelPortRegistry::definePort (ID<Pipe> pipe, ID<Struct> element_exposing_this_port)
    {
      LockRegistry global_lock;
      if (contains (pipe))
        throw error::Logic ("attempt to register a model port with a pipe-ID, "
                            "which has already been used to register a "
                            "model port within this transaction (build process)."
                           , LUMIERA_ERROR_DUPLICATE_MODEL_PORT);
      return (transaction_[pipe] = ModelPortDescriptor(pipe, element_exposing_this_port));
    }
    
    
    void
    ModelPortRegistry::remove (PID key)
    {
      LockRegistry global_lock;
      transaction_.erase (key);
    }
    
    
    void
    ModelPortRegistry::clear()
    {
      LockRegistry global_lock;
      transaction_.clear();
    }
    
    
    void
    ModelPortRegistry::commit()
    {
      LockRegistry global_lock;
      MPTable newTransaction(transaction_);
      TRACE (builder, "committing new ModelPort list....");
      swap (currentReg_, transaction_);
      swap (transaction_, newTransaction);
    }
    
    
    void
    ModelPortRegistry::rollback()
    {
      LockRegistry global_lock;
      TRACE (builder, "discarding changes to ModelPort list (rollback)....");
      MPTable newTransaction(currentReg_);
      swap (transaction_, newTransaction);
    }
    
    
    
    LUMIERA_ERROR_DEFINE (DUPLICATE_MODEL_PORT, "Attempt to define a new model port with an pipe-ID already denoting an existing port");
    
}// namespace fixture


namespace mobject {
  
  LUMIERA_ERROR_DEFINE (INVALID_MODEL_PORT, "Referral to unknown model port");
  LUMIERA_ERROR_DEFINE (UNCONNECTED_MODEL_PORT, "Attempt to operate on an existing but unconnected model port");
  
  
  ModelPort::ModelPort (ID<asset::Pipe> refID)
    : id_(refID)
    {
      fixture::ModelPortRegistry::accessDescriptor (refID);
    }
  
  
  bool
  ModelPort::exists (ID<asset::Pipe> key)
  {
    return fixture::ModelPortRegistry::globalInstance().isRegistered (key);
  }
  
  
  ID<asset::Pipe>
  ModelPort::pipe()  const
  {
    ENSURE (this->id_ == fixture::ModelPortRegistry::accessDescriptor(this->id_).id());
    
    return fixture::ModelPortRegistry::accessDescriptor(this->id_).id();
  }
  
  
  ID<asset::Struct>
  ModelPort::holder()  const
  {
    return fixture::ModelPortRegistry::accessDescriptor(this->id_).holder();
  }
  
  
  StreamType::ID
  ModelPort::streamType() const
  {
    return this->id_.streamType();
  }
  
  
  
}} // namespace steam::mobject