The type of boolean value. The type of object pointer. The type of callback function used for comparing objects. the object to compare with @v2. the object to compare with @v1. The type of callback function used for copying @data. the object to be copied. The database set of structure to peek instances of them. this is useful for the debugging purpose only. The placeholder to store the object of #LtLangDb. The placeholder to store the object of #LtExtlangDb. The placeholder to sthre the object of #LtScriptDb. The placeholder to store the object of #LtRegionDb. The placeholder to store the object of #LtVariantDb. The placeholder to store the object of #LtGrandfatheredDb. The placeholder to store the object of #LtRedundantDb. The placeholder to store the object of #LtRelationDb. The type of callback function used for destroying @data. the object to be destroyed. Static variable for the module version. this is used to ensure if the built module is compatible with the runtime library. All the fields in the <structname>LtError</structname> structure are private to the #LtError implementation. Creates #LtError object. this function is protected and not supposed to use in applications directly. Use lt_error_set(). a newly allocated #LtError. it has to be freed with lt_error_unref(). Clean up all of the errors in @error. a #LtError Checks if @error contains @type of errors. if #LT_ERR_ANY is set to @type, all the types of the errors are targeted. otherwise the result is filtered out by @type. %TRUE if any, otherwise %FALSE a #LtError a #LtErrorype_t Output the error messages in @error according to @type. a #LtError a #LtErrorype_t Inscreases the reference count of @error. the same @error object. a #LtError Decreases the reference count of @error. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtError Sets the error into @error according to the given parameters. an instance of #LtError a return location for a #LtError a #LtErrorype_t the string format to output the error messages the parameters to insert into the format string Error code used in this library. All the fields in the <structname>LtExtModule</structname> structure are private to the #LtExtModule implementation. Increases the reference count of @module. the same @module object. a #lt_ext_module_t. Decreases the reference count of @module. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #lt_ext_module_t. All the fields in the <structname>LtExtModuleData</structname> structure are private to the #LtExtModuleData implementation. a dummy pointer for alignment. Create a new instance of #LtExtModuleData. this function allows to create an inherited instance like: |[ struct _my_module_data_t { LtExtModuleData parent; ...own members... }; ]| a #LtExtModuleData. real size to allocate memory for the object. a callback function to destroy the content. Increases the reference count of @data. the same @data object. a #LtExtModuleData. Decreases the reference count of @data. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtExtModuleData. The type of the callback function used to create a new instance of #LtExtModuleData. This is invoked when new Extension subtag appears and keep data. a new instance of #LtExtModuleData. The <structname>LtExtModuleFuncs</structname> struct is a callback collection to provide an accessor between #lt_extension_t and #LtExtModule and extend features. A callback function to obtain the singleton character that are supposed in the module. A callback function to create a new instance of #LtExtModuleData for the module. A callback function to check tags prior to parse subtags. A callback function to parse a tag. A callback function to obtain the tag string. A callback function to validate the tag. The type of the module_get_funcs() that is required to implement an extension module. a #LtExtModuleFuncs. The type of the callback function used to obtain the tag. a tag string. a #LtExtModuleData. The type of the callback function used to parse tags. %TRUE if the @subtag is valid for Extension. otherwise %FALSE. a #LtExtModuleData. a subtag string to parse. a #LtError. The type of the callback function used to check @tag prior to process parsing subtags for the extension. %TRUE if @tag is valid to process parsing subtags for the extension. otherwise %FALSE. a #LtExtModuleData. a #LtTag. a #LtError. The type of the callback function used to obtain a singleton character for Extension subtag that the module would support. a singleton character. The type of the callback function used to validate the tags in @data. %TRUE if it's valid, otherwise %FALSE. a #LtExtModuleData. The type of the module_get_version() that is required to implement an extension module. a version number. this is the same to #LT_EXT_MODULE_VERSION when the module was built. All the fields in the <structname>LtExtension</structname> structure are private to the #LtExtension implementation. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same, otherwise %FALSE. a #LtExtension. a #LtExtension. Dumps the container information to the standard output. a #LtExtension. Generate a canonicalized tag. a string. this must be freed. a #LtExtension. Obtain the tag string. the tag string. a #LtExtension. Increases the reference count of @extension. the same @extension object. a #LtExtension. Decreases the reference count of @extension. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtExtension. All the fields in the <structname>LtExtlang</structname> structure are private to the #LtExtlang implementation. Compares if @v1 and @v2 is the same object or not. %TRUE if it's the same, otherwise %FALSE. a #LtExtlang. a #LtExtlang. Dumps the container information to the standard output. a #LtExtlang. Obtains the macrolanguage being assigned for the subtag. This is available only when the subtag is registered as the macrolanguage in ISO 639-3. a macrolanguage string or %NULL. a #LtExtlang. Obtains the description of the subtag. a description string. a #LtExtlang. Obtains the preferred-value. this is available only when the subtag is marked as deprecated. a preferred-value for the subtag or %NULL. a #LtExtlang. Obtains the prefix being assigned to the subtag. This is available only when the subtag has a particular seqnence of subgtags that form a meaningful tag with the subtag. a prefix string or %NULL. a #LtExtlang. Obtains the subtag that is registered as ISO 639 code. a subtag name. a #LtExtlang. Increases the reference count of @extlang. the same @extlang object. a #LtExtlang. Decreases the reference count of @extlang. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtExtlang. All the fields in the <structname>LtExtlangDb</structname> structure are private to the #LtExtlangDb implementation. Create a new instance of a #LtExtlangDb. a new instance of #LtExtlangDb. Lookup @LtExtlang if @subtag is valid and registered into the database. a #LtExtlang that meets with @subtag. otherwise %NULL. a #LtExtlangDb. a subtag name to lookup. Increases the reference count of @extlangdb. the same @extlangdb object. a #LtExtlangDb. Decreases the reference count of @extlangdb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtExtlangDb. Expands to the GNU C <literal>format</literal> function attribute if the compiler is <command>gcc</command>. This is used for declaring functions which take a variable number of arguments, with the same syntax as <function>printf()</function>. It allows the compiler to type-check the arguments passed to the function. See the GNU C documentation for details. the index of the argument corresponding to the format string. (The arguments are numberered from 1). the index of the first of the format arguments. All the fields in the <structname>LtGrandfathered</structname> structure are private to the #LtGrandfathered implementation. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same. otherwise %FALSE. a #LtGrandfathered. a #LtGrandfathered. Dumps the container information to the standard output. a #LtGrandfathered. Obtains the better tag for use. this is a convenient function to get the preferred-value if available. a tag string. a #LtGrandfathered. Obtains the description of the tag. a description string. a #LtGrandfathered. Obtains the preferred-value. this is available only when the tag is marked as deprecated. a preferred-value for the tag or %NULL. a #LtGrandfathered. Obtains the tag name. a tag string. a #LtGrandfathered. Increases the reference count of @grandfathered. the same @grandfathered object. a #LtGrandfathered. Decreases the reference count of @grandfathered. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtGrandfathered. All the fields in the <structname>LtGrandfatheredDb</structname> structure are private to the #LtGrandfatheredDb implementation. Create a new instance of a #LtGrandfatheredDb. a new instance of #LtGrandfatheredDb. Lookup @LtGrandfathered if @tag is valid and registered into the database. a #LtGrandfathered that meets with @tag. otherwise %NULL. a #LtGrandfatheredDb. a tag name to lookup. Increases the reference count of @grandfathereddb. the same @grandfathereddb object. a #LtGrandfatheredDb. Decreases the reference count of @grandfathereddb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtGrandfatheredDb. This is a convenient macro to call lt_iter_init(). an object that initialize the iterator with. All the fields in the <structname>LtIter</structname> structure are private to the #LtIter implementation. Finalize the iterator and free its memory. a #LtIter Advances @iter and retrieves the key and/or value that are now pointed to as a result of this advancement. If %FALSE is returned, @key and @value are not set, and the iterator becomes invalid. %FALSE if the end of the object that the iterator is adapted has been reached. a #LtIter a location to store the key, or %NULL a location to store the value, or %NULL Increases the reference count of @iter. the same @iter object. a #LtIter Decreases the reference count of @iter. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtIter Initialize the iterator with @tmpl object. this function has to be called before performing any opperation with the iterator and lt_iter_finish() when the iterator isn't needed anymore. |[ lt_lang_db *lang = lt_lang_db_new(); LtPointer *key, *val; LtIter *iter; iter = LT_ITER_INIT (lang); while (lt_iter_next(iter, &key, &val)) { /&ast; do something with key and value &ast;/ } lt_iter_finish(iter); ]| the initialized iterator object. a #LtItermpl_t All the fields in the <structname>LtIterTmpl</structname> structure are private to the #LtIterTmpl implementation. Hints the compiler that the expression is likely to evaluate to a true value. The compiler may use this information for optimizations. the expression All the fields in the <structname>LtLang</structname> structure are private to the #LtLang implementation. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same, otherwise %FALSE. a #LtLang. a #LtLang. Dumps the container information to the standard output. a #LtLang. Obtains the better tag for use. this is a convenient function to get the preferred-value if available. a tag string. a #LtLang. Obtains the macrolanguage being assigned for the subtag. This is available only when the subtag is registered as the macrolanguage in ISO 639-3. a macrolanguage string or %NULL. a #LtLang. Obtains the description of the subtag. a description string. a #LtLang. Obtains the preferred-value. this is available only when the tag is marked as deprecated. a preferred-value for the tag or %NULL. a #LtLang. Obtains the scope value indicating the type of language code according to ISO 639. a scope string or %NULL. a #LtLang. Obtains the suppress-script value. which shouldn't be used to form language tags with the associated primary or extended language subtag. a suppress-script string or %NULL. a #LtLang. Obtains the tag name. a tag string. a #LtLang. Increases the reference count of @lang. the same @lang object. a #LtLang. Decreases the reference count of @lang. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtLang. All the fields in the <structname>LtLangDb</structname> structure are private to the #LtLangDb implementation. Create a new instance of a #LtLangDb. a new instance of #LtLangDb. Lookup @LtLang if @subtag is valid and registered into the database. a #LtLang that meets with @subtag. otherwise %NULL. a #LtLangDb. a subtag name to lookup. Increases the reference count of @langdb. the same @langdb object. a #LtLangDb. Decreases the reference count of @langdb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtLangDb. All the fields in the <structname>LtList</structname> structure are private to the #LtList implementation. Creates #LtList object. this function is protected and not supposed to use in applications directly. Use lt_list_append() or lt_list_prepend() with %NULL as the first argument to newly allocate the object. a newly allocated #LtList. it has to be freed with lt_list_unref(). Adds a new element on to the end of the list. the new start of the #LtList. a #LtList. the data for the new element the call back function to destroy @data or %NULL Removes an element from a #LtList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #LtList is unchanged. the new start of the #LtList. a #LtList. the data of the element to remove. Removes the node @link_ from the @list and frees it. the new head of @list a #LtList node to delete from @list Finds the element in a #LtList which contains the given data. the found #LtList element, or %NULL if it's not found a #LtList the element data to find Finds an element in a #LtList, using a supplied function to find the desired element. It iterates over the list, calling the given function which should return 0 when the desired element is found. The function takes two const #LtPointer arguments, the #LtList element's data as the first argument and the given data. the found #LtList element, or %NULL if it's not found a #LtList the data passed to the function the function to call for each element. It should return 0 when the desired element is found Gets the first element in a #LtList. the first element in the #LtList or %NULL if the #LtList has no elements. a #LtList. Gets the last element in a #LtList. the last element in the #LtList or %NULL if the #LtList has no elements. a #LtList. Gets the number of elements in a #LtList. the number of elements in the #LtList. a #LtList. Gets the next element in a #LtList. the next element, or %NULL if there are no more elements. a #LtList. Sets the data in the first element to @data and drop the element. the new head of @list. a #LtList a pointer to set the data in the first element Adds a new element on to the start of the list. the new start of the #LtList. a #LtList the data for the new element the call back function to destroy @data or %NULL Gets the previous element in a #LtList. the previous element, or %NULL if there are no previous elements. a #LtList. Increases the reference count of @list. the same @list object. a #LtList. Removes an element from a #LtList. If two elements contain the same data, only the first is removed. If none of the elements contain the data, the #LtList is unchanged. This works similar to lt_list_delete() though, the difference is this won't calls the finalizer to destroy the data in the element. the new start of the #LtList. a #LtList. the data of the element to remove. Sorts a #LtList using the given comparison function. the start of the sorted #LtList a #LtList the comparison function used to sort the #LtList. This function is passed the data from 2 elements of the #LtList and should return 0 if they are equal, a negative value if the first element comes before the second, or a positive value if the first element comes after the second. Decreases the reference count of @list. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtList. Gets a value in a #LtList. a pointer to be set to the #LtList. a #LtList. Frees all of the memory used by a #LtList. a #LtList. Determines the number of elements in an array. The array must be declared so the compiler knows its size at compile-time; this macro will not work on an array allocated on the heap, only static arrays or arrays on the stack. the array All the fields in the <structname>LtRedundant</structname> structure are private to the #LtRedundant implementation. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same. otherwise %FALSE. a #LtRedundant. a #LtRedundant. Dumps the container information to the standard output. a #LtRedundant. Obtains the better tag for use. this is a convenient function to get the preferred-value if available. a tag string. a #LtRedundant. Obtains the description of the tag. a description string. a #LtRedundant. Obtains the preferred-value. this is available only when the tag is marked as deprecated. a preferred-value for the tag or %NULL. a #LtRedundant. Obtains the tag name. a tag string. a #LtRedundant. Increases the reference count of @redundant. the same @redundant object. a #LtRedundant. Decreases the reference count of @redundant. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtRedundant. All the fields in the <structname>LtRedundantDb</structname> structure are private to the #LtRedundantDb implementation. Create a new instance of a #LtRedundantDb. a new instance of #LtRedundantDb. Lookup @lt_redundant_t if @tag is valid and registered into the database. a #lt_redundant_t that meets with @tag. otherwise %NULL. a #LtRedundantDb. a tag name to lookup. Increases the reference count of @redundantdb. the same @redundantdb object. a #LtRedundantDb. Decreases the reference count of @redundantdb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtRedundantDb. All the fields in the <structname>LtRegion</structname> structure are private to the #LtRegion implementation. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same, otherwise %FALSE. a #LtRegion. a #LtRegion. Dumps the container information to the standard output. a #LtRegion. Obtains the better tag for use. this is a convenient function to get the preferred-value if available. a tag string. a #LtRegion. Obtains the description of the subtag. a description string. a #LtRegion. Obtains the preferred-value. this is available only when the tag is marked as deprecated. a preferred-value for the tag or %NULL. a #LtRegion. Obtains the tag name. a tag string. a #LtRegion. Increases the reference count of @region. the same @region object. a #LtRegion. Decreases the reference count of @region. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtRegion. All the fields in the <structname>LtRegionDb</structname> structure are private to the #LtRegionDb implementation. Create a new instance of a #LtRegionDb. a new instance of #LtRegionDb. Lookup @LtRegion if @language_or_code is valid and registered into the database. a #LtRegion that meets with @language_or_code. otherwise %NULL. a #LtRegionDb. a region code to lookup. Increases the reference count of @regiondb. the same @regiondb object. a #LtRegionDb. Decreases the reference count of @regiondb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtRegionDb. All the fields in the <structname>LtRelationDb</structname> structure are private to the #LtRelationDb implementation. Create a new instance of a #LtRelationDb. a new instance of #LtRelationDb. Look up the languages corresponding to the script @script. a #LtList containing #LtLang object. a #LtRelationDb. a #LtScript. Look up the scripts corresponding to the language @lang. a #LtList containing #LtScript objects. a #LtRelationDb. a #LtLang. Increases the reference count of @relationdb. the same @relationddb object. a #LtRelationDb. Decreases the reference count of @relationdb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtRelationDb. All the fields in the <structname>LtScript</structname> structure are private to the #LtScript implementation. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same, otherwise %FALSE. a #LtScript. a #LtScript. Convert the script subtag to the locale variant modifier. a modifier string or %NULL. a #LtScript. Dumps the container information to the standard output. a #LtScript. Obtains the description of the subtag. a description string. a #LtScript. Obtains the tag name. a tag string. a #LtScript. Increases the reference count of @script. the same @script object. a #LtScript. Decreases the reference count of @script. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtScript. All the fields in the <structname>LtScriptDb</structname> structure are private to the #LtScriptDb implementation. Create a new instance of a #LtScriptDb. a new instance of #LtScriptDb. Lookup @LtScript if @subtag is valid and registered into the database. a #LtScript that meets with @subtag. otherwise %NULL. a #LtScriptDb. a subtag name to lookup. Increases the reference count of @scriptdb. the same @scriptdb object. a #LtScriptDb. Decreases the reference count of @scriptdb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtScriptDb. All the fields in the <structname>LtString</structname> structure are private to the #LtString implementation. Creates an instance of #LtString with @string. a new instance of #LtString. an initial string to set Adds a string onto the end of a #LtString, expanding it if necessary. the same @string object a #LtString the string to append onto the end of @string Adds a byte onto the end of a #LtString, expanding it if necessary. the same @string object. a #LtString the byte to append onto the end of @string Adds a string onto the end of a #LtString as a file path. the same @string object a #LtString the string to append onto the end of @string as a file path a %NULL-terminated list of strings to append onto the end of @string as a file path Appends a formatted string onto the end of a #LtString. This is similar to the standard sprintf() function, except that the text is appended to the #LtString. a #LtString the string format. See the printf() documentation the parameters to insert into the format string Obtain a byte in a #LtString at @pos. If @pos is a negative, the position is calculated from current size. i.e. if the buffer contains "abc", and @pos is -1, this will returns 'c' then. the byte in @string at @pos a #LtString position in @string where to obtain the byte Clean up the buffer in @string. a #LtString Frees the memory allocated for the #LtString. If @free_segment is %TRUE it also frees the character data. If it's %FALSE, the caller gains ownership of the buffer and must free it after use with free(). the character data of @string (i.e. %NULL if @free_segment is %TRUE) a #LtString if %TRUE, the actual character data is freed as well Returns the number of characters in buffer for @string. the number of characters a #LtString Increases the reference count of @string. the same @string object. a #LtString Replaces a character in @string at @pos. the same @string object a #LtString position in @string where replacement should happen the byte to replace Decreases the reference count of @string. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtString Returns the buffer in @string. a string which @string has. a #LtString All the fields in the <structname>LtTag</structname> structure are private to the #LtTag implementation. Create a new instance of #LtTag. a new instance of #LtTag. Canonicalize the language tag according to various information of subtags. a language tag string. a #LtTag. a #LtError or %NULL. Canonicalize the language tag in the extlang form according to various information of subtags. a language tag string. a #LtTag. a #LtError or %NULL. (Re-)Initialize all of the subtag information stored in @tag. a #LtTag. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same, otherwise %FALSE. a #LtTag. a #LtTag. Convert the language tag to the locale. a locale string or %NULL if fails a #LtTag. a #LtError or %NULL. Create a copy instance of @tag. a new instance of #LtTag or %NULL if fails. a #LtTag. Dumps the container information to the standard output. a #LtTag. Obtain a #LtExtension instance in @tag. a #LtExtension. a #LtTag. Obtain a #LtExtlang instance in @tag. a #LtExtlang. a #LtTag. Obtain a #LtGrandfathered instance in @tag. a #LtGrandfathered. a #LtTag. Obtain a #LtLang instance in @tag. a #LtLang. a #LtTag. Obtain a #LtString instance in @tag. a #LtString. a #LtTag. Obtain a #LtRegion instance in @tag. a #LtRegion. a #LtTag. Obtain a #LtScript instance in @tag. a #LtScript. a #LtTag. Obtains a language tag in string. a language tag string. a #LtTag. Obtains a language tag in string against @filter. a language tag string. a #LtTag. a binary count sequence of #lt_tag_filter_t. Obtain a list of #LtVariant instance in @tag. a #LtList containing #LtVariant. a #LtTag. Lookup the language tag that @tag meets with @pattern. Any of subtags in @pattern is allowed to use the wildcard according to the syntax in RFC 4647. a language tag string if any matches, otherwise %NULL. a #LtTag. a language range string. a #LtError or %NULL. Try matching of @v1 and @v2. any of subtags in @v2 is allowed to use the wildcard according to the syntax in RFC 4647. %TRUE if it matches, otherwise %FALSE. a #LtTag. a language range string. a #LtError or %NULL. Parse @tag_string and create appropriate instances for subtags. %TRUE if it's successfully completed, otherwise %FALSE. a #LtTag. language tag to be parsed. a #LtError or %NULL. Continue to parse a language tag with @tag_string. please use lt_tag_parse() at first. %TRUE if it's successfully completed, otherwise %FALSE. a #LtTag. a language tag to be parsed much more. a #LtError or %NULL. Increases the reference count of @tag. the same @tag object. a #LtTag. Decreases the reference count of @tag. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtTag. Convert current locale to the language tag. a #LtTag, %NULL if fails. a #LtError. Convert @locale to the language tag. a #LtTag, %NULL if fails. a locale string a #LtError or %NULL. This is used as a binary count sequence with lt_tag_get_string_with_filter() to allow only given tags to be the outcome. Hints the compiler that the expression is unlikely to evaluate to a true value. The compiler may use this information for optimizations. the expression All the fields in the <structname>LtVariant</structname> structure are private to the #LtVariant implementation. Compare if @v1 and @v2 is the same object or not. %TRUE if it's the same, otherwise %FALSE. a #LtVariant. a #LtVariant. Dumps the container information to the standard output. a #LtVariant. Obtains the better tag for use. this is a convenient function to get the preferred-value if available. a tag string. a #LtVariant. Obtains the description of the subtag. a description string. a #LtVariant. Obtains the preferred-value. this is available only when the tag is marked as deprecated. a preferred-value for the tag or %NULL. a #LtVariant. Obtains the prefix being assigned to the subtag. This is available only when the subtag has any suitable sequence of subtags for forming (with other subtags, as appropriate) a language tag when using the variant. a #LtList contains prefix strings or %NULL. a #LtVariant. Obtains the tag name. a tag string. a #LtVariant. Increases the reference count of @variant. the same @variant object. a #LtVariant. Decreases the reference count of @variant. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtVariant. All the fields in the <structname>LtVariantDb</structname> structure are private to the #LtVariantDb implementation. Create a new instance of a #LtVariantDb. a new instance of #LtVariantDb. Lookup @LtVariant if @subtag is valid and registered into the database. a #LtVariant that meets with @subtag. otherwise %NULL. a #LtVariantDb. a subtag name to lookup. Increases the reference count of @variantdb. the same @variantdb object. a #LtVariantDb. Decreases the reference count of @variantdb. when its reference count drops to 0, the object is finalized (i.e. its memory is freed). a #LtVariantDb. Load all of the modules on the system, including the internal accessor. This has to be invoked before processing something with #lt_extension_t. or lt_db_initialize() does. Unload all of the modules already loaded. Initialize the iterator with @tmpl object. this function has to be called before performing any opperation with the iterator and lt_iter_finish() when the iterator isn't needed anymore. |[ lt_lang_db *lang = lt_lang_db_new(); LtPointer *key, *val; LtIter *iter; iter = LT_ITER_INIT (lang); while (lt_iter_next(iter, &key, &val)) { /&ast; do something with key and value &ast;/ } lt_iter_finish(iter); ]| the initialized iterator object. a #LtItermpl_t Frees all of the memory used by a #LtList. a #LtList. This section describes the error handling in this library. This class provides functionality to extend features in #lt_extension_t, such as validating tags more strictly. This container class provides a data access for a specific data of extension subtag. This container class provides a data access to Extension subtag entry. This container class provides a data access to Extlang subtag entry. This class provides an interface to access Extlang database. which has been registered as ISO 639 code. This container class provides a data access to Grandfathered subtag entry. This class provides an interface to access Grandfathered database. which has been registered under RFC 3066 and mostly deprecated. This class provides a common interface to iterate over the key/value pairs in an initiated object. This container class provides a data access to Language subtag entry. This class provides an interface to access Language database. which has been registered as ISO 639 code. The #LtList object and its associated functions provide a standard doubly-linked list data structure. These macros provide more specialized features which are not needed so often by application programmers. This container class provides a data access to Redundant subtag entry. This class provides an interface to access Redundant database. which were mostly made redundant by the advent of either RFC 4646 or RFC 5646. This container class provides a data access to Region subtag entry. This class provides an interface to access Region database. which has been registered as ISO 3166-1 and UN M.49 code. This class providdes an interface to access Relation database. This container class provides a data access to Script subtag entry. This class provides an interface to access Script Database. which has been registered as ISO 15924. A #LtString is an object that handles the memory management of a C string. This container class provides an interface to deal with the language tag. This container class provides a data access to Variant subtag entry. This class provides an interface to access Variant database. which has been registered with IANA. Convert current locale to the language tag. a #LtTag, %NULL if fails. a #LtError. Convert @locale to the language tag. a #LtTag, %NULL if fails. a locale string a #LtError or %NULL.