void ModificationMap::applyModifications(UpdatableByteContainer &ubc) {
if(isEmpty()) {
return;
}
Iterator<Entry<__int64, BytePair> > it = entrySet().getIterator();
Entry<__int64, BytePair> &e = it.next();
__int64 seqStartAddr = e.getKey();
__int64 lastAddr = seqStartAddr;
ByteArray byteSequence;
byteSequence.append(e.getValue().getTo());
while(it.hasNext()) {
Entry<__int64, BytePair> &e1 = it.next();
const __int64 addr = e1.getKey();
if(addr != lastAddr+1) {
ubc.putBytes(seqStartAddr, byteSequence);
byteSequence.clear();
seqStartAddr = addr;
}
byteSequence.append(e1.getValue().getTo());
lastAddr = addr;
}
ubc.putBytes(seqStartAddr, byteSequence); // byteSequence is NOT empty
}
//------------------------------------------------------------------------------
bool ImuGetConfigResponseBinaryMessage::binaryMessageToByteArray(
ByteArray& byteArray) const
{
return (byteArray.append(myMessage.index, ENDIAN_BIG) &&
byteArray.append(myMessage.measurementMode, ENDIAN_BIG) &&
byteArray.append(myMessage.accelMeasurementRange, ENDIAN_BIG) &&
byteArray.append(myMessage.accelMeasurementRateHz, ENDIAN_BIG) &&
byteArray.append(myMessage.gyroMeasurementRange, ENDIAN_BIG) &&
byteArray.append(myMessage.gyroMeasurementRateHz, ENDIAN_BIG) &&
byteArray.append(myMessage.magMeasurementRange, ENDIAN_BIG) &&
byteArray.append(myMessage.magMeasurementRateHz, ENDIAN_BIG));
}
void Shader::build()
{
m_vertexShader = compileVertexShader(m_strVertexShader->cstr());
m_fragmentShader = compileFragmentShader(m_strFragmentShader->cstr());
m_shaderProgram = linkShaderProgram(m_vertexShader, m_fragmentShader);
const SPVRTPFXUniformSemantic* semantics = PVRTPFXSemanticsGetSemanticList();
for (int i = 0; i < m_uniforms->count(); ++i)
{
SPVRTPFXUniform& uniform = m_uniforms->get(i);
const SPVRTPFXUniformSemantic& semantic = semantics[uniform.nSemantic];
if (semantic.isAttrib)
{
uniform.nLocation = glGetAttribLocation(m_shaderProgram, uniform.sValueName->cstr());
m_isAttributeRequired[semantic.n] = true;
++m_numAttributesRequired;
}
else
{
uniform.nLocation = glGetUniformLocation(m_shaderProgram, uniform.sValueName->cstr());
// Check for array. Workaround for some OpenGL:ES implementations which require array element appended to uniform name
// in order to return the correct location.
if (uniform.nLocation == -1)
{
ByteArray* szTmpUniformName = ByteArray::create(uniform.sValueName->cstr());
szTmpUniformName->append("[0]");
uniform.nLocation = glGetUniformLocation(m_shaderProgram, szTmpUniformName->cstr());
}
}
}
}
int testConnectivity () {
/*
* B requests A's Data
* Must get it delivered as soon it is ready.
*/
test::DataSharingScenario scenario;
scenario.initConnectAndLift (2,false,true);
BufferChannelPtr a (new BufferChannel());
BufferChannelPtr b (new BufferChannel());
scenario.peer(0)->server->share ("bla", DataSharingServer::createFixedPromise (DataPromisePtr (new ChannelDataSource (a))));
ds::Request r;
r.mark = ds::Request::Transmission;
r.path = "bla";
scenario.peer(1)->client->request (scenario.peer(0)->hostId(), r, abind (&writeGateWay, b));
ByteArray testData1 ("Hello World");
ByteArray testData2 ("How are you?");
ByteArray testData = testData1; testData.append (testData2);
test::millisleep_locked (100);
a->feed (sf::createByteArrayPtr (testData1));
test::millisleep_locked (100);
a->feed (sf::createByteArrayPtr (testData2));
test::millisleep_locked (100);
ByteArrayPtr p = b->consume();
tcheck1 (p && *p == testData);
return 0;
}
//------------------------------------------------------------------------------
ComInterface::Error Usb::getRxBytes(ByteArray& byteArray,
unsigned int nBytes)
{
unsigned int size;
if (nBytes == 0)
{
size = myRxBuffer.count();
}
else
{
size = nBytes;
}
for (int i = 0; i < size; i++)
{
uint8_t byte;
if (myRxBuffer.read(byte))
{
byteArray.append(byte);
}
}
return ComInterface::ERROR_NONE;
}
void ElfSegment::writeData(ByteArray& output)
{
if (sections.size() == 0)
{
output.alignSize(header.p_align);
if (header.p_offset == header.p_paddr)
header.p_paddr = output.size();
header.p_offset = output.size();
return;
}
// align segment to alignment of first section
int align = std::max<int>(sections[0]->getAlignment(),16);
output.alignSize(align);
header.p_offset = output.size();
for (int i = 0; i < (int)sections.size(); i++)
{
sections[i]->setOffsetBase(header.p_offset);
}
if (paddrSection)
{
header.p_paddr = paddrSection->getOffset();
}
output.append(data);
}
ByteArray Process::readAll()
{
ssize_t sizeRead;
char buffer[1024];
ByteArray ret;
while ((sizeRead = ::read(_stdoutFd, buffer, sizeof buffer)) > 0)
ret.append(buffer, sizeRead);
return ret;
}
ByteArray operator+(const ByteArray& op1, const ByteArray& op2)
{
// Create array to return
ByteArray retval;
// Copy contents
retval.append(op1);
retval.append(op2);
return retval;
}
// Test >50MB Traffic between two sockets, at least filling 5 mb into the buffer
int testHeavyTraffic (UDTSocket * socket1, UDTSocket * socket2){
// test data size
const size_t amount = 1024 * 5500; // > 5mb
const size_t halfAmount = amount / 2;
const int rounds = 5;
tassert (halfAmount * 2 == amount, "bad testcase");
// creating test data
static bool initialized = false;
static ByteArray data (amount, 0); // > 5mb
if (!initialized){
printf ("Creating %d bytes test data\n", (int) amount);
test::pseudoRandomData(amount,data.c_array());
initialized = true;
}
double t0 = sf::microtime();
for (int i = 0; i < rounds; i++) {
printf ("TestHeavyTraffic - Round: %d\n", i);
double ts0 = sf::microtime ();
// sending
socket1->write (sf::createByteArrayPtr(data));
// first half
tassert (test::waitUntilTrueMs (sf::bind(hasData, socket2, halfAmount), 10000), "Should get data");
ByteArrayPtr part1 = socket2->read(halfAmount);
// second half
tassert (test::waitUntilTrueMs (sf::bind(hasData, socket2, halfAmount), 10000), "Should get data");
ByteArrayPtr part2 = socket2->read(halfAmount);
// checking correctness
tassert (part1 && part2, "Shall receive all data");
ByteArray combined;
combined = *part1;
combined.append(*part2);
tassert (combined == data, "Shall receive the same as send");
double ts1 = sf::microtime ();
double rate = amount / (ts1 - ts0) / 1024 / 1024; // MiB/s
printf (" Round rate: %f MiB/s\n", rate);
}
double t1 = sf::microtime ();
size_t totalTraffic = rounds * amount;
double rate = totalTraffic / (t1 - t0) / 1024 / 1024; // MiB/s
printf ("TestHeavyTraffic: Rate: %f MiB/s\n", rate);
return 0;
}
// only called for segmentless sections
void ElfSection::writeData(ByteArray& output)
{
if (header.sh_type == SHT_NULL) return;
// nobits sections still get a provisional file address
if (header.sh_type == SHT_NOBITS)
{
header.sh_offset = output.size();
}
if (header.sh_addralign != -1)
output.alignSize(header.sh_addralign);
header.sh_offset = output.size();
output.append(data);
}
unsigned short VirtualKPA::loadRig(const QString& rigFileName, ByteArray& blob)
{
QFile kiprFile(rigFileName);
kiprFile.open(QIODevice::ReadOnly);
QDataStream stream(&kiprFile);
int magicSize = sizeof(sKiprMagic1);
ByteArray magic(magicSize, 0);
stream.readRawData((char*)magic.data(), magicSize);
if(magic == sKiprMagic1 || magic == sKiprMagic2)
{
qint64 fileSize = kiprFile.bytesAvailable();
blob.reserve(fileSize + magicSize);
blob.append(magic);
stream.readRawData((char*) blob.data()+magicSize, fileSize);
}
return Utils::crc14(blob);
}
void File::Read( ByteArray& buffer, uint size )
{
if( m_fd < 0 )
{
THROW_ERROR( "Can't read from a closed file" );
}
buffer.clear();
char inbuf[UTIL_FILE_READBUF_SIZE];
while( size > 0 )
{
size_t max_read;
if( size > sizeof(inbuf) )
{
max_read = sizeof(inbuf);
}
else
{
max_read = size;
}
ssize_t n = read( m_fd, inbuf, max_read );
if( n < 0 )
{
if( errno == EINTR ) continue;
THROW_ERROR( "Failed to read data from the file (Error=%s)", strerror(errno) );
}
buffer.append( inbuf, n );
size -= n;
if( (size_t)n < max_read ) break;
}
}
ByteArray NRPNBase::createNRPNSingleParamSetCmd(const ByteArray& addressPage, const ByteArray& param, const ByteArray& val)
{
ByteArray res;
if(val.size() == 2 || val.size() == 1)
{
res.append(sHeader);
res.append(sAddressPageTag);
res.append(addressPage);
res.append(sHeader);
res.append(sParameterTag);
res.append(param);
if(val.size() == 2)
{
res.append(sHeader);
res.append(sMSBValueTag);
res.push_back(val[0]);
res.append(sHeader);
res.append(sLSBValueTag);
res.push_back(val[1]);
}
else
{
res.append(sHeader);
res.append(sLowResValueTag);
res.push_back(val[0]);
}
}
return res;
}
void FindDialog::find_input(bool next)
{
if (m_parent->get_data_provider().isNull())
return;
// 添加到下拉列表
addToInputList();
const QString invalidInput(tr("输入不合法"));
const QString notFound(tr("未找到"));
if (ui.find_num_ratio->isChecked())
{
// 要查找的数据长度
const int search_len = (ui.byte_radio->isChecked() ? 1 :
(ui.word_radio->isChecked() ? 2 :
(ui.double_word_radio->isChecked() ? 4 : 8)));
// 解析并验证要查找的数字
bool valid = false;
const int64_t v = parse_number(ui.input_comb->currentText(), &valid);
if (!valid || (search_len == 1 && (v < -(int64_t)0x80 || v > (int64_t)0xFF)) ||
(search_len == 2 && (v < -(int64_t)0x8000 || v > (int64_t)0xFFFF)) ||
(search_len == 4 && (v < -(int64_t)0x80000000L || v > (int64_t)0xFFFFFFFFL)))
{
emit m_parent->on_error(invalidInput);
return;
}
// 查找并显示
const int rs = find_data(next, reinterpret_cast<const uint8_t*>(&v), search_len, false);
if (rs < 0)
{
emit m_parent->on_error(notFound);
if (next)
{
m_parent->ui.hex_edit->moveCaretTo(0);
m_parent->ui.hex_edit->showData(0);
}
else
{
m_parent->ui.hex_edit->moveCaretTo(m_parent->get_data_provider()->length());
m_parent->ui.hex_edit->showData(m_parent->get_data_provider()->length());
}
}
else
{
m_parent->ui.hex_edit->moveCaretTo(next ? rs + search_len : rs);
m_parent->ui.hex_edit->selectHex(rs, search_len);
m_parent->ui.hex_edit->showData(rs);
}
return;
}
else if (ui.find_txt_radio->isChecked())
{
string _s = ui.input_comb->currentText().toLocal8Bit().data();
ByteArray s(_s.c_str(), _s.length());
if (s.length() == 0)
return;
// 处理扩展模式
if (ui.expend_txt_radio->isChecked())
{
ByteArray actual;
size_t i = 0;
while (i < s.length())
{
// 一般字符
char c = s[i++];
if (c != '\\' || i == s.length())
{
actual.append(&c, 1);
continue;
}
// 转义字符
c = s[i++];
switch (c)
{
case 'a': // 响铃
c = '\a';
break;
case 'b': // 退格
c = '\b';
break;
case 'f': // 换页
c = '\f';
break;
case 'n': // 换行
c = '\n';
break;
case 'r': // 回车
c = '\r';
break;
case 't': // 水平制表符
c = '\t';
break;
case 'v': // 垂直制表符
c = '\v';
break;
case '\\':
c = '\\';
case 'x': // 16进制转义
c = 0;
for (size_t j = 0; j < 2 && i < s.length(); ++j)
{
char cc = s[i++];
if ('0' <= cc && cc <= '9')
{
c = (char) (c * 16 + cc - '0');
}
else if ('a' <= (cc | 0x20) && (cc | 0x20) <= 'f')
{
c = (char) (c * 16 + (cc | 0x20) - 'a' + 10);
}
else
{
--i;
break;
}
}
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
c -= '0';
for (size_t j = 0; j < 2 && i < s.length(); ++j)
{
char cc = s[i++];
if ('0' <= cc && cc <= '7')
{
c = (char) (c * 8 + cc - '0');
}
else
{
--i;
break;
}
}
break;
default:
break;
}
actual.append(&c, 1);
}
s = actual;
}
// 处理大小写 -> 转为小写
const bool ignoreCase = !ui.match_case_txt_chckbox->isChecked();
if (ignoreCase)
for (size_t i = 0; i < s.length(); ++i)
if ('A' <= s[i] && s[i] <= 'Z')
s[i] = s[i] | 0x20;
// 查找并显示
const int rs = find_data(next, s.buffer(), s.length(), ignoreCase);
if (rs < 0)
{
emit m_parent->on_error(notFound);
if (next)
{
m_parent->ui.hex_edit->moveCaretTo(0);
m_parent->ui.hex_edit->showData(0);
}
else
{
m_parent->ui.hex_edit->moveCaretTo(m_parent->get_data_provider()->length());
m_parent->ui.hex_edit->showData(m_parent->get_data_provider()->length());
}
}
else
{
m_parent->ui.hex_edit->moveCaretTo(next ? rs + s.length() : rs);
m_parent->ui.hex_edit->selectAscii(rs, s.length());
m_parent->ui.hex_edit->showData(rs);
}
}
else
{
// 有效性验证
if (m_parent->get_root().isNull())
return;
QString lookup = ui.input_comb->currentText();
if (lookup.isNull() || lookup.length() == 0)
return;
if (ui.regex_node_radio->isChecked())
{
QRegExp r(lookup);
if (!r.isValid())
{
emit m_parent->on_error(invalidInput);
return;
}
}
QAbstractItemModel *model = m_parent->ui.tree_view->model();
assert(NULL != model);
QModelIndex index = m_parent->ui.tree_view->currentIndex();
if (next) // 往后找
{
while (true)
{
index = getNextIndex(index);
if (!index.isValid())
{
emit m_parent->on_error(notFound);
m_parent->ui.tree_view->setCurrentIndex(model->index(0,0,QModelIndex()));
return;
}
QString t = index.data(Qt::DisplayRole).toString();
if (elemMatch(t))
{
m_parent->ui.tree_view->setCurrentIndex(index);
return;
}
}
}
else // 往前找
{
while (true)
{
QModelIndex pre = getPreIndex(index);
if (!index.isValid() || !pre.isValid())
{
QModelIndex last = getPreIndex(QModelIndex());
emit m_parent->on_error(notFound);
m_parent->ui.tree_view->setCurrentIndex(last);
return;
}
index = pre;
QString t = index.data(Qt::DisplayRole).toString();
if (elemMatch(t))
{
m_parent->ui.tree_view->setCurrentIndex(index);
return;
}
}
}
}
}
ByteArray Serializable::serialize() {
beforeSerialization();
int len = serial_objects.length();
LinkedListState< Ref<SERIAL_OBJECT> > objs(&serial_objects);
SERIAL_OBJECT *obj;
ByteArray ret;
ByteArray ba_obj;
for (int i=0; i<len; i++) {
ba_obj.clear();
obj = objs.next().getPtr();
if (obj->type != OBJECT_TYPE_SERIALIZABLE)
ba_obj.append(ByteArray((const char*)&obj->type, 1));
switch (obj->type) {
case OBJECT_TYPE_OTHER:
{
ByteArray s = serializeOther(i, obj->object);
ssize_t len = s.length();
ba_obj.append(ByteArray((const char*)&len, 4));
ba_obj.append(s);
}
break;
case OBJECT_TYPE_SERIALIZABLE:
{
ByteArray s = reinterpret_cast<Serializable*>(obj->object)->serialize();
ssize_t len = s.length();
if (len <= 0xFF)
obj->type = OBJECT_TYPE_TINY_SERIALIZABLE;
else if (len <= 0xFFFF)
obj->type = OBJECT_TYPE_MEDIUM_SERIALIZABLE;
ba_obj.append(ByteArray((const char*)&obj->type, 1));
if (obj->type == OBJECT_TYPE_TINY_SERIALIZABLE)
ba_obj.append(ByteArray((const char*)&len, 1));
else if (obj->type == OBJECT_TYPE_MEDIUM_SERIALIZABLE)
ba_obj.append(ByteArray((const char*)&len, 2));
else
ba_obj.append(ByteArray((const char*)&len, 4));
ba_obj.append(s);
}
break;
case OBJECT_TYPE_TINY_BYTEARRAY:
ba_obj.append(ByteArray((const char*)&obj->len, 1));
ba_obj.append(ByteArray((const char*)obj->object, (int)obj->len));
break;
case OBJECT_TYPE_MEDIUM_BYTEARRAY:
ba_obj.append(ByteArray((const char*)&obj->len, 2));
ba_obj.append(ByteArray((const char*)obj->object, (int)obj->len));
break;
case OBJECT_TYPE_BYTEARRAY:
ba_obj.append(ByteArray((const char*)&obj->len, 4));
ba_obj.append(ByteArray((const char*)obj->object, (int)obj->len));
break;
default:
ba_obj.append(ByteArray((const char*)obj->object, (int)obj->len));
}
ret.append(ba_obj);
}
return ret;
}
inline void _appendType(ByteArray& str, RPCType _type) {
char type = static_cast<char>(_type);
str.append(&type, sizeof(type));
}
inline void _appendScalar(ByteArray& str, real data) {
str.append(reinterpret_cast<char*>(&data), sizeof(data));
}
//------------------------------------------------------------------------------
bool ImuSetConfigResponseBinaryMessage::binaryMessageToByteArray(
ByteArray& byteArray) const
{
return (byteArray.append(myMessage.error, ENDIAN_BIG));
}
void SymbolData::writeExSym()
{
if (exSymFileName.empty())
return;
ByteArray data;
ByteArray stringData;
data.reserveBytes(sizeof(ExSymHeader));
ExSymHeader header;
memcpy(header.magic,"ESYM",4);
header.version = 1;
header.headerSize = sizeof(ExSymHeader);
header.modulePos = data.size();
header.moduleCount = modules.size();
data.reserveBytes(header.moduleCount*sizeof(ExSymModuleHeader));
// add modules
for (size_t i = 0; i < modules.size(); i++)
{
SymDataModule& module = modules[i];
ExSymModuleHeader moduleHeader;
int modulePos = header.modulePos+i*sizeof(ExSymModuleHeader);
std::sort(module.addressInfo.begin(),module.addressInfo.end());
std::sort(module.data.begin(),module.data.end());
std::sort(module.functions.begin(),module.functions.end());
std::sort(module.symbols.begin(),module.symbols.end());
SymDataModuleInfo moduleInfo;
if (module.file != NULL && module.file->getModuleInfo(moduleInfo))
{
moduleHeader.crc32 = moduleInfo.crc32;
} else {
moduleHeader.crc32 = -1;
}
// add address info
moduleHeader.addressInfosPos = data.size();
moduleHeader.addressInfosCount = module.addressInfo.size();
for (size_t l = 0; l < module.addressInfo.size(); l++)
{
SymDataAddressInfo& info = module.addressInfo[l];
ExSymAddressInfoEntry entry;
entry.address = info.address;
entry.fileIndex = info.fileIndex;
entry.lineNumber = info.lineNumber;
data.append((byte*)&entry,sizeof(entry));
}
// add symbols
moduleHeader.symbolsPos = data.size();
moduleHeader.symbolsCount = module.symbols.size();
for (size_t l = 0; l < module.symbols.size(); l++)
{
SymDataSymbol& sym = module.symbols[l];
ExSymSymbolEntry entry;
entry.addressInfoIndex = getAddressInfoEntry(module.addressInfo,sym.address);
entry.functionIndex = getFunctionEntry(module.functions,sym.address);
entry.namePos = stringData.size();
stringData.append((byte*)sym.name.c_str(),sym.name.size()+1);
entry.type = 0;
data.append((byte*)&entry,sizeof(entry));
}
// add functions
moduleHeader.functionsPos = data.size();
moduleHeader.functionsCount = module.functions.size();
for (size_t l = 0; l < module.functions.size(); l++)
{
SymDataFunction& func = module.functions[l];
ExSymFunctionEntry entry;
entry.addressInfoIndex = getAddressInfoEntry(module.addressInfo,func.address);
entry.size = func.size;
data.append((byte*)&entry,sizeof(entry));
}
// add data
moduleHeader.datasPos = data.size();
moduleHeader.datasCount = module.data.size();
for (size_t l = 0; l < module.data.size(); l++)
{
SymDataData& d = module.data[l];
ExSymDataEntry entry;
entry.addressInfoIndex = getAddressInfoEntry(module.addressInfo,d.address);
entry.size = d.size;
entry.type = d.type;
data.append((byte*)&entry,sizeof(entry));
}
// write header
data.replaceBytes(modulePos,(byte*)&moduleHeader,sizeof(moduleHeader));
}
// add files
header.filesPos = data.size();
header.fileCount = files.size();
for (size_t i = 0; i < files.size(); i++)
{
ExSymFileEntry entry;
entry.filePos = stringData.size();
stringData.append((byte*)files[i].c_str(),files[i].size()+1);
data.append((byte*)&entry,sizeof(entry));
}
// add string table
header.stringTablePos = data.size();
data.append(stringData);
// write header
data.replaceBytes(0,(byte*)&header,sizeof(header));
// write
data.toFile(exSymFileName);
}
