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.spi;
 
 
 
 
 
 
 public class RegEscapeTool extends EscapeTool
 {
     private static final RegEscapeTool INSTANCE = ServiceFinder.findService(RegEscapeTool.class);
     private static final Charset HEX_CHARSET = Charset.forName("UTF-16LE");
     private static final int LOWER_DIGIT = 0x0f;
     private static final int UPPER_DIGIT = 0xf0;
     private static final int DIGIT_SIZE = 4;
 
     public static final RegEscapeTool getInstance()
     {
         return ;
     }
 
     public TypeValuesPair decode(String raw)
     {
         Type type = type(raw);
         String value = (type == .) ? unquote(raw) : raw.substring(type.toString().length() + 1);
         String[] values;
 
         switch (type)
         {
 
             case :
             case :
                 value = bytes2string(binary(value));
                 break;
 
             case :
                 value = String.valueOf(Long.parseLong(value));
                 break;
 
             case :
                 break;
 
             default:
                 break;
         }
 
         if (type == .)
         {
             values = splitMulti(value);
         }
         else
         {
             values = new String[] { value };
         }
 
         return new TypeValuesPair(typevalues);
     }
 
     public String encode(TypeValuesPair data)
     {
         String ret = null;
 
         if (data.getType() == .)
         {
             ret = quote(data.getValues()[0]);
         }
         else if (data.getValues()[0] != null)
         {
             ret = encode(data.getType(), data.getValues());
         }
 
         return ret;
     }
 
     byte[] binary(String value)
     {
         byte[] bytes = new byte[value.length()];
         int idx = 0;
         int shift = ;
 
        for (int i = 0; i < value.length(); i++)
        {
            char c = value.charAt(i);
            if (Character.isWhitespace(c))
            {
                continue;
            }
            if (c == ',')
            {
                idx++;
                shift = ;
            }
            else
            {
                int digit = Character.digit(c);
                if (digit >= 0)
                {
                    bytes[idx] |= digit << shift;
                    shift = 0;
                }
            }
        }
        return Arrays.copyOfRange(bytes, 0, idx + 1);
    }
    String encode(Type typeString[] values)
    {
        StringBuilder buff = new StringBuilder();
        buff.append(type.toString());
        buff.append(.);
        switch (type)
        {
            case :
                buff.append(hexadecimal(values[0]));
                break;
            case :
                buff.append(String.format("%08x", Long.parseLong(values[0])));
                break;
            case :
                int n = values.length;
                for (int i = 0; i < ni++)
                {
                    buff.append(hexadecimal(values[i]));
                    buff.append(',');
                }
                buff.append("00,00");
                break;
            default:
                buff.append(values[0]);
                break;
        }
        return buff.toString();
    }
    String hexadecimal(String value)
    {
        StringBuilder buff = new StringBuilder();
        if ((value != null) && (value.length() != 0))
        {
            byte[] bytes = string2bytes(value);
            for (int i = 0; i < bytes.lengthi++)
            {
                buff.append(Character.forDigit((bytes[i] & ) >> ));
                buff.append(Character.forDigit(bytes[i] & ));
                buff.append(',');
            }
            buff.append("00,00");
        }
        return buff.toString();
    }
    Registry.Type type(String raw)
    {
        Registry.Type type;
        if (raw.charAt(0) == )
        {
            type = ..;
        }
        else
        {
            int idx = raw.indexOf(.);
            type = (idx < 0) ? .. : Registry.Type.fromString(raw.substring(0, idx));
        }
        return type;
    }
    // XXX Java 1.4 compatibility hack
    private String bytes2string(byte[] bytes)
    {
        String str;
        try
        {
            str = new String(bytes, 0, bytes.length - 2, );
        }
        catch (NoSuchMethodError x)
        {
            try
            {
                str = new String(bytes, 0, bytes.length.name());
            }
            catch (UnsupportedEncodingException ex)
            {
                throw new IllegalStateException(ex);
            }
        }
        return str;
    }
    private String[] splitMulti(String value)
    {
        int len = value.length();
        int start;
        int end;
        int n = 0;
        start = 0;
        for (end = value.indexOf(0, start); end >= 0; end = value.indexOf(0, start))
        {
            n++;
            start = end + 1;
            if (start >= len)
            {
                break;
            }
        }
        String[] values = new String[n];
        start = 0;
        for (int i = 0; i < ni++)
        {
            end = value.indexOf(0, start);
            values[i] = value.substring(startend);
            start = end + 1;
        }
        return values;
    }
    // XXX Java 1.4 compatibility hack
    private byte[] string2bytes(String value)
    {
        byte[] bytes;
        try
        {
            bytes = value.getBytes();
        }
        catch (NoSuchMethodError x)
        {
            try
            {
                bytes = value.getBytes(.name());
            }
            catch (UnsupportedEncodingException ex)
            {
                throw new IllegalStateException(ex);
            }
        }
        return bytes;
    }
New to GrepCode? Check out our FAQ X