/*-----------------------------------------------------------------*/ void simReset (void) { invalidateCache(XMEM_CACHE); invalidateCache(IMEM_CACHE); invalidateCache(SREG_CACHE); sendSim("res\n"); waitForSim(100, NULL); }
void QNetworkAccessHttpBackend::postRequest() { bool loadedFromCache = false; QHttpNetworkRequest httpRequest; switch (operation()) { case QNetworkAccessManager::GetOperation: httpRequest.setOperation(QHttpNetworkRequest::Get); validateCache(httpRequest, loadedFromCache); break; case QNetworkAccessManager::HeadOperation: httpRequest.setOperation(QHttpNetworkRequest::Head); validateCache(httpRequest, loadedFromCache); break; case QNetworkAccessManager::PostOperation: invalidateCache(); httpRequest.setOperation(QHttpNetworkRequest::Post); uploadDevice = new QNetworkAccessHttpBackendIODevice(this); break; case QNetworkAccessManager::PutOperation: invalidateCache(); httpRequest.setOperation(QHttpNetworkRequest::Put); uploadDevice = new QNetworkAccessHttpBackendIODevice(this); break; default: break; // can't happen } httpRequest.setData(uploadDevice); httpRequest.setUrl(url()); QList<QByteArray> headers = request().rawHeaderList(); foreach (const QByteArray &header, headers) httpRequest.setHeaderField(header, request().rawHeader(header)); if (loadedFromCache) { QNetworkAccessBackend::finished(); return; // no need to send the request! :) } httpReply = http->sendRequest(httpRequest); httpReply->setParent(this); #ifndef QT_NO_OPENSSL if (pendingSslConfiguration) httpReply->setSslConfiguration(*pendingSslConfiguration); if (pendingIgnoreSslErrors) httpReply->ignoreSslErrors(); #endif connect(httpReply, SIGNAL(readyRead()), SLOT(replyReadyRead())); connect(httpReply, SIGNAL(finished()), SLOT(replyFinished())); connect(httpReply, SIGNAL(finishedWithError(QNetworkReply::NetworkError,QString)), SLOT(httpError(QNetworkReply::NetworkError,QString))); connect(httpReply, SIGNAL(headerChanged()), SLOT(replyHeaderChanged())); }
/*! \brief Set the color of the symbol Change the color of the brush for symbol types with a filled area. For all other symbol types the color will be assigned to the pen. \param color Color \sa setBrush(), setPen(), brush(), pen() */ void QwtSymbol::setColor( const QColor &color ) { switch ( d_data->style ) { case QwtSymbol::Ellipse: case QwtSymbol::Rect: case QwtSymbol::Diamond: case QwtSymbol::Triangle: case QwtSymbol::UTriangle: case QwtSymbol::DTriangle: case QwtSymbol::RTriangle: case QwtSymbol::LTriangle: case QwtSymbol::Star2: case QwtSymbol::Hexagon: { if ( d_data->brush.color() != color ) { d_data->brush.setColor( color ); invalidateCache(); } break; } case QwtSymbol::Cross: case QwtSymbol::XCross: case QwtSymbol::HLine: case QwtSymbol::VLine: case QwtSymbol::Star1: { if ( d_data->pen.color() != color ) { d_data->pen.setColor( color ); invalidateCache(); } break; } default: { if ( d_data->brush.color() != color || d_data->pen.color() != color ) { invalidateCache(); } d_data->brush.setColor( color ); d_data->pen.setColor( color ); } } }
void stNaiveConnectivity_addEdge(stNaiveConnectivity *connectivity, void *node1, void *node2) { invalidateCache(connectivity); struct adjacency *newEdge1 = malloc(sizeof(struct adjacency)); struct adjacency *newEdge2 = malloc(sizeof(struct adjacency)); newEdge1->toNode = node2; newEdge2->toNode = node1; newEdge1->inverse = newEdge2; newEdge2->inverse = newEdge1; newEdge1->prev = NULL; newEdge2->prev = NULL; struct adjacency *adjList1 = stHash_search(connectivity->nodesToAdjList, node1); if (adjList1 == NULL) { newEdge1->next = NULL; } else { newEdge1->next = adjList1; adjList1->prev = newEdge1; } stHash_remove(connectivity->nodesToAdjList, node1); stHash_insert(connectivity->nodesToAdjList, node1, newEdge1); struct adjacency *adjList2 = stHash_search(connectivity->nodesToAdjList, node2); if (adjList2 == NULL) { newEdge2->next = NULL; } else { newEdge2->next = adjList2; adjList2->prev = newEdge2; } stHash_remove(connectivity->nodesToAdjList, node2); stHash_insert(connectivity->nodesToAdjList, node2, newEdge2); }
NABoolean NAList<T>::getLast(T &elem) { if (this->entries() > 0) { // copy last element elem = this->usedEntry(last_); // remove the last element from the list NACollection<T>::remove(last_); // fix up the list pointers if (first_ == last_) first_ = last_ = NULL_COLL_INDEX; else { last_ = this->findUsage(last_); this->setUsage(last_, NULL_COLL_INDEX); } // invalidate the cache, if necessary if (userIndexCache_ >= this->entries()) invalidateCache(); return TRUE; } else return FALSE; }
void AreaStore::setCacheParams(bool enabled, u8 block_radius, size_t limit) { m_cache_enabled = enabled; m_cacheblock_radius = MYMAX(block_radius, 16); m_res_cache.setLimit(MYMAX(limit, 20)); invalidateCache(); }
int simSetValue (unsigned int addr,char mem, unsigned int size, unsigned long val) { unsigned int i; char cachenr; char buffer[40]; char *s; if ( size <= 0 ) return 0; cachenr = getMemString(buffer, 1, &addr, mem, size); if ( cachenr < NMEM_CACHE ) { invalidateCache(cachenr); } s = buffer + strlen(buffer) -1; for ( i = 0 ; i < size ; i++ ) { sprintf(s," 0x%lx", val & 0xff); s += strlen(s); val >>= 8; } sprintf(s,"\n"); sendSim(buffer); waitForSim(100,NULL); simResponse(); return 0; }
/*! Specify the symbol style \param style Style \sa style() */ void QwtSymbol::setStyle( QwtSymbol::Style style ) { if ( d_data->style != style ) { d_data->style = style; invalidateCache(); } }
/*! En/Disable the pin point alignment \param on Enabled, when on is true \sa setPinPoint(), isPinPointEnabled() */ void QwtSymbol::setPinPointEnabled( bool on ) { if ( d_data->isPinPointEnabled != on ) { d_data->isPinPointEnabled = on; invalidateCache(); } }
/*! Set the symbol's size \param size Size \sa size() */ void QwtSymbol::setSize( const QSize &size ) { if ( size.isValid() && size != d_data->size ) { d_data->size = size; invalidateCache(); } }
/*! Change the cache policy The default policy is AutoCache \param policy Cache policy \sa CachePolicy, cachePolicy() */ void QwtSymbol::setCachePolicy( QwtSymbol::CachePolicy policy ) { if ( d_data->cache.policy != policy ) { d_data->cache.policy = policy; invalidateCache(); } }
/*! Set the text The label will be aligned to the plot canvas according to the alignment flags of text. \param text Text to be displayed \sa text(), QwtText::renderFlags() */ void QwtPlotTextLabel::setText( const QwtText &text ) { if ( d_data->text != text ) { d_data->text = text; invalidateCache(); itemChanged(); } }
void ThermoPhase::resetHf298(size_t k) { if (k != npos) { m_spthermo->resetHf298(k); } else { for (size_t k = 0; k < nSpecies(); k++) { m_spthermo->resetHf298(k); } } invalidateCache(); }
/*! Assign a pen The pen is used to draw the symbol's outline. \param pen Pen \sa pen(), setBrush() */ void QwtSymbol::setPen( const QPen &pen ) { if ( pen != d_data->pen ) { d_data->pen = pen; invalidateCache(); if ( d_data->style == QwtSymbol::Path ) d_data->path.graphic.reset(); } }
/*! \brief Assign a brush The brush is used to draw the interior of the symbol. \param brush Brush \sa brush() */ void QwtSymbol::setBrush( const QBrush &brush ) { if ( brush != d_data->brush ) { d_data->brush = brush; invalidateCache(); if ( d_data->style == QwtSymbol::Path ) d_data->path.graphic.reset(); } }
/*! Change the color map Often it is useful to display the mapping between intensities and colors as an additional plot axis, showing a color bar. \param colorMap Color Map \sa colorMap(), QwtScaleWidget::setColorBarEnabled(), QwtScaleWidget::setColorMap() */ void QwtPlotSpectrogram::setColorMap( QwtColorMap *colorMap ) { if ( d_data->colorMap != colorMap ) { delete d_data->colorMap; d_data->colorMap = colorMap; } invalidateCache(); itemChanged(); }
void Kinetics::resizeSpecies() { m_kk = 0; m_start.resize(nPhases()); for (size_t i = 0; i < m_thermo.size(); i++) { m_start[i] = m_kk; // global index of first species of phase i m_kk += m_thermo[i]->nSpecies(); } invalidateCache(); }
/*! Set the data to be displayed \param data Spectrogram Data \sa data() */ void QwtPlotSpectrogram::setData( QwtRasterData *data ) { if ( data != d_data->data ) { delete d_data->data; d_data->data = data; invalidateCache(); itemChanged(); } }
/*! Change the cache policy The default policy is NoCache \param policy Cache policy \sa CachePolicy, cachePolicy() */ void QwtPlotRasterItem::setCachePolicy( QwtPlotRasterItem::CachePolicy policy ) { if ( d_data->cache.policy != policy ) { d_data->cache.policy = policy; invalidateCache(); itemChanged(); } }
bool SpatialAreaStore::insertArea(Area *a) { if (a->id == U32_MAX) a->id = getNextId(); if (!areas_map.insert(std::make_pair(a->id, *a)).second) // ID is not unique return false; m_tree->insertData(0, nullptr, get_spatial_region(a->minedge, a->maxedge), a->id); invalidateCache(); return true; }
void LatticeSolidPhase::modifyOneHf298SS(const size_t k, const doublereal Hf298New) { for (size_t n = 0; n < m_lattice.size(); n++) { if (lkstart_[n+1] < k) { size_t kk = k-lkstart_[n]; MultiSpeciesThermo& l_spthermo = m_lattice[n]->speciesThermo(); l_spthermo.modifyOneHf298(kk, Hf298New); } } invalidateCache(); _updateThermo(); }
bool VectorAreaStore::insertArea(Area *a) { if (a->id == U32_MAX) a->id = getNextId(); std::pair<AreaMap::iterator, bool> res = areas_map.insert(std::make_pair(a->id, *a)); if (!res.second) // ID is not unique return false; m_areas.push_back(&res.first->second); invalidateCache(); return true; }
/*! \brief Set and enable a pin point The position of a complex symbol is not always aligned to its center ( f.e an arrow, where the peak points to a position ). The pin point defines the position inside of a Pixmap, Graphic, SvgDocument or PainterPath symbol where the represented point has to be aligned to. \param pos Position \param enable En/Disable the pin point alignment \sa pinPoint(), setPinPointEnabled() */ void QwtSymbol::setPinPoint( const QPointF &pos, bool enable ) { if ( d_data->pinPoint != pos ) { d_data->pinPoint = pos; if ( d_data->isPinPointEnabled ) { invalidateCache(); } } setPinPointEnabled( enable ); }
void stNaiveConnectivity_removeNode(stNaiveConnectivity *connectivity, void *node) { invalidateCache(connectivity); struct adjacency *adjList = stHash_search(connectivity->nodesToAdjList, node); while (adjList != NULL) { struct adjacency *next = adjList->next; // Have to do this beforehand -- adjList will be freed by next line! stNaiveConnectivity_removeEdge(connectivity, node, adjList->toNode); adjList = next; } stHash_remove(connectivity->nodesToAdjList, node); }
bool SpatialAreaStore::removeArea(u32 id) { std::map<u32, Area>::iterator itr = areas_map.find(id); if (itr != areas_map.end()) { Area *a = &itr->second; bool result = m_tree->deleteData(get_spatial_region(a->minedge, a->maxedge), id); areas_map.erase(itr); invalidateCache(); return result; } else { return false; } }
// Remove and free an edge properly. static void removeEdgeFromAdjList(stNaiveConnectivity *connectivity, void *node, struct adjacency *adj) { invalidateCache(connectivity); if (adj->next != NULL) { adj->next->prev = adj->prev; } if (adj->prev != NULL) { adj->prev->next = adj->next; } else { stHash_remove(connectivity->nodesToAdjList, node); stHash_insert(connectivity->nodesToAdjList, node, adj->next); } free(adj); }
void Phase::modifySpecies(size_t k, shared_ptr<Species> spec) { if (speciesName(k) != spec->name) { throw CanteraError("Phase::modifySpecies", "New species name '{}' does not match existing name '{}'", spec->name, speciesName(k)); } const shared_ptr<Species>& old = m_species[spec->name]; if (spec->composition != old->composition) { throw CanteraError("Phase::modifySpecies", "New composition for '{}' does not match existing composition", spec->name); } m_species[spec->name] = spec; invalidateCache(); }
void Clock::constraintsEvent(Plasma::Constraints constraints) { ClockApplet::constraintsEvent(constraints); if (constraints & Plasma::SizeConstraint) { invalidateCache(); } if (constraints & Plasma::FormFactorConstraint) { if (formFactor() == Plasma::Planar || formFactor() == Plasma::MediaCenter) { setPreferredSize(256, 256); } else { setPreferredSize(-1, -1); } } }
void LatticeSolidPhase::resetHf298(const size_t k) { if (k != npos) { for (size_t n = 0; n < m_lattice.size(); n++) { if (lkstart_[n+1] < k) { size_t kk = k-lkstart_[n]; m_lattice[n]->speciesThermo().resetHf298(kk); } } } else { for (size_t n = 0; n < m_lattice.size(); n++) { m_lattice[n]->speciesThermo().resetHf298(npos); } } invalidateCache(); _updateThermo(); }
bool VectorAreaStore::removeArea(u32 id) { AreaMap::iterator it = areas_map.find(id); if (it == areas_map.end()) return false; Area *a = &it->second; for (std::vector<Area *>::iterator v_it = m_areas.begin(); v_it != m_areas.end(); ++v_it) { if (*v_it == a) { m_areas.erase(v_it); break; } } areas_map.erase(it); invalidateCache(); return true; }