00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00024
00025 #include <QVDisjointSet>
00026 #include <QVPropertyContainer>
00027
00028 uint QVPropertyContainer::maxIdent = 0;
00029
00030
00031 QVPropertyContainer::QVPropertyContainer(const QString name):
00032 name(name), errorString(), variants(), safelyCopiedVariants(), minimum(),
00033 maximum(), _info(), io_flags(), link_flags(), insertion_order(),
00034 inputLinks(), outputLinks()
00035 {
00036 ident = getNewIdent();
00037 qDebug() << "QVPropertyContainer::QVPropertyContainer(" << name << ")";
00038 if(qvApp == NULL)
00039 {
00040 QString str = "QVPropertyContainer::QVPropertyContainer(): holder " + name +
00041 ": property holders cannot be created before the " +
00042 "QVApplication instance. Aborting now.";
00043 std::cerr << qPrintable(str) << std::endl;
00044 exit(1);
00045 }
00046 else
00047 {
00048 qvApp->registerQVPropertyContainer(this);
00049
00050 }
00051 qDebug() << "QVPropertyContainer::QVPropertyContainer(" << name << ") <- return";
00052 }
00053
00054 QVPropertyContainer::QVPropertyContainer(const QVPropertyContainer &cont):
00055 name(cont.name), ident(cont.ident), errorString(cont.errorString), variants(cont.variants),
00056 safelyCopiedVariants(cont.safelyCopiedVariants), minimum(cont.minimum), maximum(cont.maximum),
00057 _info(cont._info), io_flags(cont.io_flags), link_flags(cont.link_flags), insertion_order(cont.insertion_order),
00058 RWLock(), inputLinks(cont.inputLinks), outputLinks(cont.outputLinks)
00059 {
00060 qDebug() << "QVPropertyContainer::QVPropertyContainer(" << name << ")";
00061 if(qvApp == NULL)
00062 {
00063 QString str = "QVPropertyContainer::QVPropertyContainer(): holder " + name +
00064 ": property holders cannot be created before the " +
00065 "QVApplication instance. Aborting now.";
00066 std::cerr << qPrintable(str) << std::endl;
00067 exit(1);
00068 }
00069 else
00070 {
00071 qvApp->registerQVPropertyContainer(this);
00072
00073 }
00074 qDebug() << "QVPropertyContainer::QVPropertyContainer(" << name << ") <- return";
00075 }
00076
00077 QVPropertyContainer & QVPropertyContainer::operator=(const QVPropertyContainer &cont)
00078 {
00079 name = cont.name;
00080 ident = cont.ident;
00081 errorString = cont.errorString;
00082 variants = cont.variants;
00083 safelyCopiedVariants = cont.safelyCopiedVariants;
00084 minimum = cont.minimum;
00085 maximum = cont.maximum;
00086 _info = cont._info;
00087 io_flags = cont.io_flags;
00088 link_flags = cont.link_flags;
00089 insertion_order = cont.insertion_order;
00090 inputLinks = cont.inputLinks;
00091 outputLinks = cont.outputLinks;
00092
00093 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::All));
00094 return *this;
00095 }
00096
00097 QVPropertyContainer::~QVPropertyContainer()
00098 {
00099 if(qvApp != NULL)
00100 qvApp->deregisterQVPropertyContainer(this);
00101
00102 unlink();
00103 readInputProperties();
00104 writeOutputProperties();
00105 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::ContainerDel));
00106 }
00107
00108 void QVPropertyContainer::setName(const QString name)
00109 { this->name = name; informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::Name)); }
00110
00111 const QString QVPropertyContainer::getName() const
00112 { return this->name; }
00113
00114 const uint QVPropertyContainer::getId() const
00115 { return this->ident; }
00116
00117 bool QVPropertyContainer::operator==(const QVPropertyContainer &cont) const
00118 { return (ident == cont.ident); }
00119
00120 QList<QString> QVPropertyContainer::getPropertyList() const
00121 { return variants.keys(); }
00122
00123 bool QVPropertyContainer::containsProperty(const QString name) const
00124 { return variants.contains(name); }
00125
00126 int QVPropertyContainer::getPropertyType(const QString name, bool *ok) const
00127 {
00128 if(not checkExists(name,"QVPropertyContainer::getPropertyType()"))
00129 {
00130 if(ok != NULL) *ok = FALSE;
00131 return QVariant::Invalid;
00132 }
00133 if(ok != NULL) *ok = TRUE;
00134 QVariant variant = variants.value(name);
00135 return variant.userType();
00136 }
00137
00138 bool QVPropertyContainer::removeProperty(const QString name)
00139 {
00140 if(not checkExists(name,"QVPropertyContainer::removeProperty()"))
00141 return FALSE;
00142 this->variants.remove(name);
00143 this->safelyCopiedVariants.remove(name);
00144 this->minimum.remove(name);
00145 this->maximum.remove(name);
00146 this->_info.remove(name);
00147 this->io_flags.remove(name);
00148 int i = this->insertion_order.indexOf(name);
00149 this->insertion_order.removeAt(i);
00150 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::PropertyDel, name));
00151 return TRUE;
00152 }
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182 bool QVPropertyContainer::hasRange(const QString name) const
00183 { return maximum.contains(name) and minimum.contains(name); }
00184
00185 bool QVPropertyContainer::isInput(const QString name) const
00186 { return (io_flags[name] & inputFlag);};
00187
00188 bool QVPropertyContainer::isOutput(const QString name) const
00189 { return (io_flags[name] & outputFlag);};
00190
00191 bool QVPropertyContainer::isGUIInvisible(const QString name) const
00192 { return (io_flags[name] & guiInvisible);};
00193
00194 bool QVPropertyContainer::isLinkedInput(const QString name) const
00195 { return (link_flags[name] & linkedInputFlag);};
00196
00197 bool QVPropertyContainer::isLinkedOutput(const QString name) const
00198 { return (link_flags[name] & linkedOutputFlag);};
00199
00200 QVariant QVPropertyContainer::getPropertyQVariantValue(const QString name, bool *ok) const
00201 {
00202 if (not checkExists(name,"QVPropertyContainer::getPropertyQVariantValue()"))
00203 if(ok != NULL) *ok = FALSE;
00204 else
00205 if(ok != NULL) *ok = TRUE;
00206 return variants[name];
00207 }
00208
00209 QString QVPropertyContainer::getPropertyInfo(const QString name, bool *ok) const
00210 {
00211 if(not checkExists(name,"QVPropertyContainer::getPropertyInfo()"))
00212 if(ok != NULL) *ok = FALSE;
00213 else
00214 if(ok != NULL) *ok = TRUE;
00215 return this->_info[name];
00216 }
00217
00218 QString QVPropertyContainer::getLastError() const
00219 {
00220 return errorString;
00221 }
00222
00223 const QString QVPropertyContainer::infoInputProperties() const
00224 {
00225 qDebug() << "QVPropertyContainer::infoInputProperties(" << getName() << ")";
00226
00227 QString info = QString("Input parameters for ") + getName() + QString(":\n");
00228 bool emptyInfo=TRUE;
00229
00230 qDebug() << "QVPropertyContainer::infoInputProperties(): Properties " << insertion_order;
00231
00232 foreach (QString property, insertion_order)
00233
00234
00235 {
00236
00237
00238 if( not isInput(property) )
00239 continue;
00240
00241 bool printableProperty = TRUE;
00242 QString propertyInfo(" --" + property + "=");
00243
00244 switch(getPropertyType(property))
00245 {
00246 case QVariant::String:
00247 propertyInfo += QString() + "[text] " + "(def. '" + getPropertyValue<QString>(property) + "') ";
00248 break;
00249
00250 case QVariant::Double:
00251 propertyInfo += ( (maximum.contains(property) and minimum.contains(property))?
00252 "[" + QString().setNum(getPropertyMinimum<double>(property)) + "..."
00253 + QString().setNum(getPropertyMaximum<double>(property)) + "] ":
00254 "[double] " ) + "(def. "+ QString().setNum(getPropertyValue<double>(property)) + ") ";
00255 break;
00256
00257 case QVariant::Int:
00258 propertyInfo += ( (maximum.contains(property) and minimum.contains(property))?
00259 "[" + QString().setNum(getPropertyMinimum<int>(property)) + "..." +
00260 QString().setNum(getPropertyMaximum<int>(property)) + "] ":
00261 "[int] " ) + "(def. "+ QString().setNum(getPropertyValue<int>(property)) + ") ";
00262 break;
00263
00264 case QVariant::Bool:
00265 propertyInfo += "[true,false]" + (getPropertyValue<bool>(property) ?
00266 QString(" (def. true) "):QString("(def. false) "));
00267 break;
00268
00269 default:
00270 printableProperty = FALSE;
00271 break;
00272 }
00273
00274 if (printableProperty)
00275 {
00276 info += propertyInfo + getPropertyInfo(property).rightJustified(100-propertyInfo.split('\n').last().length(),' ') + ".\n";
00277 emptyInfo=FALSE;
00278 }
00279 }
00280
00281 qDebug() << "QVPropertyContainer::infoInputProperties(" << getName() << ") <~ return";
00282
00283 if(emptyInfo)
00284 return QString("");
00285
00286 return info;
00287 }
00288
00289 bool QVPropertyContainer::correctRange(const QString name, const double & value) const
00290 {
00291 if(not maximum.contains(name) and not minimum.contains(name))
00292 return TRUE;
00293 double maximum = getPropertyMaximum<double>(name);
00294 double minimum = getPropertyMinimum<double>(name);
00295 if(minimum <= value and maximum >= value)
00296 return TRUE;
00297 else
00298 {
00299 QString str = "QVPropertyContainer::setPropertyValue(): value " +
00300 QString("%1").arg(value) + " for property " +
00301 name + " in holder " + getName() +
00302 "is not valid for the range [" +
00303 QString("%1,%2").arg(minimum).arg(maximum) +
00304 "] stablished for it." ;
00305 setLastError(str);
00306 if(qvApp->isRunning())
00307 {
00308 std::cerr << qPrintable("Warning: " + str + "\n");
00309 }
00310 return FALSE;
00311 }
00312 }
00313
00314 bool QVPropertyContainer::correctRange(const char *name, const int & value) const
00315 { return correctRange(QString(name),static_cast<double>(value)); }
00316
00317 bool QVPropertyContainer::correctRange(QString name, const int & value) const
00318 { return correctRange(name,static_cast<double>(value)); }
00319
00320 bool QVPropertyContainer::checkExists(const QString name, const QString methodname) const
00321 {
00322 if(not variants.contains(name))
00323 {
00324 QString str = methodname + ": property " + name +
00325 " doesn't exists in holder " + getName() + ".";
00326 setLastError(str);
00327 if(qvApp->isRunning()) {
00328 std::cerr << qPrintable("Warning: " + str + "\n");
00329 }
00330 return FALSE;
00331 } else {
00332 return TRUE;
00333 }
00334 }
00335
00336 bool QVPropertyContainer::checkIsNewProperty(const QString name, const QString methodname) const
00337 {
00338 if(variants.contains(name))
00339 {
00340 QString str = methodname + "(): property " + name +
00341 " already exists in holder " + getName() + ".";
00342 setLastError(str);
00343 if(qvApp->isRunning()) {
00344 std::cerr << qPrintable("Warning: " + str + "\n");
00345 }
00346 return FALSE;
00347 } else {
00348 return TRUE;
00349 }
00350 }
00351
00352 bool QVPropertyContainer::linkProperty(QString prop_orig, QVPropertyContainer *qvp_dest, QString prop_dest, LinkType link_type)
00353 {
00354 bool ok1,ok2;
00355 QString errMsg;
00356 int t1,t2;
00357 QVPropertyContainer *qvp_err=NULL;
00358
00359 t1 = this->getPropertyType(prop_orig,&ok1);
00360 t2 = qvp_dest->getPropertyType(prop_dest,&ok2);
00361 if(qvApp->isRunning())
00362 {
00363 qvp_err = this;
00364 errMsg = QString("QVPropertyContainer::linkProperty(): Property holder %1:"
00365 "Cannot link properties after launching QVApplication.\n")
00366 .arg(prop_orig).arg(this->getName());
00367 }
00368 else if(this == qvp_dest)
00369 {
00370 errMsg = QString("QVPropertyContainer::linkProperty(): Property holder %1: cannot link a QVPropertyContainer with itself.\n").arg(this->getName());
00371 qvp_err = this;
00372 }
00373 else if(not ok1)
00374 {
00375 errMsg = QString("QVPropertyContainer::linkProperty(): Property %1 does not exist in property holder %2.\n")
00376 .arg(prop_orig).arg(this->getName());
00377 qvp_err = this;
00378 }
00379 else if (not ok2)
00380 {
00381 errMsg = QString("QVPropertyContainer::linkProperty(): Property %1 does not exist in property holder %2.\n")
00382 .arg(prop_dest).arg(qvp_dest->getName());
00383 qvp_err = qvp_dest;
00384 }
00385 else if(t1 != t2)
00386 {
00387 errMsg = QString("QVPropertyContainer::linkProperty(): Properties %1 and %2 of QVPropertyContainers %3 and %4 respectively are not of the same type.\n").arg(prop_orig).arg(prop_dest).arg(this->getName()).arg(qvp_dest->getName());
00388 qvp_err = this;
00389 }
00390 else if(not (this->io_flags[prop_orig] & outputFlag))
00391 {
00392 errMsg = QString("QVPropertyContainer::linkProperty(): Property %1 of property holder %2 is not of Output type, and cannot be linked as such.\n").arg(prop_orig).arg(this->getName());
00393 qvp_err = this;
00394 }
00395 else if(not (qvp_dest->io_flags[prop_dest] & inputFlag))
00396 {
00397 errMsg = QString("QVPropertyContainer::linkProperty(): Property %1 property holder %2 is not of Input type, and cannot be linked as such.\n").arg(prop_dest).arg(qvp_dest->getName());
00398 qvp_err = qvp_dest;
00399 }
00400
00401 if(errMsg != QString())
00402 {
00403 qvp_err->setLastError(errMsg);
00404 if(qvApp->isRunning()) {
00405 std::cerr << qPrintable("Warning: " + errMsg + "\n");
00406 }
00407 return FALSE;
00408 }
00409 else
00410 {
00411 QVPropertyContainerLink *link = new QVPropertyContainerLink(this,prop_orig,qvp_dest,prop_dest,link_type);
00412 this->outputLinks[prop_orig].push_back(link);
00413 this->link_flags[prop_orig] |= linkedOutputFlag;
00414
00415
00416
00417 qvp_dest->addInputLink(prop_dest, link);
00418
00419
00420
00421 this->RWLock.lockForWrite();
00422 safelyCopiedVariants[prop_orig] = variants[prop_orig];
00423 this->RWLock.unlock();
00424
00425 if (link_type == QVPropertyContainer::AsynchronousLink)
00426 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::LinkAdd, this->getName(), prop_orig, qvp_dest->getName(), prop_dest,FALSE));
00427 else
00428 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::LinkAdd, this->getName(), prop_orig, qvp_dest->getName(), prop_dest,TRUE));
00429 return TRUE;
00430 }
00431 }
00432
00433 void QVPropertyContainer::addInputLink(QString prop_dest, QVPropertyContainerLink *link)
00434 {
00435 inputLinks[prop_dest] = link;
00436 link_flags[prop_dest] |= linkedInputFlag;
00437 }
00438
00439 void QVPropertyContainer::linkProperty(QVPropertyContainer *container, LinkType linkType)
00440 {
00441 QList<QString> localProper = getPropertyList();
00442 QList<QString> inputProper = container->getPropertyList();
00443
00444 qSort(localProper.begin(), localProper.end());
00445 qSort(inputProper.begin(), inputProper.end());
00446
00447 int i=0, l=0;
00448 while ( (i < inputProper.size()) && (l < localProper.size()) )
00449 {
00450 QString localName = localProper[l];
00451 QString inputName = inputProper[i];
00452 if (
00453 (localName == inputName) &&
00454 (getPropertyType(localName) == container->getPropertyType(inputName)) &&
00455 (io_flags[localName] & outputFlag) &&
00456 (container->io_flags[inputName] & inputFlag) &&
00457 (!(io_flags[localName] & internalProp)) &&
00458 (!(container->io_flags[inputName] & internalProp))
00459 )
00460 linkProperty(localProper[l], container, inputProper[i], linkType);
00461
00462 if(localName <= inputName) l++;
00463 if(localName >= inputName) i++;
00464 }
00465 }
00466
00467 bool QVPropertyContainer::unlinkProperty(QString origName, QVPropertyContainer *destCont, QString destName)
00468 {
00469 QList<QVPropertyContainerLink*> linkList = outputLinks[origName];
00470 foreach(QVPropertyContainerLink* link, linkList) {
00471 if ( (link->qvp_orig == this) && (link->prop_orig == origName) &&
00472 (link->qvp_dest == destCont) && (link->prop_dest == destName) ) {
00473 link->markedForDeletion = TRUE;
00474
00475
00476 link->SyncSemaphoreOut.release();
00477 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::LinkDel, this->getName(), origName, destCont->getName(), destName));
00478 return TRUE;
00479 }
00480 }
00481 return FALSE;
00482 }
00483
00484 void QVPropertyContainer::unlink()
00485 {
00486 foreach(QVPropertyContainerLink* link, inputLinks.values()) {
00487 link->markedForDeletion = TRUE;
00488
00489
00490 link->SyncSemaphoreIn.release();
00491
00492 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::LinkDel, link->qvp_orig_name, link->prop_orig, link->qvp_dest_name, link->prop_dest));
00493 }
00494
00495 foreach(QList<QVPropertyContainerLink*> linkList, outputLinks.values()) {
00496 foreach(QVPropertyContainerLink* link, linkList) {
00497 link->markedForDeletion = TRUE;
00498
00499
00500 link->SyncSemaphoreOut.release();
00501
00502 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::LinkDel, link->qvp_orig_name, link->prop_orig, link->qvp_dest_name, link->prop_dest));
00503 }
00504 }
00505 }
00506
00507 void QVPropertyContainer::readInputProperties()
00508 {
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 QMutableMapIterator<QString, QVPropertyContainerLink*> i(inputLinks);
00520 while (i.hasNext()) {
00521 i.next();
00522 QVPropertyContainerLink *link = i.value();
00523
00524
00525 if(link->markedForDeletion) {
00526 i.remove();
00527 toDeleteLink(link);
00528 }
00529 else {
00530 if(link->link_type == SynchronousLink) {
00531 link->SyncSemaphoreOut.acquire();
00532 }
00533 link->qvp_orig->RWLock.lockForRead();
00534
00535 this->variants[link->prop_dest] = link->qvp_orig->safelyCopiedVariants[link->prop_orig];
00536 link->qvp_orig->RWLock.unlock();
00537 if(link->link_type == SynchronousLink) {
00538 link->SyncSemaphoreIn.release();
00539 }
00540 }
00541 }
00542 informer.emitChange(QVPropertyContainerChange(this->getName(), QVPropertyContainerChange::PropertiesValues));
00543 }
00544
00545 void QVPropertyContainer::writeOutputProperties()
00546 {
00547 QMutableMapIterator<QString, QList<QVPropertyContainerLink*> >i(outputLinks);
00548
00549
00550
00551
00552 while (i.hasNext()) {
00553 i.next();
00554 QListIterator<QVPropertyContainerLink*> j(i.value());
00555 while(j.hasNext()) {
00556 QVPropertyContainerLink *link = j.next();
00557 if(link->link_type == SynchronousLink and not link->markedForDeletion) {
00558 link->SyncSemaphoreIn.acquire();
00559 }
00560 }
00561 }
00562
00563
00564
00565 i.toFront();
00566 this->RWLock.lockForWrite();
00567 while (i.hasNext()) {
00568 i.next();
00569 QString prop_orig = i.key();
00570 safelyCopiedVariants[prop_orig] = variants[prop_orig];
00571 }
00572 this->RWLock.unlock();
00573
00574
00575
00576
00577 i.toFront();
00578 while (i.hasNext()) {
00579 i.next();
00580 QMutableListIterator<QVPropertyContainerLink*> j(i.value());
00581 while(j.hasNext()) {
00582 QVPropertyContainerLink *link = j.next();
00583 if(link->link_type == SynchronousLink and not link->markedForDeletion) {
00584 link->SyncSemaphoreOut.release();
00585 }
00586
00587 if(link->markedForDeletion) {
00588 j.remove();
00589 toDeleteLink(link);
00590 if(i.value().isEmpty()) {
00591 i.remove();
00592 break;
00593 }
00594 }
00595 }
00596 }
00597 }
00598
00599 void QVPropertyContainer::toDeleteLink(QVPropertyContainerLink* link)
00600 {
00601 if (link->qvp_orig == this) {
00602 link->qvp_orig = NULL;
00603 }
00604 else if (link->qvp_dest == this) {
00605 link->qvp_dest = NULL;
00606 }
00607
00608 if ((link->qvp_orig == NULL) && (link->qvp_dest == NULL)) delete link;
00609 }
00610
00611 void QVPropertyContainer::setLastError(QString str) const
00612 { errorString = str; }
00613
00614 QVPropertyContainer *QVPropertyContainer::getSourceContainer(const QString name) const
00615 {
00616 const QMap<QString, QVPropertyContainerLink* > inLinks = getInputLinks();
00617 if (inLinks.contains(name))
00618 return inLinks.value(name)->qvp_orig;
00619
00620 return NULL;
00621 }
00622
00623 QString QVPropertyContainer::getSourceProperty(const QString name) const
00624 {
00625 const QMap<QString, QVPropertyContainerLink* > inLinks = getInputLinks();
00626 if (inLinks.contains(name))
00627 return inLinks.value(name)->prop_orig;
00628
00629 return QString();
00630 }
00631
00632 bool QVPropertyContainer::isSynchronous(const QString name) const
00633 {
00634 const QMap<QString, QVPropertyContainerLink* > inLinks = getInputLinks();
00635 if (inLinks.contains(name))
00636 return (inLinks.value(name)->link_type == SynchronousLink);
00637
00638 return FALSE;
00639 }
00640
00641 bool QVPropertyContainer::areSynchronized(const QList<QVPropertyContainer *> conts)
00642 {
00643 QVDisjointSet dSet(conts.size());
00644
00645 for (int i = 0; i < conts.size(); i++)
00646 for (int j = i+1; j < conts.size(); j++)
00647 {
00648 bool find = false;
00649
00650 if (conts.at(i)->getId() == conts.at(j)->getId())
00651 {
00652 dSet.unify(i, j);
00653 find = true;
00654 }
00655 if (!find)
00656 {
00657 const QMap<QString, QVPropertyContainerLink* > inLinksI = conts.at(i)->getInputLinks();
00658 foreach(QVPropertyContainerLink* proConLink, inLinksI.values())
00659 if ( (proConLink->qvp_orig->getId() == conts.at(j)->getId()) &&
00660 (proConLink->link_type == SynchronousLink) )
00661 {
00662 dSet.unify(i, j);
00663 find = true;
00664 break;
00665 }
00666 }
00667 if (!find)
00668 {
00669 const QMap<QString, QVPropertyContainerLink* > inLinksJ = conts.at(j)->getInputLinks();
00670 foreach(QVPropertyContainerLink* proConLink, inLinksJ.values())
00671 if ( (proConLink->qvp_orig->getId() == conts.at(i)->getId()) &&
00672 (proConLink->link_type == SynchronousLink) )
00673 {
00674 dSet.unify(i, j);
00675 break;
00676 }
00677 }
00678 }
00679
00680 return (dSet.numberOfSets() == 1);
00681 }
00682
00683 template <> bool QVPropertyContainer::parseArgument<bool>(const QString parameter, const QString value)
00684 {
00685 if (value.toLower() == "true" || value.toLower() == "false")
00686 {
00687
00688 setPropertyValue<bool>(parameter,value.toLower() == "true");
00689 return TRUE;
00690 }
00691 else {
00692 errorString = "QVPropertyContainer::parseArgument(): holder " + getName() +
00693 ": value " + value +
00694 " is not a valid boolean value for parameter " +
00695 parameter + ".\n";
00696 return FALSE;
00697 }
00698 }
00699
00700 template <> bool QVPropertyContainer::parseArgument<int>(const QString parameter, const QString value)
00701 {
00702 bool okInt;
00703 int intValue = value.toInt(&okInt);
00704 if(not okInt)
00705 {
00706 errorString = "QVPropertyContainer::parseArgument(): holder " + getName() +
00707 ": value " + value +
00708 " is not a valid integer value for parameter " +
00709 parameter + ".\n";
00710 return FALSE;
00711 }
00712
00713 setPropertyValue<int>(parameter,intValue);
00714 return TRUE;
00715 }
00716
00717 template <> bool QVPropertyContainer::parseArgument<double>(const QString parameter, const QString value)
00718 {
00719 bool okDouble;
00720 double doubleValue = value.toDouble(&okDouble);
00721 if(not okDouble)
00722 {
00723 errorString = "QVPropertyContainer::parseArgument(): holder " + getName() +
00724 ": value " + value +
00725 " is not a valid double value for parameter " +
00726 parameter + ".\n";
00727 return FALSE;
00728 }
00729
00730 setPropertyValue<double>(parameter,doubleValue);
00731 return TRUE;
00732 }
00733
00734 template <> bool QVPropertyContainer::parseArgument<QString>(const QString parameter, const QString value)
00735 {
00736
00737 setPropertyValue<QString>(parameter,value);
00738 return TRUE;
00739 }