linux下產生垃圾的工具 SnailRubbishFileFactory version0.003:)

#ifndef SNAILRUBBISHFILEFACTORY_H_
#define SNAILRUBBISHFILEFACTORY_H_

#include <qstring.h>
#include <qtimer.h>
#include <qfile.h>
#include <qdir.h>
#include <qimage.h>
#include <sys/select.h>
#include </usr/include/unistd.h> 

#include <fstream>
#include <iostream>

using std::ifstream;
using std::ofstream;
using std::fstream;
using std::ofstream;
using std::ios_base;
using std::cout;
using std::cin;
using std::endl;

#include <unistd.h>

void flushMemoryToDevice(){
    sync();
}

/*  date: 2007/01/10
 * version0.001 添加了產生垃圾檔案的功能
 * version0.002 添加了指定圖片檔案複製產生垃圾的功能   -copyImage
 * version0.003 添加了sync功能，每產生一個垃圾調用一次sync    -sync
 */

void millisleep(int ms) {
    if (ms>0) {
        struct timeval tv;
        tv.tv_sec=0;
        tv.tv_usec=ms*1000;
        select(0, 0, 0, 0, &tv);
    }
}

class SnailRubbishFileFactory {
public:
    SnailRubbishFileFactory(QString rubbishDir) :
        rubbishSum_(0), processedArgc_(1), copyFromImage_(false),flushMemToDev(false) {
        rubbishDir_ = rubbishDir;
    }

    bool processArgv(int argc, char *argv[]) {
        bool exitProgream = true;
        bool goToMakeRubbish = false;

        bool processDone = true;
        while (processDone) {
            QString argvString;

            //            qWarning("processedArgc_-->%d",processedArgc_);
            //            qWarning("argc--->%d",argc);
            if (processedArgc_<argc) {
                //如果還有命令列參數未處理，則處理
                argvString = QString(argv[processedArgc_]);
                processedArgc_++;
            } else {
                return goToMakeRubbish;
            }

            if (argvString==QString("-changedir")) {
                if (argc>processedArgc_) {
                    QString dir = QString(argv[processedArgc_]);
                    QDir d(dir);
                    if (d.exists()) {
                        rubbishDir_ = dir;
                        qWarning("change dir-->%s", rubbishDir_.latin1());
                    } else {
                        qWarning("no this dir-->%s", dir.latin1());
                        qWarning("use default->%s", rubbishDir_.latin1());
                    }
                } else {
                    qWarning("no dir specify!");
                    qWarning("use default->%s", rubbishDir_.latin1());
                }
                qWarning("##################");
                qWarning("-changedir done");
                qWarning("##################/n");
                processedArgc_++;
                continue;
            }

            if (argvString==QString("-sync")) {
                flushMemToDev = true;
                qWarning("##################");
                qWarning("-sync done");
                qWarning("##################/n");
                continue;
            }
           
            if (argvString==QString("-copyImage")) {
                if (argc>processedArgc_) {
                    copyImageName = QString(argv[processedArgc_]);
                    if (!QFile::exists(copyImageName)) {
                        qWarning("no this file-->%s", copyImageName.latin1());
                        return goToMakeRubbish;
                    }
                    copyImage_ = QImage(copyImageName);
                    copyFromImage_ = true;
                } else {
                    qWarning("no file specify!");
                    return goToMakeRubbish;
                }
                qWarning("##################");
                qWarning("-copyImage done");
                qWarning("##################/n");
                processedArgc_++;
                continue;
            }

            if (argvString==QString("clean")) {
                qWarning("clean [%s] rubbish! ", rubbishDir_.latin1());
                QDir rubbishDir(rubbishDir_);
                int removeNum = 0;
                for (unsigned int i=0; i<rubbishDir.count(); i++) {
                    if (rubbishDir[i]!="."&&rubbishDir[i]!="..") {
                        rubbishDir.remove(rubbishDir[i]);
                        removeNum++;
                    }
                }
                qWarning("remove rubbish num->%d", removeNum);
                qWarning("##################");
                qWarning("clean done");
                qWarning("##################/n");
                return exitProgream;
            }

            if (argvString==QString("--version")) {
                qWarning("Snail RubbishMaker version 0.003!");
                qWarning("0.001 ---> make empty rubbish only!");
                qWarning("0.002 ---> make specify image rubbish!");
                qWarning("0.003 ---> add system call  sync()!");
                return exitProgream;
            }

            if (argvString==QString("--help")) {
                qWarning("rubbish [-sync]  [[-copyImage] imageAbsPath ]  [[-check] ??KB] [[-changedir] dirpath]  [clean]  [--help] [--version]-- make  rubish game!!");
                return exitProgream;
            }

            if (argvString==QString("-check")) {
                if (argc>processedArgc_) {
                    QString goodRubbishValue = QString(argv[processedArgc_]);
                    int goodRubbishVal = goodRubbishValue.toInt();
                    qWarning("good rubbish size?-->%s", goodRubbishValue.latin1());

                    QDir rubbishDir(rubbishDir_);
                    //            if(argc>2){
                    //                QString ruubishSizeString(argv[2]);
                    //                int ruubishSize = ruubishSizeString.toInt();
                    //                cout << "-------------------------------------------------" << endl;
                    //                qWarning("good rubbish is %d KB!!!",ruubishSize);
                    //                cout << "-------------------------------------------------" << endl;
                    //            }
                    bool hasAbad = false;
                    for (unsigned int i=0; i<rubbishDir.count(); i++) {
                        if (rubbishDir.count()<=2) {
                            qWarning("no rubbish!");
                            return exitProgream;
                        }
                        if (rubbishDir[i]!="."&&rubbishDir[i]!="..") {
                            QFile f(rubbishDir.filePath(rubbishDir[i]));
                            if ((float)f.size()/1024!=(float)goodRubbishVal) {
                                hasAbad = true;
                                qWarning("%s ->%fKB", rubbishDir[i].latin1(), (float)f.size()/1024);
                            }
                        }
                    }
                    if (!hasAbad) {
                        qWarning("all rubbish is good!!!!!!!!!!!");
                    }
                } else {
                    qWarning("no goodrubbish size exist!");
                }
                qWarning("##################");
                qWarning("-check done");
                qWarning("##################/n");
                return exitProgream;
            }
        }
        return goToMakeRubbish;
    }

    void collectRubbishInfo() {
        qWarning("/n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
        qWarning("make rubbish --snail 2008/01/08");
        qWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! /n/n/n/n");
        int rubbishNum;
        cout << "-------------------------------------------------" << endl;
        cout << "[input Rubbish num:] " << endl;;
        cin >> rubbishNum;
        if (rubbishNum<=0) {
            rubbishNum = 10;
        }

        setRubbishNum(rubbishNum);
        cout << "Rubbish Num:" << rubbishNum << endl;
        cout << "-------------------------------------------------" << endl;

        if (!copyFromImage_) {
            int rubbishSize;
            cout << "-------------------------------------------------" << endl;
            cout << "[input RubbishSize(KB):] ";
            cin >> rubbishSize;
            if (rubbishSize<=0) {
                rubbishSize = 10;
            }
            setRubbishSize(rubbishSize);
            cout << "Rubbish Size(KB):" << rubbishSize << endl;
            cout << "-------------------------------------------------" << endl;
        }

        int speed;
        cout << "-------------------------------------------------" << endl;
        cout << "[input createRubbishSpeed(ms):] ";
        cin >> speed;
        if (speed<=0) {
            speed = 1;
        }
        setRubbishCreateSpeed(speed);
        cout << "Rubbish Size(KB):" << speed << endl;
        cout << "-------------------------------------------------" << endl;

    }

    void startMakeRubbish() {
        QString rubbishName;
        while (++rubbishSum_<=rubbishNum_) {
            rubbishName = QString(rubbishDir_).append("/").append("rubbish").append(QString::number(rubbishSum_));
            if (copyFromImage_) {
                rubbishName.append(".jpg");
                makeRubbishFromImage(rubbishName);
            } else {
                makeDefaultRubbish(rubbishName);
                qWarning("make rubbish -->%s", rubbishName.latin1());
            }
            if(flushMemToDev){
                flushMemoryToDevice();
            }
            millisleep(makeRubbishSpeed_);
        }
        qWarning("------------------enjoy u rubbish!-------------------");
    }

private:
    int rubbishNum_;
    int rubbishKBSize_;
    int makeRubbishSpeed_;

    int rubbishSum_;
    QString rubbishDir_;
    int processedArgc_;

    QImage copyImage_;
    QString copyImageName;
    bool copyFromImage_;
   
    bool flushMemToDev;

    void setRubbishNum(int num) {
        rubbishNum_ = num;
    }

    void setRubbishSize(int numK) {
        rubbishKBSize_ = numK;
    }

    void setRubbishCreateSpeed(int sec) {
        makeRubbishSpeed_ = sec;
    }

    void makeDefaultRubbish(QString name) {
        ofstream to(name.latin1(), ios_base::binary);
        if (!to) {
            qWarning("cannot open the file:%s", name.latin1());
            return;
        }
        static char buf[1024];
        int sum = 0;
        do {
            to.write(buf, 1024);
            sum++;
        } while (sum < rubbishKBSize_);
        to.close();
    }

    void makeRubbishFromImage(QString name) {
        static const char* format = QImage::imageFormat(copyImageName);
        copyImage_.save(name, format);
        qWarning("make Image rubbish -->%s", name.latin1());
    }
};

int main(int argc, char *argv[]) {
#ifndef ARM_VERSION
    QString dir = "/home/snail/Desktop/rubbish";
#else
    QString dir = "/mmc/rubbish";
#endif //ARM_VERSION
    SnailRubbishFileFactory factory(dir);

    if (factory.processArgv(argc, argv)) {
        return 0;
    }

    factory.collectRubbishInfo();
    factory.startMakeRubbish();
}

#endif /*SNAILRUBBISHFILEFACTORY_H_*/