QVariant MapBrowserWidget::value()
{
if (dataSource().isEmpty()){
return serializeData(0.0, 0.0, 1100);
}
return serializeData(centerLatitude(), centerLongitude(), zoom());
}
void ActionDialog::createAction()
{
const QString cmd = ui->plainTextEditCommand->toPlainText();
if ( cmd.isEmpty() )
return;
const QString format = ui->comboBoxInputFormat->currentText();
const QString input = ( format.isEmpty() || format.toLower().startsWith(QString("text")) )
? ui->inputText->toPlainText() : QString();
QByteArray bytes;
QStringList inputFormats;
if ( !format.isEmpty() ) {
if ( m_index.isValid() )
inputFormats.append(format);
if ( !input.isEmpty() ) {
bytes = input.toLocal8Bit();
} else if ( !m_data.isEmpty() ) {
if (format == mimeItems) {
QVariantMap data2;
inputFormats.clear();
foreach ( const QString &format, m_data.keys() ) {
if ( !format.startsWith(MIME_PREFIX) ) {
data2.insert( format, m_data[format] );
if ( m_index.isValid() )
inputFormats.append(format);
}
}
bytes = serializeData(data2);
} else {
bytes = m_data.value(format).toByteArray();
}
}
QByteArray serializeData(const QVariantMap &data)
{
QByteArray bytes;
QDataStream out(&bytes, QIODevice::WriteOnly);
serializeData(&out, data);
return bytes;
}
void TcpServer::incomingConnection(qintptr socketDescriptor)
{
LocalSocket * tcpTemp = new LocalSocket(socketDescriptor,this);
QString thisHost;
qint16 thisPort;
if (isSerCon) {
if (!initLocalProxy(thisHost,thisPort,tcpTemp)) return;
data.operater = 1;
data.socketID = socketDescriptor;
data.userID = this->userID;
newHost = qMakePair(thisHost,thisPort);
if (!serializeData(bytearry,newHost)) return ;
data.data = encryptData(aes,bytearry);
if (sentServerData()) {
connect(tcpTemp,&LocalSocket::readyRead,this,&TcpServer::LocalSocketRead);
connect(tcpTemp,&LocalSocket::disconnected,this,&TcpServer::localSockedDisCon);
tcpClient->insert(socketDescriptor,tcpTemp);
localDataRead(tcpTemp);
} else {
tcpTemp->disconnectFromHost();
tcpTemp->deleteLater();
}
} else {
tcpTemp->close();
tcpTemp->deleteLater();
serverSocket->connectToHost(ConfigClass::getClass().serverUrl,ConfigClass::getClass().serverPort);
if (serverSocket->waitForConnected(5000)) {
isSerCon = true;
}
return;
}
}
QDataStream & TaoControlEvent::serialize(QDataStream &out)
// ----------------------------------------------------------------------------
// Serialize delay and event type, then data using the virtual method
// ----------------------------------------------------------------------------
{
out << delay;
out << getType();
return serializeData(out);
}
inline bool ClientSocket::sentClientData()
{
if (!serializeData(bytearry,data)) return false;
qulonglong size = bytearry.size();
basize = QByteArray::number(size,16);
while(basize.size() < 6)
basize.insert(0,'0');
this->write(basize + bytearry);
return true;
}
void Action::setInputWithFormat(const QVariantMap &data, const QString &inputFormat)
{
if (inputFormat == mimeItems) {
m_input = serializeData(data);
m_inputFormats = data.keys();
} else {
m_input = data.value(inputFormat).toByteArray();
m_inputFormats = QStringList(inputFormat);
}
}
bool serializeData(const QAbstractItemModel &model, QDataStream *stream)
{
qint32 length = model.rowCount();
*stream << length;
for(qint32 i = 0; i < length && stream->status() == QDataStream::Ok; ++i)
serializeData( stream, model.data(model.index(i, 0), contentType::data).toMap() );
return stream->status() == QDataStream::Ok;
}
/**
* Serializes this event's data.
*/
char* Event::serialize(short& outLength) {
int i;
short myLength = (_name.length() + _description.length() + 2) + 17;
short subclassLength = 0;
char* subclassData = serializeData(subclassLength);
outLength = myLength + subclassLength;
int tempInt;
float tempFloat;
char* ret = new char[myLength + subclassLength];
char* bufferPtr = ret;
// Name
memcpy(bufferPtr, _name.c_str(), _name.length() + 1);
bufferPtr += _name.length() + 1;
// Description
memcpy(bufferPtr, _description.c_str(), _description.length() + 1);
bufferPtr += _description.length() + 1;
// Type
*bufferPtr = _type;
bufferPtr++;
// ID
tempInt = _id;
if (EndianConverter::isLittleEndian()) {
tempInt = EndianConverter::swapIntEndian(tempInt);
}
memcpy(bufferPtr, &tempInt, 4);
bufferPtr += 4;
// Location
for (i = 0; i < 3; i++) {
tempFloat = _location[i];
if (EndianConverter::isLittleEndian()) {
tempFloat = EndianConverter::swapFloatEndian(tempFloat);
}
memcpy(bufferPtr, &tempFloat, 4);
bufferPtr += 4;
}
// Subclass data
memcpy(bufferPtr, subclassData, subclassLength);
return ret;
};
void TcpServer::socketConnect()
{
serverSocket->connectToHost(ConfigClass::getClass().serverUrl,ConfigClass::getClass().serverPort);
if (serverSocket->waitForConnected(5000)) {
isSerCon = true;
data.operater = 3;
QPair<QString,QString> host(ConfigClass::getClass().user,ConfigClass::getClass().password);
if (!serializeData(bytearry,host)) return;
data.data = bytearry;
sentServerData();
} else {
isSerCon = false;
emit notToServer();
}
}
void RKRBackendSerializer::serializeData (const RData &data, QDataStream &stream) {
RK_TRACE (RBACKEND);
RData::RDataType type = data.getDataType ();
stream << (qint8) type;
if (type == RData::IntVector) stream << data.getIntVector ();
else if (type == RData::StringVector) stream << data.getStringVector ();
else if (type == RData::RealVector) stream << data.getRealVector ();
else if (type == RData::StructureVector) {
RData::RDataStorage list = data.getStructureVector ();
qint32 len = list.size ();
stream << len;
for (qint32 i = 0; i < list.size (); ++i) {
serializeData (*(list[i]), stream);
}
} else {
RK_ASSERT (type == RData::NoData);
}
}
long SerializeStreamImpl::findLabelInFile(const char * label) {
assert(_fpLoad==NULL);
assert(_fpSave!=NULL);
long curPos;
long nextPos = _lastNextEntry;
while (true) {
fseek(_fpLoad, nextPos, SEEK_SET);
curPos = nextPos;
fread(&nextPos, sizeof(nextPos), 1, _fpLoad);
if (curPos==nextPos) {
// we didn't find it
throw ccor::Exception("core : label '%s' not found in a loading stream", label);
}
// load label string
fseek(_fpLoad, nextPos, SEEK_SET);
int n = getNumElements();
std::string strLabel;
strLabel.resize(n-1);
serializeData((void*)strLabel.c_str(), 'L', sizeof(char), n);
nextPos = ftell(_fpLoad);
// compare it to what we want to find
if (strLabel==label) {
long _v;
fread(&_v, sizeof(_v), 1, _fpLoad);
// store label for future use
long pos = ftell(_fpLoad);
_labelMap.insert(LabelMap::value_type(label,pos));
_lastNextEntry = nextPos;
return pos;
}
}
return 0;
}
void SerializeStreamImpl::setLabel(const char * label) {
if (label==NULL)
label = "";
if (_fpLoad) {
LabelMap::const_iterator it = _labelMap.find(label);
if (it==_labelMap.end()) {//throw ccor::Exception("core : label '%s' not found in a loading stream", label);
findLabelInFile(label);
}
else {
long pos = it->second;
fseek(_fpLoad, pos, SEEK_SET);
}
}
if (_fpSave) {
LabelMap::const_iterator it = _labelMap.find(label);
if (it!=_labelMap.end()) throw ccor::Exception("core : label '%s' already exists in a saving stream", label);
fseek(_fpSave, 0, SEEK_END);
long pos = ftell(_fpSave);
// save label's begin pos
fseek(_fpSave, _lastNextEntry, SEEK_SET);
fwrite(&pos, sizeof(pos), 1, _fpSave);
// save label info
fseek(_fpSave, pos, SEEK_SET);
serializeData((void*)label, 'L', sizeof(char), strlen(label)+1);
// reserve place for next label pointer
_lastNextEntry = ftell(_fpSave);
fwrite(&_lastNextEntry, sizeof(_lastNextEntry), 1, _fpSave);
// store pos
pos = ftell(_fpSave);
_labelMap.insert(LabelMap::value_type(label,pos));
}
}
bool serializeData(const QAbstractItemModel &model, QFile *file)
{
QDataStream stream(file);
stream.setVersion(QDataStream::Qt_4_7);
return serializeData(model, &stream);
}
void ClipboardMonitor::clipboardChanged(const QVariantMap &data)
{
sendMessage( serializeData(data), MonitorClipboardChanged );
}
