version compare

yanghui

2021-05-14 2604d2075715ec3ecd11c526d86b75ee8947f2ec

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package vaversion
 
import (
    "encoding/json"
    "flag"
    "fmt"
    "math"
    "os"
    "strconv"
    "strings"
)
 
var (
    BuildVersion string
    BuildTime    string
    CommitSha1   string
    AppName      string
)
 
func init() {
    var showVer bool
    flag.BoolVar(&showVer, "v", false, "display build version")
    flag.Parse()
    if showVer {
        info := make(map[string]interface{})
        info["version"] = BuildVersion
        info["build"] = BuildTime
        info["commit"] = CommitSha1
        info["name"] = AppName
 
        b, err := json.Marshal(info)
        if nil != err {
            fmt.Println("internal error:", err)
            os.Exit(1)
        } else {
            fmt.Println(string(b))
            os.Exit(0)
        }
    }
}
 
func VersionCode2Name(version int64) (string, error) {
    if version < 0 {
        return "", errors.New("Version can't be negetive")
    }
 
    majorVersion := version >> 32
    minorVersion := (version >> 16) & 0xffff
    buildNumber := version & 0xffff
 
    name := fmt.Sprintf("%d.%d.%d", majorVersion, minorVersion, buildNumber)
 
    return name, nil
}
 
func VersionName2Code(version string) (int64, error) {
    subVersions := strings.Split(version, ".")
    if len(subVersions) != 3 {
        return 0, errors.New("Incorrect version format, version formats like 1.12.3")
    }
 
    majorVersion, err := strconv.ParseInt(subVersions[0], 10, 64)
    if nil != err {
        return 0, errors.New(version + " major part can't be parsed, version formats like 1.12.3")
    }
 
    minorVersion, err := strconv.ParseInt(subVersions[1], 10, 64)
    if nil != err {
        return 0, errors.New(version + " minor part can't be parsed, version formats like 1.12.3")
    }
 
    buildNumber, err := strconv.ParseInt(subVersions[2], 10, 64)
    if nil != err {
        return 0, errors.New(version + " build number part can't be parsed, version formats like 1.12.3")
    }
 
    if majorVersion > math.MaxUint16 {
        return 0, errors.New(version + " major version too large, max value is:" + strconv.Itoa(math.MaxUint16))
    }
 
    if minorVersion > math.MaxUint16 {
        return 0, errors.New(version + " minor version too large, max value is:" + strconv.Itoa(math.MaxUint16))
    }
 
    if buildNumber > math.MaxUint16 {
        return 0, errors.New(version + " build number too large, max value is:" + strconv.Itoa(math.MaxUint16))
    }
 
    num := (majorVersion << 32) | (minorVersion << 16) | buildNumber
 
    return num, nil
}