void Proxy::sync_add_placeholders(Rule* parent) { assert(parent == NULL || parent->dataSource != NULL); std::list<std::string> path = parent ? this->dataSource->buildPath(*parent->dataSource) : std::list<std::string>(); bool eop_is_blacklisted = false; for (std::list<std::list<std::string> >::const_iterator pti_iter = this->__idPathList_OtherEntriesPlaceHolders.begin(); pti_iter != this->__idPathList_OtherEntriesPlaceHolders.end(); pti_iter++) { if (*pti_iter == path) { eop_is_blacklisted = true; break; } } std::list<Rule>& list = parent ? parent->subRules : this->rules; if (!eop_is_blacklisted) { Rule newRule(Rule::OTHER_ENTRIES_PLACEHOLDER, parent ? this->dataSource->buildPath(*parent->dataSource) : std::list<std::string>(), "*", true); newRule.dataSource = this->dataSource->getEntryByPath(path); newRule.dataSource_list = this->dataSource->getListByPath(path); list.push_front(newRule); this->__idPathList_OtherEntriesPlaceHolders.push_back(path); } for (std::list<Rule>::iterator iter = list.begin(); iter != list.end(); iter++) { if (iter->dataSource && iter->type == Rule::NORMAL && iter->dataSource->type == Entry::SUBMENU) { this->sync_add_placeholders(&*iter); } } }
Quadrature<Real>::Quadrature(const int dimension, const std::vector<int> &numPoints1D, const std::vector<EQuadrature> &rule1D, const std::vector<EGrowth> &growth1D, const bool isNormalized) : dimension_(dimension) { TEUCHOS_TEST_FOR_EXCEPTION((dimension!=(int)numPoints1D.size()|| dimension!=(int)rule1D.size()|| dimension!=(int)growth1D.size()),std::out_of_range, ">>> ERROR (Quadrature): Dimension mismatch for inputs."); accuracy_.clear(); accuracy_.resize(dimension); std::vector<int> degree(1); Quadrature<Real> newRule(0,1); for (int i=0; i<dimension; i++) { // Compute 1D rules int numPoints = growthRule1D(numPoints1D[i],growth1D[i],rule1D[i]); Quadrature<Real> rule1(rule1D[i],numPoints,isNormalized); rule1.getAccuracy(degree); accuracy_.push_back(degree[0]); // Build Tensor Rule newRule = kron_prod<Real>(newRule,rule1); } typename std::map<std::vector<Real>,int>::iterator it; int loc = 0; std::vector<Real> node; for (it=newRule.begin(); it!=newRule.end(); it++) { node = it->first; addPointAndWeight(node,newRule.getWeight(node),loc); loc++; } if (isNormalized) { normalize(); } }
std::shared_ptr<OsmAnd::MapStyleRule> OsmAnd::MapStyle_P::createTagValueRootWrapperRule( uint64_t id, const std::shared_ptr<MapStyleRule>& rule ) { if(rule->_d->_values.size() <= 2) return rule; QHash< QString, QString > attributes; attributes.insert(QLatin1String("tag"), getTagString(id)); attributes.insert(QLatin1String("value"), getValueString(id)); std::shared_ptr<MapStyleRule> newRule(new MapStyleRule(owner, attributes)); newRule->_d->_ifElseChildren.push_back(rule); return newRule; }
void RuleControl::OnText(wxCommandEvent &evt) { Rule newRule(GetValue(), this); if (newRule.IsValid() || GetValue().Trim().IsEmpty()) { m_rule = newRule; m_canvas->Redraw(); SetToolTip(wxT("expression ok")); } else { SetToolTip(newRule.GetErrorLog()); } }
void RandomCollatorTest::Test(){ // See ticket 5747 about reenabling this test. errln("This test needs to be fixed.\n"); LanguageGenerator test_rule; if (test_rule.parseBNF(collationBNF, "$root", TRUE) != LanguageGenerator::OK){ errln("The test code itself is wrong."); return; }; //TestColltorCompare coll_test; static const int CONSTRUCT_RANDOM_COUNT = 1000; int i; for (i=0; i < CONSTRUCT_RANDOM_COUNT; i++){ const char * rule = test_rule.next(); logln("\n-----------------------------------%d\n",i); logln(UnicodeString(rule, strlen(rule))); UnicodeString newRule(rule); // potential bug UErrorCode status = U_ZERO_ERROR; logln( "===========================================\n"); fwrite(rule, strlen(rule),1,stdout); logln("\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"); Collator * c = new RuleBasedCollator(newRule,status); if (U_FAILURE(status)) { errln( "Could not create Collator for the %d(th) generated rule.\n" "Error Name: %s\n" "The rule is ", i, u_errorName(status)); return; } delete c; } }
DataPriorityController::DataPriorityController(FileQueue& queue, FileQueueParameters const* params) : m_rules(params->rules.size()), m_defaultRule(DataPriorityController::Rule("*", 0, 0, false)), m_queue(queue), m_queueParams(params) { for (unsigned int i = 0; i < m_queueParams->rules.size(); ++i) { // look for a channel with a matching name int channelIdx = -1; for (unsigned int j = 0; j < m_queueParams->channels.size(); ++j) { if (params->channels[j].name == params->rules[i].channelName) { channelIdx = j; break; } } if (channelIdx == -1) { MIRO_LOG_OSTR(LL_ERROR, "DPC: channel name: " << m_queueParams->rules[i].channelName << " does not exist. skipping rule."); } else { Rule newRule(m_queueParams->rules[i].extension, channelIdx, m_queueParams->rules[i].priority, m_queueParams->rules[i].autoAdd); if (m_queueParams->rules[i].extension == "*") { m_defaultRule = newRule; } else { m_rules.push_back(newRule); } } } }
void CSV::createMainPage () { setCaption(tr("CSV Quotes")); QString s = "new"; QString s2 = tr("New Rule"); toolbar->addButton(s, newchart, s2); QObject::connect(toolbar->getButton(s), SIGNAL(clicked()), this, SLOT(newRule())); s = "edit"; s2 = tr("Edit Rule"); toolbar->addButton(s, edit, s2); QObject::connect(toolbar->getButton(s), SIGNAL(clicked()), this, SLOT(editRule())); s = "delete"; s2 = tr("Delete Rule"); toolbar->addButton(s, deleteitem, s2); QObject::connect(toolbar->getButton(s), SIGNAL(clicked()), this, SLOT(deleteRule())); QLabel *label = new QLabel(tr("Rule"), baseWidget); grid->addWidget(label, 0, 0); ruleCombo = new QComboBox(baseWidget); updateRules(); grid->addWidget(ruleCombo, 0, 1); label = new QLabel(tr("Input"), baseWidget); grid->addWidget(label, 1, 0); QStringList l; file = new FileButton(baseWidget, l, lastPath); grid->addWidget(file, 1, 1); label = new QLabel(tr("Symbol"), baseWidget); grid->addWidget(label, 2, 0); symbol = new QLineEdit(baseWidget); grid->addWidget(symbol, 2, 1); label = new QLabel(tr("Auto Reload"), baseWidget); grid->addWidget(label, 3, 0); minutes = new QSpinBox(baseWidget); minutes->setMinValue(0); minutes->setMaxValue(99); minutes->setLineStep(1); QObject::connect(minutes, SIGNAL(valueChanged(int)), this, SLOT(reloadTimerChanged(int))); grid->addWidget(minutes, 3, 1); dateRange = new QCheckBox(tr("Select Date Range"), baseWidget); QObject::connect(dateRange, SIGNAL(toggled(bool)), this, SLOT(dateRangeChanged(bool))); grid->addWidget(dateRange, 5, 0); label = new QLabel(tr("Date Start"), baseWidget); grid->addWidget(label, 6, 0); sdate = new Q3DateEdit(QDate::currentDate(), baseWidget); sdate->setAutoAdvance(TRUE); sdate->setOrder(Q3DateEdit::YMD); grid->addWidget(sdate, 6, 1); label = new QLabel(tr("Date End"), baseWidget); grid->addWidget(label, 7, 0); edate = new Q3DateEdit(QDate::currentDate(), baseWidget); edate->setAutoAdvance(TRUE); edate->setOrder(Q3DateEdit::YMD); grid->addWidget(edate, 7, 1); // set the default end date QDate dt = QDate::currentDate(); if (dt.dayOfWeek() == 6) dt = dt.addDays(-1); else { if (dt.dayOfWeek() == 7) dt = dt.addDays(-2); } edate->setDate(dt); sdate->setDate(dt); }
void FilterEditor::onAddRule(GtkWidget* widget, FilterEditor* self) { FilterRule newRule("texture", "textures/", false); self->_filter.rules.push_back(newRule); self->update(); }
STDMETHODIMP CContentBasedClassifier::UseRulesAndDefinitions( IFsrmCollection * Rules, IFsrmCollection * propertyDefinitions ) { HRESULT hr = S_OK; _variant_t vRule; CComPtr<IFsrmRule> pFsrmRule; CComPtr<IFsrmClassificationRule> pFsrmClassificationRule; CComBSTR strRuleName; wstring strRuleNameLower; CComBSTR strPropertyName; CComBSTR strPropertyValue; LONG cRuleCount; SAFEARRAY *psaParams = NULL; SAFEARRAY *psaParsedParams = NULL; SAFEARRAYBOUND rgsaBound[1]; LONG paramIndex; LONG lBoundParams; LONG uBoundParams; GUID idRule; m_mapFsrmClassificationRules.clear(); hr = Rules->get_Count( &cRuleCount ); if (hr != S_OK) { goto exit; } //iterate over the rules collection and build a map to store //this map will be used while processing records for matching rules for (LONG iRule = 1; iRule <= cRuleCount; iRule++) { vRule.Clear( ); // Get the next rule hr = Rules->get_Item( iRule, &vRule ); if (hr != S_OK) { goto exit; } // Query for the IFsrmRule interface pFsrmRule.Release( ); hr = vRule.pdispVal->QueryInterface( _uuidof( IFsrmRule ), (void **)&pFsrmRule ); if (hr != S_OK) { goto exit; } // Query for the IFsrmClassificationRule interface pFsrmClassificationRule.Release( ); hr = pFsrmRule->QueryInterface( _uuidof( IFsrmClassificationRule ), (void **)&pFsrmClassificationRule ); if (hr != S_OK) { goto exit; } // Get the rule's name strRuleName.Empty( ); hr = pFsrmRule->get_Name( &strRuleName ); if (hr != S_OK) { goto exit; } // Get the property name for this rule strPropertyName.Empty( ); hr = pFsrmClassificationRule->get_PropertyAffected( &strPropertyName ); if (hr != S_OK) { goto exit; } // Get the property value that will be applied by this rule strPropertyValue.Empty( ); hr = pFsrmClassificationRule->get_Value( &strPropertyValue ); if (hr != S_OK) { goto exit; } // Get the additional classification parameters for this rule psaParams = NULL; hr = pFsrmRule->get_Parameters(&psaParams); if (FAILED(hr)) { goto exit; } // Get the rule id guid ::memset(&idRule, 0, sizeof(GUID)); hr = pFsrmRule->get_Id(&idRule); if (FAILED(hr)) { goto exit; } psaParsedParams = NULL; if (psaParams) { // The additional parameters array contains parameters in the following format // key=value // This classifier treats the key as a value as well since it needs to search for words // in the contents of files. lBoundParams = 0; uBoundParams = 0; hr = SafeArrayGetLBound(psaParams, 1, &lBoundParams); if (FAILED(hr)) { goto exit; } hr = SafeArrayGetUBound(psaParams, 1, &uBoundParams); if (FAILED(hr)) { goto exit; } rgsaBound[0].cElements = ((uBoundParams - lBoundParams + 1) * 2); rgsaBound[0].lLbound = 0; paramIndex = 0; psaParsedParams = SafeArrayCreate(VT_VARIANT, 1, rgsaBound); if (psaParsedParams == NULL) { hr = E_OUTOFMEMORY; goto exit; } for (LONG iParam = lBoundParams; iParam <= uBoundParams; iParam++) { _variant_t vParam; hr = SafeArrayGetElement(psaParams, &iParam, &vParam); if (FAILED(hr)) { goto exit; } CComBSTR strParam = vParam.bstrVal; LPWSTR pwszParamKey = (LPWSTR)strParam; LPWSTR pwszParamVal = ::wcschr(pwszParamKey, L'='); *pwszParamVal = 0; pwszParamVal++; BSTR bstrKey = SysAllocString(pwszParamKey); BSTR bstrVal = SysAllocString(pwszParamVal); _variant_t vKey = bstrKey; _variant_t vVal = bstrVal; hr = SafeArrayPutElement(psaParsedParams, ¶mIndex, &vKey); if (FAILED(hr)) { goto exit; } paramIndex++; hr = SafeArrayPutElement(psaParsedParams, ¶mIndex, &vVal); if (FAILED(hr)) { goto exit; } } //create a new property/value pair to store CFsrmClassificationRule newRule( strPropertyName, strPropertyValue, &psaParsedParams ); //make sure rule name is lower case for ease in matching strRuleNameLower = strRuleName; std::transform( strRuleNameLower.begin( ), strRuleNameLower.end( ), strRuleNameLower.begin( ), towlower ); //add rule with property/value to map m_mapFsrmClassificationRules[idRule] = newRule; } } exit: return hr; }
void MainWindow::createActions() { newAction = new QAction("&New",this); newAction->setIcon(QIcon(":/images/new.png")); newAction->setShortcut(tr("Ctrl+N")); newAction->setStatusTip("Create a new edit session"); connect(newAction,SIGNAL(triggered()), this,SLOT(newFile())); openFileAction = new QAction("&Open file",this); openFileAction->setIcon(QIcon(":/images/open.png")); openFileAction->setShortcut(tr("Ctrl+O")); openFileAction->setStatusTip("Open/load data from file"); connect(openFileAction,SIGNAL(triggered()), this,SLOT(openFile())); openVideoAction= new QAction("Open video image",this); openVideoAction->setIcon(QIcon(":/images/video-x-generic.svg")); //openVideoAction->setShortcut(tr("Ctrl+O+O")); //openVideoAction->setStatusTip("Open/load contexts data from file"); connect(openVideoAction,SIGNAL(triggered()), this,SLOT(openVideoFile())); saveProjectAction= new QAction("&Save project",this); saveProjectAction->setIcon(QIcon(":/images/save.png")); saveProjectAction->setShortcut(tr("Ctrl+P")); saveProjectAction->setStatusTip("Save data to project file"); connect(saveProjectAction,SIGNAL(triggered()), this,SLOT(saveProjectFile())); saveContextsAction = new QAction("Save contexts",this); saveContextsAction->setIcon(QIcon(":/images/insert-object.svg")); saveContextsAction->setShortcut(tr("Ctrl+S+C")); saveContextsAction->setStatusTip("Save contexts data to file"); connect(saveContextsAction,SIGNAL(triggered()), this,SLOT(saveContextsToFile())); saveRulesAction = new QAction("Save rules",this); saveRulesAction->setIcon(QIcon(":/images/insert-object.svg")); saveRulesAction->setShortcut(tr("Ctrl+S+C")); saveRulesAction->setStatusTip("Save rule data to file"); connect(saveRulesAction,SIGNAL(triggered()), this,SLOT(saveRulesToFile())); exitAction = new QAction("&Exit",this); exitAction->setIcon(QIcon(":/images/application-exit.svg")); exitAction->setShortcut(tr("Ctrl+Q")); exitAction->setStatusTip("Close application"); connect(exitAction, SIGNAL(triggered()), this, SLOT(close())); aboutAction = new QAction("&About",this); aboutAction->setIcon(QIcon(":/images/find.png")); aboutAction->setShortcut(tr("Ctrl+A")); aboutAction->setStatusTip("About"); connect(aboutAction,SIGNAL(triggered()), this,SLOT(about())); newRuleAction = new QAction("&New rule",this); newRuleAction->setIcon(QIcon(":/images/rule.svg")); connect(newRuleAction,SIGNAL(triggered()), this,SLOT(newRule())); runVirtualFencingAction = new QAction("&Video",this); runVirtualFencingAction->setIcon(QIcon(":/images/arrow.png")); connect(runVirtualFencingAction,SIGNAL(triggered()), this,SLOT(runVirtualFencing())); addLineAction = new QAction("Add &Line",this); addLineAction->setIcon(QIcon(":/images/linepointer.png")); addLineAction->setShortcut(tr("Ctrl+L")); addLineAction->setStatusTip("Add line"); connect(addLineAction,SIGNAL(triggered()), this,SLOT(about())); }
void DLR() { pSymbolNode symbol_start = ll[0]; pRule rule_start = gRules; ll[2] = ll[0]; for (pSymbolNode i = symbol_start; i; i = i->next) { // Delete the indirect left recursion for (pSymbolNode j = symbol_start; j != i; j = j->next) { for (pRule ri = rule_start; ri; ri = ri->next) { // Rules that in the form of i ::= j... if (ri->addr->serial == i->serial) { if (ri->addr->next->serial == j->serial) { int changed = 0; // j is going to be substituted for (pRule rj = rule_start; rj; rj = rj->next) { // Rules that in the form of j ::= ... if (rj->addr->serial == j->serial) { char* buf; pRuleNode origanal = ri->addr->next; changed = 1; buf = Rule2String(rj->addr->next); ri->addr->next = (pRuleNode)getLinkedList(buf, origanal->next, newRuleNode); free(buf); buf = Rule2String(ri->addr); gRules = newRule((pRuleNode)getLinkedList(buf, 0, newRuleNode), gRules); free(buf); buf = NULL; for (pRuleNode prn = ri->addr->next; prn != origanal->next;) { pRuleNode temp = prn; prn = prn->next; free(temp); } ri->addr->next = origanal; } } // Delete the rule rj if (changed) { pRule preRi = gRules; while (preRi->next != ri && preRi != ri) preRi = preRi->next; for (pRuleNode pr = ri->addr; pr;) { pRuleNode prn = pr; pr = pr->next; free(prn->symbol); free(prn); } preRi->next = ri->next; free(ri); ri = preRi; } } } } } rule_start = gRules; // Delete the direct left recursion for (pRule r = rule_start; r; r = r->next) { // Rules that in the form of i ::= i... if (r->addr->serial == i->serial && r->addr->serial == r->addr->next->serial) { char newSymbol[BUFSIZ], *buf; size_t sLen, rLen; pRule preRi; int deleted = 0; // Fine all rules that indicate a direct left recursion rule of i for (pRule ri = r; ri; ri = ri->next) { if (ri->addr->serial == i->serial && ri->addr->serial == ri->addr->next->serial) { // Add symbol i' strcpy(newSymbol, i->symbol); sLen = strlen(i->symbol); newSymbol[sLen++] = '\''; newSymbol[sLen] = 0; if (strcmp(ll[0]->symbol, newSymbol)) { ll[0] = newSymbolNode(gNonTerSerial, newSymbol, 0, 0, ll[0]); gNonTerSerial += 2; } // Add rule i ::= 0 if (!deleted) { newSymbol[sLen] = 0x20; newSymbol[sLen + 1] = '0'; newSymbol[sLen + 2] = 0; gRules = newRule((pRuleNode)getLinkedList(newSymbol, 0, newRuleNode), gRules); } // Add rule i' ::= ...i' buf = Rule2String(ri->addr->next->next); newSymbol[sLen++] = 0x20; memcpy(newSymbol + sLen, buf, strlen(buf)); sLen += strlen(buf); free(buf); newSymbol[sLen++] = 0x20; rLen = sLen; sLen = 0; while (*(newSymbol + sLen) != 0x20) sLen++; newSymbol[sLen] = 0; strcpy(newSymbol + rLen, newSymbol); rLen += sLen; newSymbol[sLen] = 0x20; newSymbol[rLen] = 0; gRules = newRule((pRuleNode)getLinkedList(newSymbol, 0, newRuleNode), gRules); newSymbol[sLen] = 0; // Add rules i ::= a i' for all a in rules i ::= a starting without i for (pRule rr = rule_start; rr; rr = rr->next) { // If rules i ::= a i' for all a in rules i ::= a starting without i has been deleted if (deleted) break; // Rule in the form of i ::= a starting without i if (rr->addr->serial == i->serial && rr->addr->serial != rr->addr->next->serial) { char newR[BUFSIZ]; buf = Rule2String(rr->addr); rLen = strlen(buf); strcpy(newR, buf); free(buf); newR[rLen++] = 0x20; strcpy(newR + rLen, newSymbol); gRules = newRule((pRuleNode)getLinkedList(newR, 0, newRuleNode), gRules); // Delete the rule rr preRi = gRules; while (preRi->next != rr) preRi = preRi->next; for (pRuleNode pr = rr->addr; pr;) { pRuleNode prn = pr; pr = pr->next; free(prn->symbol); free(prn); } preRi->next = rr->next; if (rr == ri) ri = preRi; free(rr); rr = preRi; } } deleted = 1; } } // Delete all rules that indicates a direct left recursion of i for (pRule ri = r; ri; ri = ri->next) { if (ri->addr->serial == i->serial) { preRi = gRules; while (preRi->next != ri) preRi = preRi->next; for (pRuleNode pr = ri->addr; pr;) { pRuleNode prn = pr; pr = pr->next; free(prn->symbol); free(prn); } preRi->next = ri->next; if (ri == r) r = preRi; free(ri); ri = preRi; } } rule_start = gRules; } } } }