DataItem AxisIterator::GetItem()
{
if (m_axis == AxisStep::K_ATTRIBUTE)
return DataItem(m_contextParentItem, (m_contextPos<<1) | 1);
else
return DataItem(m_contextParentItem, (m_contextPos<<1));
}
DataItem CacheSystem::get(const String& key)
{
OS_LOCK(m_cs);
if(check(key) == false)
return DataItem();
shared_ptr<Item> item = m_items[key];
if(item != nullptr)
return item->item;
else
{
OS_ASSERT(false);
return DataItem();
}
}
void dataItemFromScriptValue(const QScriptValue &obj, DataItem &dataItem)
{
if (obj.isObject()) {
if (DataItem *item = get_data_item(obj)) {
dataItem = *item;
return;
}
dataItem = DataItem();
QScriptValueIterator it(obj);
while (it.hasNext()) {
it.next();
dataItem.setProperty(it.name().toUtf8(), it.value().toVariant());
}
} else {
dataItem = DataItem(obj.toVariant().value<LocalizedString>());
}
}
void QuickContactInfo::show(QObject *object)
{
InfoRequestFactory *factory = InfoRequestFactory::factory(object);
SupportLevel type = factory ? factory->supportLevel(object) : InfoRequestFactory::Unavailable;
if (type <= InfoRequestFactory::Unavailable)
object = 0;
if (m_object != object) {
m_object = object;
emit objectChanged(object);
}
if (!object) {
m_item = DataItem("No data");
emit itemChanged(m_item);
delete m_request;
m_request = 0;
return;
}
bool readWrite = (type == InfoRequestFactory::ReadWrite);
if (m_readWrite != readWrite) {
m_readWrite = readWrite;
emit readOnlyChanged(!readWrite);
}
delete m_request;
m_request = InfoRequestFactory::dataFormRequest(object);
if (m_request) {
connect(m_request, SIGNAL(stateChanged(qutim_sdk_0_3::InfoRequest::State)),
SLOT(onRequestStateChanged(qutim_sdk_0_3::InfoRequest::State)));
m_request->requestData();
}
QString title;
QString avatar;
if (Buddy *buddy = qobject_cast<Buddy*>(m_object)) {
title = QApplication::translate("ContactInfo", "About contact %1 <%2>")
.arg(buddy->name())
.arg(buddy->id());
} else {
if (Account *account = qobject_cast<Account*>(m_object)) {
title = QApplication::translate("ContactInfo", "About account %1")
.arg(account->name());
} else {
title = QApplication::translate("ContactInfo", "About %1 <%2>")
.arg(m_object->property("name").toString())
.arg(m_object->property("id").toString());
}
}
if (m_request)
onRequestStateChanged(m_request->state());
emit showRequest();
}
bool BigDataWriter::writeDataItems(ItemGroup* itemGroup) {
if (pFile != NULL) {
DataItem& item = DataItem();
int size = itemGroup->getItemVector().size();
for (int i = 0; i < size; i++) {
item = (*itemGroup)[i];
if (errorInd == item.isError()) {
fputs(item.getLine().c_str(), pFile);
if (item.isError()) {
fputs(",ERROR:", pFile);
fputs(DataItem::errorTypesArray[item.getErrorType()].c_str(), pFile);
}
fputc('\n', pFile);
}
}
}
return true;
}
/**
* unpack does exactly the opposite from pack, it will take a data buffer
* and load this object with the contents. If we need more data than the
* size claims that we have, then we have a corrupt buffer and we will
* throw an exception.
*/
void System::unpack( const void* payload )
{
u32 size = 0, netOrder;
char* packed = (char*) payload;
char* next = packed;;
string item;
if( payload == NULL )
{
// Rather than throwing an exception, this will just return, if NULL is handed in
// this far there is nothing that we can do to stop program instability other
// than refuse to mess with it.
return;
}
// Load the size of the payload. (It is packed in network order)
memcpy( &netOrder, next, sizeof( u32 ) );
size = ntohl( netOrder );
next += sizeof( u32 );
memcpy( &netOrder, next, sizeof( u32 ) );
mCPUCount = ntohl( netOrder );
next += sizeof( u32 );
mChildren = vector<string>( );
mDeviceSpecific = vector<DataItem*>( );
mIdNode = DataItem( next );
next += mIdNode.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mArch = DataItem( next );
next += mArch.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
deviceTreeNode = DataItem( next );
next += deviceTreeNode.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mDescription = DataItem( next );
next += mDescription.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mBrand = DataItem( next );
next += mBrand.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mNodeName = DataItem( next );
next += mNodeName.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mOS = DataItem( next );
next += mOS.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mProcessorID = DataItem( next );
next += mProcessorID.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mMachineType = DataItem( next );
next += mMachineType.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mMachineModel = DataItem( next );
next += mMachineModel.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mFeatureCode = DataItem( next );
next += mFeatureCode.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mFlagField = DataItem( next );
next += mFlagField.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mRecordType = DataItem( next );
next += mRecordType.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mSerialNum1 = DataItem( next );
next += mSerialNum1.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mSerialNum2 = DataItem( next );
next += mSerialNum2.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mSUID = DataItem( next );
next += mSUID.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mKeywordVersion = DataItem( next );
next += mKeywordVersion.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
mLocationCode = DataItem( next );
next += mLocationCode.getPackedLength( );
if( next > packed + size )
{
goto lderror;
}
// Now onto the vectors, these should go much the same way that the packing
// did.
if( next == CHILD_START )
{
next += CHILD_START.length( ) + 1;
if( next > packed + size )
{
goto lderror;
}
item = string( (char*)next );
while( CHILD_END != item )
{
if( item != string( "" ) )
{
string child = string( (char*)next );
mChildren.push_back( child );
next += item.length( );
}
next++;
item = string( (char*)next );
}
next += CHILD_END.length( ) + 1;
}
if( DEVICE_START == next )
{
next += DEVICE_START.length( ) + 1;
if( next > packed + size )
{
goto lderror;
}
item = string( (char*) next );
while( DEVICE_END != item )
{
DataItem* d = new DataItem( next );
if ( d == NULL ) {
VpdException ve( "Out of memory." );
throw ve;
}
next += d->getPackedLength( );
if( next > packed + size )
{
delete ( d );
goto lderror;
}
mDeviceSpecific.push_back( d );
item = string( (char*)next );
}
next += DEVICE_END.length( ) + 1;
}
if( USER_START == next )
{
next += USER_START.length( ) + 1;
if( next > packed + size )
{
goto lderror;
}
item = string( (char*) next );
while( USER_END != item )
{
DataItem* d = new DataItem( next );
if ( d == NULL ) {
VpdException ve( "Out of memory." );
throw ve;
}
next += d->getPackedLength( );
if( next > packed + size )
{
delete ( d );
goto lderror;
}
mDeviceSpecific.push_back( d );
item = string( (char*)next );
}
}
return;
lderror:
string message( "Component.unpack( ): Attempting to unpack corrupt buffer." );
Logger l;
l.log( message, LOG_ERR );
VpdException ve( message );
throw ve;
}
main(int argc, char **argv)
{
cout << "List l1;" << endl;
List l1;
cout << l1 << endl;
cout << "insert(l1, DataItem);" << endl;
for (int il = 0; il < atoi(argv[1]); il++)
{
DataItem *d = new DataItem(2*il);
assert(d != 0);
assert(insert(l1, d, STARTOFLIST) == OK);
}
cout << l1 << endl;
cout << "List l2;" << endl;
List l2;
cout << l2 << endl;
cout << "insert(l1, DataItem);" << endl;
for (il = 0; il < atoi(argv[1]); il++)
{
DataItem *d = new DataItem(2*il);
assert(d != 0);
assert(insert(l2, d, ENDOFLIST) == OK);
}
cout << l2 << endl;
cout << "locate(l1, DataItem(10), lp);" << endl;
ListPosition lp;
if (locate(l1, &DataItem(10), lp) == OK)
cout << *lp << endl;
else
cout << "DataItem(10) not found." << endl;
cout << "retrieve(l1, d, lp);" << endl;
DataItem *d;
if (retrieve(l1, d, lp) == OK)
{
cout << *d << endl;
}
else
cout << "DataItem(10) not found." << endl;
cout << "ListIterator li(l1);" << endl;
ListIterator li(l1);
while ((d = li()) != (DataItem *)0)
{
cout << *d << endl;
}
cout << "li = l2);" << endl;
li = l2;
while ((d = li()) != (DataItem *)0)
{
cout << *d << endl;
}
cout << "retrieveAndRemove(l1, d, STARTOFLIST);" << endl;
while (retrieveAndRemove(l1, d, STARTOFLIST) == OK)
{
cout << "removed ..." << *d << endl;
cout << "list remaining = " << l1 << endl;
}
cout << "retrieveAndRemove(l2, d, ENDOFLIST);" << endl;
while (retrieveAndRemove(l2, d, ENDOFLIST) == OK)
{
cout << "removed ..." << *d << endl;
cout << "list remaining = " << l2 << endl;
}
// all done
return(0);
}
QuetzalFieldsDialog::QuetzalFieldsDialog(const char *title, const char *primary,
const char *secondary, PurpleRequestFields *fields,
const char *ok_text, GCallback ok_cb,
const char *cancel_text, GCallback cancel_cb,
void *user_data, QWidget *parent)
: QuetzalRequestDialog(PURPLE_REQUEST_FIELDS, user_data, parent)
{
m_ok_cb = (PurpleRequestFieldsCb) ok_cb;
m_cancel_cb = (PurpleRequestFieldsCb) cancel_cb;
m_fields = fields;
DataItem root = createItem(title, primary, secondary);
GList *group_it = purple_request_fields_get_groups(m_fields);
bool useGroupBox = group_it->next;
debug() << "useGroupBox" << useGroupBox;
for (; group_it; group_it = group_it->next) {
PurpleRequestFieldGroup *group = reinterpret_cast<PurpleRequestFieldGroup*>(group_it->data);
DataItem groupItem;
if (useGroupBox)
groupItem = DataItem(purple_request_field_group_get_title(group));
GList *field_it = purple_request_field_group_get_fields(group);
for (; field_it; field_it = field_it->next) {
PurpleRequestField *field = reinterpret_cast<PurpleRequestField*>(field_it->data);
debug() << field->id << purple_request_field_is_visible(field)
<< purple_request_field_get_type(field);
if (!purple_request_field_is_visible(field))
continue;
DataItem item(purple_request_field_get_id(field),
purple_request_field_get_label(field),
QVariant());
switch (purple_request_field_get_type(field)) {
case PURPLE_REQUEST_FIELD_STRING:
item.setData(QString::fromUtf8(purple_request_field_string_get_default_value(field)));
item.setProperty("multiline", purple_request_field_string_is_multiline(field));
item.setProperty("password", bool(purple_request_field_string_is_masked(field)));
item.setReadOnly(!purple_request_field_string_is_editable(field));
debug() << item.name() << item.data() << item.property("password") << item.isReadOnly();
break;
case PURPLE_REQUEST_FIELD_INTEGER:
item.setData(purple_request_field_int_get_default_value(field));
item.setProperty("minValue", G_MININT);
item.setProperty("maxValue", G_MAXINT);
break;
case PURPLE_REQUEST_FIELD_BOOLEAN:
item.setData(bool(purple_request_field_bool_get_default_value(field)));
break;
case PURPLE_REQUEST_FIELD_CHOICE:
{
GList *labels = purple_request_field_choice_get_labels(field);
QStringList alternatives;
for (; labels; labels = labels->next)
alternatives << QString::fromUtf8(reinterpret_cast<char*>(labels->data));
item.setData(alternatives.value(purple_request_field_choice_get_default_value(field)));
item.setProperty("alternatives", alternatives);
}
break;
case PURPLE_REQUEST_FIELD_LIST:
break;
case PURPLE_REQUEST_FIELD_LABEL:
item.setData(purple_request_field_get_label(field));
item.setReadOnly(true);
item.setProperty("hideTitle", true);
break;
case PURPLE_REQUEST_FIELD_IMAGE:
{
QImageReader reader;
QByteArray data = QByteArray::fromRawData(purple_request_field_image_get_buffer(field),
purple_request_field_image_get_size(field));
QBuffer buffer(&data);
reader.setDevice(&buffer);
QSize imageSize = reader.size();
if (imageSize.isValid()) {
imageSize.setWidth(imageSize.width() * purple_request_field_image_get_scale_x(field));
imageSize.setHeight(imageSize.height() * purple_request_field_image_get_scale_y(field));
reader.setScaledSize(imageSize);
}
item.setData(qVariantFromValue(reader.read()));
item.setProperty("imageSize", qVariantFromValue(imageSize));
item.setReadOnly(true);
}
break;
case PURPLE_REQUEST_FIELD_ACCOUNT:
break;
case PURPLE_REQUEST_FIELD_NONE:
default:
continue;
}
item.setProperty("mandatory", purple_request_field_is_required(field));
if (useGroupBox)
groupItem.addSubitem(item);
else
root.addSubitem(item);
}
if (useGroupBox)
root.addSubitem(groupItem);
}
createItem(root, ok_text, cancel_text);
return;
}
