int main()
{
BinarySearch binarySearch;
int ret = -1;
{
std::vector<int> datas;
int dest = 3;
ret = binarySearch.search(datas, dest);
LOG_IF(INFO, ret == -1) << "Case 1 Pass";
CHECK(ret == -1) << "Case 1 Failed, Dest Not Found:" << dest << " ret:" << ret;
}
{
int dataArr[] = {1};
std::vector<int> datas(dataArr, dataArr + 1);
int dest = 3;
ret = binarySearch.search(datas, dest);
LOG_IF(INFO, ret == -1) << "Case 2 Pass";
CHECK(ret == -1) << "Case 2 Failed, Dest Not Found:" << dest;
}
{
int dataArr[] = {1,2,3,4,5,6,7};
std::vector<int> datas(dataArr, dataArr + 7);
int dest = 5;
ret = binarySearch.search(datas, dest);
LOG_IF(INFO, ret == 4) << "Case 3 Pass";
CHECK(ret == 4) << "Case 3 Failed, Dest Not Found:" << dest;
}
return 0;
}
void HttpRequest::upload(const QString& aUrl, const QString& aContent, const QString& aFilePath)
{
qDebug() << "HttpRequest::upload(const QString& aUrl, const QString& aFileName)";
qDebug() << aUrl << " body is " + aFilePath.toUtf8();
if(aUrl.isEmpty())
{
return;
}
QByteArray ba;
ba.append(aUrl);
qDebug() << QUrl::fromEncoded(ba);
mRequest->setUrl(QUrl::fromEncoded(ba));
QString fileName = aFilePath.section('\\', -1);
qsrand(QDateTime::currentDateTime().toTime_t());
QString b = QVariant(qrand()).toString()+QVariant(qrand()).toString()+QVariant(qrand()).toString();
QString boundary="---------------------------" + b;
QByteArray datas(QString("--" + boundary + "\r\n").toAscii());
datas += "Content-Disposition: form-data; name=\"status\"\r\n";
datas += "Content-Transfer-Encoding: binary\r\n";
datas += "Content-Type: text/plain; charset=utf-8\r\n\r\n";
datas += aContent;
datas += "\r\n";
datas += QString("--" + boundary + "\r\n").toAscii();
datas += "Content-Disposition: form-data; name=\"media[]\"; ";
datas += "filename=\"" + fileName + "\"\r\n";
datas += "Content-Transfer-Encoding: binary\r\n";
datas += "Content-Type: image/jpeg\r\n\r\n";
qDebug() << datas;
QFile file(TwtImageScaler::scaled(aFilePath));
if (!file.open(QIODevice::ReadOnly))
{
qDebug() << "HttpRequest::upload open file failed";
return;
}
qDebug() << "HttpRequest::file name" << file.fileName();
qDebug() << "HttpRequest::file size" << file.size();
datas += file.readAll();
datas += "\r\n";
datas += QString("--" + boundary + "--\r\n").toAscii();
qDebug() << QString::number(datas.length());
file.close();
mRequest->setHeader(QNetworkRequest::ContentLengthHeader, QString::number(datas.length()));
mRequest->setHeader(QNetworkRequest::ContentTypeHeader, "multipart/form-data; boundary=" + boundary);
if(NULL != gUniqueNetwrkManager)
{
// upload file need more time
mRequestTimeoutTimer->setInterval(KRequestTimeOut*2);
mRequestTimeoutTimer->start();
mReply = gUniqueNetwrkManager->post(*mRequest, datas);
connect(mReply, SIGNAL(finished()), this, SLOT(onReplyFinished()));
}
}
highscores::highscores()
{
QFile fl("test.dat");
fl.open(QIODevice::ReadWrite);
QDataStream datas(&fl);
qltext = new QLabel("<b>Name</b><br>",this);
qlscore = new QLabel("<b>Score</b><br>",this);
qhb = new QHBoxLayout;
datas>>qvscores;
for(int i=0;i<qvscores.size();i++){
qltext->setText(qltext->text()+"<br>"+qvscores[i][0]);
qlscore->setText(qlscore->text()+"<br>"+qvscores[i][1]);
}
qhb->addWidget(qltext);
qhb->addWidget(qlscore);
this->setLayout(qhb);
fl.close();
}
void SohuMiniBlog::upload(const QString& aUrl, const QString& aFilePath)
{
qDebug() << "SohuMiniBlog::upload(const QString& aUrl, const QString& aFileName)";
qDebug() << aUrl << " body is " + aFilePath.toUtf8();
if(aUrl.isEmpty())
{
return;
}
mRequest->setUrl(QUrl(aUrl));
QString fileName = aFilePath.section('\\', -1).section('.', 0, 0);
qsrand(QDateTime::currentDateTime().toTime_t());
QString b = QVariant(qrand()).toString()+QVariant(qrand()).toString()+QVariant(qrand()).toString();
QString boundary="---------------------------" + b;
QByteArray datas(QString("--" + boundary + "\r\n").toAscii());
datas += "Content-Disposition: form-data; name=\"pic\"\r\n";
datas += "filename=\"0" + fileName.toUtf8() + ".jpeg\" Content-Type: image/jpeg\r\n\r\n";
QFile file(aFilePath);
if ( !file.open(QIODevice::ReadOnly) )
{
qDebug() << "SohuMiniBlog::upload open file failed";
return;
}
datas += file.readAll();
datas += "\r\n";
datas += QString("--" + boundary + "--\r\n").toAscii();
qDebug() << QString::number(datas.length());
mRequest->setHeader(QNetworkRequest::ContentLengthHeader, QString::number(datas.length()));
mRequest->setHeader(QNetworkRequest::ContentTypeHeader, "multipart/form-data; boundary=" + boundary);
if(NULL != gUniqueNetwrkManager)
{
mRequestTimeoutTimer->setInterval(KRequestTimeOut);
mRequestTimeoutTimer->start();
mReply = gUniqueNetwrkManager->post(*mRequest, datas);
qDebug() << "Start upload:"<<QDateTime::currentDateTime().toString();
connect(mReply, SIGNAL(finished()), this, SLOT(onReplyFinished()));
}
}
void Data<Annotation>::set_union(
std::set<Data<Annotation> *> & result_,
const std::set<Data<Annotation> *> & datas_
) {
// FIXME currently: same symbol => same data
std::vector<Data<Annotation> *> datas(datas_.begin(), datas_.end());
std::vector<Data<Annotation> *> result_in (result_.begin(), result_.end());
std::vector<Data<Annotation> *> result_out(result_.size() + datas.size());
std::sort(result_in.begin(), result_in.end(), less);
std::sort(datas.begin(), datas.end(), less);
typename std::vector<Data<Annotation> *>::iterator it_result_begin = result_out.begin();
typename std::vector<Data<Annotation> *>::iterator it_result_end = std::set_union(result_in.begin(), result_in.end(), datas.begin(), datas.end(), it_result_begin, less);
result_.clear();
result_.insert(it_result_begin, it_result_end);
}
void DataManager::generateXmlFile(){
XmlTree dataTree;
dataTree.setTag("QLT_Genome_Data");
dataTree.push_back(XmlTree("datapath","./data/exons/"));
XmlTree datas("datasets","");
for(int i=0;i<23;i++){
XmlTree dataset("dataset","");
dataset.setAttribute("id", i);
dataset.push_back( XmlTree("title","Chromosome "+toString(i+1)) );
dataset.push_back( XmlTree("map","exons."+toString(i+1)+".locations") );
dataset.push_back( XmlTree("bases","exons."+toString(i+1)+".bases") );
datas.push_back( dataset );
}
dataTree.push_back( datas );
DataTargetPathRef f = writeFile( getAssetPath( "QLT_Genome_Data.xml" ), true );
dataTree.write( f );
}
pass2()
{
exnull();
if(comments) putcomment();
if(verbose)
fprintf(diagfile, " Pass 2\n");
dclsect = 0;
indent = 0;
namegen();
dclgen();
body(iefile);
datas();
body(icfile);
p2stmt(0);
p2key(FEND);
p2flush();
if(verbose)
fprintf(diagfile, " Pass 2 done\n");
}
int main() {
{
TimeCheck time;
constexpr int WIDTH = 175;
constexpr int HEIGHT = 175;
constexpr int STRIDE = WIDTH * 4;
std::vector<unsigned char> datas(HEIGHT*STRIDE);
auto surface = create_surface(datas, CAIRO_FORMAT_ARGB32, SURFACE_SIZE{ WIDTH, HEIGHT }, STRIDE);
auto cr = create(surface);
rectangle(cr, POINT{ 0,0 }, SIZE{ WIDTH, HEIGHT });
source(cr, RGB{ 0,0,0 });
fill(cr);
draw(cr, WIDTH, HEIGHT);
write_to_png(surface, "image.png");
}
return 0;
}
TreeList * FunctionListModel::insertFunction (const QString &name,const QString &prototype,const QString &filename,long start_line_org,long end_line_org,long start_line_pre,long start_column_pre,long end_line_pre, long end_column_pre,bool reference)
{
TreeList *item_p=NULL;
QStringList name_list = name.split("::");
int count=name_list.size();
int name_list_id=1;
TreeList *parent_p=rootItem;
for ( QStringList::const_iterator it = name_list.begin(); it != name_list.end(); ++it )
{
if (name_list_id==count)
{ /* Last Element */
if ( ! (item_p=findFunction(parent_p,*it,prototype) ) )
{ /* create new entry */
QVector <QVariant> datas(ITEM_MAX);
datas[ITEM_FILE_NAME_REF] = QString();
datas[ITEM_START_LINE_REF] = -1;
datas[ITEM_START_COLUMN_REF] = -1;
datas[ITEM_END_LINE_REF] = -1;
datas[ITEM_END_COLUMN_REF] = -1;
datas[ITEM_FILE_NAME] = QString();
datas[ITEM_START_LINE] = -1;
datas[ITEM_START_COLUMN] = -1;
datas[ITEM_END_LINE] = -1;
datas[ITEM_END_COLUMN] = -1;
datas[ITEM_FUNCTION] = false;
datas[ITEM_DESCRIPTION] = QString();
datas[ITEM_NB_TESTED]= QVariant();
datas[ITEM_NB_UNTESTED]= QVariant();
datas[ITEM_NAME]=*it;
item_p=new TreeList(datas,parent_p);
/* insert the row in the model */
QModelIndex parent_index;
if (item_p->parent()!=rootItem)
parent_index=createIndex(item_p->parent()->row(),0,item_p->parent());
}
item_p->setData(ITEM_FUNCTION, true);
item_p->setData(ITEM_DESCRIPTION, prototype);
item_p->setData(ITEM_NB_TESTED,QVariant());
item_p->setData(ITEM_NB_UNTESTED,QVariant());
if (reference)
{
item_p->setData(ITEM_FILE_NAME_REF, filename);
item_p->setData(ITEM_START_LINE_REF_ORIG, static_cast<int>(start_line_org));
item_p->setData(ITEM_END_LINE_REF_ORIG, static_cast<int>(end_line_org));
item_p->setData(ITEM_START_LINE_REF, static_cast<int>(start_line_pre));
item_p->setData(ITEM_START_COLUMN_REF, static_cast<int>(start_column_pre));
item_p->setData(ITEM_END_LINE_REF, static_cast<int>(end_line_pre));
item_p->setData(ITEM_END_COLUMN_REF, static_cast<int>(end_column_pre));
}
else
{
item_p->setData(ITEM_FILE_NAME, filename);
item_p->setData(ITEM_START_LINE_ORIG, static_cast<int>(start_line_org));
item_p->setData(ITEM_END_LINE_ORIG, static_cast<int>(end_line_org));
item_p->setData(ITEM_START_LINE, static_cast<int>(start_line_pre));
item_p->setData(ITEM_START_COLUMN, static_cast<int>(start_column_pre));
item_p->setData(ITEM_END_LINE, static_cast<int>(end_line_pre));
item_p->setData(ITEM_END_COLUMN, static_cast<int>(end_column_pre));
}
}
else
{
if ( ! (item_p=findFunction(parent_p,*it,QString()) ) )
{ /* create new entry */
QVector <QVariant> datas(ITEM_MAX);
datas[ITEM_FILE_NAME_REF] = QString();
datas[ITEM_START_LINE_REF] = -1;
datas[ITEM_START_LINE_REF_ORIG] = -1;
datas[ITEM_END_LINE_REF_ORIG] = -1;
datas[ITEM_START_LINE_ORIG] = -1;
datas[ITEM_END_LINE_ORIG] = -1;
datas[ITEM_START_COLUMN_REF] = -1;
datas[ITEM_END_LINE_REF] = -1;
datas[ITEM_END_COLUMN_REF] = -1;
datas[ITEM_FILE_NAME] = QString();
datas[ITEM_START_LINE] = -1;
datas[ITEM_START_COLUMN] = -1;
datas[ITEM_END_LINE] = -1;
datas[ITEM_END_COLUMN] = -1;
datas[ITEM_FUNCTION] = false;
datas[ITEM_DESCRIPTION] = QString();
datas[ITEM_NB_TESTED]= QVariant();
datas[ITEM_NB_UNTESTED]= QVariant();
datas[ITEM_NAME]=*it;
item_p=new TreeList(datas,parent_p);
/* insert the row in the model */
QModelIndex parent_index;
if (item_p->parent()!=rootItem)
parent_index=createIndex(item_p->parent()->row(),0,item_p->parent());
}
}
parent_p=item_p;
name_list_id++;
}
return item_p;
}
int main() {
{
TimeCheck time;
constexpr int WIDTH = 450;
constexpr int HEIGHT = 900;
constexpr int STRIDE = WIDTH * 4;
std::vector<unsigned char> datas(HEIGHT*STRIDE);
auto surface = create_surface(datas, CAIRO_FORMAT_ARGB32, SURFACE_SIZE{ WIDTH, HEIGHT }, STRIDE);
auto cr = create(surface);
rectangle(cr, POINT{ 0,0 }, SIZE{ WIDTH ,HEIGHT });
source(cr, RGB{ 1,1,1 });
fill(cr);
source(cr, RGB{ 0,0,0 });
font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
font_size(cr, 40);
translate(cr, POINT{ 40, 40 });
font_face(cr, u8"mono", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
font_size(cr, 12);
show_text(cr, u8"+CTM rotation");
constexpr auto NUM_STRINGS = 3;
save(cr);
{
font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
font_size(cr, 40);
for (int i = 0; i < NUM_STRINGS; ++i) {
RADIAN angle{ i * 0.5*pi<double> / double(NUM_STRINGS - 1) };
save(cr);
rotate(cr, angle);
move_to(cr, POINT{ 100, 0 });
show_text(cr, u8"Text");
restore(cr);
}
}
restore(cr);
translate(cr, POINT{ 0, HEIGHT / 3 });
move_to(cr, POINT{ 0, 0 });
show_text(cr, u8"+CTM rotation");
rel_move_to(cr, POINT{ 0, 12 });
show_text(cr, u8"-font rotation");
save(cr);
font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
font_size(cr, 40);
{
cairo_matrix_t mat{};
for (int i = 0; i < NUM_STRINGS; ++i) {
RADIAN angle{ i * 0.5*pi<double> / double(NUM_STRINGS - 1) };
save(cr);
rotate(cr, angle);
identity(mat);
scale(mat, SCALE{ 40,40 });
rotate(mat, -angle);
font_matrix(cr, mat);
move_to(cr, POINT{ 100, 0 });
show_text(cr, u8"Text");
restore(cr);
}
}
restore(cr);
translate(cr, POINT{ 0, HEIGHT / 3 });
move_to(cr, POINT{ 0, 0 });
show_text(cr, u8"+CTM rotation");
rel_move_to(cr, POINT{ 0, 12 });
show_text(cr, u8"-CTM rotation");
save(cr);
font_face(cr, u8"serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
font_size(cr, 40);
{
for (int i = 0; i < NUM_STRINGS; ++i) {
RADIAN angle{ i * 0.5*pi<double> / double(NUM_STRINGS - 1) };
save(cr);
rotate(cr, angle);
move_to(cr, POINT{ 100, 0 });
rotate(cr, -angle);
show_text(cr, u8"Text");
restore(cr);
}
}
restore(cr);
write_to_png(surface, "image.png");
}
return 0;
}
/**
* Gets the response from the STUN server, checks it for its validity and
* then parses the answer into address and port
* \return "" if the address could be parsed or an error message
*/
std::string GetPublicAddress::parseStunResponse()
{
TransportAddress sender;
const int LEN = 2048;
char buffer[LEN];
int len = m_transaction_host->receiveRawPacket(buffer, LEN, &sender, 2000);
if(sender.getIP()!=m_stun_server_ip)
{
TransportAddress stun(m_stun_server_ip, m_stun_server_port);
Log::warn("GetPublicAddress",
"Received stun response from %s instead of %s.",
sender.toString().c_str(), stun.toString().c_str());
}
if (len<0)
return "STUN response contains no data at all";
// Convert to network string.
NetworkString datas((uint8_t*)buffer, len);
// check that the stun response is a response, contains the magic cookie
// and the transaction ID
if (datas.getUInt16() != 0x0101)
return "STUN response doesn't contain the magic cookie";
int message_size = datas.getUInt16();
if (datas.getUInt32() != m_stun_magic_cookie)
{
return "STUN response doesn't contain the magic cookie";
}
for (int i = 0; i < 12; i++)
{
if (datas.getUInt8() != m_stun_tansaction_id[i])
return "STUN response doesn't contain the transaction ID";
}
Log::debug("GetPublicAddress",
"The STUN server responded with a valid answer");
// The stun message is valid, so we parse it now:
if (message_size == 0)
return "STUN response does not contain any information.";
if (message_size < 4) // cannot even read the size
return "STUN response is too short.";
// Those are the port and the address to be detected
int pos = 20;
while (true)
{
int type = datas.getUInt16();
int size = datas.getUInt16();
if (type == 0 || type == 1)
{
assert(size == 8);
datas.getUInt8(); // skip 1 byte
assert(datas.getUInt8() == 0x01); // Family IPv4 only
uint16_t port = datas.getUInt16();
uint32_t ip = datas.getUInt32();
TransportAddress address(ip, port);
// finished parsing, we know our public transport address
Log::debug("GetPublicAddress",
"The public address has been found: %s",
address.toString().c_str());
NetworkConfig::get()->setMyAddress(address);
break;
} // type = 0 or 1
datas.skip(4 + size);
message_size -= 4 + size;
if (message_size == 0)
return "STUN response is invalid.";
if (message_size < 4) // cannot even read the size
return "STUN response is invalid.";
} // while true
return "";
} // parseStunResponse
void run()
{
while(!this->pollfds.empty())
{
int r = 0;
std::vector<pollfd> pollfds(this->pollfds.begin(), this->pollfds.end());
std::vector<filter_data> datas(this->datas.begin(), this->datas.end());
do
{
r = poll(&pollfds[0], pollfds.size(), 1000);
} while (r == -1 && errno == EINTR);
if(r == -1)
{
std::cout << "Failed reading poll with errno: " << errno << std::endl;
throw std::runtime_error ("Failed poll'ing");
}
boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();
for(std::vector<pollfd>::iterator first = pollfds.begin()
, last = pollfds.end(); first != last; ++first)
{
if(first->revents & POLLIN)
{
datas[std::distance(pollfds.begin(), first)].idle_time = now;
std::cout << "Can read from " << std::distance(pollfds.begin(), first) << std::endl;
unsigned char buffer[188*1000];
int size = 0;
do
{
size = read(first->fd, buffer, sizeof(buffer));
} while(size == -1 && errno == EINTR);
if(size == -1 && errno == EOVERFLOW)
{
std::cout << "Data overflow" << std::endl;
}
else if(size == -1)
{
std::cout << "Error reading data" << std::endl;
throw std::runtime_error("Error reading data");
}
datas[std::distance(pollfds.begin(), first)].callback(buffer, size, first->fd);
}
else if(now - datas[std::distance(pollfds.begin(), first)].idle_time >= boost::posix_time::minutes(1))
{
std::cout << "Marking Timeout after " << (now - datas[std::distance(pollfds.begin(), first)].idle_time) << " time elapsed" << std::endl;
datas[std::distance(pollfds.begin(), first)].timeout = true;
}
}
std::vector<filter_data>::const_iterator data_first = datas.begin()
, data_last = datas.end();
std::vector<pollfd>::const_iterator poll_first = pollfds.begin();
while(data_first != data_last)
{
std::size_t i = 0;
for(std::list<pollfd>::iterator mutable_it = this->pollfds.begin()
, mutable_end_it = this->pollfds.end(); mutable_it != mutable_end_it
;++mutable_it, ++i)
{
if(poll_first->fd == mutable_it->fd)
{
if(data_first->timeout)
{
this->datas.erase(boost::next(this->datas.begin(), i));
this->pollfds.erase(mutable_it);
break;
}
else
boost::next(this->datas.begin(), i)->idle_time = data_first->idle_time;
}
}
++data_first;
++poll_first;
}
assert(this->pollfds.size() == this->datas.size());
}
}
