[Merged] copying data from structure to a ByteArray and vise versa

phamtv

Can someone provide me and example on how to get this to work?

phamtv

How can I access ByteArray´s underlying data buffer so I can use memmove to copy data from a structure to a ByteArray data type? Please provide example. Thanks!

phamtv

Sorry this post is under the wrong thread...

kkrzewniak

Have You tried QDataStream with a QBuffer.
@
struct YourStruct
{
quint8 x;
quint16 y;
float z;

YourStruct()
    :x(0),y(0),z(0.0f)
{}

YourStruct(const YourStruct& other)
    :x(other.x),y(other.y),z(other.z)
{}

bool operator == (const WeaponStats& other) const
{
    ...
}

bool operator < (const WeaponStats& other) const
{
   ...
}

bool operator > (const WeaponStats& other) const
{
   ...
}

};

inline QDataStream& operator<<(QDataStream& out, const YourStruct& str)
{
out << str.x;
out << str.y;
out << str.z;
return out;
}

inline QDataStream& operator>>(QDataStream& in, YourStruct& str)
{
in >> str.x;
in >> str.y;
in >> str.z;
return in;
}

Q_DECLARE_METATYPE(YourStruct)

//before using call
qRegisterMetaTypeStreamOperators<YourStructs>("YourStruct");
@

or just have a look "here":http://www.qtcentre.org/wiki/index.php?title=Using_custom_data_types_with_Qt#QDataStream

kkrzewniak

Post Irrelevant since Merged

phamtv

is there not a way I can use memmove?

kkrzewniak

char * QByteArray::data ()
Returns a pointer to the data stored in the byte array.
Have You tried this.

phamtv

yes I have... the following code I have does not seem to work. I checked under the memory window after the memmove function but do not see the result I am expecting.

@
struct_MtrTxMsgType TX_Msg;
int txcnt, rcvLen;
QByteArray TX_Buffer;
TX_Buffer.resize(2049);
QByteArray RX_Buffer;
RX_Buffer.resize(2049);
bool ok;

memset(&TX_Msg.WakeUp[0], 0xFE, sizeof(TX_Msg.WakeUp));
TX_Msg.Header = 0x68;
TX_Msg.Address[0] = 0x09;
TX_Msg.Address[1] = 0x90;
TX_Msg.Address[2] = 0x78;
TX_Msg.Address[3] = 0x56;
TX_Msg.Address[4] = 0x34;
TX_Msg.Address[5] = 0x12;
TX_Msg.Delimeter = 0x68;
TX_Msg.R_W = 0x01;
TX_Msg.DataLength = 0x02;

memmove((void *)TX_Buffer.data(), &TX_Msg, sizeof(TX_Msg));

@

DenisKormalev

Do you need memmove for speedup or for something else? In first case I think using QByteArray will remove all advantages of using memmove.

tobias.hunger

Denis: Why? You can reserve a chunk of memory and qMemCopy into it. Why is that slower as using some other method?

tobias.hunger

phamtv: I'd recommend using qMemCopy/qMemSet from QtCore/QtGlobal. I think those are not documented, so they are not officially supported, but they work well for me.

DenisKormalev

Tobias, hm, I mostly saying that from my point of view memmove and other c things should be used now only if you are know what you are doing (e.g. if you need to speed up your memory management). In common cases such low-level work is not needed. And in case of mixing memmove for initializing data and using QByteArray to work with it I think initial speedup from memmove will be neglected by QByteArray abstractions.

tobias.hunger

Denis: You are right that you should not need these low level functionality 95% of the time... but it is still very useful for the last 5%:-)

I actually do not think that the QByteArray overhead is that big by the way (I did not do any measurements though), it is just a wrapper around a piece of memory after all. Resizing the buffer is of course expensive and needs to be avoided.

tobias.hunger

phamtv: You did read the "documentation of QByteArray":http://doc.trolltech.com/4.7/qbytearray.html, didn't you? It states quite clearly how to access its buffer.

phamtv

yes I have read the QByteArray document. I am still puzzled on the benefits of a QByteArray. My background with byte arrays have always been something similar to quint8 arr[] in which I can later cast to whatever my data structure is. Besides dynamic resizing of the array size, are there any other advantages to QByteArray over the quint8[]? Also, is it true that if I use the QByteArray, I should use the qMemCopy/qMemSet from QtCore/QtGlobal instead of the memmove, memcpy???

tobias.hunger

To quote the documentation:

QByteArray can be used to store both raw bytes (including '\0's) and traditional 8-bit '\0'-terminated strings. Using QByteArray is much more convenient than using const char *. Behind the scenes, it always ensures that the data is followed by a '\0' terminator, and uses implicit sharing (copy-on-write) to reduce memory usage and avoid needless copying of data.

Using QByteArray or not does not matter for qMemCopy or memcpy. The first is just a wrapper around the latter anyway. qMemCopy will be there wherever Qt is available, and it is in a Qt header which is included in almost all Qt code.

phamtv

Thank you Tobias. As always, your continual support is greatly appreciated!

Mart

That time tests:

@ QByteArray ba1(2048, 0);
QByteArray ba2(2048, 255);
QByteArray ba3(1024, 255);
char *ba1data = ba1.data();
char *ba2data = ba2.data();

QElapsedTimer timer;
timer.start();

for (int i = 0; i < 100000000; i++)
{
//ba2.replace(1000, 1024, ba1.data()+1000, 1024); // For 12324 ms.
//ba2.replace(1000, 1024, ba1.mid(1000, 1024)); // For 33228 ms.
//ba3 = ba1.left(1024); // For 45615 ms. <- ?!
//ba3 = ba1.right(1024); // For 29640 ms.
//ba3 = ba1.mid(1000, 1024); // For 29859 ms.

//memcpy(ba2data+1000, ba1data+1000, 1024);       // For 7722 ms.
qMemCopy(ba2data+1000, ba1data+1000, 1024);     // For 11981 ms.

}

qDebug() << timer.elapsed();@