NLS.cs

Go to the documentation of this file.

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Collections.Generic;
using Lucene.Net.Support;

namespace Lucene.Net.Messages
{
    
    /// <summary> MessageBundles classes extend this class, to implement a bundle.
    /// 
    /// For Native Language Support (NLS), system of software internationalization.
    /// 
    /// This interface is similar to the NLS class in eclipse.osgi.util.NLS class -
    /// initializeMessages() method resets the values of all static strings, should
    /// only be called by classes that extend from NLS (see TestMessages.java for
    /// reference) - performs validation of all message in a bundle, at class load
    /// time - performs per message validation at runtime - see NLSTest.java for
    /// usage reference
    /// 
    /// MessageBundle classes may subclass this type.
    /// </summary>
    public class NLS
    {
        public interface IPriviligedAction
        {
            /// <summary>
            /// Performs the priviliged action.
            /// </summary>
            /// <returns>A value that may represent the result of the action.</returns>
            System.Object Run();
        }

        private class AnonymousClassPrivilegedAction : IPriviligedAction
        {
            public AnonymousClassPrivilegedAction(System.Reflection.FieldInfo field)
            {
                InitBlock(field);
            }
            private void  InitBlock(System.Reflection.FieldInfo field)
            {
                this.field = field;
            }
            private System.Reflection.FieldInfo field;
            public virtual System.Object Run()
            {
                // field.setAccessible(true); // {{Aroush-2.9}} java.lang.reflect.AccessibleObject.setAccessible
                return null;
            }
        }
        
        private static IDictionary<string, Type> bundles = new HashMap<string, Type>(0);
        
        protected internal NLS()
        {
            // Do not instantiate
        }
        
        public static System.String GetLocalizedMessage(System.String key)
        {
            return GetLocalizedMessage(key, System.Threading.Thread.CurrentThread.CurrentCulture);
        }
        
        public static System.String GetLocalizedMessage(System.String key, System.Globalization.CultureInfo locale)
        {
            System.Object message = GetResourceBundleObject(key, locale);
            if (message == null)
            {
                return "Message with key:" + key + " and locale: " + locale + " not found.";
            }
            return message.ToString();
        }
        
        public static System.String GetLocalizedMessage(System.String key, System.Globalization.CultureInfo locale, params System.Object[] args)
        {
            System.String str = GetLocalizedMessage(key, locale);
            
            if (args.Length > 0)
            {
                str = System.String.Format(str, args);
            }
            
            return str;
        }
        
        public static System.String GetLocalizedMessage(System.String key, params System.Object[] args)
        {
            return GetLocalizedMessage(key, System.Threading.Thread.CurrentThread.CurrentCulture, args);
        }
        
        /// <summary> Initialize a given class with the message bundle Keys Should be called from
        /// a class that extends NLS in a static block at class load time.
        /// 
        /// </summary>
        /// <param name="bundleName">Property file with that contains the message bundle
        /// </param>
        /// <param name="clazz">where constants will reside
        /// </param>
        //@SuppressWarnings("unchecked")
        protected internal static void  InitializeMessages<T>(System.String bundleName)
        {
            try
            {
                Load<T>();
                if (!bundles.ContainsKey(bundleName))
                    bundles[bundleName] = typeof(T);
            }
            catch (System.Exception)
            {
                // ignore all errors and exceptions
                // because this function is supposed to be called at class load time.
            }
        }
        
        private static System.Object GetResourceBundleObject(System.String messageKey, System.Globalization.CultureInfo locale)
        {
            
            // slow resource checking
            // need to loop thru all registered resource bundles
            for (var it = bundles.Keys.GetEnumerator(); it.MoveNext(); )
            {
                System.Type clazz = bundles[it.Current];
                System.Threading.Thread.CurrentThread.CurrentUICulture = locale;
                System.Resources.ResourceManager resourceBundle = System.Resources.ResourceManager.CreateFileBasedResourceManager(clazz.Name, "Messages", null); //{{Lucene.Net-2.9.1}} Can we make resourceDir "Messages" more general?
                if (resourceBundle != null)
                {
                    try
                    {
                        System.Object obj = resourceBundle.GetObject(messageKey);
                        if (obj != null)
                            return obj;
                    }
                    catch (System.Resources.MissingManifestResourceException)
                    {
                        // just continue it might be on the next resource bundle
                    }
                }
            }
            // if resource is not found
            return null;
        }
        
        private static void  Load<T>()
        {
            var clazz = typeof (T);
            System.Reflection.FieldInfo[] fieldArray = clazz.GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.DeclaredOnly | System.Reflection.BindingFlags.Static);
            
            bool isFieldAccessible = clazz.IsPublic;
            
            // build a map of field names to Field objects
            int len = fieldArray.Length;
            var fields = new HashMap<string, System.Reflection.FieldInfo>(len * 2);
            for (int i = 0; i < len; i++)
            {
                fields[fieldArray[i].Name] = fieldArray[i];
                LoadfieldValue<T>(fieldArray[i], isFieldAccessible);
            }
        }

        /// <param name="field"></param>
        /// <param name="isFieldAccessible"></param>
        private static void  LoadfieldValue<T>(System.Reflection.FieldInfo field, bool isFieldAccessible)
        {
            var clazz = typeof (T);
            /*
            int MOD_EXPECTED = Modifier.PUBLIC | Modifier.STATIC;
            int MOD_MASK = MOD_EXPECTED | Modifier.FINAL;
            if ((field.getModifiers() & MOD_MASK) != MOD_EXPECTED)
                return ;
            */
            if (!(field.IsPublic || field.IsStatic))
                return ;
            
            // Set a value for this empty field.
            if (!isFieldAccessible)
                MakeAccessible(field);
            try
            {
                field.SetValue(null, field.Name);
                ValidateMessage<T>(field.Name);
            }
            catch (System.ArgumentException)
            {
                // should not happen
            }
            catch (System.UnauthorizedAccessException)
            {
                // should not happen
            }
        }
        
        /// <param name="key">- Message Key
        /// </param>
        private static void  ValidateMessage<T>(System.String key)
        {
            // Test if the message is present in the resource bundle
            var clazz = typeof (T);
            try
            {
                System.Threading.Thread.CurrentThread.CurrentUICulture = System.Threading.Thread.CurrentThread.CurrentCulture;
                System.Resources.ResourceManager resourceBundle = System.Resources.ResourceManager.CreateFileBasedResourceManager(clazz.FullName, "", null);
                if (resourceBundle != null)
                {
                    System.Object obj = resourceBundle.GetObject(key);
                    if (obj == null)
                    {
                        System.Console.Error.WriteLine("WARN: Message with key:" + key + " and locale: " + System.Threading.Thread.CurrentThread.CurrentCulture + " not found.");
                    }
                }
            }
            catch (System.Resources.MissingManifestResourceException)
            {
                System.Console.Error.WriteLine("WARN: Message with key:" + key + " and locale: " + System.Threading.Thread.CurrentThread.CurrentCulture + " not found.");
            }
            catch (System.Exception)
            {
                // ignore all other errors and exceptions
                // since this code is just a test to see if the message is present on the
                // system
            }
        }
        
        /*
        * Make a class field accessible
        */
        //@SuppressWarnings("unchecked")
        private static void  MakeAccessible(System.Reflection.FieldInfo field)
        {
            if (System.Security.SecurityManager.SecurityEnabled)
            {
                //field.setAccessible(true);   // {{Aroush-2.9}} java.lang.reflect.AccessibleObject.setAccessible
            }
            else
            {
                //AccessController.doPrivileged(new AnonymousClassPrivilegedAction(field));     // {{Aroush-2.9}} java.security.AccessController.doPrivileged
            }
        }
    }
}