diff options
Diffstat (limited to 'src/translators/pilotdb/libflatfile/Database.cpp')
| -rw-r--r-- | src/translators/pilotdb/libflatfile/Database.cpp | 331 |
1 files changed, 331 insertions, 0 deletions
diff --git a/src/translators/pilotdb/libflatfile/Database.cpp b/src/translators/pilotdb/libflatfile/Database.cpp new file mode 100644 index 0000000..578b82d --- /dev/null +++ b/src/translators/pilotdb/libflatfile/Database.cpp @@ -0,0 +1,331 @@ +/* + * palm-db-tools: Abstract adaptor for flat-file databases. + * Copyright (C) 1999-2000 by Tom Dyas (tdyas@users.sourceforge.net) + */ + +#include <iostream> +#include <sstream> +#include <stdexcept> +#include <sstream> +#include <utility> +#include <cctype> + +#include <kdebug.h> + +#include "Database.h" + +PalmLib::FlatFile::Database::Database(std::string p_Type, const PalmLib::Database& pdb) + : m_Type(p_Type) +{ + title(pdb.name()); + m_backup = pdb.backup(); + m_readonly = pdb.readonly(); + m_copy_prevention = pdb.copy_prevention(); +} + +void +PalmLib::FlatFile::Database::outputPDB(PalmLib::Database& pdb) const +{ + pdb.name(title()); + pdb.backup(m_backup); + pdb.readonly(m_readonly); + pdb.copy_prevention(m_copy_prevention); +} + +std::string +PalmLib::FlatFile::Database::title() const +{ + return m_title; +} + +void +PalmLib::FlatFile::Database::title(const std::string& title) +{ + m_title = title; +} + +unsigned +PalmLib::FlatFile::Database::getNumOfFields() const +{ + return m_fields.size(); +} + +std::string +PalmLib::FlatFile::Database::field_name(int i) const +{ + return m_fields[i].title(); +/* return m_fields[i].first;*/ +} + +PalmLib::FlatFile::Field::FieldType +PalmLib::FlatFile::Database::field_type(int i) const +{ + return m_fields[i].type(); +/* return m_fields[i].second;*/ +} + +PalmLib::FlatFile::FType +PalmLib::FlatFile::Database::field(int i) const +{ + return m_fields[i]; +} + +void +PalmLib::FlatFile::Database::appendField(PalmLib::FlatFile::FType field) +{ + if (! supportsFieldType(field.type())) { +// throw PalmLib::error("unsupported field type"); + kdDebug() << "unsupported field type" << endl; + return; + } + if (getMaxNumOfFields() != 0 && getNumOfFields() + 1 > getMaxNumOfFields()) { +// throw PalmLib::error("maximum number of fields reached"); + kdDebug() << "maximum number of fields reached" << endl; + return; + } + m_fields.push_back(field); +} + +void +PalmLib::FlatFile::Database::appendField(const std::string& name, + Field::FieldType type, std::string data) +{ + if (! supportsFieldType(type)) { + kdDebug() << "PalmLib::FlatFile::Database::appendField() - unsupported field type" << endl; + return; + } +// throw PalmLib::error("unsupported field type"); + if (getMaxNumOfFields() != 0 && getNumOfFields() + 1 > getMaxNumOfFields()) { + kdDebug() << "PalmLib::FlatFile::Database::appendField() - maximum number of fields reached" << endl; + return; + } +// throw PalmLib::error("maximum number of fields reached"); + +/* m_fields.push_back(std::make_pair(name, type));*/ +/* m_fields.push_back(PalmLib::FlatFile::make_ftype(name, type));*/ + m_fields.push_back(PalmLib::FlatFile::FType(name, type, data)); +} + +void +PalmLib::FlatFile::Database::insertField(int i, PalmLib::FlatFile::FType field) +{ + if (! supportsFieldType(field.type())) { +// throw PalmLib::error("unsupported field type"); + kdDebug() << "unsupported field type" << endl; + return; + } + if (getMaxNumOfFields() != 0 && getNumOfFields() + 1 > getMaxNumOfFields()) { +// throw PalmLib::error("maximum number of fields reached"); + kdDebug() << "maximum number of fields reached" << endl; + return; + } +/* m_fields.push_back(std::make_pair(name, type));*/ +/* m_fields.push_back(PalmLib::FlatFile::make_ftype(name, type));*/ + m_fields.insert(m_fields.begin() + i, field); +} + +void +PalmLib::FlatFile::Database::insertField(int i, const std::string& name, + Field::FieldType type, std::string data) +{ + if (! supportsFieldType(type)) { +// throw PalmLib::error("unsupported field type"); + kdDebug() << "unsupported field type" << endl; + return; + } + if (getMaxNumOfFields() != 0 && getNumOfFields() + 1 > getMaxNumOfFields()) { +// throw PalmLib::error("maximum number of fields reached"); + kdDebug() << "maximum number of fields reached" << endl; + return; + } +/* m_fields.push_back(std::make_pair(name, type));*/ +/* m_fields.push_back(PalmLib::FlatFile::make_ftype(name, type));*/ + m_fields.insert(m_fields.begin() + i, PalmLib::FlatFile::FType(name, type, data)); +} + +void +PalmLib::FlatFile::Database::removeField(int i) +{ + m_fields.erase(m_fields.begin() + i); +} + +unsigned +PalmLib::FlatFile::Database::getNumRecords() const +{ + return m_records.size(); +} + +PalmLib::FlatFile::Record +PalmLib::FlatFile::Database::getRecord(unsigned index) const +{ + if (index >= getNumRecords()) { + kdDebug() << "invalid index" << endl; + //throw std::out_of_range("invalid index"); + } + return m_records[index]; +} + +void +PalmLib::FlatFile::Database::appendRecord(PalmLib::FlatFile::Record rec) +{ + if (rec.fields().size() != getNumOfFields()) { +// throw PalmLib::error("the number of fields mismatch"); + kdDebug() << "the number of fields mismatch" << endl; + return; + } + for (unsigned int i = 0; i < getNumOfFields(); i++) { +#ifdef HAVE_VECTOR_AT + const Field field = rec.fields().at(i); +#else + const Field field = rec.fields()[i]; +#endif + if (field.type != field_type(i)) { + kdDebug() << "field " << i << " type " << field_type(i) << " mismatch: " << field.type << endl; + return; +// throw PalmLib::error(buffer.str()); + } + } + m_records.push_back(rec); +} + +void +PalmLib::FlatFile::Database::deleteRecord(unsigned index) +{ + m_records.erase(m_records.begin() + index); +} + +void +PalmLib::FlatFile::Database::clearRecords() +{ + m_records.clear(); +} + +unsigned +PalmLib::FlatFile::Database::getNumOfListViews() const +{ + return m_listviews.size(); +} + +PalmLib::FlatFile::ListView +PalmLib::FlatFile::Database::getListView(unsigned index) const +{ + return m_listviews[index]; +} + +void +PalmLib::FlatFile::Database::setListView(unsigned index, + const PalmLib::FlatFile::ListView& lv) +{ + // Ensure that the field numbers are within range. + for (PalmLib::FlatFile::ListView::const_iterator i = lv.begin(); + i != lv.end(); ++i) { + if ((*i).field >= getNumOfFields()) + return; + } + + m_listviews[index] = lv; +} + +void +PalmLib::FlatFile::Database::appendListView(const ListView& lv) +{ + // Enforce any limit of the maximum number of list views. + if (getMaxNumOfListViews() != 0 + && getNumOfListViews() + 1 > getMaxNumOfListViews()) + return; +// throw PalmLib::error("too many list views for this database type"); + + // Ensure that the field numbers are within range. + for (PalmLib::FlatFile::ListView::const_iterator i = lv.begin(); + i != lv.end(); ++i) { + if ((*i).field >= getNumOfFields()) + return; + } + m_listviews.push_back(lv); +} + +void +PalmLib::FlatFile::Database::removeListView(unsigned index) +{ + if (index < getNumOfListViews()) + m_listviews.erase( m_listviews.begin()+index); +} + +static void +strlower(std::string& str) +{ + for (std::string::iterator p = str.begin(); p != str.end(); ++p) { + if (isupper(*p)) + *p = tolower(*p); + } +} + +static bool +string2boolean(std::string str) +{ + strlower(str); + if (str == "on") + return true; + else if (str == "off") + return false; + else if (str == "true") + return true; + else if (str == "t") + return true; + else if (str == "false") + return false; + else if (str == "f") + return false; + else { + int num = 0; + + std::istringstream(str.c_str()) >> num; + return num != 0 ? true : false; + } +} + +void +PalmLib::FlatFile::Database::setOption(const std::string& name, + const std::string& value) +{ + if (name == "backup") + m_backup = string2boolean(value); + else if (name == "inROM") + m_readonly = string2boolean(value); + else if (name == "copy-prevention") + m_copy_prevention = string2boolean(value); +} + +PalmLib::FlatFile::Database::options_list_t +PalmLib::FlatFile::Database::getOptions() const +{ + PalmLib::FlatFile::Database::options_list_t set; + typedef PalmLib::FlatFile::Database::options_list_t::value_type value; + + if (m_backup) + set.push_back(value("backup", "true")); + else + set.push_back(value("backup", "false")); + + if (m_readonly) + set.push_back(value("inROM", "true")); + + if (m_copy_prevention) + set.push_back(value("copy-prevention", "true")); + + return set; +} + +void +PalmLib::FlatFile::Database::doneWithSchema() +{ + // Ensure that the database has at least one field. + if (getNumOfFields() == 0) + return; +// throw PalmLib::error("at least one field must be specified"); + + // Ensure that the database has a title. + if (title().empty()) + return; +// throw PalmLib::error("a title must be specified"); +} |