haiku.git

/*
 * Copyright (c) 2010, Haiku, Inc.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		Adrien Destugues <pulkomandy@pulkomandy.ath.cx>
 * 		Oliver Tappe <zooey@hirschkaefer.de>
 */


#include <unicode/uversion.h>
#include <TimeZone.h>

#include <new>

#include <unicode/locid.h>
#include <unicode/timezone.h>
#include <ICUWrapper.h>

#include <Language.h>


U_NAMESPACE_USE


const char* BTimeZone::kNameOfGmtZone = "GMT";


static const BString skEmptyString;


static const uint32 skNameField 					= 1U << 0;
static const uint32 skDaylightSavingNameField 		= 1U << 1;
static const uint32 skShortNameField 				= 1U << 2;
static const uint32 skShortDaylightSavingNameField 	= 1U << 3;
static const uint32 skLongGenericNameField 			= 1U << 4;
static const uint32 skGenericLocationNameField 		= 1U << 5;
static const uint32 skShortCommonlyUsedNameField	= 1U << 6;
static const uint32 skSupportsDaylightSavingField   = 1U << 7;
static const uint32 skOffsetFromGMTField			= 1U << 8;


BTimeZone::BTimeZone(const char* zoneID, const BLanguage* language)
	:
	fICUTimeZone(NULL),
	fICULocale(NULL),
	fInitStatus(B_NO_INIT),
	fInitializedFields(0)
{
	SetTo(zoneID, language);
}


BTimeZone::BTimeZone(const BTimeZone& other)
	:
	fICUTimeZone(other.fICUTimeZone == NULL
		? NULL
		: other.fICUTimeZone->clone()),
	fICULocale(other.fICULocale == NULL
		? NULL
		: other.fICULocale->clone()),
	fInitStatus(other.fInitStatus),
	fInitializedFields(other.fInitializedFields),
	fZoneID(other.fZoneID),
	fName(other.fName),
	fDaylightSavingName(other.fDaylightSavingName),
	fShortName(other.fShortName),
	fShortDaylightSavingName(other.fShortDaylightSavingName),
	fOffsetFromGMT(other.fOffsetFromGMT),
	fSupportsDaylightSaving(other.fSupportsDaylightSaving)
{
}


BTimeZone::~BTimeZone()
{
	delete fICULocale;
	delete fICUTimeZone;
}


BTimeZone& BTimeZone::operator=(const BTimeZone& source)
{
	delete fICUTimeZone;
	fICUTimeZone = source.fICUTimeZone == NULL
		? NULL
		: source.fICUTimeZone->clone();
	fICULocale = source.fICULocale == NULL
		? NULL
		: source.fICULocale->clone();
	fInitStatus = source.fInitStatus;
	fInitializedFields = source.fInitializedFields;
	fZoneID = source.fZoneID;
	fName = source.fName;
	fDaylightSavingName = source.fDaylightSavingName;
	fShortName = source.fShortName;
	fShortDaylightSavingName = source.fShortDaylightSavingName;
	fOffsetFromGMT = source.fOffsetFromGMT;
	fSupportsDaylightSaving = source.fSupportsDaylightSaving;

	return *this;
}


const BString&
BTimeZone::ID() const
{
	return fZoneID;
}


const BString&
BTimeZone::Name() const
{
	if ((fInitializedFields & skNameField) == 0) {
		UnicodeString unicodeString;
		if (fICULocale != NULL) {
			fICUTimeZone->getDisplayName(false, TimeZone::GENERIC_LOCATION,
				*fICULocale, unicodeString);
		} else {
			fICUTimeZone->getDisplayName(false, TimeZone::GENERIC_LOCATION,
				unicodeString);
		}
		BStringByteSink sink(&fName);
		unicodeString.toUTF8(sink);
		fInitializedFields |= skNameField;
	}

	return fName;
}


const BString&
BTimeZone::DaylightSavingName() const
{
	if ((fInitializedFields & skDaylightSavingNameField) == 0) {
		UnicodeString unicodeString;
		if (fICULocale != NULL) {
			fICUTimeZone->getDisplayName(true, TimeZone::GENERIC_LOCATION,
				*fICULocale, unicodeString);
		} else {
			fICUTimeZone->getDisplayName(true, TimeZone::GENERIC_LOCATION,
				unicodeString);
		}
		BStringByteSink sink(&fDaylightSavingName);
		unicodeString.toUTF8(sink);
		fInitializedFields |= skDaylightSavingNameField;
	}

	return fDaylightSavingName;
}


const BString&
BTimeZone::ShortName() const
{
	if ((fInitializedFields & skShortNameField) == 0) {
		UnicodeString unicodeString;
		if (fICULocale != NULL) {
			fICUTimeZone->getDisplayName(false, TimeZone::SHORT, *fICULocale,
				unicodeString);
		} else {
			fICUTimeZone->getDisplayName(false, TimeZone::SHORT, unicodeString);
		}
		BStringByteSink sink(&fShortName);
		unicodeString.toUTF8(sink);
		fInitializedFields |= skShortNameField;
	}

	return fShortName;
}


const BString&
BTimeZone::ShortDaylightSavingName() const
{
	if ((fInitializedFields & skShortDaylightSavingNameField) == 0) {
		UnicodeString unicodeString;
		if (fICULocale != NULL) {
			fICUTimeZone->getDisplayName(true, TimeZone::SHORT, *fICULocale,
				unicodeString);
		} else {
			fICUTimeZone->getDisplayName(true, TimeZone::SHORT, unicodeString);
		}
		BStringByteSink sink(&fShortDaylightSavingName);
		unicodeString.toUTF8(sink);
		fInitializedFields |= skShortDaylightSavingNameField;
	}

	return fShortDaylightSavingName;
}


int
BTimeZone::OffsetFromGMT() const
{
	if ((fInitializedFields & skOffsetFromGMTField) == 0) {
		int32_t rawOffset;
		int32_t dstOffset;
		UDate nowMillis = 1000 * (double)time(NULL);

		UErrorCode error = U_ZERO_ERROR;
		fICUTimeZone->getOffset(nowMillis, FALSE, rawOffset, dstOffset, error);
		if (!U_SUCCESS(error))
			fOffsetFromGMT = 0;
		else {
			fOffsetFromGMT = (rawOffset + dstOffset) / 1000;
				// we want seconds, not ms (which ICU gives us)
		}
		fInitializedFields |= skOffsetFromGMTField;
	}

	return fOffsetFromGMT;
}


bool
BTimeZone::SupportsDaylightSaving() const
{
	if ((fInitializedFields & skSupportsDaylightSavingField) == 0) {
		fSupportsDaylightSaving = fICUTimeZone->useDaylightTime();
		fInitializedFields |= skSupportsDaylightSavingField;
	}

	return fSupportsDaylightSaving;
}


status_t
BTimeZone::InitCheck() const
{
	return fInitStatus;
}


status_t
BTimeZone::SetLanguage(const BLanguage* language)
{
	return SetTo(fZoneID, language);
}


status_t
BTimeZone::SetTo(const char* zoneID, const BLanguage* language)
{
	delete fICULocale;
	fICULocale = NULL;
	delete fICUTimeZone;
	fInitializedFields = 0;

	if (zoneID == NULL || zoneID[0] == '\0')
		fICUTimeZone = TimeZone::createDefault();
	else
		fICUTimeZone = TimeZone::createTimeZone(zoneID);

	if (fICUTimeZone == NULL) {
		fInitStatus = B_NAME_NOT_FOUND;
		return fInitStatus;
	}

	if (language != NULL) {
		fICULocale = new Locale(language->Code());
		if (fICULocale == NULL) {
			fInitStatus = B_NO_MEMORY;
			return fInitStatus;
		}
	}

	UnicodeString unicodeString;
	fICUTimeZone->getID(unicodeString);
	BStringByteSink sink(&fZoneID);
	unicodeString.toUTF8(sink);

	fInitStatus = B_OK;

	return fInitStatus;
}