Properties.cs

Go to the documentation of this file.

// 
//  Copyright 2010-2015 Deveel
// 
//    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.
//

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace Deveel.Data.Util {
    class Properties : Dictionary<string, string> {

        protected Properties defaults;

        public Properties() {
        }

        public Properties(Properties defaults) {
            this.defaults = defaults;
        }

        public Object SetProperty(String key, String value) {
            return this[key] = value;
        }

        public void Load(Stream inStream) {
            // The spec says that the file must be encoded using ISO-8859-1.
            StreamReader reader = new StreamReader(inStream, Encoding.GetEncoding("ISO-8859-1"));
            String line;

            while ((line = reader.ReadLine()) != null) {
                char c = '\0';
                int pos = 0;
                // Leading whitespaces must be deleted first.
                while (pos < line.Length
                       && Char.IsWhiteSpace(c = line[pos]))
                    pos++;

                // If empty line or begins with a comment character, skip this line.
                if ((line.Length - pos) == 0
                || line[pos] == '#' || line[pos] == '!')
                    continue;

                // The characters up to the next Whitespace, ':', or '='
                // describe the key.  But look for escape sequences.
                // Try to short-circuit when there is no escape char.
                int start = pos;
                bool needsEscape = line.IndexOf('\\', pos) != -1;
                StringBuilder key = needsEscape ? new StringBuilder() : null;
                while (pos < line.Length
                       && !Char.IsWhiteSpace(c = line[pos++])
                       && c != '=' && c != ':') {
                    if (needsEscape && c == '\\') {
                        if (pos == line.Length) {
                            // The line continues on the next line.  If there
                            // is no next line, just treat it as a key with an
                            // empty value.
                            line = reader.ReadLine();
                            if (line == null)
                                line = "";
                            pos = 0;
                            while (pos < line.Length
                                   && Char.IsWhiteSpace(c = line[pos]))
                                pos++;
                        } else {
                            c = line[pos++];
                            switch (c) {
                                case 'n':
                                    key.Append('\n');
                                    break;
                                case 't':
                                    key.Append('\t');
                                    break;
                                case 'r':
                                    key.Append('\r');
                                    break;
                                case 'u':
                                    if (pos + 4 <= line.Length) {
                                        char uni = (char)Convert.ToInt32(line.Substring(pos, 4), 16);
                                        key.Append(uni);
                                        pos += 4;
                                    }        // else throw exception?
                                    break;
                                default:
                                    key.Append(c);
                                    break;
                            }
                        }
                    } else if (needsEscape)
                        key.Append(c);
                }

                bool isDelim = (c == ':' || c == '=');

                String keyString;
                if (needsEscape)
                    keyString = key.ToString();
                else if (isDelim || Char.IsWhiteSpace(c))
                    keyString = line.Substring(start, (pos - 1) - start);
                else
                    keyString = line.Substring(start, pos - start);

                while (pos < line.Length
                       && Char.IsWhiteSpace(c = line[pos]))
                    pos++;

                if (!isDelim && (c == ':' || c == '=')) {
                    pos++;
                    while (pos < line.Length
                           && Char.IsWhiteSpace(c = line[pos]))
                        pos++;
                }

                // Short-circuit if no escape chars found.
                if (!needsEscape) {
                    this[keyString] = line.Substring(pos);
                    continue;
                }

                // Escape char found so iterate through the rest of the line.
                StringBuilder element = new StringBuilder(line.Length - pos);
                while (pos < line.Length) {
                    c = line[pos++];
                    if (c == '\\') {
                        if (pos == line.Length) {
                            // The line continues on the next line.
                            line = reader.ReadLine();

                            // We might have seen a backslash at the end of
                            // the file.  The JDK ignores the backslash in
                            // this case, so we follow for compatibility.
                            if (line == null)
                                break;

                            pos = 0;
                            while (pos < line.Length
                                   && Char.IsWhiteSpace(c = line[pos]))
                                pos++;
                            element.EnsureCapacity(line.Length - pos + element.Length);
                        } else {
                            c = line[pos++];
                            switch (c) {
                                case 'n':
                                    element.Append('\n');
                                    break;
                                case 't':
                                    element.Append('\t');
                                    break;
                                case 'r':
                                    element.Append('\r');
                                    break;
                                case 'u':
                                    if (pos + 4 <= line.Length) {
                                        char uni = (char)Convert.ToInt32(line.Substring(pos, 4), 16);
                                        element.Append(uni);
                                        pos += 4;
                                    }        // else throw exception?
                                    break;
                                default:
                                    element.Append(c);
                                    break;
                            }
                        }
                    } else
                        element.Append(c);
                }
                this[keyString] = element.ToString();
            }
        }

        [Obsolete("Use Store(Stream, string) method instead.")]
        public void Save(Stream output, String header) {
            try {
                Store(output, header);
            } catch (IOException) {
            }
        }

        public void Store(Stream output, String header) {
            // The spec says that the file must be encoded using ISO-8859-1.
            StreamWriter writer = new StreamWriter(output, Encoding.GetEncoding("ISO-8859-1"));
            if (header != null)
                writer.WriteLine("#" + header);
            writer.WriteLine("#" + DateTime.Now);

            StringBuilder s = new StringBuilder(); // Reuse the same buffer.
            foreach (var entry in this) {
                FormatForOutput((String)entry.Key, s, true);
                s.Append('=');
                FormatForOutput((String)entry.Value, s, false);
                writer.WriteLine(s);
            }

            writer.Flush();
        }

        public String GetProperty(String key) {
            Properties prop = this;
            // Eliminate tail recursion.
            do {
                String value = (String)prop[key];
                if (value != null)
                    return value;
                prop = prop.defaults;
            }
            while (prop != null);
            return null;
        }

        public String GetProperty(String key, String defaultValue) {
            String prop = GetProperty(key);
            if (prop == null)
                prop = defaultValue;
            return prop;
        }

        public ICollection PropertyNames {
            get {
                // We make a new Set that holds all the keys, then return an enumeration
                // for that. This prevents modifications from ruining the enumeration,
                // as well as ignoring duplicates.
                Properties prop = this;
                var s = new List<string>();
                // Eliminate tail recursion.
                do {
                    s.AddRange(prop.Keys);
                    prop = prop.defaults;
                } while (prop != null);
                return s;
            }
        }

        public void List(Stream output) {
            StreamWriter writer = new StreamWriter(output);
            List(writer);
        }

        public void List(StreamWriter output) {
            output.WriteLine("-- listing properties --");

            foreach (var entry in this) {
                output.Write((String)entry.Key + "=");

                String s = (String)entry.Value;
                if (s != null && s.Length > 40)
                    output.WriteLine(s.Substring(0, 37) + "...");
                else
                    output.WriteLine(s);
            }
            output.Flush();
        }

        private static void FormatForOutput(String str, StringBuilder buffer, bool key) {
            if (key) {
                buffer.Length = 0;
                buffer.EnsureCapacity(str.Length);
            } else
                buffer.EnsureCapacity(buffer.Length + str.Length);
            bool head = true;
            int size = str.Length;
            for (int i = 0; i < size; i++) {
                char c = str[i];
                switch (c) {
                    case '\n':
                        buffer.Append("\\n");
                        break;
                    case '\r':
                        buffer.Append("\\r");
                        break;
                    case '\t':
                        buffer.Append("\\t");
                        break;
                    case ' ':
                        buffer.Append(head ? "\\ " : " ");
                        break;
                    case '\\':
                    case '!':
                    case '#':
                    case '=':
                    case ':':
                        buffer.Append('\\').Append(c);
                        break;
                    default:
                        if (c < ' ' || c > '~') {
                            String hex = ((int)c).ToString("{0:x4}");
                            buffer.Append("\\u0000".Substring(0, 6 - hex.Length));
                            buffer.Append(hex);
                        } else
                            buffer.Append(c);
                        break;
                }
                if (c != ' ')
                    head = key;
            }
        }

        /*
        TODO:
        public void storeToXML(Stream os, String comment) {
            storeToXML(os, comment, "UTF-8");
        }

        public void storeToXML(Stream os, String comment, String encoding) {
            if (os == null)
                throw new ArgumentNullException("os");
            if (encoding == null)
                throw new ArgumentNullException("encoding");
            try {
                DOMImplementationRegistry registry =
                  DOMImplementationRegistry.newInstance();
                DOMImplementation domImpl = registry.getDOMImplementation("LS 3.0");
                DocumentType doctype =
                  domImpl.createDocumentType("properties", null,
                                 "http://java.sun.com/dtd/properties.dtd");
                Document doc = domImpl.createDocument(null, "properties", doctype);
                Element root = doc.getDocumentElement();
                if (comment != null) {
                    Element commentElement = doc.createElement("comment");
                    commentElement.appendChild(doc.createTextNode(comment));
                    root.appendChild(commentElement);
                }
                Iterator iterator = entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry entry = (Map.Entry)iterator.next();
                    Element entryElement = doc.createElement("entry");
                    entryElement.setAttribute("key", (String)entry.getKey());
                    entryElement.appendChild(doc.createTextNode((String)
                                        entry.getValue()));
                    root.appendChild(entryElement);
                }
                DOMImplementationLS loadAndSave = (DOMImplementationLS)domImpl;
                LSSerializer serializer = loadAndSave.createLSSerializer();
                LSOutput output = loadAndSave.createLSOutput();
                output.setByteStream(os);
                output.setEncoding(encoding);
                serializer.write(doc, output);
            } catch (ClassNotFoundException e) {
                throw (IOException)
                  new IOException("The XML classes could not be found.").initCause(e);
            } catch (InstantiationException e) {
                throw (IOException)
                  new IOException("The XML classes could not be instantiated.")
                  .initCause(e);
            } catch (IllegalAccessException e) {
                throw (IOException)
                  new IOException("The XML classes could not be accessed.")
                  .initCause(e);
            }
        }

        public void loadFromXML(InputStream input) {
            if (input == null)
                throw new NullPointerException("Null input stream supplied.");
            try {
                XMLInputFactory factory = XMLInputFactory.newInstance();
                // Don't resolve external entity references
                factory.setProperty("javax.xml.stream.isSupportingExternalEntities",
                                    Boolean.FALSE);
                XMLStreamReader reader = factory.createXMLStreamReader(input);
                String name, key = null;
                StringBuffer buf = null;
                while (reader.hasNext()) {
                    switch (reader.next()) {
                        case XMLStreamConstants.START_ELEMENT:
                            name = reader.getLocalName();
                            if (buf == null && "entry".equals(name)) {
                                key = reader.getAttributeValue(null, "key");
                                if (key == null) {
                                    String msg = "missing 'key' attribute";
                                    throw new InvalidPropertiesFormatException(msg);
                                }
                                buf = new StringBuffer();
                            } else if (!"properties".equals(name) && !"comment".equals(name)) {
                                String msg = "unexpected element name '" + name + "'";
                                throw new InvalidPropertiesFormatException(msg);
                            }
                            break;
                        case XMLStreamConstants.END_ELEMENT:
                            name = reader.getLocalName();
                            if (buf != null && "entry".equals(name)) {
                                put(key, buf.toString());
                                buf = null;
                            } else if (!"properties".equals(name) && !"comment".equals(name)) {
                                String msg = "unexpected element name '" + name + "'";
                                throw new InvalidPropertiesFormatException(msg);
                            }
                            break;
                        case XMLStreamConstants.CHARACTERS:
                        case XMLStreamConstants.SPACE:
                        case XMLStreamConstants.CDATA:
                            if (buf != null)
                                buf.append(reader.getText());
                            break;
                    }
                }
                reader.close();
            } catch (XMLStreamException e) {
                throw (InvalidPropertiesFormatException)
                  new InvalidPropertiesFormatException("Error in parsing XML.").
                  initCause(e);
            }
        }
        */
    } // class Properties
}