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());
}
