void rebuildBuffers() { if (!mapData) return; groundVert.clear(); aboveVert.clear(); TileAtlasVX::readTiles(*this, *mapData, flags, mapViewp.x, mapViewp.y, mapViewp.w, mapViewp.h); groundQuads = groundVert.size() / 4; aboveQuads = aboveVert.size() / 4; size_t totalQuads = groundQuads + aboveQuads; VBO::bind(vbo); if (totalQuads > allocQuads) { VBO::allocEmpty(quadBytes(totalQuads), GL_DYNAMIC_DRAW); allocQuads = totalQuads; } VBO::uploadSubData(0, quadBytes(groundQuads), dataPtr(groundVert)); VBO::uploadSubData(quadBytes(groundQuads), quadBytes(aboveQuads), dataPtr(aboveVert)); VBO::unbind(); shState->ensureQuadIBO(totalQuads); }
PppConfOption* PppConfPacket::optionAt (const int optIdx) { ACE_TRACE("PppConfPacket::optionAt"); int optNum = 0; if (codeVal() != Configure_Request && codeVal() != Configure_Ack && codeVal() != Configure_Nak) throw std::runtime_error("No options in this type of packet."); ACE_UINT8 optType, bufLen; ACE_UINT8* optPtr; int optPos = 0; do { optType = *(dataPtr() + optPos); bufLen = *(dataPtr() + optPos + 1) - 2; optPtr = dataPtr() + optPos + 2; optPos += bufLen + 2; } while ( optPos < dataLength() && optNum++ <= optIdx ); if ( optNum != optIdx ) throw std::runtime_error("Could not reach specified option index."); // TODO: use an auto_ptr here so there's no worry about deleting later return new PppConfOption(optType, bufLen, optPtr); }
bool VectorRecord::allValuesAreLoaded() const { if (!dataPtr() || !dataPtr()->pagedAndPageletTreeValueCount()) return true; IntegerSequence curSlice(size(), offset(), stride()); IntegerSequence restrictedSlice = curSlice.intersect(IntegerSequence(pagedAndPageletTreeValueCount())); if (restrictedSlice.size() == 0) return true; Nullable<long> slotIndex; Fora::Interpreter::ExecutionContext* context = Fora::Interpreter::ExecutionContext::currentExecutionContext(); if (context) slotIndex = context->getCurrentBigvecSlotIndex(); else slotIndex = 0; lassert(slotIndex); if (!dataPtr()->bigvecHandleForSlot(*slotIndex)) return false; bool tr = dataPtr()-> bigvecHandleForSlot(*slotIndex)->allValuesAreLoadedBetween( restrictedSlice.smallestValue(), restrictedSlice.largestValue() + 1 ); return tr; }
void QDeclarativeVMEVariant::setValue(QObject *v) { if (type != QMetaType::QObjectStar) { cleanup(); type = QMetaType::QObjectStar; new (dataPtr()) QDeclarativeGuard<QObject>(); } *(QDeclarativeGuard<QObject>*)(dataPtr()) = v; }
void QQmlVMEVariant::setValue(QObject *v, QQmlVMEMetaObject *target, int index) { if (type != QMetaType::QObjectStar) { cleanup(); type = QMetaType::QObjectStar; new (dataPtr()) QQmlVMEVariantQObjectPtr(false); } reinterpret_cast<QQmlVMEVariantQObjectPtr*>(dataPtr())->setGuardedValue(v, target, index); }
void QDeclarativeVMEVariant::setValue(const QVariant &v) { if (type != qMetaTypeId<QVariant>()) { cleanup(); type = qMetaTypeId<QVariant>(); new (dataPtr()) QVariant(v); } else { *(QVariant *)(dataPtr()) = v; } }
void QDeclarativeVMEVariant::setValue(const QString &v) { if (type != QMetaType::QString) { cleanup(); type = QMetaType::QString; new (dataPtr()) QString(v); } else { *(QString *)(dataPtr()) = v; } }
void QDeclarativeVMEVariant::setValue(const QUrl &v) { if (type != QMetaType::QUrl) { cleanup(); type = QMetaType::QUrl; new (dataPtr()) QUrl(v); } else { *(QUrl *)(dataPtr()) = v; } }
void QDeclarativeVMEVariant::setValue(const QColor &v) { if (type != QMetaType::QColor) { cleanup(); type = QMetaType::QColor; new (dataPtr()) QColor(v); } else { *(QColor *)(dataPtr()) = v; } }
void QDeclarativeVMEVariant::setValue(const QDateTime &v) { if (type != QMetaType::QDateTime) { cleanup(); type = QMetaType::QDateTime; new (dataPtr()) QDateTime(v); } else { *(QDateTime *)(dataPtr()) = v; } }
void QDeclarativeVMEVariant::setValue(const QScriptValue &v) { if (type != qMetaTypeId<QScriptValue>()) { cleanup(); type = qMetaTypeId<QScriptValue>(); new (dataPtr()) QScriptValue(v); } else { *(QScriptValue *)(dataPtr()) = v; } }
void QQmlVMEVariant::setValue(const QJSValue &v) { if (type != qMetaTypeId<QJSValue>()) { cleanup(); type = qMetaTypeId<QJSValue>(); new (dataPtr()) QJSValue(v); } else { *(QJSValue *)(dataPtr()) = v; } }
void QQmlVMEVariant::setValue(const QSizeF &v) { if (type != QMetaType::QSizeF) { cleanup(); type = QMetaType::QSizeF; new (dataPtr()) QSizeF(v); } else { *(QSizeF *)(dataPtr()) = v; } }
void QQmlVMEVariant::setValue(const QPointF &v) { if (type != QMetaType::QPointF) { cleanup(); type = QMetaType::QPointF; new (dataPtr()) QPointF(v); } else { *(QPointF *)(dataPtr()) = v; } }
void QQmlVMEVariant::setValue(const QDate &v) { if (type != QMetaType::QDate) { cleanup(); type = QMetaType::QDate; new (dataPtr()) QDate(v); } else { *(QDate *)(dataPtr()) = v; } }
bool VectorRecord::entirelyCoveredByJOV(const JudgmentOnValue& inJOV) const { if (!dataPtr()) return true; VectorHandle* handle = dataPtr(); lassert(allValuesAreLoaded()); int64_t curIndex = 0; while (curIndex < size()) { TypedFora::Abi::ForaValueArraySlice slice = sliceForOffset(curIndex); lassert_dump( slice.array(), "We should have guaranteed that this value was loaded by calling 'allValuesAreLoaded'" ); if (slice.mapping().stride() == 1) { bool allAreCovered = true; auto visitor = [&](const PackedForaValues& vals) { if (!allAreCovered || !inJOV.covers(vals.elementJOV())) allAreCovered = false; }; slice.array()->visitValuesSequentially( visitor, slice.mapping().range().offset(), slice.mapping().range().endValue() ); if (!allAreCovered) return false; } else { while (curIndex < slice.mapping().highIndex()) { if (!inJOV.covers(slice.jovFor(curIndex))) return false; curIndex++; } } curIndex = slice.mapping().highIndex(); } return true; }
void BaseFab<Real>::performCopy (const BaseFab<Real>& src, const Box& srcbox, int srccomp, const Box& destbox, int destcomp, int numcomp) { BL_ASSERT(destbox.ok()); BL_ASSERT(src.box().contains(srcbox)); BL_ASSERT(box().contains(destbox)); BL_ASSERT(destbox.sameSize(srcbox)); BL_ASSERT(srccomp >= 0 && srccomp+numcomp <= src.nComp()); BL_ASSERT(destcomp >= 0 && destcomp+numcomp <= nComp()); if (destbox == domain && srcbox == src.box()) { Real* data_dst = dataPtr(destcomp); const Real* data_src = src.dataPtr(srccomp); for (long i = 0, N = numcomp*numpts; i < N; i++) { *data_dst++ = *data_src++; } } else { const int* destboxlo = destbox.loVect(); const int* destboxhi = destbox.hiVect(); const int* _th_plo = loVect(); const int* _th_phi = hiVect(); const int* _x_lo = srcbox.loVect(); const int* _x_plo = src.loVect(); const int* _x_phi = src.hiVect(); Real* _th_p = dataPtr(destcomp); const Real* _x_p = src.dataPtr(srccomp); FORT_FASTCOPY(_th_p, ARLIM(_th_plo), ARLIM(_th_phi), D_DECL(destboxlo[0],destboxlo[1],destboxlo[2]), D_DECL(destboxhi[0],destboxhi[1],destboxhi[2]), _x_p, ARLIM(_x_plo), ARLIM(_x_phi), D_DECL(_x_lo[0],_x_lo[1],_x_lo[2]), &numcomp); } }
double QDeclarativeVMEVariant::asDouble() { if (type != QMetaType::Double) setValue(double(0)); return *(double *)(dataPtr()); }
Real BaseFab<Real>::sum (const Box& bx, int comp, int ncomp) const { BL_ASSERT(domain.contains(bx)); BL_ASSERT(comp >= 0 && comp + ncomp <= nvar); const int* _box_lo = bx.loVect(); const int* _box_hi = bx.hiVect(); const int* _datalo = loVect(); const int* _datahi = hiVect(); const Real* _data = dataPtr(comp); Real sm = 0; FORT_FASTSUM(_data, ARLIM(_datalo), ARLIM(_datahi), _box_lo, _box_hi, &ncomp, &sm); return sm; }
TagBox* TagBox::coarsen (const IntVect& ratio) { TagBox* crse = new TagBox(BoxLib::coarsen(domain,ratio)); const Box& cbox = crse->box(); Box b1(BoxLib::refine(cbox,ratio)); const int* flo = domain.loVect(); const int* fhi = domain.hiVect(); IntVect d_length = domain.size(); const int* flen = d_length.getVect(); const int* clo = cbox.loVect(); IntVect cbox_len = cbox.size(); const int* clen = cbox_len.getVect(); const int* lo = b1.loVect(); int longlen = b1.longside(); TagType* fdat = dataPtr(); TagType* cdat = crse->dataPtr(); Array<TagType> t(longlen,TagBox::CLEAR); int klo = 0, khi = 0, jlo = 0, jhi = 0, ilo, ihi; D_TERM(ilo=flo[0]; ihi=fhi[0]; ,
BaseFab<Real>& BaseFab<Real>::saxpy (Real a, const BaseFab<Real>& src, const Box& srcbox, const Box& destbox, int srccomp, int destcomp, int numcomp) { const int* destboxlo = destbox.loVect(); const int* destboxhi = destbox.hiVect(); const int* _th_plo = loVect(); const int* _th_phi = hiVect(); const int* _x_lo = srcbox.loVect(); const int* _x_plo = src.loVect(); const int* _x_phi = src.hiVect(); Real* _th_p = dataPtr(destcomp); const Real* _x_p = src.dataPtr(srccomp); FORT_FASTSAXPY(_th_p, ARLIM(_th_plo), ARLIM(_th_phi), D_DECL(destboxlo[0],destboxlo[1],destboxlo[2]), D_DECL(destboxhi[0],destboxhi[1],destboxhi[2]), &a, _x_p, ARLIM(_x_plo), ARLIM(_x_phi), D_DECL(_x_lo[0],_x_lo[1],_x_lo[2]), &numcomp); return *this; }
const QVariant &QDeclarativeVMEVariant::asQVariant() { if (type != QMetaType::QVariant) setValue(QVariant()); return *(QVariant *)(dataPtr()); }
QObject *QDeclarativeVMEVariant::asQObject() { if (type != QMetaType::QObjectStar) setValue((QObject *)0); return *(QDeclarativeGuard<QObject> *)(dataPtr()); }
bool QDeclarativeVMEVariant::asBool() { if (type != QMetaType::Bool) setValue(bool(false)); return *(bool *)(dataPtr()); }
int QDeclarativeVMEVariant::asInt() { if (type != QMetaType::Int) setValue(int(0)); return *(int *)(dataPtr()); }
const QScriptValue &QDeclarativeVMEVariant::asQScriptValue() { if (type != qMetaTypeId<QScriptValue>()) setValue(QScriptValue()); return *(QScriptValue *)(dataPtr()); }
const QDateTime &QDeclarativeVMEVariant::asQDateTime() { if (type != QMetaType::QDateTime) setValue(QDateTime()); return *(QDateTime *)(dataPtr()); }
const QColor &QDeclarativeVMEVariant::asQColor() { if (type != QMetaType::QColor) setValue(QColor()); return *(QColor *)(dataPtr()); }
const QUrl &QDeclarativeVMEVariant::asQUrl() { if (type != QMetaType::QUrl) setValue(QUrl()); return *(QUrl *)(dataPtr()); }
const QString &QDeclarativeVMEVariant::asQString() { if (type != QMetaType::QString) setValue(QString()); return *(QString *)(dataPtr()); }