Skip to content

Commit 3fd0d3d

Browse files
AzzaareAzzaare
committed
Renamed NormalStack into ClassicStack
1 parent 2f60bbf commit 3fd0d3d

File tree

5 files changed

+42
-42
lines changed

5 files changed

+42
-42
lines changed

‎include/buffer.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,10 +21,10 @@ template <class T, class D>
2121
class CompressedStack; // Required for the friendship
2222
template <class T, class D> class Signature; // Required for the friendship
2323
template <class T, class D> class Component; // Required for the friendship
24-
template <class T, class D> class NormalStack; // Required for the friendship
24+
template <class T, class D> class ClassicStack; // Required for the friendship
2525
template <class T, class D> class Buffer {
2626
friend class CompressedStack<T, D>;
27-
friend class NormalStack<T, D>;
27+
friend class ClassicStack<T, D>;
2828
friend class Signature<T, D>;
2929
friend class Component<T, D>;
3030

include/normalStack.hpp renamed to include/classicStack.hpp

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
1-
#ifndef NORMALSTACK
2-
#define NORMALSTACK
1+
#ifndef CLASSICSTACK
2+
#define CLASSICSTACK
33

44
/*==============================================================================
55
Includes
@@ -17,14 +17,14 @@
1717
template <class T, class D> class StackAlgo; // Required for the friendship
1818
template <class T, class D> class CompareStacks; // Required for the friendship
1919
class Comparison; // Required for the friendship
20-
template <class T, class D> class NormalStack : public Stack<T, D> {
20+
template <class T, class D> class ClassicStack : public Stack<T, D> {
2121
friend class StackAlgo<T, D>;
2222
friend class CompareStacks<T, D>;
2323
friend class Comparison;
2424

2525
public:
2626
// Constructors
27-
NormalStack<T, D>();
27+
ClassicStack<T, D>();
2828

2929
// IO
3030
std::string toString();
@@ -58,7 +58,7 @@ template <class T, class D> class NormalStack : public Stack<T, D> {
5858
/*==============================================================================
5959
Constructors
6060
==============================================================================*/
61-
template <class T, class D> NormalStack<T, D>::NormalStack() {
61+
template <class T, class D> ClassicStack<T, D>::ClassicStack() {
6262
Explicit<T, D> datas;
6363
datas = initExplicit<T, D>();
6464
mDatas = datas;
@@ -68,57 +68,57 @@ template <class T, class D> NormalStack<T, D>::NormalStack() {
6868
Stack Functions: push, pop, top, isempty
6969
==============================================================================*/
7070
template <class T, class D>
71-
bool NormalStack<T, D>::empty(int lvl, int component) {
71+
bool ClassicStack<T, D>::empty(int lvl, int component) {
7272
return mDatas.empty();
7373
}
7474

7575
template <class T, class D>
76-
Data<T, D> NormalStack<T, D>::pop(StackAlgo<T, D> &problem) {
76+
Data<T, D> ClassicStack<T, D>::pop(StackAlgo<T, D> &problem) {
7777
Data<T, D> data = mDatas.back();
7878
mDatas.pop_back();
7979
return data;
8080
}
81-
template <class T, class D> Data<T, D> NormalStack<T, D>::pop() {
81+
template <class T, class D> Data<T, D> ClassicStack<T, D>::pop() {
8282
Data<T, D> data = mDatas.back();
8383
mDatas.pop_back();
8484
return data;
8585
}
8686

8787
template <class T, class D>
88-
void NormalStack<T, D>::push(const Data<T, D> &elt) {
88+
void ClassicStack<T, D>::push(const Data<T, D> &elt) {
8989
mDatas.push_back(elt);
9090
}
9191

92-
template <class T, class D> Data<T, D> NormalStack<T, D>::top(int k) {
92+
template <class T, class D> Data<T, D> ClassicStack<T, D>::top(int k) {
9393
int index = mDatas.size() - k;
9494
return mDatas.at(index);
9595
}
9696

97-
template <class T, class D> void NormalStack<T, D>::compress() {}
97+
template <class T, class D> void ClassicStack<T, D>::compress() {}
9898

9999
/*==============================================================================
100100
Getters
101101
==============================================================================*/
102102
template <class T, class D>
103-
Block<T, D> NormalStack<T, D>::getFirstPartial(int lvl) {
103+
Block<T, D> ClassicStack<T, D>::getFirstPartial(int lvl) {
104104
return initBlock<T, D>(0);
105105
}
106106

107-
template <class T, class D> Block<T, D> NormalStack<T, D>::getCompressed() {
107+
template <class T, class D> Block<T, D> ClassicStack<T, D>::getCompressed() {
108108
return initBlock<T, D>(0);
109109
}
110110

111111
template <class T, class D>
112-
ExplicitPointer<T, D> NormalStack<T, D>::getFirstExplicit() {
112+
ExplicitPointer<T, D> ClassicStack<T, D>::getFirstExplicit() {
113113
return initExplicitPointer<T, D>();
114114
}
115115

116116
template <class T, class D>
117-
int NormalStack<T, D>::getBufferSize() {
117+
int ClassicStack<T, D>::getBufferSize() {
118118
return 0;
119119
}
120120

121-
template <class T, class D> Signature<T, D> NormalStack<T, D>::getFirstSign() {
121+
template <class T, class D> Signature<T, D> ClassicStack<T, D>::getFirstSign() {
122122
Signature<T, D> sign(0, std::streampos(0), std::shared_ptr<T>(nullptr),
123123
Buffer<T, D>(0));
124124
return sign;
@@ -127,11 +127,11 @@ template <class T, class D> Signature<T, D> NormalStack<T, D>::getFirstSign() {
127127
/*==============================================================================
128128
IO : toString
129129
==============================================================================*/
130-
template <class T, class D> std::string NormalStack<T, D>::toString() {
130+
template <class T, class D> std::string ClassicStack<T, D>::toString() {
131131
std::string str;
132-
str = "\tNormal Stack (Explicit Datas)\n\t\t";
132+
str = "\tClassic Stack (Explicit Datas)\n\t\t";
133133
str += explicitToString(mDatas);
134134
return str;
135135
}
136136

137-
#endif /* NORMALSTACK */
137+
#endif /* CLASSICSTACK */

‎include/compare.hpp‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ template <class T, class D> class CompareStacks : public StackAlgo<T, D> {
2525
// IO
2626
void printCompare() {
2727
std::string str = StackAlgo<T, D>::toString();
28-
str += "\n" + (*mNormalStack).toString();
28+
str += "\n" + (*mClassicStack).toString();
2929
std::cout << str << std::endl;
3030
}
3131

@@ -45,7 +45,7 @@ template <class T, class D> class CompareStacks : public StackAlgo<T, D> {
4545
Data<T, D> popCompare();
4646

4747
// Stack: Normal Stack for comparison
48-
std::shared_ptr<NormalStack<T, D>> mNormalStack;
48+
std::shared_ptr<ClassicStack<T, D>> mClassicStack;
4949
};
5050

5151
/*==============================================================================
@@ -54,7 +54,7 @@ template <class T, class D> class CompareStacks : public StackAlgo<T, D> {
5454

5555
template <class T, class D>
5656
CompareStacks<T, D>::CompareStacks(std::string fileName)
57-
: StackAlgo<T, D>(fileName), mNormalStack(new NormalStack<T, D>()) {}
57+
: StackAlgo<T, D>(fileName), mClassicStack(new ClassicStack<T, D>()) {}
5858

5959
/*==============================================================================
6060
Stack Functions: run, push, pop, top
@@ -70,11 +70,11 @@ template <class T, class D> void CompareStacks<T, D>::runCompare(int buffer) {
7070
std::streampos position = StackAlgo<T, D>::mInput.tellg();
7171
(*StackAlgo<T, D>::mStack).setPosition(position);
7272
for (int i = 1; i <= buffer; i++) {
73-
bool bIndex = StackAlgo<T, D>::top(i).mIndex == mNormalStack->top(i).mIndex;
74-
bool bData = StackAlgo<T, D>::top(i).mData == mNormalStack->top(i).mData;
73+
bool bIndex = StackAlgo<T, D>::top(i).mIndex == mClassicStack->top(i).mIndex;
74+
bool bData = StackAlgo<T, D>::top(i).mData == mClassicStack->top(i).mData;
7575
if (!bIndex || !bData) {
7676
StackAlgo<T, D>::println();
77-
std::cout << mNormalStack->toString() << std::endl;
77+
std::cout << mClassicStack->toString() << std::endl;
7878
throw "The top $(i)st elements are different";
7979
}
8080
}
@@ -84,39 +84,39 @@ template <class T, class D> void CompareStacks<T, D>::runCompare(int buffer) {
8484
}
8585
D data = readInput(line);
8686
StackAlgo<T, D>::mIndex++;
87-
if ((*StackAlgo<T, D>::mStack).empty() != mNormalStack->empty()) {
87+
if ((*StackAlgo<T, D>::mStack).empty() != mClassicStack->empty()) {
8888
(*StackAlgo<T, D>::mStack).empty();
8989
StackAlgo<T, D>::println();
90-
std::cout << mNormalStack->toString() << std::endl;
90+
std::cout << mClassicStack->toString() << std::endl;
9191
(*StackAlgo<T, D>::mStack).empty();
9292
throw "One stack is empty and not the other";
9393
}
9494
while ((!(StackAlgo<T, D>::emptystack())) && (popCondition(data))) {
9595
Data<T, D> elt = StackAlgo<T, D>::pop();
96-
Data<T, D> eltNormal = mNormalStack->pop();
96+
Data<T, D> eltNormal = mClassicStack->pop();
9797
popAction(elt);
9898
bool bIndex = elt.mIndex == eltNormal.mIndex;
9999
bool bData = elt.mData == eltNormal.mData;
100100
if (!bIndex || !bData) {
101101
StackAlgo<T, D>::println();
102102
//std::cout << *StackAlgo<T, D>::mContext << std::endl;
103-
std::cout << mNormalStack->toString() << std::endl;
103+
std::cout << mClassicStack->toString() << std::endl;
104104
throw "The two elements popped are different";
105105
}
106106
}
107107
if (pushCondition(data)) {
108108
Data<T, D> elt(StackAlgo<T, D>::mIndex, data);
109109
pushAction(elt);
110110
StackAlgo<T, D>::push(elt);
111-
mNormalStack->push(elt);
111+
mClassicStack->push(elt);
112112
}
113113
if (StackAlgo<T, D>::mStack->getBufferSize() > 0) {
114114
std::cout << "Is it working" << std::endl;
115115
for (int k = 1; k <= StackAlgo<T, D>::mStack->getBufferSize(); k++) {
116-
if (StackAlgo<T, D>::mStack->top(k).mIndex == mNormalStack->top(k).mIndex) {
116+
if (StackAlgo<T, D>::mStack->top(k).mIndex == mClassicStack->top(k).mIndex) {
117117
StackAlgo<T, D>::println();
118118
//std::cout << *StackAlgo<T, D>::mContext << std::endl;
119-
std::cout << mNormalStack->toString() << std::endl;
119+
std::cout << mClassicStack->toString() << std::endl;
120120
throw "The two elements at the k = $(k) position are different";
121121
}
122122
}
@@ -137,7 +137,7 @@ template <class T, class D> void CompareStacks<T, D>::readPush(int iter) {
137137
Data<T, D> elt(StackAlgo<T, D>::mIndex, data);
138138
pushAction(elt);
139139
StackAlgo<T, D>::push(elt);
140-
mNormalStack->push(elt);
140+
mClassicStack->push(elt);
141141
}
142142
}
143143

‎include/sign.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,11 @@
2020
template <class T, class D> class Component; // Required for the friendship
2121
template <class T, class D>
2222
class CompressedStack; // Required for the friendship
23-
template <class T, class D> class NormalStack; // Required for the friendship
23+
template <class T, class D> class ClassicStack; // Required for the friendship
2424
template <class T, class D> class Signature {
2525
friend class Component<T, D>;
2626
friend class CompressedStack<T, D>;
27-
friend class NormalStack<T, D>;
27+
friend class ClassicStack<T, D>;
2828

2929
public:
3030
// IO

‎include/stackAlgo.hpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
Includes
66
==============================================================================*/
77
#include "compressedStack.hpp"
8-
#include "normalStack.hpp"
8+
#include "classicStack.hpp"
99
#include "stack.hpp"
1010
#include <exception>
1111
#include <fstream>
@@ -18,7 +18,7 @@
1818
Extensions : Instance
1919
Aliases :
2020
Friends -> CompressedStack
21-
<- NormalStack, CompressedStack, Data
21+
<- ClassicStack, CompressedStack, Data
2222
==============================================================================*/
2323
template <class T, class D>
2424
class CompressedStack; // Required for the friendship
@@ -79,12 +79,12 @@ template <class T, class D> class StackAlgo {
7979
// StackAlgo internal during run
8080
std::shared_ptr<T> mContext;
8181

82-
// Stack: Normal or Compressed
82+
// Stack: Classic or Compressed
8383
std::shared_ptr<Stack<T, D>> mStack;
8484
};
8585

8686
/*==============================================================================
87-
Constructors : with NormalStack or CompressedStack
87+
Constructors : with ClassicStack or CompressedStack
8888
==============================================================================*/
8989
template <class T, class D>
9090
StackAlgo<T, D>::StackAlgo(std::string fileName) : mIndex(0), mContext(nullptr) {
@@ -113,7 +113,7 @@ StackAlgo<T, D>::StackAlgo(std::string fileName) : mIndex(0), mContext(nullptr)
113113
throw("StackAlgo<T,D>::StackAlgo(std::string fileName), wrong header format ");
114114
if (!foundP)
115115
mStack = std::shared_ptr<Stack<T, D>>(
116-
new NormalStack<T, D>()); // space not provided, normal stack
116+
new ClassicStack<T, D>()); // space not provided, classic stack
117117
else // space was provided, compressed stack
118118
{
119119
if (!foundBuffer)

0 commit comments

Comments
 (0)