/** * 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 Iterable 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 to detect encoding and removed from the data) * @return an Iterable over the parsed Java objects in this stream in proper * sequence */ public Iterable<Object> loadAll(InputStream yaml) { return loadAll(new UnicodeReader(yaml)); }
List<MVELRuleDefinition> readAll(Reader reader) { List<MVELRuleDefinition> ruleDefinitions = new ArrayList<>(); Iterable<Object> rules = yaml.loadAll(reader); for (Object rule : rules) { Map<String, Object> map = (Map<String, Object>) rule; ruleDefinitions.add(createRuleDefinitionFrom(map)); } return ruleDefinitions; }
private boolean process(MatchCallback callback, Yaml yaml, Resource resource) { int count = 0; try { if (logger.isDebugEnabled()) { logger.debug("Loading from YAML: " + resource); } Reader reader = new UnicodeReader(resource.getInputStream()); try { for (Object object : yaml.loadAll(reader)) { if (object != null && process(asMap(object), callback)) { count++; if (this.resolutionMethod == ResolutionMethod.FIRST_FOUND) { break; } } } if (logger.isDebugEnabled()) { logger.debug("Loaded " + count + " document" + (count > 1 ? "s" : "") + " from YAML resource: " + resource); } } finally { reader.close(); } } catch (IOException ex) { handleProcessError(resource, ex); } return (count > 0); }
public void loadString( String string ) throws Exception { this.string = string; for ( Object data : getYaml().loadAll( getStringValue() ) ) { documents.add( data ); this.useMap = ( data instanceof Map ); } this.documenti = documents.iterator(); }
private Iterable<Object> getComposeConfigurations(File composePath, MavenProject project, MavenSession session) { try { Yaml yaml = new Yaml(); return yaml.loadAll(getFilteredReader(composePath, project, session)); } catch (FileNotFoundException | MavenFilteringException e) { throw new ExternalConfigHandlerException("failed to load external configuration: " + composePath, e); } }
private boolean process(MatchCallback callback, Yaml yaml, Resource resource) { int count = 0; try { if (logger.isDebugEnabled()) { logger.debug("Loading from YAML: " + resource); } Reader reader = new UnicodeReader(resource.getInputStream()); try { for (Object object : yaml.loadAll(reader)) { if (object != null && process(asMap(object), callback)) { count++; if (this.resolutionMethod == ResolutionMethod.FIRST_FOUND) { break; } } } if (logger.isDebugEnabled()) { logger.debug("Loaded " + count + " document" + (count > 1 ? "s" : "") + " from YAML resource: " + resource); } } finally { reader.close(); } } catch (IOException ex) { handleProcessError(resource, ex); } return (count > 0); }
public void loadFile( String filename ) throws Exception { this.filename = filename; this.file = KettleVFS.getFileObject( filename ); InputStream is = null; try { is = KettleVFS.getInputStream( getFile() ); for ( Object data : getYaml().loadAll( is ) ) { documents.add( data ); this.useMap = ( data instanceof Map ); } this.documenti = documents.iterator(); } finally { if ( is != null ) { is.close(); } } }
try { int count = 0; for (Object object : yaml.loadAll(resource.getInputStream())) { if (resolutionMethod != ResolutionMethod.FIRST_FOUND || !found) { @SuppressWarnings("unchecked")
@SuppressWarnings("unchecked") void load(InputStream is) { if (is != null) { for (Object map : yaml.loadAll(is)) { loadMap((Map<String, Object>)map, null); } } }
/** * load a input {@link InputStream} to be a map {@link Map}, you have to close the inputStream by yourself, such as:<br> * <p>try (InputStream in = url.openStream()) {<br> * configMap.putAll(YAMLUtil.yaml2Properties(in));<br> * }<br> * </p> * @param input the stream to be loaded * @return a config map */ @SuppressWarnings("unchecked") public static Map<String, Object> yaml2Properties(InputStream input) { Map<String, Object> configurations = new LinkedHashMap<>(); Yaml yaml = new Yaml(); yaml.loadAll(input).forEach(data -> configurations.putAll(retrieveItems("", (Map<String, Object>) data))); return configurations; }
protected void readAttributesFromFile(InputStreamReader is) throws IOException { if (fileLocation.endsWith(PROPERTIES_EXTENSION)) { Properties properties = new Properties(); properties.load(is); properties.keySet().stream().map(key -> { Object rawValue = properties.get(key); rawValue = createValue((String) key, (String) rawValue); return new DefaultConfigurationProperty(of(this), (String) key, rawValue); }).forEach(configurationAttribute -> { configurationAttributes.put(configurationAttribute.getKey(), configurationAttribute); }); } else { Yaml yaml = new Yaml(); Iterable<Object> yamlObjects = yaml.loadAll(is); try { yamlObjects.forEach(yamlObject -> { createAttributesFromYamlObject(null, null, yamlObject); }); } catch (ParserException e) { throw new ConfigurationPropertiesException(createStaticMessage("Error while parsing YAML configuration file. Check that all quotes are correctly closed."), this, e); } } }
private void assertSyncStateStructureCorrect(File syncStateFile) throws FileNotFoundException { Iterable<Object> syncState = new Yaml().loadAll(new FileInputStream(syncStateFile)); for (Object ymlMap : syncState) { assertTrue("Sync state contains unrecognizable object", ymlMap instanceof Map); Map map = (Map) ymlMap; if (map.containsKey(LockServiceStateLogger.SYNC_STATE_TITLE)) { Object mapObj = map.get(LockServiceStateLogger.SYNC_STATE_TITLE); assertTrue("Sync state is not a map", mapObj instanceof Map); assertEquals(getSyncStateDescriptors().size(), ((Map) mapObj).size()); } else { throw new IllegalStateException("Map found in YAML document without an expected key"); } } }
private void assertSynthesizedRequestStateStructureCorrect(File file) throws FileNotFoundException { Iterable<Object> synthesizedRequestState = new Yaml().loadAll(new FileInputStream(file)); for (Object ymlMap : synthesizedRequestState) { assertTrue("Request state contains unrecognizable object", ymlMap instanceof Map); Map map = (Map) ymlMap; if (map.containsKey(LockServiceStateLogger.SYNTHESIZED_REQUEST_STATE_TITLE)) { Object mapObj = map.get(LockServiceStateLogger.SYNTHESIZED_REQUEST_STATE_TITLE); assertTrue("Request state is not a map", mapObj instanceof Map); assertEquals(getSyncStateDescriptors().size(), ((Map) mapObj).size()); } else { throw new IllegalStateException("Map found in YAML document without an expected key"); } } }
@Test public void testLockState() throws Exception { List<File> files = LockServiceTestUtils.logStateDirFiles(); Optional<File> lockStateFile = files.stream().filter( file -> file.getName().startsWith(LockServiceStateLogger.LOCKSTATE_FILE_PREFIX)).findFirst(); Iterable<Object> lockState = new Yaml().loadAll(new FileInputStream(lockStateFile.get())); for (Object ymlMap : lockState) { assertTrue("Lock state contains unrecognizable object", ymlMap instanceof Map); Map map = (Map) ymlMap; if (map.containsKey(LockServiceStateLogger.OUTSTANDING_LOCK_REQUESTS_TITLE)) { Object arrayObj = map.get(LockServiceStateLogger.OUTSTANDING_LOCK_REQUESTS_TITLE); assertTrue("Outstanding lock requests is not a list", arrayObj instanceof List); assertEquals(getOutstandingDescriptors().size(), ((List) arrayObj).size()); } else if (map.containsKey(LockServiceStateLogger.HELD_LOCKS_TITLE)) { Object mapObj = map.get(LockServiceStateLogger.HELD_LOCKS_TITLE); assertTrue("Held locks is not a map", mapObj instanceof Map); assertEquals(getHeldDescriptors().size(), ((Map) mapObj).size()); } else { throw new IllegalStateException("Map found in YAML document without an expected key"); } } }
@Override public Iterable<Object> loadAll(final Reader yaml) { final List<Object> list = new ArrayList<>(); for (final Object doc : super.loadAll(yaml)) list.add(doc); return list; }
@SuppressWarnings("unchecked") public static List<Map<String, Object>> readAllFromFile(File file) throws IOException { Yaml yaml = new Yaml(); List<Map<String, Object>> documents = new ArrayList<>(); try (InputStream is = new BufferedInputStream(new FileInputStream(file))) { for (Object document : yaml.loadAll(is)) { documents.add((Map<String, Object>) document); } } return documents; }
@SuppressWarnings("unchecked") void load(InputStream is) { if (is != null) { for (Object map : yaml.loadAll(is)) { loadMap((Map<String, Object>)map, null); } } }
@Override public Iterable<ACLPolicyDoc> loadAll(final Yaml yaml) throws IOException { if (null == fileInputStream) { fileInputStream = new FileInputStream(file); } return YamlParsePolicy.documentIterable( yaml.loadAll(fileInputStream).iterator(), validationSet, file.getName() ); }
public boolean canSupport(String manifest) { Yaml yaml = new Yaml(); Iterable<Object> object = yaml.loadAll(manifest); for (Object o : object) { boolean supportKind = assertSupportedKind(o); if (!supportKind) { return false; } } return true; }