android.databinding.tool.store.ResourceBundle Maven / Gradle / Ivy
/*
* Copyright (C) 2015 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.databinding.tool.store;
import android.databinding.tool.processing.ErrorMessages;
import android.databinding.tool.processing.Scope;
import android.databinding.tool.processing.ScopedException;
import android.databinding.tool.processing.scopes.FileScopeProvider;
import android.databinding.tool.processing.scopes.LocationScopeProvider;
import android.databinding.tool.util.L;
import android.databinding.tool.util.ParserHelper;
import android.databinding.tool.util.Preconditions;
import java.io.File;
import java.io.InputStream;
import java.io.Serializable;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
/**
* This is a serializable class that can keep the result of parsing layout files.
*/
public class ResourceBundle implements Serializable {
private static final String[] ANDROID_VIEW_PACKAGE_VIEWS = new String[]
{"View", "ViewGroup", "ViewStub", "TextureView", "SurfaceView"};
private String mAppPackage;
private HashMap> mLayoutBundles
= new HashMap>();
private List mRemovedFiles = new ArrayList();
public ResourceBundle(String appPackage) {
mAppPackage = appPackage;
}
public void addLayoutBundle(LayoutFileBundle bundle) {
if (bundle.mFileName == null) {
L.e("File bundle must have a name. %s does not have one.", bundle);
return;
}
if (!mLayoutBundles.containsKey(bundle.mFileName)) {
mLayoutBundles.put(bundle.mFileName, new ArrayList());
}
final List bundles = mLayoutBundles.get(bundle.mFileName);
for (LayoutFileBundle existing : bundles) {
if (existing.equals(bundle)) {
L.d("skipping layout bundle %s because it already exists.", bundle);
return;
}
}
L.d("adding bundle %s", bundle);
bundles.add(bundle);
}
public HashMap> getLayoutBundles() {
return mLayoutBundles;
}
public String getAppPackage() {
return mAppPackage;
}
public void validateMultiResLayouts() {
for (List layoutFileBundles : mLayoutBundles.values()) {
for (LayoutFileBundle layoutFileBundle : layoutFileBundles) {
List unboundIncludes = new ArrayList();
for (BindingTargetBundle target : layoutFileBundle.getBindingTargetBundles()) {
if (target.isBinder()) {
List boundTo =
mLayoutBundles.get(target.getIncludedLayout());
if (boundTo == null || boundTo.isEmpty()) {
L.d("There is no binding for %s, reverting to plain layout",
target.getIncludedLayout());
if (target.getId() == null) {
unboundIncludes.add(target);
} else {
target.setIncludedLayout(null);
target.setInterfaceType("android.view.View");
target.mViewName = "android.view.View";
}
} else {
String binding = boundTo.get(0).getFullBindingClass();
target.setInterfaceType(binding);
}
}
}
layoutFileBundle.getBindingTargetBundles().removeAll(unboundIncludes);
}
}
for (Map.Entry> bundles : mLayoutBundles.entrySet()) {
if (bundles.getValue().size() < 2) {
continue;
}
// validate all ids are in correct view types
// and all variables have the same name
for (LayoutFileBundle bundle : bundles.getValue()) {
bundle.mHasVariations = true;
}
String bindingClass = validateAndGetSharedClassName(bundles.getValue());
Map variableTypes = validateAndMergeNameTypeLocations(
bundles.getValue(), ErrorMessages.MULTI_CONFIG_VARIABLE_TYPE_MISMATCH,
new ValidateAndFilterCallback() {
@Override
public List get(LayoutFileBundle bundle) {
return bundle.mVariables;
}
});
Map importTypes = validateAndMergeNameTypeLocations(
bundles.getValue(), ErrorMessages.MULTI_CONFIG_IMPORT_TYPE_MISMATCH,
new ValidateAndFilterCallback() {
@Override
public List get(LayoutFileBundle bundle) {
return bundle.mImports;
}
});
for (LayoutFileBundle bundle : bundles.getValue()) {
// now add missing ones to each to ensure they can be referenced
L.d("checking for missing variables in %s / %s", bundle.mFileName,
bundle.mConfigName);
for (Map.Entry variable : variableTypes.entrySet()) {
if (!NameTypeLocation.contains(bundle.mVariables, variable.getKey())) {
NameTypeLocation orig = variable.getValue();
bundle.addVariable(orig.name, orig.type, orig.location, false);
L.d("adding missing variable %s to %s / %s", variable.getKey(),
bundle.mFileName, bundle.mConfigName);
}
}
for (Map.Entry userImport : importTypes.entrySet()) {
if (!NameTypeLocation.contains(bundle.mImports, userImport.getKey())) {
bundle.mImports.add(userImport.getValue());
L.d("adding missing import %s to %s / %s", userImport.getKey(),
bundle.mFileName, bundle.mConfigName);
}
}
}
Set includeBindingIds = new HashSet();
Set viewBindingIds = new HashSet();
Map viewTypes = new HashMap();
Map includes = new HashMap();
L.d("validating ids for %s", bundles.getKey());
Set conflictingIds = new HashSet();
for (LayoutFileBundle bundle : bundles.getValue()) {
try {
Scope.enter(bundle);
for (BindingTargetBundle target : bundle.mBindingTargetBundles) {
try {
Scope.enter(target);
L.d("checking %s %s %s", target.getId(), target.getFullClassName(),
target.isBinder());
if (target.mId != null) {
if (target.isBinder()) {
if (viewBindingIds.contains(target.mId)) {
L.d("%s is conflicting", target.mId);
conflictingIds.add(target.mId);
continue;
}
includeBindingIds.add(target.mId);
} else {
if (includeBindingIds.contains(target.mId)) {
L.d("%s is conflicting", target.mId);
conflictingIds.add(target.mId);
continue;
}
viewBindingIds.add(target.mId);
}
String existingType = viewTypes.get(target.mId);
if (existingType == null) {
L.d("assigning %s as %s", target.getId(),
target.getFullClassName());
viewTypes.put(target.mId, target.getFullClassName());
if (target.isBinder()) {
includes.put(target.mId, target.getIncludedLayout());
}
} else if (!existingType.equals(target.getFullClassName())) {
if (target.isBinder()) {
L.d("overriding %s as base binder", target.getId());
viewTypes.put(target.mId,
"android.databinding.ViewDataBinding");
includes.put(target.mId, target.getIncludedLayout());
} else {
L.d("overriding %s as base view", target.getId());
viewTypes.put(target.mId, "android.view.View");
}
}
}
} catch (ScopedException ex) {
Scope.defer(ex);
} finally {
Scope.exit();
}
}
} finally {
Scope.exit();
}
}
if (!conflictingIds.isEmpty()) {
for (LayoutFileBundle bundle : bundles.getValue()) {
for (BindingTargetBundle target : bundle.mBindingTargetBundles) {
if (conflictingIds.contains(target.mId)) {
Scope.registerError(String.format(
ErrorMessages.MULTI_CONFIG_ID_USED_AS_IMPORT,
target.mId), bundle, target);
}
}
}
}
for (LayoutFileBundle bundle : bundles.getValue()) {
try {
Scope.enter(bundle);
for (Map.Entry viewType : viewTypes.entrySet()) {
BindingTargetBundle target = bundle.getBindingTargetById(viewType.getKey());
if (target == null) {
String include = includes.get(viewType.getKey());
if (include == null) {
bundle.createBindingTarget(viewType.getKey(), viewType.getValue(),
false, null, null, null);
} else {
BindingTargetBundle bindingTargetBundle = bundle
.createBindingTarget(
viewType.getKey(), null, false, null, null, null);
bindingTargetBundle
.setIncludedLayout(includes.get(viewType.getKey()));
bindingTargetBundle.setInterfaceType(viewType.getValue());
}
} else {
L.d("setting interface type on %s (%s) as %s", target.mId,
target.getFullClassName(), viewType.getValue());
target.setInterfaceType(viewType.getValue());
}
}
} catch (ScopedException ex) {
Scope.defer(ex);
} finally {
Scope.exit();
}
}
}
// assign class names to each
for (Map.Entry> entry : mLayoutBundles.entrySet()) {
for (LayoutFileBundle bundle : entry.getValue()) {
final String configName;
if (bundle.hasVariations()) {
// append configuration specifiers.
final String parentFileName = bundle.mDirectory;
L.d("parent file for %s is %s", bundle.getFileName(), parentFileName);
if ("layout".equals(parentFileName)) {
configName = "";
} else {
configName = ParserHelper.toClassName(parentFileName.substring("layout-".length()));
}
} else {
configName = "";
}
bundle.mConfigName = configName;
}
}
}
/**
* Receives a list of bundles which are representations of the same layout file in different
* configurations.
* @param bundles
* @return The map for variables and their types
*/
private Map validateAndMergeNameTypeLocations(
List bundles, String errorMessage,
ValidateAndFilterCallback callback) {
Map result = new HashMap();
Set mismatched = new HashSet();
for (LayoutFileBundle bundle : bundles) {
for (NameTypeLocation item : callback.get(bundle)) {
NameTypeLocation existing = result.get(item.name);
if (existing != null && !existing.type.equals(item.type)) {
mismatched.add(item.name);
continue;
}
result.put(item.name, item);
}
}
if (mismatched.isEmpty()) {
return result;
}
// create exceptions. We could get more clever and find the outlier but for now, listing
// each file w/ locations seems enough
for (String mismatch : mismatched) {
for (LayoutFileBundle bundle : bundles) {
NameTypeLocation found = null;
for (NameTypeLocation item : callback.get(bundle)) {
if (mismatch.equals(item.name)) {
found = item;
break;
}
}
if (found == null) {
// variable is not defined in this layout, continue
continue;
}
Scope.registerError(String.format(
errorMessage, found.name, found.type,
bundle.mDirectory + "/" + bundle.getFileName()), bundle,
found.location.createScope());
}
}
return result;
}
/**
* Receives a list of bundles which are representations of the same layout file in different
* configurations.
* @param bundles
* @return The shared class name for these bundles
*/
private String validateAndGetSharedClassName(List bundles) {
String sharedClassName = null;
boolean hasMismatch = false;
for (LayoutFileBundle bundle : bundles) {
bundle.mHasVariations = true;
String fullBindingClass = bundle.getFullBindingClass();
if (sharedClassName == null) {
sharedClassName = fullBindingClass;
} else if (!sharedClassName.equals(fullBindingClass)) {
hasMismatch = true;
break;
}
}
if (!hasMismatch) {
return sharedClassName;
}
// generate proper exceptions for each
for (LayoutFileBundle bundle : bundles) {
Scope.registerError(String.format(ErrorMessages.MULTI_CONFIG_LAYOUT_CLASS_NAME_MISMATCH,
bundle.getFullBindingClass(), bundle.mDirectory + "/" + bundle.getFileName()),
bundle, bundle.getClassNameLocationProvider());
}
return sharedClassName;
}
public void addRemovedFile(File file) {
mRemovedFiles.add(file);
}
public List getRemovedFiles() {
return mRemovedFiles;
}
@XmlAccessorType(XmlAccessType.NONE)
@XmlRootElement(name="Layout")
public static class LayoutFileBundle implements Serializable, FileScopeProvider {
@XmlAttribute(name="layout", required = true)
public String mFileName;
@XmlAttribute(name="modulePackage", required = true)
public String mModulePackage;
@XmlAttribute(name="absoluteFilePath", required = true)
public String mAbsoluteFilePath;
private String mConfigName;
// The binding class as given by the user
@XmlAttribute(name="bindingClass", required = false)
public String mBindingClass;
// The location of the name of the generated class, optional
@XmlElement(name = "ClassNameLocation", required = false)
private Location mClassNameLocation;
// The full package and class name as determined from mBindingClass and mModulePackage
private String mFullBindingClass;
// The simple binding class name as determined from mBindingClass and mModulePackage
private String mBindingClassName;
// The package of the binding class as determined from mBindingClass and mModulePackage
private String mBindingPackage;
@XmlAttribute(name="directory", required = true)
public String mDirectory;
public boolean mHasVariations;
@XmlElement(name="Variables")
public List mVariables = new ArrayList();
@XmlElement(name="Imports")
public List mImports = new ArrayList();
@XmlElementWrapper(name="Targets")
@XmlElement(name="Target")
public List mBindingTargetBundles = new ArrayList();
@XmlAttribute(name="isMerge", required = true)
private boolean mIsMerge;
private LocationScopeProvider mClassNameLocationProvider;
// for XML binding
public LayoutFileBundle() {
}
/**
* Updates configuration fields from the given bundle but does not change variables,
* binding expressions etc.
*/
public void inheritConfigurationFrom(LayoutFileBundle other) {
mFileName = other.mFileName;
mModulePackage = other.mModulePackage;
mBindingClass = other.mBindingClass;
mFullBindingClass = other.mFullBindingClass;
mBindingClassName = other.mBindingClassName;
mBindingPackage = other.mBindingPackage;
mHasVariations = other.mHasVariations;
mIsMerge = other.mIsMerge;
}
public LayoutFileBundle(File file, String fileName, String directory,
String modulePackage, boolean isMerge) {
mFileName = fileName;
mDirectory = directory;
mModulePackage = modulePackage;
mIsMerge = isMerge;
mAbsoluteFilePath = file.getAbsolutePath();
}
public LocationScopeProvider getClassNameLocationProvider() {
if (mClassNameLocationProvider == null && mClassNameLocation != null
&& mClassNameLocation.isValid()) {
mClassNameLocationProvider = mClassNameLocation.createScope();
}
return mClassNameLocationProvider;
}
public void addVariable(String name, String type, Location location, boolean declared) {
Preconditions.check(!NameTypeLocation.contains(mVariables, name),
"Cannot use same variable name twice. %s in %s", name, location);
mVariables.add(new VariableDeclaration(name, type, location, declared));
}
public void addImport(String alias, String type, Location location) {
Preconditions.check(!NameTypeLocation.contains(mImports, alias),
"Cannot import same alias twice. %s in %s", alias, location);
mImports.add(new NameTypeLocation(alias, type, location));
}
public BindingTargetBundle createBindingTarget(String id, String viewName,
boolean used, String tag, String originalTag, Location location) {
BindingTargetBundle target = new BindingTargetBundle(id, viewName, used, tag,
originalTag, location);
mBindingTargetBundles.add(target);
return target;
}
public boolean isEmpty() {
return mVariables.isEmpty() && mImports.isEmpty() && mBindingTargetBundles.isEmpty();
}
public BindingTargetBundle getBindingTargetById(String key) {
for (BindingTargetBundle target : mBindingTargetBundles) {
if (key.equals(target.mId)) {
return target;
}
}
return null;
}
public String getFileName() {
return mFileName;
}
public String getConfigName() {
return mConfigName;
}
public String getDirectory() {
return mDirectory;
}
public boolean hasVariations() {
return mHasVariations;
}
public List getVariables() {
return mVariables;
}
public List getImports() {
return mImports;
}
public boolean isMerge() {
return mIsMerge;
}
public String getBindingClassName() {
if (mBindingClassName == null) {
String fullClass = getFullBindingClass();
int dotIndex = fullClass.lastIndexOf('.');
mBindingClassName = fullClass.substring(dotIndex + 1);
}
return mBindingClassName;
}
public void setBindingClass(String bindingClass, Location location) {
mBindingClass = bindingClass;
mClassNameLocation = location;
}
public String getBindingClassPackage() {
if (mBindingPackage == null) {
String fullClass = getFullBindingClass();
int dotIndex = fullClass.lastIndexOf('.');
mBindingPackage = fullClass.substring(0, dotIndex);
}
return mBindingPackage;
}
private String getFullBindingClass() {
if (mFullBindingClass == null) {
if (mBindingClass == null) {
mFullBindingClass = getModulePackage() + ".databinding." +
ParserHelper.toClassName(getFileName()) + "Binding";
} else if (mBindingClass.startsWith(".")) {
mFullBindingClass = getModulePackage() + mBindingClass;
} else if (mBindingClass.indexOf('.') < 0) {
mFullBindingClass = getModulePackage() + ".databinding." + mBindingClass;
} else {
mFullBindingClass = mBindingClass;
}
}
return mFullBindingClass;
}
public List getBindingTargetBundles() {
return mBindingTargetBundles;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
LayoutFileBundle bundle = (LayoutFileBundle) o;
if (mConfigName != null ? !mConfigName.equals(bundle.mConfigName)
: bundle.mConfigName != null) {
return false;
}
if (mDirectory != null ? !mDirectory.equals(bundle.mDirectory)
: bundle.mDirectory != null) {
return false;
}
return !(mFileName != null ? !mFileName.equals(bundle.mFileName)
: bundle.mFileName != null);
}
@Override
public int hashCode() {
int result = mFileName != null ? mFileName.hashCode() : 0;
result = 31 * result + (mConfigName != null ? mConfigName.hashCode() : 0);
result = 31 * result + (mDirectory != null ? mDirectory.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "LayoutFileBundle{" +
"mHasVariations=" + mHasVariations +
", mDirectory='" + mDirectory + '\'' +
", mConfigName='" + mConfigName + '\'' +
", mModulePackage='" + mModulePackage + '\'' +
", mFileName='" + mFileName + '\'' +
'}';
}
public String getModulePackage() {
return mModulePackage;
}
public String getAbsoluteFilePath() {
return mAbsoluteFilePath;
}
@Override
public String provideScopeFilePath() {
return mAbsoluteFilePath;
}
private static Marshaller sMarshaller;
private static Unmarshaller sUmarshaller;
public String toXML() throws JAXBException {
StringWriter writer = new StringWriter();
getMarshaller().marshal(this, writer);
return writer.getBuffer().toString();
}
public static LayoutFileBundle fromXML(InputStream inputStream) throws JAXBException {
return (LayoutFileBundle) getUnmarshaller().unmarshal(inputStream);
}
private static Marshaller getMarshaller() throws JAXBException {
if (sMarshaller == null) {
JAXBContext context = JAXBContext
.newInstance(ResourceBundle.LayoutFileBundle.class);
sMarshaller = context.createMarshaller();
}
return sMarshaller;
}
private static Unmarshaller getUnmarshaller() throws JAXBException {
if (sUmarshaller == null) {
JAXBContext context = JAXBContext
.newInstance(ResourceBundle.LayoutFileBundle.class);
sUmarshaller = context.createUnmarshaller();
}
return sUmarshaller;
}
}
@XmlAccessorType(XmlAccessType.NONE)
public static class NameTypeLocation {
@XmlAttribute(name="type", required = true)
public String type;
@XmlAttribute(name="name", required = true)
public String name;
@XmlElement(name="location", required = false)
public Location location;
public NameTypeLocation() {
}
public NameTypeLocation(String name, String type, Location location) {
this.type = type;
this.name = name;
this.location = location;
}
@Override
public String toString() {
return "{" +
"type='" + type + '\'' +
", name='" + name + '\'' +
", location=" + location +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
NameTypeLocation that = (NameTypeLocation) o;
if (location != null ? !location.equals(that.location) : that.location != null) {
return false;
}
if (!name.equals(that.name)) {
return false;
}
return type.equals(that.type);
}
@Override
public int hashCode() {
int result = type.hashCode();
result = 31 * result + name.hashCode();
result = 31 * result + (location != null ? location.hashCode() : 0);
return result;
}
public static boolean contains(List list, String name) {
for (NameTypeLocation ntl : list) {
if (name.equals(ntl.name)) {
return true;
}
}
return false;
}
}
@XmlAccessorType(XmlAccessType.NONE)
public static class VariableDeclaration extends NameTypeLocation {
@XmlAttribute(name="declared", required = false)
public boolean declared;
public VariableDeclaration() {
}
public VariableDeclaration(String name, String type, Location location, boolean declared) {
super(name, type, location);
this.declared = declared;
}
}
public static class MarshalledMapType {
public List entries;
}
@XmlAccessorType(XmlAccessType.NONE)
public static class BindingTargetBundle implements Serializable, LocationScopeProvider {
// public for XML serialization
@XmlAttribute(name="id")
public String mId;
@XmlAttribute(name="tag", required = true)
public String mTag;
@XmlAttribute(name="originalTag")
public String mOriginalTag;
@XmlAttribute(name="view", required = false)
public String mViewName;
private String mFullClassName;
public boolean mUsed = true;
@XmlElementWrapper(name="Expressions")
@XmlElement(name="Expression")
public List mBindingBundleList = new ArrayList();
@XmlAttribute(name="include")
public String mIncludedLayout;
@XmlElement(name="location")
public Location mLocation;
private String mInterfaceType;
// For XML serialization
public BindingTargetBundle() {}
public BindingTargetBundle(String id, String viewName, boolean used,
String tag, String originalTag, Location location) {
mId = id;
mViewName = viewName;
mUsed = used;
mTag = tag;
mOriginalTag = originalTag;
mLocation = location;
}
public void addBinding(String name, String expr, boolean isTwoWay, Location location,
Location valueLocation) {
mBindingBundleList.add(new BindingBundle(name, expr, isTwoWay, location, valueLocation));
}
public void setIncludedLayout(String includedLayout) {
mIncludedLayout = includedLayout;
}
public String getIncludedLayout() {
return mIncludedLayout;
}
public boolean isBinder() {
return mIncludedLayout != null;
}
public void setInterfaceType(String interfaceType) {
mInterfaceType = interfaceType;
}
public void setLocation(Location location) {
mLocation = location;
}
public Location getLocation() {
return mLocation;
}
public String getId() {
return mId;
}
public String getTag() {
return mTag;
}
public String getOriginalTag() {
return mOriginalTag;
}
public String getFullClassName() {
if (mFullClassName == null) {
if (isBinder()) {
mFullClassName = mInterfaceType;
} else if (mViewName.indexOf('.') == -1) {
if (Arrays.asList(ANDROID_VIEW_PACKAGE_VIEWS).contains(mViewName)) {
mFullClassName = "android.view." + mViewName;
} else if("WebView".equals(mViewName)) {
mFullClassName = "android.webkit." + mViewName;
} else {
mFullClassName = "android.widget." + mViewName;
}
} else {
mFullClassName = mViewName;
}
}
if (mFullClassName == null) {
L.e("Unexpected full class name = null. view = %s, interface = %s, layout = %s",
mViewName, mInterfaceType, mIncludedLayout);
}
return mFullClassName;
}
public boolean isUsed() {
return mUsed;
}
public List getBindingBundleList() {
return mBindingBundleList;
}
public String getInterfaceType() {
return mInterfaceType;
}
@Override
public List provideScopeLocation() {
return mLocation == null ? null : Arrays.asList(mLocation);
}
@XmlAccessorType(XmlAccessType.NONE)
public static class BindingBundle implements Serializable {
private String mName;
private String mExpr;
private Location mLocation;
private Location mValueLocation;
private boolean mIsTwoWay;
public BindingBundle() {}
public BindingBundle(String name, String expr, boolean isTwoWay, Location location,
Location valueLocation) {
mName = name;
mExpr = expr;
mLocation = location;
mIsTwoWay = isTwoWay;
mValueLocation = valueLocation;
}
@XmlAttribute(name="attribute", required=true)
public String getName() {
return mName;
}
@XmlAttribute(name="text", required=true)
public String getExpr() {
return mExpr;
}
public void setName(String name) {
mName = name;
}
public void setExpr(String expr) {
mExpr = expr;
}
public void setTwoWay(boolean isTwoWay) {
mIsTwoWay = isTwoWay;
}
@XmlElement(name="Location")
public Location getLocation() {
return mLocation;
}
public void setLocation(Location location) {
mLocation = location;
}
@XmlElement(name="ValueLocation")
public Location getValueLocation() {
return mValueLocation;
}
@XmlElement(name="TwoWay")
public boolean isTwoWay() {
return mIsTwoWay;
}
public void setValueLocation(Location valueLocation) {
mValueLocation = valueLocation;
}
}
}
/**
* Just an inner callback class to process imports and variables w/ the same code.
*/
private interface ValidateAndFilterCallback {
List get(LayoutFileBundle bundle);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy