versionnumber.cpp

Go to the documentation of this file.
00001 /*
00002     Copyright (C) 2008  Tim Fechtner < urwald at users dot sourceforge dot net >
00003 
00004     This program is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU General Public License as
00006     published by the Free Software Foundation; either version 2 of
00007     the License or (at your option) version 3 or any later version
00008     accepted by the membership of KDE e.V. (or its successor approved
00009     by the membership of KDE e.V.), which shall act as a proxy
00010     defined in Section 14 of version 3 of the license.
00011 
00012     This program is distributed in the hope that it will be useful,
00013     but WITHOUT ANY WARRANTY; without even the implied warranty of
00014     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015     GNU General Public License for more details.
00016 
00017     You should have received a copy of the GNU General Public License
00018     along with this program.  If not, see <http://www.gnu.org/licenses/>.
00019 */
00020 
00021 #include "versionnumber.h"
00022 
00023 VersionNumber::VersionNumber()
00024 {
00025 }
00026 
00027 VersionNumber::VersionNumber(const QString & value)
00028 {
00029   helper_setValue(value);
00030 }
00031 
00032 VersionNumber::VersionNumber(const VersionNumber & value)
00033 {
00034   helper_copyFromHere(value);
00035 }
00036 
00037 VersionNumber::VersionNumber(const qint64 & value)
00038 {
00039   helper_setValue(QString::number(value));
00040 }
00041 
00042 VersionNumber::~VersionNumber()
00043 {
00044 }
00045 
00046 QString VersionNumber::toString() const
00047 {
00048   return theString;
00049 }
00050 
00051 VersionNumber VersionNumber::operator=(const VersionNumber & value)
00052 {
00053   helper_copyFromHere(value);
00054   return *this;
00055 }
00056 
00057 VersionNumber VersionNumber::operator=(const QString & value)
00058 {
00059   helper_setValue(value);
00060   return *this;
00061 }
00062 
00063 VersionNumber VersionNumber::operator=(const qint64 & value)
00064 {
00065   helper_setValue(QString::number(value));
00066   return *this;
00067 }
00068 
00069 bool VersionNumber::operator<(const VersionNumber & value) const
00070 {
00071   return (whichIsBigger(*this, value) == second_one);
00072 }
00073 
00074 bool VersionNumber::operator<=(const VersionNumber & value) const
00075 {
00076   return (! (whichIsBigger(*this, value) == first_one));
00077 }
00078 
00079 bool VersionNumber::operator>(const VersionNumber & value) const
00080 {
00081   return (whichIsBigger(*this, value) == first_one);
00082 }
00083 
00084 bool VersionNumber::operator>=(const VersionNumber & value) const
00085 {
00086   return (!(whichIsBigger(*this, value) == second_one));
00087 }
00088 
00089 bool VersionNumber::operator==(const VersionNumber & value) const
00090 {
00091   return (whichIsBigger(*this, value) == both_are_equal);
00092 }
00093 
00094 bool VersionNumber::operator!=(const VersionNumber & value) const
00095 {
00096   return (!(whichIsBigger(*this, value) == both_are_equal));
00097 }
00098 
00099 void VersionNumber::helper_setValue(const QString & value)
00100 {
00101   theString = value;
00102   if (value.contains(':')) {
00103     // part before the first ':'...
00104     epoch = helper_createNumberWithPointsAndDashes(value.section(':', 0, 0));
00105     // part after the first ':'...
00106     version_and_release = helper_createNumberWithPointsAndDashes(value.section(':', 1));
00107   } else {
00108     epoch = helper_createNumberWithPointsAndDashes(QChar('0'));
00109     version_and_release = helper_createNumberWithPointsAndDashes(value);
00110   };
00111 }
00112 
00113 VersionNumber::characterType VersionNumber::helper_characterType(const QChar & value)
00114 {
00115   // variables
00116   characterType returnValue;
00117 
00118   // code
00119   if (value.isLetter()) {
00120     returnValue = letter;
00121   } else {
00122     if (value.isDigit()) {
00123       returnValue = digit;
00124     } else {
00125       returnValue = other;
00126     };
00127   };
00128   return returnValue;
00129 }
00130 
00131 VersionNumber::simpleNumber VersionNumber::helper_createSimpleNumber(const QString & value)
00132 {
00133   // variables
00134   simpleNumber returnValue;
00135   int i;
00136   characterType oldCharacterType;
00137   characterType newCharacterType;
00138   QString stack;
00139 
00140   // code
00141   if (value.size() > 0) {
00142     oldCharacterType = helper_characterType(value.at(0)); // works only if the
00143     // string isn't empty!
00144     for (i=0; i<value.size(); ++i) {
00145       newCharacterType = helper_characterType(value.at(i));
00146       if (newCharacterType == oldCharacterType) {
00147         stack += value.at(i);
00148       } else {
00149         returnValue.append(stack);
00150         stack.clear();
00151         stack += value.at(i);
00152         oldCharacterType = newCharacterType;
00153       };
00154     };
00155     returnValue.append(stack);
00156   };
00157   return returnValue;
00158 }
00159 
00160 VersionNumber::numberWithPoints VersionNumber::helper_createNumberWithPoints(
00161   const QString & value)
00162 {
00163   // variables
00164   numberWithPoints returnValue;
00165   QStringList m_list;
00166   int i;
00167 
00168   // code
00169   m_list = value.split('-');
00170   for (i=0; i<m_list.size(); i++) {
00171     returnValue.append(helper_createSimpleNumber(m_list.at(i)));
00172   };
00173   return returnValue;
00174 }
00175 
00176 VersionNumber::numberWithPointsAndDashes VersionNumber::helper_createNumberWithPointsAndDashes(
00177   const QString & value)
00178 {
00179   // variables
00180   numberWithPointsAndDashes returnValue;
00181   QStringList m_list;
00182   int i;
00183 
00184   // code
00185   m_list = value.split('-');
00186   for (i=0; i<m_list.size(); i++) {
00187     returnValue.append(helper_createNumberWithPoints(m_list.at(i)));
00188     // TODO kann "Streamripper 1.64.0-beta-1" älter sein als 1.64.0 ??? Wohl eher nicht... Schade!
00189   };
00190   return returnValue;
00191 }
00192 
00193 void VersionNumber::helper_copyFromHere(const VersionNumber & value)
00194 {
00195   theString = value.theString;
00196   epoch = value.epoch;
00197   version_and_release = value.version_and_release;
00198 }
00199 
00200 VersionNumber::type_whichIsBigger VersionNumber::whichIsBigger(const VersionNumber & firstValue,
00201                                                                 const VersionNumber & secondValue)
00202 {
00203   // variables
00204   type_whichIsBigger temp;
00205   type_whichIsBigger returnValue;
00206 
00207   // code
00208   temp = whichIsBigger(firstValue.epoch, secondValue.epoch);
00209   if (temp != both_are_equal) {
00210     returnValue = temp;
00211   } else {
00212     returnValue = whichIsBigger(firstValue.version_and_release, secondValue.version_and_release);
00213   };
00214   return returnValue;
00215 }
00216 
00217 VersionNumber::type_whichIsBigger VersionNumber::whichIsBigger(
00218   const numberWithPointsAndDashes & firstValue,
00219   const numberWithPointsAndDashes & secondValue)
00220 {
00221   // variables
00222   type_whichIsBigger temp;
00223   bool abort;
00224   int i;
00225 
00226   // code
00227   i = 0;
00228   abort = false;
00229   while (abort == false) {
00230     if (firstValue.size() > i) {
00231 
00232         if (secondValue.size() > i) {
00233           temp = whichIsBigger(firstValue.at(i), secondValue.at(i));
00234           if (temp != both_are_equal) {
00235             abort = true;
00236           };
00237         } else {
00238           temp = first_one;
00239           abort = true;
00240         };
00241 
00242     } else {
00243 
00244         if (secondValue.size() > i) {
00245           temp = second_one;
00246           abort = true;
00247         } else {
00248           temp = both_are_equal;
00249           abort = true;
00250         };
00251 
00252     };
00253     i = i+1;
00254   };
00255   return temp;
00256 }
00257 
00258 VersionNumber::type_whichIsBigger VersionNumber::whichIsBigger(
00259   const numberWithPoints & firstValue,
00260   const numberWithPoints & secondValue)
00261 {
00262 // same code as the function above!!!
00263   // variables
00264   type_whichIsBigger temp;
00265   bool abort;
00266   int i;
00267 
00268   // code
00269   i = 0;
00270   abort = false;
00271   while (abort == false) {
00272     if (firstValue.size() > i) {
00273 
00274         if (secondValue.size() > i) {
00275           temp = whichIsBigger(firstValue.at(i), secondValue.at(i));
00276           if (temp != both_are_equal) {
00277             abort = true;
00278           };
00279         } else {
00280           temp = first_one;
00281           abort = true;
00282         };
00283 
00284     } else {
00285 
00286         if (secondValue.size() > i)  {
00287           temp = second_one;
00288           abort = true;
00289         } else {
00290           temp = both_are_equal;
00291           abort = true;
00292         };
00293 
00294     };
00295     i = i+1;
00296   };
00297   return temp;
00298 }
00299 
00300 VersionNumber::type_whichIsBigger VersionNumber::whichIsBigger(const simpleNumber & firstValue,
00301                                                                 const simpleNumber & secondValue)
00302 {
00303 // same code as the function above
00304   // variables
00305   type_whichIsBigger temp;
00306   bool abort;
00307   int i;
00308 
00309   // code
00310   i = 0;
00311   abort = false;
00312   while (abort == false) {
00313     if (firstValue.size() > i) {
00314 
00315         if (secondValue.size() > i) {
00316           temp = whichIsBigger(firstValue.at(i), secondValue.at(i));
00317           if (temp != both_are_equal) {
00318             abort = true;
00319           };
00320         } else {
00321           temp = first_one;
00322           abort = true;
00323         };
00324 
00325     } else {
00326 
00327         if (secondValue.size() > i) {
00328           temp = second_one;
00329           abort = true;
00330         } else {
00331           temp = both_are_equal;
00332           abort = true;
00333         };
00334 
00335     };
00336     i = i+1;
00337   };
00338   return temp;
00339 }
00340 
00341 VersionNumber::type_whichIsBigger VersionNumber::helper_whichNumberIsBigger(
00342   const QString & firstValue,
00343   const QString & secondValue)
00344 {
00345   // TODO Attention: Documentation: This function assumes the values to be strings
00346   // which contain numbers. If not, this function will not have a useful result.
00347 
00348   // variables
00349   quint64 m_firstNumber;
00350   quint64 m_secondNumber;
00351   quint64 m_firstStringSize;
00352   quint64 m_secondStringSize;
00353   type_whichIsBigger returnValue;
00354 
00355   // code
00356   m_firstNumber = firstValue.toULongLong();
00357   m_secondNumber = secondValue.toULongLong();
00358   if (m_firstNumber > m_secondNumber) {
00359     returnValue = first_one;
00360   } else if (m_firstNumber < m_secondNumber) {
00361     returnValue = second_one;
00362   } else { // both are numericly equal
00363     m_firstStringSize = firstValue.size();
00364     m_secondStringSize = secondValue.size();
00365     if (m_firstStringSize > m_secondStringSize) {
00366       returnValue = first_one;
00367     } else if (m_firstStringSize < m_secondStringSize) {
00368       returnValue = second_one;
00369     } else {
00370       returnValue = both_are_equal;
00371     };
00372   };
00373   return returnValue;
00374 }
00375 
00376 VersionNumber::type_whichIsBigger VersionNumber::helper_whichStringIsBigger(
00377   const QString & firstValue,
00378   const QString & secondValue)
00379 {
00380   // variables
00381   type_whichIsBigger returnValue;
00382 
00383   // code
00384   if (firstValue > secondValue) {
00385     returnValue = first_one;
00386   } else if (firstValue < secondValue) {
00387     returnValue = second_one;
00388   } else {
00389     returnValue = both_are_equal;
00390   };
00391   return returnValue;
00392 }
00393 
00394 VersionNumber::type_whichIsBigger VersionNumber::whichIsBigger(const QString & firstValue,
00395                                                                 const QString & secondValue)
00396 {
00397   // TODO Attention: -> Documentation: Both strings must have size() > 0!
00398   // Otherwise this function will crash!!!
00399 
00400   // variables
00401   type_whichIsBigger returnValue;
00402 
00403   // code
00404   if (firstValue.at(0).isDigit() && secondValue.at(0).isDigit()) {
00405     returnValue = helper_whichNumberIsBigger(firstValue, secondValue);
00406   } else {
00407     returnValue = helper_whichStringIsBigger(firstValue, secondValue);
00408   };
00409   return returnValue;
00410 }

Generated on Sat May 2 10:43:44 2009 for kradioripper by  doxygen 1.5.6