github-starred/qmlnet
2
0
Fork 0
mirror of https://github.com/qmlnet/qmlnet.git synced 2026-05-15 14:15:54 -06:00
Code Issues 56 Projects Packages Wiki Activity Actions

Don't need to store the "preferred variant type" anymore.

Browse source 
It isn't needed.
This commit is contained in:
Paul Knopf 2019-04-27 19:39:50 -04:00
parent 679ae9064e
commit 6d14686f90
14 changed files with 80 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/native/QmlNet/QmlNet/qml/NetValueMetaObject.cpp
View file

@ -166,7 +166,7 @@ int NetValueMetaObject::metaCallRecursive(QMetaObject::Call c, int originalIdx,
qPrintable(result->getDisplayValue()));
#endif
NetMetaValuePack(propertyType->getPrefVariantType(), result, a[0]);
NetMetaValuePack(result, a[0]);
}
break;
case WriteProperty:
@ -184,7 +184,7 @@ int NetValueMetaObject::metaCallRecursive(QMetaObject::Call c, int originalIdx,
QSharedPointer<NetTypeInfo> propertyType = propertyInfo->getReturnType();
QSharedPointer<NetVariant> newValue = QSharedPointer<NetVariant>(new NetVariant());
NetMetaValueUnpack(propertyType->getPrefVariantType(), newValue, a[0]);
NetMetaValueUnpack(newValue, a[0]);
QmlNet::writeProperty(propertyInfo, instance, nullptr, newValue);
}
@ -220,7 +220,7 @@ int NetValueMetaObject::metaCallRecursive(QMetaObject::Call c, int originalIdx,
QSharedPointer<NetMethodInfoArguement> parameter = methodInfo->getParameter(index);
QSharedPointer<NetTypeInfo> parameterType = parameter->getType();
QSharedPointer<NetVariant> netVariant = QSharedPointer<NetVariant>(new NetVariant());
NetMetaValueUnpack(parameterType->getPrefVariantType(), netVariant, a[index + 1]);
NetMetaValueUnpack(netVariant, a[index + 1]);
parameters->add(netVariant);
}
@ -246,7 +246,7 @@ int NetValueMetaObject::metaCallRecursive(QMetaObject::Call c, int originalIdx,
#endif
if(result != nullptr) {
NetMetaValuePack(returnType->getPrefVariantType(), result, a[0]);
NetMetaValuePack(result, a[0]);
}
return -1;
@ -264,10 +264,8 @@ int NetValueMetaObject::metaCallRecursive(QMetaObject::Call c, int originalIdx,
parameters = QSharedPointer<NetVariantList>(new NetVariantList());
for(int index = 0; index <= signalInfo->getParameterCount() - 1; index++)
{
NetVariantTypeEnum parameterType = signalInfo->getParameter(index);
QSharedPointer<NetVariant> netVariant = QSharedPointer<NetVariant>(new NetVariant());
NetMetaValueUnpack(parameterType, netVariant, a[index + 1]);
NetMetaValueUnpack(netVariant, a[index + 1]);
parameters->add(netVariant);
}
}

124
src/native/QmlNet/QmlNet/qml/NetValueMetaObjectPacker.cpp
View file

@ -8,9 +8,10 @@
void NetValueTypePacker::pack(const QSharedPointer<NetVariant>& source, void* destination)
{
QVariant* destinationVariant = static_cast<QVariant*>(destination);
switch(source->getVariantType()) {
switch(source->getVariantType())
{
case NetVariantTypeEnum_Invalid:
destinationVariant->setValue(QVariant::fromValue(nullptr));
destinationVariant->clear();
break;
case NetVariantTypeEnum_Null:
destinationVariant->setValue(nullptr);
@ -45,8 +46,7 @@ void NetValueTypePacker::pack(const QSharedPointer<NetVariant>& source, void* de
case NetVariantTypeEnum_DateTime:
destinationVariant->setValue(source->getDateTime());
break;
case NetVariantTypeEnum_Object:
{
case NetVariantTypeEnum_Object: {
QSharedPointer<NetReference> newInstance = source->getNetReference();
NetValue* netValue = NetValue::forInstance(newInstance);
destinationVariant->setValue(netValue);
@ -58,10 +58,14 @@ void NetValueTypePacker::pack(const QSharedPointer<NetVariant>& source, void* de
case NetVariantTypeEnum_QObject:
destinationVariant->setValue(source->getQObject()->getQObject());
break;
case NetVariantTypeEnum_NetVariantList:
destinationVariant->clear();
qWarning() << "TODO: Pack NetVariantList into a QVariantList";
break;
}
}
void NetValueTypePacker::unpack(const QSharedPointer<NetVariant>& destination, void* source, NetVariantTypeEnum prefType)
void NetValueTypePacker::unpack(const QSharedPointer<NetVariant>& destination, void* source)
{
QVariant* sourceVariant = static_cast<QVariant*>(source);
@ -70,115 +74,12 @@ void NetValueTypePacker::unpack(const QSharedPointer<NetVariant>& destination, v
return;
}
switch(prefType) {
case NetVariantTypeEnum_Invalid:
destination->clear();
return;
case NetVariantTypeEnum_Null:
destination->setNull();
break;
case NetVariantTypeEnum_Bool:
destination->setBool(sourceVariant->toBool());
return;
case NetVariantTypeEnum_Char:
{
const QString& v = sourceVariant->toString();
if(v.length() == 1) {
destination->setChar(v.at(0));
} else {
qDebug() << "Can't set string" << v << "to char.";
destination->setChar(QChar::Null);
}
return;
}
case NetVariantTypeEnum_Int:
destination->setInt(sourceVariant->value<qint32>());
return;
case NetVariantTypeEnum_UInt:
destination->setUInt(sourceVariant->value<quint32>());
return;
case NetVariantTypeEnum_Long:
destination->setLong(sourceVariant->value<qint64>());
return;
case NetVariantTypeEnum_ULong:
destination->setULong(sourceVariant->value<quint64>());
return;
case NetVariantTypeEnum_Float:
destination->setFloat(sourceVariant->toFloat());
return;
case NetVariantTypeEnum_Double:
destination->setDouble(sourceVariant->toDouble());
return;
case NetVariantTypeEnum_String:
destination->setString(sourceVariant->toString());
return;
case NetVariantTypeEnum_DateTime:
destination->setDateTime(sourceVariant->toDateTime());
return;
case NetVariantTypeEnum_Object:
{
if(sourceVariant->userType() == QMetaType::QObjectStar) {
QObject* value = sourceVariant->value<QObject*>();
NetValueInterface* netValue = qobject_cast<NetValueInterface*>(value);
if(netValue) {
destination->setNetReference(netValue->getNetReference());
} else {
QSharedPointer<NetQObject> netQObject(new NetQObject(value));
destination->setQObject(netQObject);
}
return;
}
break;
}
case NetVariantTypeEnum_JSValue:
{
if(sourceVariant->userType() == qMetaTypeId<QJSValue>()) {
QSharedPointer<NetJSValue> netJsValue(new NetJSValue(sourceVariant->value<QJSValue>()));
destination->setJsValue(netJsValue);
return;
}
// TODO: Try to convert other types to JS Value.
break;
}
case NetVariantTypeEnum_QObject:
{
if(sourceVariant->userType() == QMetaType::QObjectStar) {
QSharedPointer<NetQObject> netQObject(new NetQObject(sourceVariant->value<QObject*>()));
}
}
}
NetVariant::fromQVariant(sourceVariant, destination);
}
NetValueMetaObjectPacker::NetValueMetaObjectPacker()
{
NetValueTypePacker* variantPacker = new NetValueTypePacker();
//This is might not be pretty, but it does allow the compiler generate a warning if a value is missing.
for (int typeInt = NetVariantTypeEnum_Invalid; typeInt <= NetVariantTypeEnum_JSValue; ++typeInt)
{
NetVariantTypeEnum type = NetVariantTypeEnum(typeInt);
switch(type) {
case NetVariantTypeEnum_Invalid:
case NetVariantTypeEnum_Null:
case NetVariantTypeEnum_Bool:
case NetVariantTypeEnum_Char:
case NetVariantTypeEnum_Int:
case NetVariantTypeEnum_UInt:
case NetVariantTypeEnum_Long:
case NetVariantTypeEnum_ULong:
case NetVariantTypeEnum_Float:
case NetVariantTypeEnum_Double:
case NetVariantTypeEnum_DateTime:
case NetVariantTypeEnum_Object:
case NetVariantTypeEnum_JSValue:
case NetVariantTypeEnum_QObject:
case NetVariantTypeEnum_String:
packers[type] = variantPacker;
break;
}
}
_packer = new NetValueTypePacker();
}
NetValueMetaObjectPacker* NetValueMetaObjectPacker::getInstance()
@ -187,8 +88,7 @@ NetValueMetaObjectPacker* NetValueMetaObjectPacker::getInstance()
return &packer;
}
NetValueTypePacker* NetValueMetaObjectPacker::getPacker(NetVariantTypeEnum variantType)
NetValueTypePacker* NetValueMetaObjectPacker::getPacker()
{
Q_ASSERT(packers.contains(variantType));
return packers[variantType];
return _packer;
}

14
src/native/QmlNet/QmlNet/qml/NetValueMetaObjectPacker.h
View file

@ -13,22 +13,22 @@ public:
NetValueTypePacker() {}
virtual ~NetValueTypePacker() {}
virtual void pack(const QSharedPointer<NetVariant>& source, void* destination);
virtual void unpack(const QSharedPointer<NetVariant>& destination, void* source, NetVariantTypeEnum prefType);
virtual void unpack(const QSharedPointer<NetVariant>& destination, void* source);
};
#define NetMetaValuePack(type, source, destination) \
NetValueMetaObjectPacker::getInstance()->getPacker(type)->pack(source, destination)
#define NetMetaValueUnpack(type, destination, source) \
NetValueMetaObjectPacker::getInstance()->getPacker(type)->unpack(destination, source, type)
#define NetMetaValuePack(source, destination) \
NetValueMetaObjectPacker::getInstance()->getPacker()->pack(source, destination)
#define NetMetaValueUnpack(destination, source) \
NetValueMetaObjectPacker::getInstance()->getPacker()->unpack(destination, source)
class NetValueMetaObjectPacker
{
public:
NetValueMetaObjectPacker();
static NetValueMetaObjectPacker* getInstance();
NetValueTypePacker* getPacker(NetVariantTypeEnum variantType);
NetValueTypePacker* getPacker();
private:
QMap<NetVariantTypeEnum, NetValueTypePacker*> packers;
NetValueTypePacker* _packer;
};
#endif // NETVALUEMETAOBJECTPACKER_H

82
src/native/QmlNet/QmlNet/qml/NetVariant.cpp
View file

@ -55,7 +55,7 @@ NetVariant::~NetVariant()
NetVariantTypeEnum NetVariant::getVariantType() const
{
const int type = variant.userType();
const int type = _variant.userType();
switch(type) {
case QMetaType::UnknownType:
return NetVariantTypeEnum_Invalid;
@ -95,7 +95,7 @@ NetVariantTypeEnum NetVariant::getVariantType() const
return NetVariantTypeEnum_NetVariantList;
}
else {
qWarning() << "Unknown type for NetVariant: " << variant.typeName();
qWarning() << "Unknown type for NetVariant: " << _variant.typeName();
return NetVariantTypeEnum_Invalid;
}
}
@ -104,13 +104,13 @@ NetVariantTypeEnum NetVariant::getVariantType() const
void NetVariant::setNull()
{
clearNetReference();
variant.setValue(nullptr);
_variant.setValue(nullptr);
}
void NetVariant::setNetReference(QSharedPointer<NetReference> netReference)
{
clearNetReference();
variant.setValue(NetReferenceQmlContainer{ std::move(netReference) });
_variant.setValue(NetReferenceQmlContainer{ std::move(netReference) });
}
QSharedPointer<NetReference> NetVariant::getNetReference() const
@ -135,6 +135,15 @@ void NetVariant::setChar(QChar value)
QChar NetVariant::getChar() const
{
// Try to convert the internal QString into a Char
if(_variant.userType() == QMetaType::QString) {
QString str = _variant.value<QString>();
if(str.length() == 1) {
return str.at(0);
}
qWarning() << "Can't convert '" << str << "' to QChar";
return QChar::Null;
}
return getValue<QChar>();
}
@ -210,12 +219,7 @@ void NetVariant::setString(const QString& value)
QString NetVariant::getString() const
{
if(variant.userType() != QMetaType::QString) {
qDebug() << "Variant is not a string";
return QString();
}
return variant.toString();
return _variant.toString();
}
void NetVariant::setDateTime(const QDateTime& value)
@ -261,7 +265,7 @@ QSharedPointer<NetVariantList> NetVariant::getNetVariantList() const
void NetVariant::clear()
{
clearNetReference();
variant.clear();
_variant.clear();
}
QVariantList NetVariant::toQVariantList() const
@ -300,7 +304,7 @@ QVariantList NetVariant::toQVariantList() const
return list;
}
qWarning() << "Can't convert value" << variant << "from" << variant.typeName() << "to QVariantList";
qWarning() << "Can't convert value" << _variant << "from" << _variant.typeName() << "to QVariantList";
return QVariantList();
}
@ -327,7 +331,7 @@ QSharedPointer<NetVariant> NetVariant::fromQJSValue(const QJSValue& qJsValue)
} else {
result = QSharedPointer<NetVariant>(new NetVariant());
QVariant variant = qJsValue.toVariant();
result->variant = variant;
result->_variant = variant;
}
return result;
}
@ -433,18 +437,30 @@ QSharedPointer<NetVariant> NetVariant::fromQVariant(const QVariant* variant)
}
QVariant NetVariant::toQVariant() const
{
QVariant variant;
toQVariant(&variant);
return variant;
}
void NetVariant::toQVariant(QVariant* variant) const
{
switch(getVariantType()) {
case NetVariantTypeEnum_JSValue:
return getJsValue()->getJsValue().toVariant();
*variant = getJsValue()->getJsValue().toVariant();
break;
case NetVariantTypeEnum_Object:
return QVariant::fromValue<QObject*>(NetValue::forInstance(getNetReference()));
*variant = QVariant::fromValue<QObject*>(NetValue::forInstance(getNetReference()));
break;
case NetVariantTypeEnum_QObject:
return QVariant::fromValue<QObject*>(this->getQObject()->getQObject());
*variant = QVariant::fromValue<QObject*>(this->getQObject()->getQObject());
break;
case NetVariantTypeEnum_NetVariantList:
return QVariant::fromValue(toQVariantList());
*variant = QVariant::fromValue(toQVariantList());
break;
default:
return variant;
*variant = _variant;
break;
}
}
@ -458,23 +474,23 @@ QString NetVariant::getDisplayValue() const
case NetVariantTypeEnum_QObject:
return getQObject()->getQObject()->objectName();
default:
return variant.toString();
return _variant.toString();
}
}
void NetVariant::clearNetReference()
{
if(variant.canConvert<NetReferenceQmlContainer>()) {
variant.value<NetReferenceQmlContainer>().netReference.clear();
variant.clear();
if(_variant.canConvert<NetReferenceQmlContainer>()) {
_variant.value<NetReferenceQmlContainer>().netReference.clear();
_variant.clear();
}
else if(variant.canConvert<NetJsValueQmlContainer>()) {
variant.value<NetJsValueQmlContainer>().jsValue.clear();
variant.clear();
else if(_variant.canConvert<NetJsValueQmlContainer>()) {
_variant.value<NetJsValueQmlContainer>().jsValue.clear();
_variant.clear();
}
else if(variant.canConvert<NetQObjectQmlContainer>()) {
variant.value<NetQObjectQmlContainer>().netQObject.clear();
variant.clear();
else if(_variant.canConvert<NetQObjectQmlContainer>()) {
_variant.value<NetQObjectQmlContainer>().netQObject.clear();
_variant.clear();
}
}
@ -482,7 +498,7 @@ template<typename T>
void NetVariant::setValue(const T& value)
{
clearNetReference();
variant.setValue(value);
_variant.setValue(value);
}
void NetVariant::setValueVariant(const QVariant& value)
@ -491,7 +507,7 @@ void NetVariant::setValueVariant(const QVariant& value)
Q_ASSERT(value.userType() != qMetaTypeId<QJSValue>());
Q_ASSERT(value.userType() < QMetaType::User);
clearNetReference();
variant = value;
_variant = value;
}
template<typename T>
@ -507,10 +523,10 @@ void NetVariant::setValuePtr(const T* value)
template<typename T>
T NetVariant::getValue() const
{
if(!variant.canConvert(qMetaTypeId<T>())) {
qDebug() << "Can't convert value" << variant << "from" << variant.typeName() << "to" << QMetaType::typeName(qMetaTypeId<T>());
if(!_variant.canConvert(qMetaTypeId<T>())) {
qDebug() << "Can't convert value" << _variant << "from" << _variant.typeName() << "to" << QMetaType::typeName(qMetaTypeId<T>());
}
return variant.value<T>();
return _variant.value<T>();
}
extern "C" {

3
src/native/QmlNet/QmlNet/qml/NetVariant.h
View file

@ -56,6 +56,7 @@ public:
static void fromQVariant(const QVariant* variant, const QSharedPointer<NetVariant>& destination);
static QSharedPointer<NetVariant> fromQVariant(const QVariant* variant);
QVariant toQVariant() const;
void toQVariant(QVariant* variant) const;
QString getDisplayValue() const;
private:
@ -71,7 +72,7 @@ private:
template<typename T>
T getValue() const;
QVariant variant;
QVariant _variant;
};
struct NetVariantContainer {

17
src/native/QmlNet/QmlNet/types/NetTypeInfo.cpp
View file

@ -16,7 +16,6 @@ Q_GLOBAL_STATIC(QMutex, typeIdMutex);
NetTypeInfo::NetTypeInfo(QString fullTypeName) :
metaObject(nullptr),
_fullTypeName(std::move(fullTypeName)),
_variantType(NetVariantTypeEnum_Invalid),
_isArray(false),
_isList(false),
_hasComponentCompleted(false),
@ -61,14 +60,6 @@ void NetTypeInfo::setClassName(QString className) {
_className = std::move(className);
}
NetVariantTypeEnum NetTypeInfo::getPrefVariantType() {
return _variantType;
}
void NetTypeInfo::setPrefVariantType(NetVariantTypeEnum variantType) {
_variantType = variantType;
}
bool NetTypeInfo::isArray()
{
return _isArray;
@ -264,14 +255,6 @@ Q_DECL_EXPORT void type_info_setClassName(NetTypeInfoContainer* netTypeInfo, LPW
netTypeInfo->netTypeInfo->setClassName(QString::fromUtf16(static_cast<const char16_t*>(className)));
}
Q_DECL_EXPORT NetVariantTypeEnum type_info_getPrefVariantType(NetTypeInfoContainer* netTypeInfo) {
return netTypeInfo->netTypeInfo->getPrefVariantType();
}
Q_DECL_EXPORT void type_info_setPrefVariantType(NetTypeInfoContainer* netTypeInfo, NetVariantTypeEnum variantType) {
netTypeInfo->netTypeInfo->setPrefVariantType(variantType);
}
Q_DECL_EXPORT uchar type_info_getIsArray(NetTypeInfoContainer* netTypeInfo)
{
if(netTypeInfo->netTypeInfo->isArray()) {

4
src/native/QmlNet/QmlNet/types/NetTypeInfo.h
View file

@ -27,9 +27,6 @@ public:
QString getClassName();
void setClassName(QString className);
NetVariantTypeEnum getPrefVariantType();
void setPrefVariantType(NetVariantTypeEnum variantType);
bool isArray();
void setIsArray(bool isArray);
@ -73,7 +70,6 @@ private:
QString _fullTypeName;
QString _baseType;
QString _className;
NetVariantTypeEnum _variantType;
bool _isArray;
bool _isList;
bool _hasComponentCompleted;

2
src/net/Qml.Net.Tests/Qml/EnumTests.cs
View file

@ -116,7 +116,7 @@ namespace Qml.Net.Tests.Qml
}
[Fact]
public void Nullable_enum_is_null_type_is_js_when_null()
public void Nullable_enum_is_null_type_in_js_when_null()
{
Mock.Setup(x => x.ValueNullable).Returns((EnumTestsObject.TestEnum?)null);
Mock.Setup(x => x.Test(It.IsAny<string>()));

1
src/net/Qml.Net.Tests/Qml/NetVariantTests.cs
View file

@ -179,7 +179,6 @@ namespace Qml.Net.Tests.Qml
}
}
}
}
[Fact]

4
src/net/Qml.Net.Tests/Qml/QObjectTests.cs
View file

@ -575,7 +575,7 @@ namespace Qml.Net.Tests.Qml
{
AssertQObject(qObject =>
{
AssertValue(qObject, "QVariantList", new List<int>{ 3 }, result =>
AssertValue(qObject, "QVariantList", new List<int> { 3 }, result =>
{
result.Should().NotBeNull();
var list = result.Should().BeAssignableTo<IList<object>>().Subject;
@ -584,7 +584,7 @@ namespace Qml.Net.Tests.Qml
});
qObject.SetProperty("objectName", "tetttt");
AssertValue(qObject, "QVariantList", new List<object>{ qObject }, result =>
AssertValue(qObject, "QVariantList", new List<object> { qObject }, result =>
{
result.Should().NotBeNull();
var list = result.Should().BeAssignableTo<IList<object>>().Subject;

1
src/net/Qml.Net.Tests/Types/NetTypeManagerTests.cs
View file

@ -27,7 +27,6 @@ namespace Qml.Net.Tests.Types
typeInfo.FullTypeName.Should().Be(typeof(TestType1).AssemblyQualifiedName);
typeInfo.ClassName.Should().Be("TestType1");
typeInfo.PrefVariantType.Should().Be(NetVariantType.Object);
typeInfo.MethodCount.Should().Be(1);
typeInfo.PropertyCount.Should().Be(1);
}

4
src/net/Qml.Net/Internal/DefaultCallbacks.cs
View file

@ -42,9 +42,7 @@ namespace Qml.Net.Internal
}
type.ClassName = typeInfo.Name;
type.PrefVariantType = GetPrefVariantType(typeInfo);
// All the methods/properties/signals are later populated when needed.
}
}

3
src/net/Qml.Net/Internal/Interop.cs
View file

@ -49,8 +49,7 @@ namespace Qml.Net.Internal
if (!result.IsSuccess)
{
throw new Exception("Unable to find the native Qml.Net library." +
" Try calling \"RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();\" in Program.Main()");;
throw new Exception("Unable to find the native Qml.Net library. Try calling \"RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();\" in Program.Main()");
}
var library = loader.LoadLibrary(result.Path);

20
src/net/Qml.Net/Internal/Types/NetTypeInfo.cs
View file

@ -32,12 +32,6 @@ namespace Qml.Net.Internal.Types
set => Interop.NetTypeInfo.SetClassName(Handle, value);
}
public NetVariantType PrefVariantType
{
get => Interop.NetTypeInfo.GetPrefVariantType(Handle);
set => Interop.NetTypeInfo.SetPrefVariantType(Handle, value);
}
public bool IsArray
{
get => Interop.NetTypeInfo.GetIsArray(Handle) == 1;
@ -195,20 +189,6 @@ namespace Qml.Net.Internal.Types
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate IntPtr GetClassNameDel(IntPtr netTypeInfo);
[NativeSymbol(Entrypoint = "type_info_setPrefVariantType")]
public SetPrefVariantTypeDel SetPrefVariantType { get; set; }
[SuppressUnmanagedCodeSecurity]
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void SetPrefVariantTypeDel(IntPtr netTypeInfo, NetVariantType variantType);
[NativeSymbol(Entrypoint = "type_info_getPrefVariantType")]
public GetPrefVariantTypeDel GetPrefVariantType { get; set; }
[SuppressUnmanagedCodeSecurity]
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate NetVariantType GetPrefVariantTypeDel(IntPtr netTypeInfo);
[NativeSymbol(Entrypoint = "type_info_getIsArray")]
public GetIsArrayDel GetIsArray { get; set; }