int getTagId (char * name) {
int id = m_tags == NULL ? -1 : m_tags->find (name);
if (id < 0) {
appendTag (new Tag (name, id = m_nbTags++, NULL));
}
return id;
}
Trigger(bool enabled = true, bool autoDisable = true) :
enabled(enabled),
autoDisable(autoDisable) {
appendTag(TRIGGER_TAG);
}
/**
* Create a tag string from the supplied parameters. The lang, script and region
* parameters may be NULL pointers. If they are, their corresponding length parameters
* must be less than or equal to 0.
*
* If any of the language, script or region parameters are empty, and the alternateTags
* parameter is not NULL, it will be parsed for potential language, script and region tags
* to be used when constructing the new tag. If the alternateTags parameter is NULL, or
* it contains no language tag, the default tag for the unknown language is used.
*
* If the length of the new string exceeds the capacity of the output buffer,
* the function copies as many bytes to the output buffer as it can, and returns
* the error U_BUFFER_OVERFLOW_ERROR.
*
* If an illegal argument is provided, the function returns the error
* U_ILLEGAL_ARGUMENT_ERROR.
*
* Note that this function can return the warning U_STRING_NOT_TERMINATED_WARNING if
* the tag string fits in the output buffer, but the null terminator doesn't.
*
* @param lang The language tag to use.
* @param langLength The length of the language tag.
* @param script The script tag to use.
* @param scriptLength The length of the script tag.
* @param region The region tag to use.
* @param regionLength The length of the region tag.
* @param trailing Any trailing data to append to the new tag.
* @param trailingLength The length of the trailing data.
* @param alternateTags A string containing any alternate tags.
* @param tag The output buffer.
* @param tagCapacity The capacity of the output buffer.
* @param err A pointer to a UErrorCode for error reporting.
* @return The length of the tag string, which may be greater than tagCapacity, or -1 on error.
**/
static int32_t U_CALLCONV
createTagStringWithAlternates(
const char* lang,
int32_t langLength,
const char* script,
int32_t scriptLength,
const char* region,
int32_t regionLength,
const char* trailing,
int32_t trailingLength,
const char* alternateTags,
char* tag,
int32_t tagCapacity,
UErrorCode* err) {
if (U_FAILURE(*err)) {
goto error;
}
else if (tag == NULL ||
tagCapacity <= 0 ||
langLength >= ULOC_LANG_CAPACITY ||
scriptLength >= ULOC_SCRIPT_CAPACITY ||
regionLength >= ULOC_COUNTRY_CAPACITY) {
goto error;
}
else {
/**
* ULOC_FULLNAME_CAPACITY will provide enough capacity
* that we can build a string that contains the language,
* script and region code without worrying about overrunning
* the user-supplied buffer.
**/
char tagBuffer[ULOC_FULLNAME_CAPACITY];
int32_t tagLength = 0;
int32_t capacityRemaining = tagCapacity;
UBool regionAppended = FALSE;
if (langLength > 0) {
appendTag(
lang,
langLength,
tagBuffer,
&tagLength);
}
else if (alternateTags == NULL) {
/*
* Append the value for an unknown language, if
* we found no language.
*/
appendTag(
unknownLanguage,
(int32_t)uprv_strlen(unknownLanguage),
tagBuffer,
&tagLength);
}
else {
/*
* Parse the alternateTags string for the language.
*/
char alternateLang[ULOC_LANG_CAPACITY];
int32_t alternateLangLength = sizeof(alternateLang);
alternateLangLength =
uloc_getLanguage(
alternateTags,
alternateLang,
alternateLangLength,
err);
if(U_FAILURE(*err) ||
alternateLangLength >= ULOC_LANG_CAPACITY) {
goto error;
}
else if (alternateLangLength == 0) {
/*
* Append the value for an unknown language, if
* we found no language.
*/
appendTag(
unknownLanguage,
(int32_t)uprv_strlen(unknownLanguage),
tagBuffer,
&tagLength);
}
else {
appendTag(
alternateLang,
alternateLangLength,
tagBuffer,
&tagLength);
}
}
if (scriptLength > 0) {
appendTag(
script,
scriptLength,
tagBuffer,
&tagLength);
}
else if (alternateTags != NULL) {
/*
* Parse the alternateTags string for the script.
*/
char alternateScript[ULOC_SCRIPT_CAPACITY];
const int32_t alternateScriptLength =
uloc_getScript(
alternateTags,
alternateScript,
sizeof(alternateScript),
err);
if (U_FAILURE(*err) ||
alternateScriptLength >= ULOC_SCRIPT_CAPACITY) {
goto error;
}
else if (alternateScriptLength > 0) {
appendTag(
alternateScript,
alternateScriptLength,
tagBuffer,
&tagLength);
}
}
if (regionLength > 0) {
appendTag(
region,
regionLength,
tagBuffer,
&tagLength);
regionAppended = TRUE;
}
else if (alternateTags != NULL) {
/*
* Parse the alternateTags string for the region.
*/
char alternateRegion[ULOC_COUNTRY_CAPACITY];
const int32_t alternateRegionLength =
uloc_getCountry(
alternateTags,
alternateRegion,
sizeof(alternateRegion),
err);
if (U_FAILURE(*err) ||
alternateRegionLength >= ULOC_COUNTRY_CAPACITY) {
goto error;
}
else if (alternateRegionLength > 0) {
appendTag(
alternateRegion,
alternateRegionLength,
tagBuffer,
&tagLength);
regionAppended = TRUE;
}
}
{
const int32_t toCopy =
tagLength >= tagCapacity ? tagCapacity : tagLength;
/**
* Copy the partial tag from our internal buffer to the supplied
* target.
**/
uprv_memcpy(
tag,
tagBuffer,
toCopy);
capacityRemaining -= toCopy;
}
if (trailingLength > 0) {
if (*trailing != '@' && capacityRemaining > 0) {
tag[tagLength++] = '_';
--capacityRemaining;
if (capacityRemaining > 0 && !regionAppended) {
/* extra separator is required */
tag[tagLength++] = '_';
--capacityRemaining;
}
}
if (capacityRemaining > 0) {
/*
* Copy the trailing data into the supplied buffer. Use uprv_memmove, since we
* don't know if the user-supplied buffers overlap.
*/
const int32_t toCopy =
trailingLength >= capacityRemaining ? capacityRemaining : trailingLength;
uprv_memmove(
&tag[tagLength],
trailing,
toCopy);
}
}
tagLength += trailingLength;
return u_terminateChars(
tag,
tagCapacity,
tagLength,
err);
}
error:
/**
* An overflow indicates the locale ID passed in
* is ill-formed. If we got here, and there was
* no previous error, it's an implicit overflow.
**/
if (*err == U_BUFFER_OVERFLOW_ERROR ||
U_SUCCESS(*err)) {
*err = U_ILLEGAL_ARGUMENT_ERROR;
}
return -1;
}
Tagable() {
static int id = 0;
this->id = id++;
appendTag(HEADER_TAG);
}
