locatingpin.hpp

Go to the documentation of this file.

/*
  LOCATINGPIN.hpp  -  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.
 
*/
 
 
#ifndef STEAM_MOBJECT_SESSION_LOCATINGPIN_H
#define STEAM_MOBJECT_SESSION_LOCATINGPIN_H
 
 
#include "steam/common.hpp"
#include "lib/time/timevalue.hpp"
 
#include <utility>
#include <memory>
 
 
 
 
namespace steam {
namespace asset { class Pipe; }
 
namespace mobject {
  
  class MObject;
  
//
//template<class MO, class B=MObject>
//class Placement ;
//typedef Placement<MObject> PMO;
  
  template<class MO>
  class PlacementRef;    
  
  typedef PlacementRef<MObject> PlaRef;
  
  
  namespace session {
    
    class FixedLocation;
    class RelativeLocation;
    
    
    
    class LocatingPin
      {
      protected:
        typedef lib::time::Time Time;
        typedef lib::time::TimeVar TimeVar;
        typedef lib::time::Offset Offset;
        typedef Time* Fork; //TODO dummy declaration; we don't use Tracks as first-class entity any longer. This role should be taken by the "Output Designation"
        typedef std::shared_ptr<asset::Pipe> Pipe;
        typedef std::pair<Time,Pipe> SolutionData;  //TICKET #100 (ichthyo considers better passing of solution by subclass)
        struct LocatingSolution;
      
        std::unique_ptr<LocatingPin> next_;
        
        virtual int getPrioLevel ()  const { return 0; }
        
        LocatingPin& addChain (LocatingPin*);
        void resolve (LocatingSolution&)  const;
        virtual void intersect (LocatingSolution&)  const;
        
      public:
        const SolutionData resolve ()  const;
        bool isOverdetermined () const;
        
        /* Factory functions for adding LocatingPins */
        
        FixedLocation&    operator() (Time start, Fork track=0);                                                 
        RelativeLocation& operator() (PlacementRef<MObject>& refObj, Offset const& offset=Offset(Time::ZERO));   
        
        LocatingPin (const LocatingPin&);
        LocatingPin& operator= (const LocatingPin&);
        virtual LocatingPin* clone ()  const;
        
        virtual ~LocatingPin() {};
        
//      protected:
        LocatingPin () {};
        
//TODO (for working out the buildable interface; ctor should be protected)
protected:
  
//        friend class Placement<MObject>;
        
        struct LocatingSolution
          {
            TimeVar minTime;
            TimeVar maxTime;
            Fork minTrack; // TODO don't use Tracks
            Fork maxTrack;
            bool impo;
            
            LocatingSolution () 
              : minTime(Time::MIN),  // TODO: better implementation of "unspecified..."
                maxTime(Time::MAX),
                minTrack(0),     // TODO
                maxTrack(0),
                impo(false)
              { }
            
            Time getTime ();
            Pipe getPipe ();
            
            bool is_definite ();
            bool is_impossible ();
            bool still_to_solve (); 
            
          };
        
        friend bool operator== (LocatingPin const&, LocatingPin const&);
        
      };
      
    
    inline bool
    operator== (LocatingPin const& pin1, LocatingPin const& pin2)
    {
      return pin1.resolve().first == pin2.resolve().first;
    }
      
      
 
}}} // namespace steam::mobject::session
#endif