git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.shelly.internal.util;
  14
  15 import org.eclipse.jdt.annotation.NonNullByDefault;
  16 import org.eclipse.jdt.annotation.Nullable;
  17
  18 /**
  19  * {@link ShellyVersionDTO} compares 2 version strings.
  20  *
  21  * @author Markus Michels - Initial contribution
  22  */
  23 @NonNullByDefault
  24 public class ShellyVersionDTO {
  25     private class VersionTokenizer {
  26         private final String versionString;
  27         private final int length;
  28
  29         private int position;
  30         private int number;
  31         private String suffix = "";
  32
  33         public VersionTokenizer(@Nullable String versionString) {
  34             if (versionString == null) {
  35                 throw new IllegalArgumentException("versionString is null");
  36             }
  37
  38             this.versionString = versionString;
  39             length = versionString.length();
  40         }
  41
  42         private boolean moveNext() {
  43             number = 0;
  44             suffix = "";
  45
  46             // No more characters
  47             if (position >= length) {
  48                 return false;
  49             }
  50
  51             while (position < length) {
  52                 char c = versionString.charAt(position);
  53                 if (c < '0' || c > '9') {
  54                     break;
  55                 }
  56                 number = number * 10 + (c - '0');
  57                 position++;
  58             }
  59
  60             int suffixStart = position;
  61
  62             while (position < length) {
  63                 char c = versionString.charAt(position);
  64                 if (c == '.') {
  65                     break;
  66                 }
  67                 position++;
  68             }
  69
  70             suffix = versionString.substring(suffixStart, position);
  71
  72             if (position < length) {
  73                 position++;
  74             }
  75
  76             return true;
  77         }
  78
  79         private int getNumber() {
  80             return number;
  81         }
  82
  83         private String getSuffix() {
  84             return suffix;
  85         }
  86     }
  87
  88     public boolean equals(String s1, String s2) {
  89         return compare(s1, s2) == 0;
  90     }
  91
  92     public int compare(String version1, String version2) {
  93         VersionTokenizer tokenizer1 = new VersionTokenizer(version1);
  94         VersionTokenizer tokenizer2 = new VersionTokenizer(version2);
  95
  96         int number1 = 0, number2 = 0;
  97         String suffix1 = "", suffix2 = "";
  98
  99         while (tokenizer1.moveNext()) {
 100             if (!tokenizer2.moveNext()) {
 101                 do {
 102                     number1 = tokenizer1.getNumber();
 103                     suffix1 = tokenizer1.getSuffix();
 104                     if (number1 != 0 || suffix1.length() != 0) {
 105                         // Version one is longer than number two, and non-zero
 106                         return 1;
 107                     }
 108                 } while (tokenizer1.moveNext());
 109
 110                 // Version one is longer than version two, but zero
 111                 return 0;
 112             }
 113
 114             number1 = tokenizer1.getNumber();
 115             suffix1 = tokenizer1.getSuffix();
 116             number2 = tokenizer2.getNumber();
 117             suffix2 = tokenizer2.getSuffix();
 118
 119             if (number1 < number2) {
 120                 // Number one is less than number two
 121                 return -1;
 122             }
 123             if (number1 > number2) {
 124                 // Number one is greater than number two
 125                 return 1;
 126             }
 127
 128             boolean empty1 = suffix1.length() == 0;
 129             boolean empty2 = suffix2.length() == 0;
 130
 131             if (empty1 && empty2) {
 132                 continue;
 133             } // No suffixes
 134             if (empty1) {
 135                 return 1;
 136             } // First suffix is empty (1.2 > 1.2b)
 137             if (empty2) {
 138                 return -1;
 139             } // Second suffix is empty (1.2a < 1.2)
 140
 141             // Lexical comparison of suffixes
 142             int result = suffix1.compareTo(suffix2);
 143             if (result != 0) {
 144                 return result;
 145             }
 146
 147         }
 148
 149         while (tokenizer2.moveNext()) {
 150             number2 = tokenizer2.getNumber();
 151             suffix2 = tokenizer2.getSuffix();
 152             if (number2 != 0 || suffix2.length() != 0) {
 153                 // Version one is longer than version two, and non-zero
 154                 return -1;
 155             }
 156         }
 157         // Version two is longer than version one, but zero
 158         return 0;
 159     }
 160
 161     public boolean checkBeta(@Nullable String version) {
 162         if (version == null) {
 163             return false;
 164         }
 165         return version.isEmpty() || version.contains("???") || version.toLowerCase().contains("master")
 166                 || (version.toLowerCase().contains("-rc") || version.toLowerCase().contains("beta"));
 167     }
 168 }