bool readXML(map<string, Table>& tables) { TiXmlDocument *myDoc = new TiXmlDocument("information.xml"); if (!myDoc->LoadFile()) { cout << myDoc->ErrorDesc() << endl; return false; } else myDoc->LoadFile(); TiXmlElement* root = myDoc->RootElement(); //the first layer loop for (TiXmlNode* firstNode = root->FirstChild(); firstNode; firstNode = firstNode->NextSibling()) { Table tmpTable; if (strcmp(firstNode->Value(), "class") == 0) { //the second layer loop for (TiXmlNode *secondNode = firstNode->FirstChild(); secondNode; secondNode = secondNode->NextSibling()) { if (strcmp(secondNode->Value(), "class_name") == 0) { tmpTable.setTableName(secondNode->FirstChild()->Value()); } else if (strcmp(secondNode->Value(), "attribute") == 0) { Attribute tmpAttribute; for (TiXmlNode *thirdNode = secondNode->FirstChild(); thirdNode; thirdNode = thirdNode->NextSibling()) { if (strcmp(thirdNode->Value(), "attribute_name") == 0) { if (thirdNode->FirstChild() != 0) tmpAttribute.name = thirdNode->FirstChild()->Value(); string name = tmpTable.getTableName(); string newName = name.substr(0,2) + '_'; newName += tmpAttribute.name; tmpAttribute.name = newName; } else if (strcmp(thirdNode->Value(), "identifier") == 0) { if (thirdNode->FirstChild() != 0) { tmpAttribute.id = thirdNode->FirstChild()->Value(); } } else if (strcmp(thirdNode->Value(), "multiplicity") == 0) { if (thirdNode->FirstChild() != 0) tmpAttribute.multiplicity = thirdNode->FirstChild()->Value(); } } tmpTable.setAttribute(tmpAttribute); } } tables.insert(make_pair(tmpTable.getTableName(), tmpTable)); } else if (strcmp(firstNode->Value(), "association") == 0) { Association tmpAssociation; for (TiXmlNode *secondNode = firstNode->FirstChild(); secondNode; secondNode = secondNode->NextSibling()) { if (strcmp(secondNode->Value(), "nameOfAssociation") == 0) { if (secondNode->FirstChild() != 0) tmpAssociation.nameOfAssociation = secondNode->FirstChild()->Value(); } else if (strcmp(secondNode->Value(), "class") == 0) { Association_class tableValue; for (TiXmlNode *thirdNode = secondNode->FirstChild(); thirdNode; thirdNode = thirdNode->NextSibling()) { if (strcmp(thirdNode->Value(), "class_name") == 0) { if (thirdNode->FirstChild() != 0) tableValue.name = thirdNode->FirstChild()->Value(); } else if (strcmp(thirdNode->Value(), "multiplicity") == 0) { if (thirdNode->FirstChild() != 0) tableValue.multiplicity = thirdNode->FirstChild()->Value(); } else if (strcmp(thirdNode->Value(), "role") == 0) { if (thirdNode->FirstChild() != 0) tableValue.role = thirdNode->FirstChild()->Value(); } else { if (thirdNode->FirstChild() != 0) tableValue.qualification.push_back(thirdNode-> FirstChild()->Value()); } } tmpAssociation.startTable = tableValue; } else if (strcmp(secondNode->Value(), "other_class") == 0) { Association_class tableValue; for (TiXmlNode *thirdNode = secondNode->FirstChild(); thirdNode; thirdNode = thirdNode->NextSibling()) { if (strcmp(thirdNode->Value(), "class_name") == 0) { tableValue.name = thirdNode->FirstChild()->Value(); } else if (strcmp(thirdNode->Value(), "multiplicity") == 0) { if (thirdNode->FirstChild() != 0) tableValue.multiplicity = thirdNode->FirstChild()->Value(); } else if (strcmp(thirdNode->Value(), "role") == 0) { if (thirdNode->FirstChild() != 0) tableValue.role = thirdNode->FirstChild()->Value(); } else { if (thirdNode->FirstChild() != 0) tableValue.qualification.push_back(thirdNode-> FirstChild()->Value()); } } tmpAssociation.anotherTable = tableValue; } else if (strcmp(secondNode->Value(), "Link") == 0) { Linker tmpLink; TiXmlNode* thirdNode = secondNode->FirstChild(); for (; thirdNode; thirdNode = thirdNode->NextSibling()) { if (strcmp(thirdNode->Value(), "link_attribute") == 0 && thirdNode->FirstChild() != 0) { TiXmlNode* forthNode = thirdNode->FirstChild(); for (; forthNode; forthNode = forthNode->NextSibling()) { if (forthNode->FirstChild() != NULL) tmpLink.attributes.push_back(forthNode->FirstChild() ->Value()); } } else if (strcmp(thirdNode->Value(), "association_class") == 0 && thirdNode->FirstChild() != 0) { TiXmlNode* forthNode = thirdNode->FirstChild(); for (; forthNode; forthNode = forthNode->NextSibling()) { if (strcmp(forthNode->Value(), "nameOfAssociationClass") == 0) { if (strlen(forthNode->FirstChild()->Value()) > 0) { if (forthNode->FirstChild() != 0) tmpLink.nameOfAssociationClass = forthNode->FirstChild() ->Value(); } } else if (strcmp(forthNode->Value(), "qualification") == 0) { if (strlen(forthNode->FirstChild()->Value()) > 0) { if (forthNode->FirstChild() != 0) tmpLink.qualification.push_back(forthNode->FirstChild() ->Value()); } } } } } if (tmpLink.attributes.size() != 0 || tmpLink.nameOfAssociationClass != "" || tmpLink.qualification.size() != 0) { tmpAssociation.link = tmpLink; } } } map<string, Table>::iterator tableIte = tables.find(tmpAssociation. startTable.name); if (tableIte != tables.end()) { tableIte->second.setAssociation(tmpAssociation); tableIte->second.setHasLink(true); tableIte = tables.find(tmpAssociation.anotherTable.name); tableIte->second.setHasLink(true); } else { cerr << "There is no table in this database."; } } else if (strcmp(firstNode->Value(), "generlisation") == 0) { TiXmlNode* secondNode = firstNode->FirstChild(); Generalisation tmpGeneralisation; vector<string> tmpClassName; for (; secondNode; secondNode = secondNode->NextSibling()) { if (strcmp(secondNode->Value(), "class_name") == 0) { if (secondNode->FirstChild() != 0) tmpClassName.push_back(secondNode->FirstChild()->Value()); } else if (strcmp(secondNode->Value(), "ISA") == 0) { if (secondNode->FirstChild() != 0) tmpGeneralisation.ISA = secondNode->FirstChild()->Value(); } else if (strcmp(secondNode->Value(), "generalisation") == 0) { if (secondNode->FirstChild() != 0) tmpGeneralisation.type = secondNode->FirstChild()->Value(); } } vector<string>::iterator classNameIter = tmpClassName.begin(); while(classNameIter != tmpClassName.end()){ tmpGeneralisation.className = *classNameIter; map<string, Table>::iterator tableIte = tables.find(tmpGeneralisation.className); if (tableIte != tables.end()) { tableIte->second.setGeneralisation(tmpGeneralisation); } else { cerr << "There is no table in this database."; } classNameIter++; } } } return true; }
void translate(Table& envT, Table& userT) { enum QueueType { UNKNOWN = -1, SLURM = 1, SGE, SLURM_TACC, PBS, LSF }; QueueType queueType = UNKNOWN; // Pick type of queuing system. if (envT.count("SGE_ACCOUNT")) queueType = SGE; else if (envT.count("SLURM_TACC_ACCOUNT") || envT.count("SLURM_TACC_JOBNAME")) queueType = SLURM_TACC; else if (envT.count("SBATCH_ACCOUNT")) queueType = SLURM; else if (envT.count("PBS_JOBID")) queueType = PBS; else if (envT.count("LSF_VERSION")) queueType = LSF; // Now fill in num_cores, num_nodes, account, job_id, queue, submit_host in userT from the environment if (queueType == SGE) { userT["num_cores"] = safe_get(userT, "num_tasks", "1"); userT["num_nodes"] = safe_get(envT, "NHOSTS", "1"); userT["account"] = safe_get(envT, "SGE_ACCOUNT", "unknown"); userT["job_id"] = safe_get(envT, "JOB_ID", "unknown"); userT["queue"] = safe_get(envT, "QUEUE", "unknown"); userT["submit_host"] = "unknown"; } else if (queueType == SLURM_TACC || queueType == SLURM ) { userT["num_cores"] = safe_get(userT, "num_tasks", "1"); userT["num_nodes"] = safe_get(envT, "SLURM_NNODES", "1"); userT["job_id"] = safe_get(envT, "SLURM_JOB_ID", "unknown"); userT["queue"] = safe_get(envT, "SLURM_QUEUE", "unknown"); userT["submit_host"] = safe_get(envT, "SLURM_SUBMIT_HOST", "unknown"); if (queueType == SLURM_TACC) userT["account"] = safe_get(envT, "SLURM_TACC_ACCOUNT", "unknown"); } else if (queueType == PBS) { userT["num_cores"] = safe_get(userT, "num_tasks", "1"); userT["num_nodes"] = safe_get(envT, "PBS_NUM_NODES", "1"); userT["job_id"] = safe_get(envT, "PBS_JOBID", "unknown"); userT["queue"] = safe_get(envT, "PBS_QUEUE", "unknown"); userT["submit_host"] = safe_get(envT, "PBS_O_HOST", "unknown"); userT["account"] = safe_get(envT, "PBS_ACCOUNT", "unknown"); } else if (queueType == LSF) { // We must count the number of "words" in mcpuA. // We find the number of words by counting space blocks and add 1; // then divide by 2. then convert to a string. std::string mcpuA = safe_get(envT, "LSB_MCPU_HOSTS", "a 1"); std::string::size_type idx; int count = 1; idx = 0; while (1) { idx = mcpuA.find(" ",idx); if (idx == std::string::npos) break; count++; idx = mcpuA.find_first_not_of(" ",idx+1); } count /= 2; std::ostringstream sstream; sstream << count; userT["num_cores"] = safe_get(userT, "num_tasks", "1"); userT["num_nodes"] = sstream.str(); userT["job_id"] = safe_get(envT, "LSB_JOBID", "unknown"); userT["queue"] = safe_get(envT, "LSB_QUEUE", "unknown"); userT["submit_host"] = safe_get(envT, "LSB_EXEC_CLUSTER", "unknown"); userT["account"] = "unknown"; } else { userT["num_cores"] = "1"; userT["num_nodes"] = "1"; userT["job_id"] = "unknown"; userT["queue"] = "unknown"; userT["submit_host"] = "unknown"; userT["account"] = "unknown"; } }
void print_system_meminfo() { // We can't use sysinfo() here because iit doesn't tell us how much cached // memory we're using. (On B2G, this is often upwards of 30mb.) // // Instead, we have to parse /proc/meminfo. FILE* meminfo = fopen("/proc/meminfo", "r"); if (!meminfo) { perror("Couldn't open /proc/meminfo"); return; } // These are all in kb. int total = -1; int free = -1; int buffers = -1; int cached = -1; int swap_total = -1; int swap_free = -1; int swap_cached = -1; char line[256]; while(fgets(line, sizeof(line), meminfo)) { int val; if (sscanf(line, "MemTotal: %d kB", &val) == 1) { total = val; } else if (sscanf(line, "MemFree: %d kB", &val) == 1) { free = val; } else if (sscanf(line, "Buffers: %d kB", &val) == 1) { buffers = val; } else if (sscanf(line, "Cached: %d kB", &val) == 1) { cached = val; } else if (sscanf(line, "SwapTotal: %d kB", &val) == 1) { swap_total = val; } else if (sscanf(line, "SwapFree: %d kB", &val) == 1) { swap_free = val; } else if (sscanf(line, "SwapCached: %d kB", &val) == 1) { swap_cached = val; } } fclose(meminfo); if (total == -1 || free == -1 || buffers == -1 || cached == -1 || swap_total == -1 || swap_free == -1 || swap_cached == -1) { fprintf(stderr, "Unable to parse /proc/meminfo.\n"); return; } int actually_used = total - free - buffers - cached - swap_cached; puts("System memory info:\n"); Table t; t.start_row(); t.add("Total"); t.add_fmt("%0.1f MB", kb_to_mb(total)); t.start_row(); t.add("SwapTotal"); t.add_fmt("%0.1f MB", kb_to_mb(swap_total)); t.start_row(); t.add("Used - cache"); t.add_fmt("%0.1f MB", kb_to_mb(total - free - buffers - cached - swap_cached)); t.start_row(); t.add("B2G procs (PSS)"); int b2g_mem_kb = 0; for (vector<Process*>::const_iterator it = ProcessList::singleton().b2g_processes().begin(); it != ProcessList::singleton().b2g_processes().end(); ++it) { b2g_mem_kb += (*it)->pss_kb(); } t.add_fmt("%0.1f MB", b2g_mem_kb / 1024.0); t.start_row(); t.add("Non-B2G procs"); t.add_fmt("%0.1f MB", kb_to_mb(total - free - buffers - cached - b2g_mem_kb - swap_cached)); t.start_row(); t.add("Free + cache"); t.add_fmt("%0.1f MB", kb_to_mb(free + buffers + cached + swap_cached)); t.start_row(); t.add("Free"); t.add_fmt("%0.1f MB", kb_to_mb(free)); t.start_row(); t.add("Cache"); t.add_fmt("%0.1f MB", kb_to_mb(buffers + cached + swap_cached)); t.start_row(); t.add("SwapFree"); t.add_fmt("%0.1f MB", kb_to_mb(swap_free)); t.print_with_indent(2); }
void MeshAlg::weldBoundaryEdges( Array<Face>& faceArray, Array<Edge>& edgeArray, Array<Vertex>& vertexArray) { // Copy over the original edge array Array<Edge> oldEdgeArray = edgeArray; // newEdgeIndex[e] is the new index of the old edge with index e // Note that newEdgeIndex[e] might be negative, indicating that // the edge switched direction between the arrays. Array<int> newEdgeIndex; newEdgeIndex.resize(edgeArray.size()); edgeArray.resize(0); // boundaryEdgeIndices[v_low] is an array of the indices of // all boundary edges whose lower vertex is v_low. Table<int, Array<int> > boundaryEdgeIndices; // Copy over non-boundary edges to the new array for (int e = 0; e < oldEdgeArray.size(); ++e) { if (oldEdgeArray[e].boundary()) { // Add to the boundary table const int v_low = iMin(oldEdgeArray[e].vertexIndex[0], oldEdgeArray[e].vertexIndex[1]); if (! boundaryEdgeIndices.containsKey(v_low)) { boundaryEdgeIndices.set(v_low, Array<int>()); } boundaryEdgeIndices[v_low].append(e); // We'll fill out newEdgeIndex[e] later, when we find pairs } else { // Copy the edge to the new array newEdgeIndex[e] = edgeArray.size(); edgeArray.append(oldEdgeArray[e]); } } // Remove all edges from the table that have pairs. Table<int, Array<int> >::Iterator cur = boundaryEdgeIndices.begin(); Table<int, Array<int> >::Iterator end = boundaryEdgeIndices.end(); while (cur != end) { Array<int>& boundaryEdge = cur->value; for (int i = 0; i < boundaryEdge.size(); ++i) { int ei = boundaryEdge[i]; const Edge& edgei = oldEdgeArray[ei]; for (int j = i + 1; j < boundaryEdge.size(); ++j) { int ej = boundaryEdge[j]; const Edge& edgej = oldEdgeArray[ej]; // See if edge ei is the reverse (match) of edge ej. // True if the edges match bool match = false; // True if edgej's vertex indices are reversed from // edgei's (usually true). bool reversej = false; int u = edgei.vertexIndex[0]; int v = edgei.vertexIndex[1]; if (edgei.faceIndex[0] != Face::NONE) { // verts|faces // edgei = [u v A /] if (edgej.faceIndex[0] != Face::NONE) { if ((edgej.vertexIndex[0] == v) && (edgej.vertexIndex[1] == u)) { // This is the most common of the four cases // edgej = [v u B /] match = true; reversej = true; } } else { if ((edgej.vertexIndex[0] == u) && (edgej.vertexIndex[1] == v)) { // edgej = [u v / B] match = true; } } } else { // edgei = [u v / A] if (edgej.faceIndex[0] != Face::NONE) { if ((edgej.vertexIndex[0] == u) && (edgej.vertexIndex[1] == v)) { // edgej = [u v B /] match = true; } } else { if ((edgej.vertexIndex[0] == v) && (edgej.vertexIndex[1] == u)) { // edgej = [v u / B] match = true; reversej = true; } } } if (match) { // ei and ej can be paired as a single edge int e = edgeArray.size(); Edge& edge = edgeArray.next(); // Follow the direction of edgei. edge = edgei; newEdgeIndex[ei] = e; // Insert the face index for edgej. int fj = edgej.faceIndex[0]; if (fj == Face::NONE) { fj = edgej.faceIndex[1]; } if (edge.faceIndex[0] == Face::NONE) { edge.faceIndex[0] = fj; } else { edge.faceIndex[1] = fj; } if (reversej) { // The new edge is backwards of the old edge for ej newEdgeIndex[ej] = ~e; } else { newEdgeIndex[ej] = e; } // Remove both ei and ej from being candidates for future pairing. // Remove ej first since it comes later in the list (removing // ei would decrease the index of ej to j - 1). boundaryEdge.fastRemove(j); boundaryEdge.fastRemove(i); // Re-process element i, which is now a new edge index --i; // Jump out of the j for-loop break; } } } ++cur; } // Anything remaining in the table is a real boundary edge; just copy it to // the end of the array. cur = boundaryEdgeIndices.begin(); end = boundaryEdgeIndices.end(); while (cur != end) { Array<int>& boundaryEdge = cur->value; for (int b = 0; b < boundaryEdge.size(); ++b) { const int e = boundaryEdge[b]; newEdgeIndex[e] = edgeArray.size(); edgeArray.append(oldEdgeArray[e]); } ++cur; } // Finally, fix up edge indices in the face and vertex arrays for (int f = 0; f < faceArray.size(); ++f) { Face& face = faceArray[f]; for (int i = 0; i < 3; ++i) { int e = face.edgeIndex[i]; if (e < 0) { face.edgeIndex[i] = ~newEdgeIndex[~e]; } else { face.edgeIndex[i] = newEdgeIndex[e]; } } } for (int v = 0; v < vertexArray.size(); ++v) { Vertex& vertex = vertexArray[v]; for (int i = 0; i < vertex.edgeIndex.size(); ++i) { int e = vertex.edgeIndex[i]; if (e < 0) { vertex.edgeIndex[i] = ~newEdgeIndex[~e]; } else { vertex.edgeIndex[i] = newEdgeIndex[e]; } } } }
Table( const Table& t){ //Copy constructor for(int i=0; i< t.size(); i++){ Data.push_back(t.getRow(i)); } recalc(); }
void MaskSprite::deserialize(const Table& table) { Sprite::deserialize(table); setAlphaMask( table.getFloat("alphaMask", getAlphaMask()) ); }
void MaskBox::deserialize(const Table& table) { box.set(table.getVector2D("center", box.getCenter()), table.getVector2D("size", box.getSize()), Angle::degree(table.getFloat("angle", box.getAngle().valueDegrees()))); }
void TestTable::parseSQL() { QString sSQL = "create TABLE hero (\n" "\tid integer PRIMARY KEY AUTOINCREMENT,\n" "\tname text NOT NULL DEFAULT 'xxxx',\n" "\tinfo VARCHAR(255) CHECK (info == 'x')\n" ");"; Table tab = Table::parseSQL(sSQL).first; QVERIFY(tab.name() == "hero"); QVERIFY(tab.rowidColumn() == "_rowid_"); QVERIFY(tab.fields().at(0)->name() == "id"); QVERIFY(tab.fields().at(1)->name() == "name"); QVERIFY(tab.fields().at(2)->name() == "info"); QVERIFY(tab.fields().at(0)->type() == "integer"); QVERIFY(tab.fields().at(1)->type() == "text"); QCOMPARE(tab.fields().at(2)->type(), QString("VARCHAR ( 255 )")); FieldVector pk = tab.primaryKey(); QVERIFY(tab.fields().at(0)->autoIncrement()); QVERIFY(pk.size() == 1 && pk.at(0) == tab.fields().at(0)); QVERIFY(tab.fields().at(1)->notnull()); QCOMPARE(tab.fields().at(1)->defaultValue(), QString("'xxxx'")); QCOMPARE(tab.fields().at(1)->check(), QString("")); QCOMPARE(tab.fields().at(2)->check(), QString("info == 'x'")); }
void TestTable::parseSQLdefaultexpr() { QString sSQL = "CREATE TABLE chtest(\n" "id integer primary key,\n" "dumpytext text default('axa') CHECK(dumpytext == \"aa\"),\n" "date datetime default CURRENT_TIMESTAMP," "zoi integer)"; Table tab = Table::parseSQL(sSQL).first; QCOMPARE(tab.name(), QString("chtest")); QCOMPARE(tab.fields().at(0)->name(), QString("id")); QCOMPARE(tab.fields().at(1)->name(), QString("dumpytext")); QCOMPARE(tab.fields().at(2)->name(), QString("date")); QCOMPARE(tab.fields().at(3)->name(), QString("zoi")); QCOMPARE(tab.fields().at(0)->type(), QString("integer")); QCOMPARE(tab.fields().at(1)->type(), QString("text")); QCOMPARE(tab.fields().at(2)->type(), QString("datetime")); QCOMPARE(tab.fields().at(3)->type(), QString("integer")); QCOMPARE(tab.fields().at(1)->defaultValue(), QString("('axa')")); QCOMPARE(tab.fields().at(1)->check(), QString("dumpytext == \"aa\"")); QCOMPARE(tab.fields().at(2)->defaultValue(), QString("CURRENT_TIMESTAMP")); QCOMPARE(tab.fields().at(2)->check(), QString("")); QCOMPARE(tab.fields().at(3)->defaultValue(), QString("")); QCOMPARE(tab.fields().at(3)->check(), QString("")); sqlb::FieldVector pk = tab.primaryKey(); QVERIFY(pk.size() == 1 && pk.at(0) == tab.fields().at(0)); }
void Table::addObject(BaseObject *obj, int obj_idx) { ObjectType obj_type; if(!obj) throw Exception(ERR_ASG_NOT_ALOC_OBJECT,__PRETTY_FUNCTION__,__FILE__,__LINE__); else { int idx; obj_type=obj->getObjectType(); #ifdef DEMO_VERSION #warning "DEMO VERSION: table children objects creation limit." vector<TableObject *> *obj_list=(obj_type!=OBJ_TABLE ? getObjectList(obj_type) : nullptr); if((obj_list && obj_list->size() >= GlobalAttributes::MAX_OBJECT_COUNT) || (obj_type==OBJ_TABLE && ancestor_tables.size() >= GlobalAttributes::MAX_OBJECT_COUNT)) throw Exception(trUtf8("In demonstration version tables can have only `%1' instances of each child object type or ancestor tables! You've reach this limit for the type: `%2'") .arg(GlobalAttributes::MAX_OBJECT_COUNT) .arg(BaseObject::getTypeName(obj_type)), ERR_CUSTOM,__PRETTY_FUNCTION__,__FILE__,__LINE__); #endif try { //Raises an error if already exists a object with the same name and type if(getObject(obj->getName(),obj_type,idx)) { throw Exception(QString(Exception::getErrorMessage(ERR_ASG_DUPLIC_OBJECT)) .arg(obj->getName(true)) .arg(obj->getTypeName()) .arg(this->getName(true)) .arg(this->getTypeName()), ERR_ASG_DUPLIC_OBJECT,__PRETTY_FUNCTION__,__FILE__,__LINE__); } //Raises an error if the user try to set the table as ancestor/copy of itself else if((obj_type==OBJ_TABLE || obj_type==BASE_TABLE) && obj==this) throw Exception(ERR_INV_INH_COPY_RELATIONSHIP,__PRETTY_FUNCTION__,__FILE__,__LINE__); switch(obj_type) { case OBJ_COLUMN: case OBJ_CONSTRAINT: case OBJ_TRIGGER: case OBJ_INDEX: case OBJ_RULE: TableObject *tab_obj; vector<TableObject *> *obj_list; Column *col; tab_obj=dynamic_cast<TableObject *>(obj); col=dynamic_cast<Column *>(tab_obj); //Sets the object parent table if there isn't one if(!tab_obj->getParentTable()) tab_obj->setParentTable(this); //Raises an error if the parent table of the table object is different from table 'this' else if(tab_obj->getParentTable()!=this) throw Exception(ERR_ASG_OBJ_BELONGS_OTHER_TABLE,__PRETTY_FUNCTION__,__FILE__,__LINE__); //Validates the object SQL code befor insert on table obj->getCodeDefinition(SchemaParser::SQL_DEFINITION); if(col && col->getType()==this) { throw Exception(Exception::getErrorMessage(ERR_INV_COLUMN_TABLE_TYPE) .arg(col->getName()) .arg(this->getName()), ERR_INV_COLUMN_TABLE_TYPE,__PRETTY_FUNCTION__,__FILE__,__LINE__); } else if(obj_type==OBJ_CONSTRAINT) { //Raises a error if the user try to add a second primary key on the table if(dynamic_cast<Constraint *>(tab_obj)->getConstraintType()==ConstraintType::primary_key && this->getPrimaryKey()) throw Exception(ERR_ASG_EXISTING_PK_TABLE,__PRETTY_FUNCTION__,__FILE__,__LINE__); } else if(obj_type==OBJ_TRIGGER) dynamic_cast<Trigger *>(tab_obj)->validateTrigger(); obj_list=getObjectList(obj_type); //Adds the object to the table if(obj_idx < 0 || obj_idx >= static_cast<int>(obj_list->size())) obj_list->push_back(tab_obj); else { //If there is a object index specified inserts the object at the position if(obj_list->size() > 0) obj_list->insert((obj_list->begin() + obj_idx), tab_obj); else obj_list->push_back(tab_obj); } if(obj_type==OBJ_COLUMN || obj_type==OBJ_CONSTRAINT) { updateAlterCmdsStatus(); if(obj_type==OBJ_CONSTRAINT) dynamic_cast<Constraint *>(tab_obj)->setColumnsNotNull(true); } break; case OBJ_TABLE: Table *tab; tab=dynamic_cast<Table *>(obj); if(obj_idx < 0 || obj_idx >= static_cast<int>(ancestor_tables.size())) ancestor_tables.push_back(tab); else ancestor_tables.insert((ancestor_tables.begin() + obj_idx), tab); /* Updating the storage parameter WITH OIDS depending on the ancestors. According to the docs, the child table will inherit WITH OID status from the parents */ with_oid=(with_oid || tab->isWithOIDs()); break; default: throw Exception(ERR_ASG_OBJECT_INV_TYPE,__PRETTY_FUNCTION__,__FILE__,__LINE__); break; } setCodeInvalidated(true); } catch(Exception &e) { if(e.getErrorType()==ERR_UNDEF_ATTRIB_VALUE) throw Exception(Exception::getErrorMessage(ERR_ASG_OBJ_INV_DEFINITION) .arg(obj->getName()) .arg(obj->getTypeName()), ERR_ASG_OBJ_INV_DEFINITION,__PRETTY_FUNCTION__,__FILE__,__LINE__, &e); else throw Exception(e.getErrorMessage(),e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e); } } }
typename Table::size_type bucket_count () const {return table.size();}
bool InsertExecutor::p_init(AbstractPlanNode* abstractNode, const ExecutorVector& executorVector) { VOLT_TRACE("init Insert Executor"); m_node = dynamic_cast<InsertPlanNode*>(abstractNode); assert(m_node); assert(m_node->getTargetTable()); assert(m_node->getInputTableCount() == (m_node->isInline() ? 0 : 1)); Table* targetTable = m_node->getTargetTable(); m_isUpsert = m_node->isUpsert(); // // The insert node's input schema is fixed. But // if this is an inline node we don't set it here. // We let the parent node set it in p_execute_init. // // Also, we don't want to set the input table for inline // insert nodes. // if ( ! m_node->isInline()) { setDMLCountOutputTable(executorVector.limits()); m_inputTable = dynamic_cast<AbstractTempTable*>(m_node->getInputTable()); //input table should be temptable assert(m_inputTable); } else { m_inputTable = NULL; } // Target table can be StreamedTable or PersistentTable and must not be NULL PersistentTable *persistentTarget = dynamic_cast<PersistentTable*>(targetTable); m_partitionColumn = -1; StreamedTable *streamTarget = dynamic_cast<StreamedTable*>(targetTable); m_hasStreamView = false; if (streamTarget != NULL) { m_isStreamed = true; //See if we have any views. m_hasStreamView = streamTarget->hasViews(); m_partitionColumn = streamTarget->partitionColumn(); } if (m_isUpsert) { VOLT_TRACE("init Upsert Executor actually"); assert( ! m_node->isInline() ); if (m_isStreamed) { VOLT_ERROR("UPSERT is not supported for Stream table %s", targetTable->name().c_str()); } // look up the tuple whether it exists already if (persistentTarget->primaryKeyIndex() == NULL) { VOLT_ERROR("No primary keys were found in our target table '%s'", targetTable->name().c_str()); } } if (persistentTarget) { m_partitionColumn = persistentTarget->partitionColumn(); } m_multiPartition = m_node->isMultiPartition(); m_sourceIsPartitioned = m_node->sourceIsPartitioned(); // allocate memory for template tuple, set defaults for all columns m_templateTupleStorage.init(targetTable->schema()); TableTuple tuple = m_templateTupleStorage.tuple(); std::set<int> fieldsExplicitlySet(m_node->getFieldMap().begin(), m_node->getFieldMap().end()); // These default values are used for an INSERT including the INSERT sub-case of an UPSERT. // The defaults are purposely ignored in favor of existing column values // for the UPDATE subcase of an UPSERT. m_node->initTupleWithDefaultValues(m_engine, &m_memoryPool, fieldsExplicitlySet, tuple, m_nowFields); m_hasPurgeFragment = persistentTarget ? persistentTarget->hasPurgeFragment() : false; return true; }
std::string System::findDataFile (const std::string& full, bool errorIfNotFound) { // Places where specific files were most recently found. This is // used to cache seeking of common files. static Table<std::string, std::string> lastFound; // First check if the file exists as requested. This will go // through the FileSystemCache, so most calls do not touch disk. if (fileExists(full)) { return full; } // Now check where we previously found this file. std::string* last = lastFound.getPointer(full); if (last != NULL) { if (fileExists(*last)) { // Even if cwd has changed the file is still present. // We won't notice if it has been deleted, however. return *last; } else { // Remove this from the cache it is invalid lastFound.remove(full); } } // Places to look static Array<std::string> directoryArray; if (directoryArray.size() == 0) { // Initialize the directory array RealTime t0 = System::time(); Array<std::string> baseDirArray; std::string initialAppDataDir(instance().m_appDataDir); baseDirArray.append(""); if (! initialAppDataDir.empty()) { baseDirArray.append(initialAppDataDir); } const char* g3dPath = getenv("G3DDATA"); if (g3dPath && (initialAppDataDir != g3dPath)) { baseDirArray.append(g3dPath); } static const std::string subdirs[] = {"font", "gui", "SuperShader", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", ""}; for (int j = 0; j < baseDirArray.size(); ++j) { std::string d = baseDirArray[j]; if (fileExists(d)) { directoryArray.append(d); for (int i = 0; ! subdirs[i].empty(); ++i) { const std::string& p = pathConcat(d, subdirs[i]); if (fileExists(p)) { directoryArray.append(p); } } } } logLazyPrintf("Initializing System::findDataFile took %fs\n", System::time() - t0); } for (int i = 0; i < directoryArray.size(); ++i) { const std::string& p = pathConcat(directoryArray[i], full); if (fileExists(p)) { lastFound.set(full, p); return p; } } if (errorIfNotFound) { // Generate an error message std::string locations; for (int i = 0; i < directoryArray.size(); ++i) { locations += pathConcat(directoryArray[i], full) + "\n"; } alwaysAssertM(false, "Could not find '" + full + "' in:\n" + locations); } // Not found return ""; }
int main() { Connection conn; DbRetVal rv = conn.open("root", "manager"); if (rv != OK) { printf("Error during connection %d\n", rv); return 1; } DatabaseManager *dbMgr = conn.getDatabaseManager(); if (dbMgr == NULL) { printf("Auth failed\n"); return 2;} TableDef tabDef; tabDef.addField("f1", typeInt, 0, NULL, true); tabDef.addField("f2", typeString, 196); rv = dbMgr->createTable("t1", tabDef); if (rv != OK) { printf("Table creation failed\n"); return 3; } printf("Table created\n"); #ifdef WITHINDEX HashIndexInitInfo *idxInfo = new HashIndexInitInfo(); strcpy(idxInfo->tableName, "t1"); idxInfo->list.append("f1"); idxInfo->indType = hashIndex; idxInfo->isUnique = true; idxInfo->isPrimary = true; rv = dbMgr->createIndex("indx1", idxInfo); if (rv != OK) { printf("Index creation failed\n"); return -1; } printf("Index created\n"); delete idxInfo; #endif #ifdef WITHTREEINDEX HashIndexInitInfo *idxInfo = new HashIndexInitInfo(); strcpy(idxInfo->tableName, "t1"); idxInfo->list.append("f1"); idxInfo->indType = treeIndex; rv = dbMgr->createIndex("indx1", idxInfo); if (rv != OK) { printf("Index creation failed\n"); return -1; } printf("Index created\n"); delete idxInfo; #endif #ifdef WITHTRIEINDEX HashIndexInitInfo *idxInfo = new HashIndexInitInfo(); strcpy(idxInfo->tableName, "t1"); idxInfo->list.append("f1"); idxInfo->indType = trieIndex; rv = dbMgr->createIndex("indx1", idxInfo); if (rv != OK) { printf("Index creation failed\n"); return -1; } printf("Index created\n"); delete idxInfo; #endif Table *table = dbMgr->openTable("t1"); if (table == NULL) { printf("Unable to open table\n"); return 4; } table->bindFld("f1", &id); table->bindFld("f2", name); char *tuple; int ret; int i; rv =conn.startTransaction(); for(i = 0; i< 5; i++) { if (rv != OK) exit(5); id= i; strcpy(name, "PRABAKARAN0123456750590"); ret = table->insertTuple(); if (ret != 0) break; } conn.commit(); conn.startTransaction(); select(table, OpEquals); conn.commit(); conn.startTransaction(); select(table, OpNotEquals); conn.commit(); conn.startTransaction(); select(table, OpLessThan); conn.commit(); conn.startTransaction(); select( table, OpLessThanEquals); conn.commit(); conn.startTransaction(); select( table, OpGreaterThan); conn.commit(); conn.startTransaction(); select( table, OpGreaterThanEquals); conn.commit(); dbMgr->closeTable(table); dbMgr->dropTable("t1"); conn.close(); return 0; }
void assert_field_type(Table &td, int field_index, ActiveRecord::Type::Type type) { ASSERT_EQ(type, td.fields()[field_index].type()); }
void LineProfileTool::calculateLineProfile(const QPoint& start, const QPoint& end) { QRect rect = d_target->rect(); if (!rect.contains(start) || !rect.contains(end)){ QMessageBox::warning(d_graph, tr("MantidPlot - Pixel selection warning"), tr("Please select the end line point inside the image rectangle!")); return; } QPoint o = d_target->origin(); QPixmap pic = d_target->pixmap(); QImage image = pic.convertToImage(); int x1 = start.x()-o.x(); int x2 = end.x()-o.x(); int y1 = start.y()-o.y(); int y2 = end.y()-o.y(); QSize realSize = pic.size(); QSize actualSize = d_target->size(); if (realSize != actualSize){ double ratioX = (double)realSize.width()/(double)actualSize.width(); double ratioY = (double)realSize.height()/(double)actualSize.height(); x1 = static_cast<int>(x1*ratioX); x2 = static_cast<int>(x2*ratioX); y1 = static_cast<int>(y1*ratioY); y2 = static_cast<int>(y2*ratioY); } QString text = tr("pixel") + "\tx\ty\t" + tr("intensity") + "\n"; //uses the fast Bresenham's line-drawing algorithm #define sgn(x) ((x<0)?-1:((x>0)?1:0)) int i,dx,dy,sdx,sdy,dxabs,dyabs,x,y,px,py,n = 0; dx=x2-x1; //the horizontal distance of the line dy=y2-y1; //the vertical distance of the line dxabs=abs(dx); dyabs=abs(dy); sdx=sgn(dx); sdy=sgn(dy); x=dyabs>>1; y=dxabs>>1; px=x1; py=y1; if (dxabs>=dyabs){ //the line is more horizontal than vertical for(i=0;i<dxabs;i++){ y+=dyabs; if (y>=dxabs){ y-=dxabs; py+=sdy; } px+=sdx; n=dxabs; text+=QString::number(i)+"\t"; text+=QString::number(px)+"\t"; text+=QString::number(py)+"\t"; text+=QString::number(averageImagePixel(image, px, py, true))+"\n"; } } else {// the line is more vertical than horizontal for(i=0;i<dyabs;i++){ x+=dxabs; if (x>=dyabs){ x-=dyabs; px+=sdx; } py+=sdy; n=dyabs; text+=QString::number(i)+"\t"; text+=QString::number(px)+"\t"; text+=QString::number(py)+"\t"; text+=QString::number(averageImagePixel(image, px, py, false))+"\n"; } } Table *t = d_app->newTable(tr("Table") + "1", n, 4, text); MultiLayer* plot = d_app->multilayerPlot(t, QStringList(QString(t->objectName())+"_intensity"), 0); Graph *g = dynamic_cast<Graph*>(plot->activeGraph()); if (g){ g->setTitle(""); g->setXAxisTitle(tr("pixels")); g->setYAxisTitle(tr("pixel intensity (a.u.)")); } }
void MaskSprite::serialize(Table& table) { Sprite::serialize(table); table.set("alphaMask", getAlphaMask()); }
/***************************************************** ** ** HoraExpert --- write ** ******************************************************/ void HoraExpert::write( Sheet *sheet, const bool isLocaltime ) { TzUtil tzu; wxString s; TzFormattedDate fd; Lang lang; SheetFormatter fmt; double corr = ( location->getTimeZone() + location->getDST()) / 24; Table *table = new Table( 7, 13 ); if ( config->view->showTextViewHeaders ) table->setHeader( _( "Hora" )); table->setHeader( 0, _( "Begin" )); table->setHeader( 1, _( "Lord" )); table->setHeader( 2, _( "End" )); //table->setHeader( 3, wxEmptyString ); table->setHeader( 4, _( "Begin" )); table->setHeader( 5, _( "Lord" )); table->setHeader( 6, _( "End" )); int line = 1; int colskip = 0; for ( int i = 0; i < 24; i++ ) { if ( i == 12 ) { colskip = 4; line = 1; } table->setEntry( 3, line, wxEmptyString ); fd = tzu.getDateFormatted( horaStart[i] + corr, isLocaltime ); table->setEntry( colskip, line, fd.timeFormatted ); table->setEntry( 1+colskip, line, fmt.getObjectName( horaLord[i], TF_LONG )); fd = tzu.getDateFormatted( horaStart[i+1] + corr, isLocaltime ); table->setEntry( 2+colskip, line, fd.timeFormatted ); line++; } sheet->addItem( table ); sheet->addLine( wxString::Format( wxT( "%s: %s" ), _( "Lord of the day" ), lang.getObjectName( getDinaLord(), TF_LONG ).c_str())); sheet->addLine( wxString::Format( wxT( "%s: %s" ), _( "Lord of the month" ), lang.getObjectName( getMasaLord(), TF_LONG ).c_str())); sheet->addLine( wxString::Format( wxT( "%s: %s" ), _( "Lord of the year" ), lang.getObjectName( getVarshaLord(), TF_LONG ).c_str() )); }
void MaskBox::serialize(Table& table) { table.set("center", box.getCenter()); table.set("size", box.getSize()); table.set("angle", box.getAngle().valueDegrees()); }
bool InsertExecutor::p_execute(const NValueArray ¶ms) { assert(m_node == dynamic_cast<InsertPlanNode*>(m_abstractNode)); assert(m_node); assert(m_inputTable == dynamic_cast<TempTable*>(m_node->getInputTable())); assert(m_inputTable); // Target table can be StreamedTable or PersistentTable and must not be NULL // Update target table reference from table delegate Table* targetTable = m_node->getTargetTable(); assert(targetTable); assert((targetTable == dynamic_cast<PersistentTable*>(targetTable)) || (targetTable == dynamic_cast<StreamedTable*>(targetTable))); PersistentTable* persistentTable = m_isStreamed ? NULL : static_cast<PersistentTable*>(targetTable); TableTuple upsertTuple = TableTuple(targetTable->schema()); VOLT_TRACE("INPUT TABLE: %s\n", m_inputTable->debug().c_str()); // count the number of successful inserts int modifiedTuples = 0; Table* outputTable = m_node->getOutputTable(); assert(outputTable); TableTuple templateTuple = m_templateTuple.tuple(); std::vector<int>::iterator it; for (it = m_nowFields.begin(); it != m_nowFields.end(); ++it) { templateTuple.setNValue(*it, NValue::callConstant<FUNC_CURRENT_TIMESTAMP>()); } VOLT_DEBUG("This is a %s-row insert on partition with id %d", m_node->getChildren()[0]->getPlanNodeType() == PLAN_NODE_TYPE_MATERIALIZE ? "single" : "multi", m_engine->getPartitionId()); VOLT_DEBUG("Offset of partition column is %d", m_partitionColumn); // // An insert is quite simple really. We just loop through our m_inputTable // and insert any tuple that we find into our targetTable. It doesn't get any easier than that! // TableTuple inputTuple(m_inputTable->schema()); assert (inputTuple.sizeInValues() == m_inputTable->columnCount()); TableIterator iterator = m_inputTable->iterator(); while (iterator.next(inputTuple)) { for (int i = 0; i < m_node->getFieldMap().size(); ++i) { // Most executors will just call setNValue instead of // setNValueAllocateForObjectCopies. // // However, We need to call // setNValueAlocateForObjectCopies here. Sometimes the // input table's schema has an inlined string field, and // it's being assigned to the target table's outlined // string field. In this case we need to tell the NValue // where to allocate the string data. templateTuple.setNValueAllocateForObjectCopies(m_node->getFieldMap()[i], inputTuple.getNValue(i), ExecutorContext::getTempStringPool()); } VOLT_TRACE("Inserting tuple '%s' into target table '%s' with table schema: %s", templateTuple.debug(targetTable->name()).c_str(), targetTable->name().c_str(), targetTable->schema()->debug().c_str()); // if there is a partition column for the target table if (m_partitionColumn != -1) { // get the value for the partition column NValue value = templateTuple.getNValue(m_partitionColumn); bool isLocal = m_engine->isLocalSite(value); // if it doesn't map to this site if (!isLocal) { if (!m_multiPartition) { throw ConstraintFailureException( dynamic_cast<PersistentTable*>(targetTable), templateTuple, "Mispartitioned tuple in single-partition insert statement."); } // don't insert continue; } } // for multi partition export tables, only insert into one // place (the partition with hash(0)), if the data is from a // replicated source. If the data is coming from a subquery // with partitioned tables, we need to perform the insert on // every partition. if (m_isStreamed && m_multiPartition && !m_sourceIsPartitioned) { bool isLocal = m_engine->isLocalSite(ValueFactory::getBigIntValue(0)); if (!isLocal) continue; } if (! m_isUpsert) { // try to put the tuple into the target table if (m_hasPurgeFragment) { if (!executePurgeFragmentIfNeeded(&persistentTable)) return false; // purge fragment might have truncated the table, and // refreshed the persistent table pointer. Make sure to // use it when doing the insert below. targetTable = persistentTable; } if (!targetTable->insertTuple(templateTuple)) { VOLT_ERROR("Failed to insert tuple from input table '%s' into" " target table '%s'", m_inputTable->name().c_str(), targetTable->name().c_str()); return false; } } else { // upsert execution logic assert(persistentTable->primaryKeyIndex() != NULL); TableTuple existsTuple = persistentTable->lookupTupleByValues(templateTuple); if (existsTuple.isNullTuple()) { // try to put the tuple into the target table if (m_hasPurgeFragment) { if (!executePurgeFragmentIfNeeded(&persistentTable)) return false; } if (!persistentTable->insertTuple(templateTuple)) { VOLT_ERROR("Failed to insert tuple from input table '%s' into" " target table '%s'", m_inputTable->name().c_str(), persistentTable->name().c_str()); return false; } } else { // tuple exists already, try to update the tuple instead upsertTuple.move(templateTuple.address()); TableTuple &tempTuple = persistentTable->getTempTupleInlined(upsertTuple); if (!persistentTable->updateTupleWithSpecificIndexes(existsTuple, tempTuple, persistentTable->allIndexes())) { VOLT_INFO("Failed to update existsTuple from table '%s'", persistentTable->name().c_str()); return false; } } } // successfully inserted or updated modifiedTuples++; } TableTuple& count_tuple = outputTable->tempTuple(); count_tuple.setNValue(0, ValueFactory::getBigIntValue(modifiedTuples)); // try to put the tuple into the output table if (!outputTable->insertTuple(count_tuple)) { VOLT_ERROR("Failed to insert tuple count (%d) into" " output table '%s'", modifiedTuples, outputTable->name().c_str()); return false; } // add to the planfragments count of modified tuples m_engine->addToTuplesModified(modifiedTuples); VOLT_DEBUG("Finished inserting %d tuples", modifiedTuples); return true; }
int main() { Connection conn; DbRetVal rv = conn.open("root", "manager"); if (rv != OK) { printf("Error during connection %d\n", rv); return -1; } DatabaseManager *dbMgr = conn.getDatabaseManager(); if (dbMgr == NULL) { printf("Auth failed\n"); return -1;} TableDef tabDef; tabDef.addField("f1", typeInt, 0, NULL, true ); tabDef.addField("f2", typeString, 196); rv = dbMgr->createTable("t1", tabDef); if (rv != OK) { printf("Table creation failed\n"); return -1; } printf("Table created\n"); HashIndexInitInfo *idxInfo = new HashIndexInitInfo(); strcpy(idxInfo->tableName, "t1"); idxInfo->list.append("f1"); idxInfo->indType = hashIndex; if (LOAD >0 ) idxInfo->bucketSize = 100007; else idxInfo->bucketSize = 10007; rv = dbMgr->createIndex("indx1", idxInfo); if (rv != OK) { printf("Index creation failed\n"); return -1; } printf("Index created\n"); delete idxInfo; Table *table = dbMgr->openTable("t1"); if (table == NULL) { printf("Unable to open table\n"); return -1; } int id = 0; char name[196] = "PRABAKARAN"; table->bindFld("f1", &id); table->bindFld("f2", name); char *tuple; int ret; int i; int icount =0; if (LOAD > 0) { TableImpl *impl = (TableImpl*)table; impl->setUndoLogging(false); strcpy(name, "PRABAKARAN0123456750590"); rv = conn.startTransaction(); if (rv != OK) exit(1); for(i = 0; i< LOAD; i++) { id= i; ret = table->insertTuple(); if (ret != 0) break; icount++; if (i % 100 == 0 ) { rv = conn.commit(); if (rv != OK) exit(1); rv = conn.startTransaction(); if (rv != OK) exit(1); } if (i %50000 == 0) printf("%d rows inserted\n", i); } conn.commit(); impl->setUndoLogging(true); printf("Loaded %d records\n", icount); } //TableImpl *impl = (TableImpl*)table; //impl->setUndoLogging(false); i = 0; NanoTimer timer; icount =0; for(i = LOAD; i< LOAD+ITERATIONS; i++) { timer.start(); rv = conn.startTransaction(); if (rv != OK) exit(1); id= i; strcpy(name, "PRABAKARAN0123456750590"); ret = table->insertTuple(); if (ret != 0) break; // printf("%d\n ", i); icount++; conn.commit(); timer.stop(); } printf("%d rows inserted %lld %lld %lld\n",icount, timer.minc(), timer.maxc(), timer.avg()); int offset1= os::align(sizeof(int)); Condition p1; int val1 = 0; p1.setTerm("f1", OpEquals, &val1); table->setCondition(&p1); icount=0; timer.reset(); for(i = LOAD; i< LOAD+ITERATIONS; i++) { timer.start(); rv =conn.startTransaction(); if (rv != OK) exit(1); val1 = i; table->execute(); tuple = (char*)table->fetch() ; if (tuple == NULL) {printf("loop break in %d\n", i);table->closeScan();break;} // printf(" %d tuple value is %d %s \n", i, *((int*)tuple), tuple+offset1); table->closeScan(); icount++; conn.commit(); timer.stop(); } printf("%d rows selected %lld %lld %lld\n", icount, timer.minc(), timer.maxc(), timer.avg()); timer.reset(); for(i = LOAD; i< LOAD+ITERATIONS; i++) { timer.start(); rv = conn.startTransaction(); if (rv != OK) exit (1); val1 = i; table->execute(); tuple = (char*)table->fetch() ; if (tuple == NULL) {printf("loop break in %d\n", i);table->closeScan();break;} strcpy(name, "PRABAKARAN0950576543210"); table->updateTuple(); table->closeScan(); conn.commit(); timer.stop(); } printf("%d rows updated %lld %lld %lld\n", i- LOAD, timer.minc(), timer.maxc(), timer.avg()); icount=0; for(i = LOAD; i< LOAD+ITERATIONS; i++) { timer.start(); rv = conn.startTransaction(); if (rv != OK) exit (1); val1 = i; table->execute(); tuple = (char*)table->fetch() ; if (tuple == NULL) {printf("No record for %d\n", i);table->closeScan();break;} table->deleteTuple(); icount++; table->closeScan(); conn.commit(); timer.stop(); } printf("%d rows deleted %lld %lld %lld\n", icount, timer.minc(), timer.maxc(), timer.avg()); dbMgr->closeTable(table); dbMgr->dropTable("t1"); printf("Table dropped\n"); conn.close(); return 0; }
void InfoPanel::DrawInfo() const { Color dim = *GameData::Colors().Get("medium"); Color bright = *GameData::Colors().Get("bright"); Color elsewhere = *GameData::Colors().Get("dim"); Color dead(.4, 0., 0., 0.); const Font &font = FontSet::Get(14); // Player info. Table table; table.AddColumn(0, Table::LEFT); table.AddColumn(230, Table::RIGHT); table.SetUnderline(0, 230); table.DrawAt(Point(-490., -265.)); table.Draw("player:", dim); table.Draw(player.FirstName() + " " + player.LastName(), bright); table.Draw("net worth:", dim); table.Draw(Format::Number(player.Accounts().NetWorth()) + " credits", bright); // Determine the player's combat rating. table.DrawGap(10); size_t ratingLevel = 0; auto it = player.Conditions().find("combat rating"); if(it != player.Conditions().end() && it->second > 0) { ratingLevel = log(it->second); ratingLevel = min(ratingLevel, RATINGS.size() - 1); } table.DrawUnderline(dim); table.Draw("combat rating:", bright); table.Advance(); table.DrawGap(5); table.Draw(RATINGS[ratingLevel], dim); table.Draw("(" + to_string(ratingLevel) + ")", dim); auto salary = Match(player, "salary: ", ""); sort(salary.begin(), salary.end()); DrawList(salary, table, "salary:", 4); auto tribute = Match(player, "tribute: ", ""); sort(tribute.begin(), tribute.end()); DrawList(tribute, table, "tribute:", 4); int maxRows = static_cast<int>(250. - 30. - table.GetPoint().Y()) / 20; auto licenses = Match(player, "license: ", " License"); DrawList(licenses, table, "licenses:", maxRows, false); // Fleet listing. Point pos = Point(-240., -270.); font.Draw("ship", pos + Point(0., 0.), bright); font.Draw("model", pos + Point(220., 0.), bright); font.Draw("system", pos + Point(350., 0.), bright); font.Draw("shields", pos + Point(550. - font.Width("shields"), 0.), bright); font.Draw("hull", pos + Point(610. - font.Width("hull"), 0.), bright); font.Draw("fuel", pos + Point(670. - font.Width("fuel"), 0.), bright); font.Draw("crew", pos + Point(730. - font.Width("crew"), 0.), bright); FillShader::Fill(pos + Point(365., 15.), Point(730., 1.), dim); if(!player.Ships().size()) return; int lastIndex = player.Ships().size() - 1; pos.Y() += 5.; int index = 0; auto sit = player.Ships().begin() + scroll; for( ; sit < player.Ships().end(); ++sit) { const shared_ptr<Ship> &ship = *sit; pos.Y() += 20.; if(pos.Y() >= 250.) break; bool isElsewhere = (ship->GetSystem() != player.GetSystem()); bool isDead = ship->IsDestroyed() || ship->IsDisabled(); bool isHovered = (index == hover); const Color &color = isDead ? dead : isElsewhere ? elsewhere : isHovered ? bright : dim; font.Draw(ship->Name(), pos + Point(10. * ship->CanBeCarried(), 0.), color); font.Draw(ship->ModelName(), pos + Point(220., 0.), color); const System *system = ship->GetSystem(); if(system) font.Draw(system->Name(), pos + Point(350., 0.), color); string shields = to_string(static_cast<int>(100. * max(0., ship->Shields()))) + "%"; font.Draw(shields, pos + Point(550. - font.Width(shields), 0.), color); string hull = to_string(static_cast<int>(100. * max(0., ship->Hull()))) + "%"; font.Draw(hull, pos + Point(610. - font.Width(hull), 0.), color); string fuel = to_string(static_cast<int>( ship->Attributes().Get("fuel capacity") * ship->Fuel())); font.Draw(fuel, pos + Point(670. - font.Width(fuel), 0.), color); string crew = ship->IsParked() ? "Parked" : to_string(index ? ship->RequiredCrew() : ship->Crew()); font.Draw(crew, pos + Point(730. - font.Width(crew), 0.), color); if(index < lastIndex || selected < 0) zones.emplace_back(pos + Point(365, font.Height() / 2), Point(730, 20), index); else { int height = 270. - pos.Y(); zones.emplace_back(pos + Point(365, height / 2), Point(730, height), index); } ++index; } // Re-ordering ships in your fleet. if(selected >= 0) { const string &name = player.Ships()[selected]->Name(); Point pos(hoverPoint.X() - .5 * font.Width(name), hoverPoint.Y()); font.Draw(name, pos + Point(1., 1.), Color(0., 1.)); font.Draw(name, pos, bright); } }
void IsisMain() { // Create a serial number list UserInterface &ui = Application::GetUserInterface(); QString filename = ui.GetFileName("FROM"); SerialNumberList serialNumberList; serialNumberList.Add(filename); // Get the coordinate for updating the camera pointing // We will want to make the camera pointing match the lat/lon at this // line sample double samp1 = ui.GetDouble("SAMP1"); double line1 = ui.GetDouble("LINE1"); Latitude lat1(ui.GetDouble("LAT1"), Angle::Degrees); Longitude lon1(ui.GetDouble("LON1"), Angle::Degrees); Distance rad1; if(ui.WasEntered("RAD1")) { rad1 = Distance(ui.GetDouble("RAD1"), Distance::Meters); } else { rad1 = GetRadius(ui.GetFileName("FROM"), lat1, lon1); } // In order to use the bundle adjustment class we will need a control // network ControlMeasure * m = new ControlMeasure; m->SetCubeSerialNumber(serialNumberList.SerialNumber(0)); m->SetCoordinate(samp1, line1); // m->SetType(ControlMeasure::Manual); m->SetType(ControlMeasure::RegisteredPixel); ControlPoint * p = new ControlPoint; p->SetAprioriSurfacePoint(SurfacePoint(lat1, lon1, rad1)); p->SetId("Point1"); p->SetType(ControlPoint::Fixed); p->Add(m); ControlNet cnet; // cnet.SetType(ControlNet::ImageToGround); cnet.AddPoint(p); // We need the target body Cube c; c.open(filename, "rw"); //check for target name if(c.label()->hasKeyword("TargetName", PvlObject::Traverse)) { // c.Label()->findKeyword("TargetName"); PvlGroup inst = c.label()->findGroup("Instrument", PvlObject::Traverse); QString targetName = inst["TargetName"]; cnet.SetTarget(targetName); } c.close(); // See if they wanted to solve for twist if(ui.GetBoolean("TWIST")) { double samp2 = ui.GetDouble("SAMP2"); double line2 = ui.GetDouble("LINE2"); Latitude lat2(ui.GetDouble("LAT2"), Angle::Degrees); Longitude lon2(ui.GetDouble("LON2"), Angle::Degrees); Distance rad2; if(ui.WasEntered("RAD2")) { rad2 = Distance(ui.GetDouble("RAD2"), Distance::Meters); } else { rad2 = GetRadius(ui.GetFileName("FROM"), lat2, lon2); } ControlMeasure * m = new ControlMeasure; m->SetCubeSerialNumber(serialNumberList.SerialNumber(0)); m->SetCoordinate(samp2, line2); m->SetType(ControlMeasure::Manual); ControlPoint * p = new ControlPoint; p->SetAprioriSurfacePoint(SurfacePoint(lat2, lon2, rad2)); p->SetId("Point2"); p->SetType(ControlPoint::Fixed); p->Add(m); cnet.AddPoint(p); } // Bundle adjust to solve for new pointing try { BundleAdjust b(cnet, serialNumberList); b.SetSolveTwist(ui.GetBoolean("TWIST")); // double tol = ui.GetDouble("TOL"); //int maxIterations = ui.GetInteger("MAXITS"); //b.Solve(tol, maxIterations); b.SetSolveCmatrix(BundleAdjust::AnglesOnly); b.SetSolveSpacecraftPosition(BundleAdjust::Nothing); b.SetErrorPropagation(false); b.SetOutlierRejection(false); b.SetSolutionMethod("SPECIALK"); b.SetStandardOutput(true); b.SetCSVOutput(false); b.SetResidualOutput(true); b.SetConvergenceThreshold(ui.GetDouble("SIGMA0")); b.SetMaxIterations(ui.GetInteger("MAXITS")); b.SetDecompositionMethod(BundleAdjust::SPECIALK); b.SolveCholesky(); Cube c; c.open(filename, "rw"); //check for existing polygon, if exists delete it if(c.label()->hasObject("Polygon")) { c.label()->deleteObject("Polygon"); } Table cmatrix = b.Cmatrix(0); // Write out a description in the spice table QString deltackComment = "deltackAdjusted = " + Isis::iTime::CurrentLocalTime(); cmatrix.Label().addComment(deltackComment); //PvlKeyword description("Description"); //description = "Camera pointing updated via deltack application"; //cmatrix.Label().findObject("Table",Pvl::Traverse).addKeyword(description); // Update the cube history c.write(cmatrix); History h("IsisCube"); c.read(h); h.AddEntry(); c.write(h); c.close(); PvlGroup gp("DeltackResults"); gp += PvlKeyword("Status", "Camera pointing updated"); Application::Log(gp); } catch(IException &e) { QString msg = "Unable to update camera pointing for [" + filename + "]"; throw IException(e, IException::Unknown, msg, _FILEINFO_); } }
void Emitter::serialize(Table& table) { rsSerialize(table); ////////////////////////////////////////////////////////// table.set("maxParticles",getMaxParticles()); table.set("emissionRate",getEmissionRate()); table.set("gravity",getGravity()); if(getDuration()>=0.0) table.set("duration",getDuration()); table.set("relative",(float)getRelative()); ////////////////////////////////////////////////////////// table.set("position",getPosition()); table.set("direction",getDirection()); table.set("startScale",getStartScale()); table.set("endScale",getEndScale()); table.set("startSpin",getStartSpin().valueDegrees()); table.set("endSpin", getEndSpin().valueDegrees()); table.set("startColor",getStartColor().toVec4()); table.set("endColor",getEndColor().toVec4()); table.set("life",getLife()); ////////////////////////////////////////////////////////// table.set("positionVar",getPositionVar()); table.set("directionVar",getDirectionVar()); table.set("startScaleVar",getStartScaleVar()); table.set("endScaleVar",getEndScaleVar()); table.set("startSpinVar",getStartSpinVar().valueDegrees()); table.set("endSpinVar" ,getEndSpinVar().valueDegrees()); table.set("startColorVar",getStartColorVar().toVec4()); table.set("endColorVar",getEndColorVar().toVec4()); table.set("lifeVar",getLifeVar()); ////////////////////////////////////////////////////////// //serialize texture if(getTexture()) table.set("texture",getTexture()->getName()); //serialize shader if(getShader()) table.set("shader",getShader()->getName()); }
std::string System::findDataFile (const std::string& full, bool errorIfNotFound) { // Places where specific files were most recently found. This is // used to cache seeking of common files. static Table<std::string, std::string> lastFound; // First check if the file exists as requested. This will go // through the FileSystemCache, so most calls do not touch disk. if (FileSystem::exists(full)) { return full; } // Now check where we previously found this file. std::string* last = lastFound.getPointer(full); if (last != NULL) { if (FileSystem::exists(*last)) { // Even if cwd has changed the file is still present. // We won't notice if it has been deleted, however. return *last; } else { // Remove this from the cache it is invalid lastFound.remove(full); } } // Places to look static Array<std::string> directoryArray; std::string initialAppDataDir(instance().m_appDataDir); const char* g3dPath = getenv("G3DDATA"); if (directoryArray.size() == 0) { // Initialize the directory array RealTime t0 = System::time(); Array<std::string> baseDirArray; baseDirArray.append(""); if (! initialAppDataDir.empty()) { baseDirArray.append(initialAppDataDir); } # ifdef G3D_WIN32 if (g3dPath == NULL) { // If running the demos under visual studio from the G3D.sln file, // this will locate the data directory. const char* paths[] = {"../data-files/", "../../data-files/", "../../../data-files/", NULL}; for (int i = 0; paths[i]; ++i) { if (FileSystem::exists(pathConcat(paths[i], "G3D-DATA-README.TXT"))) { g3dPath = paths[i]; break; } } } # endif if (g3dPath && (initialAppDataDir != g3dPath)) { baseDirArray.append(g3dPath); } static const std::string subdirs[] = {"font", "gui", "SuperShader", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", ""}; for (int j = 0; j < baseDirArray.size(); ++j) { std::string d = baseDirArray[j]; if ((d == "") || FileSystem::exists(d)) { directoryArray.append(d); for (int i = 0; ! subdirs[i].empty(); ++i) { const std::string& p = pathConcat(d, subdirs[i]); if (FileSystem::exists(p)) { directoryArray.append(p); } } } } logLazyPrintf("Initializing System::findDataFile took %fs\n", System::time() - t0); } for (int i = 0; i < directoryArray.size(); ++i) { const std::string& p = pathConcat(directoryArray[i], full); if (FileSystem::exists(p)) { lastFound.set(full, p); return p; } } if (errorIfNotFound) { // Generate an error message std::string locations; for (int i = 0; i < directoryArray.size(); ++i) { locations += "\'" + pathConcat(directoryArray[i], full) + "'\n"; } std::string msg = "Could not find '" + full + "'.\n\n"; msg += "cwd = \'" + FileSystem::currentDirectory() + "\'\n"; if (g3dPath) { msg += "G3DDATA = "; if (! FileSystem::exists(g3dPath)) { msg += "(illegal path!) "; } msg += std::string(g3dPath) + "\'\n"; } else { msg += "(G3DDATA environment variable is undefined)\n"; } msg += "GApp::Settings.dataDir = "; if (! FileSystem::exists(initialAppDataDir)) { msg += "(illegal path!) "; } msg += std::string(initialAppDataDir) + "\'\n"; msg += "\nLocations searched:\n" + locations; alwaysAssertM(false, msg); } // Not found return ""; }
void Emitter::deserialize(const Table& table) { ////////////////////////////////////////////////////////// rsDeserialize(table); //allways false setCanBatch(false); //get shader if(table.existsAsType("shader",Table::STRING)) { auto rsmanager=table.getResourcesManager(); DEBUG_ASSERT(rsmanager); auto rsgroup=rsmanager->getResourcesGroup(); DEBUG_ASSERT(rsgroup); setShader(rsgroup->load<Shader>(table.getString("shader"))); } //get texture if(table.existsAsType("texture",Table::STRING)) { auto rsmanager=table.getResourcesManager(); DEBUG_ASSERT(rsmanager); auto rsgroup=rsmanager->getResourcesGroup(); DEBUG_ASSERT(rsgroup); //set texture setTexture(rsgroup->load<Texture>(table.getString("texture"))); } ////////////////////////////////////////////////////////// DEBUG_ASSERT(table.existsAsType("maxParticles",Table::FLOAT)); ////////////////////////////////////////////////////////// setMaxParticles(table.get("maxParticles",getMaxParticles())); setEmissionRate(table.get("emissionRate",getEmissionRate())); setDuration(table.get("duration",getDuration())); setGravity(table.get("gravity",getGravity())); setRelative(table.get("relative",getRelative())); center.dir=table.get("direction",getDirection()); ////////////////////////////////////////////////////////// center.position=table.get("position",getPosition()); center.startScale=table.get("startScale",getStartScale()); center.endScale=table.get("endScale",getEndScale()); center.startSpin=Angle( Degree( table.getFloat("startSpin",getStartSpin().valueDegrees()) ) ); center.endSpin =Angle( Degree( table.getFloat("endSpin" ,getEndSpin().valueDegrees() ) ) ); center.startColor=table.get("startColor",getStartColor()).toNormalize(); center.endColor=table.get("endColor",getEndColor()).toNormalize(); center.life=table.getFloat("life",getLife()); ////////////////////////////////////////////////////////// var.position=table.getVector2D("positionVar",getPositionVar()); var.dir=table.getVector2D("directionVar",getDirectionVar()); var.startScale=table.getVector2D("startScaleVar",getStartScaleVar()); var.endScale=table.getVector2D("endScaleVar",getEndScaleVar()); var.startSpin=Angle( Degree( table.getFloat("startSpinVar",getStartSpinVar().valueDegrees()) ) ); var.endSpin =Angle( Degree( table.getFloat("endSpinVar",getEndSpinVar().valueDegrees()) ) ); var.startColor=table.get("startColorVar",getStartColorVar()).toNormalize(); var.endColor=table.get("endColorVar",getEndColorVar()).toNormalize(); var.life=table.getFloat("lifeVar",getLifeVar()); ////////////////////////////////////////////////////////// }
int updateNewTable(vector<ihead_t> &iheadvec, vector<ohead_t> &oheadvec, Table &itab, Table &otab, int orowoff) { unsigned i, row; char c; std::stringstream valstream; if(itab.getNbrofrows()+orowoff>otab.getNbrofrows()) return -1; for(i=0; i<min(iheadvec.size(),oheadvec.size()); i++) { // write out tablehead c = oheadvec[i].oname[0]; if('$'==c || '+'==c || '-'==c || '%'==c || '['==c || ']'==c) { otab.Tablewrite(0, oheadvec[i].ocol, oheadvec[i].oname.substr(1,std::string::npos)); } else { otab.Tablewrite(0, oheadvec[i].ocol, oheadvec[i].oname); } // process/write table content for(row=1; row<itab.getNbrofrows(); row++) { if(1>iheadvec[i].iname.size()) return -4; if(-2==iheadvec[i].icol) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, iheadvec[i].iname.substr(1, std::string::npos)); } else if('$'==oheadvec[i].oname[0]) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, ""); valstream.str(""); valstream << std::scientific << norm_value(itab.Tableread(row, iheadvec[i].icol)); otab.Tablewrite(row + orowoff, oheadvec[i].ocol, valstream.str()); } else if('%'==oheadvec[i].oname[0]) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, to_string(is_relative(itab.Tableread(row, iheadvec[i].icol)))); } else if('\\'==oheadvec[i].oname[0]) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, firstword(itab.Tableread(row, iheadvec[i].icol))); } else if('+'==oheadvec[i].oname[0]) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, ""); valstream.str(""); valstream << std::scientific << tolupp(itab.Tableread(row, iheadvec[i].icol)); otab.Tablewrite(row + orowoff, oheadvec[i].ocol, valstream.str()); } else if('-'==oheadvec[i].oname[0]) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, ""); valstream.str(""); valstream << std::scientific << tollow(itab.Tableread(row, iheadvec[i].icol)); otab.Tablewrite(row + orowoff, oheadvec[i].ocol, valstream.str()); } else if('['==oheadvec[i].oname[0]) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, ""); valstream.str(""); valstream << std::scientific << vallow(norm_value(itab.Tableread(row, iheadvec[i+1].icol)), tollow(itab.Tableread(row, iheadvec[i].icol)), is_relative(itab.Tableread(row, iheadvec[i].icol))); otab.Tablewrite(row + orowoff, oheadvec[i].ocol, valstream.str()); } else if(']'==oheadvec[i].oname[0]) { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, ""); valstream.str(""); valstream << std::scientific << valupp(norm_value(itab.Tableread(row, iheadvec[i-1].icol)), tolupp(itab.Tableread(row, iheadvec[i].icol)), is_relative(itab.Tableread(row, iheadvec[i].icol))); otab.Tablewrite(row + orowoff, oheadvec[i].ocol, valstream.str()); } else { otab.Tablewrite(row + orowoff, oheadvec[i].ocol, itab.Tableread(row, iheadvec[i].icol)); } if(false==otab.OK) return -2; if(false==itab.OK) return -3; } } return 0; }
void assert_field_name( Table &td, int field_index, const string &name ) { ASSERT_STREQ( td.fields()[ field_index ].name().c_str(), name.c_str() ); }
void b2g_ps_add_table_headers(Table& t, bool show_threads) { t.start_row(); t.add("NAME"); t.add(show_threads ? "TID" : "PID"); t.add("PPID"); t.add("CPU(s)"); t.add("NICE"); t.add("USS"); t.add("PSS"); t.add("RSS"); t.add("SWAP"); t.add("VSIZE"); t.add("OOM_ADJ"); t.add("USER", Table::ALIGN_LEFT); }
void generateFKey(map<string, Table>& tables) { map<string, Table>::iterator tableIte = tables.begin(); vector<Table> linkers; ForeignKey foreignKey; while (tableIte != tables.end()) { if (!tableIte->second.getAssociation().empty()) { vector <Association> tmpAssociation = tableIte->second.getAssociation(); vector <Association>::iterator associationIter = tmpAssociation.begin(); while (associationIter != tmpAssociation.end()) { //these are all one-to-many. if (isMultiplicity(associationIter->startTable) && !isMultiplicity(associationIter->anotherTable)) { map<string, Table>::iterator tmpTableIte = tables.find( associationIter->anotherTable.name); if(!tmpTableIte->second.getPK().empty()){ foreignKey.associationClassName = associationIter->anotherTable.name; foreignKey.attributes = tmpTableIte->second.getPK(); tableIte->second.setFK(foreignKey); tableIte->second.setAttribute(foreignKey.attributes); foreignKey.attributes.clear(); foreignKey.associationClassName.clear(); } } else if (!isMultiplicity(associationIter->startTable) && isMultiplicity(associationIter->anotherTable)) { foreignKey.associationClassName = associationIter->startTable.name; map<string, Table>::iterator tmpTableIte = tables.find( associationIter->anotherTable.name); if(!tableIte->second.getPK().empty()){ foreignKey.attributes = tableIte->second.getPK(); tmpTableIte->second.setFK(foreignKey); tmpTableIte->second.setAttribute(foreignKey.attributes); foreignKey.attributes.clear(); foreignKey.associationClassName.clear(); } }//it is many to many,so I create a linker to set it as one to many else if (isMultiplicity(associationIter->startTable) && isMultiplicity(associationIter->anotherTable)) { if (associationIter->link.nameOfAssociationClass.empty() && tableIte->first == associationIter->startTable.name){ Table newLink; string name = associationIter->startTable.name; string of = "_"; name += of; name += associationIter->anotherTable.name; newLink.setTableName(name); //set the first FK and attributes map<string, Table>::iterator aTableIte = tables.find( associationIter->anotherTable.name); if (!aTableIte->second.getPK().empty()) { foreignKey.associationClassName = associationIter->anotherTable.name; foreignKey.attributes = aTableIte->second.getPK(); newLink.setFK(foreignKey); vector <Attribute>::iterator attributeIte = foreignKey.attributes.begin(); while(attributeIte != foreignKey.attributes.end()){ attributeIte->id = "ID"; attributeIte++; } newLink.setAttribute(foreignKey.attributes); foreignKey.attributes.clear(); foreignKey.associationClassName.clear(); } //set another FK and attributes map<string, Table>::iterator sTableIte = tables.find(associationIter->startTable.name); if (!sTableIte->second.getPK().empty()) { foreignKey.associationClassName = associationIter->startTable.name; foreignKey.attributes = sTableIte->second.getPK(); newLink.setFK(foreignKey); vector <Attribute>::iterator attributeIte = foreignKey.attributes.begin(); while(attributeIte != foreignKey.attributes.end()){ attributeIte->id = "ID"; attributeIte++; } newLink.setAttribute(foreignKey.attributes); foreignKey.attributes.clear(); foreignKey.associationClassName.clear(); } newLink.setPK(); linkers.push_back(newLink); }else { editLink(tables, *associationIter); } }//here is one-to-one model else { //set another table's FK foreignKey.associationClassName = associationIter->startTable.name; map<string, Table>::iterator tmpTableIte = tables.find( associationIter->anotherTable.name); if (!tableIte->second.getPK().empty()) { foreignKey.attributes = tableIte->second.getPK(); tmpTableIte->second.setFK(foreignKey); tmpTableIte->second.setAttribute(foreignKey.attributes); foreignKey.attributes.clear(); foreignKey.associationClassName.clear(); } //set current table's FK foreignKey.associationClassName = associationIter->anotherTable.name; tmpTableIte = tables.find(associationIter->anotherTable.name); if (!tmpTableIte->second.getPK().empty()) { foreignKey.attributes = tmpTableIte->second.getPK(); tableIte->second.setFK(foreignKey); tableIte->second.setAttribute(foreignKey.attributes); foreignKey.attributes.clear(); foreignKey.associationClassName.clear(); } } associationIter++; } } tableIte++; } //insert new table into container vector<Table>::iterator linkIte = linkers.begin(); while (linkIte != linkers.end()) { tables.insert(make_pair(linkIte->getTableName(), *linkIte)); linkIte++; } }