void MainWindow::generate_f(){
QString polyString = polyField->text();
QString startString = startValueField->text();
polyString.remove(0,1);
if(polyString.length() != startString.length()){
resultDoc->setPlainText("Invalid Input");
return;
}
if(!checkInput(polyString)){
return;
}
if(!checkInput(startString)){
return;
}
if((polyData = convertData(polyString)) == NULL){
resultDoc->setPlainText("Invalid Input");
return;
}
if((data = convertData(startString)) == NULL){
resultDoc->setPlainText("Invalid Input");
return;
}
std::reverse(polyData->begin(), polyData->end());
generateOutput();
}
void ADC_INT_ISR(void) {
// Reset interrupt flags
AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;
AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
// Read ADC results
rawData.gyro_z_t = AdcRegs.ADCRESULT0 >> 4;
rawData.ref_mon = AdcRegs.ADCRESULT1 >> 4;
rawData.mag_y = AdcRegs.ADCRESULT2 >> 4;
rawData.accel_x_t = AdcRegs.ADCRESULT3 >> 4;
rawData.gyro_x_t = AdcRegs.ADCRESULT4 >> 4;
rawData.accel_x = AdcRegs.ADCRESULT5 >> 4;
rawData.gyro_x = AdcRegs.ADCRESULT6 >> 4;
rawData.mag_z = AdcRegs.ADCRESULT7 >> 4;
rawData.gyro_z = AdcRegs.ADCRESULT8 >> 4;
rawData.mag_x = AdcRegs.ADCRESULT9 >> 4;
rawData.gyro_y = AdcRegs.ADCRESULT10 >> 4;
rawData.gyro_y_t = AdcRegs.ADCRESULT11 >> 4;
rawData.accel_z = AdcRegs.ADCRESULT12 >> 4;
rawData.accel_z_t = AdcRegs.ADCRESULT13 >> 4;
rawData.accel_y = AdcRegs.ADCRESULT14 >> 4;
rawData.accel_y_t = AdcRegs.ADCRESULT15 >> 4;
// Pass data to the filter. If a decimation cycle is up, convert the data
// and start a low g conversion.
if (updateFilter()) {
convertData();
readLowG();
}
}
int main(int argc, char** argv)
{
int fin; /* input file handle */
int fout; /* output file handle */
/* too few parameters passed */
if (argc <= 2)
{
printHelp();
return 1;
}
fin = initFile(argv[1], INIT_READ);
if (fin < 0) {
printf("\n !!! Error opening file %s! \n", argv[1]);
return 1;
}
fout = initFile(argv[2], INIT_WRITE);
if (fout < 0) {
printf("\n !!! Error opening file %s! \n", argv[2]);
return 1;
}
convertData(fin, fout);
close(fout);
close(fin);
return 0;
}
bool Http::get(QUrl url, QByteArray data, QByteArray &result, QMap<QString, QString> cookies, int timeout)
{
QByteArray body;
QByteArray cookiesData = convertData(cookies);
QString urlstr;
if (!data.isEmpty()) {
urlstr.append(url.toEncoded());
urlstr.append('?');
urlstr.append(data);
} else {
urlstr = url.toEncoded();
}
body.append(QString("GET %1 HTTP/1.1\r\n").arg(urlstr));
body.append(QString("Host: %1:%2\r\n").arg(url.host()).arg(url.port()));
body.append("Connection: close\r\n");
if (!cookies.isEmpty()) {
body.append("Cookie: ");
body.append(cookiesData);
body.append("\r\n");
}
body.append("\r\n");
return send(url.host(),url.port(),body,result,timeout);
}
void Tercon::extractData(){
QList <QByteArray> splitByteArray(recvBytes.split('\r'));
for(int i =0;i <splitByteArray.size()-1;++i){
convertData(splitByteArray.at(i));
}
recvBytes.clear();
recvBytes.append(splitByteArray.last());
}
/*
conver the character matrix data:
convert the array matrixdata[] data,and save convert result in array matrixdata_conver[];
*/
void E_ink_ESP8266::converCharMatrixData (void)
{
INT16U tempData;
INT8U i,j,m;
INT8U temp;
for(i=0;i<8;i++) //convert the first 8 byte data
{
tempData=convertData(matrixdata[i]);
matrixdata_conver[i]=tempData>>8; //save data at matrixdata_conver[0]~matrixdata_conver[7]
matrixdata_conver[i+8]=tempData; //save data at matrixdata_conver[8]~matrixdata_conver[15]
}
for(i=8;i<16;i++) //convert the last 8 byte data
{
tempData=convertData(matrixdata[i]);
matrixdata_conver[i+8]=tempData>>8; //save data at matrixdata_conver[16]~matrixdata[23]
matrixdata_conver[i+16]=tempData; //save data at matrixdata_conver[24]~matrixdata_conver[31]
}
}
void DDLIndexPopulator::convertColData(const execplan::ColumnResult* cr, int idx, const erydbSystemCatalog::ColType& colType, WriteEngine::IdxTuple& tuple)
{
if (isDictionaryType(colType))
{
/* tuple.data = tokenizeData ( colType, cr->GetStringData(idx) );*/
/* tuple.data = tokenizeData ( cr->GetRid(idx) );*/
tuple.data = convertTokenData(cr->GetStringData(idx));
}
else tuple.data = convertData( colType, cr, idx);
}
boost::optional<openstudio::TimeSeries> SimFile::pathFlow1(int nr) const
{
int index = m_pathNr.indexOf(nr);
if(index == -1)
{
return boost::optional<openstudio::TimeSeries>();
}
openstudio::TimeSeries series = convertData(m_dateTimes,m_F1[index],"kg/s");
return boost::optional<openstudio::TimeSeries>(series);
}
boost::optional<openstudio::TimeSeries> SimFile::nodeTemperature(int nr) const
{
int index = m_nodeNr.indexOf(nr);
if(index == -1)
{
return boost::optional<openstudio::TimeSeries>();
}
openstudio::TimeSeries series = convertData(m_dateTimes,m_T[index],"K");
return boost::optional<openstudio::TimeSeries>(series);
}
boost::optional<openstudio::TimeSeries> SimFile::nodeDensity(int nr) const
{
int index = m_nodeNr.indexOf(nr);
if(index == -1)
{
return boost::optional<openstudio::TimeSeries>();
}
openstudio::TimeSeries series = convertData(m_dateTimes,m_D[index],"kg/m^3");
return boost::optional<openstudio::TimeSeries>(series);
}
vector<SkillInfoNew> SkillData::getAllPlayerSkillData()
{
vector<SkillInfoNew> allSkill;
sqlite3 *data = SqlUtil::openData(DATAFILE);
string sql = "select * from player_skill";
vector<vector<string>> a = SqlUtil::runQuery(data, sql.c_str());
for (auto &item : a)
{
allSkill.push_back(convertData(item));
}
return allSkill;
}
SkillInfoNew SkillData::getPlayerSkillDataBySkillId(int skillId)
{
sqlite3 *data = SqlUtil::openData(DATAFILE);
string sql = "select * from player_skill where player_skill.id =";
sql.append(DataUtils::numberToString(skillId));
vector<vector<string>> a = SqlUtil::runQuery(data, sql.c_str());
if (a.size() > 0)
{
return convertData(a[0]);
}
SkillInfoNew b;
return b;
}
vector<SkillInfoNew> SkillData::getUnitSkillsByUnitId(int unitId)
{
vector<SkillInfoNew> returnData;
string sql = "SELECT skill.* FROM unit_skill JOIN unit ON unit.id = unit_skill.unitId JOIN skill ON skill.id = unit_skill.skillId WHERE unit.id = ";
sql.append(DataUtils::numberToString(unitId));
sqlite3 *data = SqlUtil::openData(DATAFILE);
vector<vector<string>> a = SqlUtil::runQuery(data, sql.c_str());
for (auto &item : a)
{
returnData.push_back(convertData(item));
}
return returnData;
}
bool AVOutput::writeData(const QByteArray &data)
{
Q_UNUSED(data);
//DPTR_D(AVOutput);
//locker(&mutex)
//TODO: make sure d.data thread safe. lock around here? for audio and video(main thread problem)?
/* you can use d.data directly in AVThread. In other thread, it's not safe, you must do something
* to make sure the data is not be modified in AVThread when using it*/
//d_func().data = data;
convertData(data);
bool result = write();
//write then pause: if capture when pausing, the displayed picture is captured
tryPause();
return result;
}
void printList(const LinkedList * theList, void (*convertData)(void *))
{
Node *temp =theList->head;
if(temp==NULL)
{
printf("List is Empty");
}
while(temp->next !=NULL){
temp = temp->next;
convertData(temp->data);
}
free(temp);
}
boost::optional<openstudio::TimeSeries> SimFile::pathFlow(int nr) const
{
int index = m_pathNr.indexOf(nr);
if(index == -1)
{
return boost::optional<openstudio::TimeSeries>();
}
std::vector<double> flow(m_dateTimes.size());
for(unsigned i=0;i<m_dateTimes.size();i++)
{
flow[i] = m_F0[index][i] + m_F1[index][i];
}
// Need to confirm that the total flow is F0+F1, since it also could be F0-F1
openstudio::TimeSeries series = convertData(m_dateTimes,flow,"kg/s");
return boost::optional<openstudio::TimeSeries>(series);
}
bool Http::post(QUrl url, QByteArray data, QByteArray &result, QMap<QString, QString> cookies, int timeout)
{
QByteArray body;
QByteArray cookiesData = convertData(cookies);
QString urlstr = url.toEncoded();
body.append(QString("POST %1 HTTP/1.1\r\n").arg(urlstr));
body.append(QString("Host: %1:%2\r\n").arg(url.host()).arg(url.port()));
body.append(QString("Content-Length: %1\r\n").arg(data.length()));
body.append("Content-Type: application/x-www-form-urlencoded\r\n");
body.append("Connection: close\r\n");
if (!cookies.isEmpty()) {
body.append("Cookie: ");
body.append(cookiesData);
body.append("\r\n");
}
body.append("\r\n");
body.append(data);
return send(url.host(),url.port(),body,result,timeout);
}
/*
conver the two-dimensional data:
convert the array dimensionalData[] data,and save convert result in array matrixdata_conver[];
*/
void E_ink_ESP8266::converDimensionalCode(void)
{
int tempData;
INT8U i,j;
INT8U adder,Adder;
for(j=0;j<4;j++)
{
adder=25*j;
Adder=adder+25;
for(i=adder;i<Adder;i++)
{
tempData=convertData(dimensionalData[i]);
matrixdata_conver[i+adder]=tempData>>8;
matrixdata_conver[i+Adder]=tempData;
}
}
}
IDirect3DTexture9* ModelViewer::loadTexture( uint p_fileId ) {
auto entryNumber = this->datFile( )->entryNumFromFileId( p_fileId );
auto fileData = this->datFile( )->readEntry( entryNumber );
// Bail if read failed
if ( fileData.GetSize( ) == 0 ) {
return nullptr;
}
// Convert to image
ANetFileType fileType;
this->datFile( )->identifyFileType( fileData.GetPointer( ), fileData.GetSize( ), fileType );
auto reader = FileReader::readerForData( fileData, fileType );
// Bail if not an image
auto imgReader = dynamic_cast<ImageReader*>( reader );
if ( !imgReader ) {
deletePointer( reader );
return nullptr;
}
// Convert to PNG and bail if invalid
auto pngData = imgReader->convertData( );
if ( pngData.GetSize( ) == 0 ) {
deletePointer( reader );
return nullptr;
}
// Finally, load texture from in-memory PNG.
IDirect3DTexture9* texture = nullptr;
::D3DXCreateTextureFromFileInMemory( m_device.get( ), pngData.GetPointer( ), pngData.GetSize( ), &texture );
// Delete reader and return
deletePointer( reader );
return texture;
}
void Network::sendActionPackets(vector<GameObj*> * gameObjs, vector<GameEvents*>* ge){
//cout << "size of GO " << gameObjs->size() << endl;
//cout << "size of GE " << ge->size() << endl;
//cout << "send Action" << endl;
// send action packet
if (gameObjs == nullptr)
{
//std::cout << "null ptr\n" << endl;
}
const unsigned int packet_size = sizeof(SPacket);
char packet_data[packet_size];
//GameObj* obj = new GameObj(1, -1, -5);
//GameObj* obj2 = new GameObj(1, -2, -5);
SPacket packet;
//packet.data[0] = '1';
//string des = "1 1 1 0";
string des = convertData(gameObjs);
//string des;
des += convertEventData(ge);
//cout << "convertEvent " << des.c_str() << endl;
//cout << "*********Sending SPacket: " << des << endl;
memset(packet.data, 0, sizeof(packet.data));
//char* str = new char[sizeof(des) + 1];
//std::strcpy(str, des.c_str());
//cout << "packet size is : "<< sizeof(des) << endl;
memcpy(packet.data, des.c_str(), des.length());
//cout << "size of des: " << sizeof(des) << endl;
//cout << "des.cstr: " << des.c_str() << endl;
//cout << "packet.data[4] : " << packet.data[4] << endl;
//cout << "AFTER MEM COPY" << endl;
packet.packet_type = GAME_STATE;
packet.serialize(packet_data);
//cout << "BERFORE SEND TO ALL" << endl;
//cout << packet.packet_type << endl;
network->sendToAll(packet_data, packet_size);
//for (vector<GameObj*>::iterator i = gameObjs->begin();
// i != gameObjs->end(); ++i)
//{
// if ((*i)->getIsRobot()){
// Robot* r = (Robot*)(*i);
// if (r->getState() == PS_ALIVE)
// {
// int cid = r->getCID();
// network->sendToOne(packet_data, packet_size,cid);
// }
// else if(r->_deathSent == 0){
// int cid = r->getCID();
// //cout << "send death package to : " << cid << endl;
// network->sendToOne(packet_data, packet_size, cid);
// r->_deathSent = 1;
// }
// else{
// int cid = r->getCID();
// //cout << "do not send when in build: " << cid << endl;
// }
// }
//}
//cout << "AFTER SEND TO ALL" << endl;
}
void *tdatarecv_fn(void * arg)
{
unsigned char hd[max_buffer_size],*rbuf, meaningfuldata[DATASIZE], meaningfuldata2[NEIDATASIZE]; /*定义接收缓冲区*/
int flag_close;
int k;
struct termios opt;
AbsMsg * absmsg = (AbsMsg*)arg;
while(1)
{
/*******************************************************************/
open_serial(0); /*打开串口0*/
/*******************************************************************/
tcgetattr(fd,&opt);
cfmakeraw(&opt);
/*****************************************************************/
cfsetispeed(&opt,B115200); /*波特率设置为115200bps*/
cfsetospeed(&opt,B115200);
/*******************************************************************/
tcsetattr(fd,TCSANOW,&opt);
//printf("\n接收线程...\n");
/*数据接收流程*/
while(1){
//pthread_mutex_lock(&absmsg->ecollock);
if(recvUart(hd) < 0)
continue;
putchar(10);
if(msgtype == 0){
memset(meaningfuldata, DATASIZE, 0);
memcpy(meaningfuldata, hd+1, DATASIZE);
absmsg->ecolmsg = (EcolMsg*)meaningfuldata;
/*调整字节序*/
convertData(absmsg->ecolmsg);
pthread_cond_broadcast(&dataready1);
pthread_cond_broadcast(&dataready2);
}else if(msgtype == 1){
memset(meaningfuldata2, NEIDATASIZE, 0);
memcpy(meaningfuldata2, hd+1, NEIDATASIZE);
absmsg->neimsg = (NeiMsg*)meaningfuldata2;
/*调整字节序*/
convertData2(absmsg->neimsg);
printf("Neighbor Msg:\n");
printf("Node %d has %d neighbors with power %d, t %d, h %d, l %d :\n", absmsg->neimsg->nodeid, absmsg->neimsg->neighbourNum, absmsg->neimsg->power, absmsg->neimsg->temp, absmsg->neimsg->humid, absmsg->neimsg->light);
for(k=0;k<absmsg->neimsg->neighbourNum;k++)
printf("#%d: node %d, linkQ:%f, RSSI:%d, LQI:%d \n",k+1, absmsg->neimsg->neighbourSet[k].nodeid, absmsg->neimsg->neighbourSet[k].linkquality/100.0f, absmsg->neimsg->neighbourSet[k].rssi, absmsg->neimsg->neighbourSet[k].lqi);
putchar(10);
if(absmsg->NQueue == NULL)
printf("NULL!!!!\n");
addQueue(absmsg->NQueue, absmsg->neimsg);
}else{
}
usleep(50000);
}
close(fd);
sleep(5);
}
}
/**
* バイナリデータよりEntity作成
*
* @param data バイナリデータ
*
* @return Entity
*/
GameItemStatusEntity GameItemStatusEntity::createEntity(const unsigned char *data) {
auto entity = GameItemStatusEntity();
entity.convertData(data);
return entity;
}
/*!
Handle an IPC request.
\param aMessage Message object.
*/
void CServiceSymbianSession::handleRequestL(const RMessage2& aMessage)
{
XQSERVICE_DEBUG_PRINT("CServiceSymbianSession::handleRequestL");
// Store the message
iMessage = aMessage;
// Convert from Symbian to QT
HBufC* request = ReadDesLC(aMessage, 0);
HBufC8* data = ReadDes8LC(aMessage, 1);
XQSharableFile *file = 0;
if (aMessage.Function() == KIPCOperationWithSharableFile)
{
// Only one file support now !
file = new XQSharableFile();
AdoptSharableFile(aMessage, file);
}
// Shallow copy only, we want a deep copy
QString d = QString::fromUtf16(request->Ptr(), request->Length());
QString operation;
operation += d;
XQSERVICE_DEBUG_PRINT("operation: %s", qPrintable(operation));
//QByteArray convertData;
TPtr8 ptr8(data->Des());
const char* ptrz = reinterpret_cast<const char*> (ptr8.PtrZ());
//convertData.append(ptrz);
QByteArray convertData(ptrz,data->Length());
XQSERVICE_DEBUG_PRINT("convertData: %s", convertData.constData());
// New request
if (iCurRequest) {
iObserver->handleDeleteRequest(iCurRequest);
delete iCurRequest;
}
iCurRequest = NULL;
iCurRequest = new ServiceIPCRequest(this, 0, operation);
iData.clear();
// Get client info
ClientInfo *client = new ClientInfo();
client->setProcessId(aMessage.SecureId().iId);
client->setVendorId(aMessage.VendorId().iId);
RThread clientThread;
aMessage.ClientL(clientThread);
CleanupClosePushL(clientThread);
RProcess clientProc;
CleanupClosePushL(clientProc);
clientThread.Process(clientProc);
client->setName(QString::fromUtf16(clientProc.Name().Ptr(),
clientProc.Name().Length()));
client->setCapabilities(ClientCapabilities(aMessage));
CleanupStack::PopAndDestroy(2, &clientThread);
// Set the picked sharable file if any
if (file != 0)
{
// Support only one sharable file
iCurRequest->addSharableFile(file, 0);
}
// Add data and callback to the observer
//
iCurRequest->addRequestdata(convertData);
iCurRequest->setClientInfo(client); // ownership passed
iObserver->handleRequest(iCurRequest);
CleanupStack::PopAndDestroy(2, request);
}
/** @brief Parse xml-data
*----------------------------------------------------------------------------*/
void ParseObject::slotParse(const QByteArray &xmlData, const int &feedId,
const QDateTime &dtReply, const QString &codecName)
{
if (mainApp->isSaveDataLastFeed()) {
QFile file(mainApp->dataDir() + "/lastfeed.dat");
file.open(QIODevice::WriteOnly);
file.write(xmlData);
file.close();
}
qDebug() << "=================== parseXml:start ============================";
db_.transaction();
// extract feed id and duplicate news mode from feed table
parseFeedId_ = feedId;
QString feedUrl;
duplicateNewsMode_ = false;
QSqlQuery q(db_);
q.setForwardOnly(true);
q.exec(QString("SELECT duplicateNewsMode, xmlUrl FROM feeds WHERE id=='%1'").arg(parseFeedId_));
if (q.first()) {
duplicateNewsMode_ = q.value(0).toBool();
feedUrl = q.value(1).toString();
}
// id not found (ex. feed deleted while updating)
if (feedUrl.isEmpty()) {
qWarning() << QString("Feed with id = '%1' not found").arg(parseFeedId_);
emit signalFinishUpdate(parseFeedId_, false, 0, "0");
db_.commit();
return;
}
qDebug() << QString("Feed '%1' found with id = %2").arg(feedUrl).arg(parseFeedId_);
// actually parsing
feedChanged_ = false;
bool codecOk = false;
QString convertData(xmlData);
QString feedType;
QDomDocument doc;
QString errorStr;
int errorLine;
int errorColumn;
QRegExp rx("encoding=\"([^\"]+)",
Qt::CaseInsensitive, QRegExp::RegExp2);
int pos = rx.indexIn(xmlData);
if (pos == -1) {
rx.setPattern("encoding='([^']+)");
pos = rx.indexIn(xmlData);
}
if (pos > -1) {
QString codecNameT = rx.cap(1);
qDebug() << "Codec name (1):" << codecNameT;
QTextCodec *codec = QTextCodec::codecForName(codecNameT.toUtf8());
if (codec) {
convertData = codec->toUnicode(xmlData);
} else {
qWarning() << "Codec not found (1): " << codecNameT << feedUrl;
if (codecNameT.contains("us-ascii", Qt::CaseInsensitive)) {
QString str(xmlData);
convertData = str.remove(rx.cap(0)+"\"");
}
}
} else {
if (!codecName.isEmpty()) {
qDebug() << "Codec name (2):" << codecName;
QTextCodec *codec = QTextCodec::codecForName(codecName.toUtf8());
if (codec) {
convertData = codec->toUnicode(xmlData);
codecOk = true;
} else {
qWarning() << "Codec not found (2): " << codecName << feedUrl;
}
}
if (!codecOk) {
codecOk = false;
QStringList codecNameList;
codecNameList << "UTF-8" << "Windows-1251" << "KOI8-R" << "KOI8-U"
<< "ISO 8859-5" << "IBM 866";
foreach (QString codecNameT, codecNameList) {
QTextCodec *codec = QTextCodec::codecForName(codecNameT.toUtf8());
if (codec && codec->canEncode(xmlData)) {
qDebug() << "Codec name (3):" << codecNameT;
convertData = codec->toUnicode(xmlData);
codecOk = true;
break;
}
}
if (!codecOk) {
convertData = QString::fromLocal8Bit(xmlData);
}
}
