Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2005,2009 Ivan SZKIBA
   *
   * Licensed 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.
  */
 package org.ini4j;
 
 
 
 
 public class BasicOptionMap extends CommonMultiMap<StringStringimplements OptionMap
 {
     private static final char SUBST_CHAR = '$';
     private static final String SYSTEM_PROPERTY_PREFIX = "@prop/";
     private static final String ENVIRONMENT_PREFIX = "@env/";
     private static final int SYSTEM_PROPERTY_PREFIX_LEN = .length();
     private static final int ENVIRONMENT_PREFIX_LEN = .length();
     private static final Pattern EXPRESSION = Pattern.compile("(?<!\\\\)\\$\\{(([^\\[\\}]+)(\\[([0-9]+)\\])?)\\}");
     private static final int G_OPTION = 2;
     private static final int G_INDEX = 4;
     private static final long serialVersionUID = 325469712293707584L;
     private BeanAccess _defaultBeanAccess;
     private final boolean _propertyFirstUpper;
 
     public BasicOptionMap()
     {
         this(false);
     }
 
     public BasicOptionMap(boolean propertyFirstUpper)
     {
          = propertyFirstUpper;
     }
 
     @Override
     public <T> T getAll(Object keyClass<T> clazz)
     {
         requireArray(clazz);
         T value;
 
         value = (T) Array.newInstance(clazz.getComponentType(), length(key));
         for (int i = 0; i < length(key); i++)
         {
             Array.set(valuei, BeanTool.getInstance().parse(get(keyi), clazz.getComponentType()));
         }
 
         return value;
     }
 
     @Override public void add(String keyObject value)
     {
         super.add(key, ((value == null) || (value instanceof String)) ? (Stringvalue : String.valueOf(value));
     }
 
     @Override public void add(String keyObject valueint index)
     {
         super.add(key, ((value == null) || (value instanceof String)) ? (Stringvalue : String.valueOf(value), index);
     }
 
     @Override public <T> T as(Class<T> clazz)
     {
         return BeanTool.getInstance().proxy(clazzgetDefaultBeanAccess());
     }
 
     @Override public <T> T as(Class<T> clazzString keyPrefix)
     {
         return BeanTool.getInstance().proxy(clazznewBeanAccess(keyPrefix));
     }
 
     @Override public String fetch(Object key)
     {
         int len = length(key);
 
         return (len == 0) ? null : fetch(keylen - 1);
     }
 
     @Override public String fetch(Object keyString defaultValue)
     {
         String str = get(key);
 
         return (str == null) ? defaultValue : str;
     }
    @Override public String fetch(Object keyint index)
    {
        String value = get(keyindex);
        if ((value != null) && (value.indexOf() >= 0))
        {
            StringBuilder buffer = new StringBuilder(value);
            resolve(buffer);
            value = buffer.toString();
        }
        return value;
    }
    @Override public <T> T fetch(Object keyClass<T> clazz)
    {
        return BeanTool.getInstance().parse(fetch(key), clazz);
    }
    @Override public <T> T fetch(Object keyClass<T> clazz, T defaultValue)
    {
        String str = fetch(key);
        return (str == null) ? defaultValue : BeanTool.getInstance().parse(strclazz);
    }
    @Override public <T> T fetch(Object keyint indexClass<T> clazz)
    {
        return BeanTool.getInstance().parse(fetch(keyindex), clazz);
    }
    @Override
    public <T> T fetchAll(Object keyClass<T> clazz)
    {
        requireArray(clazz);
        T value;
        value = (T) Array.newInstance(clazz.getComponentType(), length(key));
        for (int i = 0; i < length(key); i++)
        {
            Array.set(valuei, BeanTool.getInstance().parse(fetch(keyi), clazz.getComponentType()));
        }
        return value;
    }
    @Override public void from(Object bean)
    {
        BeanTool.getInstance().inject(getDefaultBeanAccess(), bean);
    }
    @Override public void from(Object beanString keyPrefix)
    {
        BeanTool.getInstance().inject(newBeanAccess(keyPrefix), bean);
    }
    @Override public <T> T get(Object keyClass<T> clazz)
    {
        return BeanTool.getInstance().parse(get(key), clazz);
    }
    @Override public String get(Object keyString defaultValue)
    {
        String str = get(key);
        return (str == null) ? defaultValue : str;
    }
    @Override public <T> T get(Object keyClass<T> clazz, T defaultValue)
    {
        String str = get(key);
        return (str == null) ? defaultValue : BeanTool.getInstance().parse(strclazz);
    }
    @Override public <T> T get(Object keyint indexClass<T> clazz)
    {
        return BeanTool.getInstance().parse(get(keyindex), clazz);
    }
    @Override public String put(String keyObject value)
    {
        return super.put(key, ((value == null) || (value instanceof String)) ? (Stringvalue : String.valueOf(value));
    }
    @Override public String put(String keyObject valueint index)
    {
        return super.put(key, ((value == null) || (value instanceof String)) ? (Stringvalue : String.valueOf(value), index);
    }
    @Override public void putAll(String keyObject value)
    {
        if (value != null)
        {
            requireArray(value.getClass());
        }
        remove(key);
        if (value != null)
        {
            int n = Array.getLength(value);
            for (int i = 0; i < ni++)
            {
                add(key, Array.get(valuei));
            }
        }
    }
    @Override public void to(Object bean)
    {
        BeanTool.getInstance().inject(beangetDefaultBeanAccess());
    }
    @Override public void to(Object beanString keyPrefix)
    {
        BeanTool.getInstance().inject(beannewBeanAccess(keyPrefix));
    }
    synchronized BeanAccess getDefaultBeanAccess()
    {
        if ( == null)
        {
             = newBeanAccess();
        }
        return ;
    }
    boolean isPropertyFirstUpper()
    {
        return ;
    }
    {
        return new Access();
    }
    BeanAccess newBeanAccess(String propertyNamePrefix)
    {
        return new Access(propertyNamePrefix);
    }
    void resolve(StringBuilder buffer)
    {
        Matcher m = .matcher(buffer);
        while (m.find())
        {
            String name = m.group();
            int index = (m.group() == null) ? -1 : Integer.parseInt(m.group());
            String value;
            if (name.startsWith())
            {
                value = Config.getEnvironment(name.substring());
            }
            else if (name.startsWith())
            {
                value = Config.getSystemProperty(name.substring());
            }
            else
            {
                value = (index == -1) ? fetch(name) : fetch(nameindex);
            }
            if (value != null)
            {
                buffer.replace(m.start(), m.end(), value);
                m.reset(buffer);
            }
        }
    }
    private void requireArray(Class clazz)
    {
        if (!clazz.isArray())
        {
            throw new IllegalArgumentException("Array required");
        }
    }
    class Access implements BeanAccess
    {
        private final String _prefix;
        Access()
        {
            this(null);
        }
        Access(String prefix)
        {
             = prefix;
        }
        @Override public void propAdd(String propertyNameString value)
        {
            add(transform(propertyName), value);
        }
        @Override public String propDel(String propertyName)
        {
            return remove(transform(propertyName));
        }
        @Override public String propGet(String propertyName)
        {
            return fetch(transform(propertyName));
        }
        @Override public String propGet(String propertyNameint index)
        {
            return fetch(transform(propertyName), index);
        }
        @Override public int propLength(String propertyName)
        {
            return length(transform(propertyName));
        }
        @Override public String propSet(String propertyNameString value)
        {
            return put(transform(propertyName), value);
        }
        @Override public String propSet(String propertyNameString valueint index)
        {
            return put(transform(propertyName), valueindex);
        }
        private String transform(String orig)
        {
            String ret = orig;
            if ((( != null) || isPropertyFirstUpper()) && (orig != null))
            {
                StringBuilder buff = new StringBuilder();
                if ( != null)
                {
                    buff.append();
                }
                if (isPropertyFirstUpper())
                {
                    buff.append(Character.toUpperCase(orig.charAt(0)));
                    buff.append(orig.substring(1));
                }
                else
                {
                    buff.append(orig);
                }
                ret = buff.toString();
            }
            return ret;
        }
    }
New to GrepCode? Check out our FAQ X