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 BasicProfile extends CommonMultiMap<StringProfile.Sectionimplements Profile
 {
     private static final String SECTION_SYSTEM_PROPERTIES = "@prop";
     private static final String SECTION_ENVIRONMENT = "@env";
     private static final Pattern EXPRESSION = Pattern.compile(
             "(?<!\\\\)\\$\\{(([^\\[\\}]+)(\\[([0-9]+)\\])?/)?([^\\[^/\\}]+)(\\[(([0-9]+))\\])?\\}");
     private static final int G_SECTION = 2;
     private static final int G_SECTION_IDX = 4;
     private static final int G_OPTION = 5;
     private static final int G_OPTION_IDX = 7;
     private static final long serialVersionUID = -1817521505004015256L;
     private String _comment;
     private final boolean _propertyFirstUpper;
     private final boolean _treeMode;
 
     public BasicProfile()
     {
         this(falsefalse);
     }
 
     public BasicProfile(boolean treeModeboolean propertyFirstUpper)
     {
          = treeMode;
          = propertyFirstUpper;
     }
 
     @Override public String getComment()
     {
         return ;
     }
 
     @Override public void setComment(String value)
     {
          = value;
     }
 
     @Override public Section add(String name)
     {
         if (isTreeMode())
         {
             int idx = name.lastIndexOf(getPathSeparator());
 
             if (idx > 0)
             {
                 String parent = name.substring(0, idx);
 
                 if (!containsKey(parent))
                 {
                     add(parent);
                 }
             }
         }
 
         Section section = newSection(name);
 
         add(namesection);
 
         return section;
     }
 
     @Override public void add(String sectionString optionObject value)
     {
         getOrAdd(section).add(optionvalue);
     }
 
     @Override public <T> T as(Class<T> clazz)
     {
         return as(clazznull);
     }
 
     @Override public <T> T as(Class<T> clazzString prefix)
     {
        return clazz.cast(Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[] { clazz },
                    new BeanInvocationHandler(prefix)));
    }
    @Override public String fetch(Object sectionNameObject optionName)
    {
        Section sec = get(sectionName);
        return (sec == null) ? null : sec.fetch(optionName);
    }
    @Override public <T> T fetch(Object sectionNameObject optionNameClass<T> clazz)
    {
        Section sec = get(sectionName);
        return (sec == null) ? BeanTool.getInstance().zero(clazz) : sec.fetch(optionNameclazz);
    }
    @Override public String get(Object sectionNameObject optionName)
    {
        Section sec = get(sectionName);
        return (sec == null) ? null : sec.get(optionName);
    }
    @Override public <T> T get(Object sectionNameObject optionNameClass<T> clazz)
    {
        Section sec = get(sectionName);
        return (sec == null) ? BeanTool.getInstance().zero(clazz) : sec.get(optionNameclazz);
    }
    @Override public String put(String sectionNameString optionNameObject value)
    {
        return getOrAdd(sectionName).put(optionNamevalue);
    }
    @Override public Section remove(Section section)
    {
        return remove((Objectsection.getName());
    }
    @Override public String remove(Object sectionNameObject optionName)
    {
        Section sec = get(sectionName);
        return (sec == null) ? null : sec.remove(optionName);
    }
    boolean isTreeMode()
    {
        return ;
    }
    char getPathSeparator()
    {
        return ;
    }
    boolean isPropertyFirstUpper()
    {
        return ;
    }
    Section newSection(String name)
    {
        return new BasicProfileSection(thisname);
    }
    void resolve(StringBuilder bufferSection owner)
    {
        Matcher m = .matcher(buffer);
        while (m.find())
        {
            String sectionName = m.group();
            String optionName = m.group();
            int optionIndex = parseOptionIndex(m);
            Section section = parseSection(mowner);
            String value = null;
            if (.equals(sectionName))
            {
                value = Config.getEnvironment(optionName);
            }
            else if (.equals(sectionName))
            {
                value = Config.getSystemProperty(optionName);
            }
            else if (section != null)
            {
                value = (optionIndex == -1) ? section.fetch(optionName) : section.fetch(optionNameoptionIndex);
            }
            if (value != null)
            {
                buffer.replace(m.start(), m.end(), value);
                m.reset(buffer);
            }
        }
    }
    void store(IniHandler formatter)
    {
        formatter.startIni();
        store(formattergetComment());
        for (Ini.Section s : values())
        {
            store(formatters);
        }
        formatter.endIni();
    }
    void store(IniHandler formatterSection s)
    {
        store(formattergetComment(s.getName()));
        formatter.startSection(s.getName());
        for (String name : s.keySet())
        {
            store(formattersname);
        }
        formatter.endSection();
    }
    void store(IniHandler formatterString comment)
    {
        formatter.handleComment(comment);
    }
    void store(IniHandler formatterSection sectionString option)
    {
        store(formattersection.getComment(option));
        int n = section.length(option);
        for (int i = 0; i < ni++)
        {
            store(formattersectionoptioni);
        }
    }
    void store(IniHandler formatterSection sectionString optionint index)
    {
        formatter.handleOption(optionsection.get(optionindex));
    }
    private Section getOrAdd(String sectionName)
    {
        Section section = get(sectionName);
        return ((section == null)) ? add(sectionName) : section;
    }
    private int parseOptionIndex(Matcher m)
    {
        return (m.group() == null) ? -1 : Integer.parseInt(m.group());
    }
    private Section parseSection(Matcher mSection owner)
    {
        String sectionName = m.group();
        int sectionIndex = parseSectionIndex(m);
        return (sectionName == null) ? owner : ((sectionIndex == -1) ? get(sectionName) : get(sectionNamesectionIndex));
    }
    private int parseSectionIndex(Matcher m)
    {
        return (m.group() == null) ? -1 : Integer.parseInt(m.group());
    }
    private final class BeanInvocationHandler extends AbstractBeanInvocationHandler
    {
        private final String _prefix;
        private BeanInvocationHandler(String prefix)
        {
             = prefix;
        }
        @Override protected Object getPropertySpi(String propertyClass<?> clazz)
        {
            String key = transform(property);
            Object o = null;
            if (containsKey(key))
            {
                if (clazz.isArray())
                {
                    o = Array.newInstance(clazz.getComponentType(), length(key));
                    for (int i = 0; i < length(key); i++)
                    {
                        Array.set(oiget(keyi).as(clazz.getComponentType()));
                    }
                }
                else
                {
                    o = get(key).as(clazz);
                }
            }
            return o;
        }
        @Override protected void setPropertySpi(String propertyObject valueClass<?> clazz)
        {
            String key = transform(property);
            remove(key);
            if (value != null)
            {
                if (clazz.isArray())
                {
                    for (int i = 0; i < Array.getLength(value); i++)
                    {
                        Section sec = add(key);
                        sec.from(Array.get(valuei));
                    }
                }
                else
                {
                    Section sec = add(key);
                    sec.from(value);
                }
            }
        }
        @Override protected boolean hasPropertySpi(String property)
        {
            return containsKey(transform(property));
        }
        String transform(String property)
        {
            String ret = ( == null) ? property : ( + property);
            if (isPropertyFirstUpper())
            {
                StringBuilder buff = new StringBuilder();
                buff.append(Character.toUpperCase(property.charAt(0)));
                buff.append(property.substring(1));
                ret = buff.toString();
            }
            return ret;
        }
    }
New to GrepCode? Check out our FAQ X