/**

  * Copyright (c) 2008-2011, http://www.snakeyaml.org

  *

  * 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.yaml.snakeyaml;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.Reader;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import java.util.regex.Pattern;

 import org.yaml.snakeyaml.DumperOptions.FlowStyle;

 import org.yaml.snakeyaml.composer.Composer;

 import org.yaml.snakeyaml.constructor.BaseConstructor;

 import org.yaml.snakeyaml.constructor.Constructor;

 import org.yaml.snakeyaml.emitter.Emitable;

 import org.yaml.snakeyaml.emitter.Emitter;

 import org.yaml.snakeyaml.error.YAMLException;

 import org.yaml.snakeyaml.events.Event;

 import org.yaml.snakeyaml.introspector.BeanAccess;

 import org.yaml.snakeyaml.nodes.Node;

 import org.yaml.snakeyaml.nodes.Tag;

 import org.yaml.snakeyaml.parser.Parser;

 import org.yaml.snakeyaml.parser.ParserImpl;

 import org.yaml.snakeyaml.reader.StreamReader;

 import org.yaml.snakeyaml.reader.UnicodeReader;

 import org.yaml.snakeyaml.representer.Representer;

 import org.yaml.snakeyaml.resolver.Resolver;

 import org.yaml.snakeyaml.serializer.Serializer;

 /**

  * Public YAML interface. Each Thread must have its own instance.

  */

 public class Yaml {

     protected final Resolver resolver;

     private String name;

     protected BaseConstructor constructor;

     protected Representer representer;

     protected DumperOptions dumperOptions;

     protected LoaderOptions loaderOptions;

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      */

     public Yaml() {

         this(new Constructor(), new LoaderOptions(), new Representer(), new DumperOptions(),

                 new Resolver());

     }

     public Yaml(LoaderOptions loaderOptions) {

         this(new Constructor(), loaderOptions, new Representer(), new DumperOptions(),

                 new Resolver());

     }

     /**

      * Create Yaml instance.

      * 

      * @param dumperOptions

      *            DumperOptions to configure outgoing objects

      */

     public Yaml(DumperOptions dumperOptions) {

         this(new Constructor(), new Representer(), dumperOptions);

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param representer

      *            Representer to emit outgoing objects

      */

     public Yaml(Representer representer) {

         this(new Constructor(), representer);

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param constructor

      *            BaseConstructor to construct incoming documents

      */

     public Yaml(BaseConstructor constructor) {

         this(constructor, new Representer());

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param constructor

      *            BaseConstructor to construct incoming documents

      * @param representer

      *            Representer to emit outgoing objects

      */

     public Yaml(BaseConstructor constructor, Representer representer) {

         this(constructor, representer, new DumperOptions());

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param representer

      *            Representer to emit outgoing objects

      * @param dumperOptions

      *            DumperOptions to configure outgoing objects

      */

     public Yaml(Representer representer, DumperOptions dumperOptions) {

         this(new Constructor(), representer, dumperOptions, new Resolver());

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param constructor

      *            BaseConstructor to construct incoming documents

      * @param representer

      *            Representer to emit outgoing objects

      * @param dumperOptions

      *            DumperOptions to configure outgoing objects

      */

     public Yaml(BaseConstructor constructor, Representer representer, DumperOptions dumperOptions) {

         this(constructor, representer, dumperOptions, new Resolver());

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param constructor

      *            BaseConstructor to construct incoming documents

      * @param representer

      *            Representer to emit outgoing objects

      * @param dumperOptions

      *            DumperOptions to configure outgoing objects

      * @param resolver

      *            Resolver to detect implicit type

      */

     public Yaml(BaseConstructor constructor, Representer representer, DumperOptions dumperOptions,

             Resolver resolver) {

         this(constructor, new LoaderOptions(), representer, dumperOptions, resolver);

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param constructor

      *            BaseConstructor to construct incoming documents

      * @param loaderOptions

      *            LoaderOptions to control construction process

      * @param representer

      *            Representer to emit outgoing objects

      * @param dumperOptions

      *            DumperOptions to configure outgoing objects

      * @param resolver

      *            Resolver to detect implicit type

      */

     public Yaml(BaseConstructor constructor, LoaderOptions loaderOptions, Representer representer,

             DumperOptions dumperOptions, Resolver resolver) {

         if (!constructor.isExplicitPropertyUtils()) {

             constructor.setPropertyUtils(representer.getPropertyUtils());

         } else if (!representer.isExplicitPropertyUtils()) {

             representer.setPropertyUtils(constructor.getPropertyUtils());

         }

         this.constructor = constructor;

         this.loaderOptions = loaderOptions;

         representer.setDefaultFlowStyle(dumperOptions.getDefaultFlowStyle());

         representer.setDefaultScalarStyle(dumperOptions.getDefaultScalarStyle());

         representer.getPropertyUtils().setAllowReadOnlyProperties(

                 dumperOptions.isAllowReadOnlyProperties());

         this.representer = representer;

         this.dumperOptions = dumperOptions;

         this.resolver = resolver;

         this.name = "Yaml:" + System.identityHashCode(this);

     }

     /**

      * Serialize a Java object into a YAML String.

      * 

      * @param data

      *            Java object to be Serialized to YAML

      * @return YAML String

      */

     public String dump(Object data) {

         List<Object> list = new ArrayList<Object>(1);

         list.add(data);

         return dumpAll(list.iterator());

     }

     /**

      * Produce the corresponding representation tree for a given Object.

      * 

      * @see http://yaml.org/spec/1.1/#id859333

      * @param data

      *            instance to build the representation tree for

      * @return representation tree

      */

     public Node represent(Object data) {

         return representer.represent(data);

     }

     /**

      * Serialize a sequence of Java objects into a YAML String.

      * 

      * @param data

      *            Iterator with Objects

      * @return YAML String with all the objects in proper sequence

      */

     public String dumpAll(Iterator<? extends Object> data) {

         StringWriter buffer = new StringWriter();

         dumpAll(data, buffer);

         return buffer.toString();

     }

     /**

      * Serialize a Java object into a YAML stream.

      * 

      * @param data

      *            Java object to be serialized to YAML

      * @param output

      *            stream to write to

      */

     public void dump(Object data, Writer output) {

         List<Object> list = new ArrayList<Object>(1);

         list.add(data);

         dumpAll(list.iterator(), output);

     }

     /**

      * Serialize a sequence of Java objects into a YAML stream.

      * 

      * @param data

      *            Iterator with Objects

      * @param output

      *            stream to write to

      */

     @SuppressWarnings("deprecation")

     public void dumpAll(Iterator<? extends Object> data, Writer output) {

         dumpAll(data, output, dumperOptions.getExplicitRoot());

     }

     private void dumpAll(Iterator<? extends Object> data, Writer output, Tag rootTag) {

         Serializer serializer = new Serializer(new Emitter(output, dumperOptions), resolver,

                 dumperOptions, rootTag);

         try {

             serializer.open();

             while (data.hasNext()) {

                 Node node = representer.represent(data.next());

                 serializer.serialize(node);

             }

             serializer.close();

         } catch (java.io.IOException e) {

             throw new YAMLException(e);

         }

     }

     /**

      * <p>

      * Serialize a Java object into a YAML string. Override the default root tag

      * with <code>rootTag</code>.

      * </p>

      * 

      * <p>

      * This method is similar to <code>Yaml.dump(data)</code> except that the

      * root tag for the whole document is replaced with the given tag. This has

      * two main uses.

      * </p>

      * 

      * <p>

      * First, if the root tag is replaced with a standard YAML tag, such as

      * <code>Tag.MAP</code>, then the object will be dumped as a map. The root

      * tag will appear as <code>!!map</code>, or blank (implicit !!map).

      * </p>

      * 

      * <p>

      * Second, if the root tag is replaced by a different custom tag, then the

      * document appears to be a different type when loaded. For example, if an

      * instance of MyClass is dumped with the tag !!YourClass, then it will be

      * handled as an instance of YourClass when loaded.

      * </p>

      * 

      * @param data

      *            Java object to be serialized to YAML

      * @param rootTag

      *            the tag for the whole YAML document. The tag should be Tag.MAP

      *            for a JavaBean to make the tag disappear (to use implicit tag

      *            !!map). If <code>null</code> is provided then the standard tag

      *            with the full class name is used.

      * @param flowStyle

      *            flow style for the whole document. See Chapter 10. Collection

      *            Styles http://yaml.org/spec/1.1/#id930798. If

      *            <code>null</code> is provided then the flow style from

      *            DumperOptions is used.

      * 

      * @return YAML String

      */

     public String dumpAs(Object data, Tag rootTag, FlowStyle flowStyle) {

         FlowStyle oldStyle = representer.getDefaultFlowStyle();

         if (flowStyle != null) {

             representer.setDefaultFlowStyle(flowStyle);

         }

         List<Object> list = new ArrayList<Object>(1);

         list.add(data);

         StringWriter buffer = new StringWriter();

         dumpAll(list.iterator(), buffer, rootTag);

         representer.setDefaultFlowStyle(oldStyle);

         return buffer.toString();

     }

     /**

      * <p>

      * Serialize a Java object into a YAML string. Override the default root tag

      * with <code>Tag.MAP</code>.

      * </p>

      * <p>

      * This method is similar to <code>Yaml.dump(data)</code> except that the

      * root tag for the whole document is replaced with <code>Tag.MAP</code> tag

      * (implicit !!map).

      * </p>

      * <p>

      * Block Mapping is used as the collection style. See 10.2.2. Block Mappings

      * (http://yaml.org/spec/1.1/#id934537)

      * </p>

      * 

      * @param data

      *            Java object to be serialized to YAML

      * @return YAML String

      */

     public String dumpAsMap(Object data) {

         return dumpAs(data, Tag.MAP, FlowStyle.BLOCK);

     }

     /**

      * Serialize the representation tree into Events.

      * 

      * @see http://yaml.org/spec/1.1/#id859333

      * @param data

      *            representation tree

      * @return Event list

      */

     public List<Event> serialize(Node data) {

         SilentEmitter emitter = new SilentEmitter();

         @SuppressWarnings("deprecation")

         Serializer serializer = new Serializer(emitter, resolver, dumperOptions,

                 dumperOptions.getExplicitRoot());

         try {

             serializer.open();

             serializer.serialize(data);

             serializer.close();

         } catch (java.io.IOException e) {

             throw new YAMLException(e);

         }

         return emitter.getEvents();

     }

     private class SilentEmitter implements Emitable {

         private List<Event> events = new ArrayList<Event>(100);

         public List<Event> getEvents() {

             return events;

         }

         public void emit(Event event) throws IOException {

             events.add(event);

         }

     }

     /**

      * Parse the only YAML document in a String and produce the corresponding

      * Java object. (Because the encoding in known BOM is not respected.)

      * 

      * @param yaml

      *            YAML data to load from (BOM must not be present)

      * @return parsed object

      */

     public Object load(String yaml) {

         return loadFromReader(new StreamReader(yaml), Object.class);

     }

     /**

      * Parse the only YAML document in a stream and produce the corresponding

      * Java object.

      * 

      * @param io

      *            data to load from (BOM is respected and removed)

      * @return parsed object

      */

     public Object load(InputStream io) {

         return loadFromReader(new StreamReader(new UnicodeReader(io)), Object.class);

     }

     /**

      * Parse the only YAML document in a stream and produce the corresponding

      * Java object.

      * 

      * @param io

      *            data to load from (BOM must not be present)

      * @return parsed object

      */

     public Object load(Reader io) {

         return loadFromReader(new StreamReader(io), Object.class);

     }

     /**

      * Parse the only YAML document in a stream and produce the corresponding

      * Java object.

      * 

      * @param <T>

      *            Class is defined by the second argument

      * @param io

      *            data to load from (BOM must not be present)

      * @param type

      *            Class of the object to be created

      * @return parsed object

      */

     @SuppressWarnings("unchecked")

     public <T> T loadAs(Reader io, Class<T> type) {

         return (T) loadFromReader(new StreamReader(io), type);

     }

     /**

      * Parse the only YAML document in a String and produce the corresponding

      * Java object. (Because the encoding in known BOM is not respected.)

      * 

      * @param <T>

      *            Class is defined by the second argument

      * @param yaml

      *            YAML data to load from (BOM must not be present)

      * @param type

      *            Class of the object to be created

      * @return parsed object

      */

     @SuppressWarnings("unchecked")

     public <T> T loadAs(String yaml, Class<T> type) {

         return (T) loadFromReader(new StreamReader(yaml), type);

     }

     /**

      * Parse the only YAML document in a stream and produce the corresponding

      * Java object.

      * 

      * @param <T>

      *            Class is defined by the second argument

      * @param input

      *            data to load from (BOM is respected and removed)

      * @param type

      *            Class of the object to be created

      * @return parsed object

      */

     @SuppressWarnings("unchecked")

     public <T> T loadAs(InputStream input, Class<T> type) {

         return (T) loadFromReader(new StreamReader(new UnicodeReader(input)), type);

     }

     private Object loadFromReader(StreamReader sreader, Class<?> type) {

         Composer composer = new Composer(new ParserImpl(sreader), resolver);

         constructor.setComposer(composer);

         return constructor.getSingleData(type);

     }

     /**

      * Parse all YAML documents in a String and produce corresponding Java

      * objects. The documents are parsed only when the iterator is invoked.

      * 

      * @param yaml

      *            YAML data to load from (BOM must not be present)

      * @return an iterator over the parsed Java objects in this String in proper

      *         sequence

      */

     public Iterable<Object> loadAll(Reader yaml) {

         Composer composer = new Composer(new ParserImpl(new StreamReader(yaml)), resolver);

         constructor.setComposer(composer);

         Iterator<Object> result = new Iterator<Object>() {

             public boolean hasNext() {

                 return constructor.checkData();

             }

             public Object next() {

                 return constructor.getData();

             }

             public void remove() {

                 throw new UnsupportedOperationException();

             }

         };

         return new YamlIterable(result);

     }

     private class YamlIterable implements Iterable<Object> {

         private Iterator<Object> iterator;

         public YamlIterable(Iterator<Object> iterator) {

             this.iterator = iterator;

         }

         public Iterator<Object> iterator() {

             return iterator;

         }

     }

     /**

      * Parse all YAML documents in a String and produce corresponding Java

      * objects. (Because the encoding in known BOM is not respected.) The

      * documents are parsed only when the iterator is invoked.

      * 

      * @param yaml

      *            YAML data to load from (BOM must not be present)

      * @return an iterator over the parsed Java objects in this String in proper

      *         sequence

      */

     public Iterable<Object> loadAll(String yaml) {

         return loadAll(new StringReader(yaml));

     }

     /**

      * Parse all YAML documents in a stream and produce corresponding Java

      * objects. The documents are parsed only when the iterator is invoked.

      * 

      * @param yaml

      *            YAML data to load from (BOM is respected and ignored)

      * @return an iterator over the parsed Java objects in this stream in proper

      *         sequence

      */

     public Iterable<Object> loadAll(InputStream yaml) {

         return loadAll(new UnicodeReader(yaml));

     }

     /**

      * Parse the first YAML document in a stream and produce the corresponding

      * representation tree. (This is the opposite of the represent() method)

      * 

      * @see http://yaml.org/spec/1.1/#id859333

      * @param yaml

      *            YAML document

      * @return parsed root Node for the specified YAML document

      */

     public Node compose(Reader yaml) {

         Composer composer = new Composer(new ParserImpl(new StreamReader(yaml)), resolver);

         constructor.setComposer(composer);

         return composer.getSingleNode();

     }

     /**

      * Parse all YAML documents in a stream and produce corresponding

      * representation trees.

      * 

      * @see http://yaml.org/spec/1.1/#id859333

      * @param yaml

      *            stream of YAML documents

      * @return parsed root Nodes for all the specified YAML documents

      */

     public Iterable<Node> composeAll(Reader yaml) {

         final Composer composer = new Composer(new ParserImpl(new StreamReader(yaml)), resolver);

         constructor.setComposer(composer);

         Iterator<Node> result = new Iterator<Node>() {

             public boolean hasNext() {

                 return composer.checkNode();

             }

             public Node next() {

                 return composer.getNode();

             }

             public void remove() {

                 throw new UnsupportedOperationException();

             }

         };

         return new NodeIterable(result);

     }

     private class NodeIterable implements Iterable<Node> {

         private Iterator<Node> iterator;

         public NodeIterable(Iterator<Node> iterator) {

             this.iterator = iterator;

         }

         public Iterator<Node> iterator() {

             return iterator;

         }

     }

     /**

      * Add an implicit scalar detector. If an implicit scalar value matches the

      * given regexp, the corresponding tag is assigned to the scalar.

      * 

      * @deprecated use Tag instead of String

      * @param tag

      *            tag to assign to the node

      * @param regexp

      *            regular expression to match against

      * @param first

      *            a sequence of possible initial characters or null (which means

      *            any).

      * 

      */

     public void addImplicitResolver(String tag, Pattern regexp, String first) {

         addImplicitResolver(new Tag(tag), regexp, first);

     }

     /**

      * Add an implicit scalar detector. If an implicit scalar value matches the

      * given regexp, the corresponding tag is assigned to the scalar.

      * 

      * @param tag

      *            tag to assign to the node

      * @param regexp

      *            regular expression to match against

      * @param first

      *            a sequence of possible initial characters or null (which means

      *            any).

      */

     public void addImplicitResolver(Tag tag, Pattern regexp, String first) {

         resolver.addImplicitResolver(tag, regexp, first);

     }

     @Override

     public String toString() {

         return name;

     }

     /**

      * Get a meaningful name. It simplifies debugging in a multi-threaded

      * environment. If nothing is set explicitly the address of the instance is

      * returned.

      * 

      * @return human readable name

      */

     public String getName() {

         return name;

     }

     /**

      * Set a meaningful name to be shown in toString()

      * 

      * @param name

      *            human readable name

      */

     public void setName(String name) {

         this.name = name;

     }

     /**

      * Parse a YAML stream and produce parsing events.

      * 

      * @see http://yaml.org/spec/1.1/#id859333

      * @param yaml

      *            YAML document(s)

      * @return parsed events

      */

     public Iterable<Event> parse(Reader yaml) {

         final Parser parser = new ParserImpl(new StreamReader(yaml));

         Iterator<Event> result = new Iterator<Event>() {

             public boolean hasNext() {

                 return parser.peekEvent() != null;

             }

             public Event next() {

                 return parser.getEvent();

             }

             public void remove() {

                 throw new UnsupportedOperationException();

             }

         };

         return new EventIterable(result);

     }

     private class EventIterable implements Iterable<Event> {

         private Iterator<Event> iterator;

         public EventIterable(Iterator<Event> iterator) {

             this.iterator = iterator;

         }

         public Iterator<Event> iterator() {

             return iterator;

         }

     }

     public void setBeanAccess(BeanAccess beanAccess) {

         constructor.getPropertyUtils().setBeanAccess(beanAccess);

         representer.getPropertyUtils().setBeanAccess(beanAccess);

     }

     // deprecated

     /**

      * @deprecated use with Constructor instead of Loader

      */

     public Yaml(Loader loader) {

         this(loader, new Dumper(new DumperOptions()));

     }

     /**

      * @deprecated use with Constructor instead of Loader

      */

     public Yaml(Loader loader, Dumper dumper) {

         this(loader, dumper, new Resolver());

     }

     /**

      * @deprecated use with Constructor instead of Loader

      */

     public Yaml(Loader loader, Dumper dumper, Resolver resolver) {

         this(loader.constructor, dumper.representer, dumper.options, resolver);

     }

     /**

      * Create Yaml instance. It is safe to create a few instances and use them

      * in different Threads.

      * 

      * @param dumper

      *            Dumper to emit outgoing objects

      */

     @SuppressWarnings("deprecation")

     public Yaml(Dumper dumper) {

         this(new Constructor(), dumper.representer, dumper.options);

     }

 }