Tracking.h

Go to the documentation of this file.

// politopix allows to make computations on polytopes such as finding vertices, intersecting, Minkowski sums, ...
//     Copyright (C) 2014-2015 : Delos Vincent
//
//     This program is free software: you can redistribute it and/or modify
//     it under the terms of the GNU Lesser General Public License as published by
//     the Free Software Foundation, either version 3 of the License, or
//     (at your option) any later version.
//
//     This program 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 Lesser General Public License for more details.
//
//     You should have received a copy of the GNU Lesser General Public License
//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// I2M (UMR CNRS 5295 / University of Bordeaux)

#ifndef INC_Tracking
#define INC_Tracking


enum StatusBefore {
  Operator_UNCHANGED = 0,
  Operator_MODIFIED = 1,
  Operator_DELETED = 2,
  Operator_UNKNOWN = 4
};

enum StatusAfter {
  Result_UNCHANGED = 0,
  Result_MODIFIED = 1,
  Result_CREATED = 2,
  Result_UNKNOWN = 4
};


class TrackingOperatorToResult {

 public:

  TrackingOperatorToResult() {}

  void setNumbersOfEntities(unsigned int nbEntBefore, unsigned int nbEntAfter) {
    _operator.resize(nbEntBefore);
    _result.resize(nbEntAfter);
    // Set DELETED by default as we will change the status further on.
    for (unsigned int i=0;i<_operator.size();++i)
      _operator[i].first = Operator_DELETED;
    for (unsigned int i=0;i<_result.size();++i)
      _result[i].first = Result_UNCHANGED;
  }

  void setOperatorEntityAsUnchanged(unsigned int nb) {_operator[nb].first = Operator_UNCHANGED;}

  void  setOperatorEntityAsModified(unsigned int nb) {_operator[nb].first = Operator_MODIFIED;}

  void   setOperatorEntityAsDeleted(unsigned int nb) {_operator[nb].first = Operator_DELETED;}

  void setResultEntityAsUnchanged(unsigned int nb) {_result[nb].first = Result_UNCHANGED;}

  void  setResultEntityAsModified(unsigned int nb) {_result[nb].first = Result_MODIFIED;}

  void   setResultEntityAsUnknown(unsigned int nb) {_result[nb].first = Result_UNKNOWN;}

  void   setResultEntityAsCreated(unsigned int nb) {_result[nb].first = Result_CREATED;}

  StatusAfter    getResultEntityStatus(unsigned int nb) {return   _result[nb].first;}

  StatusBefore getOperatorEntityStatus(unsigned int nb) {return _operator[nb].first;}


  void setOperator_Result(unsigned int nb, int nbRes) {_operator[nb].second = nbRes;}

  void setResult_Operator(unsigned int nbRes, int nb) {_result[nbRes].second = nb;}

  const std::vector< std::pair< StatusBefore, int > >& getOperatorToResult() const {return _operator;}

  const std::vector< std::pair< StatusAfter,  int > >& getResultToOperator() const {return _result;}

 protected:

  std::vector< std::pair< StatusBefore, int > > _operator;
  std::vector< std::pair< StatusAfter,  int > > _result;

};


typedef std::pair< int, int > operator1_operator2;

class TrackingBinaryOperation {

 public:

  TrackingBinaryOperation() {}

  void setNumbersOfEntities(unsigned int nbEntBefore1, unsigned int nbEntBefore2, unsigned int nbEntAfter) {
    _operator1.resize(nbEntBefore1);
    _operator2.resize(nbEntBefore2);
    _result.resize(nbEntAfter);
    {for (unsigned int i=0;i<_operator1.size();++i) {
      _operator1[i].first = Operator_DELETED;
      // Put -1 at the moment as we don't know the corresponding element.
      _operator1[i].second = -1;
    }}
    {for (unsigned int i=0;i<_operator2.size();++i) {
      _operator2[i].first = Operator_DELETED;
      _operator2[i].second = -1;
    }}
    {for (unsigned int i=0;i<_result.size();++i) {
      _result[i].first = Result_UNCHANGED;
      _result[i].second.first  = -1;
      _result[i].second.second = -1;
    }}
  }

  void setOperator1_Result(unsigned int nbOp1, int nbRes) {_operator1[nbOp1].second = nbRes;}

  void setOperator2_Result(unsigned int nbOp2, int nbRes) {_operator2[nbOp2].second = nbRes;}

  void setResult_Operator1Operator2(unsigned int nbRes, int nbOp1, int nbOp2) {
    _result[nbRes].second.first  = nbOp1;
    _result[nbRes].second.second = nbOp2;
  }

  const std::vector< std::pair< StatusAfter, operator1_operator2 > >& getResultStatus_Operator1Operator2() const { return _result;}

  void setOperator1EntityAsUnchanged(unsigned int nbOp1) {_operator1[nbOp1].first = Operator_UNCHANGED;}

  void setOperator1EntityAsModified( unsigned int nbOp1) {_operator1[nbOp1].first = Operator_MODIFIED;}

  void setOperator1EntityAsDeleted(  unsigned int nbOp1) {_operator1[nbOp1].first = Operator_DELETED;}

  void setOperator2EntityAsUnchanged(unsigned int nbOp2) {_operator2[nbOp2].first = Operator_UNCHANGED;}

  void setOperator2EntityAsModified( unsigned int nbOp2) {_operator2[nbOp2].first = Operator_MODIFIED;}

  void  setOperator2EntityAsDeleted( unsigned int nbOp2) {_operator2[nbOp2].first = Operator_DELETED;}

  void setResultEntityAsUnchanged(unsigned int nbRes) { _result[nbRes].first = Result_UNCHANGED;}

  void setResultEntityAsModified( unsigned int nbRes) { _result[nbRes].first = Result_MODIFIED;}

  void  setResultEntityAsUnknown( unsigned int nbRes) { _result[nbRes].first = Result_UNKNOWN;}

  void  setResultEntityAsCreated( unsigned int nbRes) { _result[nbRes].first = Result_CREATED;}


 protected:
  std::vector< std::pair< StatusBefore, int > > _operator1;
  std::vector< std::pair< StatusBefore, int > > _operator2;
  std::vector< std::pair< StatusAfter, operator1_operator2 > > _result;

};

#endif // INC_Tracking