locatingpin.cpp

Go to the documentation of this file.

/*
  LocatingPin  -  Chaining and constraining the Placement of a Media Object

   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 "steam/mobject/mobject.hpp"
#include "steam/mobject/placement.hpp"
#include "steam/mobject/session/locatingpin.hpp"
#include "steam/mobject/session/fixedlocation.hpp"
#include "steam/mobject/session/relativelocation.hpp"

using std::unique_ptr;

namespace steam {
namespace mobject {
namespace session {
  
  inline LocatingPin*
  cloneChain (const unique_ptr<LocatingPin>& chain)
  {
    if (!chain) 
      return 0;
    else        
      return chain->clone(); 
  }
  
  
  LocatingPin::LocatingPin (const LocatingPin& other)
    : next_(cloneChain (other.next_))
  { }
  
  
  LocatingPin& 
  LocatingPin::operator= (const LocatingPin& other)
  {
    if (this != &other) 
      this->next_.reset (cloneChain (other.next_));
    return *this;
  }
  
  
  LocatingPin* 
  LocatingPin::clone ()  const
  {
    return new LocatingPin(*this);
  }
  
  
  
  LocatingPin&
  LocatingPin::addChain (LocatingPin* newLp)  
  {
    REQUIRE (newLp);
    REQUIRE (!newLp->next_, "can insert only single LocatingPins");
    
    if (next_ && newLp->getPrioLevel() > next_->getPrioLevel())
      return next_->addChain (newLp);
    else
      {
        unique_ptr<LocatingPin> tmp_next (newLp);
        tmp_next->next_.swap(next_);
        next_.swap(tmp_next);
        return *newLp;
      }
  }
  
  
  const LocatingPin::SolutionData
  LocatingPin::resolve ()  const
  {
    LocatingSolution solution;
    resolve (solution);
    return SolutionData (solution.getTime(), solution.getPipe());
  }
  
  bool 
  LocatingPin::isOverdetermined () const
  {
    LocatingSolution solution;
    resolve (solution);
    return solution.is_impossible(); 
  }
  
  
  
  void 
  LocatingPin::resolve (LocatingSolution& solution)  const
  {
    if (!solution.still_to_solve()) 
      return;
    this->intersect (solution);
    if (next_ && solution.still_to_solve())
      next_->resolve(solution);
  }
  
  
  void 
  LocatingPin::intersect (LocatingSolution& solution)  const
  {
    REQUIRE (solution.still_to_solve());
    // base class Implementation is NOP...
  }
  
  
  LocatingPin::Time 
  LocatingPin::LocatingSolution::getTime()
  {
    return minTime;   
  }
  
  LocatingPin::Pipe
  LocatingPin::LocatingSolution::getPipe()
  {
    TODO ("implement Placement LocatingSolution");
    return asset::Pipe::query ("pipe(master)");  // yet another idiotic dummy
  }
  
  
  bool 
  LocatingPin::LocatingSolution::is_definite()  
  {
    return (minTime == maxTime && minTrack == maxTrack);
  }
  
  bool 
  LocatingPin::LocatingSolution::is_impossible()
  {
    if (minTime > maxTime)  impo = true;
    TODO ("track???");
    return impo;
  }
  
  bool
  LocatingPin::LocatingSolution::still_to_solve () 
  { 
    return not (is_definite() or is_impossible()); 
  }
  
  
  
  
  
  
  
  
  /* === Factory functions for adding LocatingPins === */
  
  FixedLocation&    
  LocatingPin::operator() (Time start, Fork track)    
  {
    return static_cast<FixedLocation&> 
              (addChain (new FixedLocation (start, track)));
  }
  
  
  RelativeLocation& 
  LocatingPin::operator() (PlaRef& refObj, Offset const& offset)
  {
    return static_cast<RelativeLocation&> 
              (addChain (new RelativeLocation (refObj, offset)));
  }
  
  
  
  
}}} // namespace steam::mobject::session