TEST (json, fetch_object)
{
std::string string1 ("{ \"thing\": \"junktest\" }");
std::stringstream stream1 (string1);
json_upgrade_test object1;
auto error1 (rai::fetch_object (object1, stream1));
ASSERT_FALSE (error1);
ASSERT_EQ ("changed", object1.text);
boost::property_tree::ptree tree1;
stream1.seekg (0);
boost::property_tree::read_json (stream1, tree1);
ASSERT_EQ ("changed", tree1.get <std::string> ("thing"));
std::string string2 ("{ \"thing\": \"junktest2\" }");
std::stringstream stream2 (string2);
json_upgrade_test object2;
auto error2 (rai::fetch_object (object2, stream2));
ASSERT_FALSE (error2);
ASSERT_EQ ("junktest2", object2.text);
ASSERT_EQ ("{ \"thing\": \"junktest2\" }", string2);
std::string string3 ("{ \"thing\": \"error\" }");
std::stringstream stream3 (string3);
json_upgrade_test object3;
auto error3 (rai::fetch_object (object3, stream3));
ASSERT_TRUE (error3);
std::fstream stream4;
rai::open_or_create (stream4, rai::unique_path().string());
json_upgrade_test object4;
auto error4 (rai::fetch_object (object4, stream4));
ASSERT_FALSE (error4);
ASSERT_EQ ("created", object4.text);
boost::property_tree::ptree tree2;
stream4.seekg (0);
boost::property_tree::read_json (stream4, tree2);
ASSERT_EQ ("created", tree2.get <std::string> ("thing"));
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
printf("Please Input Process Num :\n");
int Pnumber;
QTextStream stream(stdin);
stream >> Pnumber;
printf("Please Input fileBase Num :\n");
int fileBaseNum;
QTextStream stream1(stdin);
stream1 >> fileBaseNum;
printf("Please Input fileSize (kB) :\n");
int fileSize;
QTextStream stream2(stdin);
stream2 >> fileSize;
readConfig read;
QString program = read.map["writeFileEXE"] ;
QTime timer;
timer.start();
CreateProcess Cprocess(Pnumber, fileBaseNum, program, fileSize, timer);
Cprocess.clear_pro();
return 0;
}
QMimeData* KexiFieldListModel::mimeData(const QModelIndexList& indexes) const
{
if (!d->schema) {
return new QMimeData();
}
QString sourceMimeType;
QString sourceName;
QStringList fields;
QMimeData *mimedata = new QMimeData();
QByteArray fielddata;
QDataStream stream1(&fielddata, QIODevice::WriteOnly);
if (d->schema->table()) {
sourceMimeType = "kexi/table";
} else if (d->schema->query()) {
sourceMimeType = "kexi/query";
}
sourceName = d->schema->name();
foreach (const QModelIndex &idx, indexes) {
fields << data(idx, Qt::DisplayRole).toString();
}
void Ventana_Principal::AnalisisJSON()
{
Pestana *actual = (Pestana*)ui->tabWidget->currentWidget();
if(actual != NULL){
QFile file("temp.txt"); //SE CREA UN ARCHIVO TEMPORAL PARA COMPILARLO
if ( file.open( file.WriteOnly ) ) { //BUFFER PARA EL TEXTO QUE SE DESEA COMPILAR
QTextStream stream1( &file );
stream1 << actual->enviar_texto();
}
const char* x = "temp.txt";
FILE* input = fopen(x, "r" );
errores_json->ven()->clear();
SetVentanita_json(errores_json->ven());
setFila();
setColumna();
setEdit(actual->textedit());
yyrestart(input);//SE PASA LA CADENA DE ENTRADA A FLEX
yyparse();//SE INICIA LA COMPILACION
ArbolJ *nuevo = setArbolito();
if(nuevo != NULL && correctojson() != 1){
//nuevo->Dibujar();
}
}
}
void tst_QContactRelationship::datastream()
{
QSKIP("Datastream is not currently supported when using the QContactIdMock class");
//After QContactId introduction, the QCOMPARE at then end this case will fail, since
//relationshipOut will contain contacts with "null" QContactIds, whereas
//relationshipIn will contain contacts with QContactIds referring to
//manager "a", which is an invalid one.
QByteArray buffer;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
QContactRelationship relationshipIn;
QContact contact1;
contact1.setId(QContactIdMock::createId("a", 1));
relationshipIn.setFirst(contact1);
QContact contact2;
contact2.setId(QContactIdMock::createId("a", 2));
relationshipIn.setSecond(contact2);
relationshipIn.setRelationshipType(QContactRelationship::HasMember());
stream1 << relationshipIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
QContactRelationship relationshipOut;
stream2 >> relationshipOut;
QCOMPARE(relationshipOut, relationshipIn);
}
int main() {
//get camera stream
VideoCapture stream1(countCameras()); //id of video device
if (!stream1.isOpened()) {
cout << "cannot open camera";
}
//load up face detection
String face_cascade_name = "haarcascade_frontalface_alt.xml";
if(!face_cascade.load(face_cascade_name)){
cout << "Could not find face cascade file: " + face_cascade_name + "\n";
return -1;
}
//load lookup tables
calcGradientLookup();
//loop forever
while (true) {
Mat cameraFrame;
stream1.read(cameraFrame);
getGazePosition(cameraFrame);
if (waitKey(30) >= 0)
break;
}
return 0;
}
/**
Opens the exported file and compares it with expected vCard file passed as argument.
*/
void CCntPBAPSupport::CompareFilesL(RReadStream& aCompareStream)
{
RFile exportedFile;
TInt err = exportedFile.Open(iFsSession, KTempExportFile(), EFileRead);
if (err != KErrNone)
{
ReportFileErrorL(err, KTempExportFile());
}
CleanupClosePushL(exportedFile);
RFileReadStream stream1(exportedFile);
CleanupClosePushL(stream1);
TBuf8<0x80> bufO,bufC;
TInt line = 1;
do {
TRAP(err, stream1.ReadL(bufO, TChar(0xa)));
if (err == KErrNone || err == KErrEof)
{
TRAP(err, aCompareStream.ReadL(bufC, TChar(0xa)));
}
if (err != KErrNone && err != KErrEof)
{
User::Leave(err);
}
test(CompareLines(bufO, bufC));
++line;
} while (err != KErrEof);
CleanupStack::PopAndDestroy(2,&exportedFile);
}
// Test asynchronous HTTP with an error status returned by the server.
void read_stream_asynchronous_http_not_found_test()
{
http_server server;
std::string port = boost::lexical_cast<std::string>(server.port());
std::string request =
"GET / HTTP/1.0\r\n"
"Host: localhost:" + port + "\r\n"
"Accept: */*\r\n"
"Connection: close\r\n\r\n";
std::string response =
"HTTP/1.0 404 Not Found\r\n"
"Content-Length: 9\r\n"
"Content-Type: text/plain\r\n\r\n";
std::string content = "Not Found";
server.start(request, 0, response, 0, content);
boost::asio::io_service io_service;
urdl::read_stream stream1(io_service);
boost::system::error_code ec;
std::size_t bytes_transferred = 0;
handler h = { ec, bytes_transferred };
stream1.async_open("http://localhost:" + port + "/", h);
io_service.run();
bool request_matched = server.stop();
BOOST_CHECK(request_matched);
BOOST_CHECK(ec == urdl::http::errc::not_found);
}
void DigManager::shortDigAnswer(const QStringList hostname, QByteArray bufferData, QByteArray bufferError)
{
Q_UNUSED(hostname);
/*
* TODO: remove this check with QT5 QStandardPaths::findExecutable.
*
*/
if (!bufferData.size() && bufferError.size()) {
qWarning() << "Error: Dig is not installed.";
return;
}
QString buff1(bufferData);
QTextStream stream1(&buff1);
QString line;
m_elemObjUtil->setHostName(m_hostNameLocal);
while (!stream1.atEnd()) {
line = stream1.readLine();
m_elemObjUtil->setInfoLookup(line);
}
// clear thread
bufferData.clear();
bufferError.clear();
}
/** Compares two files, excluding the REV property, as it doesn't remain the same always
@param aExpectedFile The expected vcf file
@param aFile This is the vcf file produced, and will be compared against aExpectedFile
*/
TBool CTestCompareCntFiles::CompareWholeFileL(const TDesC& aExpectedFile, const TDesC& aFile)
{
User::LeaveIfError(iFsSession.Connect());
CleanupClosePushL(iFsSession);
RFile fileExpected;
RFile fileOutput;
CleanupClosePushL(fileExpected);
CleanupClosePushL(fileOutput);
TInt err;
err = fileExpected.Open(iFsSession, aExpectedFile, EFileRead);
if (err != KErrNone)
{
User::Leave(err);
}
err = fileOutput.Open(iFsSession, aFile, EFileWrite);
if (err != KErrNone)
{
User::Leave(err);
}
RFileReadStream stream1(fileExpected);
RFileReadStream stream2(fileOutput);
CleanupClosePushL(stream1);
CleanupClosePushL(stream2);
TBuf8<0x80> bufO,bufC;
TBool flag = ETrue;
TInt line = 1;
do
{
TRAP(err, stream1.ReadL(bufO, KLinefeedChar));
if (err == KErrNone || err == KErrEof)
TRAP(err, stream2.ReadL(bufC, KLinefeedChar));
if (err != KErrNone && err != KErrEof)
User::Leave(err);
if (CompareLine(bufO, bufC) == EFalse)
{
flag = EFalse;
break;
}
++line;
}
while (err != KErrEof);
CleanupStack::PopAndDestroy(4, &fileExpected);
CleanupStack::PopAndDestroy(&iFsSession);
iFsSession.Close();
if(flag)
{
return ETrue;
}
else
{
return EFalse;
}
}
// Test synchronous HTTP.
void read_stream_synchronous_http_test()
{
http_server server;
std::string port = boost::lexical_cast<std::string>(server.port());
std::string request =
"GET / HTTP/1.0\r\n"
"Host: localhost:" + port + "\r\n"
"Accept: */*\r\n"
"Connection: close\r\n\r\n";
std::string response =
"HTTP/1.0 200 OK\r\n"
"Content-Length: 13\r\n"
"Content-Type: text/plain\r\n\r\n";
std::string content = "Hello, World!";
server.start(request, 0, response, 0, content);
boost::asio::io_service io_service;
urdl::read_stream stream1(io_service);
stream1.open("http://localhost:" + port + "/");
std::string returned_content(stream1.content_length(), 0);
boost::asio::read(stream1, boost::asio::buffer(
&returned_content[0], returned_content.size()));
bool request_matched = server.stop();
BOOST_CHECK(request_matched);
BOOST_CHECK(stream1.content_type() == "text/plain");
BOOST_CHECK(stream1.content_length() == 13);
BOOST_CHECK(returned_content == content);
}
details::details(QWidget *parent) :
QDialog(parent),
ui(new Ui::details)
{
ui->setupUi(this);
this->setWindowTitle("TICKET CONFIRMED!!!");
QString filename="D:\\qt\\irctc3\\p-detail.txt";
QFile file(filename);
if(!file.exists()){
qDebug() << "NO exist "<<filename;
}else{
qDebug() << filename<<" exits...";
}
QString line;
QString name,age,gender;
int i=0;
ui->label->setText(ui->label->text()+"\nS.No.\tName\tAge\tGender\n");
if (file.open(QIODevice::ReadOnly | QIODevice::Text)){
QTextStream stream(&file);
while (!stream.atEnd()){
line = stream.readLine();
name = line.split(" ").at(0);
age = line.split(" ").at(1);
gender=line.split(" ").at(2);
i++;
ui->label->setText(ui->label->text()+"\n"+QString::number(i)+"\t"+name+"\t"+age+"\t"+gender);
}
}
file.close();
QString src,dst,date,arr_time,fare,avail,train_no,train_name,day;
QString filename1="D:\\qt\\irctc3\\select.txt";
QFile file1(filename1);
if(!file1.exists()){
qDebug() << "NO exist "<<filename1;
}else{
qDebug() << filename1<<" exits...";
}
QString line1;
if (file1.open(QIODevice::ReadOnly | QIODevice::Text)){
QTextStream stream1(&file1);
while (!stream1.atEnd()){
line1 = stream1.readLine();
train_no= line1.split(" ").at(0);
train_name= line1.split(" ").at(1);
arr_time= line1.split(" ").at(2);
avail= line1.split(" ").at(3);
fare= line1.split(" ").at(4);
}
}
file1.close();
int f=fare.toInt();
f=(i)*f;
ui->label->setText(ui->label->text()+"\n\nFare Details:\nTicket Fare: "+QString ::number(f)+"\nService Charge: 22.90\ntotal Fare: "+QString :: number(f+22.9) );
}
void ImageWidget::readImageInfo()
{
int nn = socket->bytesAvailable();
if(bytesReceived <= 0)
{
if(socket->bytesAvailable() > 0)
{
info = new ImageInfo();
bytesReceived = socket->bytesAvailable();
QByteArray tt = socket->readAll();
QByteArray bt = tt.left(8);
QDataStream stream1(bt);
qint64 infosize;
stream1 >>infosize;
tt.remove(0,8);
QByteArray ct = tt.left(8);
QDataStream stream2(ct);
stream2 >>totalBytes;
tt.remove(0,8);
QByteArray infoData = tt.left((int)infosize);
tt.remove(0,(int)infosize);
QString readData = QString::fromUtf8(infoData);
QStringList ColumnList = readData.split(":");
info->id = ColumnList.at(0);
info->title = ColumnList.at(1);
info->size = ColumnList.at(2);
info->path = ColumnList.at(3);
info->bm = tt;
if(bytesReceived == totalBytes)
{
socket->disconnectFromHost();
imageInfoList.append(*info);
insertTableRow(*info);
currentNum++;
if(currentNum < imageCount)
{
ui->progressBar->setValue(currentNum);
GetImageInfo(currentNum);
}else{
disconnect(socket,SIGNAL(readyRead()),this,SLOT(readImageInfo()));
connect(playlist,SIGNAL(clicked(QModelIndex)),this,SLOT(ImageChange(QModelIndex)));
connect(playlist, SIGNAL(cellChanged(int,int)), this, SLOT(CheckBoxChanged(int, int)));
ui->progressBar->hide();
}
}
}
void tst_QContactDetail::datastream()
{
QByteArray buffer;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
QContactDetail detailIn("definition");
detailIn.setValue("key1", "value1");
detailIn.setValue("key2", "value2");
stream1 << detailIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
QContactDetail detailOut;
stream2 >> detailOut;
QCOMPARE(detailOut, detailIn);
}
TEST (message, confirm_ack_serialization)
{
rai::keypair key1;
auto vote (std::make_shared<rai::vote> (key1.pub, key1.prv, 0, std::unique_ptr<rai::block> (new rai::send_block (0, 1, 2, key1.prv, 4, 5))));
rai::confirm_ack con1 (vote);
std::vector<uint8_t> bytes;
{
rai::vectorstream stream1 (bytes);
con1.serialize (stream1);
}
rai::bufferstream stream2 (bytes.data (), bytes.size ());
bool error;
rai::message_header header (error, stream2);
rai::confirm_ack con2 (error, stream2, header);
ASSERT_FALSE (error);
ASSERT_EQ (con1, con2);
}
void CCntPBAPSupport::CompareExportsL(const TDesC8& aExpected)
{
RFile exportedFile;
TInt err = exportedFile.Open(iFsSession, KTempExportFile(), EFileRead);
if (err != KErrNone)
{
ReportFileErrorL(err, KTempExportFile());
}
CleanupClosePushL(exportedFile);
RFileReadStream stream1(exportedFile);
CleanupClosePushL(stream1);
TBuf8<0x80> bufO;
TInt line = 1;
do {
TRAP(err, stream1.ReadL(bufO, TChar(0xa)));
if (err != KErrNone && err != KErrEof)
{
User::Leave(err);
}
_LIT8(KPropREV,"REV:");
_LIT8(KPropUID,"UID:");
TBufC8<4> first4char(bufO.Left(4));
if(!first4char.Compare(KPropREV()) || !first4char.Compare(KPropUID()))
{
continue;
}
if (KErrNotFound == aExpected.Find(bufO))
{
TBuf<256> info;
info.Copy(bufO);
TRefByValue<const TDesC> format(info);
test.Printf(format);
test (EFalse);
}
++line;
} while (err != KErrEof);
CleanupStack::PopAndDestroy(2,&exportedFile);
}
void CAgentTest::CompareFilesL(const TDesC& aOutputFile,const TDesC& aCompareFile)
{
RFs fsSession;
User::LeaveIfError(fsSession.Connect());
RFile file1,file2;
TInt err=file1.Open(fsSession, aOutputFile, EFileRead);
if (err!=KErrNone)
{
User::Leave(err);
}
CleanupClosePushL(file1);
err=file2.Open(fsSession, aCompareFile, EFileRead);
if (err!=KErrNone)
{
User::Leave(err);
}
CleanupClosePushL(file2);
RFileReadStream stream1(file1);
RFileReadStream stream2(file2);
CleanupClosePushL(stream1);
CleanupClosePushL(stream2);
TBuf8<0x80> bufO,bufC;
TInt line=1;
do {
TRAP(err,stream1.ReadL(bufO,TChar(0xa)));
if (err==KErrNone || err==KErrEof)
{
TRAP(err,stream2.ReadL(bufC,TChar(0xa)));
}
if (err!=KErrNone && err!=KErrEof)
{
User::Leave(err);
}
CompareLines(bufO, bufC);
++line;
} while (err!=KErrEof);
CleanupStack::PopAndDestroy(4,&file1);
}
void Ventana_Principal::AnalisisJSLT()
{
Pestana *actual = (Pestana*)ui->tabWidget->currentWidget();
if(actual != NULL){
QFile file("temp2.txt"); //SE CREA UN ARCHIVO TEMPORAL PARA COMPILARLO
if ( file.open( file.WriteOnly ) ) { //BUFFER PARA EL TEXTO QUE SE DESEA COMPILAR
QTextStream stream1( &file );
stream1 << actual->enviar_texto();
}
//INICIO DE AUTOCOMPLETADO
completer->setModel(modelFromFile("/home/jerduar/COMPI2/palabras.txt"));
completer->setModelSorting(QCompleter::CaseInsensitivelySortedModel);
completer->setCaseSensitivity(Qt::CaseInsensitive);
completer->setWrapAround(false);
actual->setCompleter(completer);
const char* x = "temp2.txt";
FILE* input = fopen(x, "r" );
this->errores->ven()->clear();
SetVentana(this->errores->ven());
SetVentanita(this->errores->ven());
jjsetFila();
jjsetColumna();
setEdit_jslt(actual->textedit());
jjrestart(input);//SE PASA LA CADENA DE ENTRADA A FLEX
jjparse();//SE INICIA LA COMPILACION
ArbolAST *nuevo;
nuevo = setArbol();
if(nuevo != NULL){
//nuevo->Dibujar();
}else{
//QMessageBox::information(this,"ÁRBOL","El árbol es nulo");
}
}
}
int main()
{
typedef std::vector< copy_ptr<process_data> >::iterator iterator;
assert(spawn_status::last_value == GEPD::ExitStatus::min);
int const timeout = -1; // milliseconds
realloc_ptr<unsigned char> erlang_buffer(32768, 4194304); // 4MB
realloc_ptr<unsigned char> stream1(1, 16384);
realloc_ptr<unsigned char> stream2(1, 16384);
int status;
if ((status = GEPD::init()))
return status;
int count;
while ((status = GEPD::wait(count, timeout, erlang_buffer,
stream1, stream2)) == GEPD::ExitStatus::ready)
{
iterator itr = processes.begin();
while (itr != processes.end() && count > 0)
{
if ((status = (*itr)->check(count, erlang_buffer)))
{
if (status != GEPD::ExitStatus::error_HUP)
return status;
if ((status = (*itr)->flush(count, erlang_buffer)))
return status;
iterator const dead = itr;
(*dead)->close();
for (++itr; itr != processes.end(); ++itr)
(*itr)->shift();
itr = processes.erase(dead);
}
else
{
++itr;
}
}
}
return status;
}
void tst_QContactRelationship::datastream()
{
QByteArray buffer;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
QContactRelationship relationshipIn;
QContactId id1;
id1.setManagerUri("a");
id1.setLocalId(1);
relationshipIn.setFirst(id1);
QContactId id2;
id2.setManagerUri("b");
id2.setLocalId(2);
relationshipIn.setSecond(id2);
relationshipIn.setRelationshipType(QContactRelationship::HasMember);
stream1 << relationshipIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
QContactRelationship relationshipOut;
stream2 >> relationshipOut;
QCOMPARE(relationshipOut, relationshipIn);
}
Trampoline AmbTest(Search &s)
{
CapturedVar<int> n, m;
CapturedCont c1, c2, c3;
UncountedCont c1_u = c1, c2_u = c2, c3_u = c3;
combine_refs(c1, c2, c3);
//note it can't safely use Search inside of functions that return a value
*c1 = [=](Search &s) { return stream1(s, n, trampoline(c2_u, s)); };
*c2 = [=](Search &s) { return stream2(s, m, trampoline(c3_u, s)); };
*c3 = [=](Search &s)
{
if (*n != *m) return s.fail();
else {
s.results.insert_or_assign("n", *n);
s.results.insert_or_assign("m", *m);
return end_search;
}
};
cout << c1.get()->use_count() << endl;
cout << c2.get()->use_count() << endl;
cout << c3.get()->use_count() << endl;
return trampoline(c1, s);
}
void tst_QOrganizerCollection::datastream()
{
// collection datastreaming
QByteArray buffer;
QOrganizerCollection collectionIn;
collectionIn.setMetaData("key", "value");
QOrganizerCollection collectionOut;
QOrganizerCollectionId originalId;
// first, stream an item with a complete id
{
QDataStream stream1(&buffer, QIODevice::WriteOnly);
QOrganizerManager om("memory");
QVERIFY(om.saveCollection(&collectionIn)); // fill in its ID
originalId = collectionIn.id();
stream1 << collectionIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> collectionOut;
QCOMPARE(collectionOut, collectionIn); // can use QCOMPARE for collections, since no detail keys.
}
// second, stream an item with an id with the mgr uri set, local id null
{
QDataStream stream1(&buffer, QIODevice::WriteOnly);
collectionIn.setId(QOrganizerCollectionId());
stream1 << collectionIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> collectionOut;
QCOMPARE(collectionOut, collectionIn); // can use QCOMPARE for collections, since no detail keys.
}
/* TODO: Review tests
// third, stream an item with an id with the mgr uri null, local id set
{
QDataStream stream1(&buffer, QIODevice::WriteOnly);
QOrganizerCollectionId modifiedId = originalId;
modifiedId.setManagerUri(QString()); // this will clear the local id!
modifiedId.setId(originalId.localId()); // so reset it and make sure nothing bad happens.
collectionIn.setId(modifiedId);
stream1 << collectionIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> collectionOut;
QVERIFY(collectionOut.metaData() == collectionIn.metaData());
QVERIFY(collectionOut.id() != collectionIn.id()); // no manager uri of input :. won't be serialized.
}*/
// fourth, stream an item with a null id
{
QDataStream stream1(&buffer, QIODevice::WriteOnly);
collectionIn.setId(QOrganizerCollectionId());
stream1 << collectionIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> collectionOut;
QVERIFY(collectionOut.metaData() == collectionIn.metaData());
QVERIFY(collectionOut.id() == collectionIn.id()); // should both be null ids.
}
// id datastreaming
buffer.clear();
QOrganizerCollectionId inputId;
QOrganizerCollectionId outputId;
// first, stream the whole id (mgr uri set, local id set)
{
inputId = originalId;
QString serializedId = inputId.toString();
outputId = QOrganizerCollectionId::fromString(serializedId);
QCOMPARE(inputId, outputId);
inputId = originalId;
buffer.clear();
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << inputId;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> outputId;
QCOMPARE(inputId, outputId);
}
/* TODO: review test
// second, stream a partial id (mgr uri null, local id set)
{
inputId.setManagerUri(QString());
inputId.setId(originalId.localId());
buffer.clear();
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << inputId;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> outputId;
// because the manager uri is null, we cannot stream it in.
QVERIFY(outputId.isNull());
QVERIFY(!inputId.isNull());
}
// third, stream a partial id (mgr uri set, local id null).
{
inputId.setManagerUri(originalId.managerUri());
inputId.setId(QOrganizerCollectionId());
buffer.clear();
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << inputId;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> outputId;
QCOMPARE(inputId, outputId);
}*/
// fourth, stream a null id
{
inputId = QOrganizerCollectionId();
QString serializedId = inputId.toString();
outputId = QOrganizerCollectionId::fromString(serializedId);
QCOMPARE(inputId, outputId);
inputId = QOrganizerCollectionId();
buffer.clear();
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << inputId;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> outputId;
QCOMPARE(inputId, outputId);
}
/* TODO: review test
// fifth, stream an id after changing it's manager uri.
{
inputId.setManagerUri(originalId.managerUri());
inputId.setId(originalId.localId());
inputId.setManagerUri("test manager uri"); // should clear the local id.
QVERIFY(inputId.localId() == QOrganizerCollectionId());
buffer.clear();
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << inputId;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> outputId;
QCOMPARE(inputId, outputId);
}
// sixth, stream an id after changing it's manager uri and resetting the local id.
// this should cause great problems, because the manager doesn't exist so it shouldn't
// be able to deserialize. Make sure it's handled gracefully.
{
inputId.setManagerUri(originalId.managerUri());
inputId.setManagerUri("test manager uri"); // should clear the local id.
inputId.setId(originalId.localId());
buffer.clear();
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << inputId;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> outputId;
QVERIFY(outputId.isNull());
} */
}
DEF_TEST(FILEStreamWithOffset, r) {
if (GetResourcePath().isEmpty()) {
return;
}
SkString filename = GetResourcePath("images/baby_tux.png");
SkFILEStream stream1(filename.c_str());
if (!stream1.isValid()) {
ERRORF(r, "Could not create SkFILEStream from %s", filename.c_str());
return;
}
REPORTER_ASSERT(r, stream1.hasLength());
REPORTER_ASSERT(r, stream1.hasPosition());
// Seek halfway through the file. The second SkFILEStream will be created
// with the same filename and offset and therefore will treat that offset as
// the beginning.
const size_t size = stream1.getLength();
const size_t middle = size / 2;
if (!stream1.seek(middle)) {
ERRORF(r, "Could not seek SkFILEStream to %lu out of %lu", middle, size);
return;
}
REPORTER_ASSERT(r, stream1.getPosition() == middle);
FILE* file = sk_fopen(filename.c_str(), kRead_SkFILE_Flag);
if (!file) {
ERRORF(r, "Could not open %s as a FILE", filename.c_str());
return;
}
if (fseek(file, (long) middle, SEEK_SET) != 0) {
ERRORF(r, "Could not fseek FILE to %lu out of %lu", middle, size);
return;
}
SkFILEStream stream2(file);
const size_t remaining = size - middle;
SkAutoTMalloc<uint8_t> expected(remaining);
REPORTER_ASSERT(r, stream1.read(expected.get(), remaining) == remaining);
auto test_full_read = [&r, &expected, remaining](SkStream* stream) {
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
REPORTER_ASSERT(r, stream->getPosition() == stream->getLength());
REPORTER_ASSERT(r, stream->isAtEnd());
};
auto test_rewind = [&r, &expected, remaining](SkStream* stream) {
// Rewind goes back to original offset.
REPORTER_ASSERT(r, stream->rewind());
REPORTER_ASSERT(r, stream->getPosition() == 0);
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
};
auto test_move = [&r, &expected, size, remaining](SkStream* stream) {
// Cannot move to before the original offset.
REPORTER_ASSERT(r, stream->move(- (long) size));
REPORTER_ASSERT(r, stream->getPosition() == 0);
REPORTER_ASSERT(r, stream->move(std::numeric_limits<long>::min()));
REPORTER_ASSERT(r, stream->getPosition() == 0);
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
// Cannot move beyond the end.
REPORTER_ASSERT(r, stream->move(1));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
};
auto test_seek = [&r, &expected, middle, remaining](SkStream* stream) {
// Seek to an arbitrary position.
const size_t arbitrary = middle / 2;
REPORTER_ASSERT(r, stream->seek(arbitrary));
REPORTER_ASSERT(r, stream->getPosition() == arbitrary);
const size_t miniRemaining = remaining - arbitrary;
SkAutoTMalloc<uint8_t> actual(miniRemaining);
REPORTER_ASSERT(r, stream->read(actual.get(), miniRemaining) == miniRemaining);
REPORTER_ASSERT(r, !memcmp(expected.get() + arbitrary, actual.get(), miniRemaining));
};
auto test_seek_beginning = [&r, &expected, remaining](SkStream* stream) {
// Seek to the beginning.
REPORTER_ASSERT(r, stream->seek(0));
REPORTER_ASSERT(r, stream->getPosition() == 0);
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
};
auto test_seek_end = [&r, remaining](SkStream* stream) {
// Cannot seek past the end.
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->seek(remaining + 1));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
const size_t middle = remaining / 2;
REPORTER_ASSERT(r, stream->seek(middle));
REPORTER_ASSERT(r, !stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == middle);
REPORTER_ASSERT(r, stream->seek(remaining * 2));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
REPORTER_ASSERT(r, stream->seek(std::numeric_limits<long>::max()));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
};
std::function<void (SkStream* stream, bool recurse)> test_all;
test_all = [&](SkStream* stream, bool recurse) {
REPORTER_ASSERT(r, stream->getLength() == remaining);
REPORTER_ASSERT(r, stream->getPosition() == 0);
test_full_read(stream);
test_rewind(stream);
test_move(stream);
test_seek(stream);
test_seek_beginning(stream);
test_seek_end(stream);
if (recurse) {
// Duplicate shares the original offset.
auto duplicate = stream->duplicate();
if (!duplicate) {
ERRORF(r, "Failed to duplicate the stream!");
} else {
test_all(duplicate.get(), false);
}
// Fork shares the original offset, too.
auto fork = stream->fork();
if (!fork) {
ERRORF(r, "Failed to fork the stream!");
} else {
REPORTER_ASSERT(r, fork->isAtEnd());
REPORTER_ASSERT(r, fork->getLength() == remaining);
REPORTER_ASSERT(r, fork->rewind());
test_all(fork.get(), false);
}
}
};
test_all(&stream2, true);
}
void tst_QOrganizerItemDetailDefinition::testStreaming()
{
QMap<QString, QOrganizerItemDetailFieldDefinition> allFields;
QVariantList allowedStrings;
allowedStrings << QString("First") << QString("Second");
// generate some field definitions
QOrganizerItemDetailFieldDefinition dfd;
dfd.setDataType(QVariant::String);
dfd.setAllowableValues(allowedStrings);
allFields.insert("TestFieldDefinition", dfd);
dfd.setDataType(QVariant::Int);
dfd.setAllowableValues(QVariantList());
allFields.insert("TestCount", dfd);
// now create our detail definition
QOrganizerItemDetailDefinition dd;
dd.setName("TestDefinitionName");
dd.setUnique(true);
dd.setFields(allFields);
// testing streaming of field definition, with no allowable values set
{
QByteArray buffer;
QOrganizerItemDetailFieldDefinition fieldDefIn = allFields.value("TestCount");
QOrganizerItemDetailFieldDefinition fieldDefOut;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << fieldDefIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> fieldDefOut;
QVERIFY(fieldDefIn == fieldDefOut);
}
// testing streaming of field definition, with specific allowable values set
{
QByteArray buffer;
QOrganizerItemDetailFieldDefinition fieldDefIn = allFields.value("TestFieldDefinition");
QOrganizerItemDetailFieldDefinition fieldDefOut;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << fieldDefIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> fieldDefOut;
QVERIFY(fieldDefIn == fieldDefOut);
}
// testing streaming of detail definition
{
QByteArray buffer;
QOrganizerItemDetailDefinition defIn = dd;
QOrganizerItemDetailDefinition defOut;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << defIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> defOut;
QVERIFY(defIn == defOut);
}
// now try inserting and removing a field, streaming again, and testing.
{
// remove the field
QByteArray buffer;
QOrganizerItemDetailDefinition defIn = dd;
defIn.removeField("TestCount");
QVERIFY(defIn != dd);
QOrganizerItemDetailDefinition defOut;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << defIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> defOut;
QVERIFY(defIn == defOut);
}
{
// re-add the field.
QByteArray buffer;
QOrganizerItemDetailDefinition defIn = dd;
defIn.removeField("TestCount"); // remove and reinsert the field
QVERIFY(defIn != dd);
defIn.insertField("TestCount", dfd);
QVERIFY(defIn == dd);
QOrganizerItemDetailDefinition defOut;
QDataStream stream1(&buffer, QIODevice::WriteOnly);
stream1 << defIn;
QVERIFY(buffer.size() > 0);
QDataStream stream2(buffer);
stream2 >> defOut;
QVERIFY(defIn == defOut);
QVERIFY(defOut == dd); // should be equal to the original.
}
}
bool CGloryAndTitleServer::Init()
{
//加载荣耀基本数据
dwt::ifstream stream("Data\\荣耀和称号\\GloryTable.txt");
if (!stream.is_open())
return false;
char buffer[2048];
SGloryBaseData *pData = 0;
while (!stream.eof())
{
stream.getline(buffer, sizeof(buffer));
if (0 == buffer[0] || '//' == (*(LPWORD)buffer))
continue;
std::strstream linebuf(buffer, (std::streamsize)strlen(buffer));
pData = new SGloryBaseData;
DWORD temp = 0;
pData->m_GloryID= ((linebuf >> temp), temp); temp = 0;
linebuf >> pData->m_GloryName;
pData->m_GloryType = ((linebuf >> temp), temp); temp = 0;
for (int i = 0; i < GLORY_AMAX; i++)
linebuf >> pData->m_AwardFactor[i];
for (int i = 0; i < GLORY_CMAX; i++)
linebuf >> pData->m_GetConditionFactor[i];
pData->m_GloryConditionIndex = ((linebuf >> temp), temp); temp = 0;
linebuf >> pData->m_ConditionDetail;
pData->m_GloryIcon = ((linebuf >> temp), temp); temp = 0;
m_GloryBaseData.insert(make_pair(pData->m_GloryID, pData));
}
//加载称号基本数据
dwt::ifstream stream1("Data\\荣耀和称号\\TitleTable.txt");
if (!stream1.is_open())
return false;
char buffer1[2048];
STitleBaseData *pData1 = 0;
while (!stream1.eof())
{
stream1.getline(buffer1, sizeof(buffer1));
if (0 == buffer1[0] || '//' == (*(LPWORD)buffer1))
continue;
std::strstream linebuf1(buffer1, (std::streamsize)strlen(buffer1));
pData1 = new STitleBaseData;
DWORD temp = 0;
pData1->m_TitleID = ((linebuf1 >> temp), temp); temp = 0;
linebuf1 >> pData1->m_TitleName;
for (int i = 0; i < TITLE_AMAX; i++)
linebuf1 >> pData1->m_AddFactor[i];
for (int i = 0; i < TITLE_CMAX; i++)
linebuf1 >> pData1->m_ConsumeFactor[i];
pData1->m_ConsumeItemID = ((linebuf1 >> temp), temp); temp = 0;
pData1->m_TitleIcon = ((linebuf1 >> temp), temp); temp = 0;
linebuf1 >> pData1->m_TitleDescript;
m_TitleBaseData.insert(make_pair(pData1->m_TitleID, pData1));
}
return true;
}
// Ensure all functions compile correctly.
void read_stream_compile_test()
{
try
{
boost::asio::io_service io_service;
boost::system::error_code ec;
char buffer[1024];
// Constructors
urdl::read_stream stream1(io_service);
// get_io_service()
want<boost::asio::io_service>(stream1.get_io_service());
// set_option()
stream1.set_option(0);
stream1.set_option<char>(0);
// set_options()
stream1.set_options(urdl::option_set());
// get_option()
const urdl::read_stream& const_stream1 = stream1;
want<int>(const_stream1.get_option<int>());
want<char>(const_stream1.get_option<char>());
// get_options()
want<urdl::option_set>(const_stream1.get_options());
// is_open()
want<bool>(const_stream1.is_open());
// open()
stream1.open("file://xyz");
stream1.open(urdl::url("file://xyz"));
want<boost::system::error_code>(stream1.open("file://xyz", ec));
want<boost::system::error_code>(stream1.open(urdl::url("file://xyz"), ec));
// async_open()
stream1.async_open("file://xyz", open_handler);
stream1.async_open(urdl::url("file://xyz"), open_handler);
// close()
stream1.close();
want<boost::system::error_code>(stream1.close(ec));
// content_type()
want<std::string>(const_stream1.content_type());
// content_length()
want<std::size_t>(const_stream1.content_length());
// headers()
want<std::string>(const_stream1.headers());
// read_some()
want<std::size_t>(stream1.read_some(boost::asio::buffer(buffer)));
want<std::size_t>(stream1.read_some(boost::asio::buffer(buffer), ec));
// async_read_some()
stream1.async_read_some(boost::asio::buffer(buffer), read_handler);
}
catch (std::exception&)
{
}
}
int main()
{
// --- OpenCV Init ---
//0 is the id of video device. 0 if you have only one camera.
cv::VideoCapture stream1(1);
if (!stream1.isOpened()) { //check if video device has been initialised
std::cerr << "cannot open camera" << std::endl;
}
// --- GLFW Init ---
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// --- Create window ---
GLFWwindow* window = glfwCreateWindow(800, 600,
"OpenGL", nullptr, nullptr); // Windowed
if(window == NULL) return 2;
glfwMakeContextCurrent(window);
// --- GLEW/GL Init ---
glewExperimental = GL_TRUE;
glewInit();
// --- Application Specific Setup ---
// Create FG Vertex Array Object
GLuint bd_vao;
glGenVertexArrays(1, &bd_vao);
glBindVertexArray(bd_vao);
// Create FG Vertex Buffer Object
GLuint bd_vbo;
glGenBuffers(1, &bd_vbo);
glBindBuffer(GL_ARRAY_BUFFER, bd_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(backdrop_vert),
backdrop_vert, GL_STATIC_DRAW);
glBindVertexArray(0);
// Create BG Vertex Array Object
GLuint bb_vao;
glGenVertexArrays(1, &bb_vao);
glBindVertexArray(bb_vao);
// Create BG Vertex Buffer Object
GLuint bb_vbo;
glGenBuffers(1, &bb_vbo);
glBindBuffer(GL_ARRAY_BUFFER, bb_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(backdrop_vert),
backdrop_vert, GL_STATIC_DRAW);
glBindVertexArray(0);
// Create Axis Vertex Array Object
GLuint axis_vao;
glGenVertexArrays(1, &axis_vao);
glBindVertexArray(axis_vao);
// Create Axis Vertex Buffer Object
GLuint axis_vbo;
glGenBuffers(1, &axis_vbo);
glBindBuffer(GL_ARRAY_BUFFER, axis_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(axis_vertices),
axis_vertices, GL_STATIC_DRAW);
glBindVertexArray(0);
// Compile color vertex shader
GLuint colorVert = glCreateShader(GL_VERTEX_SHADER);
//const char *cvSource = readFile("3dvert.glsl").c_str();
const char *cvSource = SHADER_VERT3D_COLOR;
glShaderSource(colorVert, 1, &cvSource, NULL);
glCompileShader(colorVert);
GLint cvStatus;
glGetShaderiv(colorVert, GL_COMPILE_STATUS, &cvStatus);
if(cvStatus != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(colorVert, 512, NULL, buffer);
std::cerr << buffer << std::endl;
return 1;
}
// Compile color fragment shader
GLuint colorFrag = glCreateShader(GL_FRAGMENT_SHADER);
//const char* cfSource = readFile("colorfrag.glsl").c_str();
const char *cfSource = SHADER_FRAG_COLOR;
glShaderSource(colorFrag, 1, &cfSource, NULL);
glCompileShader(colorFrag);
GLint cfStatus;
glGetShaderiv(colorFrag, GL_COMPILE_STATUS, &cfStatus);
if(cfStatus != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(colorFrag, 512, NULL, buffer);
std::cerr << buffer << std::endl;
return 2;
}
// Compile pretty vertex shader
GLuint prettyVert = glCreateShader(GL_VERTEX_SHADER);
//const char *pvSource = readFile("3dvert.glsl").c_str();
const char *pvSource = SHADER_VERT3D;
glShaderSource(prettyVert, 1, &pvSource, NULL);
glCompileShader(prettyVert);
GLint pvStatus;
glGetShaderiv(prettyVert, GL_COMPILE_STATUS, &pvStatus);
if(pvStatus != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(prettyVert, 512, NULL, buffer);
std::cerr << buffer << std::endl;
return 3;
}
// Compile pretty fragment shader
GLuint prettyFrag = glCreateShader(GL_FRAGMENT_SHADER);
//const char* pfSource = readFile("prettyfrag.glsl").c_str();
const char* pfSource = SHADER_FRAG_PRETTY;
glShaderSource(prettyFrag, 1, &pfSource, NULL);
glCompileShader(prettyFrag);
GLint pfStatus;
glGetShaderiv(prettyFrag, GL_COMPILE_STATUS, &pfStatus);
if(pfStatus != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(prettyFrag, 512, NULL, buffer);
std::cerr << buffer << std::endl;
return 4;
}
// Compile blank vertex shader
GLuint blankVert = glCreateShader(GL_VERTEX_SHADER);
//const char *bvSource = readFile("3dvert.glsl").c_str();
const char *bvSource = SHADER_VERT3D;
glShaderSource(blankVert, 1, &bvSource, NULL);
glCompileShader(blankVert);
GLint bvStatus;
glGetShaderiv(blankVert, GL_COMPILE_STATUS, &bvStatus);
if(bvStatus != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(blankVert, 512, NULL, buffer);
std::cerr << buffer << std::endl;
return 5;
}
// Compile blank fragment shader
GLuint blankFrag = glCreateShader(GL_FRAGMENT_SHADER);
//const char* bfSource = readFile("simplefrag.glsl").c_str();
const char* bfSource = SHADER_FRAG_SIMPLE;
glShaderSource(blankFrag, 1, &bfSource, NULL);
glCompileShader(blankFrag);
GLint bfStatus;
glGetShaderiv(blankFrag, GL_COMPILE_STATUS, &bfStatus);
if(bfStatus != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(blankFrag, 512, NULL, buffer);
std::cerr << buffer << std::endl;
return 6;
}
// Make color shader program.
GLuint colorShaderProgram = glCreateProgram();
glAttachShader(colorShaderProgram, colorVert);
glAttachShader(colorShaderProgram, colorFrag);
glBindFragDataLocation(colorShaderProgram, 0, "outColor");
glLinkProgram(colorShaderProgram);
glUseProgram(colorShaderProgram);
//GLint ctAttrib = glGetAttribLocation(colorShaderProgram, "texcoord`");
//glEnableVertexAttribArray(ctAttrib);
//glVertexAttribPointer(ctAttrib, 3, GL_FLOAT, GL_FALSE,
// 6 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
glBindVertexArray(axis_vao);
glBindBuffer(GL_ARRAY_BUFFER, axis_vbo);
GLint cvpAttrib = glGetAttribLocation(colorShaderProgram, "position");
glEnableVertexAttribArray(cvpAttrib);
glVertexAttribPointer(cvpAttrib, 3, GL_FLOAT, GL_FALSE,
6*sizeof(GLfloat), 0);
GLint cvcAttrib = glGetAttribLocation(colorShaderProgram, "v_color");
glEnableVertexAttribArray(cvcAttrib);
glVertexAttribPointer(cvcAttrib, 3, GL_FLOAT, GL_FALSE,
6*sizeof(GLfloat), (void*)(3*sizeof(GLfloat)));
// Make pretty shader program.
GLuint prettyShaderProgram = glCreateProgram();
glAttachShader(prettyShaderProgram, prettyVert);
glAttachShader(prettyShaderProgram, prettyFrag);
glBindFragDataLocation(prettyShaderProgram, 0, "outColor");
glLinkProgram(prettyShaderProgram);
glUseProgram(prettyShaderProgram);
glBindVertexArray(bd_vao);
glBindBuffer(GL_ARRAY_BUFFER, bd_vbo);
GLint pvpAttrib = glGetAttribLocation(prettyShaderProgram, "position");
glEnableVertexAttribArray(pvpAttrib);
glVertexAttribPointer(pvpAttrib, 3, GL_FLOAT, GL_FALSE,
5*sizeof(GLfloat), 0);
GLint pvtAttrib = glGetAttribLocation(prettyShaderProgram, "texcoord");
glEnableVertexAttribArray(pvtAttrib);
glVertexAttribPointer(pvtAttrib, 2, GL_FLOAT, GL_FALSE,
5 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
// Make blank shader program.
GLuint blankShaderProgram = glCreateProgram();
glAttachShader(blankShaderProgram, blankVert);
glAttachShader(blankShaderProgram, blankFrag);
glBindFragDataLocation(blankShaderProgram, 0, "outColor");
glLinkProgram(blankShaderProgram);
glUseProgram(blankShaderProgram);
glBindVertexArray(bb_vao);
glBindBuffer(GL_ARRAY_BUFFER, bb_vbo);
GLint bvpAttrib = glGetAttribLocation(blankShaderProgram, "position");
glEnableVertexAttribArray(bvpAttrib);
glVertexAttribPointer(bvpAttrib, 3, GL_FLOAT, GL_FALSE,
5*sizeof(GLfloat), 0);
GLint bvtAttrib = glGetAttribLocation(blankShaderProgram, "texcoord");
glEnableVertexAttribArray(bvtAttrib);
glVertexAttribPointer(bvtAttrib, 2, GL_FLOAT, GL_FALSE,
5 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
// Setup view
glm::mat4 view = glm::lookAt(
glm::vec3( 0.5f, 2.0f, 1.5f),
glm::vec3( 0.5f, 0.0f, 0.0f),
glm::vec3( 0.0f, 0.0f, 1.0f)
);
glm::mat4 proj =
glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 1.0f, 10.0f);
glm::mat4 model = glm::mat4();
glUniformMatrix4fv(glGetUniformLocation(colorShaderProgram, "view" ),
1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(colorShaderProgram, "proj" ),
1, GL_FALSE, glm::value_ptr(proj));
glUniformMatrix4fv(glGetUniformLocation(colorShaderProgram, "model"),
1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(glGetUniformLocation(prettyShaderProgram, "view" ),
1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(prettyShaderProgram, "proj" ),
1, GL_FALSE, glm::value_ptr(proj));
glUniformMatrix4fv(glGetUniformLocation(prettyShaderProgram, "model"),
1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(glGetUniformLocation(blankShaderProgram, "view" ),
1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(blankShaderProgram, "proj" ),
1, GL_FALSE, glm::value_ptr(proj));
glUniformMatrix4fv(glGetUniformLocation(blankShaderProgram, "model"),
1, GL_FALSE, glm::value_ptr(model));
// Create texture
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenerateMipmap(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glEnableClientState(GL_VERTEX_ARRAY);
float xco = 0.0f;
float yco = 0.0f;
// --- Main Loop ---
while(!glfwWindowShouldClose(window))
{
// Reset
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Move camera
//GLfloat radius = 2.0f;
//GLfloat camX = sin(glfwGetTime()) * radius;
//GLfloat camY = cos(glfwGetTime()) * radius;
//view = glm::lookAt(glm::vec3(camX,camY,1.5f),
// glm::vec3(0.0f, 0.0f, 0.0f),
// glm::vec3(0.0f, 0.0f, 1.0f));
// Capture Image
cv::Mat cameraFrame;
stream1 >> cameraFrame;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
cameraFrame.cols, cameraFrame.rows, 0, GL_BGR,
GL_UNSIGNED_BYTE, cameraFrame.data);
glGenerateMipmap(GL_TEXTURE_2D);
// Draw Backboard
model = glm::mat4();
model = glm::translate(model,glm::vec3(0.5f,0.0f,0.0f));
glUseProgram(prettyShaderProgram);
glUniformMatrix4fv(glGetUniformLocation(prettyShaderProgram, "view"),
1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(prettyShaderProgram, "proj"),
1, GL_FALSE, glm::value_ptr(proj));
glUniformMatrix4fv(glGetUniformLocation(prettyShaderProgram, "model"),
1, GL_FALSE, glm::value_ptr(model));
glBindVertexArray(bd_vao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
// Draw Baseboard
model = glm::rotate(
model,
glm::radians(90.0f),
glm::vec3(1.0f, 0.0f, 0.0f)
);
model = glm::translate(model,glm::vec3(-0.5f,0.0f,0.0f));
glUseProgram(blankShaderProgram);
glUniformMatrix4fv(glGetUniformLocation(blankShaderProgram, "view"),
1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(blankShaderProgram, "proj"),
1, GL_FALSE, glm::value_ptr(proj));
glUniformMatrix4fv(glGetUniformLocation(blankShaderProgram, "model"),
1, GL_FALSE, glm::value_ptr(model));
glBindVertexArray(bb_vao);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
// Draw Axis
model = glm::mat4();
// Process Image
vector<float> point = findObject(cameraFrame);
if (point.size() != 0) {
xco = ((point[0] / cameraFrame.cols));
yco = ((point[1] / cameraFrame.rows));
cerr << "#" << point[0] << ", " << point[1] << endl;
cerr << "!" << xco << ", " << yco << endl;
}
model = glm::translate(glm::mat4(1.0f), glm::vec3(xco, yco, 0.0f));
glUseProgram(colorShaderProgram);
glUniformMatrix4fv(glGetUniformLocation(colorShaderProgram, "view"),
1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(colorShaderProgram, "proj"),
1, GL_FALSE, glm::value_ptr(proj));
glUniformMatrix4fv(glGetUniformLocation(colorShaderProgram, "model"),
1, GL_FALSE, glm::value_ptr(model));
glBindVertexArray(axis_vao);
glDrawArrays(GL_LINES, 0, 6);
glBindVertexArray(0);
//Display
glfwSwapBuffers(window);
glfwPollEvents();
}
// --- Cleanup/Shutdown ---
glDeleteProgram(colorShaderProgram);
glDeleteProgram(prettyShaderProgram);
glDeleteProgram(blankShaderProgram);
glDeleteShader(colorFrag);
glDeleteShader(colorVert);
glDeleteShader(prettyFrag);
glDeleteShader(prettyVert);
glDeleteShader(blankVert);
glDeleteShader(blankFrag);
glDeleteBuffers(1, &axis_vbo);
glDeleteBuffers(1, &bd_vbo);
glDeleteBuffers(1, &bb_vbo);
glDeleteVertexArrays(1, &axis_vao);
glDeleteVertexArrays(1, &bd_vao);
glDeleteVertexArrays(1, &bb_vao);
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void EvolverController::run()
{
double TIME_STEP = getBasicTimeStep();
receiver->enable(TIME_STEP);
while (receiver->getQueueLength() > 0)
{
receiver->nextPacket();
}
/****************************************
***** WAIT UNTIL ENVIRONMENT IS OK *****
****************************************/
// wait unitil EnvironmentModifierController sais the environment is ok
bool environmentOk = false;
while (step(TIME_STEP) != -1 && !environmentOk)
{
while(receiver->getQueueLength() > 0)
{
std::string message = (char*)receiver->getData();
if (message.substr(0,24).compare("[ENVIRONMENT_OK_MESSAGE]") == 0)
{
environmentOk = true;
simulationDateAndTime = MessagesManager::get(message, "SDAT");
}
receiver->nextPacket();
}
}
/***************************************
******* CREATE THE FIRST GENOME *******
***************************************/
random = Utils::Random::getInstance();
CppnGenome genome = createRandomGenome();
sendGenomeToBirthClinic(genomeManager->genomeToString(genome), "", 0, 0, 0, 0);
// MAIN CYCLE
initialization = true;
initPopulationWaitingTime = getRandomWait();
initialPopulationSize = 0;
lastGeneratedTime = 0;
currentTime = 0;
lastMating = 0; // FOR CENTRALIZED REPRODUCTION BY THE EVOLVER
lastDeath = 0; // FOR CENTRALIZED DEATH BY THE EVOLVER
lastEvolutionEndCheck = 0;
lastOffspringLoggingTime = 30;
logger.noticeStream() << BOLDGREEN << "Initializing next individual in " << initPopulationWaitingTime << " seconds" << RESET;
while (step(TIME_STEP) != -1)
{
currentTime = getTime();
/***********************************
******* CHECK END EVOLUTION *******
***********************************/
checkEndEvolution(currentTime);
/*************************************
***** POPULATION INITIALIZATION *****
*************************************/
if (initialization && (currentTime - lastGeneratedTime > initPopulationWaitingTime))
{
CppnGenome newGenome = createRandomGenome();
sendGenomeToBirthClinic(genomeManager->genomeToString(newGenome), "", 0, 0, 0, 0);
lastGeneratedTime = getTime();
initialPopulationSize++;
if(initialPopulationSize >= INITIAL_POPULATION_MAX_SIZE) {
initialization = false;
logger.noticeStream() << BOLDGREEN << "Finished initialising population" << RESET;
}else{
initPopulationWaitingTime = getRandomWait();
logger.noticeStream() << BOLDGREEN << "Initializing next individual in " << initPopulationWaitingTime << " seconds" << RESET;
}
}
/***************************************************************
************************** MANAGE MESSAGES ********************
***************************************************************/
while(receiver->getQueueLength() > 0)
{
std::string message = (char*)receiver->getData();
/**************************************
****** UPDATE BECAUSE OF DEATH ******
**************************************/
if (message.substr(0,28).compare("[DEATH_ANNOUNCEMENT_MESSAGE]") == 0)
{
deathMessage(message,currentTime);
}
/*************************************
****** UPDATE BECAUSE OF BIRTH ******
*************************************/
else if (message.substr(0,24).compare("[ORGANISM_BUILT_MESSAGE]") == 0)
{
birthMessage(message,currentTime);
}
/*************************************
****** UPDATE BECAUSE OF ADULT ******
*************************************/
else if (message.substr(0,20).compare("[ADULT_ANNOUNCEMENT]") == 0)
{
adultMessage(message,currentTime);
}
/*************************************
***** UPDATE BECAUSE OF FERTILE *****
*************************************/
else if (message.substr(0,20).compare("[FERTILE_ANNOUNCEMENT]") == 0)
{
fertileMessage(message,currentTime);
}
/******************************
******* UPDATE FITNESS *******
******************************/
// should be useful only for distributed
else if (message.substr(0,16).compare("[FITNESS_UPDATE]") == 0)
{
fitnessUpdateMessage(message,currentTime);
}
/**************************************************************
******* CREATE NEW GENOME AFTER SELECTION BY ORGANISMS *******
**************************************************************/
else if (matingType == MATING_SELECTION_BY_ORGANISMS)
{
if (message.substr(0,16).compare("[COUPLE_MESSAGE]") == 0)
{
coupleMessage(message,currentTime);
}
}
/*************************************************
******* GET GENOMES FOR MATING BY EVOLVER *******
*************************************************/
else if (matingType == MATING_SELECTION_BY_EVOLVER)
{
if (message.substr(0,23).compare("[GENOME_SPREAD_MESSAGE]") == 0)
{
genomeSpreadMessage(message,currentTime);
}
}
receiver->nextPacket();
}
/***************************************************************
********************* INTERVAL OPERATIONS *********************
***************************************************************/
/************************************************************
******* CREATE NEW GENOME USING SELECTION BY EVOLVER *******
************************************************************/
if (matingType == MATING_SELECTION_BY_EVOLVER)
{
if(currentTime - lastMating > MATING_TIME)
{
logger.debugStream() << "time to mate";
std::vector<id_t> forMating = selectForMating();
if (forMating.size() == 2)
{
try {
std::vector<CppnGenome> parentsGenomes = std::vector<CppnGenome>();
std::stringstream stream1(organismsList[searchForOrganism(forMating[0])].getGenome());
std::stringstream stream2(organismsList[searchForOrganism(forMating[1])].getGenome());
parentsGenomes.push_back(CppnGenome(stream1));
parentsGenomes.push_back(CppnGenome(stream2));
bool empty = true;
for (int i = 0; i < 100 && empty; i++)
{
CppnGenome newGenome = genomeManager->createGenome(parentsGenomes);
empty = checkEmptyPlan(newGenome);
if(!empty) {
std::vector<boost::shared_ptr<MindGenome> > parentMindGenomes;
std::stringstream mind1(organismsList[searchForOrganism(forMating[0])].getMind());
std::stringstream mind2(organismsList[searchForOrganism(forMating[1])].getMind());
boost::shared_ptr<MindGenome> mindGenome1 = mindGenomeManager->getGenomeFromStream(mind1);
boost::shared_ptr<MindGenome> mindGenome2 = mindGenomeManager->getGenomeFromStream(mind2);
parentMindGenomes.push_back(mindGenome1);
parentMindGenomes.push_back(mindGenome2);
boost::shared_ptr<MindGenome> newMind = mindGenomeManager->createGenome(parentMindGenomes);
logger.debugStream() << "NEW GENOME CREATED FROM organism_" << forMating[0] << " and organism_" << forMating[1];
std::string log = std::to_string(getTime()) + " NEW GENOME CREATED FROM " + std::to_string(forMating[0]) + " and " + std::to_string(forMating[1]);
storeEventOnFile(log);
double fitness1 = organismsList[searchForOrganism(forMating[0])].getFitness();
double fitness2 = organismsList[searchForOrganism(forMating[1])].getFitness();
sendGenomeToBirthClinic(genomeManager->genomeToString(newGenome), newMind->toString(), forMating[0], forMating[1], fitness1, fitness2);
initialization = false;
logger.noticeStream() << BOLDGREEN << "Finished initialising population" << RESET;
}
}
}catch(LocatedException &e){
logger.warnStream() << "Evolver Mating failed, genomeManager threw a located exception: " << e.what();
}catch(std::exception &e){
logger.warnStream() << "Evolver Mating failed, genomeManager threw a normal exception: " << e.what();
}
}
if (forMating.size() == 1)
{
try{
std::vector<CppnGenome> parentsGenomes = std::vector<CppnGenome>();
std::stringstream stream1(organismsList[searchForOrganism(forMating[0])].getGenome());
parentsGenomes.push_back(CppnGenome(stream1));
bool empty = true;
for (int i = 0; i < 100 && empty; i++)
{
CppnGenome newGenome = genomeManager->createGenome(parentsGenomes);
empty = checkEmptyPlan(newGenome);
if(!empty){
std::vector<boost::shared_ptr<MindGenome> > parentMindGenomes;
std::stringstream mind1(organismsList[searchForOrganism(forMating[0])].getMind());
boost::shared_ptr<MindGenome> mindGenome1 = mindGenomeManager->getGenomeFromStream(mind1);
parentMindGenomes.push_back(mindGenome1);
boost::shared_ptr<MindGenome> newMind = mindGenomeManager->createGenome(parentMindGenomes);
logger.debugStream() << "NEW GENOME CREATED FROM SINGLE PARENT organism_" << forMating[0];
std::string log = std::to_string(getTime()) + " NEW GENOME CREATED FROM " + std::to_string(forMating[0]);
storeEventOnFile(log);
double fitness = organismsList[searchForOrganism(forMating[0])].getFitness();
sendGenomeToBirthClinic(genomeManager->genomeToString(newGenome), newMind->toString(), forMating[0], 0, fitness, -1);
initialization = false;
}
}
}catch(LocatedException &e){
logger.warnStream() << "Evolver Mating failed, genomeManager threw a located exception: " << e.what();
}catch(std::exception &e){
logger.warnStream() << "Evolver Mating failed, genomeManager threw a normal exception: " << e.what();
}
}
if (forMating.size() == 0)
{
logger.debugStream() << "couple of parents not found";
std::string log = std::to_string(getTime()) + " couple of parents not found";
storeEventOnFile(log);
}
lastMating = getTime();
}
}
/***********************************
********** LOG OFFSPRING **********
***********************************/
if(currentTime - lastOffspringLoggingTime > MATING_TIME)
{
storeParentsOnFile(currentTime);
lastOffspringLoggingTime = getTime();
}
/******************************************
******* DEATH BY EVOLVER SELECTION *******
******************************************/
if (deathType == DEATH_SELECTION_BY_EVOLVER)
{
if(currentTime - lastDeath > DYING_TIME)
{
std::vector<id_t> forDying = selectForDying();
for (int i = 0; i < forDying.size(); i++)
{
sendDeathMessage(forDying[i]);
logger.debugStream() << "organism_" << forDying[i] << " SELECTED FOR DEATH";
}
lastDeath = getTime();
}
}
}
}
bool ReadPairReads(const std::string& file1, const std::string& file2, PairReadList& pair_reads) {
std::ifstream stream1(file1.c_str()), stream2(file2.c_str());
return ReadPairReads(stream1, stream2, pair_reads);
}
