// TODO: why must we check for all possible value<> castings? this is fragile
void QLayoutItemfromScriptValue(const QScriptValue &obj, QLayoutItem* &item)
{
if (DEBUG) qDebug("QLayoutItemfromScriptValue(obj, %p) called", item);
item = obj.data().toVariant().value<QLayoutItem*>();
if (! item)
item = obj.data().toVariant().value<QSpacerItem*>();
if (DEBUG) qDebug("QLayoutItemfromScriptValue set %p", item);
}
void QDiagramPluginLoaderClass::setProperty( QScriptValue & object, const QScriptString &name, uint id, const QScriptValue & value )
{
QDiagramPluginLoader *c= qscriptvalue_cast<QDiagramPluginLoader*>(object.data());
if (!c){
return;
}
}
ReflectivePropertyIterator::ReflectivePropertyIterator(
const QScriptValue& object) :
QScriptClassPropertyIterator(object),
m_idx(-1)
{
m_node = qscriptvalue_cast< Node_ptr >(object.data());
}
QScriptValue SearchResultsScriptClass::toScriptValue(QScriptEngine *eng, const SearchResults &searchResults)
{
QScriptValue ctor = eng->globalObject().property("SearchResults");
SearchResultsScriptClass *cls = qscriptvalue_cast<SearchResultsScriptClass*>(ctor.data());
if (!cls) return eng->newVariant(qVariantFromValue(searchResults));
return cls->newInstance(searchResults);
}
QByteArray FilePrototype::toByteArray(const QScriptValue &value)
{
ByteArrayClass *cls = getByteArrayClass(engine());
return (cls && value.scriptClass() == cls)
? *qscriptvalue_cast<QByteArray*>(value.data())
: value.toString().toUtf8();
}
QScriptValue ByteArrayClass::toScriptValue(QScriptEngine *eng, const QByteArray &ba) {
QScriptValue ctor = eng->globalObject().property("ByteArray");
ByteArrayClass *cls = qscriptvalue_cast<ByteArrayClass*>(ctor.data());
if (!cls)
return eng->newVariant(QVariant::fromValue(ba));
return cls->newInstance(ba);
}
QScriptValue::PropertyFlags DefaultScriptClass::propertyFlags(const QScriptValue& object, const QScriptString& name, uint id)
{
QScriptValue::PropertyFlags result;
const ScriptHandlerInfo::Mode mode = mHandlerInfo->mode();
Q_ASSERT(mode != ScriptHandlerInfo::None);
DataInformation* data = toDataInformation(object);
if (!data)
{
mHandlerInfo->logger()->error() << "could not cast data from" << object.data().toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Attempting to access an invalid object"));
return 0;
}
if (name == s_valid || name == s_validationError)
{
if (mode != ScriptHandlerInfo::Validating)
result |= QScriptValue::ReadOnly;
}
else if (mode != ScriptHandlerInfo::Updating)
{
result |= QScriptValue::ReadOnly;
}
for (int i = 0, size = mIterableProperties.size(); i < size; ++i) {
if (mIterableProperties.at(i).first == name)
return result | mIterableProperties.at(i).second;
}
if (additionalPropertyFlags(data, name, id, &result))
return result; //is a child element
else
{
data->logError() << "could not find flags for property with name" << name.toString();
return 0;
}
}
QScriptValue ArrayBufferClass::property(const QScriptValue& object,
const QScriptString& name, uint id) {
QByteArray* ba = qscriptvalue_cast<QByteArray*>(object.data());
if (ba && name == _byteLength) {
return ba->length();
}
return QScriptValue();
}
QScriptValue post_data_list_class::toScriptValue(QScriptEngine *eng, const http_data_list &pdl)
{
QScriptValue ctor = eng->globalObject().property("post_data_list");
post_data_list_class *cls = qscriptvalue_cast<post_data_list_class*>(ctor.data());
if (!cls)
return eng->newVariant(QVariant::fromValue(pdl));
return cls->newInstance(pdl);
}
void setProperty(QScriptValue &object,
const QScriptString &name, uint, const QScriptValue & value)
{
if (name == str_forwardOnly) {
QSqlQuery query = qscriptvalue_cast<QSqlQuery>(object.data());
query.setForwardOnly(value.toBool());
}
}
QScriptValue QDiagramPluginLoaderClass::property(const QScriptValue &object, const QScriptString & name, uint id)
{
QDiagramPluginLoader* c = qscriptvalue_cast<QDiagramPluginLoader*>(object.data());
if (!c){
return QScriptValue();
}
return QScriptValue();
}
QScriptValue QDiagramPluginLoaderClass::toScriptValue(QScriptEngine* engine, const QDiagramPluginLoader & o)
{
QScriptValue ctor = engine->globalObject().property("QDiagramPluginLoader");
QDiagramPluginLoaderClass* c = qscriptvalue_cast<QDiagramPluginLoaderClass*>(ctor.data());
if (!c){
return engine->newVariant(qVariantFromValue(c));
}
return c->newInstance(o);
}
QScriptValue TypedArray::property(const QScriptValue& object,
const QScriptString& name, uint id) {
if (name == _bytesPerElementName) {
return QScriptValue(_bytesPerElement);
}
if (name == _lengthName) {
return object.data().property(_lengthName);
}
return ArrayBufferViewClass::property(object, name, id);
}
QScriptClass::QueryFlags ArrayBufferClass::queryProperty(const QScriptValue& object,
const QScriptString& name,
QueryFlags flags, uint* id) {
QByteArray* ba = qscriptvalue_cast<QByteArray*>(object.data());
if (ba && name == _byteLength) {
// if the property queried is byteLength, only handle read access
return flags &= HandlesReadAccess;
}
return 0; // No access
}
QScriptClass::QueryFlags TypedArray::queryProperty(const QScriptValue& object,
const QScriptString& name,
QueryFlags flags, uint* id) {
if (name == _bytesPerElementName || name == _lengthName) {
return flags &= HandlesReadAccess; // Only keep read access flags
}
quint32 byteOffset = object.data().property(_byteOffsetName).toInt32();
quint32 length = object.data().property(_lengthName).toInt32();
bool ok = false;
quint32 pos = name.toArrayIndex(&ok);
// Check that name is a valid index and arrayBuffer exists
if (ok && pos < length) {
*id = byteOffset + pos * _bytesPerElement; // save pos to avoid recomputation
return HandlesReadAccess | HandlesWriteAccess; // Read/Write access
}
return ArrayBufferViewClass::queryProperty(object, name, flags, id);
}
QScriptValue ArrayBufferClass::toScriptValue(QScriptEngine* engine, const QByteArray& ba) {
QScriptValue ctor = engine->globalObject().property(CLASS_NAME);
ArrayBufferClass* cls = qscriptvalue_cast<ArrayBufferClass*>(ctor.data());
if (!cls) {
if (engine->currentContext()) {
engine->currentContext()->throwError("arrayBufferClass::toScriptValue -- could not get " + CLASS_NAME + " class constructor");
}
return QScriptValue::NullValue;
}
return cls->newInstance(ba);
}
QScriptClass::QueryFlags TimerClass::queryProperty(const QScriptValue &object,
const QScriptString &name,
QueryFlags flags, uint */*id*/) {
QTimer *timer = qscriptvalue_cast<QTimer*>(object.data());
if (!timer)
return 0;
if (name == _interval || name == _singleShot)
return flags;
return 0;
}
QScriptClass::QueryFlags QDiagramPluginLoaderClass::queryProperty( const QScriptValue & object, const QScriptString & name, QScriptClass::QueryFlags flags, uint* id )
{
QDiagramPluginLoader* c = qscriptvalue_cast<QDiagramPluginLoader*>(object.data());
if (!c){
return 0;
}
//if (name == cPropertyCurrentEngineer){
// return flags;
//}
return 0;
}
QScriptValue TimerClass::property(const QScriptValue &object,
const QScriptString &name, uint /*id*/) {
QTimer *timer = qscriptvalue_cast<QTimer*>(object.data());
if (!timer)
return QScriptValue();
if (name == _interval) {
return timer->interval();
} else if (name == _singleShot) {
return timer->isSingleShot();
}
return QScriptValue();
}
void TimerClass::setProperty(QScriptValue &object,
const QScriptString &name,
uint /*id*/, const QScriptValue &value) {
QTimer *timer = qscriptvalue_cast<QTimer*>(object.data());
qDebug() << "Value after de-varianting setProperty: " << timer << name;
if (!timer)
return;
if (name == _interval) {
timer->setInterval(value.toInt32());
} else if (name == _singleShot) {
timer->setSingleShot(value.toBoolean());
}
}
QScriptValue ByteArrayClass::property(const QScriptValue &object,
const QScriptString &name, uint id) {
QByteArray *ba = qscriptvalue_cast<QByteArray*>(object.data());
if (!ba)
return QScriptValue();
if (name == length) {
return ba->length();
} else {
qint32 pos = id;
if ((pos < 0) || (pos >= ba->size()))
return QScriptValue();
return uint(ba->at(pos)) & 255;
}
return QScriptValue();
}
void post_data_list_class::setProperty(QScriptValue &object, const QScriptString &name,
uint id, const QScriptValue &value)
{
http_data_list *pdli = qscriptvalue_cast<http_data_list*>(object.data());
if (!pdli)
return;
qint32 pos = id;
if (pos < 0)
return;
if (pdli->size() <= pos)
return;
(*pdli)[pos] = value.toVariant().value<http_data_ptr>();
}
void ReflectiveScriptClass::setProperty(
QScriptValue& object,
const QScriptString & name,
uint id,
const QScriptValue& value)
{
// std::cout << __FUNCTION__ << " " <<
// name.toString().toStdString() << std::endl;
Node_ptr node = qscriptvalue_cast< Node_ptr >(object.data());
if (node)
{
// Ensure it is initialized
node->check_for_initialized();
::gsim::core::descriptor_type type =
node->descriptor->get_type();
if (type == ::gsim::core::TYPE_STRUCT)
{
// because I am sure it is initialized
if (id < node->children.size())
{
fromScriptValue(value, node->children[id]);
}
}
else if (node->descriptor->is_repeated())
{
if (id < node->children.size())
{
fromScriptValue(value, node->children[id]);
}
else if (node->descriptor->is_variable_length() &&
QString(name) == "length")
{
// length property
unsigned int length = value.toUInt32();
node->descriptor->set_length(node->holder, length);
// re-initialized in next access
node->reset();
}
}
}
}
static QScriptValue qscript_options(QScriptContext *ctx, QScriptEngine *)
{
static QHash<QString, int> stringToFlagHash;
if (stringToFlagHash.isEmpty()) {
stringToFlagHash["strict"] = 1;
stringToFlagHash["werror"] = 2;
stringToFlagHash["atline"] = 4;
stringToFlagHash["xml"] = 8;
}
QScriptValue callee = ctx->callee();
int opts = callee.data().toInt32();
QString result = optionsToString(opts);
for (int i = 0; i < ctx->argumentCount(); ++i)
opts |= stringToFlagHash.value(ctx->argument(0).toString());
callee.setData(opts);
return result;
}
void ByteArrayClass::setProperty(QScriptValue &object,
const QScriptString &name,
uint id, const QScriptValue &value) {
QByteArray *ba = qscriptvalue_cast<QByteArray*>(object.data());
if (!ba)
return;
if (name == length) {
resize(*ba, value.toInt32());
} else {
qint32 pos = id;
if (pos < 0)
return;
if (ba->size() <= pos)
resize(*ba, pos + 1);
(*ba)[pos] = char(value.toInt32());
}
}
QScriptValue post_data_list_class::property(const QScriptValue &object,
const QScriptString &name, uint id)
{
http_data_list *pdli = qscriptvalue_cast<http_data_list*>(object.data());
if (!pdli)
return QScriptValue();
if (name == length) {
return pdli->length();
}
else {
qint32 pos = id;
if ((pos < 0) || (pos >= pdli->size()))
return QScriptValue();
return engine()->newVariant(QVariant::fromValue(pdli->at(pos)));
}
return QScriptValue();
}
QScriptClass::QueryFlags DefaultScriptClass::queryProperty(const QScriptValue& object,
const QScriptString& name, QScriptClass::QueryFlags flags, uint* id)
{
const ScriptHandlerInfo::Mode mode = mHandlerInfo->mode();
Q_ASSERT(mode != ScriptHandlerInfo::None);
DataInformation* data = toDataInformation(object);
if (!data)
{
mHandlerInfo->logger()->error() << "could not cast data from" << object.data().toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Attempting to access an invalid object"));
return 0;
}
if (name == s_valid || name == s_validationError)
{
return mode == ScriptHandlerInfo::Validating ? flags : flags & ~HandlesWriteAccess;
}
if (mode != ScriptHandlerInfo::Updating)
{
//the only properties that are possibly writable when not updating are valid and validationError
//but we checked them before so we remove handlesWriteAccess from the flags
flags &= ~HandlesWriteAccess;
}
if (name == s_byteOrder || name == s_name || name == s_updateFunc || name == s_validationFunc
|| name == s_datatype || name == s_customTypeName || name == s_asStringFunc)
{
return flags;
}
else if (name == s_wasAbleToRead || name == s_parent)
{
return flags & ~HandlesWriteAccess;
}
else if (queryAdditionalProperty(data, name, &flags, id))
{
return flags;
}
else
{
data->logError() << "could not find property with name" << name.toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Could not find property with name ") + name.toString());
return 0;
}
}
void ArrayBufferClass::fromScriptValue(const QScriptValue& object, QByteArray& byteArray) {
if (object.isString()) {
// UTF-8 encoded String
byteArray = object.toString().toUtf8();
} else if (object.isArray()) {
// Array of uint8s eg: [ 128, 3, 25, 234 ]
auto Uint8Array = object.engine()->globalObject().property("Uint8Array");
auto typedArray = Uint8Array.construct(QScriptValueList{object});
if (QByteArray* buffer = qscriptvalue_cast<QByteArray*>(typedArray.property("buffer"))) {
byteArray = *buffer;
}
} else if (object.isObject()) {
// ArrayBuffer instance (or any JS class that supports coercion into QByteArray*)
if (QByteArray* buffer = qscriptvalue_cast<QByteArray*>(object.data())) {
byteArray = *buffer;
}
}
}
QScriptClass::QueryFlags ByteArrayClass::queryProperty(const QScriptValue &object,
const QScriptString &name,
QueryFlags flags, uint *id) {
QByteArray *ba = qscriptvalue_cast<QByteArray*>(object.data());
if (!ba)
return 0;
if (name == length) {
return flags;
} else {
bool isArrayIndex;
qint32 pos = name.toArrayIndex(&isArrayIndex);
if (!isArrayIndex)
return 0;
*id = pos;
if ((flags & HandlesReadAccess) && (pos >= ba->size()))
flags &= ~HandlesReadAccess;
return flags;
}
}
//! [78]
QScriptValue getSet(QScriptContext *ctx, QScriptEngine *eng)
{
QScriptValue obj = ctx->thisObject();
QScriptValue data = obj.data();
if (!data.isValid()) {
data = eng->newObject();
obj.setData(data);
}
QScriptValue result;
if (ctx->argumentCount() == 1) {
QString str = ctx->argument(0).toString();
str.replace("Roberta", "Ken");
result = str;
data.setProperty("x", result);
} else {
result = data.property("x");
}
return result;
}
