QT_BEGIN_NAMESPACE
ResourceHelper::ResourceHelper()
{
qFill(palettes, palettes + QPlatformTheme::NPalettes, static_cast<QPalette *>(0));
qFill(fonts, fonts + QPlatformTheme::NFonts, static_cast<QFont *>(0));
}
void WidgetSelection::updateActive()
{
const WidgetState ws = widgetState(m_formWindow->core(), m_widget);
bool active[WidgetHandle::TypeCount];
qFill(active, active + WidgetHandle::TypeCount, false);
// Determine active handles
switch (ws) {
case UnlaidOut:
qFill(active, active + WidgetHandle::TypeCount, true);
break;
case ManagedGridLayout: // Grid: Allow changing span
active[WidgetHandle::Left] = active[WidgetHandle::Top] = active[WidgetHandle::Right] = active[WidgetHandle::Bottom] = true;
break;
case ManagedFormLayout: // Form: Allow changing column span
if (const unsigned operation = ChangeFormLayoutItemRoleCommand::possibleOperations(m_formWindow->core(), m_widget)) {
active[WidgetHandle::Left] = operation & (ChangeFormLayoutItemRoleCommand::SpanningToField|ChangeFormLayoutItemRoleCommand::FieldToSpanning);
active[WidgetHandle::Right] = operation & (ChangeFormLayoutItemRoleCommand::SpanningToLabel|ChangeFormLayoutItemRoleCommand::LabelToSpanning);
}
break;
default:
break;
}
for (int i = WidgetHandle::LeftTop; i < WidgetHandle::TypeCount; ++i)
if (WidgetHandle *h = m_handles[i]) {
h->setWidget(m_widget);
h->setActive(active[i]);
}
}
void ResourceHelper::clear()
{
qDeleteAll(palettes, palettes + QPlatformTheme::NPalettes);
qDeleteAll(fonts, fonts + QPlatformTheme::NFonts);
qFill(palettes, palettes + QPlatformTheme::NPalettes, static_cast<QPalette *>(0));
qFill(fonts, fonts + QPlatformTheme::NFonts, static_cast<QFont *>(0));
}
int main(int argc, char**argv)
{
QCoreApplication app(argc, argv);
// create it
QAbstractSocketEngine *socketEngine =
QAbstractSocketEngine::createSocketEngine(QAbstractSocket::TcpSocket, QNetworkProxy(QNetworkProxy::NoProxy), 0);
if (!socketEngine) {
qDebug() << "could not create engine";
exit(1);
}
// initialize it
bool initialized = socketEngine->initialize(QAbstractSocket::TcpSocket, QAbstractSocket::IPv4Protocol);
if (!initialized) {
qDebug() << "not able to initialize engine";
exit(1);
}
// wait for connected
int r = socketEngine->connectToHost(QHostAddress("74.125.77.99"), 80); // google
bool readyToRead = false;
bool readyToWrite = false;
socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite, true, true, 10*1000);
if (r <= 0) //timeout or error
exit(1);
if (readyToWrite) {
// write the request
QByteArray request("GET /robots.txt HTTP/1.0\r\n\r\n");
int ret = socketEngine->write(request.constData(), request.length());
if (ret == request.length()) {
// read the response in a loop
do {
bool waitReadResult = socketEngine->waitForRead(10*1000);
int available = socketEngine->bytesAvailable();
if (waitReadResult == true && available == 0) {
// disconnected
exit(0);
}
qFill(buf, buf + bufsize, 0);
ret = socketEngine->read(buf, available);
if (ret > 0) {
printf("%s", buf);
} else {
// some failure when reading
exit(1);
}
} while (1);
} else {
qDebug() << "failed writing";
}
} else {
qDebug() << "failed connecting";
}
delete socketEngine;
}
QColorDialogStaticData::QColorDialogStaticData() : customSet(false)
{
int i = 0;
for (int g = 0; g < 4; ++g)
for (int r = 0; r < 4; ++r)
for (int b = 0; b < 3; ++b)
standardRgb[i++] = qRgb(r * 255 / 3, g * 255 / 3, b * 255 / 2);
qFill(customRgb, customRgb + CustomColorCount, 0xffffffff);
readSettings();
}
int main(int argc, char **argv)
{
int numprocs, rank;
MPI_Status status;
int max = (1 << 20);
QVector<int> send(max);
QVector<int> recv(max);
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (numprocs != 2) {
printf("Error: number of processors must be equal to 2\n");
MPI_Finalize();
return -1;
}
qFill(send, rank);
if (rank == 0) {
for (int i = 1; i < max; i = i * 2) {
qFill(recv, 0);
qDebug() << "exchange" << i;
MPI_Send(send.data(), i, MPI_INT, 1, i, MPI_COMM_WORLD);
MPI_Recv(recv.data(), i, MPI_INT, 1, i, MPI_COMM_WORLD, &status);
}
} else {
qFill(recv, 0);
for (int i = 1; i < max; i = i * 2) {
MPI_Send(send.data(), i, MPI_INT, 0, i, MPI_COMM_WORLD);
MPI_Recv(recv.data(), i, MPI_INT, 0, i, MPI_COMM_WORLD, &status);
}
}
qDebug() << "rank" << rank << "done";
MPI_Finalize();
return 0;
}
static HGLRC createContext(const QOpenGLStaticContext &staticContext,
HDC hdc,
const QSurfaceFormat &format,
const QWindowsOpenGLAdditionalFormat &,
HGLRC shared = 0)
{
enum { attribSize = 11 };
if (!staticContext.hasExtensions())
return 0;
int attributes[attribSize];
int attribIndex = 0;
qFill(attributes, attributes + attribSize, int(0));
const int requestedVersion = (format.majorVersion() << 8) + format.minorVersion();
if (requestedVersion > 0x0101) {
attributes[attribIndex++] = WGL_CONTEXT_MAJOR_VERSION_ARB;
attributes[attribIndex++] = format.majorVersion();
attributes[attribIndex++] = WGL_CONTEXT_MINOR_VERSION_ARB;
attributes[attribIndex++] = format.minorVersion();
}
if (requestedVersion >= 0x0300) {
attributes[attribIndex++] = WGL_CONTEXT_FLAGS_ARB;
attributes[attribIndex] = 0;
if (format.testOption(QSurfaceFormat::DeprecatedFunctions))
attributes[attribIndex] |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
if (format.testOption(QSurfaceFormat::DebugContext))
attributes[attribIndex++] |= WGL_CONTEXT_DEBUG_BIT_ARB;
attribIndex++;
}
if (requestedVersion >= 0x0302) {
switch (format.profile()) {
case QSurfaceFormat::NoProfile:
break;
case QSurfaceFormat::CoreProfile:
attributes[attribIndex++] = WGL_CONTEXT_PROFILE_MASK_ARB;
attributes[attribIndex++] = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
break;
case QSurfaceFormat::CompatibilityProfile:
attributes[attribIndex++] = WGL_CONTEXT_PROFILE_MASK_ARB;
attributes[attribIndex++] = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
break;
}
}
if (QWindowsContext::verboseGL)
qDebug("%s: Creating context version %d.%d with %d attributes",
__FUNCTION__, format.majorVersion(), format.minorVersion(), attribIndex / 2);
const HGLRC result =
staticContext.wglCreateContextAttribsARB(hdc, shared, attributes);
if (!result)
qErrnoWarning("%s: wglCreateContextAttribsARB() failed.", __FUNCTION__);
return result;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
// baba bombom
QVector<int> vec(10);
qFill(vec,5);
foreach (int val, vec) {
qDebug() << val;
}
// dziura bob
return a.exec();
}
void FaceTracker::updateFakeCoefficients(float leftBlink, float rightBlink, float browUp,
float jawOpen, float mouth2, float mouth3, float mouth4, QVector<float>& coefficients) {
const int MMMM_BLENDSHAPE = 34;
const int FUNNEL_BLENDSHAPE = 40;
const int SMILE_LEFT_BLENDSHAPE = 28;
const int SMILE_RIGHT_BLENDSHAPE = 29;
const int MAX_FAKE_BLENDSHAPE = 40; // Largest modified blendshape from above and below
coefficients.resize(std::max((int)coefficients.size(), MAX_FAKE_BLENDSHAPE + 1));
qFill(coefficients.begin(), coefficients.end(), 0.0f);
coefficients[_leftBlinkIndex] = leftBlink;
coefficients[_rightBlinkIndex] = rightBlink;
coefficients[_browUpCenterIndex] = browUp;
coefficients[_browUpLeftIndex] = browUp;
coefficients[_browUpRightIndex] = browUp;
coefficients[_jawOpenIndex] = jawOpen;
coefficients[SMILE_LEFT_BLENDSHAPE] = coefficients[SMILE_RIGHT_BLENDSHAPE] = mouth4;
coefficients[MMMM_BLENDSHAPE] = mouth2;
coefficients[FUNNEL_BLENDSHAPE] = mouth3;
}
void FaceplusReader::update() {
#ifdef HAVE_FACEPLUS
float x, y, rotation, scale;
if (!(faceplus_synchronous_track() && faceplus_current_face_location(&x, &y, &rotation, &scale) && !glm::isnan(x) &&
faceplus_current_output_vector(_outputVector.data()))) {
QMetaObject::invokeMethod(this, "update", Qt::QueuedConnection);
return;
}
if (!_referenceInitialized) {
_referenceX = x;
_referenceY = y;
_referenceInitialized = true;
}
const float TRANSLATION_SCALE = 10.0f;
glm::vec3 headTranslation((x - _referenceX) * TRANSLATION_SCALE, (y - _referenceY) * TRANSLATION_SCALE, 0.0f);
glm::quat headRotation(glm::radians(glm::vec3(-_outputVector.at(_headRotationIndices[0]),
_outputVector.at(_headRotationIndices[1]), -_outputVector.at(_headRotationIndices[2]))));
float estimatedEyePitch = (_outputVector.at(_leftEyeRotationIndices[0]) +
_outputVector.at(_rightEyeRotationIndices[0])) * -0.5f;
float estimatedEyeYaw = (_outputVector.at(_leftEyeRotationIndices[1]) +
_outputVector.at(_rightEyeRotationIndices[1])) * 0.5f;
qFill(_blendshapeCoefficients.begin(), _blendshapeCoefficients.end(), 0.0f);
for (int i = 0; i < _outputVector.size(); i++) {
for (QMultiHash<int, QPair<int, float> >::const_iterator it = _channelIndexMap.constFind(i);
it != _channelIndexMap.constEnd() && it.key() == i; it++) {
_blendshapeCoefficients[it.value().first] += _outputVector.at(i) * it.value().second;
}
}
QMetaObject::invokeMethod(Application::getInstance()->getFaceplus(), "setState", Q_ARG(const glm::vec3&, headTranslation),
Q_ARG(const glm::quat&, headRotation), Q_ARG(float, estimatedEyePitch), Q_ARG(float, estimatedEyeYaw),
Q_ARG(const QVector<float>&, _blendshapeCoefficients));
QMetaObject::invokeMethod(this, "update", Qt::QueuedConnection);
#endif
}
static QSurfaceFormat
qSurfaceFormatFromHDC(const QOpenGLStaticContext &staticContext,
HDC hdc, int pixelFormat,
QWindowsOpenGLAdditionalFormat *additionalIn = 0)
{
enum { attribSize =40 };
QSurfaceFormat result;
if (!staticContext.hasExtensions())
return result;
int iAttributes[attribSize];
int iValues[attribSize];
qFill(iAttributes, iAttributes + attribSize, int(0));
qFill(iValues, iValues + attribSize, int(0));
int i = 0;
const bool hasSampleBuffers = testFlag(staticContext.extensions, QOpenGLStaticContext::SampleBuffers);
iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB; // 0
iAttributes[i++] = WGL_DEPTH_BITS_ARB; // 1
iAttributes[i++] = WGL_PIXEL_TYPE_ARB; // 2
iAttributes[i++] = WGL_RED_BITS_ARB; // 3
iAttributes[i++] = WGL_GREEN_BITS_ARB; // 4
iAttributes[i++] = WGL_BLUE_BITS_ARB; // 5
iAttributes[i++] = WGL_ALPHA_BITS_ARB; // 6
iAttributes[i++] = WGL_ACCUM_BITS_ARB; // 7
iAttributes[i++] = WGL_STENCIL_BITS_ARB; // 8
iAttributes[i++] = WGL_STEREO_ARB; // 9
iAttributes[i++] = WGL_ACCELERATION_ARB; // 10
iAttributes[i++] = WGL_NUMBER_OVERLAYS_ARB; // 11
if (hasSampleBuffers) {
iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB; // 12
iAttributes[i++] = WGL_SAMPLES_ARB; // 13
}
if (!staticContext.wglGetPixelFormatAttribIVARB(hdc, pixelFormat, 0, i,
iAttributes, iValues)) {
qErrnoWarning("%s: wglGetPixelFormatAttribIVARB() failed for basic parameters.", __FUNCTION__);
return result;
}
result.setSwapBehavior(iValues[0] ? QSurfaceFormat::DoubleBuffer : QSurfaceFormat::SingleBuffer);
result.setDepthBufferSize(iValues[1]);
result.setRedBufferSize(iValues[3]);
result.setGreenBufferSize(iValues[4]);
result.setBlueBufferSize(iValues[5]);
result.setAlphaBufferSize(iValues[6]);
result.setStencilBufferSize(iValues[8]);
if (iValues[9])
result.setOption(QSurfaceFormat::StereoBuffers);
if (hasSampleBuffers)
result.setSamples(iValues[13]);
if (additionalIn) {
if (iValues[7])
additionalIn->formatFlags |= QWindowsGLAccumBuffer;
if (iValues[10] == WGL_FULL_ACCELERATION_ARB)
additionalIn->formatFlags |= QWindowsGLDirectRendering;
if (iValues[11])
additionalIn->formatFlags |= QWindowsGLOverlay;
}
return result;
}
// Choose a suitable pixelformat using ARB extension functions.
static int choosePixelFormat(HDC hdc,
const QOpenGLStaticContext &staticContext,
const QSurfaceFormat &format,
const QWindowsOpenGLAdditionalFormat &additional,
PIXELFORMATDESCRIPTOR *obtainedPfd)
{
enum { attribSize =40 };
if ((additional.formatFlags & QWindowsGLRenderToPixmap) || !staticContext.hasExtensions())
return 0;
int iAttributes[attribSize];
qFill(iAttributes, iAttributes + attribSize, int(0));
int i = 0;
iAttributes[i++] = WGL_ACCELERATION_ARB;
iAttributes[i++] = testFlag(additional.formatFlags, QWindowsGLDirectRendering) ?
WGL_FULL_ACCELERATION_ARB : WGL_NO_ACCELERATION_ARB;
iAttributes[i++] = WGL_SUPPORT_OPENGL_ARB;
iAttributes[i++] = TRUE;
iAttributes[i++] = WGL_DRAW_TO_WINDOW_ARB;
iAttributes[i++] = TRUE;
iAttributes[i++] = WGL_COLOR_BITS_ARB;
iAttributes[i++] = 24;
switch (format.swapBehavior()) {
case QSurfaceFormat::DefaultSwapBehavior:
break;
case QSurfaceFormat::SingleBuffer:
iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB;
iAttributes[i++] = FALSE;
break;
case QSurfaceFormat::DoubleBuffer:
case QSurfaceFormat::TripleBuffer:
iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB;
iAttributes[i++] = TRUE;
break;
}
if (format.stereo()) {
iAttributes[i++] = WGL_STEREO_ARB;
iAttributes[i++] = TRUE;
}
if (format.depthBufferSize() >= 0) {
iAttributes[i++] = WGL_DEPTH_BITS_ARB;
iAttributes[i++] = format.depthBufferSize();
}
iAttributes[i++] = WGL_PIXEL_TYPE_ARB;
iAttributes[i++] = WGL_TYPE_RGBA_ARB;
if (format.redBufferSize() >= 0) {
iAttributes[i++] = WGL_RED_BITS_ARB;
iAttributes[i++] = format.redBufferSize();
}
if (format.greenBufferSize() >= 0) {
iAttributes[i++] = WGL_GREEN_BITS_ARB;
iAttributes[i++] = format.greenBufferSize();
}
if (format.blueBufferSize() >= 0) {
iAttributes[i++] = WGL_BLUE_BITS_ARB;
iAttributes[i++] = format.blueBufferSize();
}
iAttributes[i++] = WGL_ALPHA_BITS_ARB;
iAttributes[i++] = format.alphaBufferSize() >= 0 ? format.alphaBufferSize() : 8;
if (additional.formatFlags & QWindowsGLAccumBuffer) {
iAttributes[i++] = WGL_ACCUM_BITS_ARB;
iAttributes[i++] = 16;
}
iAttributes[i++] = WGL_STENCIL_BITS_ARB;
iAttributes[i++] = 8;
if (additional.formatFlags & QWindowsGLOverlay) {
iAttributes[i++] = WGL_NUMBER_OVERLAYS_ARB;
iAttributes[i++] = 1;
}
const int samples = format.samples();
const bool sampleBuffersRequested = samples > 1
&& testFlag(staticContext.extensions, QOpenGLStaticContext::SampleBuffers);
int samplesValuePosition = 0;
if (sampleBuffersRequested) {
iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB;
iAttributes[i++] = TRUE;
iAttributes[i++] = WGL_SAMPLES_ARB;
samplesValuePosition = i;
iAttributes[i++] = format.samples();
} else if (samples == 0 || samples == 1 ) {
iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB;
iAttributes[i++] = FALSE;
}
// If sample buffer request cannot be satisfied, reduce request.
int pixelFormat = 0;
uint numFormats = 0;
while (true) {
const bool valid =
staticContext.wglChoosePixelFormatARB(hdc, iAttributes, 0, 1,
&pixelFormat, &numFormats)
&& numFormats >= 1;
if (valid || !sampleBuffersRequested)
break;
if (iAttributes[samplesValuePosition] > 1) {
iAttributes[samplesValuePosition] /= 2;
} else {
break;
}
}
// Verify if format is acceptable. Note that the returned
// formats have been observed to not contain PFD_SUPPORT_OPENGL, ignore.
initPixelFormatDescriptor(obtainedPfd);
DescribePixelFormat(hdc, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), obtainedPfd);
if (!isAcceptableFormat(additional, *obtainedPfd, true)) {
if (QWindowsContext::verboseGL)
qDebug() << __FUNCTION__ << " obtained px #" << pixelFormat
<< " not acceptable=" << *obtainedPfd;
pixelFormat = 0;
}
#ifndef QT_NO_DEBUG_OUTPUT
if (QWindowsContext::verboseGL) {
QDebug nsp = qDebug().nospace();
nsp << __FUNCTION__;
if (sampleBuffersRequested)
nsp << " samples=" << iAttributes[samplesValuePosition];
nsp << " Attributes: " << hex << showbase;
for (int ii = 0; ii < i; ++ii)
nsp << iAttributes[ii] << ',';
nsp << noshowbase << dec << "\n obtained px #" << pixelFormat
<< " of " << numFormats << "\n " << *obtainedPfd;
} // Debug
#endif
return pixelFormat;
}
Index3To1::Index3To1() {
indexSize = 0;
bitsPerChar = 0;
bitsPerCharX2 = 0;
qFill(maskByChar, maskByChar+256, 0);
}
bool PlotIO::write(const QString& path, const ros::Time& start, const ros::Time& end)
{
FileFormat* io = 0;
if(path.endsWith(".bag"))
io = new BagFormat;
else if(path.endsWith(".csv"))
io = new CSVFormat;
if(!io)
{
fprintf(stderr, "Could not find output format\n");
return false;
}
if(!io->init(path, start))
return false;
QLinkedList<Plot::LinkedBufferIterator> its = m_rootPlot->iterators(io->defaultFlags());
io->writeHeader(its);
QVector<Plot::LinkedBufferIterator*> to_write(its.size(), 0);
while(1)
{
ros::Time stamp = ros::Time(0);
qFill(to_write, (Plot::LinkedBufferIterator*)0);
// Get a list of iterators with the next timestamp
int i = 0;
for(QLinkedList<Plot::LinkedBufferIterator>::iterator it = its.begin(); it != its.end(); ++it, ++i)
{
Plot::LinkedBufferIterator& buf_it = *it;
if(!buf_it.isValid())
continue;
const Plot::DataPoint& point = *buf_it;
if(point.time < stamp || stamp == ros::Time(0))
{
qFill(to_write, (Plot::LinkedBufferIterator*)0);
to_write[i] = &buf_it;
stamp = point.time;
}
else if(point.time == stamp)
to_write[i] = &buf_it;
}
if(stamp == ros::Time(0))
break;
if(end != ros::Time(0) && stamp > end)
break;
if(stamp >= start)
io->writeData(stamp, to_write);
// Advance all used iterators
Q_FOREACH(Plot::LinkedBufferIterator* it, to_write)
{
if(!it)
continue;
++(*it);
}
}
delete io;
return true;
}
QByteArray huffman(QByteArray data, MainWindow *mainWindow)
{
// count
int count[tableSize];
qFill(&count[0], &count[tableSize - 1], 0);
for (int i = 0; i < data.size(); ++i)
++count[static_cast<quint8>(data[i])];
QMultiMap<int, QList<QPair<quint8, QBitArray> > > p; // <count, <symbol, code> >
for (int i = 0; i < tableSize; ++i)
{
if (count[i] == 0) continue;
QList<QPair<quint8, QBitArray> > list;
list.append(qMakePair(static_cast<quint8>(i), QBitArray()));
p.insert(count[i], list);
}
// caculate codes from bottom to top
while (p.size() > 1)
{
const int count0 = p.begin().key();
QList<QPair<quint8, QBitArray> > list0 = p.begin().value();
p.erase(p.begin());
const int count1 = p.begin().key();
QList<QPair<quint8, QBitArray> > list1 = p.begin().value();
p.erase(p.begin());
for (QList<QPair<quint8, QBitArray> >::Iterator iter = list0.begin(); iter != list0.end(); ++iter)
{
iter->second.resize(iter->second.size() + 1);
iter->second.setBit(iter->second.size() - 1, false);
}
for (QList<QPair<quint8, QBitArray> >::Iterator iter = list1.begin(); iter != list1.end(); ++iter)
{
iter->second.resize(iter->second.size() + 1);
iter->second.setBit(iter->second.size() - 1, true);
}
p.insert(count0 + count1, list0 + list1);
}
// extract codes
QHash<quint8, QBitArray> codes;
for (QList<QPair<quint8, QBitArray> >::ConstIterator iter = p.begin().value().constBegin(); iter != p.begin().value().constEnd(); ++iter)
{
QBitArray code;
code.resize(iter->second.size());
for (int j = 0; j < code.size(); ++j)
if (iter->second[code.size() - j - 1])
code.setBit(j);
codes[iter->first] = code;
}
// encode
QBitArray bits;
for (int i = 0; i < data.size(); ++i)
{
mainWindow->setProgress(qRound(static_cast<qreal>(100 * i) / data.size()));
const QBitArray &code = codes[static_cast<quint8>(data[i])];
const int oldSize = bits.size();
bits.resize(oldSize + code.size());
for (int i = 0; i < code.size(); ++i)
if (code[i]) bits.setBit(oldSize + i);
}
QByteArray result;
{
QDataStream stream(&result, QIODevice::WriteOnly);
stream << codes << static_cast<qint32>(data.size()) << bits;
}
return result;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QTextCodec::setCodecForLocale(QTextCodec::codecForName("GB2312"));
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("GB2312"));
QTextCodec::setCodecForTr(QTextCodec::codecForName("GB2312"));
QStringList list;
list<<"one"<<"two"<<"three";
qDebug()<<QObject::tr("qCopu() methord:");
QVector<QString>vect(3);
qCopy(list.begin(),list.end(),vect.begin());
qDebug()<<vect;
/****************************************************************************************************/
qDebug()<<endl<<QObject::tr("qEqual() methord:");
bool bl=qEqual(list.begin(),list.end(),vect.begin());
qDebug()<<bl;
// QList<QString>::iterator i;
// i=qFind(list.begin,list.end(),"two");
/****************************************************************************************************/
qDebug()<<endl<<QObject::tr("qFind() methord:");
QStringList::const_iterator i= qFind(list.begin(), list.end(), "two");
qDebug()<<*i;
/****************************************************************************************************/
qDebug()<<endl<<QObject::tr("qFill() methord:");
qFill(list.begin(),list.end(),"eleven");
qDebug()<<list;
/****************************************************************************************************/
QList<int>list2;
list2<<2<<31<<13<<2<<2<<2<<134<<2<<123<<4<<5<<3<<5<<51;
qDebug()<<endl<<QObject::tr("qCount() methord:");
int number=0;
qCount(list2.begin(),list2.end(),2,number);
qDebug()<<"The number of 2 is:"<<number;
qSort(list2);
QList<int>::iterator j=qLowerBound(list2.begin(),list2.end(),22);
list2.insert(j,22);
/****************************************************************************************************/
qDebug()<<list2;
qStableSort(list2);
qDebug()<<endl<<list2;
/****************************************************************************************************/
qSort(list2.begin(),list2.end(),qGreater<int>());
qDebug()<<endl<<list2;
/****************************************************************************************************/
qStableSort(list2.begin(),list2.end(),qGreater<int>());
qDebug()<<endl<<list2;
/****************************************************************************************************/
double d1=311.3998;
double d2=0.231314;
qDebug()<<endl<<"before swap:"<<d1<<" "<<d2;
qSwap(d1,d2);
qDebug()<<"then swap:"<<d1<<" "<<d2;
/****************************************************************************************************/
int int_a=qBound(2,49,12);
qDebug()<<"int_a="<<int_a;
QDateTime time = QDateTime::currentDateTime();
//QString s=time.toString("yyyy-MM-dd hh:mm:ss");
qDebug()<<time.toString();
return a.exec();
}
