Skip to content

Commit

Permalink
g++ does not support template export
Browse files Browse the repository at this point in the history
  • Loading branch information
@vilarion
vilarion committed Jul 19, 2011
1 parent 21be981 commit 221e0e6
Show file tree
Hide file tree
Showing 8 changed files with 104 additions and 136 deletions.
89 changes: 0 additions & 89 deletions db/InsertQuery.cpp
View file
Expand Up @@ -49,95 +49,6 @@ InsertQuery::~InsertQuery() {
}
}

template <typename T> void InsertQuery::addValue(const QueryColumns::columnIndex &column, const T &value) throw(std::invalid_argument) {
addValues(column, value, 1);
}

template <typename T> void InsertQuery::addValues(const QueryColumns::columnIndex &column, const T &value, uint32_t count) throw(std::invalid_argument) {
if (count == 0) {
return;
}

uint32_t columns = getColumnCount();

if (columns <= column) {
throw new std::invalid_argument("Column index out of range.");
}

std::string strValue = quote<T>(value);
std::vector<std::string *> *dataRow;

if (!dataStorage.empty()) {
for (std::vector<std::vector<std::string *> *>::iterator itr = dataStorage.begin(); itr < dataStorage.end(); itr++) {
dataRow = *itr;
dataRow->reserve(columns);

if (!dataRow->at(column)) {
dataRow->at(column) = new std::string(strValue);

if (count <= 1) {
;
return;
} else if (count != FILL) {
count--;
}
}
}
}

if (count == FILL) {
return;
}

while (count-- > 0) {
dataRow = new std::vector<std::string *>(columns, 0);
dataStorage.push_back(dataRow);
dataRow->at(column) = new std::string(strValue);
}
}

template <typename T> void InsertQuery::addValues(const QueryColumns::columnIndex &column, std::vector<T> &values) throw(std::invalid_argument) {
typename std::vector<T>::iterator itr;
for (itr = values.begin(); itr < values.end(); itr++) {
addValue<T>(column, *itr);
}
}

template <typename Key, typename T, class Compare, class Allocator>
void InsertQuery::addValues(const QueryColumns::columnIndex &column,
std::map<Key, T, Compare, Allocator> &values,
MapInsertMode mode) throw(std::invalid_argument) {
typename std::map<Key, T, Compare, Allocator>::iterator itr;
for (itr = values.begin(); itr < values.end(); itr++) {
switch (mode) {
case onlyKeys:
addValue<Key>(column, itr->first);
break;
case onlyValues:
addValue<T>(column, itr->second);
break;
case keysAndValues:
addValue<Key>(column, itr->first);
addValue<T>(column + 1, itr->second);
break;
}
}
}

template <typename Key, typename T, class Compare>
void InsertQuery::addValues(const QueryColumns::columnIndex &column,
std::map<Key, T, Compare> &values,
MapInsertMode mode) throw(std::invalid_argument) {
addValues<Key, T, Compare, std::allocator<std::pair<const Key, T> > >(column, values);
}

template <typename Key, typename T>
void InsertQuery::addValues(const QueryColumns::columnIndex &column,
std::map<Key, T> &values,
MapInsertMode mode) throw(std::invalid_argument) {
addValues<Key, T, std::less<Key> >(column, values);
}

Result InsertQuery::execute() {
std::stringstream ss;
ss << "INSERT INTO ";
Expand Down
85 changes: 79 additions & 6 deletions db/InsertQuery.hpp
View file
Expand Up @@ -49,20 +49,93 @@ class InsertQuery : public virtual QueryColumns, public virtual QueryTables {
InsertQuery(const PConnection connection);
virtual ~InsertQuery();

template <typename T> void addValue(const QueryColumns::columnIndex &column, const T &value) throw(std::invalid_argument);
template <typename T> void addValues(const QueryColumns::columnIndex &column, const T &value, uint32_t count) throw(std::invalid_argument);
template <typename T> void addValues(const QueryColumns::columnIndex &column, std::vector<T> &values) throw(std::invalid_argument);
template <typename T> void addValue(const QueryColumns::columnIndex &column, const T &value) throw(std::invalid_argument) {
addValues(column, value, 1);
};

template <typename T> void addValues(const QueryColumns::columnIndex &column, const T &value, uint32_t count) throw(std::invalid_argument) {
if (count == 0) {
return;
}

uint32_t columns = getColumnCount();

if (columns <= column) {
throw new std::invalid_argument("Column index out of range.");
}

std::string strValue = quote<T>(value);
std::vector<std::string *> *dataRow;

if (!dataStorage.empty()) {
for (std::vector<std::vector<std::string *> *>::iterator itr = dataStorage.begin(); itr < dataStorage.end(); itr++) {
dataRow = *itr;
dataRow->reserve(columns);

if (!dataRow->at(column)) {
dataRow->at(column) = new std::string(strValue);

if (count <= 1) {
;
return;
} else if (count != FILL) {
count--;
}
}
}
}

if (count == FILL) {
return;
}

while (count-- > 0) {
dataRow = new std::vector<std::string *>(columns, 0);
dataStorage.push_back(dataRow);
dataRow->at(column) = new std::string(strValue);
}
};

template <typename T> void addValues(const QueryColumns::columnIndex &column, std::vector<T> &values) throw(std::invalid_argument) {
typename std::vector<T>::iterator itr;
for (itr = values.begin(); itr < values.end(); itr++) {
addValue<T>(column, *itr);
}
};

template <typename Key, typename T>
void addValues(const QueryColumns::columnIndex &column, std::map<Key,T> &values,
MapInsertMode mode = keysAndValues) throw(std::invalid_argument);
MapInsertMode mode = keysAndValues) throw(std::invalid_argument) {
addValues<Key, T, std::less<Key> >(column, values);
};

template <typename Key, typename T, class Compare>
void addValues(const QueryColumns::columnIndex &column,
std::map<Key,T,Compare> &values,
MapInsertMode mode = keysAndValues) throw(std::invalid_argument);
MapInsertMode mode = keysAndValues) throw(std::invalid_argument) {
addValues<Key, T, Compare, std::allocator<std::pair<const Key, T> > >(column, values);
};

template <typename Key, typename T, class Compare,class Allocator>
void addValues(const QueryColumns::columnIndex &column,
std::map<Key,T,Compare, Allocator> &values,
MapInsertMode mode = keysAndValues) throw(std::invalid_argument);
MapInsertMode mode = keysAndValues) throw(std::invalid_argument) {
typename std::map<Key, T, Compare, Allocator>::iterator itr;
for (itr = values.begin(); itr != values.end(); itr++) {
switch (mode) {
case onlyKeys:
addValue<Key>(column, itr->first);
break;
case onlyValues:
addValue<T>(column, itr->second);
break;
case keysAndValues:
addValue<Key>(column, itr->first);
addValue<T>(column + 1, itr->second);
break;
}
}
};

virtual Result execute();
private:
Expand Down
4 changes: 0 additions & 4 deletions db/Query.cpp
View file
Expand Up @@ -76,10 +76,6 @@ PConnection Query::getConnection() {
return dbConnection;
}

template <typename T> std::string Query::quote(T value) {
return dbConnection.quote<T>(value);
}

std::string Query::escapeKey(const std::string &key) {
if (key.at(0) == '"' && key.at(key.length() - 1) == '"' && !key.empty()) {
return key;
Expand Down
4 changes: 3 additions & 1 deletion db/Query.hpp
View file
Expand Up @@ -48,7 +48,9 @@ class Query {

void setQuery(const std::string &query);
PConnection getConnection();
template <typename T> std::string quote(T value);
template <typename T> std::string quote(T value) {
return dbConnection->quote<T>(value);
};
private:
Query(const Query &org);
};
Expand Down
10 changes: 0 additions & 10 deletions db/QueryAssign.cpp
View file
Expand Up @@ -31,16 +31,6 @@ QueryAssign::QueryAssign(const QueryAssign &org) {
QueryAssign::QueryAssign(const PConnection connection) : Query(connection) {
};

template<typename T>
void QueryAssign::addAssignColumn(const std::string &column, const T &value) {
addAssignColumn<T>("", column, value);
}

template<typename T>
void QueryAssign::addAssignColumn(const std::string &table, const std::string &column, const T &value) {
appendToStringList(assignColumns, escapeAndChainKeys(table, column) + " = " + quote<T>(value));
}

void QueryAssign::addAssignColumnNull(const std::string &column) {
addAssignColumnNull("", column);
}
Expand Down
9 changes: 7 additions & 2 deletions db/QueryAssign.hpp
View file
Expand Up @@ -32,8 +32,13 @@ class QueryAssign : public virtual Query {
std::string assignColumns;

public:
template<typename T> void addAssignColumn(const std::string &column, const T &value);
template<typename T> void addAssignColumn(const std::string &table, const std::string &column, const T &value);
template<typename T> void addAssignColumn(const std::string &column, const T &value) {
addAssignColumn<T>("", column, value);
};

template<typename T> void addAssignColumn(const std::string &table, const std::string &column, const T &value) {
appendToStringList(assignColumns, escapeAndChainKeys(table, column) + " = " + quote<T>(value));
};

void addAssignColumnNull(const std::string &column);
void addAssignColumnNull(const std::string &table, const std::string &column);
Expand Down
20 changes: 0 additions & 20 deletions db/QueryWhere.cpp
View file
Expand Up @@ -38,26 +38,6 @@ QueryWhere::~QueryWhere() {
}
}

template<typename T>
void QueryWhere::addEqualCondition(const std::string &column, const T &value) {
addEqualCondition<T>("", column, value);
}

template<typename T>
void QueryWhere::addEqualCondition(const std::string &table, const std::string &column, const T &value) {
conditionsStack.push(new std::string(escapeAndChainKeys(table, column) + " = " + quote<T>(value)));
}

template<typename T>
void QueryWhere::addNotEqualCondition(const std::string &column, const T &value) {
addNotEqualCondition<T>("", column, value);
}

template<typename T>
void QueryWhere::addNotEqualCondition(const std::string &table, const std::string &column, const T &value) {
conditionsStack.push(new std::string(escapeAndChainKeys(table, column) + " != " + quote<T>(value)));
}

void QueryWhere::andConditions() {
mergeConditions("AND");
}
Expand Down
19 changes: 15 additions & 4 deletions db/QueryWhere.hpp
View file
Expand Up @@ -36,10 +36,21 @@ class QueryWhere : public virtual Query {
std::string conditions;

public:
template<typename T> void addEqualCondition(const std::string &column, const T &value);
template<typename T> void addEqualCondition(const std::string &table, const std::string &column, const T &value);
template<typename T> void addNotEqualCondition(const std::string &column, const T &value);
template<typename T> void addNotEqualCondition(const std::string &table, const std::string &column, const T &value);
template<typename T> void addEqualCondition(const std::string &column, const T &value) {
addEqualCondition<T>("", column, value);
};

template<typename T> void addEqualCondition(const std::string &table, const std::string &column, const T &value) {
conditionsStack.push(new std::string(escapeAndChainKeys(table, column) + " = " + quote<T>(value)));
};

template<typename T> void addNotEqualCondition(const std::string &column, const T &value) {
addNotEqualCondition<T>("", column, value);
};

template<typename T> void addNotEqualCondition(const std::string &table, const std::string &column, const T &value) {
conditionsStack.push(new std::string(escapeAndChainKeys(table, column) + " != " + quote<T>(value)));
};

void andConditions();
void orConditions();
Expand Down

0 comments on commit 221e0e6

Please sign in to comment.