versionnumber.cpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
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
00104 epoch = helper_createNumberWithPointsAndDashes(value.section(':', 0, 0));
00105
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
00116 characterType returnValue;
00117
00118
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
00134 simpleNumber returnValue;
00135 int i;
00136 characterType oldCharacterType;
00137 characterType newCharacterType;
00138 QString stack;
00139
00140
00141 if (value.size() > 0) {
00142 oldCharacterType = helper_characterType(value.at(0));
00143
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
00164 numberWithPoints returnValue;
00165 QStringList m_list;
00166 int i;
00167
00168
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
00180 numberWithPointsAndDashes returnValue;
00181 QStringList m_list;
00182 int i;
00183
00184
00185 m_list = value.split('-');
00186 for (i=0; i<m_list.size(); i++) {
00187 returnValue.append(helper_createNumberWithPoints(m_list.at(i)));
00188
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
00204 type_whichIsBigger temp;
00205 type_whichIsBigger returnValue;
00206
00207
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
00222 type_whichIsBigger temp;
00223 bool abort;
00224 int i;
00225
00226
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
00263
00264 type_whichIsBigger temp;
00265 bool abort;
00266 int i;
00267
00268
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
00304
00305 type_whichIsBigger temp;
00306 bool abort;
00307 int i;
00308
00309
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
00346
00347
00348
00349 quint64 m_firstNumber;
00350 quint64 m_secondNumber;
00351 quint64 m_firstStringSize;
00352 quint64 m_secondStringSize;
00353 type_whichIsBigger returnValue;
00354
00355
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 {
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
00381 type_whichIsBigger returnValue;
00382
00383
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
00398
00399
00400
00401 type_whichIsBigger returnValue;
00402
00403
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 }