Porting to the Qt C++ Framework :: Part 4

Jun 2nd, 10 / 0 Comments /

Having created a shell of our app in step 2, porting the image cleaner code in step 3, we’re now at the stage where we can to port our command line XML cleaner code to Qt. At the end of this post we’ll have a fully functioning C++ Qt app.

The Original ‘Command Line’ Code

  1.     // xml files
  2.     std::cout << "Starting file clean…\n";
  3.  
  4.     string fileData;
  5.  
  6.     d = opendir(storyPath.c_str());
  7.  
  8.     if (d) {
  9.  
  10.         // low memory, no parallelization
  11.         while ((dir = readdir(d)) != NULL) {
  12.             name = dir->d_name;
  13.             location = storyPath + "/" + name;
  14.  
  15.             if (name != "." && name != ".." && name != ".DS_Store") {
  16.  
  17.                 // ==> buffer
  18.  
  19.                 // alternative version of buffer – we lose the
  20.                 // BOM issue, but have to create \r\n
  21.                 string fileData2;
  22.                 string buff;
  23.                 ifstream file;
  24.                 file.open(location.c_str());
  25.  
  26.                 while (getline(file, fileData2)) {
  27.                     buff += fileData2 + "\r\n";
  28.                 }
  29.                 fileData = buff;
  30.  
  31.                 // == remove extra headline data
  32.                 int hl1Start = fileData.find("");
  33.                 int hl1End = fileData.find("");
  34.  
  35.                 if (hl1Start != -1 && hl1End != -1) {
  36.  
  37.                     replaceString = fileData.substr(hl1Start,
  38.                             (hl1End - hl1Start));
  39.  
  40.                     p = replaceString.find(br);
  41.                     while (p != -1) {
  42.                         replaceString.erase(p, 5);
  43.                         p = replaceString.find(br);
  44.                     }
  45.  
  46.                     p = replaceString.find(rl);
  47.                     while (p != -1) {
  48.                         replaceString.erase(p, 2);
  49.                         p = replaceString.find(rl);
  50.                     }
  51.  
  52.                     p = replaceString.find(nl);
  53.                     while (p != -1) {
  54.                         replaceString.erase(p, 2);
  55.                         p = replaceString.find(nl);
  56.                     }
  57.  
  58.                     // join data
  59.                     fileData.replace(hl1Start, (hl1End - hl1Start),
  60.                         replaceString);
  61.  
  62.                 } // hl1 exists
  63.  
  64.                 // == replace all instances with open p then find
  65.                 // the next \r\n and add a
  66.  
  67.                 int bodyStart = fileData.find("");
  68.                 int bodyEnd = fileData.find("");
  69.  
  70.                 int innerp;
  71.  
  72.                 if (bodyStart != -1 && bodyEnd != -1) {
  73.  
  74.                     replaceString = fileData.substr(bodyStart,
  75.                             (bodyEnd - bodyStart));
  76.  
  77.                     p = replaceString.find(doublebr);
  78.                     counter = 0;
  79.                     int matchingP = 0;
  80.                     while (p != -1) {
  81.  
  82.                         replaceString.replace(p, doublebr.size(), openp);
  83.                         matchingP = 1;
  84.  
  85.                         // next \r\n [Mac Uses nl, Windows rn]
  86.                         innerp = replaceString.find(rn, p);
  87.  
  88.                         if (innerp != -1) {
  89.                             replaceString.replace(innerp, rn.size(), closep);
  90.                             matchingP = 0;
  91.                         }
  92.  
  93.                         p = replaceString.find(doublebr, p);
  94.  
  95.                         if (matchingP == 1) {
  96. #if DEBUG == true
  97.                             cout << "Hanging p" << endl;
  98. #endif
  99.                             replaceString.append(closep);
  100.                         }
  101.  
  102.                         counter++;
  103.                     }
  104.  
  105.                     // join data
  106.                     fileData.replace(bodyStart, (bodyEnd - bodyStart),
  107.                         replaceString);
  108.  
  109.                 } // bodyEnd exists
  110.  
  111.                 // save file
  112. #if DEBUG == true
  113.                 ofstream outfile((location + "-debug.xml").c_str(),
  114.                     ofstream::binary);
  115. #else
  116.                 ofstream outfile((location).c_str(), ofstream::binary);
  117. #endif
  118.  
  119.                 outfile.write(fileData.c_str(), fileData.size());
  120.  
  121.             }
  122.  
  123.         } // while()
  124.  
  125.     }

We perform a couple of distinct steps in this code. First, we open our directory for iteration with:

  1. while ((dir = readdir(d)) != NULL) {
  2. name = dir->d_name;
  3. […]

And then write the contents of the file into a buffer with:

  1. // BOM issue, but have to create \r\n
  2. string fileData2;
  3. string buff;
  4. ifstream file;
  5. file.open(location.c_str());
  6.  
  7. while (getline(file, fileData2)) {
  8. buff += fileData2 + "\r\n";
  9. }
  10. fileData = buff;

Not too complicated: We use getline() to only get the raw text of a line, to which we then add a \r\n. We do this because part of our task is to recreate proper tags, and it just so happens that so long as we know where our line breaks are, we can do so reliably. Adding our own line break tags means cross-platform differences will be eliminated, plus our p tag code will run exactly as intended.

The remainder of the code removes extra formatting from headline elements, as well as adds p tags in proper order and sequence. Most of this logic, as it turns out, was the same in Qt, though we did have some significant differences in key locations.

The New Code

The new code segment is the result of a fair bit of experimentation. The command line version was in fact easier to create, though only because of the higher availability of resources for performing file opening, string manipulation, and file writing in plain old C++.

  1. QString Worker::cleanXMLStoryFiles()
  2. {
  3.     this->statusMessage = "Starting XML File Clean…";
  4.  
  5.     // locals
  6.     QString replaceString;
  7.     QString fileData;
  8.  
  9.     // create buffer for semaphores
  10.     uint count = QDir(this->xmlPath).count();
  11.     QString t = QString::number(count);
  12.  
  13.     // loop and clean
  14.     QDirIterator it(this->xmlPath, QDirIterator::Subdirectories);
  15.  
  16.     do{
  17.  
  18.         // reset on every turn
  19.         fileData = "";
  20.  
  21.         // open file data
  22.         QFile f(it.filePath());
  23.         if(f.open(QIODevice::ReadWrite)){
  24.  
  25.             QTextStream in(&f);
  26.  
  27.             do{
  28.                 fileData += in.readLine() += "\r\n";
  29.             } while(!in.atEnd());
  30.  
  31.         }
  32.  
  33.         // remove extra headline data
  34.         int hl1Start = fileData.indexOf("");
  35.         int hl1End = fileData.indexOf("");
  36.  
  37.         if(hl1Start != -1 && hl1End != -1){
  38.  
  39.             replaceString = fileData.mid(hl1Start, (hl1End - hl1Start));
  40.  
  41.             replaceString = replaceString.replace(this->br, "");
  42.             replaceString = replaceString.replace(this->rl, "");
  43.             replaceString = replaceString.replace(this->nl, "");
  44.  
  45.             // join data
  46.             fileData.replace(hl1Start, (hl1End - hl1Start), replaceString);
  47.  
  48.         } // hl1
  49.  
  50.         // remove p tags and extra spaces
  51.         int bodyStart = fileData.indexOf("");
  52.         int bodyEnd = fileData.indexOf("");
  53.  
  54.         int innerp;
  55.         int counter = 0;
  56.         int matchingP = 0;
  57.         int p;
  58.  
  59.         if(bodyStart != -1 && bodyEnd != -1){
  60.  
  61.             replaceString = fileData.mid(bodyStart, (bodyEnd - bodyStart));
  62.  
  63.             p = replaceString.indexOf(this->doublebr);
  64.             counter = 0;
  65.             matchingP = 0;
  66.  
  67.             while(p != -1){
  68.  
  69.                 replaceString.replace(p, doublebr.size(), this->openp);
  70.                 matchingP = 1;
  71.  
  72.                 // next \r\n [Mac Uses nl, Windows rn]
  73.                 innerp = replaceString.indexOf(rn, p);
  74.  
  75.                 if(innerp != -1){
  76.                     replaceString.replace(innerp, rn.size(), closep);
  77.                     matchingP = 0;
  78.                 }
  79.  
  80.                 p = replaceString.indexOf(doublebr, p);
  81.  
  82.                 if(matchingP == 1){
  83. #if DEBUG == true
  84.                     this->statusMessage += "\nHanging P Found And Fixed\n";
  85. #endif
  86.                     replaceString.append(closep);
  87.                 }
  88.  
  89.                 counter++;
  90.             }
  91.  
  92.             // join data
  93.             fileData.replace(bodyStart, (bodyEnd - bodyStart), replaceString);
  94.  
  95.         } // innner p
  96.  
  97.         // write file
  98.         if(it.fileName() != "."
  99.                     && it.fileName() != ".."
  100.                     && it.fileName() != ".DS_Store"){
  101. #if DEBUG == true
  102.             QString outPath = it.filePath() += "-new.xml";
  103. #else
  104.             QString outPath = it.filePath();
  105. #endif
  106.             QFile outData(outPath);
  107.             outData.open(QFile::WriteOnly);
  108.             QTextStream outFile(&outData);
  109.             outFile << fileData;
  110.         }
  111.  
  112.     } while(it.next() != "");
  113.  
  114.     this->statusMessage += "\nXML File Clean Complete.";
  115.  
  116.     return this->statusMessage;
  117. }

Some key points are as follows:

The method used to iterate through a directory:

  1. QDirIterator it(this->xmlPath, QDirIterator::Subdirectories);
  2. do{
  3.    […]
  4. } while(it.next() != "");

…feels a bit strange to me, almost as if I’m missing something. Specifically, the while() statement checks for an empty string if no further files are found. This just seems…wrong to me, but I could be mistaken. For the record, examples given in Qt help documentation had a flaw of never returning the last element of a directory. For example, if we had four items, only three would be iterated through. The do { } while() was the only way I found to hit all files.

As similar as the core logic is, here’s where things take a pretty radical departure from the command line version.

  1. // reset on every turn
  2.         fileData = "";
  3.  
  4.         // open file data
  5.         QFile f(it.filePath());
  6.         if(f.open(QIODevice::ReadWrite)){
  7.  
  8.             QTextStream in(&f);
  9.  
  10.             do{
  11.                 fileData += in.readLine() += "\r\n";
  12.             } while(!in.atEnd());
  13.  
  14.         }

In this code we’re using the handy QTextStream on an address of a QFile object to read each line of text, to which we add the \r\n to, just like the command line version.

We also save a chunk of time here by using REGEX enabled replace method to remove unwanted tags from the headline text:

  1. replaceString = replaceString.replace(this->br, "");
  2. replaceString = replaceString.replace(this->rl, "");
  3. replaceString = replaceString.replace(this->nl, "");

As you may recall in the old code we used a more complex:

  1. p = replaceString.find(rl);
  2. while (p != -1) {
  3.  replaceString.erase(p, 2);
  4.   p = replaceString.find(rl);
  5. }

The last part, the section where we add our properly closed p tags, is largely untouched, save for using indexOf() instead of find(), as well as using mid() to build our temporary string for editing.

The last step was to write the fixed file back to the file system. In the first version we used the rather succinct ofstream to do the job, The new version used a more complex series of command as:

  1. #if DEBUG == true
  2.             QString outPath = it.filePath() += "-new.xml";
  3. #else
  4.             QString outPath = it.filePath();
  5. #endif
  6.             QFile outData(outPath);
  7.             outData.open(QFile::WriteOnly);
  8.             QTextStream outFile(&outData);
  9.             outFile << fileData;

Of course we may have a more simplistic way of doing this, but I didn’t find one.

Closing Thoughts

The end result of our project is a slick little Qt desktop app that removed the burden of command line operation for its use. However, as nice as this may be for the end-user, as a developer what I was most curious to see was if Qt would stand up to the challenge of being user friendly, powerful, and at the same time, a joy to work with.

Simple answer: It was. Qt is simply brilliant–I’m sold, hooked, and thoroughly excited to learn and do more with this library. It’s all the power and functionality of C++, but wrapped into a cross platform, easy to use deployment platform with powerful tools and solid documentation.

Though of course this is somewhat relative when it comes to porting command line app to a GUI. Our command line app weighed in at 223 lines, Qt: 368. While it was very easy to find examples of file operation for vanilla C++ on the web, it was markedly more difficult for Qt. In fact, as hinted at in the text I’m still quite unsure of the “properness” of this code. It works well enough, but am I missing something?

Do I really need to used a QTextStream to write data, or should I have used the more low-level write() function inherited from QIODevice? This question reminds me of the difference in PHP between using:

  1. $content = "Sample";
  2. $res = file_put_contents($content);

verses using:

  1. $content = "Sample";
  2. $handle = fopen("somefile.txt", "wb");
  3. $res = fwrite($handle, $content, strlen($content));

In short, one simple step vs. a few more obtuse ones. It’s by no means wrong, but I can’t help but wonder…

Of course it should also be said that this program could use more error and sanity checks if it was to ever be released an a commercial app, but in this case, it’s just for pedagogical purposes.

Complete Application Source Download

Being a Qt app you should be able to run this code (build) on any platform Qt supports.
Download cleaner.zip

C++
<< >>

Leave a Comment

* are Required fields