Coverage Report - org.yaml.snakeyaml.Yaml
 
Classes in this File Line Coverage Branch Coverage Complexity
Yaml
96%
116/120
100%
8/8
1.186
Yaml$1
75%
3/4
N/A
1.186
Yaml$2
75%
3/4
N/A
1.186
Yaml$3
75%
3/4
100%
2/2
1.186
Yaml$EventIterable
100%
4/4
N/A
1.186
Yaml$NodeIterable
100%
4/4
N/A
1.186
Yaml$SilentEmitter
100%
5/5
N/A
1.186
Yaml$YamlIterable
100%
4/4
N/A
1.186
 
 1  
 /**
 2  
  * Copyright (c) 2008-2011, http://www.snakeyaml.org
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *     http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 
 17  
 package org.yaml.snakeyaml;
 18  
 
 19  
 import java.io.IOException;
 20  
 import java.io.InputStream;
 21  
 import java.io.Reader;
 22  
 import java.io.StringReader;
 23  
 import java.io.StringWriter;
 24  
 import java.io.Writer;
 25  
 import java.util.ArrayList;
 26  
 import java.util.Iterator;
 27  
 import java.util.List;
 28  
 import java.util.regex.Pattern;
 29  
 
 30  
 import org.yaml.snakeyaml.DumperOptions.FlowStyle;
 31  
 import org.yaml.snakeyaml.composer.Composer;
 32  
 import org.yaml.snakeyaml.constructor.BaseConstructor;
 33  
 import org.yaml.snakeyaml.constructor.Constructor;
 34  
 import org.yaml.snakeyaml.emitter.Emitable;
 35  
 import org.yaml.snakeyaml.emitter.Emitter;
 36  
 import org.yaml.snakeyaml.error.YAMLException;
 37  
 import org.yaml.snakeyaml.events.Event;
 38  
 import org.yaml.snakeyaml.introspector.BeanAccess;
 39  
 import org.yaml.snakeyaml.nodes.Node;
 40  
 import org.yaml.snakeyaml.nodes.Tag;
 41  
 import org.yaml.snakeyaml.parser.Parser;
 42  
 import org.yaml.snakeyaml.parser.ParserImpl;
 43  
 import org.yaml.snakeyaml.reader.StreamReader;
 44  
 import org.yaml.snakeyaml.reader.UnicodeReader;
 45  
 import org.yaml.snakeyaml.representer.Representer;
 46  
 import org.yaml.snakeyaml.resolver.Resolver;
 47  
 import org.yaml.snakeyaml.serializer.Serializer;
 48  
 
 49  
 /**
 50  
  * Public YAML interface. Each Thread must have its own instance.
 51  
  */
 52  
 public class Yaml {
 53  
     protected final Resolver resolver;
 54  
     private String name;
 55  
     protected BaseConstructor constructor;
 56  
     protected Representer representer;
 57  
     protected DumperOptions dumperOptions;
 58  
     protected LoaderOptions loaderOptions;
 59  
 
 60  
     /**
 61  
      * Create Yaml instance. It is safe to create a few instances and use them
 62  
      * in different Threads.
 63  
      */
 64  
     public Yaml() {
 65  3634
         this(new Constructor(), new LoaderOptions(), new Representer(), new DumperOptions(),
 66  
                 new Resolver());
 67  3634
     }
 68  
 
 69  
     public Yaml(LoaderOptions loaderOptions) {
 70  3
         this(new Constructor(), loaderOptions, new Representer(), new DumperOptions(),
 71  
                 new Resolver());
 72  3
     }
 73  
 
 74  
     /**
 75  
      * Create Yaml instance.
 76  
      * 
 77  
      * @param dumperOptions
 78  
      *            DumperOptions to configure outgoing objects
 79  
      */
 80  
     public Yaml(DumperOptions dumperOptions) {
 81  77
         this(new Constructor(), new Representer(), dumperOptions);
 82  77
     }
 83  
 
 84  
     /**
 85  
      * Create Yaml instance. It is safe to create a few instances and use them
 86  
      * in different Threads.
 87  
      * 
 88  
      * @param representer
 89  
      *            Representer to emit outgoing objects
 90  
      */
 91  
     public Yaml(Representer representer) {
 92  28
         this(new Constructor(), representer);
 93  28
     }
 94  
 
 95  
     /**
 96  
      * Create Yaml instance. It is safe to create a few instances and use them
 97  
      * in different Threads.
 98  
      * 
 99  
      * @param constructor
 100  
      *            BaseConstructor to construct incoming documents
 101  
      */
 102  
     public Yaml(BaseConstructor constructor) {
 103  175
         this(constructor, new Representer());
 104  175
     }
 105  
 
 106  
     /**
 107  
      * Create Yaml instance. It is safe to create a few instances and use them
 108  
      * in different Threads.
 109  
      * 
 110  
      * @param constructor
 111  
      *            BaseConstructor to construct incoming documents
 112  
      * @param representer
 113  
      *            Representer to emit outgoing objects
 114  
      */
 115  
     public Yaml(BaseConstructor constructor, Representer representer) {
 116  215
         this(constructor, representer, new DumperOptions());
 117  215
     }
 118  
 
 119  
     /**
 120  
      * Create Yaml instance. It is safe to create a few instances and use them
 121  
      * in different Threads.
 122  
      * 
 123  
      * @param representer
 124  
      *            Representer to emit outgoing objects
 125  
      * @param dumperOptions
 126  
      *            DumperOptions to configure outgoing objects
 127  
      */
 128  
     public Yaml(Representer representer, DumperOptions dumperOptions) {
 129  25
         this(new Constructor(), representer, dumperOptions, new Resolver());
 130  25
     }
 131  
 
 132  
     /**
 133  
      * Create Yaml instance. It is safe to create a few instances and use them
 134  
      * in different Threads.
 135  
      * 
 136  
      * @param constructor
 137  
      *            BaseConstructor to construct incoming documents
 138  
      * @param representer
 139  
      *            Representer to emit outgoing objects
 140  
      * @param dumperOptions
 141  
      *            DumperOptions to configure outgoing objects
 142  
      */
 143  
     public Yaml(BaseConstructor constructor, Representer representer, DumperOptions dumperOptions) {
 144  294
         this(constructor, representer, dumperOptions, new Resolver());
 145  294
     }
 146  
 
 147  
     /**
 148  
      * Create Yaml instance. It is safe to create a few instances and use them
 149  
      * in different Threads.
 150  
      * 
 151  
      * @param constructor
 152  
      *            BaseConstructor to construct incoming documents
 153  
      * @param representer
 154  
      *            Representer to emit outgoing objects
 155  
      * @param dumperOptions
 156  
      *            DumperOptions to configure outgoing objects
 157  
      * @param resolver
 158  
      *            Resolver to detect implicit type
 159  
      */
 160  
     public Yaml(BaseConstructor constructor, Representer representer, DumperOptions dumperOptions,
 161  
             Resolver resolver) {
 162  326
         this(constructor, new LoaderOptions(), representer, dumperOptions, resolver);
 163  326
     }
 164  
 
 165  
     /**
 166  
      * Create Yaml instance. It is safe to create a few instances and use them
 167  
      * in different Threads.
 168  
      * 
 169  
      * @param constructor
 170  
      *            BaseConstructor to construct incoming documents
 171  
      * @param loaderOptions
 172  
      *            LoaderOptions to control construction process
 173  
      * @param representer
 174  
      *            Representer to emit outgoing objects
 175  
      * @param dumperOptions
 176  
      *            DumperOptions to configure outgoing objects
 177  
      * @param resolver
 178  
      *            Resolver to detect implicit type
 179  
      */
 180  
     public Yaml(BaseConstructor constructor, LoaderOptions loaderOptions, Representer representer,
 181  3963
             DumperOptions dumperOptions, Resolver resolver) {
 182  3963
         if (!constructor.isExplicitPropertyUtils()) {
 183  3961
             constructor.setPropertyUtils(representer.getPropertyUtils());
 184  2
         } else if (!representer.isExplicitPropertyUtils()) {
 185  1
             representer.setPropertyUtils(constructor.getPropertyUtils());
 186  
         }
 187  3963
         this.constructor = constructor;
 188  3963
         this.loaderOptions = loaderOptions;
 189  3963
         representer.setDefaultFlowStyle(dumperOptions.getDefaultFlowStyle());
 190  3963
         representer.setDefaultScalarStyle(dumperOptions.getDefaultScalarStyle());
 191  3963
         representer.getPropertyUtils().setAllowReadOnlyProperties(
 192  
                 dumperOptions.isAllowReadOnlyProperties());
 193  3963
         this.representer = representer;
 194  3963
         this.dumperOptions = dumperOptions;
 195  3963
         this.resolver = resolver;
 196  3963
         this.name = "Yaml:" + System.identityHashCode(this);
 197  3963
     }
 198  
 
 199  
     /**
 200  
      * Serialize a Java object into a YAML String.
 201  
      * 
 202  
      * @param data
 203  
      *            Java object to be Serialized to YAML
 204  
      * @return YAML String
 205  
      */
 206  
     public String dump(Object data) {
 207  3266
         List<Object> list = new ArrayList<Object>(1);
 208  3266
         list.add(data);
 209  3266
         return dumpAll(list.iterator());
 210  
     }
 211  
 
 212  
     /**
 213  
      * Produce the corresponding representation tree for a given Object.
 214  
      * 
 215  
      * @see http://yaml.org/spec/1.1/#id859333
 216  
      * @param data
 217  
      *            instance to build the representation tree for
 218  
      * @return representation tree
 219  
      */
 220  
     public Node represent(Object data) {
 221  3
         return representer.represent(data);
 222  
     }
 223  
 
 224  
     /**
 225  
      * Serialize a sequence of Java objects into a YAML String.
 226  
      * 
 227  
      * @param data
 228  
      *            Iterator with Objects
 229  
      * @return YAML String with all the objects in proper sequence
 230  
      */
 231  
     public String dumpAll(Iterator<? extends Object> data) {
 232  3267
         StringWriter buffer = new StringWriter();
 233  3267
         dumpAll(data, buffer);
 234  3258
         return buffer.toString();
 235  
     }
 236  
 
 237  
     /**
 238  
      * Serialize a Java object into a YAML stream.
 239  
      * 
 240  
      * @param data
 241  
      *            Java object to be serialized to YAML
 242  
      * @param output
 243  
      *            stream to write to
 244  
      */
 245  
     public void dump(Object data, Writer output) {
 246  48
         List<Object> list = new ArrayList<Object>(1);
 247  48
         list.add(data);
 248  48
         dumpAll(list.iterator(), output);
 249  46
     }
 250  
 
 251  
     /**
 252  
      * Serialize a sequence of Java objects into a YAML stream.
 253  
      * 
 254  
      * @param data
 255  
      *            Iterator with Objects
 256  
      * @param output
 257  
      *            stream to write to
 258  
      */
 259  
     @SuppressWarnings("deprecation")
 260  
     public void dumpAll(Iterator<? extends Object> data, Writer output) {
 261  3318
         dumpAll(data, output, dumperOptions.getExplicitRoot());
 262  3307
     }
 263  
 
 264  
     private void dumpAll(Iterator<? extends Object> data, Writer output, Tag rootTag) {
 265  16385
         Serializer serializer = new Serializer(new Emitter(output, dumperOptions), resolver,
 266  
                 dumperOptions, rootTag);
 267  
         try {
 268  16385
             serializer.open();
 269  32765
             while (data.hasNext()) {
 270  16391
                 Node node = representer.represent(data.next());
 271  16382
                 serializer.serialize(node);
 272  16380
             }
 273  16374
             serializer.close();
 274  2
         } catch (java.io.IOException e) {
 275  2
             throw new YAMLException(e);
 276  16374
         }
 277  16374
     }
 278  
 
 279  
     /**
 280  
      * <p>
 281  
      * Serialize a Java object into a YAML string. Override the default root tag
 282  
      * with <code>rootTag</code>.
 283  
      * </p>
 284  
      * 
 285  
      * <p>
 286  
      * This method is similar to <code>Yaml.dump(data)</code> except that the
 287  
      * root tag for the whole document is replaced with the given tag. This has
 288  
      * two main uses.
 289  
      * </p>
 290  
      * 
 291  
      * <p>
 292  
      * First, if the root tag is replaced with a standard YAML tag, such as
 293  
      * <code>Tag.MAP</code>, then the object will be dumped as a map. The root
 294  
      * tag will appear as <code>!!map</code>, or blank (implicit !!map).
 295  
      * </p>
 296  
      * 
 297  
      * <p>
 298  
      * Second, if the root tag is replaced by a different custom tag, then the
 299  
      * document appears to be a different type when loaded. For example, if an
 300  
      * instance of MyClass is dumped with the tag !!YourClass, then it will be
 301  
      * handled as an instance of YourClass when loaded.
 302  
      * </p>
 303  
      * 
 304  
      * @param data
 305  
      *            Java object to be serialized to YAML
 306  
      * @param rootTag
 307  
      *            the tag for the whole YAML document. The tag should be Tag.MAP
 308  
      *            for a JavaBean to make the tag disappear (to use implicit tag
 309  
      *            !!map). If <code>null</code> is provided then the standard tag
 310  
      *            with the full class name is used.
 311  
      * @param flowStyle
 312  
      *            flow style for the whole document. See Chapter 10. Collection
 313  
      *            Styles http://yaml.org/spec/1.1/#id930798. If
 314  
      *            <code>null</code> is provided then the flow style from
 315  
      *            DumperOptions is used.
 316  
      * 
 317  
      * @return YAML String
 318  
      */
 319  
     public String dumpAs(Object data, Tag rootTag, FlowStyle flowStyle) {
 320  13067
         FlowStyle oldStyle = representer.getDefaultFlowStyle();
 321  13067
         if (flowStyle != null) {
 322  13065
             representer.setDefaultFlowStyle(flowStyle);
 323  
         }
 324  13067
         List<Object> list = new ArrayList<Object>(1);
 325  13067
         list.add(data);
 326  13067
         StringWriter buffer = new StringWriter();
 327  13067
         dumpAll(list.iterator(), buffer, rootTag);
 328  13067
         representer.setDefaultFlowStyle(oldStyle);
 329  13067
         return buffer.toString();
 330  
     }
 331  
 
 332  
     /**
 333  
      * <p>
 334  
      * Serialize a Java object into a YAML string. Override the default root tag
 335  
      * with <code>Tag.MAP</code>.
 336  
      * </p>
 337  
      * <p>
 338  
      * This method is similar to <code>Yaml.dump(data)</code> except that the
 339  
      * root tag for the whole document is replaced with <code>Tag.MAP</code> tag
 340  
      * (implicit !!map).
 341  
      * </p>
 342  
      * <p>
 343  
      * Block Mapping is used as the collection style. See 10.2.2. Block Mappings
 344  
      * (http://yaml.org/spec/1.1/#id934537)
 345  
      * </p>
 346  
      * 
 347  
      * @param data
 348  
      *            Java object to be serialized to YAML
 349  
      * @return YAML String
 350  
      */
 351  
     public String dumpAsMap(Object data) {
 352  13058
         return dumpAs(data, Tag.MAP, FlowStyle.BLOCK);
 353  
     }
 354  
 
 355  
     /**
 356  
      * Serialize the representation tree into Events.
 357  
      * 
 358  
      * @see http://yaml.org/spec/1.1/#id859333
 359  
      * @param data
 360  
      *            representation tree
 361  
      * @return Event list
 362  
      */
 363  
     public List<Event> serialize(Node data) {
 364  3
         SilentEmitter emitter = new SilentEmitter();
 365  
         @SuppressWarnings("deprecation")
 366  3
         Serializer serializer = new Serializer(emitter, resolver, dumperOptions,
 367  
                 dumperOptions.getExplicitRoot());
 368  
         try {
 369  3
             serializer.open();
 370  3
             serializer.serialize(data);
 371  3
             serializer.close();
 372  0
         } catch (java.io.IOException e) {
 373  0
             throw new YAMLException(e);
 374  3
         }
 375  3
         return emitter.getEvents();
 376  
     }
 377  
 
 378  6
     private class SilentEmitter implements Emitable {
 379  3
         private List<Event> events = new ArrayList<Event>(100);
 380  
 
 381  
         public List<Event> getEvents() {
 382  3
             return events;
 383  
         }
 384  
 
 385  
         public void emit(Event event) throws IOException {
 386  34
             events.add(event);
 387  34
         }
 388  
     }
 389  
 
 390  
     /**
 391  
      * Parse the only YAML document in a String and produce the corresponding
 392  
      * Java object. (Because the encoding in known BOM is not respected.)
 393  
      * 
 394  
      * @param yaml
 395  
      *            YAML data to load from (BOM must not be present)
 396  
      * @return parsed object
 397  
      */
 398  
     public Object load(String yaml) {
 399  436
         return loadFromReader(new StreamReader(yaml), Object.class);
 400  
     }
 401  
 
 402  
     /**
 403  
      * Parse the only YAML document in a stream and produce the corresponding
 404  
      * Java object.
 405  
      * 
 406  
      * @param io
 407  
      *            data to load from (BOM is respected and removed)
 408  
      * @return parsed object
 409  
      */
 410  
     public Object load(InputStream io) {
 411  47
         return loadFromReader(new StreamReader(new UnicodeReader(io)), Object.class);
 412  
     }
 413  
 
 414  
     /**
 415  
      * Parse the only YAML document in a stream and produce the corresponding
 416  
      * Java object.
 417  
      * 
 418  
      * @param io
 419  
      *            data to load from (BOM must not be present)
 420  
      * @return parsed object
 421  
      */
 422  
     public Object load(Reader io) {
 423  5
         return loadFromReader(new StreamReader(io), Object.class);
 424  
     }
 425  
 
 426  
     /**
 427  
      * Parse the only YAML document in a stream and produce the corresponding
 428  
      * Java object.
 429  
      * 
 430  
      * @param <T>
 431  
      *            Class is defined by the second argument
 432  
      * @param io
 433  
      *            data to load from (BOM must not be present)
 434  
      * @param type
 435  
      *            Class of the object to be created
 436  
      * @return parsed object
 437  
      */
 438  
     @SuppressWarnings("unchecked")
 439  
     public <T> T loadAs(Reader io, Class<T> type) {
 440  1
         return (T) loadFromReader(new StreamReader(io), type);
 441  
     }
 442  
 
 443  
     /**
 444  
      * Parse the only YAML document in a String and produce the corresponding
 445  
      * Java object. (Because the encoding in known BOM is not respected.)
 446  
      * 
 447  
      * @param <T>
 448  
      *            Class is defined by the second argument
 449  
      * @param yaml
 450  
      *            YAML data to load from (BOM must not be present)
 451  
      * @param type
 452  
      *            Class of the object to be created
 453  
      * @return parsed object
 454  
      */
 455  
     @SuppressWarnings("unchecked")
 456  
     public <T> T loadAs(String yaml, Class<T> type) {
 457  71
         return (T) loadFromReader(new StreamReader(yaml), type);
 458  
     }
 459  
 
 460  
     /**
 461  
      * Parse the only YAML document in a stream and produce the corresponding
 462  
      * Java object.
 463  
      * 
 464  
      * @param <T>
 465  
      *            Class is defined by the second argument
 466  
      * @param input
 467  
      *            data to load from (BOM is respected and removed)
 468  
      * @param type
 469  
      *            Class of the object to be created
 470  
      * @return parsed object
 471  
      */
 472  
     @SuppressWarnings("unchecked")
 473  
     public <T> T loadAs(InputStream input, Class<T> type) {
 474  1
         return (T) loadFromReader(new StreamReader(new UnicodeReader(input)), type);
 475  
     }
 476  
 
 477  
     private Object loadFromReader(StreamReader sreader, Class<?> type) {
 478  559
         Composer composer = new Composer(new ParserImpl(sreader), resolver);
 479  559
         constructor.setComposer(composer);
 480  559
         return constructor.getSingleData(type);
 481  
     }
 482  
 
 483  
     /**
 484  
      * Parse all YAML documents in a String and produce corresponding Java
 485  
      * objects. The documents are parsed only when the iterator is invoked.
 486  
      * 
 487  
      * @param yaml
 488  
      *            YAML data to load from (BOM must not be present)
 489  
      * @return an iterator over the parsed Java objects in this String in proper
 490  
      *         sequence
 491  
      */
 492  
     public Iterable<Object> loadAll(Reader yaml) {
 493  255
         Composer composer = new Composer(new ParserImpl(new StreamReader(yaml)), resolver);
 494  255
         constructor.setComposer(composer);
 495  255
         Iterator<Object> result = new Iterator<Object>() {
 496  
             public boolean hasNext() {
 497  398
                 return constructor.checkData();
 498  
             }
 499  
 
 500  
             public Object next() {
 501  250
                 return constructor.getData();
 502  
             }
 503  
 
 504  255
             public void remove() {
 505  0
                 throw new UnsupportedOperationException();
 506  
             }
 507  
         };
 508  255
         return new YamlIterable(result);
 509  
     }
 510  
 
 511  
     private class YamlIterable implements Iterable<Object> {
 512  
         private Iterator<Object> iterator;
 513  
 
 514  255
         public YamlIterable(Iterator<Object> iterator) {
 515  255
             this.iterator = iterator;
 516  255
         }
 517  
 
 518  
         public Iterator<Object> iterator() {
 519  255
             return iterator;
 520  
         }
 521  
 
 522  
     }
 523  
 
 524  
     /**
 525  
      * Parse all YAML documents in a String and produce corresponding Java
 526  
      * objects. (Because the encoding in known BOM is not respected.) The
 527  
      * documents are parsed only when the iterator is invoked.
 528  
      * 
 529  
      * @param yaml
 530  
      *            YAML data to load from (BOM must not be present)
 531  
      * @return an iterator over the parsed Java objects in this String in proper
 532  
      *         sequence
 533  
      */
 534  
     public Iterable<Object> loadAll(String yaml) {
 535  90
         return loadAll(new StringReader(yaml));
 536  
     }
 537  
 
 538  
     /**
 539  
      * Parse all YAML documents in a stream and produce corresponding Java
 540  
      * objects. The documents are parsed only when the iterator is invoked.
 541  
      * 
 542  
      * @param yaml
 543  
      *            YAML data to load from (BOM is respected and ignored)
 544  
      * @return an iterator over the parsed Java objects in this stream in proper
 545  
      *         sequence
 546  
      */
 547  
     public Iterable<Object> loadAll(InputStream yaml) {
 548  256
         return loadAll(new UnicodeReader(yaml));
 549  
     }
 550  
 
 551  
     /**
 552  
      * Parse the first YAML document in a stream and produce the corresponding
 553  
      * representation tree. (This is the opposite of the represent() method)
 554  
      * 
 555  
      * @see http://yaml.org/spec/1.1/#id859333
 556  
      * @param yaml
 557  
      *            YAML document
 558  
      * @return parsed root Node for the specified YAML document
 559  
      */
 560  
     public Node compose(Reader yaml) {
 561  9
         Composer composer = new Composer(new ParserImpl(new StreamReader(yaml)), resolver);
 562  9
         constructor.setComposer(composer);
 563  9
         return composer.getSingleNode();
 564  
     }
 565  
 
 566  
     /**
 567  
      * Parse all YAML documents in a stream and produce corresponding
 568  
      * representation trees.
 569  
      * 
 570  
      * @see http://yaml.org/spec/1.1/#id859333
 571  
      * @param yaml
 572  
      *            stream of YAML documents
 573  
      * @return parsed root Nodes for all the specified YAML documents
 574  
      */
 575  
     public Iterable<Node> composeAll(Reader yaml) {
 576  3
         final Composer composer = new Composer(new ParserImpl(new StreamReader(yaml)), resolver);
 577  3
         constructor.setComposer(composer);
 578  3
         Iterator<Node> result = new Iterator<Node>() {
 579  
             public boolean hasNext() {
 580  10
                 return composer.checkNode();
 581  
             }
 582  
 
 583  
             public Node next() {
 584  7
                 return composer.getNode();
 585  
             }
 586  
 
 587  10
             public void remove() {
 588  0
                 throw new UnsupportedOperationException();
 589  
             }
 590  
         };
 591  3
         return new NodeIterable(result);
 592  
     }
 593  
 
 594  
     private class NodeIterable implements Iterable<Node> {
 595  
         private Iterator<Node> iterator;
 596  
 
 597  3
         public NodeIterable(Iterator<Node> iterator) {
 598  3
             this.iterator = iterator;
 599  3
         }
 600  
 
 601  
         public Iterator<Node> iterator() {
 602  3
             return iterator;
 603  
         }
 604  
     }
 605  
 
 606  
     /**
 607  
      * Add an implicit scalar detector. If an implicit scalar value matches the
 608  
      * given regexp, the corresponding tag is assigned to the scalar.
 609  
      * 
 610  
      * @deprecated use Tag instead of String
 611  
      * @param tag
 612  
      *            tag to assign to the node
 613  
      * @param regexp
 614  
      *            regular expression to match against
 615  
      * @param first
 616  
      *            a sequence of possible initial characters or null (which means
 617  
      *            any).
 618  
      * 
 619  
      */
 620  
     public void addImplicitResolver(String tag, Pattern regexp, String first) {
 621  0
         addImplicitResolver(new Tag(tag), regexp, first);
 622  0
     }
 623  
 
 624  
     /**
 625  
      * Add an implicit scalar detector. If an implicit scalar value matches the
 626  
      * given regexp, the corresponding tag is assigned to the scalar.
 627  
      * 
 628  
      * @param tag
 629  
      *            tag to assign to the node
 630  
      * @param regexp
 631  
      *            regular expression to match against
 632  
      * @param first
 633  
      *            a sequence of possible initial characters or null (which means
 634  
      *            any).
 635  
      */
 636  
     public void addImplicitResolver(Tag tag, Pattern regexp, String first) {
 637  8
         resolver.addImplicitResolver(tag, regexp, first);
 638  8
     }
 639  
 
 640  
     @Override
 641  
     public String toString() {
 642  2
         return name;
 643  
     }
 644  
 
 645  
     /**
 646  
      * Get a meaningful name. It simplifies debugging in a multi-threaded
 647  
      * environment. If nothing is set explicitly the address of the instance is
 648  
      * returned.
 649  
      * 
 650  
      * @return human readable name
 651  
      */
 652  
     public String getName() {
 653  1
         return name;
 654  
     }
 655  
 
 656  
     /**
 657  
      * Set a meaningful name to be shown in toString()
 658  
      * 
 659  
      * @param name
 660  
      *            human readable name
 661  
      */
 662  
     public void setName(String name) {
 663  1
         this.name = name;
 664  1
     }
 665  
 
 666  
     /**
 667  
      * Parse a YAML stream and produce parsing events.
 668  
      * 
 669  
      * @see http://yaml.org/spec/1.1/#id859333
 670  
      * @param yaml
 671  
      *            YAML document(s)
 672  
      * @return parsed events
 673  
      */
 674  
     public Iterable<Event> parse(Reader yaml) {
 675  3
         final Parser parser = new ParserImpl(new StreamReader(yaml));
 676  3
         Iterator<Event> result = new Iterator<Event>() {
 677  
             public boolean hasNext() {
 678  39
                 return parser.peekEvent() != null;
 679  
             }
 680  
 
 681  
             public Event next() {
 682  36
                 return parser.getEvent();
 683  
             }
 684  
 
 685  39
             public void remove() {
 686  0
                 throw new UnsupportedOperationException();
 687  
             }
 688  
         };
 689  3
         return new EventIterable(result);
 690  
     }
 691  
 
 692  
     private class EventIterable implements Iterable<Event> {
 693  
         private Iterator<Event> iterator;
 694  
 
 695  3
         public EventIterable(Iterator<Event> iterator) {
 696  3
             this.iterator = iterator;
 697  3
         }
 698  
 
 699  
         public Iterator<Event> iterator() {
 700  3
             return iterator;
 701  
         }
 702  
     }
 703  
 
 704  
     public void setBeanAccess(BeanAccess beanAccess) {
 705  19
         constructor.getPropertyUtils().setBeanAccess(beanAccess);
 706  19
         representer.getPropertyUtils().setBeanAccess(beanAccess);
 707  19
     }
 708  
 
 709  
     // deprecated
 710  
     /**
 711  
      * @deprecated use with Constructor instead of Loader
 712  
      */
 713  
     public Yaml(Loader loader) {
 714  1
         this(loader, new Dumper(new DumperOptions()));
 715  1
     }
 716  
 
 717  
     /**
 718  
      * @deprecated use with Constructor instead of Loader
 719  
      */
 720  
     public Yaml(Loader loader, Dumper dumper) {
 721  2
         this(loader, dumper, new Resolver());
 722  2
     }
 723  
 
 724  
     /**
 725  
      * @deprecated use with Constructor instead of Loader
 726  
      */
 727  
     public Yaml(Loader loader, Dumper dumper, Resolver resolver) {
 728  4
         this(loader.constructor, dumper.representer, dumper.options, resolver);
 729  4
     }
 730  
 
 731  
     /**
 732  
      * Create Yaml instance. It is safe to create a few instances and use them
 733  
      * in different Threads.
 734  
      * 
 735  
      * @param dumper
 736  
      *            Dumper to emit outgoing objects
 737  
      */
 738  
     @SuppressWarnings("deprecation")
 739  
     public Yaml(Dumper dumper) {
 740  1
         this(new Constructor(), dumper.representer, dumper.options);
 741  1
     }
 742  
 }