/*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* PropertyPath.java
* Copyright (C) 2006-2012 University of Waikato, Hamilton, New Zealand
*/
package weka.core;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* A helper class for accessing properties in nested objects, e.g., accessing
* the "getRidge" method of a LinearRegression classifier part of
* MultipleClassifierCombiner, e.g., Vote. For doing so, one needs to
* supply the object to work on and a property path. The property path is a
* dot delimited path of property names ("getFoo()" and "setFoo(int)" have
* "foo" as property name), indices of arrays are 0-based. E.g.: <p/>
*
* <code>getPropertyDescriptor(vote, "classifiers[1].ridge")</code> will return
* the second classifier (which should be our LinearRegression) of the given
* Vote meta-classifier and there the property descriptor of the "ridge"
* property. <code>getValue(...)</code> will return the actual value of the
* ridge parameter and <code>setValue(...)</code> will set it.
*
* @author fracpete (fracpete at waikato dot ac dot nz)
* @version $Revision: 8034 $
*/
public class PropertyPath
implements RevisionHandler {
/**
* Represents a single element of a property path
*
* @author fracpete (fracpete at waikato dot ac dot nz)
* @version $Revision: 8034 $
*/
public static class PathElement
implements Cloneable, RevisionHandler {
/** the property */
protected String m_Name;
/** the index of the array (-1 for none) */
protected int m_Index;
/**
* initializes the path element with the given property
*
* @param property the property to initialize with
*/
public PathElement(String property) {
super();
if (property.indexOf("[") > -1) {
m_Name = property.replaceAll("\\[.*$", "");
m_Index = Integer.parseInt(
property.replaceAll(".*\\[", "").replaceAll("\\].*", ""));
}
else {
m_Name = property;
m_Index = -1;
}
}
/**
* returns a clone of the current object
*
* @return the clone of the current state
*/
public Object clone() {
return new PathElement(this.toString());
}
/**
* returns the name of the property
*
* @return the name of the property
*/
public String getName() {
return m_Name;
}
/**
* returns whether the property is an index-based one
*
* @return true if the property has an index
*/
public boolean hasIndex() {
return (getIndex() > -1);
}
/**
* returns the index of the property, -1 if the property is not an
* index-based one
*
* @return the index of the property
*/
public int getIndex() {
return m_Index;
}
/**
* returns the element once again as string
*
* @return the property as string
*/
public String toString() {
String result;
result = getName();
if (hasIndex())
result += "[" + getIndex() + "]";
return result;
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 8034 $");
}
}
/**
* Contains a (property) path structure
*
* @author fracpete (fracpete at waikato dot ac dot nz)
* @version $Revision: 8034 $
*/
public static class Path
implements RevisionHandler {
/** the structure */
protected Vector<PathElement> m_Elements;
/**
* default constructor, only used internally
*/
protected Path() {
super();
m_Elements = new Vector<PathElement>();
}
/**
* uses the given dot-path
*
* @param path path in dot-notation
*/
public Path(String path) {
this();
m_Elements = breakUp(path);
}
/**
* uses the vector with PathElement objects to initialize with
*
* @param elements the PathElements to use
*/
public Path(Vector<PathElement> elements) {
this();
for (int i = 0; i < elements.size(); i++)
m_Elements.add((PathElement) elements.get(i).clone());
}
/**
* uses the given array as elements for the path
*
* @param elements the path elements to use
*/
public Path(String[] elements) {
this();
for (int i = 0; i < elements.length; i++)
m_Elements.add(new PathElement(elements[i]));
}
/**
* breaks up the given path and returns it as vector
*
* @param path the path to break up
* @return the single elements of the path
*/
protected Vector<PathElement> breakUp(String path) {
Vector<PathElement> result;
StringTokenizer tok;
result = new Vector<PathElement>();
tok = new StringTokenizer(path, ".");
while (tok.hasMoreTokens())
result.add(new PathElement(tok.nextToken()));
return result;
}
/**
* returns the element at the given index
*
* @param index the index of the element to return
* @return the specified element
*/
public PathElement get(int index) {
return (PathElement) m_Elements.get(index);
}
/**
* returns the number of path elements of this structure
*
* @return the number of path elements
*/
public int size() {
return m_Elements.size();
}
/**
* returns a path object based on the given path string
*
* @param path path to work on
* @return the path structure
*/
public static Path parsePath(String path) {
return new Path(path);
}
/**
* returns a subpath of the current structure, starting with the specified
* element index up to the end
*
* @param startIndex the first element of the subpath
* @return the new subpath
*/
public Path subpath(int startIndex) {
return subpath(startIndex, size());
}
/**
* returns a subpath of the current structure, starting with the specified
* element index up. The endIndex specifies the element that is not part
* of the new subpath. In other words, the new path contains the elements
* from "startIndex" up to "(endIndex-1)".
*
* @param startIndex the first element of the subpath
* @param endIndex the element that is after the last added element
* @return the new subpath
*/
public Path subpath(int startIndex, int endIndex) {
Vector<PathElement> list;
int i;
list = new Vector<PathElement>();
for (i = startIndex; i < endIndex; i++)
list.add(get(i));
return new Path(list);
}
/**
* returns the structure again as a dot-path
*
* @return the path structure as dot-path
*/
public String toString() {
String result;
int i;
result = "";
for (i = 0; i < m_Elements.size(); i++) {
if (i > 0)
result += ".";
result += m_Elements.get(i);
}
return result;
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 8034 $");
}
}
/**
* A helper class that stores Object and PropertyDescriptor together.
*
* @author fracpete (fracpete at waikato dot ac dot nz)
* @version $Revision: 8034 $
*/
protected static class PropertyContainer
implements RevisionHandler {
/** the descriptor */
protected PropertyDescriptor m_Descriptor;
/** the associated object */
protected Object m_Object;
/**
* initializes the container
*
* @param desc the property descriptor
* @param obj the associated object
*/
public PropertyContainer(PropertyDescriptor desc, Object obj) {
super();
m_Descriptor = desc;
m_Object = obj;
}
/**
* returns the stored descriptor
*
* @return the stored descriptor
*/
public PropertyDescriptor getDescriptor() {
return m_Descriptor;
}
/**
* returns the stored object
*
* @return the stored object
*/
public Object getObject() {
return m_Object;
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 8034 $");
}
}
/**
* returns the property and object associated with the given path, null if
* a problem occurred.
*
* @param src the object to start from
* @param path the path to follow
* @return not null, if the property could be found
*/
public static PropertyContainer find(Object src, Path path) {
PropertyContainer result;
PropertyDescriptor desc;
Object newSrc;
PathElement part;
Method method;
Object methodResult;
// get descriptor
part = path.get(0);
try {
desc = new PropertyDescriptor(part.getName(), src.getClass());
}
catch (Exception e) {
desc = null;
e.printStackTrace();
}
// problem occurred? -> stop
if (desc == null)
return null;
// end of path reached?
if (path.size() == 1) {
result = new PropertyContainer(desc, src);
}
// recurse further
else {
try {
method = desc.getReadMethod();
methodResult = method.invoke(src, (Object[]) null);
if (part.hasIndex())
newSrc = Array.get(methodResult, part.getIndex());
else
newSrc = methodResult;
result = find(newSrc, path.subpath(1));
}
catch (Exception e) {
result = null;
e.printStackTrace();
}
}
return result;
}
/**
* returns the property associated with the given path, null if a problem
* occurred.
*
* @param src the object to start from
* @param path the path to follow
* @return not null, if the property could be found
*/
public static PropertyDescriptor getPropertyDescriptor(Object src, Path path) {
PropertyContainer cont;
cont = find(src, path);
if (cont == null)
return null;
else
return cont.getDescriptor();
}
/**
* returns the property associated with the given path
*
* @param src the object to start from
* @param path the path to follow
* @return not null, if the property could be found
*/
public static PropertyDescriptor getPropertyDescriptor(Object src, String path) {
return getPropertyDescriptor(src, new Path(path));
}
/**
* returns the value specified by the given path from the object
*
* @param src the object to work on
* @param path the retrieval path
* @return the value, null if an error occurred
*/
public static Object getValue(Object src, Path path) {
Object result;
PropertyContainer cont;
Method method;
Object methodResult;
PathElement part;
result = null;
cont = find(src, path);
// problem?
if (cont == null)
return null;
// retrieve the value
try {
part = path.get(path.size() - 1);
method = cont.getDescriptor().getReadMethod();
methodResult = method.invoke(cont.getObject(), (Object[]) null);
if (part.hasIndex())
result = Array.get(methodResult, part.getIndex());
else
result = methodResult;
}
catch (Exception e) {
result = null;
e.printStackTrace();
}
return result;
}
/**
* returns the value specified by the given path from the object
*
* @param src the object to work on
* @param path the retrieval path
* @return the value, null if an error occurred
*/
public static Object getValue(Object src, String path) {
return getValue(src, new Path(path));
}
/**
* set the given value specified by the given path in the object
*
* @param src the object to work on
* @param path the retrieval path
* @param value the value to set
* @return true if the value could be set
*/
public static boolean setValue(Object src, Path path, Object value) {
boolean result;
PropertyContainer cont;
Method methodRead;
Method methodWrite;
Object methodResult;
PathElement part;
result = false;
cont = find(src, path);
// problem?
if (cont == null)
return result;
// set the value
try {
part = path.get(path.size() - 1);
methodRead = cont.getDescriptor().getReadMethod();
methodWrite = cont.getDescriptor().getWriteMethod();
if (part.hasIndex()) {
methodResult = methodRead.invoke(cont.getObject(), (Object[]) null);
Array.set(methodResult, part.getIndex(), value);
methodWrite.invoke(cont.getObject(), new Object[]{methodResult});
}
else {
methodWrite.invoke(cont.getObject(), new Object[]{value});
}
result = true;
}
catch (Exception e) {
result = false;
e.printStackTrace();
}
return result;
}
/**
* set the given value specified by the given path in the object
*
* @param src the object to work on
* @param path the retrieval path
* @param value the value to set
*/
public static void setValue(Object src, String path, Object value) {
setValue(src, new Path(path), value);
}
/**
* Returns the revision string.
*
* @return the revision
*/
public String getRevision() {
return RevisionUtils.extract("$Revision: 8034 $");
}
/**
* for testing only
*
* @param args the commandline options - ignored
* @throws Exception if something goes wrong
*/
public static void main(String[] args) throws Exception {
// Path
Path path = new Path("hello.world[2].nothing");
System.out.println("Path: " + path);
System.out.println(" -size: " + path.size());
System.out.println(" -elements:");
for (int i = 0; i < path.size(); i++)
System.out.println(
" " + i + ". " + path.get(i).getName()
+ " -> " + path.get(i).getIndex());
/*
// retrieving ridge with path
weka.classifiers.meta.Vote vote = new weka.classifiers.meta.Vote();
vote.setClassifiers(
new weka.classifiers.Classifier[]{
new weka.classifiers.trees.J48(),
new weka.classifiers.functions.LinearRegression()});
path = new Path("classifiers[1].ridge");
System.out.println("path: " + path + " -> " + getValue(vote, path));
// setting ridge with path and retrieving it again
setValue(vote, path.toString(), new Double(0.1));
System.out.println("path: " + path + " -> " + getValue(vote, path));
*/
}
}