C++ QList::swap方法代码示例

//@function     testing function
void testor(void)
{

    qDebug() << LEFT(2);
    qDebug() << RIGHT(2);
    qDebug() << PARENT(5);
    qDebug() << PARENT(6);

    QList<QPoint> openlist;
    openlist.push_back(QPoint(1,0));
    openlist.push_back(QPoint(0,1));
    openlist.push_back(QPoint(2,1));
    openlist.push_back(QPoint(2,3));
    openlist.push_back(QPoint(1,1));

    for (int i =0; i< openlist.size(); i++)
        qDebug() << openlist.at(i);

    for (int i=0; i< openlist.size(); i++)
    {
        for(int j=i+1; j< openlist.size(); j++)
        {
            if (openlist.at(i).x()>openlist.at(j).x())
                openlist.swap(i,j);
            else if ((openlist.at(i).x()==openlist.at(j).x()) && openlist.at(i).y()>openlist.at(j).y())
                openlist.swap(i,j);

        }
    }
    qDebug() << "-----------------";
    for (int i =0; i< openlist.size(); i++)
        qDebug() << openlist.at(i);

}

QList< VdpVideoSurface > MPEGDecoder::getOrderedFrames()
{
   QList< VdpVideoSurface > list;
   int j;
   for ( j=0; j<NUMSURFACES; ++j ) {
      MPEGFrame *frame = frames.at( j );

      frame->info.backward_reference = VDP_INVALID_HANDLE;
      frame->info.forward_reference = VDP_INVALID_HANDLE;
      if ( frame->info.picture_coding_type==P_FRAME )
         frame->info.forward_reference = backwardRef;
      else if ( frame->info.picture_coding_type==B_FRAME ) {
         frame->info.forward_reference = forwardRef;
         frame->info.backward_reference = backwardRef;
      }

      VdpBitstreamBuffer vbit;
      vbit.struct_version = VDP_BITSTREAM_BUFFER_VERSION;
      vbit.bitstream = frame->data;
      vbit.bitstream_bytes = frame->dataLength;
      VdpStatus st = vc->vdp_decoder_render( decoder, surfaces[j], (VdpPictureInfo*)&frame->info, 1, &vbit );
      if ( st != VDP_STATUS_OK )
         fprintf( stderr, "MPEGDecoder: decoding failed: %s!\n", vc->vdp_get_error_string( st ) );


      if ( frame->info.picture_coding_type!=B_FRAME ) {				
         forwardRef = backwardRef;
         backwardRef = surfaces[j];
      }
   }

   QList< int > framesType;
   for ( j=0; j<NUMSURFACES; ++j ) {
      framesType.append( frames.at(j)->info.picture_coding_type );
      list.append( surfaces[j] );
   }

   j = 1;
   while ( j<NUMSURFACES ) {
      if ( framesType.at(j)==B_FRAME ) {
         framesType.swap(j-1, j);
         list.swap(j-1, j);
      }
      else
         ++j;
   }

   vc->vdp_decoder_destroy( decoder );
   decoder = VDP_INVALID_HANDLE;

   return list;
}

void tst_QList::swap() const
{
    QList<QString> list;
    list << "foo" << "bar" << "baz";

    // swap
    list.swap(0, 2);
    QCOMPARE(list, QList<QString>() << "baz" << "bar" << "foo");

    // swap again
    list.swap(1, 2);
    QCOMPARE(list, QList<QString>() << "baz" << "foo" << "bar");
}

QList<Experience> SystemeMotivationnel::exp(const Resultat & r) const
{
    QList<Experience> rt;
    QList<Interaction> temp;
    foreach (const Interaction& it, m_systeme)
    {
        if(r == it.resultat())
        {
            temp<<it;
        }
    }

    for(int i = 0; i < temp.size(); i ++)
    {
        for(int j = i; j < temp.size(); j ++)
        {
            //qDebug()<<temp[i].toString()<<temp[i].motivation()<<temp[j].toString()<<temp[j].motivation();

            if(temp[i] < temp[j])
            {
                temp.swap(i,j);
            }
        }
    }

    foreach (const Interaction& it, temp)
    {
        rt<<it.experience();
    }

    return rt;
}

QList<Media*> Playlist::shufflePlaylist(QList<Media *> media)
{
    for (int i = media.size()-1; i >= 0; i--)
    {

          int j = (int) (((float)qrand()/RAND_MAX) * i);
          media.swap(j, i);
    }
    return media;
}

void MReportDataAdapter::BubbleSort(QList<EventInfo *> &list)
{
    for (int i = 0; i < list.count(); i++)
    {
        for (int j = 0; j < list.count() - 1 - i; j++)
        {
            if (list.at(j)->magnitude < list.at(j+1)->magnitude)
            {
                list.swap(j, j+1);
            }
        }
    }
}

QList<QPolygonF> PathSorter::MyFakeTSP(const QList<QPolygonF> inpaths)
{
	QPolygonF zero = QPolygonF(QRectF(0.0,mediaHeight,0.0,0.0)); // able to change the start point

	QList<QPolygonF> outpaths = QList<QPolygonF>(inpaths);

	// find the shortest path
	for (int i = 0; i < (outpaths.size()-1); ++i)
	{
		if(i == 0) // find good start
		{
			qreal dist=10000.0;
			int bestindex=i;
			for (int j = (i+1); j < outpaths.size(); ++j)
			{
				if (getDistance(zero,outpaths[j]) < dist) 
				{
				dist = getDistance(zero,outpaths[j]);
				bestindex = j;
				}
				
			}
			if (dist != 0) outpaths.swap(0,bestindex);
		}
		qreal dist=10000.0;
		int bestindex=i;
		for (int j = (i+1); j < outpaths.size(); ++j)
		{
			if (getDistance(outpaths[i],outpaths[j]) < dist) 
			{
				dist = getDistance(outpaths[i],outpaths[j]);
				bestindex = j;
			}
		}
		if (dist != 0) outpaths.swap((i+1),bestindex);
	}
	return outpaths;
}

QList<QVariantList>
ImporterSqlConnection::query( const QString &query, const QVariantMap &bindValues,
                              bool* const ok )
{
    QMutexLocker lock( &m_apiMutex );

    QMetaObject::invokeMethod( this, "slotQuery", blockingConnectionType(),
                               Q_ARG( QString, query ), Q_ARG( QVariantMap, bindValues ),
                               Q_ARG( bool* const, ok ) );

    QList<QVariantList> result;
    result.swap( m_result );
    return result;
}

QList<int>* Util::randomArray(int N)
{
    // http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
    QList<int> *lst = new QList<int>();
    lst->reserve(N);

    for (int i=0; i<N; ++i)
        (*lst)[i] = i;

    for (int i=0; i<N; ++i) {
        int n = randInt(i, N-1);
        lst->swap(i, n);
    }

    return lst;
}

/*!
    \internal
*/
bool QImageReaderPrivate::initHandler()
{
    // check some preconditions
    if (!device || (!deleteDevice && !device->isOpen() && !device->open(QIODevice::ReadOnly))) {
        imageReaderError = QImageReader::DeviceError;
        errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Invalid device"));
        return false;
    }

    // probe the file extension
    if (deleteDevice && !device->isOpen() && !device->open(QIODevice::ReadOnly) && autoDetectImageFormat) {
        QList<QByteArray> extensions = QImageReader::supportedImageFormats();
        if (!format.isEmpty()) {
            // Try the most probable extension first
            int currentFormatIndex = extensions.indexOf(format.toLower());
            if (currentFormatIndex > 0)
                extensions.swap(0, currentFormatIndex);
        }

        int currentExtension = 0;

        QFile *file = static_cast<QFile *>(device);
        QString fileName = file->fileName();

        do {
            file->setFileName(fileName + QLatin1Char('.')
                    + QString::fromLatin1(extensions.at(currentExtension++).constData()));
            file->open(QIODevice::ReadOnly);
        } while (!file->isOpen() && currentExtension < extensions.size());

        if (!device->isOpen()) {
            imageReaderError = QImageReader::FileNotFoundError;
            errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "File not found"));
            file->setFileName(fileName); // restore the old file name
            return false;
        }
    }

    // assign a handler
    if (!handler && (handler = createReadHandlerHelper(device, format, autoDetectImageFormat, ignoresFormatAndExtension)) == 0) {
        imageReaderError = QImageReader::UnsupportedFormatError;
        errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Unsupported image format"));
        return false;
    }
    return true;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QList<QString> list;
    list << "aa" << "bb" << "cc";
    if(list[1] == "bb")
    {
        list[1] = "ab";
    }
    list.replace(2,"bc");
    qDebug() << "the list is:";
    for(int i = 0;i<list.size();++i)
    {
        qDebug()<<list.at(i);
    }
    list.append("dd");
    list.prepend("mm");

    QString str = list.takeAt(2);
    qDebug()<<"at(2) item is:"<<str;
    qDebug()<<"the list is:";
    for(int i = 0;i<list.size();++i)
    {
        qDebug()<<list.at(i);
    }
    list.insert(2,"mm");
    list.swap(1,3);
    qDebug()<<"the list is:";
    for(int i = 0;i<list.size();++i)
    {
        qDebug()<<list.at(i);
    }
    qDebug()<<"contains 'mm'?"<<list.contains("mm");
    qDebug()<<"the 'mm' count:"<<list.count("mm");
    qDebug()<<"the first 'mm' index:"<<list.indexOf("mm");
    qDebug()<<"the second 'mm' index:"<<list.indexOf("mm",1);



    return a.exec();
}

QList<QPolygonF> PathSorter::BbSort (const QList<QPolygonF> inpaths)
{
	QList<QPolygonF> outpaths = QList<QPolygonF>(inpaths);
	for (int i = 0; i < (outpaths.size()-1); i++)
	{
		for (int j = (i+1); j < outpaths.size(); j++)
		{
		if (outpaths[i].boundingRect().intersects(outpaths[j].boundingRect()))
			{
				if (outpaths[i].boundingRect().width() > outpaths[j].boundingRect().width() || outpaths[i].boundingRect().height() > outpaths[j].boundingRect().height()) 
				{
					outpaths.swap(i,j);
					break;
				}
			}
		}
	}
	cout<<"BbSort outpaths: "<< getTotalDistance(outpaths) << endl;
	return outpaths;
}

void EncodingTree::fill(){

    QList<EncondingNode *> lista = DList;

    while(lista.size() > 1)
    {

        EncondingNode *tmp = new EncondingNode(lista.at(0)->getFrequency() + lista.at(1)->getFrequency());
        int z = 0;

        tmp->setLeft(lista.at(0));
        tmp->setRight(lista.at(1));
        tmp->setType(1);

        lista.removeAt(0);
        lista.removeAt(0);
        lista.insert(z, tmp);

        root = tmp;

        while(1)
        {
            if(z == lista.size() - 1)
            {
                break;
            }
            if(lista.at(z)->getFrequency() > lista.at(z + 1)->getFrequency())
            {
                lista.swap(z,z+1);
            }
            else
            {
                break;
            }
            z++;
        }
    }
}

void LayerListModel::handleMoveLayer(int oldIdx, int newIdx)
{
	// Need at least two layers for this to make sense
	const int count = _items.count();
	if(count < 2)
		return;

	QList<uint16_t> layers;
	layers.reserve(count);
	foreach(const LayerListItem &li, _items)
		layers.append(li.id);

	if(newIdx>oldIdx)
		--newIdx;

	layers.move(oldIdx, newIdx);

	// Layers are shown topmost first in the list but
	// are sent bottom first in the protocol.
	for(int i=0;i<count/2;++i)
		layers.swap(i,count-(1+i));

	emit layerOrderChanged(layers);
}

void VListCF::determineChildren()
{
	// Get the single items from the list of composite items.
	QList< Item* > items = extractSingleItems();

	// Inserts elements that are not yet visualized and adjusts the order to match that in 'nodes'.
	for (int i = 0; i < node()->size(); ++i)
	{
		if (i >= items.size() ) items.append( renderer()->render(this, node()->at<Node>(i)));	// This node is new
		else if ( items[i]->node() == node()->at<Node>(i) )	continue;	// This node is already there
		else
		{
			// This node might appear somewhere ahead, we should look for it
			bool found = false;
			for (int k = i + 1; k<items.size(); ++k)
			{
				if ( items[k]->node() == node()->at<Node>(i) )
				{
					// We found this node, swap the visualizations
					items.swap(i, k);
					found = true;
					break;
				}
			}

			// The node was not found, insert a visualization here
			if (!found ) items.insert(i, renderer()->render(this, node()->at<Node>(i)));
		}
	}

	// Remove excess items
	while (items.size() > node()->size()) items.removeLast();

	// Convert the single items list back to a list of composite items.
	buildCompositeItems(items);
}