public CompareResult CompareVersions(string a, string b)
{
VersionStruct versionA = ParseVersion(a);
VersionStruct versionB = ParseVersion(b);
return(CompareVersions(versionA, versionB));
}
public bool Equal(VersionStruct target)
{
return(this.master == target.master &&
this.minor == target.minor &&
this.revised == target.revised &&
this.revised2 == target.revised2);
}
public CompareResult CompareVersions(Upset package, DependencyDefinition dependencyDefinition)
{
VersionStruct packageVersion = ParseVersion(package);
VersionStruct dependencyVersion = ParseVersion(dependencyDefinition);
return(CompareVersions(packageVersion, dependencyVersion));
}
public void CopyValue(VersionStruct target)
{
master = target.master;
minor = target.minor;
revised = target.revised;
revised2 = target.revised2;
}
public bool checkVersion(VersionStruct aVersionStruct)
{
bool lresult = false;
do
{
try
{
if (mVersionControl == null)
{
break;
}
sbyte lcheckResult = 0;
(mVersionControl as IVersionControlInner).checkVersion(
aVersionStruct.mMAJOR,
aVersionStruct.mMINOR,
aVersionStruct.mPATCH,
out lcheckResult);
if (lcheckResult > 0)
{
lresult = true;
}
}
catch (Exception exc)
{
LogManager.getInstance().write(exc.Message);
}
} while (false);
return(lresult);
}
public void SaveData()
{
if (!Directory.Exists(DirectName))
{
Directory.CreateDirectory(DirectName);
}
{
StreamWriter servWriter = new StreamWriter(new FileStream(FileName, FileMode.Create));
List <string> strings = new List <string>();
foreach (string k in m_mFileMd5.Keys)
{
strings.Add(k);
}
strings.Sort();
foreach (string s in strings)
{
servWriter.WriteLine(s + '$' + m_mFileMd5[s]);
}
servWriter.Close();
}
{
foreach (string key in m_mDepends.Keys)
{
if (m_mDepends[key].GetDirty())
{
if (m_mVersion.ContainsKey(key))
{
m_mVersion[key].value = m_maxValue;
m_mVersion[key].date = m_currDate;
}
else
{
VersionStruct vs = new VersionStruct();
vs.value = m_maxValue;
vs.date = m_currDate;
m_mVersion.Add(key, vs);
}
}
}
StreamWriter verWriter = new StreamWriter(new FileStream(VersionName, FileMode.Create));
List <string> strings = new List <string>();
foreach (string k in m_mVersion.Keys)
{
strings.Add(k);
}
strings.Sort();
foreach (string s in strings)
{
verWriter.WriteLine(s + '$' + m_mVersion[s].value.ToString() + '$' + m_mVersion[s].date);
}
verWriter.Close();
}
}
public void OpenData()
{
if (File.Exists(FileName))
{
StreamReader sr = new StreamReader(new FileStream(FileName, FileMode.Open));
char[] spiltChar = new char[1] {
'$'
};
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
string[] strings = line.Split(spiltChar);
if (strings.Length == 2)
{
m_mFileMd5.Add(strings[0], strings[1]);
m_mFileDirty.Add(strings[0], FileDirtyEnum.FRESH);
}
}
sr.Close();
}
if (File.Exists(VersionName))
{
StreamReader sr = new StreamReader(new FileStream(VersionName, FileMode.Open));
char[] spiltChar = new char[1] {
'$'
};
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
string[] strings = line.Split(spiltChar);
if (strings.Length == 3)
{
VersionStruct vs = new VersionStruct();
vs.value = int.Parse(strings[1]);
vs.date = strings[2];
m_mVersion.Add(strings[0], vs);
if (vs.value > m_maxValue)
{
m_maxValue = vs.value;
}
}
}
sr.Close();
}
m_maxValue++;
}
public static void Initialize()
{
WebClient wc = new WebClient();
var jsonstr = wc.DownloadString("https://github.com/laiglinne-ff/Aliapoh.Overlay/raw/aliapoh-versions/version.json");
var json = JObject.Parse(jsonstr);
var cur = new VersionStruct(Application.ProductVersion);
var git = new VersionStruct(json["Stable"].Value <string>());
LOG.Logger.Log(LogLevel.Warning, "Latest version: " + git.ToString());
LOG.Logger.Log(LogLevel.Warning, "Current version: " + cur.ToString());
if (cur.Diff(git) == -1)
{
LOG.Logger.Log(LogLevel.Warning, "Patch required");
}
}
public static VersionStruct ParseVersion(string versionString)
{
const string versionMatcherRegexp = @"(?<major>\d+)(\.(?<minor>\d+))?(\.(?<build>\d+))?(((?<release>\w)|\.)(?<revision>\d+))?";
Match matchObject = Regex.Match(versionString, versionMatcherRegexp);
VersionStruct result = new VersionStruct
{
Major = ExtractVersion(matchObject, "major"),
Minor = ExtractVersion(matchObject, "minor"),
Build = ExtractVersion(matchObject, "build"),
Release = ExtractRelease(matchObject),
Revision = ExtractVersion(matchObject, "revision")
};
return(result);
}
public bool getVersion(ref VersionStruct aVersionStruct)
{
bool lresult = false;
IntPtr lPtrXMLstring = IntPtr.Zero;
do
{
try
{
if (mVersionControl == null)
{
break;
}
(mVersionControl as IVersionControlInner).getVersion(
out aVersionStruct.mMAJOR,
out aVersionStruct.mMINOR,
out aVersionStruct.mPATCH,
out lPtrXMLstring);
if (lPtrXMLstring != IntPtr.Zero)
{
aVersionStruct.mAdditionalLabel = Marshal.PtrToStringBSTR(lPtrXMLstring);
}
lresult = true;
}
catch (Exception exc)
{
LogManager.getInstance().write(exc.Message);
}
} while (false);
if (lPtrXMLstring != IntPtr.Zero)
{
Marshal.FreeBSTR(lPtrXMLstring);
}
return(lresult);
}
public int Diff(VersionStruct vs)
{
if (vs.Major > Major)
{
return(-1);
}
if (vs.Minor > Minor)
{
return(-1);
}
if (vs.Build > Build)
{
return(-1);
}
if (vs.Revision > Revision)
{
return(-1);
}
return(0);
}
public CompareResult CompareVersions(VersionStruct packageVersion, VersionStruct dependencyVersion)
{
CompareResult result = new CompareResult();
// Major version comparison
if (packageVersion.Major < dependencyVersion.Major)
{
result.Major = Comparison.LOWER;
return(result);
}
else if (packageVersion.Major > dependencyVersion.Major)
{
result.Major = Comparison.HIGHER;
return(result);
}
else if (packageVersion.Major == dependencyVersion.Major)
{
result.Major = Comparison.SAME;
}
else
{
result.Major = Comparison.NA;
return(result);
}
// Minor version comparison
if (packageVersion.Minor < dependencyVersion.Minor)
{
result.Minor = Comparison.LOWER;
return(result);
}
else if (packageVersion.Minor > dependencyVersion.Minor)
{
result.Minor = Comparison.HIGHER;
return(result);
}
else if (packageVersion.Minor == dependencyVersion.Minor)
{
result.Minor = Comparison.SAME;
}
else
{
result.Minor = Comparison.NA;
return(result);
}
// Build version comparison
if (packageVersion.Build < dependencyVersion.Build)
{
result.Build = Comparison.LOWER;
return(result);
}
else if (packageVersion.Build > dependencyVersion.Build)
{
result.Build = Comparison.HIGHER;
return(result);
}
else if (packageVersion.Build == dependencyVersion.Build)
{
result.Build = Comparison.SAME;
}
else
{
result.Build = Comparison.NA;
return(result);
}
// Release strength comparison
if (packageVersion.Release < dependencyVersion.Release)
{
result.Release = Comparison.LOWER;
return(result);
}
else if (packageVersion.Release > dependencyVersion.Release)
{
result.Release = Comparison.HIGHER;
return(result);
}
else if (packageVersion.Release == dependencyVersion.Release)
{
result.Release = Comparison.SAME;
}
else
{
result.Release = Comparison.NA;
return(result);
}
// Revision version comparison
if (packageVersion.Revision < dependencyVersion.Revision)
{
result.Revision = Comparison.LOWER;
return(result);
}
else if (packageVersion.Revision > dependencyVersion.Revision)
{
result.Revision = Comparison.HIGHER;
return(result);
}
else if (packageVersion.Revision == dependencyVersion.Revision)
{
result.Revision = Comparison.SAME;
}
else
{
result.Revision = Comparison.NA;
return(result);
}
return(result);
}
