QVariant value(const QStringList & keys, const QVariantMap & context,
const QVariant & defaultValue = QVariant()){
const QVariantMap* map = &context;
int i = 0;
while(i < keys.size()) {
const QString & key = keys.at(i++);
QVariantMap::const_iterator it = map->find(key);
if(it == map->constEnd())
return defaultValue;
const QVariant & value = *it;
if(i >= keys.size()) {
return detached(value);
}
if(value.type() == QVariant::Map)
map = &asMap(value);
else if(i == keys.size() -1 && value.type() == QVariant::List) {
const QString & idxStr = keys.at(i);
bool ok;
int idx = idxStr.toInt(&ok);
if(ok) {
const QVariantList & lst = asList(value);
if(idx < lst.size())
return detached(lst[idx]);
}
}
else
return defaultValue;
}
return defaultValue;
}
QVariant & value_unsafe(const QStringList & keys, QVariantMap & context){
QVariantMap* map = &context;
int i = 0;
while(i < keys.size()) {
const QString & key = keys.at(i++);
QVariantMap::iterator it = map->find(key);
if(it == map->constEnd())
return nullVariant;
QVariant & value = *it;
if(i >= keys.size())
return value;
if(value.type() == QVariant::Map)
map = &asMap(value);
else if(i == keys.size() -1 && value.type() == QVariant::List) {
const QString & idxStr = keys.at(i);
bool ok;
int idx = idxStr.toInt(&ok);
if(ok) {
QVariantList & lst = asList(value);
if(idx < lst.size())
return lst[idx];
}
}
else
return nullVariant;
}
return nullVariant;
}
void RizzlyPrintTest::onlyInstance()
{
std::stringstream ss;
RizzlyPrint printer(ss);
Component *component = ComponentFactory::produce("Component", {}, {});
Instance *instance = InstanceFactory::produce(component, "instance", Point(0,0));
Composition *composition = new Composition(new CompositionInstanceMock());
composition->getInstances().add(instance);
printer.print(*composition);
std::vector<std::string> listing = asList(ss);
CPPUNIT_ASSERT_EQUAL(size_t(1), listing.size());
CPPUNIT_ASSERT_EQUAL(std::string("instance: Component;"), listing[0]);
CompositionFactory::dispose(composition);
ComponentFactory::dispose(component);
}
std::string VariantImpl::asString() const
{
switch(type) {
case VAR_VOID: return EMPTY;
case VAR_BOOL: return value.b ? TRUE : FALSE;
case VAR_UINT8: return boost::lexical_cast<std::string>((int) value.ui8);
case VAR_UINT16: return boost::lexical_cast<std::string>(value.ui16);
case VAR_UINT32: return boost::lexical_cast<std::string>(value.ui32);
case VAR_UINT64: return boost::lexical_cast<std::string>(value.ui64);
case VAR_INT8: return boost::lexical_cast<std::string>((int) value.i8);
case VAR_INT16: return boost::lexical_cast<std::string>(value.i16);
case VAR_INT32: return boost::lexical_cast<std::string>(value.i32);
case VAR_INT64: return boost::lexical_cast<std::string>(value.i64);
case VAR_DOUBLE: return boost::lexical_cast<std::string>(value.d);
case VAR_FLOAT: return boost::lexical_cast<std::string>(value.f);
case VAR_STRING: return *reinterpret_cast<std::string*>(value.v);
case VAR_LIST: return toString(asList());
case VAR_MAP: return toString(asMap());
default: throw InvalidConversion(QPID_MSG("Cannot convert from " << getTypeName(type) << " to " << getTypeName(VAR_STRING)));
}
}
void RizzlyPrintTest::connection()
{
std::stringstream ss;
RizzlyPrint printer(ss);
Component *component = ComponentFactory::produce("Component", {"a"}, {"b"});
Instance *instance = InstanceFactory::produce(component, "inst", Point(0,0));
Connection *connection = ConnectionFactory::produce(instance->getPorts().front(), instance->getPorts().back());
Composition *composition = new Composition(new CompositionInstanceMock());
composition->getInstances().add(instance);
composition->getConnections().add(connection);
printer.print(*composition);
std::vector<std::string> listing = asList(ss);
CPPUNIT_ASSERT_EQUAL(size_t(2), listing.size());
CPPUNIT_ASSERT_EQUAL(std::string("inst: Component;"), listing[0]);
CPPUNIT_ASSERT_EQUAL(std::string("inst.a -> inst.b;"), listing[1]);
CompositionFactory::dispose(composition);
ComponentFactory::dispose(component);
}
bool unset(const QStringList & keys, QVariantMap & context){
if(keys.size() == 1){
return context.remove(keys.first()) > 0;
}
QVariant v = value_unsafe(keys.mid(0, keys.size() - 1), context);
if(v.isNull())
return false;
if(v.type() == QVariant::Map) {
QVariantMap & map = asMap(v);
return map.remove(keys.last()) != 0;
}
if(v.type() == QVariant::List) {
QVariantList & lst = asList(v);
bool ok;
int idx = keys.last().toInt(&ok);
if(!ok || idx >= lst.size())
return false;
lst.removeAt(idx);
return true;
}
return false;
}
bool VariantImpl::isEqualTo(VariantImpl& other) const
{
if (type == other.type) {
switch(type) {
case VAR_VOID: return true;
case VAR_BOOL: return value.b == other.value.b;
case VAR_UINT8: return value.ui8 == other.value.ui8;
case VAR_UINT16: return value.ui16 == other.value.ui16;
case VAR_UINT32: return value.ui32 == other.value.ui32;
case VAR_UINT64: return value.ui64 == other.value.ui64;
case VAR_INT8: return value.i8 == other.value.i8;
case VAR_INT16: return value.i16 == other.value.i16;
case VAR_INT32: return value.i32 == other.value.i32;
case VAR_INT64: return value.i64 == other.value.i64;
case VAR_DOUBLE: return value.d == other.value.d;
case VAR_FLOAT: return value.f == other.value.f;
case VAR_STRING: return *reinterpret_cast<std::string*>(value.v)
== *reinterpret_cast<std::string*>(other.value.v);
case VAR_LIST: return equal(asList(), other.asList());
case VAR_MAP: return equal(asMap(), other.asMap());
}
}
return false;
}
