TimeLaw.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP 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 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



#ifndef TIMELAW_H
#define TIMELAW_H

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include<iostream>
#include<math.h>
#include<Time.h>
#include"Path.h"
using namespace std;

enum TimeLawType{
 STILLNESS,
 CONST_SPEED,
 TRIANGULAR_SPEED,
 TRAPEZOIDAL_SPEED,
 CUBIC_SPEED,
 TRAPEZOIDAL_ACC,
 TRAPEZOIDAL_DEC,
 LAW_NUM
};

static const char* TimeLawNames[LAW_NUM] = {
 "Stillness",
 "Constant Speed",
 "Triangular Speed",
 "Trapezoidal Speed",
 "Cubic Speed",
 "Trapezoidal Acceleration",
 "Trapezoidal Deceleration"
};

namespace MipBaselib {

class ConstSpeedParam{
 private:
  Decimal _speed; 
 public:
  ConstSpeedParam(){};
  ConstSpeedParam(Decimal speed){
   setSpeed(speed);
  }
  
  ConstSpeedParam(const ConstSpeedParam& p){
   _speed=p._speed;
  }
  
  ConstSpeedParam& operator=(const ConstSpeedParam& p){
   if (this != &p){
    _speed=p._speed;
   }
   return *this;
  }
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setSpeed(Decimal value){
   _speed=value;
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  Decimal speed(){
   return _speed;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<"Speed\t"<<_speed<<endl;
   return s.str();
  };
};

class TriangularSpeedParam{
 private:
  Decimal _acceleration; 
  Time _T;        
 public:
  TriangularSpeedParam(){};
  TriangularSpeedParam(Decimal acceleration, Time T){
   setAcceleration(acceleration);
   setT(T);
  }
  
  TriangularSpeedParam(const TriangularSpeedParam& p){
   _acceleration=p._acceleration;
   _T=p._T;
  }
  
  TriangularSpeedParam& operator=(const TriangularSpeedParam& p){
   if (this != &p){
    _acceleration=p._acceleration;
    _T=p._T;
   }
   return *this;
  }
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setAcceleration (Decimal value){
   _acceleration=value;
  }
  
  void setT (Time value){
   _T=value;
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  Decimal acceleration(){
   return _acceleration;
  }
  
  Time T(){
   return _T;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<"Acceleration\t\t\t"<<_acceleration<<endl;
   s<<"Acceleration toggling time\t"<<_T.print()<<endl;
   return s.str();
  };
};

class TrapezoidalSpeedParam{
 private:
  Decimal _acceleration; 
  Time _T1;        
  Time _T2;        
 public:
  TrapezoidalSpeedParam(){};
  TrapezoidalSpeedParam(Decimal acceleration, Time T1, Time T2){
   setAcceleration(acceleration);
   setT1(T1);
   setT2(T2);
  }
  
  TrapezoidalSpeedParam(const TrapezoidalSpeedParam& p){
   _acceleration=p._acceleration;
   _T1=p._T1;
   _T2=p._T2;
  }
  
  TrapezoidalSpeedParam& operator=(const TrapezoidalSpeedParam& p){
   if (this != &p){
    _acceleration=p._acceleration;
    _T1=p._T1;
    _T2=p._T2;
   }
   return *this;
  }
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setAcceleration (Decimal value){
   _acceleration=value;
  }
  
  void setT1 (Time value){
   _T1=value;
  }
  
  void setT2 (Time value){
   _T2=value;
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  Decimal acceleration(){
   return _acceleration;
  }
  
  Time T1(){
   return _T1;
  }
  
  Time T2(){
   return _T2;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<"Acceleration\t\t\t\t"<<_acceleration<<endl;
   s<<"Instant of acceleration zero-setting\t"<<_T1.print()<<endl;
   s<<"Instant deceleration start\t\t"<<_T2.print()<<endl;
   return s.str();
  };
};

class CubicSpeedParam{
 private:
  Decimal _acceleration; 
  Time _T1;        
  Time _T2;        
 public:
  CubicSpeedParam(){};
  CubicSpeedParam(Decimal acceleration, Time T1, Time T2){
   setAcceleration(acceleration);
   setT1(T1);
   setT2(T2);
  }
  
  CubicSpeedParam(const CubicSpeedParam& p){
   _acceleration=p._acceleration;
   _T1=p._T1;
   _T2=p._T2;
  }
  
  CubicSpeedParam& operator=(const CubicSpeedParam& p){
   if (this != &p){
    _acceleration=p._acceleration;
    _T1=p._T1;
    _T2=p._T2;
   }
   return *this;
  }
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setAcceleration (Decimal value){
   _acceleration=value;
  }
  
  void setT1 (Time value){
   _T1=value;
  }
  
  void setT2 (Time value){
   _T2=value;
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  Decimal acceleration(){
   return _acceleration;
  }
  
  Time T1(){
   return _T1;
  }
  
  Time T2(){
   return _T2;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<"Acceleration\t"<<_acceleration<<endl;
   s<<"T1???\t\t"<<_T1.print()<<endl;
   s<<"T2???\t\t"<<_T2.print()<<endl;
   return s.str();
  };
};

class TrapezoidalAccParam{
 private:
  Decimal _acceleration; 
  Time _T1;        
  Time _T2;        
 public:
  TrapezoidalAccParam(){};
  TrapezoidalAccParam(Decimal acceleration, Time T1, Time T2){
   setAcceleration(acceleration);
   setT1(T1);
   setT2(T2);
  }
  
  TrapezoidalAccParam(const TrapezoidalAccParam& p){
   _acceleration=p._acceleration;
   _T1=p._T1;
   _T2=p._T2;
  }
  
  TrapezoidalAccParam& operator=(const TrapezoidalAccParam& p){
   if (this != &p){
    _acceleration=p._acceleration;
    _T1=p._T1;
    _T2=p._T2;
   }
   return *this;
  }
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setAcceleration (Decimal value){
   _acceleration=value;
  }
  
  void setT1 (Time value){
   _T1=value;
  }
  
  void setT2 (Time value){
   _T2=value;
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  Decimal acceleration(){
   return _acceleration;
  }
  
  Time T1(){
   return _T1;
  }
  
  Time T2(){
   return _T2;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<"Acceleration\t"<<_acceleration<<endl;
   s<<"Instant of acceleration setting to constant\t\t"<<_T1.print()<<endl;
   s<<"Instant of acceleration decrement start\t\t"<<_T2.print()<<endl;
   return s.str();
  };
};

class TrapezoidalDecParam{
 private:
  Decimal _acceleration; 
  Time _T1;        
  Time _T2;        
 public:
  TrapezoidalDecParam(){};
  TrapezoidalDecParam(Decimal acceleration, Time T1, Time T2){
   setAcceleration(acceleration);
   setT1(T1);
   setT2(T2);
  }
  
  TrapezoidalDecParam(const TrapezoidalDecParam& p){
   _acceleration=p._acceleration;
   _T1=p._T1;
   _T2=p._T2;
  }
  
  TrapezoidalDecParam& operator=(const TrapezoidalDecParam& p){
   if (this != &p){
    _acceleration=p._acceleration;
    _T1=p._T1;
    _T2=p._T2;
   }
   return *this;
  }
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setAcceleration (Decimal value){
   _acceleration=value;
  }
  
  void setT1 (Time value){
   _T1=value;
  }
  
  void setT2 (Time value){
   _T2=value;
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  Decimal acceleration(){
   return _acceleration;
  }
  
  Time T1(){
   return _T1;
  }
  
  Time T2(){
   return _T2;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<"Acceleration\t"<<_acceleration<<endl;
   s<<"Instant of deceleration setting to constant\t\t"<<_T1.print()<<endl;
   s<<"Instant of deceleration decrement start\t\t"<<_T2.print()<<endl;
   return s.str();
  };
};

//TimeLaw = s(t)
class TimeLaw{
 protected:
  Decimal _s;  
  Decimal _sp; 
  Decimal _spp; 
  Time _start; 
  Time _end;  
  TimeLawType _timeLawType;
  
 public:
  TimeLaw(){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   setTimeLawType(STILLNESS);
  };
  TimeLaw(Time start,Time end){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=start;
   _end=end;
   setTimeLawType(STILLNESS);
  };
  
  TimeLaw(const TimeLaw& timeLaw){
   _s=timeLaw._s;
   _sp=timeLaw._sp;
   _spp=timeLaw._spp;
   _start=timeLaw._start;
   _end=timeLaw._end;
   _timeLawType=timeLaw._timeLawType;
  }
  
  TimeLaw& operator=(const TimeLaw& timeLaw){
   if (this != &timeLaw){
    _s=timeLaw._s;
    _sp=timeLaw._sp;
    _spp=timeLaw._spp;
    _start=timeLaw._start;
    _end=timeLaw._end;
    _timeLawType=timeLaw._timeLawType;
   }
   return *this;
  }
  virtual void inizializeS(Time time)=0;
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setS(Decimal value){
   _s=value;
  }
  
  void setSp(Decimal value){
   _sp=value;
  }
  
  void setSpp(Decimal value){
   _spp=value;
  }
  
  
  void setStart(Time value){
   _start=value;
  }
  
  void setEnd(Time value){
   _end=value;
  }
  
  void setTimeLawType(TimeLawType value){
   _timeLawType=value;
  }
  
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  Decimal s(){
   return _s;
  }
  
  Decimal sp(){
   return _sp;
  }
  
  Decimal spp(){
   return _spp;
  }
  
  Time start(){
   return _start;
  }
  
  Time end(){
   return _end;
  }
  
  TimeLawType timeLawType(){
   return _timeLawType;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<"Time Law Type\t"<<TimeLawNames[_timeLawType]<<endl;
   s<<"Start\t\t"<<_start.print()<<endl;
   s<<"End\t\t"<<_end.print()<<endl;
   return s.str();
  };
};

class Stillness :public TimeLaw{
 public:
  Stillness(){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   setTimeLawType(STILLNESS);
  };
  
  Stillness(const Stillness& stillness):TimeLaw(stillness){
   _s=stillness._s;
   _sp=stillness._sp;
   _spp=stillness._spp;
   _start=stillness._start;
   _end=stillness._end;
  }
  
  Stillness& operator=(const Stillness& stillness){
   if (this != &stillness){
    TimeLaw::operator=(stillness);
    _s=stillness._s;
    _sp=stillness._sp;
    _spp=stillness._spp;
    _start=stillness._start;
    _end=stillness._end;
   }
   return *this;
  }
  
  void inizializeS(Time time){
   _sp=0.0;
   _spp=0.0;
  };
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<TimeLaw::print();
   return s.str();
  }
};


class ConstSpeed :public TimeLaw{
 private:
  ConstSpeedParam _param; 
 public:
  ConstSpeed(){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   _param.setSpeed(1.0);
   setTimeLawType(CONST_SPEED);
  };
  ConstSpeed(ConstSpeedParam param){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   _param.setSpeed(param.speed());
   setTimeLawType(CONST_SPEED);
  };
  
  ConstSpeed(const ConstSpeed& constSpeed):TimeLaw(constSpeed){
   _param=constSpeed._param;
  }
  
  ConstSpeed& operator=(const ConstSpeed& constSpeed){
   if (this != &constSpeed){
    TimeLaw::operator=(constSpeed);
    _param=constSpeed._param;
   }
   return *this;
  }
  
  void inizializeS(Time time);
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setParam(ConstSpeedParam param){
   _param.setSpeed(param.speed());
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  ConstSpeedParam param(){
   return _param;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<TimeLaw::print();
   s<<_param.print()<<endl;
   return s.str();
  }
};

class TriangularSpeed :public TimeLaw{
 private:
  TriangularSpeedParam _param; 
 public:
  TriangularSpeed(){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   // CHECK: MAYBE IS Time(5,0) instead of (Time)(5,0)
   _param.setT((Time)(10,0));
   setTimeLawType(TRIANGULAR_SPEED);
  };
  TriangularSpeed(TriangularSpeedParam param){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   _param.setAcceleration(param.acceleration());
   _param.setT(param.T());
   setTimeLawType(TRIANGULAR_SPEED);
  };
  
  TriangularSpeed(const TriangularSpeed& triangularSpeed):TimeLaw(triangularSpeed){
   _param=triangularSpeed._param;
  }
  
  TriangularSpeed& operator=(const TriangularSpeed& triangularSpeed){
   if (this != &triangularSpeed){
    TimeLaw::operator=(triangularSpeed);
    _param=triangularSpeed._param;
   }
   return *this;
  }
  
  void inizializeS(Time time);
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setParam(TriangularSpeedParam param){
   _param.setAcceleration(param.acceleration());
   _param.setT(param.T());
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  TriangularSpeedParam param(){
   return _param;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<TimeLaw::print();
   s<<_param.print()<<endl;
   return s.str();
  }
};

class TrapezoidalSpeed :public TimeLaw{
 private:
  TrapezoidalSpeedParam _param; 
 public:
  TrapezoidalSpeed(){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   // CHECK: MAYBE IS Time(5,0) instead of (Time)(5,0)
   _param.setT1((Time)(5,0));
   _param.setT1((Time)(15,0));
   setTimeLawType(TRAPEZOIDAL_SPEED);
  };
  TrapezoidalSpeed(TrapezoidalSpeedParam param){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
   setTimeLawType(TRAPEZOIDAL_SPEED);
  };
  
  TrapezoidalSpeed(const TrapezoidalSpeed& trapezoidalSpeed):TimeLaw(trapezoidalSpeed){
   _param=trapezoidalSpeed._param;
  }
  
  TrapezoidalSpeed& operator=(const TrapezoidalSpeed& trapezoidalSpeed){
   if (this != &trapezoidalSpeed){
    TimeLaw::operator=(trapezoidalSpeed);
    _param=trapezoidalSpeed._param;
   }
   return *this;
  }
  
  void inizializeS(Time time);
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setParam(TrapezoidalSpeedParam param){
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  TrapezoidalSpeedParam param(){
   return _param;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<TimeLaw::print();
   s<<_param.print()<<endl;
   return s.str();
  }
};

class CubicSpeed :public TimeLaw{
 private:
  CubicSpeedParam _param; 
 public:
  CubicSpeed(){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   // CHECK: MAYBE IS Time(5,0) instead of (Time)(5,0)
   _param.setT1((Time)(5,0));
   _param.setT1((Time)(15,0));
   setTimeLawType(CUBIC_SPEED);
  };
  CubicSpeed(CubicSpeedParam param){
   _s=0.0;
   _sp=0.0;
   _spp=0.0;
   _start=Time(0,0);
   _end=Time((long int)INFINITY,0);
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
   setTimeLawType(CUBIC_SPEED);
  };
  
  CubicSpeed(const CubicSpeed& cubicSpeed):TimeLaw(cubicSpeed){
   _param=cubicSpeed._param;
  }
  
  CubicSpeed& operator=(const CubicSpeed& cubicSpeed){
   if (this != &cubicSpeed){
    TimeLaw::operator=(cubicSpeed);
    _param=cubicSpeed._param;
   }
   return *this;
  }
  
  void inizializeS(Time time);
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setParam(CubicSpeedParam param){
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  CubicSpeedParam param(){
   return _param;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<TimeLaw::print();
   s<<_param.print()<<endl;
   return s.str();
  }
};

class TrapezoidalAcc :public TimeLaw{
 private:
  TrapezoidalAccParam _param; 
 public:
  TrapezoidalAcc(){};
  TrapezoidalAcc(TrapezoidalAccParam param){
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
   setTimeLawType(TRAPEZOIDAL_ACC);
  };
  
  TrapezoidalAcc(const TrapezoidalAcc& trapezoidalAcc):TimeLaw(trapezoidalAcc){
   _param=trapezoidalAcc._param;
  }
  
  TrapezoidalAcc& operator=(const TrapezoidalAcc& trapezoidalAcc){
   if (this != &trapezoidalAcc){
    TimeLaw::operator=(trapezoidalAcc);
    _param=trapezoidalAcc._param;
   }
   return *this;
  }
  
  void inizializeS(Time time);
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setParam(TrapezoidalAccParam param){
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  TrapezoidalAccParam param(){
   return _param;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<TimeLaw::print();
   s<<_param.print()<<endl;
   return s.str();
  }
};

class TrapezoidalDec :public TimeLaw{
 private:
  TrapezoidalDecParam _param; 
 public:
  TrapezoidalDec(){};
  TrapezoidalDec(TrapezoidalDecParam param){
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
   setTimeLawType(TRAPEZOIDAL_DEC);
  };
  
  TrapezoidalDec(const TrapezoidalDec& trapezoidalDec):TimeLaw(trapezoidalDec){
   _param=trapezoidalDec._param;
  }
  
  TrapezoidalDec& operator=(const TrapezoidalDec& trapezoidalDec){
   if (this != &trapezoidalDec){
    TimeLaw::operator=(trapezoidalDec);
    _param=trapezoidalDec._param;
   }
   return *this;
  }
  
  void inizializeS(Time time);
/***************************************************************************************************
***********************************        SET FUNCTIONS         ***********************************
***************************************************************************************************/
  void setParam(TrapezoidalDecParam param){
   _param.setAcceleration(param.acceleration());
   _param.setT1(param.T1());
   _param.setT2(param.T2());
  }
/***************************************************************************************************
***********************************        GET FUNCTIONS         ***********************************
***************************************************************************************************/
  TrapezoidalDecParam param(){
   return _param;
  }
  
  string print(){
   stringstream s;
   s.precision(3);
   s.setf(ios::fixed,ios::floatfield);
   s<<TimeLaw::print();
   s<<_param.print()<<endl;
   return s.str();
  }
};

}; // end of namespace
#endif