C++ Q3ValueVector类代码示例

void tst_Q3ValueVector::resize()
{
    Q3ValueVector<int> a;
    a.resize( 2 );

    QVERIFY( a.size() == 2 );

    Q3ValueVector<int> b;
    b.resize( 2, 42 );

    QVERIFY( b.size() == 2 );
    QCOMPARE( b[0], 42 );
    QCOMPARE( b[1], 42 );

    b.resize( 1 );
    QVERIFY( b.size() == 1 );

    b.resize( 4, 21 );
    QCOMPARE( b[0], 42 );
    QCOMPARE( b[1], 21 );
    QCOMPARE( b[2], 21 );
    QCOMPARE( b[3], 21 );

    b.resize( 0 );
    QVERIFY( b.empty() );

}

void tst_Q3ValueVector::insert()
{
    // insert at the beginning
    Q3ValueVector<int> a;
    a.insert( a.begin(), 1 );
    QCOMPARE( a[0], 1 );

    // insert at the end
    a.insert( a.end(), 2 );
    QCOMPARE( a[1], 2 );
    // insert in the middle
    Q3ValueVector<int>::iterator it_a = a.begin();
    a.insert( ++it_a, 3 );
    QCOMPARE( a[1], 3 );

    // now testing the overloaded insert() which takes an
    // argument for the number of items to insert

    // we'll insert two of each value

    Q3ValueVector<int> b;
    b.insert( b.begin(), 2, 1 );
    QCOMPARE( b[0], 1 );
    QCOMPARE( b[1], 1 );

    // insert at the end
    b.insert( b.end(), 2, 2 );
    QCOMPARE( b[2], 2 );
    QCOMPARE( b[3], 2 );

    // insert in the middle
    Q3ValueVector<int>::iterator it_b = b.begin();
    b.insert( ++++it_b, 2, 3 );
    QCOMPARE( b[2], 3 );
    QCOMPARE( b[3], 3 );
}

void renderCode128(const QRect & r, const QString & _str, int align, QPainter * pPainter) {
    Q3ValueVector<int> str;
    int i = 0;

    // create the list.. if the list is empty then just set a start code and move on
    if(_str.isEmpty()) {
        str.push_back(104);
    } else {
        int rank_a = 0;
        int rank_b = 0;
        int rank_c = 0;

        QChar c;
        for(i = 0; i < _str.length(); i++) {
            c = _str.at(i);
            rank_a += (code128Index(c, SETA) != -1 ? 1 : 0);
            rank_b += (code128Index(c, SETB) != -1 ? 1 : 0);
            rank_c += (c >= '0' && c <= '9' ? 1 : 0);
        }
        if(rank_c == _str.length() && ((rank_c % 2) == 0 || rank_c > 4)) {
            // every value in the is a digit so we are going to go with mode C
            // and we have an even number or we have more than 4 values
            i = 0;
            if((rank_c % 2) == 1) {
                str.push_back(104); // START B
                c = _str.at(0);
                str.push_back(code128Index(c, SETB));
                str.push_back(99); // MODE C
                i = 1;
            } else {
                str.push_back(105); // START C
            }
            for(i = i; i < _str.length(); i+=2) {
                char a, b;
                c = _str.at(i);
                a = c.toAscii();
                a -= 48;
                c = _str.at(i+1);
                b = c.toAscii();
                b -= 48;
                str.push_back(int((a * 10) + b));
            }
        } else {
            // start in the mode that had the higher number of hits and then
            // just shift into the opposite mode as needed
            int set = ( rank_a > rank_b ? SETA : SETB );
            str.push_back(( rank_a > rank_b ? 103 : 104 ));
            int v = -1;
            for(i = 0; i < _str.length(); i++) {
                c = _str.at(i);
                v = code128Index(c, set);
                if(v == -1) {
                    v = code128Index(c, (set == SETA ? SETB : SETA));
                    if(v != -1) {
                        str.push_back(98); // SHIFT
                        str.push_back(v);
                    }
                } else {
                    str.push_back(v);
                }
            }
        }
    }

    // calculate and append the checksum value to the list
    int checksum = str.at(0);
    for(i = 1; i < str.size(); i++) {
        checksum += (str.at(i) * i);
    }
    checksum = checksum % 103;
    str.push_back(checksum);

    // lets determine some core attributes about this barcode
    int bar_width = 1; // the width of the base unit bar

    // this is are mandatory minimum quiet zone
    int quiet_zone = bar_width * 10;
    if(quiet_zone < 10) quiet_zone = 10;

    // what kind of area do we have to work with
    int draw_width = r.width();
    int draw_height = r.height();

    // how long is the value we need to encode?
    int val_length = str.size() - 2; // we include start and checksum in are list so
                                     // subtract them out for our calculations

    // L = (11C + 35)X 
    // L length of barcode (excluding quite zone) in units same as X and I
    // C the number of characters in the value excluding the start/stop and checksum characters
    // X the width of a bar (pixels in our case)
    int L;

    int C = val_length;
    int X = bar_width;

    L = (((11 * C) + 35) * X);

    // now we have the actual width the barcode will be so can determine the actual
    // size of the quiet zone (we assume we center the barcode in the given area
//.........这里部分代码省略.........

QString EQStr::formatMessage(uint32_t formatid,
                             const char* arguments, size_t argsLen) const
{
    QString* formatStringRes = m_messageStrings.find(formatid);

    QString tempStr;

    if (formatStringRes == NULL)
    {
        tempStr.sprintf( "Unknown: %04x: ",
                         formatid);
        tempStr += QString::fromUtf8(arguments);

        size_t totalArgsLen = strlen(arguments) + 1;

        const char* curMsg;
        while (totalArgsLen < argsLen)
        {
            curMsg = arguments + totalArgsLen;
            tempStr += QString(", ") + QString::fromUtf8(curMsg);
            totalArgsLen += strlen(curMsg) + 1;
        }
    }
    else
    {
        Q3ValueVector<QString> argList;
        argList.reserve(5); // reserve space for 5 elements to handle most common sizes

        //
        size_t totalArgsLen = 0;
        const char* curArg;
        while (totalArgsLen < argsLen)
        {
            curArg = arguments + totalArgsLen;
            // insert argument into the argument list
            argList.push_back(QString::fromUtf8(curArg));
            totalArgsLen += strlen(curArg) + 1;
        }

        bool ok;
        int curPos;
        size_t substArg;
        int substArgValue;
        QString* substFormatStringRes;
        QString substFormatString;

        ////////////////////////////
        // replace template (%T) arguments in formatted string
        QString formatString = *formatStringRes;
        QRegExp rxt("%T(\\d{1,3})", true, false);

        // find first template substitution
        curPos = rxt.search(formatString, 0);

        while (curPos != -1)
        {
            substFormatStringRes = NULL;
            substArg = rxt.cap(1).toInt(&ok);
            if (ok && (substArg <= argList.size()))
            {
                substArgValue = argList[substArg-1].toInt(&ok);

                if (ok)
                    substFormatStringRes = m_messageStrings.find(substArgValue);
            }

            // replace template argument with subst string
            if (substFormatStringRes != NULL)
                formatString.replace(curPos, rxt.matchedLength(), *substFormatStringRes);
            else
                curPos += rxt.matchedLength(); // if no replacement string, skip over

            // find next substitution
            curPos = rxt.search(formatString, curPos);
        }

        ////////////////////////////
        // now replace substitution arguments in formatted string
        // NOTE: not using QString::arg() because not all arguments are always used
        //       and it will do screwy stuff in this situation
        QRegExp rx("%(\\d{1,3})", true, false);

        // find first template substitution
        curPos = rx.search(formatString, 0);

        while (curPos != -1)
        {
            substArg = rx.cap(1).toInt(&ok);

            // replace substitution argument with argument from list
            if (ok && (substArg <= argList.size()))
                formatString.replace(curPos, rx.matchedLength(), argList[substArg-1]);
            else
                curPos += rx.matchedLength(); // if no such argument, skip over

            // find next substitution
            curPos = rx.search(formatString, curPos);
        }

        return formatString;
//.........这里部分代码省略.........