Tableur C++  1.0
API de tableur + interprète bison en ligne de commande
Plage.h
1 /*
2  * Plage.h
3  *
4  * Created on: 16 avr. 2015
5  * Author: michel
6  */
7 
8 #ifndef PLAGE_H_
9 #define PLAGE_H_
10 
11 #include <iostream> // std::cout
12 #include <string>
13 
14 #include "Expression.h"
15 #include "Feuille.h"
16 #include "Reference.h"
17 
18 //#include "PlageIterator.h"
19 
20 namespace modele {
21 class Feuille;
22 
23 class Plage: public Argument {
24 protected:
25  Feuille* feuille;
26  Ref *gauche;
27  Ref *droite;
28  Reference ga; // référence absolue de gauche
29  Reference da; // référence absolue de droite
30 
31 public:
32  class Iterator; // déclaration en avant de a classe imbriquée
33  Plage(Feuille *f,Ref *rg, Ref *rd) : feuille(f), gauche(rg), droite(rd), ga(rg->toAbsolue()), da(rd->toAbsolue()) {
34 // if (dynamic_cast<Reference *>(rg)){
35 // ga=Reference(*rg);
36 // } else{
37 // ga=rg->toAbsolue();
38 // if (dynamic_cast<Reference *>(rd)){
39 // da=Reference(*rd);
40 // } else{
41  // da=rd->toAbsolue();
42  }
43 
44  bool estCalculable(){ return false; }
49  Argument * pa=new Plage(feuille, gauche, droite);
50  return pa;
51  }
52  std::string toString(){
53  return std::string(gauche->toString()+std::string(":")+droite->toString());
54  }
55 
60  gauche->majRefRelatives(r);
61  droite->majRefRelatives(r);
62  ga=gauche->toAbsolue();
63  da=droite->toAbsolue();
64  }
69  return Iterator(this);
70  }
75  Plage::Iterator it(this);
76  it.vaALaFin();
77  return it;
78  }
79  virtual ~Plage() {
80  delete gauche;
81  delete droite;
82  }
83 
84  const Reference& getDa() const {
85  return da;
86  }
87 
88  const Reference& getGa() const {
89  return ga;
90  }
91 
92 
96  class Iterator { // : public std::iterator<std::input_iterator_tag, Reference>
97  protected:
98  Plage *pplage; // pointeur sur la plage à partir de laquelle l'itérateur est construit.
99  Reference courante; // référence absolue courante
100  int incColonne;
101  int incLigne;
102  public:
107  Iterator(Plage *p) : pplage(p),courante(p->getGa()),incColonne(0),incLigne(0) {
108  int diffligne=p->getDa().getLigne() - p->getGa().getLigne(); // droite - gauche
109  if (diffligne<0)
110  incLigne=-1;
111  else
112  incLigne=+1; // else +1 si une seule ligne, il faut quand même avancer pour aller à la fin (itérateur)
113 
114  int diffcol=p->getDa().getColonne() - p->getGa().getColonne(); // droite - gauche
115  if (diffcol<0)
116  incColonne=-1;
117  else if (diffcol>0)
118  incColonne=+1; // else 0 initialisé!
119  }
123  void vaALaFin(){
124  courante.setColonne(pplage->getGa().getColonne());
125  courante.setLigne(pplage->getDa().getLigne()+incLigne);
126  }
130  Iterator(const Iterator& it) : pplage(it.pplage), courante(it.courante), incColonne(it.incColonne), incLigne(it.incLigne){}
131 
137  if(courante.getColonne()==pplage->getGa().getColonne()&&courante.getLigne()==pplage->getDa().getLigne()+incLigne){
138  // si on est au bout
139  return *this; // ne plus rien faire
140  } else if (courante.getColonne()!=pplage->getDa().getColonne()){ // si on peut avancer sur la colonne
141  courante.setColonne(courante.getColonne()+incColonne); // on avance et on retourne !
142  return *this;
143  } else {
144  courante.setColonne(pplage->getGa().getColonne()); // sinon on revient sur la colonne de gauche
145  courante.setLigne(courante.getLigne()+incLigne); // et on avance d'une ligne
146  return *this;
147  // donc le end d'un itérateur est la référence de colonne Ga.col et de ligne Da.ligne+incLigne
148  } // else if(courante.getLigne()!=pplage->getDa().getLigne())
149  }
155  Iterator tmp(*this); operator++(); return tmp;
156  }
157 
158 // bool operator==(const Iterator& d) {
159 // return *pplage==*(d.pplage) && courante==d.courante;
160 // }
164  bool operator!=(const Iterator& d) {return courante!=d.courante;}
168  Reference& operator*() {return courante;}
169  };
170 
171 };
172 
173 } /* namespace modele */
174 
175 
176 #endif /* PLAGE_H_ */
Itérateur de plage permettant de parcourir l'ensemble des références absolues désignées par une Plage...
Definition: Plage.h:96
Classe abstraite parent de Reference (absolue), RefRelative, RefRelativeLigne, RefRelativeCol.
Definition: Ref.h:18
Référence absolue de cellule définie par un numéro de ligne [1..16384], un numéro de colonne [1...
Definition: Reference.h:24
Iterator(Plage *p)
Constructeur d'un itérateur de plage : la position courante est initialisée sur la référence absolue ...
Definition: Plage.h:107
virtual std::string toString()=0
Méthode virtuelle pure retournant une chaîne représentant l'expression (arbre)
Definition: Argument.cpp:10
Iterator & operator++()
Opérateur de pré-incrémentation d'un itérateur de plage : on avance d'abord sur la ligne courante à l...
Definition: Plage.h:136
void vaALaFin()
positionne l'itérateur (référence courante) sur la fin : fin(A1:B2)=A3
Definition: Plage.h:123
Definition: Argument.h:16
void majRefRelatives(Reference *r)
Lors du collage du presse-papier, les références relatives doivent être mises à jour en fonction de l...
Definition: Plage.h:59
Iterator begin()
retourne un itérateur de plage pointant sur la première référence de la plage (à gauche du :)...
Definition: Plage.h:68
Iterator(const Iterator &it)
constructeur par recopie
Definition: Plage.h:130
Argument * clone()
Clonage d'une plage.
Definition: Plage.h:48
Iterator operator++(int)
Opérateur de post-incrémentation d'un itérateur de plage : on avance d'abord sur la ligne courante à ...
Definition: Plage.h:154
Reference & operator*()
Déréférencement de l'itérateur qui pointe sur une référence absolue.
Definition: Plage.h:168
La classe Feuille permet de rassembler des cellules.
Definition: Feuille.h:31
bool operator!=(const Iterator &d)
Opérateur "différent de" vérifiant que les deux références courantes de sont différentes.
Definition: Plage.h:164
virtual void majRefRelatives(Reference *r)
destructeur virtuel impur : seul le destructeur de l'hérité sera appelé
Definition: Expression.h:50
Iterator end()
retourne un itérateur de plage pointant sur la position après la dernière référence valide de la plag...
Definition: Plage.h:74
std::string toString()
Méthode virtuelle pure retournant une chaîne représentant l'expression (arbre)
Definition: Plage.h:52
Definition: Plage.h:23