From 48a18872c2ee6786dd407d9ce17ee661bfa320cc Mon Sep 17 00:00:00 2001 From: Brandon Jackson Date: Wed, 30 Sep 2015 17:10:16 -0500 Subject: [PATCH] Updated user.h --- Attribute.cpp | 92 ++++ Attribute.h | 31 ++ Condition.cpp | 59 +++ Condition.h | 7 + DBApp.cpp | 40 ++ DBAppV2.cpp | 126 ++++++ DBEngine.cpp | 290 +++++++++++++ DBEngine.h | 34 ++ Parser.cpp | 1126 +++++++++++++++++++++++++++++++++++++++++++++++++ Parser.h | 419 ++++++++++++++++++ README.txt | 40 ++ Relation.cpp | 154 +++++++ Relation.h | 30 ++ a.out | Bin 0 -> 208930 bytes savefile.txt | 3 + test | Bin 0 -> 204297 bytes test.cpp | 12 + user.cpp | 37 ++ user.h | 44 ++ 19 files changed, 2544 insertions(+) create mode 100755 Attribute.cpp create mode 100755 Attribute.h create mode 100755 Condition.cpp create mode 100755 Condition.h create mode 100755 DBApp.cpp create mode 100755 DBAppV2.cpp create mode 100755 DBEngine.cpp create mode 100755 DBEngine.h create mode 100755 Parser.cpp create mode 100755 Parser.h create mode 100755 README.txt create mode 100755 Relation.cpp create mode 100755 Relation.h create mode 100755 a.out create mode 100755 savefile.txt create mode 100755 test create mode 100755 test.cpp create mode 100755 user.cpp create mode 100755 user.h diff --git a/Attribute.cpp b/Attribute.cpp new file mode 100755 index 0000000..dad5d6a --- /dev/null +++ b/Attribute.cpp @@ -0,0 +1,92 @@ +#include +#include +#include "Attribute.h" + +Attribute::Attribute(){ + name = ""; + type = ""; + key = 0; + size = 0; + limit = 0; +} + +Attribute::Attribute(string n, string t, bool k){ + name = n; + type = t; + key = k; + size = 0; + limit = 20; +} + +Attribute::Attribute(string n, string t, bool k, int s){ + name = n; + type = t; + key = k; + size = 0; + limit = s; +} + +void Attribute::addCell(string v){ + values.push_back(v); + size++; +} + +void Attribute::removeCell(int index){ + values.erase(values.begin() + index); + size--; +} + +string Attribute::operator[](int i){ + return values[i]; +} + +vector Attribute::getValues(){ + return values; +} + +string Attribute::getName(){ + return name; +} + +void Attribute::setName(string s){ + name = s; +} + +void Attribute::setValue(string s, int index) +{ + values[index] = s; +} + +string Attribute::getType(){ + return type; +} + +bool Attribute::isKey(){ + return key; +} + +int Attribute::getSize(){ + return size; +} + +void Attribute::display(){ + cout << "-------------\n"; + cout << name << "\n" << type; + if(type == "VARCHAR") + { + cout << "(" << limit << ")"; + } + cout << "\n\n"; + + vector::iterator it = values.begin(); + while (it != values.end()){ + cout << *it << "\n"; + it++; + } + + cout << "-------------\n"; +} + +void Attribute::clearAllValues(){ + values.clear(); +} \ No newline at end of file diff --git a/Attribute.h b/Attribute.h new file mode 100755 index 0000000..46bd0b3 --- /dev/null +++ b/Attribute.h @@ -0,0 +1,31 @@ +#pragma once +#include +#include + +using namespace std; + +class Attribute{ + vector values; + string name; + string type; + bool key; + int size; + int limit; + +public: + Attribute(); + Attribute(string n, string t, bool k); + Attribute(string n, string t, bool k, int s); + void addCell(string v); + void removeCell(int index); + string operator[](int i); + vector getValues(); + string getName(); + void setName(string s); + void setValue(string s, int index); + string getType(); + bool isKey(); + int getSize(); + void display(); + void clearAllValues(); +}; \ No newline at end of file diff --git a/Condition.cpp b/Condition.cpp new file mode 100755 index 0000000..80e74b7 --- /dev/null +++ b/Condition.cpp @@ -0,0 +1,59 @@ +#include +#include "Attribute.h" +#include "Relation.h" + +using namespace std; + +Relation equality(string attName, string s, Relation r){ + Attribute att = r.getAttributeByName(attName); + vector r_atts = r.getAttributes(); + vector new_atts = r_atts; + + for (int i = 0; i < new_atts.size(); ++i) { + new_atts[i].clearAllValues(); + } + + for (int i = 0; i < att.getSize(); ++i) { + if (att[i] == s){ + for (int j = 0; j < r_atts.size(); ++j){ + new_atts[j].addCell(r_atts[j][i]); + } + } + } + + //currently all returned relations are called TEMP + Relation new_r("TEMP", new_atts); + return new_r; +} + +/* +vector equality(Attribute a, int i){ + for (int i = 0; i < a.getSize(); ++i) { + // + } +} + +vector gt(Attribute a, int i){ + for (int i = 0; i < a.getSize(); ++i) { + // + } +} + +vector lt(Attribute a, int i){ + for (int i = 0; i < a.getSize(); ++i) { + // + } +} + +vector gte(Attribute a, int i){ + for (int i = 0; i < a.getSize(); ++i) { + // + } +} + +vector lte(Attribute a, int i){ + for (int i = 0; i < a.getSize(); ++i) { + // + } +} +*/ diff --git a/Condition.h b/Condition.h new file mode 100755 index 0000000..51c031e --- /dev/null +++ b/Condition.h @@ -0,0 +1,7 @@ +#pragma once +#include "Relation.h" + +using namespace std; + +//currently only implementing for comparison +Relation equality(string attName, string s, Relation r); diff --git a/DBApp.cpp b/DBApp.cpp new file mode 100755 index 0000000..50c8918 --- /dev/null +++ b/DBApp.cpp @@ -0,0 +1,40 @@ +#include // std::string +#include // std::cout +#include // std::stringstream +#include +#include +#include "Parser.h" +#include "DBEngine.h" + +using namespace std; +/* +int main() +{ + cout << "**********************" << endl; + cout << "* Generic Restaurant *" << endl; + cout << "**********************" << endl; + cout << "- Login -" << endl; + cout << "1. Login" << endl; + cout << "2. Request new account" << endl; + cout << "Enter coice: "; + int n; + cin >> n; + string u; + string p; + switch(n) + { + case 1: cout << "- Login -" << endl; + cout << "Enter username: "; + cin >> u; + cout << "Enter password: "; + cin >> p; + // implement user database. + break; + case 2: cout << "Not implemented." << endl; + break; // not implemented. + default: cout << "Not an option." << endl; + return 0; + } + +} +*/ diff --git a/DBAppV2.cpp b/DBAppV2.cpp new file mode 100755 index 0000000..3b96c2b --- /dev/null +++ b/DBAppV2.cpp @@ -0,0 +1,126 @@ +#include + +using namespace std; + +/* + +void yourAccount() +{ + cout<<"name: yourName"<>choice; + cout<<"0. Return to main menu"<>choice; + cout<<"0. Return to main menu"<>choice; + cout<<"0. Return to main menu"<>choice; + cout<<"Boards will be displayed soon"<>choice; + cout<<"0. Return to main menu"<>choice; + cout<<"0. Return to main menu"<>choice; + + switch (choice) + { + case 1: yourAccount(); + case 2: BoardMenu(); + case 3: showMessages(); + case 4: showGroups(); + } +} + + +int main() +{ + cout<<"***************************************"<>choice; + + + if (choice == 1) + { + cout<<"ramera"< +#include +#include +#include "Condition.h" +#include "DBEngine.h" + +DBEngine::DBEngine(){ + size = 0; +} + +void DBEngine::createTable(string n){ + Relation r(n); + tables.push_back(r); + size++; +} + +void DBEngine::createTable(string n, vector a){ + Relation r(n, a); + tables.push_back(r); + size++; +} + +void DBEngine::createTable(Relation r){ + tables.push_back(r); + size++; +} + +void DBEngine::insertValues(string r, vector v) +{ + for(int i = 0; i < tables.size(); i++) + { + if (tables[i].getTableName() == r) + { + tables[i].insertTuple(v); + } + } +} + +void DBEngine::storeCommands(string s){ + commands.push_back(s); +} + +void DBEngine::save(){ + + ofstream file; + file.open("savefile.txt"); + + for(int i = 0; i < commands.size(); ++i){ + file << commands[i] << endl; + } + + file.close(); +} + +void DBEngine::deleteRelation(string n) +{ + // to conserve memory after closing a file. + for(int i = 0; i < tables.size(); i++) + { + if (tables[i].getTableName() == n) + { + tables.erase(tables.begin() + i); + } + } +} + +void DBEngine::save(string n){ + + ofstream file; + string name = n + ".txt"; + file.open(name); + + for(int i = 0; i < commands.size() - 1; ++i) + { + if(commands[i].substr(0, 4) == "SAVE") + { + continue; + } + if(commands[i].substr(0, 4) == "SHOW") + { + continue; + } + if(commands[i].substr(0, 4) == "OPEN") + { + continue; + } + if(commands[i].substr(0, 5) == "CLOSE") + { + continue; + } + else + { + file << commands[i] << endl; + } + } + + file.close(); +} + +vector DBEngine::getRelations(){ + return tables; +} + +bool DBEngine::isRelation(string n) +{ + for(int i = 0; i < tables.size(); i++) + { + if (tables[i].getTableName() == n) + { + return true; + } + } + return false; +} + +Relation& DBEngine::getTableFromName(string n) +{ + for(int i = 0; i < tables.size(); i++){ + if (tables[i].getTableName() == n){ + return tables[i]; + } + } + + cout << "FAILURE TO FIND: could not locate a Relation with this name."; + return tables[0]; +} + +Relation DBEngine::selection(string attName, string s, Relation r){ + return equality(attName, s, r); +} + +//assumes that all attribute titles are unique +Relation DBEngine::projection(vector input, Relation r){ + + vector v; + string new_name = r.getTableName() + " Projection"; + + for(int i = 0; i < input.size(); ++i) + { + for(int j = 0; j < r.getSize(); ++j) + { + if((r.getAttributes())[j].getName() == input[i]) + { + v.push_back((r.getAttributes())[j]); + } + } + } + + Relation temp(new_name, v); + return temp; +} + +//test error matching +Relation DBEngine::rename(vector newnames, Relation &r) +{ + vector temp; + if (r.getSize() != newnames.size()) { + cout << "FAILURE TO RENAME: number of attributes do not match.\n"; + exit(1); + } + else + { + temp = r.getAttributeNames(); + for(int i = 0; i < temp.size(); ++i) + { + r.renameAttribute(temp[i], newnames[i]); + } + return r; + } + +} + +Relation DBEngine::setUnion(Relation r1, Relation r2){ + if (r1.getAttributeNames() != r2.getAttributeNames()){ + cout << "Failure to union: the relations are not union-compatible.\nreturning the first relation.\n"; + return r1; + } + + else { + //currently all returned relations are called TEMP + Relation new_r = r1; + new_r.setTableName("TEMP"); + vector temp; + bool duplicate = false; + + for (int i = 0; i < r2.getAttributes()[0].getSize(); ++i) { + temp = r2.getTuple(i); + + for (int j = 0; j < new_r.getAttributes()[0].getSize(); ++j){ + if (temp == new_r.getTuple(j)){ + duplicate = true; + break; + } + } + + if (!duplicate) { + new_r.insertTuple(temp); + } + + duplicate = false; + } + + return new_r; + } +} + +Relation DBEngine::setDiff(Relation r1, Relation r2){ + if (r1.getAttributeNames() != r2.getAttributeNames()){ + cout << "Failure to diff: the relations are not union-compatible.\nreturning the first relation.\n"; + return r1; + } + + else { + //currently all returned relations are called TEMP + Relation new_r = r1; + new_r.setTableName("TEMP"); + vector temp; + //bool duplicate = false; + + int size = 0; + + + for(int x = 0; x < r2.getAttributes().size(); ++x) + { + + for (int i = 0; i < r2.getAttributes()[x].getSize(); ++i) + { + + temp = r2.getTuple(i); + + for(int y = 0; y < new_r.getAttributes().size(); ++y) + { + size = new_r.getAttributes()[y].getSize(); + new_r.getAttributes()[y].getSize(); + for (int j = 0; j < size; ++j) + { + for(int a = 0; a < temp.size(); ++a) + { + for(int b = 0; b < new_r.getTuple(j).size(); ++b) + { + if (temp[a] == new_r.getTuple(j)[b]) + { + new_r.removeFromTuple(b, j); + } + } + } + size = new_r.getAttributes()[y].getSize(); + } + } + } + } + return new_r; + } +} + +Relation DBEngine::crossProduct(Relation r1, Relation r2){ + vector new_atts = r1.getAttributes(); + int r1_attsize = r1.getAttributes()[0].getSize(); + int r2_attsize = r2.getAttributes()[0].getSize(); + + for (int i = 0; i < r2_attsize; ++i) { + new_atts.push_back(r2.getAttributes()[i]); + } + + for (int i = 0; i < new_atts.size(); ++i) { + new_atts[i].clearAllValues(); + } + + //currently all returned relations are called TEMP + Relation new_r("TEMP", new_atts); + + vector r1_tuple; + vector r2_tuple; + vector temp; + + for (int i = 0; i < r1_attsize; ++i) { + r1_tuple = r1.getTuple(i); + + for (int j = 0; j < r2_attsize; ++j) { + r2_tuple = r2.getTuple(j); + temp = r1_tuple; + temp.insert(temp.end(), r2_tuple.begin(), r2_tuple.end()); + + new_r.insertTuple(temp); + } + } + + + return new_r; +} diff --git a/DBEngine.h b/DBEngine.h new file mode 100755 index 0000000..ddbdd13 --- /dev/null +++ b/DBEngine.h @@ -0,0 +1,34 @@ +#pragma once +#include +#include +#include +#include "Relation.h" + +//still in progress +class DBEngine{ + vector tables; + vector commands; + int size; + +public: + DBEngine(); + void createTable(string n); + void createTable(string n, vector a); + void createTable(Relation r); + void insertValues(string r, vector v); + vector getRelations(); + bool isRelation(string n); + Relation& getTableFromName(string n); + void saveToFile(vector cmds); + Relation selection(string attName, string s, Relation r); + Relation projection(vector input, Relation r); + Relation product(string s1, Relation r1, Relation r2); + void deleteRelation(string n); + void save(); + void save(string n); + void storeCommands(string s); + Relation rename(vector newnames, Relation &r); + Relation setUnion(Relation r1, Relation r2); + Relation setDiff(Relation r1, Relation r2); + Relation crossProduct(Relation r1, Relation r2); +}; diff --git a/Parser.cpp b/Parser.cpp new file mode 100755 index 0000000..c41a61b --- /dev/null +++ b/Parser.cpp @@ -0,0 +1,1126 @@ +#include // std::string +#include // std::cout +#include // std::ofstream +#include // std::stringstream +#include +#include +#include "Parser.h" +#include + +using namespace std; + +vector tokenize(string ss) +{ + string tempString; + stringstream lineStream(ss); + vector output; + + while (lineStream >> tempString) + { + output.push_back(tempString); + } + return output; +} + +void displayTokenList(vector input) +{ + cout<<"TokenList: "< input, Relation &r, DBEngine &engine) +{ + Relation rfinal = r; + + Attribute a1 = r.getAttributeByName(input[0]); + input.erase(input.begin()); + string op = input[0]; + input.erase(input.begin()); + Attribute a2; + string c; + if(r.isAttribute(input[0])) + { + a2 = r.getAttributeByName(input[0]); + input.erase(input.begin()); + for(int i = 0; i < r.getAttributes().size(); ++i) + { + if(r.getAttributes()[i].getName() == a1.getName()) + { + int offset = 0; + if(op == "==") + { + for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x) + { + if(r.getAttributeByName(a1.getName()).getValues()[x] != r.getAttributeByName(a2.getName()).getValues()[x]) + { + rfinal.removeTuple(x - offset); + offset += 1; + } + } + } + else if(op == "!=") + { + for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x) + { + if(r.getAttributeByName(a1.getName()).getValues()[x] == r.getAttributeByName(a2.getName()).getValues()[x]) + { + rfinal.removeTuple(x - offset); + offset += 1; + } + } + } + else if(op == ">=") + { + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER") + { + for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) < stoi(r.getAttributeByName(a2.getName()).getValues()[x])) + { + rfinal.removeTuple(x - offset); + offset += 1; + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + else if(op == "<=") + { + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER") + { + for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) > stoi(r.getAttributeByName(a2.getName()).getValues()[x])) + { + rfinal.removeTuple(x - offset); + offset += 1; + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + else if(op == ">") + { + + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER") + { + for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) <= stoi(r.getAttributeByName(a2.getName()).getValues()[x])) + { + rfinal.removeTuple(x - offset); + offset += 1; + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + else if(op == "<") + { + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER") + { + for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) >= stoi(r.getAttributeByName(a2.getName()).getValues()[x])) + { + rfinal.removeTuple(x - offset); + offset += 1; + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + } + } + } + else if(input[0].at(0) == '\"') + { + c = input[0].substr(1, input[0].find_last_of("\"") - 1); + input.erase(input.begin()); + int offset = 0; + //input.erase(input.begin()); + if(op == "==") + { + for(int i = 0; i < r.getAttributes().size(); ++i) + { + if(r.getAttributes()[i].getName() == a1.getName()) + { + for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j) + { + if(r.getAttributeByName(a1.getName()).getValues()[j] != c) + { + rfinal.removeTuple(j - offset); + offset += 1; + } + } + } + } + } + else if(op == "!=") + { + for(int i = 0; i < r.getAttributes().size(); ++i) + { + if(r.getAttributes()[i].getName() == a1.getName()) + { + for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j) + { + if(r.getAttributeByName(a1.getName()).getValues()[j] == c) + { + rfinal.removeTuple(j - offset); + offset += 1; + } + } + } + } + } + else if(op == ">=") + { + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER") + { + for(int i = 0; i < r.getAttributes().size(); ++i) + { + if(r.getAttributes()[i].getName() == a1.getName()) + { + for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) < stoi(c)) + { + rfinal.removeTuple(j - offset); + offset += 1; + } + } + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + else if(op == "<=") + { + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER") + { + for(int i = 0; i < r.getAttributes().size(); ++i) + { + if(r.getAttributes()[i].getName() == a1.getName()) + { + for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) > stoi(c)) + { + rfinal.removeTuple(j - offset); + offset += 1; + } + } + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + else if(op == ">") + { + + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER") + { + for(int i = 0; i < r.getAttributes().size(); ++i) + { + if(r.getAttributes()[i].getName() == a1.getName()) + { + for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) <= stoi(c)) + { + rfinal.removeTuple(j - offset); + offset += 1; + } + } + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + else if(op == "<") + { + + if(r.getAttributeByName(a1.getName()).getType() == "INTEGER") + { + for(int i = 0; i < r.getAttributes().size(); ++i) + { + if(r.getAttributes()[i].getName() == a1.getName()) + { + for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j) + { + if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) >= stoi(c)) + { + rfinal.removeTuple(j - offset); + offset += 1; + } + } + } + } + } + else + { + cout << "Attribute type is not an INTEGER." << endl; + exit(1); + } + } + } + if(input[0] == "&&") + { + input.erase(input.begin()); + Relation rtemp = rfinal; + rfinal = condition(input, rtemp, engine); + } + else if(input[0] == "||") + { + input.erase(input.begin()); + Relation rtemp = rfinal; + Relation rtemp2 = condition(input, r, engine); + rfinal = engine.setUnion(rtemp, rtemp2); + } + return rfinal; +} + +tuple, Relation> expression(vector input, DBEngine &engine) +{ + Relation rfinal("TEMP"); + tuple, Relation> t(input, rfinal); + if(input[0] == "select") + { + input.erase(input.begin()); + vector s; + Relation r("TEMP"); + if(input[0] == "(") + { + input.erase(input.begin()); + while(input[0] != ")") + { + s.push_back(input[0]); + input.erase(input.begin()); + } + input.erase(input.begin()); + if(engine.isRelation(input[0])) + { + r = condition(s, engine.getTableFromName(input[0]), engine); + input.erase(input.begin()); + } + else if(input[0] == "(") + { + tuple, Relation> t = expression(input, engine); + r = condition(s, get<1>(t), engine); + input.erase(input.begin()); + } + } + get<0>(t) = input; + get<1>(t) = r; + return t; + } + + else if(input[0] == "project") + { + input.erase(input.begin()); + if(input[0] == "(") + { + input.erase(input.begin()); + vector temp; + while(input[0] != ")") + { + temp.push_back(input[0]); + input.erase(input.begin()); + } + input.erase(input.begin()); + Relation rfinal("TEMP"); + if(engine.isRelation(input[0])) + { + rfinal = engine.projection(temp, engine.getTableFromName(input[0])); + input.erase(input.begin()); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + t = expression(input, engine); + rfinal = engine.projection(temp, get<1>(t)); + get<1>(t) = rfinal; + return t; + } + } + else + { + cout << "Projection syntax incorrect." << endl; + exit(1); + } + } + + else if(input[0] == "rename") + { + input.erase(input.begin()); + if(input[0] == "(") + { + input.erase(input.begin()); + vector temp; + while(input[0] != ")") + { + if(input[0] == ",") + { + input.erase(input.begin()); + } + temp.push_back(input[0]); + input.erase(input.begin()); + } + input.erase(input.begin()); + Relation rfinal("TEMP"); + if(engine.isRelation(input[0])) + { + rfinal = engine.rename(temp, engine.getTableFromName(input[0])); + input.erase(input.begin()); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + input.erase(input.begin()); + t = expression(input, engine); + input.erase(input.begin()); + rfinal = engine.rename(temp, get<1>(t)); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + } + else + { + cout << "Rename syntax incorrect." << endl; + exit(1); + } + } + + else if(engine.isRelation(input[0])) + { + Relation r1(engine.getTableFromName(input[0])); + input.erase(input.begin()); + + if(input[0] == "+") + { + input.erase(input.begin()); + if(engine.isRelation(input[0])) + { + Relation r2(engine.getTableFromName(input[0])); + rfinal = engine.setUnion(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + tuple, Relation> t = expression(input, engine); + Relation r2 = get<1>(t); + rfinal = engine.setUnion(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + } + + else if(input[0] == "-") + { + input.erase(input.begin()); + if(engine.isRelation(input[0])) + { + Relation r2(engine.getTableFromName(input[0])); + rfinal = engine.setDiff(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + tuple, Relation> t = expression(input, engine); + Relation r2 = get<1>(t); + rfinal = engine.setDiff(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + } + + else if(input[0] == "*") + { + input.erase(input.begin()); + if(engine.isRelation(input[0])) + { + Relation r2(engine.getTableFromName(input[0])); + rfinal = engine.crossProduct(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + tuple, Relation> t = expression(input, engine); + Relation r2 = get<1>(t); + rfinal = engine.crossProduct(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + } + } + + else if(input[0] == "(") + { + input.erase(input.begin()); + + Relation r1(engine.getTableFromName(input[0])); + input.erase(input.begin()); + + if(input[0] == "+") + { + input.erase(input.begin()); + if(engine.isRelation(input[0])) + { + Relation r2(engine.getTableFromName(input[0])); + rfinal = engine.setUnion(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + tuple, Relation> t = expression(input, engine); + Relation r2 = get<1>(t); + rfinal = engine.setUnion(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + } + + else if(input[0] == "-") + { + input.erase(input.begin()); + if(engine.isRelation(input[0])) + { + Relation r2(engine.getTableFromName(input[0])); + rfinal = engine.setDiff(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + tuple, Relation> t = expression(input, engine); + Relation r2 = get<1>(t); + rfinal = engine.setDiff(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + } + + else if(input[0] == "*") + { + input.erase(input.begin()); + if(engine.isRelation(input[0])) + { + Relation r2(engine.getTableFromName(input[0])); + rfinal = engine.crossProduct(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + else if(input[0] == "(") + { + tuple, Relation> t = expression(input, engine); + Relation r2 = get<1>(t); + rfinal = engine.crossProduct(r1, r2); + get<0>(t) = input; + get<1>(t) = rfinal; + return t; + } + } + } + + get<0>(t) = input; + get<1>(t) = rfinal; + return t; +} + +vector showCMD(vector input, DBEngine &engine) +{ + + if(engine.isRelation(input[0])) + { + engine.getTableFromName(input[0]).display(); + input.erase(input.begin()); + } + + else + { + tuple, Relation> t = expression(input, engine); + get<1>(t).display(); + } + + return input; +} + +vector saveCMD(vector input, DBEngine &engine) +{ + if (input.size() > 2) + { + cout<<"Syntax error!"< closeCMD(vector input, DBEngine &engine) +{ + if (input.size() > 3) + { + cout<<"Syntax error!"< openCMD(vector input, DBEngine &engine) +{ + if (input.size() > 2) + { + cout<<"Syntax error!"< exitCMD(vector input, DBEngine &engine) +{ + + exit(0); + + return input; +} + + +vector createCMD(vector input, DBEngine &engine) +{ + + if (input[0] == "TABLE") + { + input.erase(input.begin()); + + PRelation r; + r.setPRelation(input[0]); + + input.erase(input.begin()); + + if(input[0] == "(") + { + input.erase(input.begin()); + + vector a; + + while(input[0] != ")") //inserting all values to relation + { + PAttribute temp; + + if (input[0] == ",") + { + input.erase(input.begin()); + } + + temp.setPAttributeName(input[0]); + + input.erase(input.begin()); + + if(input[0] == "INTEGER") + { + temp.setPAttributeType(input[0]); + input.erase(input.begin()); + } + else + { + temp.setPAttributeType(input[0].substr(0,input[0].find("("))); + temp.setPAttributeSize(stoi(input[0].substr(input[0].find("(") + 1, input[0].find(")")))); + input.erase(input.begin()); + } + + a.push_back(temp); + } + + if(input[0] == "PRIMARY" && input[1] == "KEY") + { + input.erase(input.begin()); + input.erase(input.begin()); + + if(input[0] == "(") + { + + while(input[0] != ")") //inserting all values to relation + { + + if (input[0] == ",") + { + input.erase(input.begin()); + } + + for(int i = 0; i < a.size(); ++i) + { + if(input[0] == a[i].getPAttribute()) + { + a[i].setPAttributeKey(); + } + } + + input.erase(input.begin()); + } + } + } + + vector dba; + + for(int x = 0; x < a.size(); ++x) + { + Attribute temp(a[x].getPAttribute(), a[x].getPAttributeType(), a[x].getPAttributeKey(), a[x].getPAttributeSize()); + dba.push_back(temp); + } + + engine.createTable(r.getName(), dba); + + return input; + } + + else cout<<"Syntax error! 2"< insertCMD(vector input, DBEngine &engine) +{ + //relation name will be the first element of the vector of data returned by this function + + if (input[0] == "INTO") + { + input.erase(input.begin()); + + PRelation pr(input[0]); + Relation r = engine.getTableFromName(input[0]); + + input.erase(input.begin()); + + vector s; + + if (input[0] == "VALUES" && input[1] == "FROM") + { + input.erase(input.begin()); + input.erase(input.begin()); + + + vector a = r.getAttributes(); + + if(input[0] == "(") + { + input.erase(input.begin()); + + for(int i = 0; i < a.size(); ++i) + { + if(a[i].getType() == "INTEGER") + { + if(input[0].at(0) == '\"') + { + cout << "Incorrect type matching. Tried to insert string." << endl; + cout << "The values should be: "; + for(int x = 0; x < a.size(); ++i) + { + cout << a[x].getType(); + if(a[x].getType() == "VARCHAR") + { + cout << "(" << a[x].getSize() << ")"; + } + cout << endl; + } + exit(1); + } + s.push_back(input[0]); + input.erase(input.begin()); + } + + else + { + if(input[0].at(0) == '\"') + { + s.push_back(input[0].substr(1,input[0].find_last_of("\"") - 1 )); + input.erase(input.begin()); + } + else + { + cout << "Incorrect type matching. Tried to insert integer." << endl; + cout << "The values should be: "; + for(int x = 0; x < a.size(); ++x) + { + cout << a[x].getType(); + if(a[x].getType() == "VARCHAR") + { + cout << "(" << a[x].getSize() << ")"; + } + cout << endl; + } + exit(1); + } + } + + if (input[0] == ",") + { + input.erase(input.begin()); + } + } + if(input[0] != ")") + { + cout << "Too many values trying to be inserted. Only insert " << a.size() << " values."; + cout << "The values should be: "; + for(int x = 0; x < a.size(); ++x) + { + cout << a[x].getType(); + if(a[x].getType() == "VARCHAR") + { + cout << "(" << a[x].getSize() << ")"; + } + cout << endl; + } + exit(1); + } + engine.insertValues(r.getTableName(), s); + input.erase(input.begin()); + return input; + } + + else if (input[0] == "RELATION") + { + input.erase(input.begin()); + + tuple, Relation> t = expression(input, engine); + vector a = get<1>(t).getAttributes(); + for(int y = 0; y < a[0].getSize(); ++y) + { + for(int x = 0; x < a.size(); ++x) + { + s.push_back(a[x].getValues()[y]); + engine.insertValues(r.getTableName(), s); + s.clear(); + } + } + + input = get<0>(t); + + return input; + } + + else cout<<"Syntax error! 3"< updateCMD(vector input, DBEngine &engine) +{ + Relation r = engine.getTableFromName(input[0]); + Relation rcond("TEMP"); + Relation rfinal("TEMP"); + + input.erase(input.begin()); + + if(input[0] == "SET") + { + input.erase(input.begin()); + vector a = r.getAttributes(); + + + //parse out ( and send everything until ) into an Expression vector + if(input[0] == "(") + { + + vector a; + PAttribute temp; + + vector s; + + //vector e; + + input.erase(input.begin()); + + while(input[0] != ")") + { + temp.setPAttributeName(input[0]); + + input.erase(input.begin()); + + if(input[0] == "=") + { + input.erase(input.begin()); + + s.push_back(input[0]); + + if(input[0].at(0) == '\"') + { + s.push_back(input[0].substr(1, input[0].find_last_of("\""))); + } + else + { + s.push_back(input[0]); + } + } + + else + { + cout<<"Syntax error! 2"< s; + if(input[0] == "(") + { + input.erase(input.begin()); + while(input[0] != ")") + { + s.push_back(input[0]); + input.erase(input.begin()); + } + rcond = condition(s, r, engine); + } + + } + + // send update command to DBEngine + } + + else cout<<"Syntax error! 1"< deleteCMD(vector input, DBEngine &engine) +{ + if (input[0] == "DELETE" && input[1] == "FROM") + { + input.erase(input.begin()); + input.erase(input.begin()); + + PRelation r(input[0]); + + if(input[0] == "WHERE") + { + if(input[0] == "(") + { + //PCondition c; + + PComparison c; + POperand oops1; + POperand oops2; + POp op; + + while(input[0] != ")") + { + oops1.setPOperand(input[0]); + input.erase(input.begin()); + + oops2.setPOperand(input[0]); + input.erase(input.begin()); + + op.setPOp(input[0]); + input.erase(input.begin()); + + c.setPComparison(oops1.getPOperand(), op.getPOp(), oops2.getPOperand()); + } + } + } + + // send delete command to DBEngine + } + else cout<<"Syntax error!"< query(vector input, DBEngine &engine) +{ + PRelation pr(input[0]); + + input.erase(input.begin()); + input.erase(input.begin()); + + tuple, Relation> t = expression(input, engine); + Relation r = get<1>(t); + r.setTableName(pr.getName()); + input = get<0>(t); + + engine.createTable(r); + + return input; +} + +void par_line(vector input, DBEngine &engine) //calls par_command() or par_query() depending on first item from token list +{ +/* +• Match the first item in the token list and determine weather this is a command or a query. +• Call functions par_command() or par_query(); +• After either par_command() or par_query() returns, make sure the line ends properly with “;” token +*/ + string tempChar = input.back(); + + if (tempChar != ";") + { + cout<<"ERROR! missing semicolon "< insertInput = insertCMD(input, engine); + + } + + else if ( input[0] == "CREATE") + { + cout<<"\nPassing the following arguments to dbEngine: \nCommand: "< insertInput = createCMD(input, engine); + + } + + else if ( input[0] == "DELETE") + { + cout<<"\nPassing the following arguments to dbEngine: \nCommand: "< insertInput = deleteCMD(input, engine); + + } + + else if ( input[0] == "UPDATE") + { + cout<<"\nPassing the following arguments to dbEngine: \nCommand: "< insertInput = updateCMD(input, engine); + + } + + else if ( input[0] == "SHOW") + { + cout<<"\nPassing the following arguments to dbEngine: \nCommand: "< listOfTokens = tokenize(input); + par_line(listOfTokens, engine); +} diff --git a/Parser.h b/Parser.h new file mode 100755 index 0000000..08f37da --- /dev/null +++ b/Parser.h @@ -0,0 +1,419 @@ +#include // std::string +#include // std::cout +#include // std::stringstream +#include +#include +#include "DBEngine.h" + +using namespace std; + +class PRelation +{ + string name; + + public: + PRelation() + { + name = "~"; + } + + PRelation(string str) + { + name = str; + } + + void setPRelation(string str) + { + name = str; + } + string getName() + { + return name; + } +}; + +class PAttribute +{ + string name; + string type; + bool key; + int size; + + public: + PAttribute() + { + name = "~"; + type = "~"; + key = false; + size = 0; + } + + PAttribute(string str, string t) + { + name = str; + type = t; + key = false; + size = 0; + } + + PAttribute(string str, string t, int s) + { + name = str; + type = t; + key = false; + size = s; + } + + void setPAttributeName(string str) + { + name = str; + } + + void setPAttributeType(string t) + { + type = t; + } + + void setPAttributeKey() + { + key = true; + } + + void setPAttributeSize(int s) + { + size = s; + } + + string getPAttribute() + { + return name; + } + + string getPAttributeType() + { + return type; + } + + bool getPAttributeKey() + { + return key; + } + + int getPAttributeSize() + { + return size; + } +}; + +class PUnion +{ + string Un1; + string Un2; + + public: + PUnion() + { + Un1 = "~"; + Un2 = "~"; + } + + PUnion (string s1, string s2) + { + Un1 = s1; + Un2 = s2; + } + + string getPUnion() + { + return "Union of " + Un1 + " and " + Un2; + } +}; + +class PProduct +{ + string Pr1; + string Pr2; + + public: + PProduct() + { + Pr1 = "~"; + Pr2 = "~"; + } + + PProduct(string s1, string s2) + { + Pr1 = s1; + Pr2 = s2; + } + + string getPProduct() + { + return "Product of " + Pr1 + " and " + Pr2; + } +}; + +class PDifference +{ + string D1; + string D2; + + public: + PDifference() + { + D1 = "~"; + D2 = "~"; + } + + PDifference(string s1, string s2) + { + D1 = s1; + D2 = s2; + } + + string getPDifference() + { + return "Difference of " + D1 + " and " + D2; + } +}; + +class PRenaming +{ + string newName; + string oldName; + + public: + PRenaming() + { + newName = "~"; + oldName = "~"; + } + + PRenaming(string s1, string s2) + { + newName = s1; + oldName = s2; + } + + string doRename() + { + return "Renaming " + oldName + " to " + newName; + } +}; + +class PProjection +{ + string newName; + string oldName; + + public: + PProjection() + { + newName = "~"; + oldName = "~"; + } + + PProjection(string s1, string s2) + { + newName = s1; + oldName = s2; + } + + string doPProjection() + { + return "Projecting " + oldName + " onto " + newName; + } +}; + +class POperand +{ + string op; + + public: + + POperand() + { + op = "~"; + } + + POperand(string str) + { + op = str; + } + + void setPOperand(string str) + { + op = str; + } + + string getPOperand() + { + return op; + } +}; + +class POp +{ + string op; + + public: + POp() + { + op = "~"; + } + + POp(string str) + { + op = str; + } + + void setPOp(string str) + { + op = str; + } + + string getPOp() + { + return op; + } +}; + +class PComparison +{ + POp op; + POperand operand1; + POperand operand2; + + public: + PComparison() + { + op.setPOp("~"); + operand1.setPOperand("~"); + operand2.setPOperand("~"); + } + + PComparison(string str1, string str2, string str3) + { + operand1.setPOperand(str1); + op.setPOp(str2); + operand2.setPOperand(str3); + } + + void setPComparison(string str1, string str2, string str3) + { + operand1.setPOperand(str1); + op.setPOp(str2); + operand2.setPOperand(str3); + } + + string getPComparison() + { + return operand1.getPOperand() + " " + op.getPOp() + " " + operand2.getPOperand(); + } +}; + +class PConjunction +{ + string conj; + public: + PConjunction() + { + conj = "~"; + } + + PConjunction(string str) + { + conj = str; + } + + void setPConjunction(string str) + { + conj = str; + } + + string getPConjunction() + { + return conj; + } +}; + +class PCondition +{ + string cond; + public: + + PCondition() + { + cond = "~"; + } + + PCondition(string str) + { + cond = str; + } + + void setPCondition(string str) + { + cond = str; + } + + string getPCondition() + { + return cond; + } +}; + +class PSelection +{ + string select; + public: + PSelection() + { + select = "~"; + } + + PSelection(string str) + { + select = str; + } + + string getPSelection() + { + return select; + } +}; + +class PExpression +{ + PRelation rel; + PSelection sel; + PProjection proj; + PRenaming ren; + PUnion un; + PDifference diff; + PProduct prod; + string temp; + + public: + + PExpression() + { + } + + PExpression(string str) + { + temp = str; + } + + void setPExpression(string str) + { + temp = str; + } + + string getPExpression() + { + return temp; + } +}; + +void parse(string s, DBEngine &e); \ No newline at end of file diff --git a/README.txt b/README.txt new file mode 100755 index 0000000..3357358 --- /dev/null +++ b/README.txt @@ -0,0 +1,40 @@ +//---IMPORTANT---// + +The function stoi() is used in the parser .cpp file to parse integers from the input. +When compiling things with the parser included, make sure you compile using: + +g++ -std=c++11 *.cpp + +ALSO, now that we are compiling into a standalone executable, compile using this command: + +g++ -o test -std=c++11 *.cpp + +"test" can be anything you want, but for now our executable is "test". + +//---------------// + +I changed the name of the repo. To make everything pretty, rename your working folder, and type this line: + + git remote set-url origin https://github.tamu.edu/USERNAME/DMS.git + +I also set up development branches for each of us. I think this is the way were supposed to have it, but this is my first GitHub project so Im not at all positive. +When beginning to work: + + git checkout beccadev + +This switches to your development branch. At any time, just type git status to see whats going on. +Before doing anything, type: + + git merge beccadev master + git push + +This updates your branch with the master branch, and pushes the update to GitHub. There is probably definitely a better way to do this. (Im pretty sure you can use git clone somehow) +Dont forgot to use git add filename.txt to add any files you want saved to git. Or just use git add * to grab them all. For some reason its making me do this every time I edit anything, which is weird. +Commit changes with git commit m something descriptive. + +If everything works the way youve anticipated and it compiles properly and completely done, return to master with git checkout master and merge: + + git merge master beccadev + +Type git push and youre done. + diff --git a/Relation.cpp b/Relation.cpp new file mode 100755 index 0000000..18a1277 --- /dev/null +++ b/Relation.cpp @@ -0,0 +1,154 @@ +#include +#include +#include "Relation.h" + +Relation::Relation(string n){ + name = n; + size = 0; +} + +Relation::Relation(string n, vector a){ + name = n; + att = a; + size = a.size(); +} + +void Relation::insertAttributes(vector a){ + for (int i = 0; i < a.size(); ++i){ + att.push_back(a[i]); + } +} + +string Relation::getTableName(){ + return name; +} + +void Relation::setTableName(string s){ + name = s; +} + +Attribute Relation::operator[](int i){ + return att[i]; +} + +vector Relation::getTuple(int index){ + vector temp; + + for (int i = 0; i < att.size(); ++i){ + temp.push_back(att[i][index]); + } + + return temp; +} + +vector Relation::getAttributes(){ + return att; +} + +vector Relation::getAttributeNames(){ + vector temp; + for(int i = 0; i < size; ++i){ + temp.push_back(att[i].getName()); + } + return temp; +} + +Attribute& Relation::getAttributeByName(string s) { + for(int i = 0; i < size; ++i){ + if (att[i].getName() == s) { + return att[i]; + } + } + + cout << "Failure to return: the requested attribute does not exist."; +} + +bool Relation::isAttribute(string s) { + for(int i = 0; i < size; ++i){ + if (att[i].getName() == s) { + return true; + } + } + return false; + //cout << "Failure to return: the requested attribute does not exist."; +} + +void Relation::renameAttribute(string oldstr, string newstr){ + this->getAttributeByName(oldstr).setName(newstr); +} + +int Relation::getSize(){ + return size; +} + +void Relation::display(){ + cout << "--------------------------\n"; + cout << getTableName() << "\n"; + for (int i = 0; i < att.size(); ++i){ + att[i].display(); + } + + cout << "--------------------------\n"; +} + +void Relation::insertTuple(vector tuple){ + if (tuple.size() != this->size) { + cout << "Failure to insert: the sizes do not match."; + } + + else { + for (int i = 0; i < att.size(); ++i) { + att[i].addCell(tuple[i]); + } + } +} + +void Relation::insertFromRelation(Relation r){ + if (r.size != this->size) { + cout << "Failure to insert: the sizes do not match."; + return; + } + + else if (this->getAttributeNames() != r.getAttributeNames()) { + cout << "Failure to insert: the attributes do not match."; + return; + } + + else { + vector newAtts = r.getAttributes(); + + for (int i = 0; i < newAtts.size(); ++i) { + for (int j = 0; j < newAtts[i].getSize(); ++j) { + this->att[i].addCell(newAtts[i][j]); + } + } + } +} + +void Relation::removeTuple(int index){ + if (index >= this->size) + { + cout << "Failure to delete: the requested index is out of bounds." << endl; + } + + else + { + for (int i = 0; i < att.size(); ++i) + { + att[i].removeCell(index); + } + } +} + +void Relation::removeFromTuple(int rindex, int aindex) +{ + if (rindex >= this->size) + { + cout << "Failure to delete: the requested index is out of bounds." << endl; + } + + else + { + att[rindex].removeCell(aindex); + } +} \ No newline at end of file diff --git a/Relation.h b/Relation.h new file mode 100755 index 0000000..4c7e1e2 --- /dev/null +++ b/Relation.h @@ -0,0 +1,30 @@ +#pragma once +#include +#include +#include "Attribute.h" + +class Relation{ + string name; + vector att; + int size; + +public: + Relation(string n); + Relation(string n, vector a); + void insertAttributes(vector a); + string getTableName(); + void setTableName(string s); + Attribute operator[](int i); + vector getTuple(int index); + vector getAttributes(); + vector getAttributeNames(); + Attribute& getAttributeByName(string s); + bool isAttribute(string s); + void renameAttribute(string oldstr, string newstr); + int getSize(); + void display(); + void insertTuple(vector tuple); //assuming they are in order + void insertFromRelation(Relation r); + void removeTuple(int index); + void removeFromTuple(int rindex, int aindex); +}; \ No newline at end of file diff --git a/a.out b/a.out new file mode 100755 index 0000000000000000000000000000000000000000..be293a62c534aa436816afb07fc40b7ff196a3e3 GIT binary patch literal 208930 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�VTQ^PCrAt?;1Uq+J2`4hfl*Q7HCKpLM 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 W0!mte(>C+_tXwfseLaKgPyZjGVZK)Y literal 0 HcmV?d00001 diff --git a/savefile.txt b/savefile.txt new file mode 100755 index 0000000..4a00946 --- /dev/null +++ b/savefile.txt @@ -0,0 +1,3 @@ +SHOW Food ; +SHOW MoarFood ; +SAVE ; diff --git a/test b/test new file mode 100755 index 0000000000000000000000000000000000000000..c4326f6aae22b4f460b47b1240cee392e6c6881a GIT binary patch literal 204297 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 IdbipC2am(`aR2}S literal 0 HcmV?d00001 diff --git a/test.cpp b/test.cpp new file mode 100755 index 0000000..d8b5f70 --- /dev/null +++ b/test.cpp @@ -0,0 +1,12 @@ +#include +#include +#include "Parser.h" +//#include "Condition.h" +#include "DBEngine.h" +#include "user.h" + +using namespace std; + +int main () { + +} diff --git a/user.cpp b/user.cpp new file mode 100755 index 0000000..fce7446 --- /dev/null +++ b/user.cpp @@ -0,0 +1,37 @@ +#include +#include +#include "user.h" + +User::User(){ + name = ""; + password = ""; + phone_number = ""; + fax_number = ""; + postal_address = ""; + is_admin = false; +} + +User::User(string n, string pass, string phone, string fax, string postal, bool admin){ + name = n; + password = pass; + phone_number = phone; + fax_number = fax; + postal_address = postal; + is_admin = admin; +} + +string User::getName() {return name;} +string User::getPassword() {return password;} +string User::getPhoneNumber() {return phone_number;} +string User::getFaxNumber() {return fax_number;} +string User::getPostalAddress() {return postal_address;} +bool User::confirmAdmin() {return is_admin;} +bool User::checkLogin() {return is_logged_in;} +vector User::getGroups(){return groups;} +vector User::getMessages(){return messages;} + +void User::setName(string new_name) {name = new_name;} +void User::setPassword(string new_password) {password = new_password;} +void User::setPhone(string new_phone) {phone_number = new_phone;} +void User::setFax(string new_fax) {fax_number = new_fax;} +void User::setPostal(string new_postal) {postal_address = new_postal;} diff --git a/user.h b/user.h new file mode 100755 index 0000000..c9dcfc8 --- /dev/null +++ b/user.h @@ -0,0 +1,44 @@ +#include +#include +#include + +class User { + string name; + string password; + string phone_number; + string fax_number; + string postal_address; + vector groups; + vector messages; + + bool is_admin; + bool is_logged_in; + +public: + User(); + User(string n, string pass, string phone, string fax, string postal, bool admin); + string getName(); + string getPassword(); + string getPhoneNumber(); + string getFaxNumber(); + string getPostalAddress(); + vector getGroups(); + vector getMessages(); + bool confirmAdmin(); + bool checkLogin(); + void setName(string new_name); + void setPassword(string new_name); + void setPhone(string new_phone); + void setFax(string new_fax); + void setPostal(string new_postal); +}; + +class Message { + string timestamp; + string text; + +public: + Message(); + Message(string time, string t); +}; +