value_t *createValueFromLongLong(long long v) { value_t *val; if (v >= LONG_MIN && v <= LONG_MAX) { val = createValue(ENCODING_INT, NULL); val->ptr = (void*) ((long) v); } else { val = createValue(ENCODING_RAW, sdsfromlonglong(v)); } return val; }
//Only called on translated expressions IHqlExpression * addExpressionModifier(IHqlExpression * expr, typemod_t modifier, IInterface * extra) { //Not sure which is best implementation... #if 1 return createValue(no_typetransfer, makeModifier(expr->getType(), modifier, LINK(extra)), LINK(expr)); #else HqlExprArray args; unwindChildren(args, expr); return createValue(expr->getOperator(), makeModifier(expr->getType(), modifier, LINK(extra)), args); #endif }
void CChildDatasetColumnInfo::setColumn(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector, IHqlExpression * _value) { OwnedHqlExpr addressSize = getColumnAddress(translator, ctx, selector, sizetType, 0); OwnedHqlExpr addressData = getColumnAddress(translator, ctx, selector, queryType(), sizeof(size32_t)); OwnedHqlExpr lengthTarget = convertAddressToValue(addressSize, sizetType); ITypeInfo * columnType = column->queryType(); OwnedHqlExpr value = LINK(_value); //ensureExprType(_value, columnType); ITypeInfo * valueType = value->queryType(); assertRecordTypesMatch(valueType, columnType); bool assignInline = false; // canEvaluateInline(value); // MORE: What is the test // bool assignInline = canAssignInline(&ctx, value) && !canEvaluateInline(&ctx, value); value.setown(addDatasetLimits(translator, ctx, selector, value)); IHqlExpression * record = column->queryRecord(); if (assignInline) { OwnedHqlExpr inlineSize = getSizetConstant(0); checkAssignOk(translator, ctx, selector, inlineSize, sizeof(size32_t)); //Can only assign inline if we know the maximum length that will be assigned is 0. Owned<IHqlCppDatasetBuilder> builder = translator.createInlineDatasetBuilder(record, inlineSize, addressData); builder->buildDeclare(ctx); translator.buildDatasetAssign(ctx, builder, value); CHqlBoundTarget boundTarget; boundTarget.length.set(lengthTarget); builder->buildFinish(ctx, boundTarget); } else { CHqlBoundExpr bound; translator.buildDataset(ctx, value, bound, FormatBlockedDataset); translator.normalizeBoundExpr(ctx, bound); ensureSimpleLength(translator, ctx, bound); OwnedHqlExpr length = translator.getBoundLength(bound); OwnedHqlExpr size = createValue(no_translated, LINK(sizetType), translator.getBoundSize(bound)); checkAssignOk(translator, ctx, selector, size, sizeof(size32_t)); translator.assignBoundToTemp(ctx, lengthTarget, length); translator.buildBlockCopy(ctx, addressData, bound); //Use the size just calculated for the field OwnedHqlExpr sizeOfExpr = createValue(no_sizeof, LINK(sizetType), LINK(selector->queryExpr())); OwnedHqlExpr boundSize = translator.getBoundSize(bound); OwnedHqlExpr srcSize = adjustValue(boundSize, sizeof(size32_t)); ctx.associateExpr(sizeOfExpr, srcSize); } }
value_t *createValueFromStr(void *s, size_t len) { long v; value_t *val; // first we try to encode the string as a long. if (len > 21 || !string2l(s, len, &v)) { val = createValue(ENCODING_RAW, sdsnewlen(s, len)); } else { val = createValue(ENCODING_INT, NULL); val->ptr = (void*) ((long) v); } return val; }
// creates a predicate object from an AST parse tree boost::shared_ptr< Predicate > createPredicate( const TreeIter& it ) { std::string op( it->value.begin(), it->value.end() ); if ( it->value.id() == PredicateGrammar::predicateId ) { if ( op == "&&" ) return boost::shared_ptr< Predicate >( new PredicateAnd( createPredicate( it->children.begin() ), createPredicate( it->children.begin() + 1 ) ) ); else if ( op == "||" ) return boost::shared_ptr< Predicate >( new PredicateOr( createPredicate( it->children.begin() ), createPredicate( it->children.begin() + 1 ) ) ); else UBITRACK_THROW( "Bad predicate: " + op ); } else if ( it->value.id() == PredicateGrammar::statementId ) { if ( op == "!" ) return boost::shared_ptr< Predicate >( new PredicateNot( createPredicate( it->children.begin() ) ) ); else UBITRACK_THROW( "Bad statement: " + op ); } else if ( it->value.id() == PredicateGrammar::compOpId ) { if ( it->children.size() == 2 ) return boost::shared_ptr< Predicate >( new PredicateCompare( op, createValue( it->children.begin() ), createValue( it->children.begin() + 1 ) ) ); // hack: spirit prunes empty string constants out of the tree if ( it->children.size() == 1 ) return boost::shared_ptr< Predicate >( new PredicateCompare( op, createValue( it->children.begin() ), boost::shared_ptr< AttributeExpression >( new AttributeExpressionConstant( "" ) ) ) ); UBITRACK_THROW( "Problem with comparison parsing: illegal numer of children" ); } else if ( it->value.id() == PredicateGrammar::predicateFunctionId ) { // parse parameters into vector std::vector< boost::shared_ptr< AttributeExpression > > params; for ( TreeIter itParam = it->children.begin(); itParam != it->children.end(); itParam++ ) params.push_back( createValue( itParam ) ); return boost::shared_ptr< Predicate >( new PredicateFunction( op, params ) ); } else { UBITRACK_THROW( "bad predicate" ); } }
IHqlExpression * convertAddressToValue(IHqlExpression * address, ITypeInfo * columnType) { if (isTypePassedByAddress(columnType) && !columnType->isReference()) { Owned<ITypeInfo> refType = makeReferenceModifier(LINK(columnType)); assertex(address->getOperator() == no_externalcall || refType == address->queryType()); return createValue(no_implicitcast, LINK(refType), LINK(address)); } Owned<ITypeInfo> pointerType = makePointerType(LINK(columnType)); assertex(address->getOperator() == no_externalcall || pointerType == address->queryType()); IHqlExpression * temp = createValue(no_implicitcast, LINK(pointerType), LINK(address)); return createValue(no_deref, LINK(columnType), temp); }
IHqlExpression * addFilter(IHqlExpression * dataset, IHqlExpression * limitField) { IHqlExpression * lower = createConstant(limitField->queryType()->castFrom(true, (__int64)0)); lower = createValue(no_colon, lower, createValue(no_stored, createConstant(LOWER_LIMIT_ID))); lower = createSymbol(createIdentifierAtom(LOWER_LIMIT_ID), lower, ob_private); dataset = createDataset(no_filter, LINK(dataset), createBoolExpr(no_ge, LINK(limitField), lower)); IHqlExpression * upper = createConstant((int)DISKREAD_PAGE_SIZE); upper = createValue(no_colon, upper, createValue(no_stored, createConstant(RECORD_LIMIT_ID))); upper = createSymbol(createIdentifierAtom(RECORD_LIMIT_ID), upper, ob_private); dataset = createDataset(no_choosen, dataset, upper); dataset = createSymbol(createIdentifierAtom("_Filtered_"), dataset, ob_private); return dataset; }
DrBase* Foomatic2Loader::createOption( const QMap<QString,QVariant>& m ) const { QString type = m.operator[]( "type" ).toString(); DrBase *opt = NULL; if ( type == "enum" ) { DrListOption *lopt = new DrListOption; QVariant a = m.operator[]( "vals_byname" ); QMap<QString,QVariant>::ConstIterator it = a.mapBegin(); for ( ; it!=a.mapEnd(); ++it ) { if ( it.data().type() != QVariant::Map ) continue; DrBase *ch = createValue( it.key(), it.data().toMap() ); if ( ch ) lopt->addChoice( ch ); } opt = lopt; } else if ( type == "int" || type == "float" ) { if ( type == "int" ) opt = new DrIntegerOption; else opt = new DrFloatOption; opt->set( "minval", m.operator[]( "min" ).toString() ); opt->set( "maxval", m.operator[]( "max" ).toString() ); } else if ( type == "bool" ) { DrBooleanOption *bopt = new DrBooleanOption; DrBase *choice; // choice 1 choice = new DrBase; choice->setName( "0" ); choice->set( "text", m.operator[]( "name_false" ).toString() ); bopt->addChoice( choice ); choice = new DrBase; choice->setName( "1" ); choice->set( "text", m.operator[]( "name_true" ).toString() ); bopt->addChoice( choice ); opt = bopt; } else if ( type == "string" ) { opt = new DrStringOption; } if ( opt ) { opt->setName( m.operator[]( "name" ).toString() ); opt->set( "text", m.operator[]( "comment" ).toString() ); QString defval = m.operator[]( "default" ).toString(); if ( !defval.isEmpty() ) { opt->setValueText( defval ); opt->set( "default", defval ); } } return opt; }
IHqlExpression * CChildDatasetColumnInfo::buildSizeOfUnbound(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector) { OwnedHqlExpr addressSize = getColumnAddress(translator, ctx, selector, sizetType, 0); OwnedHqlExpr length = convertAddressToValue(addressSize, sizetType); OwnedHqlExpr boundSize = translator.getBoundSize(column->queryType(), length, NULL); return createValue(no_translated, LINK(sizetType), adjustValue(boundSize, sizeof(size32_t))); }
Dummy (int argc, char **argv):Filterd (argc, argv) { filterNum = 0; filterSleep = 3; addOption ('s', "filter_sleep", 1, "how long wait for filter change"); createValue (filterNames, "filter_names", "filter names (will be parsed)", false, RTS2_VALUE_WRITABLE); }
XDMFINFORMATION * XdmfInformationNew(char * key, char * value) { try { std::string createKey(key); std::string createValue(value); shared_ptr<XdmfInformation> generatedInfo = XdmfInformation::New(createKey, createValue); return (XDMFINFORMATION *)((void *)(new XdmfInformation(*generatedInfo.get()))); } catch (...) { std::string createKey(key); std::string createValue(value); shared_ptr<XdmfInformation> generatedInfo = XdmfInformation::New(createKey, createValue); return (XDMFINFORMATION *)((void *)(new XdmfInformation(*generatedInfo.get()))); } }
void CChildLimitedDatasetColumnInfo::setColumnFromBuilder(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector, IHqlCppDatasetBuilder * builder) { CHqlBoundExpr bound; builder->buildFinish(ctx, bound); if (bound.length) bound.length.setown(translator.ensureSimpleTranslatedExpr(ctx, bound.length)); OwnedHqlExpr size = createValue(no_translated, LINK(sizetType), translator.getBoundSize(bound)); checkAssignOk(translator, ctx, selector, size, 0); OwnedHqlExpr addressData = getColumnAddress(translator, ctx, selector, queryType(), 0); translator.buildBlockCopy(ctx, addressData, bound); //Use the size just calculated for the field OwnedHqlExpr sizeOfExpr = createValue(no_sizeof, LINK(sizetType), LINK(selector->queryExpr())); OwnedHqlExpr srcSize = translator.getBoundSize(bound); ctx.associateExpr(sizeOfExpr, srcSize); }
void CChildLimitedDatasetColumnInfo::buildDeserializeChildLoop(HqlCppTranslator & translator, BuildCtx & loopctx, IReferenceSelector * selector, IHqlExpression * helper, IAtom * serializeForm) { OwnedHqlExpr mappedCount = replaceSelector(countField, querySelfReference(), selector->queryExpr()->queryChild(0)); CHqlBoundExpr bound; translator.buildTempExpr(loopctx, mappedCount, bound); OwnedHqlExpr test = createValue(no_postdec, LINK(bound.expr)); loopctx.addLoop(test, NULL, false); }
Symbol::Symbol(std::string name, std::string type, bool var) { mName = name; mType = type; mNode = NULL; mVar = var; if (mVar) { createValue(); } }
void HqlCppCaseInfo::buildChop3Map(BuildCtx & ctx, const CHqlBoundTarget & target, CHqlBoundExpr & test, IHqlExpression * temp, unsigned start, unsigned end) { if ((end - start) <= 2) buildChop2Map(ctx, target, test, start, end); else { unsigned mid = start + (end - start) / 2; generateCompareVar(ctx, temp, test, queryCompare(mid)); OwnedHqlExpr test1 = createValue(no_eq, LINK(temp), getZero()); OwnedHqlExpr test2 = createValue(no_lt, LINK(temp), getZero()); BuildCtx subctx(ctx); IHqlStmt * if1 = subctx.addFilter(test1); // if (test == 0) translator.buildExprAssign(subctx, target, queryReturn(mid)); // target = value(n) subctx.selectElse(if1); // else IHqlStmt * if2 = subctx.addFilter(test2); // if (test < 0) buildChop3Map(subctx, target, test, temp, start, mid); // repeat for start..mid subctx.selectElse(if2); // else buildChop3Map(subctx, target, test, temp, mid+1, end); // repeat for min..end } }
//Optimize IF(a,b,c) op x to IF(a,b op x, c OP x) //But be careful because it uncommons attributes increasing the size of the queries. static IHqlExpression * peepholeOptimizeCompare(BuildCtx & ctx, IHqlExpression * expr) { IHqlExpression * lhs = expr->queryChild(0); if (ctx.queryMatchExpr(lhs)) return LINK(expr); IHqlExpression * rhs = expr->queryChild(1); if (!rhs->isConstant() || (lhs->getOperator() != no_if)) return LINK(expr); IHqlExpression * ifCond = lhs->queryChild(0); IHqlExpression * ifTrue = lhs->queryChild(1); IHqlExpression * ifFalse = lhs->queryChild(2); assertex(ifFalse); node_operator op = expr->getOperator(); OwnedHqlExpr newTrue = createValue(op, makeBoolType(), LINK(ifTrue), LINK(rhs)); OwnedHqlExpr newFalse = createValue(op, makeBoolType(), LINK(ifFalse), LINK(rhs)); OwnedHqlExpr newIf = createValue(no_if, makeBoolType(), LINK(ifCond), peepholeOptimize(ctx, newTrue), peepholeOptimize(ctx, newFalse)); return expr->cloneAllAnnotations(newIf); }
IHqlExpression * addMemberSelector(IHqlExpression * expr, IHqlExpression * selector) { if (!expr) return NULL; if (expr->getOperator() == no_variable) return createValue(no_pselect, expr->getType(), LINK(selector), LINK(expr)); if (expr->numChildren() == 0) return LINK(expr); HqlExprArray args; ForEachChild(i, expr) args.append(*addMemberSelector(expr->queryChild(i), selector)); return expr->clone(args); }
void cvtIndexListToPairs(HqlExprArray & target, IHqlExpression * from) { unsigned max = from->numChildren(); unsigned idx; target.ensure(max); for (idx = 0; idx < max; idx++) { IHqlExpression * v1 = from->queryChild(idx); IHqlExpression * v2 = createConstant(createIntValue(idx+1, LINK(unsignedType))); ITypeInfo * type = v2->queryType(); target.append(* createValue(no_mapto, LINK(type), LINK(v1), v2)); } }
void cvtInListToPairs(HqlExprArray & target, IHqlExpression * from, bool valueIfMatch) { unsigned max = from->numChildren(); unsigned idx; IHqlExpression * tValue = queryBoolExpr(valueIfMatch); ITypeInfo * type = queryBoolType(); target.ensure(max); for (idx = 0; idx < max; idx++) { IHqlExpression * v1 = from->queryChild(idx); target.append(* createValue(no_mapto, LINK(type), LINK(v1), LINK(tValue))); } }
bool CChildLimitedDatasetColumnInfo::buildReadAhead(HqlCppTranslator & translator, BuildCtx & ctx, ReadAheadState & state) { try { OwnedHqlExpr self = container->getRelativeSelf(); if (sizeField) { OwnedHqlExpr mappedSize = replaceSelector(sizeField, querySelfReference(), self); OwnedHqlExpr replacedSize = quickFullReplaceExpressions(mappedSize, state.requiredValues, state.mappedValues); if (containsSelector(replacedSize, queryRootSelf())) return false; callDeserializerSkipInputSize(translator, ctx, state. helper, replacedSize); return true; } else { OwnedHqlExpr mappedCount = replaceSelector(countField, querySelfReference(), self); OwnedHqlExpr replacedCount = quickFullReplaceExpressions(mappedCount, state.requiredValues, state.mappedValues); if (containsSelector(replacedCount, queryRootSelf())) return false; if (fixedChildSize != UNKNOWN_LENGTH) { OwnedHqlExpr scaledSize = multiplyValue(replacedCount, fixedChildSize); callDeserializerSkipInputSize(translator, ctx, state. helper, scaledSize); return true; } BuildCtx loopctx(ctx); CHqlBoundExpr bound; translator.buildTempExpr(loopctx, replacedCount, bound); OwnedHqlExpr test = createValue(no_postdec, LINK(bound.expr)); loopctx.addLoop(test, NULL, false); StringBuffer prefetcherInstanceName; translator.ensureRowPrefetcher(prefetcherInstanceName, ctx, column->queryRecord()); StringBuffer s; s.append(prefetcherInstanceName).append("->readAhead("); translator.generateExprCpp(s, state.helper).append(");"); loopctx.addQuoted(s); return true; } } catch (IException * e) { //yuk yuk yuk!! Couldn't resolve the dataset count/size for some strange reason e->Release(); } return false; }
//Initializating the value of the motor void Automata::initAutomata(){ if(DEBUG){ std::cout << "\tDebug: Initializating automata...\n"; } // DC STEPPER distance[NOPE] = createValue(new int[2]{ 0 , 0 }); distance[UP] = createValue(new int[2]{ 0 , 20 }); distance[DOWN] = createValue(new int[2]{ 0 , -20 }); distance[LEFT] = createValue(new int[2]{ -20 , 0 }); distance[RIGHT] = createValue(new int[2]{ 20 , 0 }); distance[UP_LEFT] = createValue(new int[2]{ -10 , 10 }); distance[UP_RIGHT] = createValue(new int[2]{ 10 , 10 }); distance[DOWN_LEFT] = createValue(new int[2]{ -10 , -10 }); distance[DOWN_RIGHT] = createValue(new int[2]{ 10 , -10 }); if(DEBUG){ std::cout << "\tDebug: See stepper...\n"; seeMap(); } }
std::vector<int> Automata::calcDistance(STATE s1, STATE s2){ if(DEBUG){ char buffer[300]; sprintf(buffer,"\tDebug: Transition S1 = %s -> S2 = %s",convertArrow(s1).c_str(),convertArrow(s2).c_str() ); logger->write(buffer); } std::vector<int> v1 = distance[s1]; std::vector<int> v2 = distance[s2]; return createValue( new int[2]{ v2[DC] - v1[DC], v2[STEPPER] - v1[STEPPER] }); }
ElementProperty::ElementProperty(Element *parent, const ustring &name, const ustring &info, DataType type, const ustring &list): DataValue(type) { this->parent = parent; this->name = name; this->info = info; this->list = list; this->type = type; flag = 0; lock = false; defValue = createValue(type); }
//return a linked list called parser LinkedList* parse(LinkedList* tokens, int* depth){ LinkedList* stack = createList(); init(stack); ConsCell* current = tokens->head; //while we still have tokens to step through while(current != NULL){ // if current is an open paren if((*current).car->type == 5){ (*depth)++; } // if current is a closed paren if((*current).car->type == 6){ // if the depth has already gone below 0, we don't want to do any of that stuff if((*depth) <= 0){ (*depth) = (*depth) - 1; } if((*depth) > 0){ (*depth) = (*depth) - 1; LinkedList* child = createList(); init(child); //this would insert the open parenthesis into the parse tree... //but we don't want that //insert(child, current->car); // while we are still inside a set of parens, add the contents to the child list while(((stack->head)->car)->type != 5){ insert(child, (*stack).head->car); pop(stack); } //This would add the closed parentheses to the parse tree... //but we don't want that //insert(child, (*stack).head->car); pop(stack); Value* childValue = createValue(); enum TOKEN_TYPE newCellType = consType; childValue->type = newCellType; childValue->cons = child->head; insert(stack,childValue); } }else{ insert(stack, current->car); } current = current->cdr; } return stack; }
boost::any Cache::get(IndexReaderPtr reader, EntryPtr key) { MapEntryAny innerCache; boost::any value; LuceneObjectPtr readerKey(reader->getFieldCacheKey()); { SyncLock cacheLock(&readerCache); innerCache = readerCache.get(readerKey); if (!innerCache) { innerCache = MapEntryAny::newInstance(); readerCache.put(readerKey, innerCache); } else if (innerCache.contains(key)) value = innerCache[key]; if (VariantUtils::isNull(value)) { value = newLucene<CreationPlaceholder>(); innerCache.put(key, value); } } if (VariantUtils::typeOf<CreationPlaceholderPtr>(value)) { CreationPlaceholderPtr progress(VariantUtils::get<CreationPlaceholderPtr>(value)); SyncLock valueLock(progress); if (VariantUtils::isNull(progress->value)) { progress->value = createValue(reader, key); { SyncLock cacheLock(&readerCache); innerCache.put(key, progress->value); } FieldCachePtr wrapper(_wrapper); // Only check if key.custom (the parser) is non-null; else, we check twice for a single // call to FieldCache.getXXX if (!VariantUtils::isNull(key->custom) && wrapper) { InfoStreamPtr infoStream(wrapper->getInfoStream()); if (infoStream) printNewInsanity(infoStream, progress->value); } } return progress->value; } return value; }
ElementProperty::ElementProperty(Element *parent, ConfProperty *prop):DataValue(prop->type) { this->parent = parent; name = prop->name; info = prop->info; list = prop->list; type = prop->type; flag = prop->flags; group = prop->group; lock = false; defValue = createValue(type); if(!prop->value.empty()) initFromText(prop->value, true); }
IHqlExpression * checkCreateConcreteModule(IErrorReceiver * errors, IHqlExpression * expr, const ECLlocation & errpos) { IHqlScope * scope = expr->queryScope(); if (scope && scope->queryConcreteScope()) { IHqlScope * concrete = scope->queryConcreteScope(); return LINK(queryExpression(concrete)); } if (expr->getOperator() == no_delayedscope) { if (expr->queryChild(0)->getOperator() == no_assertconcrete) return LINK(expr); } OwnedHqlExpr check = createValue(no_assertconcrete, expr->getType(), LINK(expr), errpos.createLocationAttr()); return createDelayedScope(check.getClear()); }
std::shared_ptr<headerField> headerFieldFactory::create (const string& name, const string& body) { NameMap::const_iterator pos = m_nameMap.find(utility::stringUtils::toLower(name)); std::shared_ptr<headerField> field = NULL; if (pos != m_nameMap.end()) field = ((*pos).second)(); else field = registerer <headerField, headerField>::creator(); field->setName(name); field->setValue(createValue(name)); if (body != NULL_STRING) field->parse(body); return field; }
void CChildSetColumnInfo::buildDeserialize(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector, IHqlExpression * helper, IAtom * serializeForm) { OwnedHqlExpr address = getColumnAddress(translator, ctx, selector, boolType, 0); OwnedHqlExpr addressSize = getColumnAddress(translator, ctx, selector, sizetType, sizeof(bool)); OwnedHqlExpr addressData = getColumnAddress(translator, ctx, selector, queryType(), sizeof(bool)+sizeof(size32_t)); size32_t sizeExtra = sizeof(bool)+sizeof(size32_t); //Read the all flag and the size OwnedHqlExpr sizeAllSizet = getSizetConstant(sizeExtra); callDeserializeGetN(translator, ctx, helper, sizeAllSizet, address); OwnedHqlExpr targetSize = convertAddressToValue(addressSize, sizetType); OwnedHqlExpr unboundSize = createTranslated(targetSize); checkAssignOk(translator, ctx, selector, unboundSize, sizeExtra); callDeserializeGetN(translator, ctx, helper, targetSize, addressData); OwnedHqlExpr sizeOfExpr = createValue(no_sizeof, LINK(sizetType), LINK(selector->queryExpr())); OwnedHqlExpr srcSize = adjustValue(targetSize, sizeExtra); ctx.associateExpr(sizeOfExpr, srcSize); }
void toResultItem::addItem(const QString &title, const QString &value) { if (WidgetPos >= NumWidgets) { NumWidgets += ALLOC_SIZE; Widgets.resize(NumWidgets, 0); } QString t; if (title != "-") t = Utils::toTranslateMayby(sqlName(), title); QWidget *widget; if (!Widgets[WidgetPos]) { widget = createTitle(this); Widgets[WidgetPos] = widget; } else widget = ((QLabel *)Widgets[WidgetPos]); setTitle(widget, t, value); if (ShowTitle) widget->show(); else widget->hide(); WidgetPos++; if (!Widgets[WidgetPos]) { widget = createValue(this); Widgets[WidgetPos] = widget; } else widget = Widgets[WidgetPos]; setValue(widget, title, value); widget->show(); WidgetPos++; }