/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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 android.filterfw.io;
import java.lang.Float;
import java.lang.Integer;
import java.lang.String;
import java.util.ArrayList;
import java.util.regex.Pattern;
import android.filterfw.core.Filter;
import android.filterfw.core.FilterFactory;
import android.filterfw.core.FilterGraph;
import android.filterfw.core.KeyValueMap;
import android.filterfw.core.ProtocolException;
import android.filterfw.io.GraphReader;
import android.filterfw.io.GraphIOException;
import android.filterfw.io.PatternScanner;
/**
* @hide
*/
public class TextGraphReader extends GraphReader {
private ArrayList<Command> mCommands = new ArrayList<Command>();
private Filter mCurrentFilter;
private FilterGraph mCurrentGraph;
private KeyValueMap mBoundReferences;
private KeyValueMap mSettings;
private FilterFactory mFactory;
private interface Command {
public void execute(TextGraphReader reader) throws GraphIOException;
}
private class ImportPackageCommand implements Command {
private String mPackageName;
public ImportPackageCommand(String packageName) {
mPackageName = packageName;
}
@Override
public void execute(TextGraphReader reader) throws GraphIOException {
try {
reader.mFactory.addPackage(mPackageName);
} catch (IllegalArgumentException e) {
throw new GraphIOException(e.getMessage());
}
}
}
private class AddLibraryCommand implements Command {
private String mLibraryName;
public AddLibraryCommand(String libraryName) {
mLibraryName = libraryName;
}
@Override
public void execute(TextGraphReader reader) {
reader.mFactory.addFilterLibrary(mLibraryName);
}
}
private class AllocateFilterCommand implements Command {
private String mClassName;
private String mFilterName;
public AllocateFilterCommand(String className, String filterName) {
mClassName = className;
mFilterName = filterName;
}
public void execute(TextGraphReader reader) throws GraphIOException {
// Create the filter
Filter filter = null;
try {
filter = reader.mFactory.createFilterByClassName(mClassName, mFilterName);
} catch (IllegalArgumentException e) {
throw new GraphIOException(e.getMessage());
}
// Set it as the current filter
reader.mCurrentFilter = filter;
}
}
private class InitFilterCommand implements Command {
private KeyValueMap mParams;
public InitFilterCommand(KeyValueMap params) {
mParams = params;
}
@Override
public void execute(TextGraphReader reader) throws GraphIOException {
Filter filter = reader.mCurrentFilter;
try {
filter.initWithValueMap(mParams);
} catch (ProtocolException e) {
throw new GraphIOException(e.getMessage());
}
reader.mCurrentGraph.addFilter(mCurrentFilter);
}
}
private class ConnectCommand implements Command {
private String mSourceFilter;
private String mSourcePort;
private String mTargetFilter;
private String mTargetName;
public ConnectCommand(String sourceFilter,
String sourcePort,
String targetFilter,
String targetName) {
mSourceFilter = sourceFilter;
mSourcePort = sourcePort;
mTargetFilter = targetFilter;
mTargetName = targetName;
}
@Override
public void execute(TextGraphReader reader) {
reader.mCurrentGraph.connect(mSourceFilter, mSourcePort, mTargetFilter, mTargetName);
}
}
@Override
public FilterGraph readGraphString(String graphString) throws GraphIOException {
FilterGraph result = new FilterGraph();
reset();
mCurrentGraph = result;
parseString(graphString);
applySettings();
executeCommands();
reset();
return result;
}
private void reset() {
mCurrentGraph = null;
mCurrentFilter = null;
mCommands.clear();
mBoundReferences = new KeyValueMap();
mSettings = new KeyValueMap();
mFactory = new FilterFactory();
}
private void parseString(String graphString) throws GraphIOException {
final Pattern commandPattern = Pattern.compile("@[a-zA-Z]+");
final Pattern curlyClosePattern = Pattern.compile("\\}");
final Pattern curlyOpenPattern = Pattern.compile("\\{");
final Pattern ignorePattern = Pattern.compile("(\\s+|//[^\\n]*\\n)+");
final Pattern packageNamePattern = Pattern.compile("[a-zA-Z\\.]+");
final Pattern libraryNamePattern = Pattern.compile("[a-zA-Z\\./:]+");
final Pattern portPattern = Pattern.compile("\\[[a-zA-Z0-9\\-_]+\\]");
final Pattern rightArrowPattern = Pattern.compile("=>");
final Pattern semicolonPattern = Pattern.compile(";");
final Pattern wordPattern = Pattern.compile("[a-zA-Z0-9\\-_]+");
final int STATE_COMMAND = 0;
final int STATE_IMPORT_PKG = 1;
final int STATE_ADD_LIBRARY = 2;
final int STATE_FILTER_CLASS = 3;
final int STATE_FILTER_NAME = 4;
final int STATE_CURLY_OPEN = 5;
final int STATE_PARAMETERS = 6;
final int STATE_CURLY_CLOSE = 7;
final int STATE_SOURCE_FILTERNAME = 8;
final int STATE_SOURCE_PORT = 9;
final int STATE_RIGHT_ARROW = 10;
final int STATE_TARGET_FILTERNAME = 11;
final int STATE_TARGET_PORT = 12;
final int STATE_ASSIGNMENT = 13;
final int STATE_EXTERNAL = 14;
final int STATE_SETTING = 15;
final int STATE_SEMICOLON = 16;
int state = STATE_COMMAND;
PatternScanner scanner = new PatternScanner(graphString, ignorePattern);
String curClassName = null;
String curSourceFilterName = null;
String curSourcePortName = null;
String curTargetFilterName = null;
String curTargetPortName = null;
// State machine main loop
while (!scanner.atEnd()) {
switch (state) {
case STATE_COMMAND: {
String curCommand = scanner.eat(commandPattern, "<command>");
if (curCommand.equals("@import")) {
state = STATE_IMPORT_PKG;
} else if (curCommand.equals("@library")) {
state = STATE_ADD_LIBRARY;
} else if (curCommand.equals("@filter")) {
state = STATE_FILTER_CLASS;
} else if (curCommand.equals("@connect")) {
state = STATE_SOURCE_FILTERNAME;
} else if (curCommand.equals("@set")) {
state = STATE_ASSIGNMENT;
} else if (curCommand.equals("@external")) {
state = STATE_EXTERNAL;
} else if (curCommand.equals("@setting")) {
state = STATE_SETTING;
} else {
throw new GraphIOException("Unknown command '" + curCommand + "'!");
}
break;
}
case STATE_IMPORT_PKG: {
String packageName = scanner.eat(packageNamePattern, "<package-name>");
mCommands.add(new ImportPackageCommand(packageName));
state = STATE_SEMICOLON;
break;
}
case STATE_ADD_LIBRARY: {
String libraryName = scanner.eat(libraryNamePattern, "<library-name>");
mCommands.add(new AddLibraryCommand(libraryName));
state = STATE_SEMICOLON;
break;
}
case STATE_FILTER_CLASS:
curClassName = scanner.eat(wordPattern, "<class-name>");
state = STATE_FILTER_NAME;
break;
case STATE_FILTER_NAME: {
String curFilterName = scanner.eat(wordPattern, "<filter-name>");
mCommands.add(new AllocateFilterCommand(curClassName, curFilterName));
state = STATE_CURLY_OPEN;
break;
}
case STATE_CURLY_OPEN:
scanner.eat(curlyOpenPattern, "{");
state = STATE_PARAMETERS;
break;
case STATE_PARAMETERS: {
KeyValueMap params = readKeyValueAssignments(scanner, curlyClosePattern);
mCommands.add(new InitFilterCommand(params));
state = STATE_CURLY_CLOSE;
break;
}
case STATE_CURLY_CLOSE:
scanner.eat(curlyClosePattern, "}");
state = STATE_COMMAND;
break;
case STATE_SOURCE_FILTERNAME:
curSourceFilterName = scanner.eat(wordPattern, "<source-filter-name>");
state = STATE_SOURCE_PORT;
break;
case STATE_SOURCE_PORT: {
String portString = scanner.eat(portPattern, "[<source-port-name>]");
curSourcePortName = portString.substring(1, portString.length() - 1);
state = STATE_RIGHT_ARROW;
break;
}
case STATE_RIGHT_ARROW:
scanner.eat(rightArrowPattern, "=>");
state = STATE_TARGET_FILTERNAME;
break;
case STATE_TARGET_FILTERNAME:
curTargetFilterName = scanner.eat(wordPattern, "<target-filter-name>");
state = STATE_TARGET_PORT;
break;
case STATE_TARGET_PORT: {
String portString = scanner.eat(portPattern, "[<target-port-name>]");
curTargetPortName = portString.substring(1, portString.length() - 1);
mCommands.add(new ConnectCommand(curSourceFilterName,
curSourcePortName,
curTargetFilterName,
curTargetPortName));
state = STATE_SEMICOLON;
break;
}
case STATE_ASSIGNMENT: {
KeyValueMap assignment = readKeyValueAssignments(scanner, semicolonPattern);
mBoundReferences.putAll(assignment);
state = STATE_SEMICOLON;
break;
}
case STATE_EXTERNAL: {
String externalName = scanner.eat(wordPattern, "<external-identifier>");
bindExternal(externalName);
state = STATE_SEMICOLON;
break;
}
case STATE_SETTING: {
KeyValueMap setting = readKeyValueAssignments(scanner, semicolonPattern);
mSettings.putAll(setting);
state = STATE_SEMICOLON;
break;
}
case STATE_SEMICOLON:
scanner.eat(semicolonPattern, ";");
state = STATE_COMMAND;
break;
}
}
// Make sure end of input was expected
if (state != STATE_SEMICOLON && state != STATE_COMMAND) {
throw new GraphIOException("Unexpected end of input!");
}
}
@Override
public KeyValueMap readKeyValueAssignments(String assignments) throws GraphIOException {
final Pattern ignorePattern = Pattern.compile("\\s+");
PatternScanner scanner = new PatternScanner(assignments, ignorePattern);
return readKeyValueAssignments(scanner, null);
}
private KeyValueMap readKeyValueAssignments(PatternScanner scanner,
Pattern endPattern) throws GraphIOException {
// Our parser is a state-machine, and these are our states
final int STATE_IDENTIFIER = 0;
final int STATE_EQUALS = 1;
final int STATE_VALUE = 2;
final int STATE_POST_VALUE = 3;
final Pattern equalsPattern = Pattern.compile("=");
final Pattern semicolonPattern = Pattern.compile(";");
final Pattern wordPattern = Pattern.compile("[a-zA-Z]+[a-zA-Z0-9]*");
final Pattern stringPattern = Pattern.compile("'[^']*'|\\\"[^\\\"]*\\\"");
final Pattern intPattern = Pattern.compile("[0-9]+");
final Pattern floatPattern = Pattern.compile("[0-9]*\\.[0-9]+f?");
final Pattern referencePattern = Pattern.compile("\\$[a-zA-Z]+[a-zA-Z0-9]");
final Pattern booleanPattern = Pattern.compile("true|false");
int state = STATE_IDENTIFIER;
KeyValueMap newVals = new KeyValueMap();
String curKey = null;
String curValue = null;
while (!scanner.atEnd() && !(endPattern != null && scanner.peek(endPattern))) {
switch (state) {
case STATE_IDENTIFIER:
curKey = scanner.eat(wordPattern, "<identifier>");
state = STATE_EQUALS;
break;
case STATE_EQUALS:
scanner.eat(equalsPattern, "=");
state = STATE_VALUE;
break;
case STATE_VALUE:
if ((curValue = scanner.tryEat(stringPattern)) != null) {
newVals.put(curKey, curValue.substring(1, curValue.length() - 1));
} else if ((curValue = scanner.tryEat(referencePattern)) != null) {
String refName = curValue.substring(1, curValue.length());
Object referencedObject = mBoundReferences != null
? mBoundReferences.get(refName)
: null;
if (referencedObject == null) {
throw new GraphIOException(
"Unknown object reference to '" + refName + "'!");
}
newVals.put(curKey, referencedObject);
} else if ((curValue = scanner.tryEat(booleanPattern)) != null) {
newVals.put(curKey, Boolean.parseBoolean(curValue));
} else if ((curValue = scanner.tryEat(floatPattern)) != null) {
newVals.put(curKey, Float.parseFloat(curValue));
} else if ((curValue = scanner.tryEat(intPattern)) != null) {
newVals.put(curKey, Integer.parseInt(curValue));
} else {
throw new GraphIOException(scanner.unexpectedTokenMessage("<value>"));
}
state = STATE_POST_VALUE;
break;
case STATE_POST_VALUE:
scanner.eat(semicolonPattern, ";");
state = STATE_IDENTIFIER;
break;
}
}
// Make sure end is expected
if (state != STATE_IDENTIFIER && state != STATE_POST_VALUE) {
throw new GraphIOException(
"Unexpected end of assignments on line " + scanner.lineNo() + "!");
}
return newVals;
}
private void bindExternal(String name) throws GraphIOException {
if (mReferences.containsKey(name)) {
Object value = mReferences.get(name);
mBoundReferences.put(name, value);
} else {
throw new GraphIOException("Unknown external variable '" + name + "'! "
+ "You must add a reference to this external in the host program using "
+ "addReference(...)!");
}
}
/**
* Unused for now: Often you may want to declare references that are NOT in a certain graph,
* e.g. when reading multiple graphs with the same reader. We could print a warning, but even
* that may be too much.
**/
private void checkReferences() throws GraphIOException {
for (String reference : mReferences.keySet()) {
if (!mBoundReferences.containsKey(reference)) {
throw new GraphIOException(
"Host program specifies reference to '" + reference + "', which is not "
+ "declared @external in graph file!");
}
}
}
private void applySettings() throws GraphIOException {
for (String setting : mSettings.keySet()) {
Object value = mSettings.get(setting);
if (setting.equals("autoBranch")) {
expectSettingClass(setting, value, String.class);
if (value.equals("synced")) {
mCurrentGraph.setAutoBranchMode(FilterGraph.AUTOBRANCH_SYNCED);
} else if (value.equals("unsynced")) {
mCurrentGraph.setAutoBranchMode(FilterGraph.AUTOBRANCH_UNSYNCED);
} else if (value.equals("off")) {
mCurrentGraph.setAutoBranchMode(FilterGraph.AUTOBRANCH_OFF);
} else {
throw new GraphIOException("Unknown autobranch setting: " + value + "!");
}
} else if (setting.equals("discardUnconnectedOutputs")) {
expectSettingClass(setting, value, Boolean.class);
mCurrentGraph.setDiscardUnconnectedOutputs((Boolean)value);
} else {
throw new GraphIOException("Unknown @setting '" + setting + "'!");
}
}
}
private void expectSettingClass(String setting,
Object value,
Class expectedClass) throws GraphIOException {
if (value.getClass() != expectedClass) {
throw new GraphIOException("Setting '" + setting + "' must have a value of type "
+ expectedClass.getSimpleName() + ", but found a value of type "
+ value.getClass().getSimpleName() + "!");
}
}
private void executeCommands() throws GraphIOException {
for (Command command : mCommands) {
command.execute(this);
}
}
}
|
