haiku.git

/*
 * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
 * Distributed under the terms of the MIT License.
 */


#include <package/PackageVersion.h>

#include <NaturalCompare.h>

#include <package/PackageInfo.h>
#include <package/hpkg/PackageInfoAttributeValue.h>


using BPrivate::NaturalCompare;


namespace BPackageKit {


BPackageVersion::BPackageVersion()
	:
	fRevision(0)
{
}


BPackageVersion::BPackageVersion(const BPackageVersionData& data)
{
	SetTo(data.major, data.minor, data.micro, data.preRelease, data.revision);
}


BPackageVersion::BPackageVersion(const BString& versionString,
	bool revisionIsOptional)
{
	SetTo(versionString, revisionIsOptional);
}


BPackageVersion::BPackageVersion(const BString& major, const BString& minor,
	const BString& micro, const BString& preRelease, uint32 revision)
{
	SetTo(major, minor, micro, preRelease, revision);
}


status_t
BPackageVersion::InitCheck() const
{
	return fMajor.Length() > 0 ? B_OK : B_NO_INIT;
}


const BString&
BPackageVersion::Major() const
{
	return fMajor;
}


const BString&
BPackageVersion::Minor() const
{
	return fMinor;
}


const BString&
BPackageVersion::Micro() const
{
	return fMicro;
}


const BString&
BPackageVersion::PreRelease() const
{
	return fPreRelease;
}


uint32
BPackageVersion::Revision() const
{
	return fRevision;
}


int
BPackageVersion::Compare(const BPackageVersion& other) const
{
	int diff = NaturalCompare(fMajor.String(), other.fMajor.String());
	if (diff != 0)
		return diff;

	diff = NaturalCompare(fMinor.String(), other.fMinor.String());
	if (diff != 0)
		return diff;

	diff = NaturalCompare(fMicro.String(), other.fMicro.String());
	if (diff != 0)
		return diff;

	// The pre-version works differently: The empty string is greater than any
	// non-empty string (e.g. "R1" is newer than "R1-rc2"). So we catch the
	// empty string cases first.
	if (fPreRelease.IsEmpty()) {
		if (!other.fPreRelease.IsEmpty())
			return 1;
	} else if (other.fPreRelease.IsEmpty()) {
		return -1;
	} else {
		// both are non-null -- compare normally
		diff = NaturalCompare(fPreRelease.String(), other.fPreRelease.String());
		if (diff != 0)
			return diff;
	}

	return (int)fRevision - (int)other.fRevision;
}


BString
BPackageVersion::ToString() const
{
	if (InitCheck() != B_OK)
		return BString();

	BString string = fMajor;

	if (fMinor.Length() > 0) {
		string << '.' << fMinor;
		if (fMicro.Length() > 0)
			string << '.' << fMicro;
	}

	if (!fPreRelease.IsEmpty())
		string << '~' << fPreRelease;

	if (fRevision > 0)
		string << '-' << fRevision;

	return string;
}


void
BPackageVersion::SetTo(const BString& major, const BString& minor,
	const BString& micro, const BString& preRelease, uint32 revision)
{
	fMajor = major;
	fMinor = minor;
	fMicro = micro;
	fPreRelease = preRelease;
	fRevision = revision;

	fMajor.ToLower();
	fMinor.ToLower();
	fMicro.ToLower();
	fPreRelease.ToLower();
}


status_t
BPackageVersion::SetTo(const BString& versionString, bool revisionIsOptional)
{
	Clear();
	return BPackageInfo::ParseVersionString(versionString, revisionIsOptional,
		*this);
}


void
BPackageVersion::Clear()
{
	fMajor.Truncate(0);
	fMinor.Truncate(0);
	fMicro.Truncate(0);
	fPreRelease.Truncate(0);
	fRevision = 0;
}


}	// namespace BPackageKit