/* Sets the given property to the given value. */
void QucsTranscalc::setProperty (QString prop, double value) {
struct TransValue * val = findProperty (prop);
if (val) {
val->lineedit->setText (QString::number (value));
val->value = value;
}
}
const char *PropNameData::getPropertyName(int32_t property, int32_t nameChoice) {
int32_t valueMapIndex=findProperty(property);
if(valueMapIndex==0) {
return NULL; // Not a known property.
}
return getName(nameGroups+valueMaps[valueMapIndex], nameChoice);
}
void Persistence::remove(short propertyId)
{
if (findProperty(propertyId))
{
_size -= (_currProperty->valueSize + sizeof(Property));
if (_count > 1)
{
//move data if needed
if (_index < _count - 1)
{
//copy destination location
_moveProperty = _currProperty;
//calculate data size to move
short moveSize = 0;
for (; _index < (_count - 1); _index++)
{
_currProperty = (Property *) (((unsigned short)_currProperty) + sizeof(Property) + _currProperty->valueSize);
moveSize += sizeof(Property) + _currProperty->valueSize;
}
memmove(_moveProperty, (void *) ((unsigned short)_moveProperty + sizeof(Property) + _moveProperty->valueSize), moveSize);
}
}
_count--;
if (_size <= 0)
flush();
fixPointers();
}
}
/* Returns the given property value. */
double QucsTranscalc::getProperty (QString prop) {
struct TransValue * val = findProperty (prop);
if (val) {
QString str = val->lineedit->text ();
val->value = str.toDouble ();
return val->value;
}
return 0;
}
Variant BaseGenericObject::getProperty(const char* name) const
{
auto accessor = findProperty(name);
if (!accessor.isValid())
{
TF_ASSERT(false && "Property could not be found");
return Variant();
}
return accessor.getValue();
}
/* Returns the given property selection. */
bool QucsTranscalc::isSelected (QString prop) {
struct TransValue * val = findProperty (prop);
if (val) {
if (val->radio)
if (val->radio->isChecked ()) {
return true;
}
}
return false;
}
const char *PropNameData::getPropertyValueName(int32_t property, int32_t value, int32_t nameChoice) {
int32_t valueMapIndex=findProperty(property);
if(valueMapIndex==0) {
return NULL; // Not a known property.
}
int32_t nameGroupOffset=findPropertyValueNameGroup(valueMaps[valueMapIndex+1], value);
if(nameGroupOffset==0) {
return NULL;
}
return getName(nameGroups+nameGroupOffset, nameChoice);
}
Property *Persistence::get(short propertyId)
{
if (findProperty(propertyId))
{
return _currProperty;
}
else
{
return NULL;
}
}
long Persistence::getLong(short propertyId)
{
if (findProperty(propertyId))
{
memcpy(&_lastLong, _currProperty->value, _currProperty->valueSize);
return _lastLong;
}
else
{
return -1;
}
}
int Persistence::getInt(short propertyId)
{
if (findProperty(propertyId))
{
memcpy(&_lastInt, _currProperty->value, _currProperty->valueSize);
return _lastInt;
}
else
{
return -1;
}
}
uint32_t devTree::getPhandle(dtOffset_t nodeOffset)
{
uint32_t* phandlePtr = (uint32_t*) findProperty(nodeOffset, "phandle");
if(phandlePtr)
{
return *phandlePtr;
}
/* We didn't find a phandle, so we need to add one. */
uint32_t newPhandle = mNextPhandle++;
addPropertyCell32(nodeOffset, "phandle", newPhandle);
return newPhandle;
}
/* Returns the given property unit. */
char * QucsTranscalc::getUnit (QString prop) {
struct TransValue * val = findProperty (prop);
if (val) {
QString str = val->combobox->currentText ();
for (int i = 0; val->units[i]; i++) {
if (str == val->units[i]) {
val->unit = i;
return (char *) val->units[i];
}
}
}
return NULL;
}
int32_t PropNameData::getPropertyValueEnum(int32_t property, const char *alias) {
int32_t valueMapIndex=findProperty(property);
if(valueMapIndex==0) {
return UCHAR_INVALID_CODE; // Not a known property.
}
valueMapIndex=valueMaps[valueMapIndex+1];
if(valueMapIndex==0) {
return UCHAR_INVALID_CODE; // The property does not have named values.
}
// valueMapIndex is the start of the property's valueMap,
// where the first word is the BytesTrie offset.
return getPropertyOrValueEnum(valueMaps[valueMapIndex], alias);
}
T getObjectProperty(int index, const GenericListT<GenericObjectPtr>& objects, const char* name, T&& defaultValue)
{
assert(index >= 0 && static_cast<size_t>(index) < objects.size());
auto genericObject = objects[index];
const auto accessor = genericObject->findProperty(name);
if (accessor.isValid())
{
T value;
bool isOk = genericObject->get(name, value);
assert(isOk);
return value;
}
return std::forward<T>(defaultValue);
}
/* Sets the given property unit. */
void QucsTranscalc::setUnit (QString prop, const char * unit) {
struct TransValue * val = findProperty (prop);
if (val) {
if (!unit) {
val->combobox->setCurrentIndex (0);
val->unit = 0;
}
else for (int i = 0; val->units[i]; i++) {
if (!strcmp (unit, val->units[i])) {
val->combobox->setCurrentIndex (i);
val->unit = i;
break;
}
}
}
}
void Persistence::set(short propertyId, void *data, short dataSize)
{
if (findProperty(propertyId))
{
//verify if size was changed
if (dataSize != _currProperty->valueSize)
{
remove(propertyId);
addProperty(propertyId, dataSize);
}
}
else
{
addProperty(propertyId, dataSize);
}
memcpy(_currProperty->value, data, dataSize);
}
void tst_QDeclarativeDebug::watch_property()
{
QDeclarativeDebugObjectReference obj = findRootObject();
QDeclarativeDebugPropertyReference prop = findProperty(obj.properties(), "width");
QDeclarativeDebugPropertyWatch *watch;
QDeclarativeEngineDebug *unconnected = new QDeclarativeEngineDebug(0);
watch = unconnected->addWatch(prop, this);
QCOMPARE(watch->state(), QDeclarativeDebugWatch::Dead);
delete watch;
delete unconnected;
watch = m_dbg->addWatch(QDeclarativeDebugPropertyReference(), this);
QVERIFY(QDeclarativeDebugTest::waitForSignal(watch, SIGNAL(stateChanged(QDeclarativeDebugWatch::State))));
QCOMPARE(watch->state(), QDeclarativeDebugWatch::Inactive);
delete watch;
watch = m_dbg->addWatch(prop, this);
QCOMPARE(watch->state(), QDeclarativeDebugWatch::Waiting);
QCOMPARE(watch->objectDebugId(), obj.debugId());
QCOMPARE(watch->name(), prop.name());
QSignalSpy spy(watch, SIGNAL(valueChanged(QByteArray,QVariant)));
int origWidth = m_rootItem->property("width").toInt();
m_rootItem->setProperty("width", origWidth*2);
// stateChanged() is received before valueChanged()
QVERIFY(QDeclarativeDebugTest::waitForSignal(watch, SIGNAL(stateChanged(QDeclarativeDebugWatch::State))));
QCOMPARE(watch->state(), QDeclarativeDebugWatch::Active);
QCOMPARE(spy.count(), 1);
m_dbg->removeWatch(watch);
delete watch;
// restore original value and verify spy doesn't get additional signal since watch has been removed
m_rootItem->setProperty("width", origWidth);
QTest::qWait(100);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).value<QByteArray>(), prop.name().toUtf8());
QCOMPARE(spy.at(0).at(1).value<QVariant>(), qVariantFromValue(origWidth*2));
}
void tst_QQmlEngineDebugService::watch_property()
{
QmlDebugObjectReference obj = findRootObject();
QmlDebugPropertyReference prop = findProperty(obj.properties, "width");
bool success;
QQmlEngineDebugClient *unconnected = new QQmlEngineDebugClient(0);
unconnected->addWatch(prop, &success);
QVERIFY(!success);
delete unconnected;
m_dbg->addWatch(QmlDebugPropertyReference(), &success);
QVERIFY(success);
QVERIFY(QQmlDebugTest::waitForSignal(m_dbg, SIGNAL(result())));
QCOMPARE(m_dbg->valid(), false);
quint32 id = m_dbg->addWatch(prop, &success);
QVERIFY(success);
QVERIFY(QQmlDebugTest::waitForSignal(m_dbg, SIGNAL(result())));
QCOMPARE(m_dbg->valid(), true);
QSignalSpy spy(m_dbg, SIGNAL(valueChanged(QByteArray,QVariant)));
int origWidth = m_rootItem->property("width").toInt();
m_rootItem->setProperty("width", origWidth*2);
QVERIFY(QQmlDebugTest::waitForSignal(m_dbg, SIGNAL(valueChanged(QByteArray,QVariant))));
QCOMPARE(spy.count(), 1);
m_dbg->removeWatch(id, &success);
QVERIFY(success);
QVERIFY(QQmlDebugTest::waitForSignal(m_dbg, SIGNAL(result())));
QCOMPARE(m_dbg->valid(), true);
// restore original value and verify spy doesn't get additional signal since watch has been removed
m_rootItem->setProperty("width", origWidth);
QTest::qWait(100);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).value<QByteArray>(), prop.name.toUtf8());
QCOMPARE(spy.at(0).at(1).value<QVariant>(), qVariantFromValue(origWidth*2));
}
CIMObjectPath CIMInstanceRep::buildPath(
const CIMConstClass& cimClass) const
{
//--------------------------------------------------------------------------
// Get class name:
//--------------------------------------------------------------------------
CIMName className = getClassName();
//--------------------------------------------------------------------------
// Get key names:
//--------------------------------------------------------------------------
Array<CIMName> keyNames;
cimClass.getKeyNames(keyNames);
if (keyNames.size() == 0)
return CIMObjectPath("", CIMNamespaceName(), className);
//--------------------------------------------------------------------------
// Get type and value for each key (building up key bindings):
//--------------------------------------------------------------------------
Array<CIMKeyBinding> keyBindings;
for (Uint32 i = 0, n = keyNames.size(); i < n; i++)
{
const CIMName& keyName = keyNames[i];
Uint32 index = findProperty(keyName);
if (index == PEG_NOT_FOUND)
{
throw NoSuchProperty(keyName.getString());
}
CIMConstProperty tmp = getProperty(index);
keyBindings.append(CIMKeyBinding(keyName, tmp.getValue()));
}
return CIMObjectPath(String(), CIMNamespaceName(), className, keyBindings);
}
static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyName)
{
CSSPropertyInfo propertyInfo = {CSSPropertyInvalid, false};
bool hadPixelOrPosPrefix = false;
StringImpl* propertyNameString = propertyName.publicName();
if (!propertyNameString)
return propertyInfo;
unsigned length = propertyNameString->length();
if (!length)
return propertyInfo;
String stringForCache = String(propertyNameString);
typedef HashMap<String, CSSPropertyInfo> CSSPropertyInfoMap;
static NeverDestroyed<CSSPropertyInfoMap> propertyInfoCache;
propertyInfo = propertyInfoCache.get().get(stringForCache);
if (propertyInfo.propertyID)
return propertyInfo;
const size_t bufferSize = maxCSSPropertyNameLength + 1;
char buffer[bufferSize];
char* bufferPtr = buffer;
const char* name = bufferPtr;
unsigned i = 0;
// Prefixes CSS, Pixel, Pos are ignored.
// Prefixes Apple, KHTML and Webkit are transposed to "-webkit-".
// The prefix "Epub" becomes "-epub-".
switch (getCSSPropertyNamePrefix(*propertyNameString)) {
case PropertyNamePrefixNone:
if (isASCIIUpper((*propertyNameString)[0]))
return propertyInfo;
break;
case PropertyNamePrefixCSS:
i += 3;
break;
case PropertyNamePrefixPixel:
i += 5;
hadPixelOrPosPrefix = true;
break;
case PropertyNamePrefixPos:
i += 3;
hadPixelOrPosPrefix = true;
break;
#if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
case PropertyNamePrefixApple:
case PropertyNamePrefixKHTML:
ASSERT(RuntimeEnabledFeatures::sharedFeatures().legacyCSSVendorPrefixesEnabled());
writeWebKitPrefix(bufferPtr);
i += 5;
break;
#endif
case PropertyNamePrefixEpub:
writeEpubPrefix(bufferPtr);
i += 4;
break;
case PropertyNamePrefixWebKit:
writeWebKitPrefix(bufferPtr);
i += 6;
break;
}
*bufferPtr++ = toASCIILower((*propertyNameString)[i++]);
char* bufferEnd = buffer + bufferSize;
char* stringEnd = bufferEnd - 1;
size_t bufferSizeLeft = stringEnd - bufferPtr;
size_t propertySizeLeft = length - i;
if (propertySizeLeft > bufferSizeLeft)
return propertyInfo;
for (; i < length; ++i) {
UChar c = (*propertyNameString)[i];
if (!c || c >= 0x7F)
return propertyInfo; // illegal character
if (isASCIIUpper(c)) {
size_t bufferSizeLeft = stringEnd - bufferPtr;
size_t propertySizeLeft = length - i + 1;
if (propertySizeLeft > bufferSizeLeft)
return propertyInfo;
*bufferPtr++ = '-';
*bufferPtr++ = toASCIILower(c);
} else
*bufferPtr++ = c;
ASSERT_WITH_SECURITY_IMPLICATION(bufferPtr < bufferEnd);
}
ASSERT_WITH_SECURITY_IMPLICATION(bufferPtr < bufferEnd);
*bufferPtr = '\0';
unsigned outputLength = bufferPtr - buffer;
#if PLATFORM(IOS)
cssPropertyNameIOSAliasing(buffer, name, outputLength);
#endif
const Property* hashTableEntry = findProperty(name, outputLength);
int propertyID = hashTableEntry ? hashTableEntry->id : 0;
if (propertyID) {
propertyInfo.hadPixelOrPosPrefix = hadPixelOrPosPrefix;
propertyInfo.propertyID = static_cast<CSSPropertyID>(propertyID);
propertyInfoCache.get().add(stringForCache, propertyInfo);
}
return propertyInfo;
}
/* CENTRAL METHOD to parse and render html request*/
int handle(cchar* q0,int conn){
int len=(int)strlen(q0);
if(len>1000){
p("checkSanity len>1000");
return 0;// SAFETY!
}
char* q=editable(q0);
checkSanity(q,len);
while(q[0]=='/')q++;
enum result_format format = html;//txt; html DANGER WITH ROBOTS
enum result_verbosity verbosity = normal;
if (eq(q, "favicon.ico"))return 0;
if(contains(q,"robots.txt")){
Writeline(conn,"User-agent: *\n");
Writeline("Disallow: /\n");
return 0;
}
char* jsonp=strstr(q,"jsonp");// ?jsonp=fun
if(jsonp){
jsonp[-1]=0;
jsonp+=6;
format = json;
}
else jsonp=(char*)"parseResults";
if (endsWith(q, ".json")) {
format = json;
q[len-5]=0;
}
if (endsWith(q, ".xml")) {
format = xml;
q[len-4]=0;
}
if (endsWith(q, ".csv")||endsWith(q, ".tsv")) {
format = csv;
q[len-4]=0;
}
if (endsWith(q, ".txt")) {
format = txt;
q[len-4]=0;
}
if (endsWith(q, ".html")) {
format = html;
q[len-5]=0;
}
if (startsWith(q, ".js")) {
q[len-3]=0;
Writeline(conn, jsonp);
Writeline(conn, "(");
format = js;
}
// todo : dedup!!
if (startsWith(q, "all/")) {
cut_to(q," +");
cut_to(q," -");
q = q + 4;
showExcludes=false;
verbosity = alle;
}
if (startsWith(q, "long/")){
verbosity = longer;
q = q + 5;
}
if (startsWith(q, "full/")) {
verbosity = verbose;
q = q + 5;
}
if (startsWith(q, "verbose/")) {
verbosity = verbose;
q = q + 8;
}
if (startsWith(q, "short/")) {
verbosity = shorter;
q = q + 6;
}
if (startsWith(q, "html/")) {
format = html;
if(!contains(q,".")&&!contains(q,":"))
verbosity=verbose;
q = q + 5;
}
if (startsWith(q, "plain/")) {
format = txt;
q = q + 6;
}
if (startsWith(q, "text/")) {
format = txt;
q = q + 5;
}
if (startsWith(q, "txt/")) {
format = txt;
q = q + 4;
}
if (startsWith(q, "xml/")) {
format = xml;
q = q + 4;
}
if (startsWith(q, "csv/")||startsWith(q, "tsv/")) {
format = csv;
q = q + 4;
}
if (startsWith(q, "json/")) {
format = json;
q = q + 5;
}
if (startsWith(q, "js/")) {
q = q + 3;
Writeline(conn, jsonp);
Writeline(conn, "(");
format = js;
}
if (startsWith(q, "long/")) {
verbosity = longer;
q = q + 5;
}
if (startsWith(q, "verbose/")) {
verbosity = verbose;
q = q + 8;
}
if (startsWith(q, "short/")) {
verbosity = shorter;
q = q + 6;
}
if (startsWith(q, "excludes/")||startsWith(q, "includes/")||startsWith(q, "excluded/")||startsWith(q, "included/")||startsWith(q, "showview/")) {
showExcludes=true;
verbosity=longer;
q = q + 9;
}
else showExcludes=false;
excluded.clear();
included.clear();
if(contains(q,"statement count")){Writeline(conn,itoa((int)context->statementCount).data());return 0;}
if(contains(q,"node count")){Writeline(conn,itoa(context->nodeCount).data());return 0;}
if (startsWith(q, "all/")) {
cut_to(q," +");
cut_to(q," -");
q = q + 4;
showExcludes=false;
verbosity = alle;
}
// bool get_topic=false;
bool get_topic=true;
bool sort=false;
if (startsWith(q, "ee/")||startsWith(q, "ee ")) {
q[2]=' ';
get_topic=true;
}
if (startsWith(q, "entities/")) {
q[8]=' ';
get_topic=true;
// verbosity=longer;
}
if(hasWord(q)) loadView(q);
if(contains(q,"exclude")||contains(q,"include")){
verbosity=normal;
showExcludes=true;
}
p(q);
// !!!!!!!!!!!!!!!!!!!!!!!!!!!
//
NodeVector all = parse(q); // <<<<<<<< HANDLE QUERY WITH NETBASE!
//
// !!!!!!!!!!!!!!!!!!!!!!!!!!!
autoIds=false;
int size=(int)all.size();
if(showExcludes){
for (int i = 0; i < size; i++) {
// todo : own routine!!!
Node* node = (Node*) all[i];
if(!contains(all,getAbstract(node->name)))
all.push_back(getAbstract(node->name));
N parent= getType(node);
if(parent){
if(!contains(all,parent))all.push_back(parent);
N abs= getAbstract(parent->name);
if(parent&&!contains(all,abs))all.push_back(abs);
}
}
show(excluded);
}
const char* html_block="<!DOCTYPE html><html><head><META HTTP-EQUIV='CONTENT-TYPE' CONTENT='text/html; charset=UTF-8'/></head>"\
"<body><div id='netbase_results'></div>\n<script>var results=";
// if((int)all.size()==0)Writeline("0");
// Writeline(conn,q);
char buff[10000];
bool use_json= format == json || format == js || format == html;
if (format == xml && (startsWith(q,"select")||contains(q," where "))){Writeline(conn,query2(q));return 0;}
if (format == xml)Writeline(conn, "<results>\n");
if (format == html)Writeline(conn,html_block);
if (use_json)Writeline(conn, "{\"results\":[\n");
const char* statement_format_xml = " <statement id='%d' subject=\"%s\" predicate=\"%s\" object=\"%s\" sid='%d' pid='%d' oid='%d'/>\n";
const char* statement_format_text = " $%d %s %s %s %d->%d->%d\n";
const char* statement_format_json = " { \"id\":%d, \"subject\":\"%s\", \"predicate\":\"%s\", \"object\":\"%s\", \"sid\":%d, \"pid\":%d, \"oid\":%d}";
const char* statement_format_csv = "%d\t%s\t%s\t%s\t%d\t%d\t%d\n";
const char* statement_format = 0;
if (format == xml)statement_format = statement_format_xml;
if (format == html)statement_format = statement_format_json;
if (format == json)statement_format = statement_format_json;
if (format == txt)statement_format = statement_format_text;
if (format == csv)statement_format = statement_format_csv;
const char* entity_format = 0;
const char* entity_format_txt = "%s #%d (statements:%d) %s\n";
const char* entity_format_xml = "<entity name=\"%s\" id='%d' statementCount='%d' description='%s'>\n";
const char* entity_format_json = " {\"name\":\"%s\", \"id\":%d, \"statementCount\":%d, \"description\":\"%s\"";
const char* entity_format_csv = "%s\t%d\t%d\t%s\n";
if(all.size()==1)entity_format_csv = "";//statements!
if (format == xml)entity_format = entity_format_xml;
if (format == txt)entity_format = entity_format_txt;
if (format == csv)entity_format = entity_format_csv;
if (use_json) entity_format = entity_format_json;
Node* last=0;
warnings=0;
char* entity=0;
if(startsWith(q,"all")){
entity=(char*)cut_to(q," ");
entity=keep_to(entity,"limit");
}
sortNodes(all);
int count=(int)all.size();
int good=0;
for (int i = 0; i < count && i<resultLimit; i++) {
Node* node = (Node*) all[i];
if(!checkNode(node))continue;
if(node->id==0)continue;
if(last==node)continue;
if(eq(node->name,"◊"))continue;
last=node;
if(verbosity ==normal && entity&& eq(entity,node->name))continue;
char* text=getText(node);
// if(use_json && get_topic){
// if(empty(text))continue;//! no description = no entity? BAD for amazon etc
// if(isAbstract(node))continue;
// N t=getTopic(node);
// }
good++;
if (use_json)if(good>1)Writeline(conn, "},\n");
sprintf(buff, entity_format, node->name, node->id,node->statementCount,text);
Writeline(conn, buff);
// if(verbosity != alle && !get_topic)
// loadView(node);
bool got_topic=false;
if(use_json && get_topic){
N c=getClass(node);
N t=getTopic(node);
N ty=getType(node);
// if(!c)c=t;
if(!t)t=ty;
if(t==node)t=ty;
if(t!=Entity && checkNode(t)){
got_topic=true;
Writeline(conn, ",\n\t \"topicid\":"+itoa(t->id));
Writeline(conn, ", \"topic\":\""+string(t->name)+"\"");
}
if(c && c!=t){
Writeline(conn, ",\n\t \"classid\":"+itoa(c->id));
Writeline(conn, ", \"class\":\""+string(c->name)+"\"");
}
if(ty&& c!=ty && ty!=t){
Writeline(conn, ",\n\t \"typeid\":"+itoa(ty->id));
Writeline(conn, ", \"type\":\""+string(ty->name)+"\"");
}
}
if(use_json)// && (verbosity==verbose||verbosity==shorter))// lol // just name
Writeline(conn, ", \"kind\":"+itoa(node->kind));
if((use_json)&&!showExcludes&&node->statementCount>1 && getImage(node)!="")
Writeline(", \"image\":\""+replace_all(replace_all(getImage(node,150,/*thumb*/true),"'","%27"),"\"","%22")+"\"");
// if((use_json)&&getText(node)[0]!=0)
// Writeline(", \"description\":\""+string(getText(node))+"\"");
Statement* s = 0;
if (format==csv|| verbosity == verbose || verbosity == longer|| verbosity == alle || showExcludes || ( all.size() == 1 && !(verbosity == shorter))) {
int count=0;
// Writeline(",image:\""+getImage(node->name)+"\"");
if (use_json)Writeline(conn, ",\n\t \"statements\":[\n");
// sortStatements(
deque<Statement*> statements;// sort
while ((s = nextStatement(node, s))&&count++<lookupLimit){// resultLimit
if (!checkStatement(s))break;
// if(!got_topic &&( s->predicate==_Type|| s->predicate==_SuperClass)){
// addStatementToNode(node, s->id(), true);// next time
// }
if(get_topic &&!got_topic && verbosity != verbose && (s->predicate>100 || s->predicate<-100))
continue;// only important stuff here!
// filter statements
if(s->object==0)continue;
// if(eq(s->Predicate()->name,"Offizielle Website") && !contains(s->Object()->name,"www"))
// continue;
if (s->subject==node->id and s->predicate!=4)//_instance
statements.push_front(s);
else statements.push_back(s);
}
// if(get_topic && verbosity!=shorter){
// NV topics=getTopics(node);
// N s=topics[0];
// for (int j = 0; j < topics.size() && j<=resultLimit; j++) {
// N s=topics[j];
// Temporary statement (node,topic,s)
// statements.push_front(s);
// }
// }
int good=0;
for (int j = 0; j < statements.size() && j<=resultLimit; j++) {
s=statements.at(j);
// while ((s = nextStatement(node, s))&&count++<resultLimit) {
if(format==csv&&all.size()>1)break;// entities vs statements
p(s);
if(verbosity!=alle&&checkHideStatement(s)){warnings++;continue;}
fixLabels(s);
if(!(verbosity==verbose||verbosity==alle) && (s->Predicate()==Instance||s->Predicate()==Type))continue;
if(use_json && good>0)Writeline(conn, ",\n");
char* objectName=s->Object()->name;
if(s->Predicate()==Instance){
N type=findProperty(s->Object(),Type->name,0,50);
if( checkNode(type))
objectName=(char*)(concat(concat(objectName, ": "),type->name));
}
sprintf(buff, statement_format, s->id(), s->Subject()->name, s->Predicate()->name, objectName, s->Subject()->id, s->Predicate()->id, s->Object()->id);
Writeline(conn, buff);
good++;
}
if (use_json)Writeline(conn, "]");
}
if (format == xml)Writeline(conn, "</entity>\n");
// string img=getImage(node->name);
// if(img!="")Writeline(conn,"<img src=\""+img+"\"/>");
}
if (use_json || format == html || format == js)Writeline(conn,good>0?"}\n]}":"]}");
if (format == xml)Writeline(conn, "</results>\n");
if(format == js)Writeline(conn, ")");// jsonp
const char* html_end=";\n</script>\n<script src='http://pannous.net/netbase.js'></script></body></html>\n";
if(format == html)Writeline(conn, html_end);
// sprintf(buff, "<script src='/js/%s'></script>",q0);
// Writeline(conn, buff);
// }
pf("Warnings/excluded: %d\n",warnings);
return 0;// 0K
}
const AbstractProperty * PropertyGroup::property(const std::string & path) const
{
std::vector<std::string> splittedPath = util::split(path, s_separator);
return findProperty(splittedPath);
}
QScriptObjectSnapshot::Delta QScriptObjectSnapshot::capture(const QScriptValue &object)
{
Delta result;
QMap<QString, QScriptValueProperty> currProps;
QHash<QString, int> propertyNameToIndex;
{
int i = 0;
QScriptValueIterator it(object);
while (it.hasNext()) {
it.next();
QScriptValueProperty prop(it.name(), it.value(), it.flags());
currProps.insert(it.name(), prop);
propertyNameToIndex.insert(it.name(), i);
++i;
}
if (object.prototype().isValid()) {
QString __proto__ = QString::fromLatin1("__proto__");
QScriptValueProperty protoProp(
__proto__, object.prototype(),
QScriptValue::Undeletable | QScriptValue::ReadOnly);
currProps.insert(__proto__, protoProp);
propertyNameToIndex.insert(__proto__, i);
++i;
}
}
QSet<QString> prevSet;
for (int i = 0; i < m_properties.size(); ++i)
prevSet.insert(m_properties.at(i).name());
QSet<QString> currSet = currProps.keys().toSet();
QSet<QString> removedProperties = prevSet - currSet;
QSet<QString> addedProperties = currSet - prevSet;
QSet<QString> maybeChangedProperties = currSet & prevSet;
{
QMap<int, QScriptValueProperty> am;
QSet<QString>::const_iterator it;
for (it = addedProperties.constBegin(); it != addedProperties.constEnd(); ++it) {
int idx = propertyNameToIndex[*it];
am[idx] = currProps[*it];
}
result.addedProperties = am.values();
}
{
QSet<QString>::const_iterator it;
for (it = maybeChangedProperties.constBegin(); it != maybeChangedProperties.constEnd(); ++it) {
const QScriptValueProperty &p1 = currProps[*it];
const QScriptValueProperty &p2 = findProperty(*it);
if (!_q_equal(p1.value(), p2.value())
|| (p1.flags() != p2.flags())) {
result.changedProperties.append(p1);
}
}
}
result.removedProperties = removedProperties.toList();
m_properties = currProps.values();
return result;
}
//------------------------------------------------------------------------------
void ClassDefinition::bindPropertyImpl(
const char * name,
const ObjectHandle & pBase,
PropertyAccessor & o_PropertyAccessor ) const
{
if (!*name)
{
// empty name causes noop
return;
}
// find property operator
auto propOperator = name;
while (true)
{
if( !*propOperator ||
*propOperator == INDEX_OPEN ||
*propOperator == DOT_OPERATOR )
{
break;
}
propOperator += 1;
}
auto propName = name;
auto propLength = propOperator - propName;
auto baseProp = findProperty( propName, propLength );
if (baseProp == nullptr)
{
// error: property `propName` is not found
o_PropertyAccessor.setBaseProperty( nullptr );
return;
}
o_PropertyAccessor.setObject( pBase );
o_PropertyAccessor.setBaseProperty( baseProp );
assert( strncmp( propName, o_PropertyAccessor.getName(), propLength ) == 0 );
if (!*propOperator)
{
// no operator, so that's it
return;
}
Variant propVal = o_PropertyAccessor.getValue();
if (*propOperator == INDEX_OPEN)
{
auto wholeIndex = propOperator;
// read "multidimensional" indices without recursive bind (optimization)
while (true)
{
Collection collection;
if (!propVal.tryCast( collection ))
{
// error: index operator is applicable to collections only
o_PropertyAccessor.setBaseProperty( nullptr );
return;
}
// determine key type (heterogeneous keys are not supported yet)
const auto begin = collection.begin();
const auto end = collection.end();
if (begin == end)
{
// error: can't index empty collection
o_PropertyAccessor.setBaseProperty( nullptr );
return;
}
// read key
Variant key( begin.key().type() );
{
propOperator += 1; // skip INDEX_OPEN
FixedMemoryStream dataStream( propOperator );
TextStream stream( dataStream );
stream >> key >> match( INDEX_CLOSE );
if (stream.fail())
{
// error: either key can't be read, or it isn't followed by INDEX_CLOSE
o_PropertyAccessor.setBaseProperty( nullptr );
return;
}
// skip key and closing bracket
propOperator += stream.seek( 0, std::ios_base::cur );
}
auto it = collection.find( key );
// If (it == end), still return a valid property accessor to end,
// rather than an invalid property accessor.
if (!*propOperator || (it == end))
{
// name parsing is completed
auto baseProp = std::make_shared< CollectionElementHolder >(
collection,
it,
collection.valueType(),
wholeIndex );
// o_PropertyAccessor.setObject(); - keep current base
o_PropertyAccessor.setBaseProperty( baseProp );
return;
}
propVal = it.value();
if (*propOperator == INDEX_OPEN)
{
continue;
}
// parse next operator
break;
}
}
