Skip to content

GitLab

Commit 41113c07 authored by EXT Arnaud Clère's avatar EXT Arnaud Clère
Browse files

WIP add cache to QJsonReader using QVariant

parent 7e92d744
Hide whitespace changes
Inline Side-by-side
tests/QBind/QBind_impl.h
View file @ 41113c07
......@@ -399,6 +399,8 @@ struct IBind {
virtual bool _bind( const char* u) = 0;
virtual bool _any() { return _null(); }
//! \warning QMetaData is ignored by default and subject to various interpretation, so users should define or adopt existing meta data standards like XSD for sake of interoperability
virtual void _meta(QMetaData&) {}
......@@ -513,8 +515,6 @@ struct IWriter : public IBind
virtual bool _bind(const float& r) { float copy(r); return _bind(std::move(copy)); }
virtual bool _bind(const double& r) { double copy(r); return _bind(std::move(copy)); }
virtual bool _bind(const QByteArray& r) { QByteArray copy(r); return _bind(std::move(copy)); }
virtual bool _any() { return _null(); }
};
//! Base IBind implementations with BindMode::Read
......@@ -531,12 +531,12 @@ struct IReader : public IBind
virtual bool _bind(QUtf8String& u) = 0;
virtual bool _bind( QString& s) { QUtf8String u; if (!_bind(u)) return false; s=QString::fromUtf8(u); return true; }
virtual bool _bind( bool& b) { QUtf8String u; if (!_bind(u)) return false; if (u.toLower()=="true") { b=true; } else if (u.toLower()=="false") { b=false; } else { _reportError(qBindExpectedBoolean); return false; } return true; }
virtual bool _bind( qint8& n) { qint64 l; if (!_bind(l)|| l<std::numeric_limits< qint8>::min() || std::numeric_limits< qint8>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= qint8(l); return true; }
virtual bool _bind( quint8& n) { quint64 l; if (!_bind(l)|| std::numeric_limits< quint8>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= quint8(l); return true; }
virtual bool _bind( qint16& n) { qint64 l; if (!_bind(l)|| l<std::numeric_limits< qint16>::min() || std::numeric_limits< qint16>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= qint16(l); return true; }
virtual bool _bind( quint16& n) { quint64 l; if (!_bind(l)|| std::numeric_limits<quint16>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n=quint16(l); return true; }
virtual bool _bind( qint32& n) { qint64 l; if (!_bind(l)|| l<std::numeric_limits< qint32>::min() || std::numeric_limits< qint32>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= qint32(l); return true; }
virtual bool _bind( quint32& n) { quint64 l; if (!_bind(l)|| std::numeric_limits<quint32>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n=quint32(l); return true; }
virtual bool _bind( qint8& n) { qint64 l; if (!_bind(l)) return false; if (l<std::numeric_limits< qint8>::min() || std::numeric_limits< qint8>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= qint8(l); return true; }
virtual bool _bind( quint8& n) { quint64 l; if (!_bind(l)) return false; if ( std::numeric_limits< quint8>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= quint8(l); return true; }
virtual bool _bind( qint16& n) { qint64 l; if (!_bind(l)) return false; if (l<std::numeric_limits< qint16>::min() || std::numeric_limits< qint16>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= qint16(l); return true; }
virtual bool _bind( quint16& n) { quint64 l; if (!_bind(l)) return false; if ( std::numeric_limits<quint16>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n=quint16(l); return true; }
virtual bool _bind( qint32& n) { qint64 l; if (!_bind(l)) return false; if (l<std::numeric_limits< qint32>::min() || std::numeric_limits< qint32>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n= qint32(l); return true; }
virtual bool _bind( quint32& n) { quint64 l; if (!_bind(l)) return false; if ( std::numeric_limits<quint32>::max()<l) { _reportError(qBindExpectedSmallerNumber); return false; } n=quint32(l); return true; }
virtual bool _bind( qint64& n) { QUtf8String s; if (!_bind(s)) return false; bool isOk=false; qint64 v; v=s.toLongLong (&isOk); if (isOk) { n=v; return true; } _reportError(qBindExpectedDecimal); return false; }
virtual bool _bind( quint64& n) { QUtf8String s; if (!_bind(s)) return false; bool isOk=false; quint64 v; v=s.toULongLong(&isOk); if (isOk) { n=v; return true; } _reportError(qBindExpectedDecimal); return false; }
virtual bool _bind( float& n) { QUtf8String s; if (!_bind(s)) return false; bool isOk=false; float v; v=s.toFloat (&isOk); if (isOk) { n=v; return true; } _reportError(qBindExpectedDecimal); return false; }
......@@ -592,8 +592,15 @@ struct IReader : public IBind
|| _null () ) {
return true;
};
bool b; // usually easier to check than types below
double d; // matches most used numbers more easily than types below
qint64 i; // matches most used integrals more easily than types below
quint64 u;
if (_bind(b) || _bind(d) || _bind(i) || _bind(u)) {
return true;
}
_setChoice(false);
QString s;
QString s; // matches any type with usually less encoding work than QUtf8String (which only captures efficiently utf-8 whereas QChar easily captures Latin1 in addition to ASCII)
return _bind(s);
}
};
......@@ -857,7 +864,7 @@ struct QBind<QColor> {
};
// --------------------------------------------------------------------------
// QBind specialization for generic Val<Cursor> for a fixed set of possibly BindNative types
// QBind<Val<Cursor>> for the set of IBind's BindNative types
template<> //!< \remark Enumerating types where BindSupport<_,Cur<TImpl>> = BindNative with C++11 seems hard, so we just handle the set of default IBind BindNative types
struct QBind<Val<Cursor>> {
......
tests/QBind/QJson_impl.h
View file @ 41113c07
......@@ -57,40 +57,42 @@ class QJsonBuilder : public IWriter
Q_DISABLE_COPY(QJsonBuilder)
public:
QJsonBuilder(QJsonValue* v) : json(v) { Q_ASSERT(v); }
void reset(QJsonValue* v) { json=v; Q_ASSERT(v); steps.clear(); }
// Shortcuts
/**/ Val<Cursor> value ( ) { return Cursor(this).value(); }
/**/ Seq<Cursor> sequence(quint32* s=nullptr) { return Cursor(this).value().sequence ( s); }
template<typename T> Cursor bind ( T&& t) { return Cursor(this).value().bind(std::forward<T>(t)); }
protected:
bool _sequence(quint32* s=nullptr) { Q_UNUSED(s); levels.push(Step(nullptr)); return true; }
bool _record (quint32* s=nullptr) { Q_UNUSED(s); levels.push(Step("" )); return true; }
friend class QJsonReader; //!< Calls methods below to cachedItems out-of-order _item(s)
bool _sequence(quint32* s=nullptr) { Q_UNUSED(s); steps.push(Step(nullptr)); return true; }
bool _record (quint32* s=nullptr) { Q_UNUSED(s); steps.push(Step("" )); return true; }
bool _null ( ) { set(QJsonValue( )); return true; }
bool _bind ( const char* s) { set(QJsonValue(s)); return true; }
bool _bind ( const char* u) { set(QJsonValue(u)); return true; }
bool _bind ( bool&& b) { set(QJsonValue(b)); return true; }
bool _bind ( double&& d) { set(QJsonValue(d)); return true; }
bool _bind ( quint64&& n) { return _bind(double(n)); }
bool _bind ( qint64&& n) { return _bind(double(n)); }
bool _bind ( quint64&& n) { return _bind(double(n)); }
bool _bind ( qint64&& n) { return _bind(double(n)); }
bool _item(QName n) { levels.last().key=n ; return true; }
bool _item( ) { levels.last().key=nullptr; return true; }
bool _out ( ) { auto level = levels.pop(); set(!level.key.isNull() ? QJsonValue(level.object) : QJsonValue(level.array)); return true; }
bool _item(QName n) { steps.last().key=n ; return true; }
bool _item( ) { steps.last().key=nullptr; return true; }
bool _out ( ) { auto level = steps.pop(); set(!level.key.isNull() ? QJsonValue(level.object) : QJsonValue(level.array)); return true; }
private:
void set(const QJsonValue& v) {
if (levels.isEmpty()) {
if (steps.isEmpty()) {
*json = v;
}
else {
if (!levels.last().key.isNull())
levels.last().object[levels.last().key]=v;
if (!steps.last().key.isNull())
steps.last().object[steps.last().key]=v;
else
levels.last().array.append(v);
steps.last().array.append(v);
}
}
QJsonValue* json;
struct Step { QUtf8String key; /* TODO union */ QJsonObject object; QJsonArray array; Step(const char* k=nullptr) : key(k) {} };
QStack<Step> levels = QStack<Step>(); //!< minimal dynamic context to implement out() and ensure actual building in case QJsonBuilderImpl is abandoned
QStack<Step> steps = QStack<Step>(); //!< minimal dynamic context to implement out() and ensure actual building in case QJsonBuilderImpl is abandoned
};
// --------------------------------------------------------------------------
......@@ -100,6 +102,7 @@ class QJsonVisitor : public IReader
Q_DISABLE_COPY(QJsonVisitor)
public:
QJsonVisitor(const QJsonValue* v) : json(v) { Q_ASSERT(v); }
void reset(QJsonValue* v) { json=v; Q_ASSERT(v); steps.clear(); errors.clear(); }
struct Error { const char* error; QUtf8String path; template<class T> T bind(Val<T>&& value) { return value.bind(QUtf8String(error)+' '+path); } };
QVector<Error> errors;
......@@ -210,11 +213,13 @@ private:
// --------------------------------------------------------------------------
#include "QVariant_impl.h" // as cached value reader and writer for out-of-order item keys
class QJsonReader : public IReader
{
Q_DISABLE_COPY(QJsonReader)
public:
QJsonReader(QIODevice* io) : io(io) { Q_ASSERT(io); }
QJsonReader(QIODevice* io) : io(io), cacheWriter(&cachedValue), cacheReader(&cachedValue) { Q_ASSERT(io); }
struct Step { int index; const char* end; Step(int i=-1, const char* e=nullptr) : index(i), end(e) {} };
struct Error { const char* error; int line; int column; int index; template<class T> T bind(Val<T>&& value) { QUtf8String utf8(error); utf8.append(' ').append(QUtf8String::number(line)).append(':').append(QUtf8String::number(column)); return value.bind(utf8.constData()); } };
......@@ -225,73 +230,96 @@ public:
/**/ Seq<Cursor> sequence(quint32* s=nullptr) { return Cursor(this).value().sequence(s); }
template<typename T> Cursor bind ( T&& t) { return Cursor(this).value().bind(std::forward<T>(t)); }
protected:
bool _sequence(quint32* =nullptr) { if (get('[', "[{\"ntf-0123456789.")) { levels.push(Step(-1,"]")); return true; } _reportError(qBindExpectedSequence); return false; }
bool _record (quint32* =nullptr) { if (get('{', "[{\"ntf-0123456789.")) { levels.push(Step(-1,"}")); return true; } _reportError(qBindExpectedRecord ); return false; }
bool _null ( ) { if (get('n', "[{\"ntf-0123456789.") &&
get('u', "[{\"" ) &&
get('l', "[{\"" ) &&
get('l', "[{\"" )) {
return true;
} else { _reportError(qBindExpectedNull); return false; } }
bool _bind ( QUtf8String& s) { QUtf8String u;
if ( get('"', "[{\"ntf-0123456789.")) { u.clear(); char c;
while ((c=getCharInString()) != '\0' ) { u.append(c); }
s=u;
return get('"');
} else { _reportError(qBindExpectedText); return false; } }
bool _bind ( QString& s) { QUtf8String u; if (_bind(u)) { s = QString::fromUtf8(u); return true; } return false; } // TODO Support user-defined QTextCodec
bool _bind ( bool& b) { if (get('t', "[{\"ntf-0123456789.") &&
get('r', "[{\"" ) &&
get('u', "[{\"" ) &&
get('e', "[{\"" )) { b=true;
return true;
} else
if (get('f', "[{\"ntf-0123456789.") &&
get('a', "[{\"" ) &&
get('l', "[{\"" ) &&
get('s', "[{\"" ) &&
get('e', "[{\"" )) { b=false;
return true;
} else { _reportError(qBindExpectedBoolean); return false; } }
bool _bind ( float& n) { double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { if ( d<double( std::numeric_limits<float >::min())||
double( std::numeric_limits<float >::max())<d) { n = float(d); return true; } _reportError(qBindExpectedSmallerNumber ); } return false; }
bool _bind ( double& n) { double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { n = d ; } return r; }
bool _bind ( quint64& t) { double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { if (!neg ) { t = i ; return true; } _reportError(qBindExpectedPositiveNumber); } return false; }
bool _bind ( qint64& t) { double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { if (!neg && quint64( std::numeric_limits<qint64>::max())<i) { t = qint64(i); return true; }
if ( neg && quint64(-std::numeric_limits<qint64>::min())<i) { t = -qint64(i); return true; } _reportError(qBindExpectedSmallerNumber ); } return false; }
bool _any ( ) { isChoice=true; QString t; double d; bool b; // FIXME Use QString instead of QByteArray
( (_sequence() && _out())
|| _null()
|| _bind(b)
|| _bind(d)
|| _bind(t) // including any other?
);
isChoice=false;
return true;
}
// TODO cache key:value pairs coming out of order wrt to T items() calls
bool _item(QUtf8String& k) { Step& level = levels.last();
bool _sequence(quint32* s=nullptr) { if (cached) { cacheLevel++; return cached->_sequence(s); }
if (get('[', "[{\"ntf-0123456789.")) { levels.push(Step(-1,"]")); return true; } _reportError(qBindExpectedSequence); return false; }
bool _record (quint32* s=nullptr) { if (cached) { cacheLevel++; return cached->_record(s); }
if (get('{', "[{\"ntf-0123456789.")) { levels.push(Step(-1,"}")); return true; } _reportError(qBindExpectedRecord ); return false; }
bool _null ( ) { if (cached) { cacheLevel++; return cached->_null() && cacheOut(); }
if (get('n', "[{\"ntf-0123456789.") &&
get('u', "[{\"" ) &&
get('l', "[{\"" ) &&
get('l', "[{\"" )) {
return true;
} else { _reportError(qBindExpectedNull); return false; } }
bool _bind ( QUtf8String& s) { if (cached) { cacheLevel++; return cached->_bind(s.constData()) && cacheOut(); }
QUtf8String u;
if ( get('"', "[{\"ntf-0123456789.")) { u.clear(); char c;
while ((c=getCharInString()) != '\0' ) { u.append(c); }
s=u;
return get('"');
} else { _reportError(qBindExpectedText); return false; } }
bool _bind ( QString& s) { QUtf8String u; if (_bind(u)) { s = QString::fromUtf8(u); return true; } return false; } // TODO Support user-defined QTextCodec
bool _bind ( bool& b) { if (cached) { cacheLevel++; return cached->_bind(bool(b)) && cacheOut(); }
if (get('t', "[{\"ntf-0123456789.") &&
get('r', "[{\"" ) &&
get('u', "[{\"" ) &&
get('e', "[{\"" )) { b=true;
return true;
} else
if (get('f', "[{\"ntf-0123456789.") &&
get('a', "[{\"" ) &&
get('l', "[{\"" ) &&
get('s', "[{\"" ) &&
get('e', "[{\"" )) { b=false;
return true;
} else { _reportError(qBindExpectedBoolean); return false; } }
bool _bind ( float& n) { if (cached) { cacheLevel++; return cached->_bind(double(n)) && cacheOut(); }
double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { if ( d<double( std::numeric_limits<float >::min())||
double( std::numeric_limits<float >::max())<d) { n = float(d); return true; } _reportError(qBindExpectedSmallerNumber ); } return false; }
bool _bind ( double& n) { if (cached) { cacheLevel++; return cached->_bind(double(n)) && cacheOut(); }
double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { n = d ; } return r; }
bool _bind ( quint64& t) { if (cached) { cacheLevel++; return cached->_bind(double(t)) && cacheOut(); }
double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { if (!neg ) { t = i ; return true; } _reportError(qBindExpectedPositiveNumber); } return false; }
bool _bind ( qint64& t) { if (cached) { cacheLevel++; return cached->_bind(double(t)) && cacheOut(); }
double d; quint64 i; bool neg; bool r=getNumber(d,i,neg); if (r) { if (!neg && quint64( std::numeric_limits<qint64>::max())<i) { t = qint64(i); return true; }
if ( neg && quint64(-std::numeric_limits<qint64>::min())<i) { t = -qint64(i); return true; } _reportError(qBindExpectedSmallerNumber ); } return false; }
bool cacheOut() { Q_ASSERT(cacheLevel>0);
cacheLevel--;
if (cacheLevel==1) { if (cached==&cacheWriter) { } cached=nullptr; }
if (cacheLevel==0) { cachedItems.clear(); }
return true; }
bool _out ( ) { if (cached) { return cached->_out() && cacheOut(); }
auto level = levels.pop();
while (get(',', level.end)) {
_any();
}
return get(*level.end, "}"); }
bool _item( QName u) { if (cached) { return cached->_item(u); }
QUtf8String s;
while (true) {
if (!_item(s)) return false;
if (u==s) return true;
if (cachedItems.contains(u)) {
cachedValue = cachedItems.take(u);
cacheReader.reset(&cachedValue);
cached = &cacheReader; // let outer Cursor drive QJsonReader depending on bound T
Q_ASSERT(cacheLevel<=1); cacheLevel = 1;
return true;
}
else {
cachedValue = QJsonValue();
cacheWriter.reset(&cachedValue);
if (!Cursor(this).value().bind(Cursor(&cacheWriter).value())) return false;
cachedItems.insert(s, cachedValue);
continue; // until error or u==s or
}
}}
bool _item(QUtf8String& k) { if (cached) { return cached->_item(k); }
Step& level = levels.last();
if (-1 < level.index && !get(',',level.end)) {
return false;
}
level.index++;
QString s;
if (!_bind(s)) return false;
k=s.toUtf8();
return get(':',level.end); }
bool _item( ) { Step& level = levels.last();
return _bind(k) && get(':',level.end); }
bool _item( ) { if (cached) { return cached->_item(); }
Step& level = levels.last();
if (-1 < level.index && !get(',',level.end)) {
return false;
}
level.index++;
return true; }
bool _out ( ) { auto level = levels.pop();
while (get(',', level.end)) {
_any();
}
return get(*level.end, "}"); }
bool _isOk() { return io; }
void _setChoice(bool v) { isChoice=v; }
......@@ -338,8 +366,7 @@ private:
return true;
}
qint8 getDigit(quint8 base = 10) { Q_ASSERT(0<base);
qint8 getDigit(quint8 base = 10) { Q_ASSERT(0<base);
qint8 digit;
if ( 0 <= (digit=nextChar()-'0' ) && digit < base && base <= 10) { getChar(); return digit; }
if (10 <= (digit=nextChar()-'a'+10) && digit < base && base <= 36) { getChar(); return digit; }
......@@ -404,6 +431,15 @@ private:
int line = 0, column = 0, index = -1;
QStack<Step> levels = QStack<Step>(); //!< dynamic context required to implement item() and report meaningful errors
bool isChoice = false;
// Read/Write caching of out-of-order item keys
quint8 cacheLevel = 0;
QMap<QUtf8String,QJsonValue> cachedItems ; //!< Only used if cacheLevel==1
QUtf8String cachedKey ; //!< Only used when cacheLevel==1
QJsonValue cachedValue ; //!< Only used AFTER --cacheLevel==1
IBind* cached = nullptr; //!< Only used when cacheLevel>=1 && key!=expectedKey
QJsonVisitor cacheReader ; //!< Only used as cached
QJsonBuilder cacheWriter ;
};
// //////////////////////////////////////////////////////////////////////////
......
tests/QBind/QVariant_impl.h
View file @ 41113c07
......@@ -59,13 +59,14 @@ public:
/**/ Seq<Cursor> sequence(quint32* s=nullptr) { return Cursor(this).value().sequence ( s); }
template<typename T> Cursor bind ( T&& t) { return Cursor(this).value().bind(std::forward<T>(t)); }
protected:
// TODO Support _meta to be able to cache and restitute all metadata as well as data+datatype
template<typename T>
bool _bind ( T&& t) { set(QVariant::fromValue(t)); return true; }
bool _bind ( const char* t) { set(QVariant (t)); return true; }
bool _null ( ) { set(QVariant ( )); return true; }
bool _bind ( T&& t) { set(QVariant::fromValue(t)); return true; }
bool _null ( ) { set(QVariant ( )); return true; }
bool _sequence(quint32* rows=nullptr) { Q_UNUSED(rows); levels.push(Step(nullptr)); return true; }
bool _record (quint32* cols=nullptr) { Q_UNUSED(cols); levels.push(Step("" )); return true; }
bool _sequence(quint32* =nullptr) { levels.push(Level(nullptr)); return true; }
bool _record (quint32* =nullptr) { levels.push(Level("" )); return true; }
bool _item(QName n) { levels.last().key=n ; return true; }
bool _item( ) { levels.last().key=nullptr; return true; }
......@@ -84,8 +85,8 @@ private:
}
QVariant* variant;
struct Step { QUtf8String key; /* TODO union */ QVariantMap object; QVariantList array; Step(const char* k=nullptr) : key(k) {} };
QStack<Step> levels = QStack<Step>(); //!< minimal dynamic context to implement out() and ensure actual building in case QVariantBuilder is abandoned
struct Level { QUtf8String key; /* TODO union */ QVariantMap object; QVariantList array; Level(const char* k=nullptr) : key(k) {} };
QStack<Level> levels = QStack<Level>(); //!< minimal dynamic context to implement out() and ensure actual building in case QVariantBuilder is abandoned
};
// --------------------------------------------------------------------------
......@@ -102,39 +103,39 @@ public:
QUtf8String currentPath() {
QUtf8String path;
Q_FOREACH(Step s, steps) {
if (s.key) { path.append('{').append(s.key); }
else { path.append('[').append(QUtf8String::number(s.idx)); }
Q_FOREACH(Level l, levels) {
if (l.key) { path.append('{').append(l.key); }
else { path.append('[').append(QUtf8String::number(l.idx)); }
}
return path;
}
protected:
// TODO Support _meta to be able to cache and restitute all metadata as well as data+datatype
template<typename T>
bool _bind ( T& t) { if (current()->type()==qMetaTypeId<T>()) { t = current()->value<T>(); return true; } _reportError("Expected T" ); return false; }
bool _sequence(quint32* rows=nullptr) { Q_UNUSED(rows); if (current()->type()==QVariant::List ) { steps.push(Step()); return true; } _reportError(qBindExpectedSequence); return false; }
bool _record (quint32* cols=nullptr) { Q_UNUSED(cols); if (current()->type()==QVariant::Map ) { steps.push(Step()); return true; } _reportError(qBindExpectedRecord ); return false; }
bool _null ( ) { if (current()->isNull() ) { return true; } _reportError(qBindExpectedNull ); return false; }
bool _bind ( T& t) { if (current()->type()==qMetaTypeId<T>()) { t = current()->value<T>(); return true; } _reportError("Expected T" ); return false; }
bool _sequence(quint32* =nullptr) { if (current()->type()==QVariant::List ) { levels.push(Level()); return true; } _reportError(qBindExpectedSequence); return false; }
bool _record (quint32* =nullptr) { if (current()->type()==QVariant::Map ) { levels.push(Level()); return true; } _reportError(qBindExpectedRecord ); return false; }
bool _null ( ) { if (current()->isNull() ) { return true; } _reportError(qBindExpectedNull ); return false; }
bool _item(QUtf8String& k) { steps.last().key=k; return (steps.last().item = current(1)->toMap ().value(QString::fromUtf8(steps.last().key), QVariant())).isValid(); }
bool _item( ) { steps.last().idx++; return (steps.last().item = current(1)->toList().value( steps.last().idx , QVariant())).isValid(); }
bool _out ( ) { steps.pop() ; return true; }
bool _item(QUtf8String& k) { levels.last().key=k; return (levels.last().item = current(1)->toMap ().value(QString::fromUtf8(levels.last().key), QVariant())).isValid(); }
bool _item( ) { levels.last().idx++; return (levels.last().item = current(1)->toList().value( levels.last().idx , QVariant())).isValid(); }
bool _out ( ) { levels.pop() ; return true; }
bool _isOk() { return value; }
void _setChoice(bool v) { isChoice=v; }
void _reportError(const char* error) { if (!isChoice) errors.append(Error{ error, currentPath() }); }
private:
const QVariant* current(unsigned outer=0) const { return unsigned(steps.size())-outer <= 0 ? value : &(steps[unsigned(steps.size())-outer-1].item); }
const QVariant* current(unsigned outer=0) const { return unsigned(levels.size())-outer <= 0 ? value : &(levels[unsigned(levels.size())-outer-1].item); }
const QVariant* value;
struct Step { const char* key=nullptr; int idx=-1; QVariant item; Step() = default; };
QStack<Step> steps = QStack<Step>();
struct Level { const char* key=nullptr; int idx=-1; QVariant item; Level() = default; };
QStack<Level> levels;
bool isChoice = false;
};
// TODO BindNative other QVariant-supported types?
// //////////////////////////////////////////////////////////////////////////
// QBind<QVariant,_> example support for the fixed set of IBind's BindNative types + other convenient types
// QBind<QVariant> example support for the set of IBind's BindNative types + other convenient types
template<>
struct QBind<QVariant> {
......@@ -155,9 +156,6 @@ struct QBind<QVariant> {
if (src.type()==QVariant::Int ) return v.bind(src.value< int>());
if (src.type()==QVariant::Double ) return v.bind(src.value< double>());
// TODO convert builtin types which canConvert<QString>
// \sa QBind<Val<TDst>&&, TSrcResult, IsReader<TSrcResult>>
return v.null();
}
else { Q_ASSERT_X(false, Q_FUNC_INFO, "Unsupported v->mode()"); return v.null(); }
......@@ -171,7 +169,7 @@ struct QBind<QVariant> {
};
//template<>
//struct QBind<QVariant&, Cursor, IsReader<Cursor>> { static Cursor bind(Val<Cursor>&& v, QVariant& dst) {
//struct QBind<QVariant, Cursor, IsReader<Cursor>> { static Cursor bind(Val<Cursor>&& v, QVariant& dst) {
// Cursor r;
// {
// QScopedChoice<Val<Cursor>> choice(src);
......@@ -187,3 +185,5 @@ struct QBind<QVariant> {
// if (!(r = src.null())) r.reportError("Expected boolean|decimal|text|sequence|record|null");
// /**/ dst = QVariant( ); return r;
//}};
// TODO convert builtin types which canConvert<QString>
tests/QBind/main.cpp
View file @ 41113c07
......@@ -207,6 +207,7 @@ int main(int argc, char *argv[])
QVariant v;
b.open(QIODevice::ReadWrite);
QDataStream d(&b);
#if 0
GROUP("<builtin")
{
START {
......@@ -486,11 +487,12 @@ int main(int argc, char *argv[])
STOP("Writable>Json",QString::fromUtf8(b.buffer()));
}
GROUP_STOP
#endif
GROUP("Read+Write")
{
QBuffer json;
json.open(QIODevice::ReadOnly);
json.buffer() = "_{ \"names\": [ _\"John\" _, \"Doe\"] , \"height\":_1.75 , \"age\":null, \"phones\":[ \"+44 1234567\" , \"+44 2345678\" ], \"\":\"superfluous item\" _} ";
json.buffer() = "_{ \"names\": [ _\"John\" _, \"Doe\"] , \"age\":null, \"phones\":[ \"+44 1234567\" , \"+44 2345678\" ], \"\":\"superfluous item\", \"height\":_1.75 _} ";
QJsonValue v;
#if QT_VERSION>=QT_VERSION_CHECK(5,12,0)
QCborValue c;
......@@ -498,6 +500,7 @@ int main(int argc, char *argv[])
Person p;
QVector<QJsonReader ::Error> jsonReaderErrors ;
QVector<QJsonVisitor::Error> jsonVisitorErrors;
#if 0
START {
json.seek(0); b.seek(0); b.buffer().clear();
QJsonReader r(&json);
......@@ -512,6 +515,7 @@ int main(int argc, char *argv[])
jsonReaderErrors = r.errors;
}
STOP("Json>JsonValue",QString::fromUtf8(QJsonDocument(v.toObject()).toJson()+Text(jsonReaderErrors)));
#endif
START {
json.seek(0); p = {};
QJsonReader r(&json);
......@@ -519,6 +523,7 @@ int main(int argc, char *argv[])
jsonReaderErrors = r.errors;
}
STOP("Json>T",QString::fromUtf8(Text(p)+Text(jsonReaderErrors)))
#if 0
START {
v = QJsonValue();
QJsonBuilder(&v).bind(p);
......@@ -621,8 +626,10 @@ int main(int argc, char *argv[])
QCborWriter(&b).bind(v);
}
STOP("JsonValue>Cbor",QString::fromUtf8(b.buffer().toHex()));
#endif
}
GROUP_STOP
#if 0
{
QVector<Person> persons;
persons << person << person << person;
......@@ -647,5 +654,6 @@ int main(int argc, char *argv[])
QModelWriter(&m).meta({{qmSizes ,"4,4" }}).bind(transform);
}
}
#endif
return (fclose(samples)==0) &/*anyway*/ (fclose(results)==0);
}
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment