codac2_TubeComponent.h

Go to the documentation of this file.

 
#pragma once
 
#include "codac2_Interval.h"
 
namespace codac2
{
  #if 0
  template<class T>
  class TubeComponent //: public AbstractConstTube<Interval,TubeComponent<T>>
  {
    protected:
 
      TubeComponent(Tube<T>& tubevector, size_t i) :
        _i(i), _tubevector(tubevector)
      {
        assert(i >= 0 && i < tubevector.size());
      }
 
    public:
 
      TubeComponent(const TubeComponent<T>& tubevector_i) :
        _i(tubevector_i._i), _tubevector(tubevector_i._tubevector)
      {
 
      }
      
      size_t size() const
      {
        return 1;
      }
 
      const std::shared_ptr<TDomain>& tdomain() const
      {
        return _tubevector.tdomain();
      }
      
      Interval t0_tf() const
      {
        return _tubevector.t0_tf();
      }
      
      Interval codomain() const
      {
        Interval codomain(Interval::empty());
        for(const auto& s : _tubevector)
          codomain |= s.codomain()[_i];
        return codomain;
      }
 
      /*bool contains(const Trajectory& value) const
      {
        assert(false);
        return true;
      }*/
      
      void set(const Interval& codomain)
      {
        for(auto& s : _tubevector)
          s.set_component(_i, codomain);
      }
 
      const TubeComponent<T>& operator=(const TubeComponent<T>& x)
      {
        assert(x.tdomain() == tdomain());
        for(auto& s : _tubevector)
          s.set_component(_i, std::static_pointer_cast<Slice<T>>(s._it_tslice->_slices.at(&x._tubevector))->codomain()[x._i]);
        return *this;
      }
 
      const TubeComponent<T>& operator=(std::pair<std::function<Interval(const Interval&)>,const TubeComponent<T>> rel)
      {
        assert(rel.second.tdomain() == tdomain());
        for(auto& s : _tubevector)
          s.set_component(_i, rel.first(std::static_pointer_cast<Slice<T>>(s._it_tslice->_slices.at(&rel.second._tubevector))->codomain()[rel.second._i]));
        return *this;
      }
 
      friend std::ostream& operator<<(std::ostream& os, const TubeComponent<T>& x)
      {
        os << "Component " << x._i << " of: " << x._tubevector << std::flush;
        return os;
      }
 
      std::pair<std::function<Interval(const Interval&)>,const TubeComponent<T>> cos(const TubeComponent<T>& x)
      {
        return std::make_pair(static_cast<Interval(*)(const Interval&)>(cos), x);
      }
      
 
    protected:
 
      size_t _i;
      Tube<T>& _tubevector;
 
      template<typename U>
      friend class Tube;
  };
 
  template<class T>
  std::pair<std::function<Interval(const Interval&)>,const TubeComponent<T>> cos(const TubeComponent<T>& x);
  #endif
}