/// <summary>
/// See <see cref="IResourceDataAccessor.GetSupportedCultures"/>
/// </summary>
public List <System.Globalization.CultureInfo> GetSupportedCultures(LanguageResourceType t)
{
EnsureResourceNames();
List <System.Globalization.CultureInfo> result = new List <System.Globalization.CultureInfo>();
string typeSuffix = GetResourceTypeName(t);
foreach (string fullrn in _ResourceNames)
{
if (_KeyPrefix == null || fullrn.StartsWith(_KeyPrefix, StringComparison.OrdinalIgnoreCase))
{
string rn = _KeyPrefix == null ? fullrn : fullrn.Substring(_KeyPrefix.Length + 1);
if (rn.EndsWith(typeSuffix, StringComparison.OrdinalIgnoreCase))
{
try
{
string cn = rn.Substring(0, rn.Length - typeSuffix.Length - 1);
result.Add(Core.CultureInfoExtensions.GetCultureInfo(cn));
}
catch
{
}
}
}
}
return(result.Count > 0 ? result : null);
}
/// <summary>
/// Computes the full resource key name, which is a combination of the optional <see cref="KeyPrefix"/>,
/// the name of the provided <paramref name="culture"/>, and the standardized resource key name (see <see cref="GetResourceTypeName"/>).
/// </summary>
/// <param name="culture">An optional culture. If supplied, the culture's name will be used to compute the resource key.</param>
/// <param name="t">The language resource type for which to get the resource key</param>
/// <returns>The full language resource key</returns>
public string GetName(System.Globalization.CultureInfo culture, LanguageResourceType t)
{
if (culture == null || System.Globalization.CultureInfo.InvariantCulture.LCID == culture.LCID)
{
return(GetName("", t));
}
else
{
return(GetName(culture.Name, t));
}
}
/// <summary>
/// See <see cref="IResourceDataAccessor.GetResourceStatus"/>. The
/// status returned is the status returned by the first accessor which differs from
/// <see cref="ResourceStatus.NotAvailable"/>.
/// </summary>
public ResourceStatus GetResourceStatus(System.Globalization.CultureInfo culture,
LanguageResourceType t, bool fallback)
{
for (int i = 0; i < _IndividualAccessors.Count; ++i)
{
ResourceStatus s = _IndividualAccessors[i].GetResourceStatus(culture, t, fallback);
if (s != ResourceStatus.NotAvailable)
{
return(s);
}
}
return(ResourceStatus.NotAvailable);
}
/// <summary>
/// See <see cref="IResourceDataAccessor.ReadResourceData"/>.
/// The data returned is the data returned by the first accessor which has available data.
/// </summary>
public System.IO.Stream ReadResourceData(System.Globalization.CultureInfo culture,
LanguageResourceType t, bool fallback)
{
for (int i = 0; i < _IndividualAccessors.Count; ++i)
{
// TODO could cache this information
ResourceStatus s = _IndividualAccessors[i].GetResourceStatus(culture, t, fallback);
if (s != ResourceStatus.NotAvailable)
{
return(_IndividualAccessors[i].ReadResourceData(culture, t, fallback));
}
}
return(null);
}
/// <summary>
/// See <see cref="IResourceDataAccessor.GetSupportedCultures"/>.
/// The list of supported cultures is the combination of supported cultures of all individual
/// accessors for the specified resource type.
/// </summary>
public List <System.Globalization.CultureInfo> GetSupportedCultures(LanguageResourceType t)
{
List <System.Globalization.CultureInfo> result = new List <System.Globalization.CultureInfo>();
for (int i = 0; i < _IndividualAccessors.Count; ++i)
{
foreach (System.Globalization.CultureInfo ci in _IndividualAccessors[i].GetSupportedCultures(t))
{
if (!result.Contains(ci))
{
result.Add(ci);
}
}
}
return(result.Count > 0 ? result : null);
}
/// <summary>
/// Computes the full resource key name, which is a combination of the optional <see cref="KeyPrefix"/>,
/// the <paramref name="culturePrefix"/>, and the standardized resource key name (see <see cref="GetResourceTypeName"/>).
/// </summary>
/// <param name="culturePrefix">An optional prefix which usually is the culture code (e.g. "en-US")</param>
/// <param name="t">The language resource type for which to get the resource key</param>
/// <returns>The full language resource key</returns>
public string GetName(string culturePrefix, LanguageResourceType t)
{
System.Text.StringBuilder sb = new StringBuilder();
if (!String.IsNullOrEmpty(_KeyPrefix))
{
sb.Append(_KeyPrefix);
sb.Append(".");
}
if (!String.IsNullOrEmpty(culturePrefix))
{
sb.Append(culturePrefix);
sb.Append("_");
}
sb.Append(GetResourceTypeName(t));
return(sb.ToString());
}
/// <summary>
/// Returns the resource data for the required resource as a word list. If the stored
/// resource is not a word list, an exception will be thrown.
/// </summary>
/// <param name="accessor">The resource data accessor to use to retrieve the data</param>
/// <param name="culture">The culture to obtain the resource for</param>
/// <param name="t">The type of the language resource to retrieve</param>
/// <param name="fallback">Whether or not to use a fallback stragegy if specific
/// resources cannot be found (see <see cref="IResourceDataAccessor.ReadResourceData"/>)</param>
/// <returns>The requested data as a word list</returns>
public static Core.Wordlist LoadWordlist(IResourceDataAccessor accessor,
System.Globalization.CultureInfo culture,
LanguageResourceType t,
bool fallback)
{
// TODO check resource type and load only compatible data
using (System.IO.Stream s = accessor.ReadResourceData(culture, t, fallback))
{
if (s == null)
{
return(null);
}
Core.Wordlist l = new Core.Wordlist();
l.Load(s);
return(l);
}
}
/// <summary>
/// Gets the resource key name, given a culture and the language resource type. Optionally
/// the following search strategy is applied if resources for the exact culture cannot be found:
/// <list type="ordered">
/// <item>First, it is checked whether data for the exact culture is available.</item>
/// <item>If not, data is continually requested for the culture's parent culture,
/// until the parent culture is the invariant culture, or undefined.</item>
/// <item>Data is then requested for the culture's language group.</item>
/// <item>Finally, data is requested for the invariant culture (<see cref="System.Globalization.CultureInfo.InvariantCulture"/>)</item>
/// </list>
/// The first resource key for which data is available is then returned, or <c>null</c> if no data can be found.
/// </summary>
/// <param name="culture">The culture for which to retrieve resource data</param>
/// <param name="t">The type of the language resource to retrieve</param>
/// <param name="fallback">If <c>true</c>, a fallback search strategy is applied to find
/// resources for compatible, but less specific resource data.</param>
/// <returns>The full resource key for the language resource, or <c>null</c> if
/// no data is available.</returns>
public string GetResourceName(System.Globalization.CultureInfo culture,
LanguageResourceType t, bool fallback)
{
EnsureResourceNames();
string fullName = GetName(culture, t);
string found = Find(fullName);
if (!fallback)
{
return(found); // may be null
}
// language fallback
// NOTE that the invariant's culture's parent is the invariant culture (not a null culture). We therefore
// test on LCID equality
bool triedLanguageFamily = false;
while (found == null && culture.Parent != null && culture.Parent.LCID != culture.LCID)
{
if (culture.Parent.LCID == System.Globalization.CultureInfo.InvariantCulture.LCID &&
!triedLanguageFamily)
{
string languageGroupName = CultureInfoExtensions.GetLanguageGroupName(culture);
if (languageGroupName != null)
{
fullName = GetName(languageGroupName, t);
found = Find(fullName);
// culture remains the same (will fall back on next iter)
}
triedLanguageFamily = true;
}
else
{
culture = culture.Parent;
fullName = GetName(culture, t);
found = Find(fullName);
}
}
return(found);
}
/// <summary>
/// Gets the standardized resource key name for the specified language resource type,
/// without an added prefix.
/// </summary>
/// <param name="t">The language resource type</param>
/// <returns>The standardized resource key name for the specified language resource type</returns>
public static string GetResourceTypeName(LanguageResourceType t)
{
switch (t)
{
case LanguageResourceType.Variables:
return("Variables.txt");
case LanguageResourceType.Abbreviations:
return("Abbreviations.txt");
case LanguageResourceType.OrdinalFollowers:
return("OrdinalFollowers.txt");
case LanguageResourceType.SegmentationRules:
return("SegmentationRules.xml");
case LanguageResourceType.TokenizerSettings:
return("TokenizerSettings.xml");
case LanguageResourceType.StemmingRules:
return("StemmingRules.txt");
case LanguageResourceType.Stopwords:
return("Stopwords.txt");
case LanguageResourceType.DatePatterns:
return("DatePatterns.xml");
case LanguageResourceType.TimePatterns:
return("TimePatterns.xml");
case LanguageResourceType.NumberPatterns:
return("NumberPatterns.xml");
case LanguageResourceType.MeasurementPatterns:
return("MeasurementPatterns.xml");
case LanguageResourceType.CharTrigramVector:
return("CharTrigrams.dat");
case LanguageResourceType.ShortDateFST:
return("ShortDate.fst");
case LanguageResourceType.LongDateFST:
return("LongDate.fst");
case LanguageResourceType.ShortTimeFST:
return("ShortTime.fst");
case LanguageResourceType.LongTimeFST:
return("LongTime.fst");
case LanguageResourceType.CurrencySymbols:
return("CurrencySymbols.txt");
case LanguageResourceType.PhysicalUnits:
return("PhysicalUnits.txt");
case LanguageResourceType.NumberFST:
return("Number.fst");
case LanguageResourceType.MeasurementFST:
return("Measurement.fst");
case LanguageResourceType.GenericRecognizers:
return("GenericRecognizers.xml");
case LanguageResourceType.Undefined:
default:
throw new ArgumentException("Illegal enum");
}
}
/// <summary> /// See <see cref="IResourceDataAccessor.GetResourceData"/> /// </summary> public abstract byte[] GetResourceData(System.Globalization.CultureInfo culture, LanguageResourceType t, bool fallback);
/// <summary>
/// See <see cref="IResourceDataAccessor.ReadResourceData"/>
/// </summary>
public abstract System.IO.Stream ReadResourceData(System.Globalization.CultureInfo culture,
LanguageResourceType t, bool fallback);
/// <summary>
/// See <see cref="IResourceDataAccessor.GetResourceStatus"/>
/// </summary>
public ResourceStatus GetResourceStatus(System.Globalization.CultureInfo culture, LanguageResourceType t, bool fallback)
{
string fullName = GetResourceName(culture, t, fallback);
return((fullName == null) ? ResourceStatus.NotAvailable : ResourceStatus.Loadable);
}
/// <summary>
/// See <see cref="IResourceDataAccessor.GetResourceData"/>.
/// The data returned is the data returned by the first accessor which has available data.
/// </summary>
public byte[] GetResourceData(System.Globalization.CultureInfo culture, LanguageResourceType t, bool fallback)
{
using (System.IO.Stream str = ReadResourceData(culture, t, fallback))
return(ResourceStorage.StreamToByteArray(str));
}
/// <summary>
/// See <see cref="ResourceStorage.GetResourceData"/>
/// </summary>
public override byte[] GetResourceData(System.Globalization.CultureInfo culture, LanguageResourceType t, bool fallback)
{
lock (_cacheLock)
{
if (_ResourceData == null)
{
// fill caches
GetAllResourceKeys();
if (_ResourceData == null)
{
return(null);
}
}
}
string name = GetResourceName(culture, t, fallback);
byte[] resourceData;
if (name != null && _ResourceData.Data.TryGetValue(name, out resourceData))
{
return(resourceData);
}
return(null);
}
/// <summary>
/// See <see cref="ResourceStorage.ReadResourceData"/>
/// </summary>
public override System.IO.Stream ReadResourceData(System.Globalization.CultureInfo culture, LanguageResourceType t, bool fallback)
{
byte[] data = GetResourceData(culture, t, fallback);
if (data == null)
{
return(null);
}
else
{
return(new System.IO.MemoryStream(data, false));
}
}
