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;
 
 
 import java.io.File;
 import java.io.Reader;
 import java.io.Writer;
 
 import java.net.URL;
 
 public class Reg extends BasicRegistry implements RegistryPersistableConfigurable
 {
     private static final long serialVersionUID = -1485602876922985912L;
     protected static final String DEFAULT_SUFFIX = ".reg";
     protected static final String TMP_PREFIX = "reg-";
     private static final int STDERR_BUFF_SIZE = 8192;
     private static final String PROP_OS_NAME = "os.name";
     private static final boolean WINDOWS = Config.getSystemProperty("Unknown").startsWith("Windows");
     private static final char CR = '\r';
     private static final char LF = '\n';
     private Config _config;
     private File _file;
 
     public Reg()
     {
         Config cfg = Config.getGlobal().clone();
 
         cfg.setEscape(false);
         cfg.setGlobalSection(false);
         cfg.setEmptyOption(true);
         cfg.setMultiOption(true);
         cfg.setStrictOperator(true);
         cfg.setEmptySection(true);
         cfg.setPathSeparator();
         cfg.setFileEncoding();
         cfg.setLineSeparator();
          = cfg;
     }
 
     public Reg(String registryKeythrows IOException
     {
         this();
         read(registryKey);
     }
 
     public Reg(File inputthrows IOExceptionInvalidFileFormatException
     {
         this();
          = input;
         load();
     }
 
     public Reg(URL inputthrows IOExceptionInvalidFileFormatException
     {
         this();
         load(input);
     }
 
     public Reg(InputStream inputthrows IOExceptionInvalidFileFormatException
     {
         this();
         load(input);
     }
 
     public Reg(Reader inputthrows IOExceptionInvalidFileFormatException
     {
         this();
         load(input);
     }
 
     public static boolean isWindows()
     {
         return ;
    }
    @Override public Config getConfig()
    {
        return ;
    }
    public void setConfig(Config value)
    {
         = value;
    }
    @Override public File getFile()
    {
        return ;
    }
    @Override public void setFile(File value)
    {
         = value;
    }
    @Override public void load() throws IOExceptionInvalidFileFormatException
    {
        if ( == null)
        {
            throw new FileNotFoundException();
        }
        load();
    }
    @Override public void load(InputStream inputthrows IOExceptionInvalidFileFormatException
    {
        load(new InputStreamReader(inputgetConfig().getFileEncoding()));
    }
    @Override public void load(URL inputthrows IOExceptionInvalidFileFormatException
    {
        load(new InputStreamReader(input.openStream(), getConfig().getFileEncoding()));
    }
    @Override public void load(Reader inputthrows IOExceptionInvalidFileFormatException
    {
        int newline = 2;
        StringBuilder buff = new StringBuilder();
        for (int c = input.read(); c != -1; c = input.read())
        {
            if (c == )
            {
                newline--;
                if (newline == 0)
                {
                    break;
                }
            }
            else if ((c != ) && (newline != 1))
            {
                buff.append((charc);
            }
        }
        if (buff.length() == 0)
        {
            throw new InvalidFileFormatException("Missing version header");
        }
        if (!buff.toString().equals(getVersion()))
        {
            throw new InvalidFileFormatException("Unsupported version: " + buff.toString());
        }
        IniParser.newInstance(getConfig()).parse(inputnewBuilder());
    }
    @Override public void load(File inputthrows IOExceptionInvalidFileFormatException
    {
        load(input.toURI().toURL());
    }
    public void read(String registryKeythrows IOException
    {
        File tmp = createTempFile();
        try
        {
            regExport(registryKeytmp);
            load(tmp);
        }
        finally
        {
            tmp.delete();
        }
    }
    @Override public void store() throws IOException
    {
        if ( == null)
        {
            throw new FileNotFoundException();
        }
        store();
    }
    @Override public void store(OutputStream outputthrows IOException
    {
        store(new OutputStreamWriter(outputgetConfig().getFileEncoding()));
    }
    @Override public void store(Writer outputthrows IOException
    {
        output.write(getVersion());
        output.write(getConfig().getLineSeparator());
        output.write(getConfig().getLineSeparator());
        store(IniFormatter.newInstance(outputgetConfig()));
    }
    @Override public void store(File outputthrows IOException
    {
        OutputStream stream = new FileOutputStream(output);
        store(stream);
        stream.close();
    }
    public void write() throws IOException
    {
        File tmp = createTempFile();
        try
        {
            store(tmp);
            regImport(tmp);
        }
        finally
        {
            tmp.delete();
        }
    }
    protected IniHandler newBuilder()
    {
        return RegBuilder.newInstance(this);
    }
    @Override boolean isTreeMode()
    {
        return getConfig().isTree();
    }
    @Override char getPathSeparator()
    {
        return getConfig().getPathSeparator();
    }
    @Override boolean isPropertyFirstUpper()
    {
        return getConfig().isPropertyFirstUpper();
    }
    void exec(String[] argsthrows IOException
    {
        Process proc = Runtime.getRuntime().exec(args);
        try
        {
            int status = proc.waitFor();
            if (status != 0)
            {
                Reader in = new InputStreamReader(proc.getErrorStream());
                char[] buff = new char[];
                int n = in.read(buff);
                in.close();
                throw new IOException(new String(buff, 0, n).trim());
            }
        }
        catch (InterruptedException x)
        {
            throw (IOException) (new InterruptedIOException().initCause(x));
        }
    }
    private File createTempFile() throws IOException
    {
        File ret = File.createTempFile();
        ret.deleteOnExit();
        return ret;
    }
    private void regExport(String registryKeyFile filethrows IOException
    {
        requireWindows();
        exec(new String[] { "cmd""/c""reg""export"registryKeyfile.getAbsolutePath() });
    }
    private void regImport(File filethrows IOException
    {
        requireWindows();
        exec(new String[] { "cmd""/c""reg""import"file.getAbsolutePath() });
    }
    private void requireWindows()
    {
        if (!)
        {
            throw new UnsupportedOperationException("Unsupported operating system or runtime environment");
        }
    }
New to GrepCode? Check out our FAQ X