END_TEST START_TEST (test_unitdefinition_convert_SI2) { UnitDefinition *ud = new UnitDefinition(1, 1); UnitDefinition *ud1; Unit * u = ud->createUnit(); u->setKind(UNIT_KIND_FARAD); ud1 = UnitDefinition::convertToSI(ud); fail_unless( ud1->getNumUnits() == 4); fail_unless( ud1->getLevel() == 1); fail_unless( ud1->getVersion() == 1); fail_unless( ud1->getUnit(0)->getKind() == UNIT_KIND_AMPERE ); fail_unless( ud1->getUnit(0)->getExponent() == 2); fail_unless( ud1->getUnit(1)->getKind() == UNIT_KIND_KILOGRAM ); fail_unless( ud1->getUnit(1)->getExponent() == -1); fail_unless( ud1->getUnit(2)->getKind() == UNIT_KIND_METRE ); fail_unless( ud1->getUnit(2)->getExponent() == -2); fail_unless( ud1->getUnit(3)->getKind() == UNIT_KIND_SECOND ); fail_unless( ud1->getUnit(3)->getExponent() == 4); UnitDefinition_free(ud); }
END_TEST START_TEST(test_unitdefinition_convert_SI) { UnitDefinition* ud = new UnitDefinition(2, 4); UnitDefinition* ud1 = new UnitDefinition(2, 4); Unit* u = new Unit(2, 4); u->setKind(UNIT_KIND_JOULE); Unit* u1 = new Unit(2, 4); u1->setKind(UNIT_KIND_NEWTON); u1->setExponent(-1); ud->addUnit(u); ud->addUnit(u1); ud1 = UnitDefinition::convertToSI(ud); fail_unless(ud1->getNumUnits() == 1); fail_unless(ud1->getUnit(0)->getKind() == UNIT_KIND_METRE); /* NULL case*/ ud = NULL; ud1 = UnitDefinition::convertToSI(ud); fail_unless(ud1 == NULL); delete u; delete u1; delete ud; delete ud1; }
END_TEST #if (0) START_TEST (test_getUnitDefinition_power_minus_double_exponent) { ASTNode * node = new ASTNode(AST_POWER); ASTNode * c = new ASTNode(AST_NAME); c->setName("k"); ASTNode * c1 = new ASTNode(AST_REAL); c1->setValue(0.3); ASTNode * c2 = new ASTNode(AST_MINUS); c2->addChild(c1); node->addChild(c); node->addChild(c2); UnitDefinition * ud = NULL; ud = uff->getUnitDefinition(node); fail_unless(uff->getContainsUndeclaredUnits() == false); fail_unless(uff->canIgnoreUndeclaredUnits() == false); fail_unless(ud != NULL); fail_unless(ud->getNumUnits() == 1); fail_unless(ud->getUnit(0)->getKind() == UNIT_KIND_METRE); fail_unless(util_isEqual(ud->getUnit(0)->getExponentAsDouble(), -0.3)); delete node; delete ud; }
/* * Converts a Watt Unit into the corresponding UnitDefinition * consisting only of SI units. * If the given unit does not have the correct kind, a NULL pointer is * returned. * It is up to the receiver to free the memory of the returned * UnitDefinition. * @param const Unit& unit * @return UnitDefinition* result */ LIBSBML_EXTERN UnitDefinition* UnitConversionFactory::convertWattToSI(const Unit& unit) { UnitKind_t uKind = unit.getKind(); if (uKind != UNIT_KIND_WATT) return NULL; UnitDefinition* pUdef = new UnitDefinition(UnitConversionFactory::SBML_LEVEL, UnitConversionFactory::SBML_VERSION); Unit* pU = new Unit(unit); pU->setOffset(0.0); pU->setKind(UNIT_KIND_KILOGRAM); pU->setExponent(unit.getExponent()); pUdef->addUnit(pU); delete pU; pU = new Unit(UnitConversionFactory::SBML_LEVEL, UnitConversionFactory::SBML_VERSION); pU->setKind(UNIT_KIND_METER); pU->setExponent(2*unit.getExponent()); pUdef->addUnit(pU); delete pU; pU = new Unit(UnitConversionFactory::SBML_LEVEL, UnitConversionFactory::SBML_VERSION); pU->setKind(UNIT_KIND_SECOND); pU->setExponent(-3*unit.getExponent()); pUdef->addUnit(pU); delete pU; return pUdef; }
END_TEST START_TEST (test_getUnitDefinition_power_one_child) { ASTNode * node = new ASTNode(AST_POWER); ASTNode * c = new ASTNode(AST_NAME); c->setName("k"); node->addChild(c); UnitDefinition * ud = NULL; ud = uff->getUnitDefinition(node); fail_unless(uff->getContainsUndeclaredUnits() == true); fail_unless(uff->canIgnoreUndeclaredUnits() == false); fail_unless(ud != NULL); fail_unless(ud->getNumUnits() == 1); fail_unless(ud->getUnit(0)->getKind() == UNIT_KIND_METRE); fail_unless(util_isEqual(ud->getUnit(0)->getExponent(), 1)); delete node; delete ud; }
END_TEST START_TEST ( test_UnitDefinition_parent_NULL ) { SBMLDocument *d = new SBMLDocument(); Model *m = d->createModel(); UnitDefinition *c = m->createUnitDefinition(); Unit *u = c->createUnit(); fail_unless(u->getAncestorOfType(SBML_UNIT_DEFINITION) == c); UnitDefinition *c1 = c->clone(); delete d; fail_unless(c1->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getParentSBMLObject() == NULL); fail_unless (c1->getSBMLDocument() == NULL); fail_unless(c1->getUnit(0)->getAncestorOfType(SBML_UNIT_DEFINITION) == c1); fail_unless(c1->getUnit(0)->getParentSBMLObject() != NULL); fail_unless (c1->getUnit(0)->getSBMLDocument() == NULL); delete c1; }
END_TEST START_TEST (test_WriteL3SBML_UnitDefinition) { const char* expected = "<unitDefinition id=\"myUnit\">\n" " <listOfUnits>\n" " <unit kind=\"mole\" exponent=\"1\" scale=\"0\" multiplier=\"1.8\"/>\n" " </listOfUnits>\n" "</unitDefinition>"; UnitDefinition* ud = D->createModel()->createUnitDefinition(); ud->setId("myUnit"); Unit* u1 = ud->createUnit(); u1->setKind(UnitKind_forName("mole")); u1->setMultiplier(1.8); u1->setScale(0); u1->setExponent(1); char* sbml = ud->toSBML(); fail_unless( equals(expected, sbml) ); safe_free(sbml); }
/** * Checks that the units of the arguments * of the function are dimensionless * and that there is only one argument * * If inconsistent units are found, an error message is logged. */ void ArgumentsUnitsCheckWarnings::checkDimensionlessArgs (const Model& m, const ASTNode& node, const SBase & sb, bool inKL, int reactNo) { /* check that node has children */ if (node.getNumChildren() == 0) { return; } UnitDefinition *dim = new UnitDefinition(m.getSBMLNamespaces()); Unit *unit = new Unit(m.getSBMLNamespaces()); unit->setKind(UNIT_KIND_DIMENSIONLESS); unit->initDefaults(); UnitDefinition * tempUD; dim->addUnit(unit); UnitFormulaFormatter *unitFormat = new UnitFormulaFormatter(&m); tempUD = unitFormat->getUnitDefinition(node.getChild(0), inKL, reactNo); if (tempUD->getNumUnits() != 0 && !UnitDefinition::areEquivalent(dim, tempUD)) { logInconsistentDimensionless(node, sb); } delete tempUD; delete dim; delete unit; delete unitFormat; }
END_TEST #endif START_TEST (test_getUnitDefinition_power_dim_param_exponent) { ASTNode * node = new ASTNode(AST_POWER); ASTNode * c = new ASTNode(AST_NAME); c->setName("k"); ASTNode * c1 = new ASTNode(AST_NAME); c1->setName("a"); node->addChild(c); node->addChild(c1); UnitDefinition * ud = NULL; ud = uff->getUnitDefinition(node); fail_unless(uff->getContainsUndeclaredUnits() == false); fail_unless(uff->canIgnoreUndeclaredUnits() == false); fail_unless(ud != NULL); fail_unless(ud->getNumUnits() == 1); fail_unless(ud->getUnit(0)->getKind() == UNIT_KIND_METRE); fail_unless(util_isEqual(ud->getUnit(0)->getExponentAsDouble(), 3.5)); delete node; delete ud; }
END_TEST START_TEST(test_unitdefinition_areIdentical2) { UnitDefinition* ud = new UnitDefinition(2, 2); UnitDefinition* ud1 = new UnitDefinition(2, 2); Unit* u = new Unit(2, 2); u->setKind(UNIT_KIND_JOULE); Unit* u1 = new Unit(2, 2); u1->setKind(UNIT_KIND_NEWTON); ud->addUnit(u); ud->addUnit(u1); ud1->addUnit(u); ud1->addUnit(u1); int identical = UnitDefinition::areIdentical(ud, ud1); fail_unless(identical == 1); delete u; delete u1; delete ud; delete ud1; }
END_TEST START_TEST (test_getUnitDefinition_power_three_children) { ASTNode * node = new ASTNode(AST_POWER); ASTNode * c = new ASTNode(AST_NAME); c->setName("k"); ASTNode * c1 = new ASTNode(AST_INTEGER); c1->setValue(1); ASTNode * c2 = new ASTNode(AST_INTEGER); c2->setValue(2); node->addChild(c); node->addChild(c1); node->addChild(c2); UnitDefinition * ud = NULL; ud = uff->getUnitDefinition(node); fail_unless(uff->getContainsUndeclaredUnits() == true); fail_unless(uff->canIgnoreUndeclaredUnits() == false); fail_unless(ud != NULL); fail_unless(ud->getNumUnits() == 0); delete node; delete ud; }
END_TEST START_TEST(test_unitdefinition_divide1) { UnitDefinition* ud = new UnitDefinition(2, 1); UnitDefinition* ud1 = new UnitDefinition(2, 2); UnitDefinition* udTemp; Unit* u = new Unit(2, 1); u->setKind(UNIT_KIND_METRE); Unit* u1 = new Unit(2, 2); u1->setKind(UNIT_KIND_MOLE); ud->addUnit(u); ud1->addUnit(u1); udTemp = UnitDefinition::divide(ud, ud1); fail_unless(udTemp == 0); delete u; delete ud1; delete u1; delete ud; }
END_TEST START_TEST ( test_UnitDefinition_L1 ) { UnitDefinition* ud = new UnitDefinition(1, 2); fail_unless (ud->hasRequiredElements()); delete ud; }
END_TEST START_TEST(test_unitdefinition_areIdentical) { UnitDefinition* ud = new UnitDefinition(2, 4); UnitDefinition* ud1 = new UnitDefinition(2, 4); Unit* u = new Unit(2, 4); u->setKind(UNIT_KIND_JOULE); Unit* u1 = new Unit(2, 4); u1->setKind(UNIT_KIND_NEWTON); Unit* u2 = new Unit(2, 4); u2->setKind(UNIT_KIND_METRE); ud->addUnit(u); ud->addUnit(u1); ud1->addUnit(u); ud1->addUnit(u1); int identical = UnitDefinition::areIdentical(ud, ud1); fail_unless(identical == 1); ud->addUnit(u2); identical = UnitDefinition::areIdentical(ud, ud1); fail_unless(identical == 0); /* NULL case*/ ud = NULL; identical = UnitDefinition::areIdentical(ud, ud1);; fail_unless(identical == 0); identical = UnitDefinition::areIdentical(ud1, ud);; fail_unless(identical == 0); ud1 = NULL; identical = UnitDefinition::areIdentical(ud, ud1);; fail_unless(identical == 1); delete u; delete u1; delete u2; delete ud; delete ud1; }
END_TEST START_TEST (test_CalcUnitDefinition_local1) { UnitDefinition *fud = m->getReaction("R5")->getKineticLaw() ->getLocalParameter(0)->getDerivedUnitDefinition(); fail_unless(fud->getNumUnits() == 0); m->getReaction("R5")->getKineticLaw() ->getLocalParameter(0)->setCalculatingUnits(true); fud = m->getReaction("R5")->getKineticLaw() ->getLocalParameter(0)->getDerivedUnitDefinition(); m->getReaction("R5")->getKineticLaw() ->getLocalParameter(0)->setCalculatingUnits(false); fail_unless(fud->getNumUnits() == 1); fail_unless(!strcmp(fud->getId().c_str(), ""), NULL); fail_unless(fud->getUnit(0)->getMultiplier() == 1); fail_unless(fud->getUnit(0)->getScale() == 0); fail_unless(fud->getUnit(0)->getExponent() == 1); fail_unless(fud->getUnit(0)->getOffset() == 0.0); fail_unless(fud->getUnit(0)->getKind() == UNIT_KIND_SECOND); }
END_TEST START_TEST(test_unitdefinition_areEquivalent) { UnitDefinition* ud = new UnitDefinition(2, 4); UnitDefinition* ud1 = new UnitDefinition(2, 4); Unit* u = new Unit(2, 4); u->setKind(UNIT_KIND_JOULE); Unit* u1 = new Unit(2, 4); u1->setKind(UNIT_KIND_NEWTON); Unit* u2 = new Unit(2, 4); u->setKind(UNIT_KIND_METRE); u1->setExponent(-1); ud->addUnit(u); ud->addUnit(u1); ud1->addUnit(u2); int equivalent = UnitDefinition::areEquivalent(ud, ud1); //fail_unless(equivalent == 1); ud->addUnit(u2); equivalent = UnitDefinition::areEquivalent(ud, ud1); fail_unless(equivalent == 0); /* NULL case*/ ud = NULL; equivalent = UnitDefinition::areEquivalent(ud, ud1); fail_unless(equivalent == 0); equivalent = UnitDefinition::areEquivalent(ud1, ud); fail_unless(equivalent == 0); ud1 = NULL; equivalent = UnitDefinition::areEquivalent(ud, ud1); fail_unless(equivalent == 1); delete u; delete u1; delete u2; delete ud; delete ud1; }
/* * Returns a string representation of the given Unit. THis function is * only for debugging purposes. * @param const UnitDefinition& uDef * @return std::string unitDefinitionRepresentation */ LIBSBML_EXTERN std::string UnitConversionFactory::toString(const UnitDefinition& uDef) { unsigned int maxUnits = uDef.getNumUnits(); unsigned int i; std::stringstream ss; for (i = 0; i < maxUnits; ++i) { ss << "(" << UnitConversionFactory::toString(*(uDef.getUnit(i))) << ") "; } return ss.str(); }
END_TEST START_TEST ( test_UnitDefinition ) { UnitDefinition* ud = new UnitDefinition(2, 4); fail_unless (!(ud->hasRequiredAttributes())); ud->setId("ud"); fail_unless (ud->hasRequiredAttributes()); delete ud; }
END_TEST START_TEST ( test_UnitDefinition_parent_create ) { Model *m = new Model(2, 4); UnitDefinition *ud = m->createUnitDefinition(); ListOf *lo = m->getListOfUnitDefinitions(); fail_unless(lo == m->getUnitDefinition(0)->getParentSBMLObject()); fail_unless(lo == ud->getParentSBMLObject()); fail_unless(m == lo->getParentSBMLObject()); }
/* * Converts a Second Unit into the corresponding UnitDefinition * consisting only of SI units. * If the given unit does not have the correct kind, a NULL pointer is * returned. * It is up to the receiver to free the memory of the returned * UnitDefinition. * @param const Unit& unit * @return UnitDefinition* result */ LIBSBML_EXTERN UnitDefinition* UnitConversionFactory::convertSecondToSI(const Unit& unit) { UnitKind_t uKind = unit.getKind(); if (uKind != UNIT_KIND_SECOND) return NULL; UnitDefinition* pUdef = new UnitDefinition(UnitConversionFactory::SBML_LEVEL, UnitConversionFactory::SBML_VERSION); Unit* pU = new Unit(unit); pU->setOffset(0.0); pUdef->addUnit(pU); delete pU; return pUdef; }
END_TEST START_TEST(test_unitdefinition_divide2) { UnitDefinition* ud = new UnitDefinition(2, 2); UnitDefinition* ud1 = new UnitDefinition(2, 2); UnitDefinition* udTemp; Unit* u = ud->createUnit(); u->setKind(UNIT_KIND_METRE); Unit* u1 = ud1->createUnit(); u1->setKind(UNIT_KIND_MOLE); udTemp = UnitDefinition::divide(ud, ud1); fail_unless(udTemp->getNumUnits() == 2); fail_unless(udTemp->getUnit(0)->getKind() == UNIT_KIND_METRE); fail_unless(udTemp->getUnit(1)->getKind() == UNIT_KIND_MOLE); fail_unless(udTemp->getUnit(1)->getExponent() == -1); fail_unless(udTemp->getLevel() == 2); fail_unless(udTemp->getVersion() == 2); delete ud1; delete ud; delete udTemp; }
std::string Expression2PresentationMMLUnits::getMathML(const UnitDefinition & ud) const { std::string tmp; /*tmp += "<mrow>"; unsigned int i, imax = ud.getNumUnits(); for (i=0; i<imax; ++i) { if (i) tmp += "<mo>·</mo>"; tmp += getMathML(ud.getUnit(i), false); } tmp += "</mrow>";*/ tmp += "<mrow>"; bool isFirst = true; unsigned int i, imax = ud.getNumUnits(); for (i = 0; i < imax; ++i) { if (ud.getUnit(i)->getExponent() >= 0) { if (!isFirst) tmp += "<mo>·</mo>"; tmp += getMathML(ud.getUnit(i), true); isFirst = false; } } if (isFirst) tmp += "<mn>1</mn>"; //there are no units with pos. exponent std::string tmp2; isFirst = true; for (i = 0; i < imax; ++i) { if (ud.getUnit(i)->getExponent() < 0) { if (!isFirst) tmp2 += "<mo>·</mo>"; tmp2 += getMathML(ud.getUnit(i), true); isFirst = false; } } if (!isFirst) tmp += "<mo>/</mo>" + tmp2; //only create fraction when there is a denominator tmp += "</mrow>"; return tmp; }
END_TEST START_TEST ( test_UnitDefinition ) { UnitDefinition* ud = new UnitDefinition(2, 4); fail_unless (!(ud->hasRequiredElements())); ud->createUnit(); fail_unless (ud->hasRequiredElements()); delete ud; }
END_TEST START_TEST (test_UnitFormulaFormatter2_getUnitDefinition_model_extent) { UnitDefinition * ud = NULL; /* model extent units */ ud = uff->getExtentUnitDefinition(); fail_unless(ud->getNumUnits() == 1); fail_unless(!strcmp(ud->getId().c_str(), ""), NULL); fail_unless(ud->getUnit(0)->getMultiplier() == 1); fail_unless(ud->getUnit(0)->getScale() == 0); fail_unless(ud->getUnit(0)->getExponent() == 1); fail_unless(ud->getUnit(0)->getOffset() == 0.0); fail_unless(ud->getUnit(0)->getKind() == UNIT_KIND_MOLE); /* check deals with invalid nodes */ delete ud; UnitDefinition * ud1 = NULL; m->unsetExtentUnits(); ud1 = uff->getExtentUnitDefinition(); fail_unless (ud1->getNumUnits() == 0); delete ud1; }
END_TEST START_TEST (test_UnitFormulaFormatter_getUnitDefinition_plus) { UnitDefinition * ud = new UnitDefinition(2, 4); ud = uff->getUnitDefinition(m->getRule(3)->getMath()); fail_unless(ud->getNumUnits() == 1); fail_unless(!strcmp(ud->getId().c_str(), ""), NULL); fail_unless(ud->getUnit(0)->getMultiplier() == 1); fail_unless(ud->getUnit(0)->getScale() == 0); fail_unless(ud->getUnit(0)->getExponent() == 1); fail_unless(ud->getUnit(0)->getOffset() == 0.0); fail_unless(ud->getUnit(0)->getKind() == UNIT_KIND_METRE); /* check an invalid node */ delete ud; UnitDefinition * ud1 = new UnitDefinition(m->getLevel(), m->getVersion()); ASTNode *node = new ASTNode(AST_PLUS); ud1 = uff->getUnitDefinition(node); fail_unless (ud1->getNumUnits() == 0); delete ud1; delete node; }
/* * Constructs and returns a UnitDefinition that expresses the units of this * LocalParameter. */ UnitDefinition * LocalParameter::getDerivedUnitDefinition() { /* if we have the whole model but it is not in a document * it is still possible to determine the units */ Model * m = static_cast <Model *> (getAncestorOfType(SBML_MODEL)); if (m != NULL) { if (!m->isPopulatedListFormulaUnitsData()) { m->populateListFormulaUnitsData(); } UnitDefinition *ud = NULL; const char * units = getUnits().c_str(); if (!strcmp(units, "")) { ud = new UnitDefinition(getSBMLNamespaces()); return ud; } else { if (UnitKind_isValidUnitKindString(units, getLevel(), getVersion())) { Unit * unit = new Unit(getSBMLNamespaces()); unit->setKind(UnitKind_forName(units)); unit->initDefaults(); ud = new UnitDefinition(getSBMLNamespaces()); ud->addUnit(unit); delete unit; } else { /* must be a unit definition */ ud = static_cast <Model *> (getAncestorOfType(SBML_MODEL))->getUnitDefinition(units); } return ud; } } else { return NULL; } }
END_TEST START_TEST (test_CalcUnitDefinition_global_with_local_unknown) { UnitDefinition *fud = m->getParameter("r")->getDerivedUnitDefinition(); fail_unless(fud->getNumUnits() == 0); m->getParameter("r")->setCalculatingUnits(true); fud = m->getParameter("r")->getDerivedUnitDefinition(); m->getParameter("r")->setCalculatingUnits(false); fail_unless(fud == NULL); }
/* * Converts a "Dimensionless" Unit into the corresponding UnitDefinition * consisting only of SI units. This would include e.g. the Radian unit. * If the given unit does not have the correct kind, a NULL pointer is * returned. * It is up to the receiver to free the memory of the returned * UnitDefinition. * @param const Unit& unit * @return UnitDefinition* result */ LIBSBML_EXTERN UnitDefinition* UnitConversionFactory::convertDimensionlessToSI(const Unit& unit) { UnitKind_t uKind = unit.getKind(); if (uKind != UNIT_KIND_DIMENSIONLESS && uKind != UNIT_KIND_ITEM && uKind != UNIT_KIND_RADIAN && uKind != UNIT_KIND_STERADIAN) return NULL; UnitDefinition* pUdef = new UnitDefinition(UnitConversionFactory::SBML_LEVEL, UnitConversionFactory::SBML_VERSION); Unit* pU = new Unit(unit); pU->setKind(UNIT_KIND_DIMENSIONLESS); pU->setOffset(0.0); pUdef->addUnit(pU); delete pU; return pUdef; }
/* * Checks that the units of the delay function are consistent * * If inconsistent units are found, an error message is logged. */ void ArgumentsUnitsCheck::checkUnitsFromDelay (const Model& m, const ASTNode& node, const SBase & sb, bool inKL, int reactNo) { /* check that node has two children */ if (node.getNumChildren() != 2) { return; } if (!m.getSBMLNamespaces()->getNamespaces()) { #if 0 cout << "[DEBUG] XMLNS IS NULL" << endl; #endif } /* delay(x, t) * no restrictions on units of x * but t must have units of time */ UnitDefinition *time = new UnitDefinition(m.getSBMLNamespaces()); Unit *unit = new Unit(m.getSBMLNamespaces()); unit->setKind(UNIT_KIND_SECOND); unit->initDefaults(); UnitDefinition * tempUD; time->addUnit(unit); UnitFormulaFormatter *unitFormat = new UnitFormulaFormatter(&m); tempUD = unitFormat->getUnitDefinition(node.getRightChild(), inKL, reactNo); if (!unitFormat->getContainsUndeclaredUnits()) { if (!UnitDefinition::areEquivalent(time, tempUD)) { logInconsistentDelay(node, sb); } } delete time; delete tempUD; delete unit; delete unitFormat; checkUnits(m, *node.getLeftChild(), sb, inKL, reactNo); }
/* * The functions determins wether the given UnitDefinition contains only * units from the list given as the second argument. * @param const UnitDefinition& uDef * @param const ListOf& unitList * @return bool containsOnlyGivenUnits */ LIBSBML_EXTERN bool UnitConversionFactory::containsOnlyGivenUnits(const UnitDefinition& uDef, const ListOf& unitList) { bool result = true; UnitDefinition* pTmpUdef = UnitConversionFactory::convertToSI(uDef); if (pTmpUdef) { unsigned int i; unsigned int maxUnits = pTmpUdef->getNumUnits(); for (i = 0; i < maxUnits; ++i) { Unit* pU = pTmpUdef->getUnit(i); UnitKind_t kind = pU->getKind(); unsigned int j; unsigned int maxUnits2 = unitList.size(); bool found = false; for (j = 0; j < maxUnits2; ++j) { const Unit* pU2 = dynamic_cast<const Unit*>(unitList.get(j)); if (!pU2) break; if (pU2->getKind() == kind) { found = true; break; } } if (!found) { result = false; break; } } delete pTmpUdef; } else { result = false; } return result; }