int main( int argc, char** argv )
{
/* loop variables */
int x,y;
/* Create matrixes */
unsigned int * input_array;
unsigned int * serial_array;
unsigned int * output_array;
unsigned int * filter_list;
/* Initialize the data. Values don't matter much. */
posix_memalign ( (void**)&input_array, 4096, DATA_LEN * sizeof(unsigned int));
// input_array = (unsigned int*) posix_memalign ( DATA_LEN * sizeof(unsigned int), 4096);
for (x=0; x<DATA_LEN; x++)
{
input_array[x] = x % 2048;
}
/* start with an empty *all zeros* output array */
posix_memalign ( (void**)&output_array, 4096, DATA_LEN * sizeof(unsigned int));
memset ( output_array, 0, DATA_LEN );
posix_memalign ( (void**)&serial_array, 4096, DATA_LEN * sizeof(unsigned int));
memset ( serial_array, 0, DATA_LEN );
/* Initialize the filter. Values don't matter much. */
filter_list = (unsigned int*) malloc ( FILTER_LEN * sizeof(unsigned int));
for (y=0; y<FILTER_LEN; y++)
{
filter_list[y] = y;
}
/* Execute at a variety of filter lengths */
for ( int filter_len =16; filter_len<=FILTER_LEN; filter_len*=2)
{
serialDataFirst ( DATA_LEN, input_array, serial_array, filter_len, filter_list );
memset ( output_array, 0, DATA_LEN );
serialFilterFirst ( DATA_LEN, input_array, output_array, filter_len, filter_list );
checkData ( serial_array, output_array );
memset ( output_array, 0, DATA_LEN );
//omp_set_num_threads(16);
parallelFilterFirst ( DATA_LEN, input_array, output_array, filter_len, filter_list );
checkData ( serial_array, output_array );
memset ( output_array, 0, DATA_LEN );
parallelDataFirst ( DATA_LEN, input_array, output_array, filter_len, filter_list );
checkData ( serial_array, output_array );
memset ( output_array, 0, DATA_LEN );
}
}
PlaceInformationDialog::PlaceInformationDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::PlaceInformationDialog)
{
ui->setupUi(this);
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
connect(ui->lineEditNumber, SIGNAL(editingFinished()), this, SLOT(checkData()));
connect(ui->lineEditPLZ, SIGNAL(editingFinished()), this, SLOT(checkData()));
connect(ui->lineEditStreet, SIGNAL(editingFinished()), this, SLOT(checkData()));
connect(ui->lineEditTown, SIGNAL(editingFinished()), this, SLOT(checkData()));
}
bool SudokuBox::checkResult() {
bool ret = true;
//XXX optimization: only check the error index and changed index.
m_setErrors.clear();
std::vector<int> index_array;
//1.check each row
for (int row = 0; row < m_iRows; row++) {
index_array.clear();
for (int col = 0; col < m_iCols; col++) {
index_array.push_back(m_iCols * row + col);
}
ret &= checkData(index_array);
}
//2.check each column
for (int col = 0; col < m_iCols; col++) {
index_array.clear();
for (int row = 0; row < m_iRows; row++) {
index_array.push_back(m_iCols * row + col);
}
ret &= checkData(index_array);
}
//3.check each grid
if (m_stagedata.cols_per_grid > 1 && m_stagedata.rows_per_grid > 1) {
int count = m_stagedata.grids_in_col * m_stagedata.grids_in_row;
// int cell_count = m_stagedata.rows_per_grid * m_stagedata.cols_per_grid;
for (int grid = 0; grid < count; grid++) {
index_array.clear();
int start_col = (grid % m_stagedata.grids_in_col) * m_stagedata.cols_per_grid;
int start_row = (grid / m_stagedata.grids_in_col) * m_stagedata.rows_per_grid;
int start = start_row * m_iCols + start_col;
for (int row = 0; row < m_stagedata.rows_per_grid; row++) {
for (int col = 0; col < m_stagedata.cols_per_grid; col++) {
index_array.push_back(start + row * m_iCols + col);
}
}
ret &= checkData(index_array);
}
}
//4.check if each cell filled with valid number
for (int index = 0; index < m_iRows*m_iCols; index++) {
if (m_pData[index] <= 0)
return false;
}
return ret;
}
MainWindow::MainWindow(QIODevice *ioDev, QWidget *parent) :
QMainWindow(parent),
ioDev(ioDev),
ui(new Ui::MainWindow)
{
this->setWindowFlags(Qt::Window | Qt::CustomizeWindowHint | Qt::WindowTitleHint);
ui->setupUi(this);
connect(ioDev, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
//edited
AbstractSerial *tempDev = (AbstractSerial *) ioDev;
tempDev->setDtr(false);
tempDev->setRts(true);
save="";
readFormatedTimer = new QTimer(this);
readFormatedTimer->start(1000);
connect(readFormatedTimer,SIGNAL(timeout()),this,SLOT(checkData()));
///
readWaitTimer = new QTimer(this);
connect(readWaitTimer, SIGNAL(timeout()), this, SLOT(onReadyRead()));
onReadyRead();
}
// Build a PPM from given attributes
//-------------------------------------------------------------------------------------------------
bool PPM::build(const std::string &format, unsigned int width, unsigned int height, unsigned int maxrgb,
const std::vector<unsigned char> &r,
const std::vector<unsigned char> &g,
const std::vector<unsigned char> &b)
{
// Copy the header values
m_format = format;
m_width = width;
m_height = height;
m_maxrgb = maxrgb;
// Check that the values are valid
if(!checkHeader())
{
std::cerr << "Error in build: invalid header values" << std::endl;
close(); // Prevent inconsistant state
return false;
}
// Copy each of the vectors
m_pR = new std::vector<unsigned char>(r);
m_pG = new std::vector<unsigned char>(g);
m_pB = new std::vector<unsigned char>(b);
// Check that the data is valid
if(!checkData())
{
std::cerr << "Error in build: invalid data" << std::endl;
close(); // Prevent inconsistant state
return false;
}
return true;
}
void AddClientDialog::loadQuery()
{
ThreadControl *tc = qobject_cast<ThreadControl *>( sender() );
if( !tc )
return;
int i = tc->getIndexOfLastQuery( qList );
if( i < 0 )
return;
QStringList list = tc->getDataList();
switch(i)
{
case 0:
{
checkData( list );
break;
}
case 1:
{
if( list.count() > 0 )
insertData( list.first() );
break;
}
}
}
void QXmppTransferIncomingJob::_q_disconnected()
{
if (d->state == QXmppTransferJob::FinishedState)
return;
checkData();
}
void BytesTrieTest::TestShortestBranch() {
static const StringAndValue data[]={
{ "a", 1000 },
{ "b", 2000 }
};
checkData(data, UPRV_LENGTHOF(data));
}
void BytesTrieTest::Test_a_ab() {
static const StringAndValue data[]={
{ "a", 1 },
{ "ab", 100 }
};
checkData(data, UPRV_LENGTHOF(data));
}
Foam::actuationDiskSource::actuationDiskSource
(
const word& name,
const dictionary& dict,
const fvMesh& mesh
)
:
basicSource(name, dict, mesh),
cellZoneID_(mesh.cellZones().findZoneID(this->cellSetName())),
dict_(dict.subDict(typeName + "Coeffs")),
diskDir_(dict_.lookup("diskDir")),
Cp_(readScalar(dict_.lookup("Cp"))),
Ct_(readScalar(dict_.lookup("Ct"))),
diskArea_(readScalar(dict_.lookup("diskArea")))
{
Info<< " - creating actuation disk zone: "
<< this->name() << endl;
bool foundZone = (cellZoneID_ != -1);
reduce(foundZone, orOp<bool>());
if (!foundZone && Pstream::master())
{
FatalErrorIn
(
"Foam::actuationDiskSource::actuationDiskSource"
"(const word&, const dictionary&, const fvMesh&)"
) << "cannot find porous cellZone " << this->name()
<< exit(FatalError);
}
checkData();
}
void BytesTrieTest::TestCompact() {
// Duplicate trailing strings and values provide opportunities for compacting.
static const StringAndValue data[]={
{ "+", 0 },
{ "+august", 8 },
{ "+december", 12 },
{ "+july", 7 },
{ "+june", 6 },
{ "+november", 11 },
{ "+october", 10 },
{ "+september", 9 },
{ "-", 0 },
{ "-august", 8 },
{ "-december", 12 },
{ "-july", 7 },
{ "-june", 6 },
{ "-november", 11 },
{ "-october", 10 },
{ "-september", 9 },
// The l+n branch (with its sub-nodes) is a duplicate but will be written
// both times because each time it follows a different linear-match node.
{ "xjuly", 7 },
{ "xjune", 6 }
};
checkData(data, UPRV_LENGTHOF(data));
}
void BytesTrieTest::TestLongBranch() {
// Split-branch and interesting compact-integer values.
static const StringAndValue data[]={
{ "a", -2 },
{ "b", -1 },
{ "c", 0 },
{ "d2", 1 },
{ "f", 0x3f },
{ "g", 0x40 },
{ "h", 0x41 },
{ "j23", 0x1900 },
{ "j24", 0x19ff },
{ "j25", 0x1a00 },
{ "k2", 0x1a80 },
{ "k3", 0x1aff },
{ "l234567890", 0x1b00 },
{ "l234567890123", 0x1b01 },
{ "nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn", 0x10ffff },
{ "oooooooooooooooooooooooooooooooooooooooooooooooooooooo", 0x110000 },
{ "pppppppppppppppppppppppppppppppppppppppppppppppppppppp", 0x120000 },
{ "r", 0x333333 },
{ "s2345", 0x4444444 },
{ "t234567890", 0x77777777 },
{ "z", (int32_t)0x80000001 }
};
checkData(data, UPRV_LENGTHOF(data));
}
//文件切割逻辑
void doIncise()
{
checkData();
checkSize();
if (mChang) {
createFile();
}
}
void ZipCountryCompleters::filterCountry(const int index)
{
if (!m_Country)
return;
if (!m_Model)
return;
m_Model->filterCountry(m_Country->itemData(index).toInt());
checkData();
}
Palapeli::PuzzleCreatorDialog::PuzzleCreatorDialog()
: m_result(0)
, m_imageSelector(new KUrlRequester)
, m_nameEdit(new KLineEdit)
, m_commentEdit(new KLineEdit)
, m_authorEdit(new KLineEdit)
, m_slicerSelector(new Palapeli::SlicerSelector)
, m_slicerConfigMasterWidget(new QStackedWidget)
{
//setup dialog
setCaption(i18nc("@title:window", "Create new puzzle"));
showButton(KDialog::Help, false);
//setup image selector
m_imageSelector->setMode(KFile::File | KFile::LocalOnly | KFile::ExistingOnly);
//build sublayouts
QFormLayout* sourceLayout = new QFormLayout;
sourceLayout->addRow(i18nc("@label:chooser", "Image file:"), m_imageSelector);
sourceLayout->addRow(new QLabel(i18nc("@info", "Please describe below the image which you have chosen.")));
sourceLayout->addRow(i18nc("@label:textbox", "Image name:"), m_nameEdit);
sourceLayout->addRow(i18nc("@label:textbox (like in: This comment is optional.)", "Optional comment:"), m_commentEdit);
sourceLayout->addRow(i18nc("@label:textbox", "Name of image author:"), m_authorEdit);
foreach (const Pala::Slicer* slicer, m_slicerSelector->slicers())
{
m_slicerConfigWidgets[slicer] = new Palapeli::SlicerConfigWidget(slicer);
m_slicerConfigMasterWidget->addWidget(m_slicerConfigWidgets[slicer]);
}
//build page widget items
m_sourcePage = addPage(new QWidget, i18nc("@item:inlistbox (page name in an assistant dialog)", "Choose image"));
m_sourcePage->setHeader(i18nc("@title:tab (page header in an assistant dialog)", "Specify the source image to be sliced into pieces"));
m_sourcePage->widget()->setLayout(sourceLayout);
m_slicerPage = addPage(m_slicerSelector, i18nc("@item:inlistbox (page name in an assistant dialog)", "Choose slicer"));
m_slicerPage->setHeader(i18nc("@title:tab (page header in an assistant dialog)", "Choose a slicing method"));
m_slicerConfigPage = addPage(m_slicerConfigMasterWidget, i18nc("@item:inlistbox (page name in an assistant dialog)", "Configure slicer"));
m_slicerConfigPage->setHeader(i18nc("@title:tab (page header in an assistant dialog)", "Tweak the parameters of the chosen slicing method"));
//wire up stuff
connect(this, SIGNAL(accepted()), this, SLOT(createPuzzle()));
connect(m_imageSelector, SIGNAL(urlSelected(KUrl)), this, SLOT(checkData()));
connect(m_nameEdit, SIGNAL(textChanged(QString)), this, SLOT(checkData()));
connect(m_authorEdit, SIGNAL(textChanged(QString)), this, SLOT(checkData()));
checkData(); //to invalidate first page
connect(m_slicerSelector, SIGNAL(currentSelectionChanged(Palapeli::SlicerSelection)), this, SLOT(updateSlicerSelection(Palapeli::SlicerSelection)));
}
void PlaceInformationDialog::setPlace(QSharedPointer<Place> place)
{
m_place = place;
ui->lineEditNumber->setText(QString::number(place->houseNumber()));
ui->lineEditPLZ->setText(QString::number(place->postalCode()));
ui->lineEditStreet->setText(place->street());
ui->lineEditTown->setText(place->city());
ui->imageWellIcon->setPixmap(place->cityEmblem());
checkData();
}
void Connection::connect(const SocketClient::SharedPtr &client)
{
assert(!mSocketClient);
mSocketClient = client;
mIsConnected = true;
assert(client->isConnected());
mSocketClient->disconnected().connect(std::bind(&Connection::onClientDisconnected, this, std::placeholders::_1));
mSocketClient->readyRead().connect(std::bind(&Connection::onDataAvailable, this, std::placeholders::_1, std::placeholders::_2));
mSocketClient->bytesWritten().connect(std::bind(&Connection::onDataWritten, this, std::placeholders::_1, std::placeholders::_2));
mSocketClient->error().connect(std::bind(&Connection::onSocketError, this, std::placeholders::_1, std::placeholders::_2));
mCheckTimer = EventLoop::eventLoop()->registerTimer([this](int) { checkData(); }, 0, Timer::SingleShot);
}
// Write current contents to file
//-------------------------------------------------------------------------------------------------
bool PPM::writeTo(const std::string &filename)
{
// Cheak the header values are valid
if(!checkHeader())
{
std::cerr << "Error in writeTo: invalid header values" << std::endl;
return false;
}
// Check the data is valid
if(!checkData())
{
std::cerr << "Error in writeTo: invalid data" << std::endl;
return false;
}
std::ofstream outFile;
// Open output file in binary mode
outFile.open(filename.c_str(), std::ios::binary);
// Check file open ok
if(!outFile)
{
std::cerr << "Error in writeTo: could not open or create file '" << filename << "'" << std::endl;
return false;
}
// Write header values
outFile << m_format << std::endl;
outFile << "# Created by PPM.cpp" << std::endl;
outFile << m_width << " " << m_height << std::endl;
outFile << m_maxrgb << std::endl;
// Iterate through vectors and write data
char c;
unsigned int size = m_width * m_height;
for(unsigned int i = 0; i < size; ++i)
{
c = (*m_pR)[i];
outFile.write(&c, 1);
c = (*m_pG)[i];
outFile.write(&c, 1);
c = (*m_pB)[i];
outFile.write(&c, 1);
}
// Close the file
outFile.close();
return true;
}
void BytesTrieTest::TestValuesForState() {
// Check that saveState() and resetToState() interact properly
// with next() and current().
static const StringAndValue data[]={
{ "a", -1 },
{ "ab", -2 },
{ "abc", -3 },
{ "abcd", -4 },
{ "abcde", -5 },
{ "abcdef", -6 }
};
checkData(data, UPRV_LENGTHOF(data));
}
// Read the data
//-------------------------------------------------------------------------------------------------
bool PPM::readData(std::ifstream &inFile)
{
// Read data into r, g and b vectors
// Note: if << is used data that looks like a white space will be skipped
char c;
int length = m_width * m_height;
for(int i = 0; i < length; ++i)
{
// Red
inFile.read(&c, 1); // read a byte
// Check for eof
if(inFile.eof())
{
std::cerr << "Error in readData: unexpected end of file" << std::endl;
return false;
}
// Set value
(*m_pR)[i] = (unsigned char)c;
// Green
inFile.read(&c, 1); // read a byte
// Check for eof
if(inFile.eof())
{
std::cerr << "Error in readData: unexpected end of file" << std::endl;
return false;
}
// Set value
(*m_pG)[i] = (unsigned char)c;
// Blue
inFile.read(&c, 1); // read a byte
// Check for eof
if(inFile.eof())
{
std::cerr << "Error in readData: unexpected end of file" << std::endl;
return false;
}
// Set value
(*m_pB)[i] = (unsigned char)c;
}
// Check the data is valid
if(!checkData())
{
std::cerr << "Error in readData: invalid data" << std::cout;
return false;
}
return true;
}
/** When user select a zip or a city this private slot s activated. It causes the line edit
to be populated with the selected values.
*/
void ZipCountryCompleters::indexActivated(const QModelIndex &index)
{
QString zip = m_Model->index(index.row(), ZipCountryModel::Zip).data().toString();
QString city = m_Model->index(index.row(), ZipCountryModel::City).data().toString();
if (m_Zip) {
m_Zip->clearFocus();
m_Zip->setText(zip);
}
if (m_City) {
m_City->clearFocus();
m_City->setText(city);
}
checkData();
}
void UCharsTrieTest::TestFirstForCodePoint() {
static const StringAndValue data[]={
{ "a", 1 },
{ "a\\ud800", 2 },
{ "a\\U00010000", 3 },
{ "\\ud840", 4 },
{ "\\U00020000\\udbff", 5 },
{ "\\U00020000\\U0010ffff", 6 },
{ "\\U00020000\\U0010ffffz", 7 },
{ "\\U00050000xy", 8 },
{ "\\U00050000xyz", 9 }
};
checkData(data, UPRV_LENGTHOF(data));
}
QAction *BtMenuView::newAction(QMenu *parentMenu, const QModelIndex &itemIndex) {
QVariant displayData(m_model->data(itemIndex, Qt::DisplayRole));
QVariant iconData(m_model->data(itemIndex, Qt::DecorationRole));
QVariant toolTipData(m_model->data(itemIndex, Qt::ToolTipRole));
QVariant statusTipData(m_model->data(itemIndex, Qt::StatusTipRole));
QVariant whatsThisData(m_model->data(itemIndex, Qt::WhatsThisRole));
QAction *childAction = new QAction(parentMenu);
// Set text:
if (displayData.canConvert(QVariant::String)) {
childAction->setText(displayData.toString());
}
// Set icon:
if (iconData.canConvert(QVariant::Icon)) {
childAction->setIcon(iconData.value<QIcon>());
}
// Set tooltip:
if (toolTipData.canConvert(QVariant::String)) {
childAction->setToolTip(toolTipData.toString());
}
// Set status tip:
if (statusTipData.canConvert(QVariant::String)) {
childAction->setStatusTip(statusTipData.toString());
}
// Set whatsthis:
if (whatsThisData.canConvert(QVariant::String)) {
childAction->setWhatsThis(whatsThisData.toString());
}
// Set checkable:
if (m_model->flags(itemIndex).testFlag(Qt::ItemIsUserCheckable)) {
childAction->setCheckable(true);
}
// Set checked:
QVariant checkData(m_model->data(itemIndex, Qt::CheckStateRole));
bool ok;
Qt::CheckState state = (Qt::CheckState) checkData.toInt(&ok);
if (ok) {
childAction->setChecked(state == Qt::Checked);
}
return childAction;
}
void QXmppTransferIncomingJob::_q_receiveData()
{
if (d->state != QXmppTransferJob::TransferState)
return;
// receive data block
if (d->direction == QXmppTransferJob::IncomingDirection)
{
writeData(d->socksSocket->readAll());
// if we have received all the data, stop here
if (fileSize() && d->done >= fileSize())
checkData();
}
}
void BytesTrieTest::TestLongSequence() {
static const StringAndValue data[]={
{ "a", -1 },
// sequence of linear-match nodes
{ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -2 },
// more than 256 bytes
{ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -3 }
};
checkData(data, UPRV_LENGTHOF(data));
}
void QXmppTransferJob::disconnected()
{
if (m_state == QXmppTransferJob::FinishedState)
return;
// terminate transfer
if (m_direction == QXmppTransferJob::IncomingDirection)
{
checkData();
} else {
if (fileSize() && m_done != fileSize())
terminate(QXmppTransferJob::ProtocolError);
else
terminate(QXmppTransferJob::NoError);
}
}
//Verifica se o I foi bem recebido
int checkI(char* buffer,int cns){
int res,i;
char data[15000];
if( buffer[0]!=FLAG
|| buffer[1]!=A
|| buffer[2]!=cns
|| buffer[3]!=(A^cns))
{
return FALSE;
}
else
{
res = getData(buffer,data);
res = checkData(data,res);
return res;
}
}
int peakDetection(int input){
currentTime = sampleCounter/250;
sampleCounter++;
if(init<2){
buffer[loopCheck(init,4)] = input;
init++;
counter = init;
}else{
bufferData(input);
checkData(input);
counter++;
if(misscounter==5){
printf("Missed 5 times in a row.\n");
misscounter = 0;
}
}
return 0;
}
void
execute(void* callbackObj,
SignalHeader * const header, Uint8 prio, Uint32 * const theData,
LinearSectionPtr ptr[3]){
const NodeId nodeId = refToNode(header->theSendersBlockRef);
ndbout << "Recieved prio " << (int)prio << " signal from node: "
<< nodeId
<< " gsn = " << header->theVerId_signalNumber << endl;
checkData(header, prio, theData, ptr);
ndbout << " Data is ok!\n" << endl;
signalReceived[nodeId]++;
if(prio == 0)
sendSignalTo(nodeId, 1);
else
tReg->setPerformState(nodeId, PerformDisconnect);
}
bool ServerNetObject::initGame( QString& serror)
{
for (int i=1; i<=nb_pl; i++) {
writeSelect(1);
if ( writeIsset(pl[i]->sock) ) {
/* send PLAY_MSG to clients */
write( pl[i]->sock, PLAY_MSG, (int)strlen(PLAY_MSG) );
/* send opponents' names */
strncpy(names_msg.prev, (const char *)pl[i-1]->name, NAME_LENGTH);
if ( i!=nb_pl )
strncpy( names_msg.next, (const char *)pl[i+1]->name,
NAME_LENGTH );
else
strncpy( names_msg.next, (const char *)pl[0]->name,
NAME_LENGTH );
write( pl[i]->sock, &names_msg, sizeof(names_msg) );
}
}
/* receive READY_MSG from clients */
for (int i=1; i<=nb_pl; i++) {
readSelect(1);
if ( readIsset(pl[i]->sock) ) {
nb_b = read( pl[i]->sock, buff, MAX_BUFF );
if ( !checkData(i18n("Client has died"),
i18n("Cancel from client"), serror) )
return FALSE;
if ( !hasReceivedMsg(READY_MSG) ) {
serror = i18n("Unknown message from client");
return FALSE;
}
} else {
serror = i18n("Timeout");
return FALSE;
}
}
/* set the "first time" bool */
firstTime = TRUE;
return TRUE;
}
