diff options
Diffstat (limited to 'libraries/oscP5/src/oscP5/OscPlug.java')
| -rw-r--r-- | libraries/oscP5/src/oscP5/OscPlug.java | 258 |
1 files changed, 258 insertions, 0 deletions
diff --git a/libraries/oscP5/src/oscP5/OscPlug.java b/libraries/oscP5/src/oscP5/OscPlug.java new file mode 100644 index 0000000..1fcec89 --- /dev/null +++ b/libraries/oscP5/src/oscP5/OscPlug.java @@ -0,0 +1,258 @@ +/** + * An OSC (Open Sound Control) library for processing. + * + * (c) 2004-2012 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General + * Public License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA + * + * @author Andreas Schlegel http://www.sojamo.de + * @modified 12/23/2012 + * @version 0.9.9 + */ + +package oscP5; + +import java.lang.reflect.Method; +import netP5.Logger; + +/** + * + * @invisible + */ +public class OscPlug { + + private boolean _isValid = true; + + private String _myTypetag = ""; + + private String _myAddrPattern = ""; + + private String _myPattern = ""; + + private String _myMethodName; + + private Object _myObject; + + public Method method = null; + + private int _myChecker = 0; + + protected boolean isArray = false; + + private static final int CHECK_ADDRPATTERN_TYPETAG = 0; + + private static final int CHECK_ADDRPATTERN = 1; + + private static final int CHECK_TYPETAG = 2; + + public void plug(final Object theObject, final String theMethodName, + final String theAddrPattern) { + _myObject = theObject; + _myMethodName = theMethodName; + _myAddrPattern = theAddrPattern; + _myChecker = CHECK_ADDRPATTERN_TYPETAG; + if (_myMethodName != null && _myMethodName.length() > 0) { + Class<?> myClass = theObject.getClass(); + Class<?>[] myParams = null; + Method[] myMethods = myClass.getMethods(); + _myTypetag = ""; + for (int i = 0; i < myMethods.length; i++) { + if ((myMethods[i].getName()).equals(_myMethodName)) { + myParams = myMethods[i].getParameterTypes(); + for (int j = 0; j < myParams.length; j++) { + _myTypetag += checkType(myParams[j].getName()); + } + break; + } + } + if (myParams != null) { + makeMethod(theObject.getClass(), myParams); + } else { + Logger.printWarning("OscPlug.plug()", + "no arguments found for method " + _myMethodName); + } + } + } + + public void plug(final Object theObject, final String theMethodName, + final String theAddrPattern, final String theTypetag) { + _myObject = theObject; + _myMethodName = theMethodName; + _myAddrPattern = theAddrPattern; + _myTypetag = theTypetag; + _myChecker = CHECK_ADDRPATTERN_TYPETAG; + + if (_myMethodName != null && _myMethodName.length() > 0) { + int tLen = _myTypetag.length(); + Class<?>[] myParams; + if (tLen > 0) { + myParams = getArgs(_myTypetag); + } else { + myParams = null; + } + + if (_isValid) { + makeMethod(theObject.getClass(), myParams); + } + } + } + + public Object getObject() { + return _myObject; + } + + private void makeMethod(final Class<?> theObjectsClass, final Class<?>[] theClass) { + try { + method = theObjectsClass.getDeclaredMethod(_myMethodName, theClass); + _myPattern = _myAddrPattern + _myTypetag; + method.setAccessible(true); + Logger.printProcess("OscPlug", "plugging " + theObjectsClass + + " | " + "addrPattern:" + _myAddrPattern + " typetag:" + + _myTypetag + " method:" + _myMethodName); + + } catch (Exception e) { + final Class<?> theObjecsSuperClass = theObjectsClass.getSuperclass(); + if (theObjecsSuperClass.equals(Object.class)) { + if (theObjectsClass.getName().equals("java.awt.Component") == false) { // applet fix. + Logger.printError("OscPlug", "method " + + theObjectsClass.getName() + + " does not exist in your code."); + } + } else { + makeMethod(theObjecsSuperClass, theClass); + } + } + return; + } + + public boolean checkMethod(final OscMessage theOscMessage, + final boolean isArray) { + String myTypetag; + /* + * if theFlag is true and the arguments of theOscmessage can be + * represented as an array of the same type, then only fetch the first + * character of the typetag, otherwise use the full typetag. + */ + if (isArray) { + myTypetag = "" + theOscMessage.typetag().charAt(0); + } else { + myTypetag = theOscMessage.typetag(); + } + switch (_myChecker) { + case (CHECK_ADDRPATTERN_TYPETAG): + String thePattern = theOscMessage.addrPattern() + myTypetag; + return thePattern.equals(_myPattern); + case (CHECK_ADDRPATTERN): + return (theOscMessage.addrPattern().equals(_myAddrPattern)); + case (CHECK_TYPETAG): + return (myTypetag.equals(_myTypetag)); + default: + return false; + } + } + + public Method getMethod() { + return method; + } + + + public String checkType(final String theName) { + if (theName.equals("int")) { + return "i"; + } else if (theName.equals("float")) { + return "f"; + } else if (theName.equals("java.lang.String")) { + return "s"; + } else if (theName.equals("[Ljava.lang.String;")) { + isArray = true; + return "s"; + } + + else if (theName.equals("char")) { + return "c"; + } else if (theName.equals("[B")) { + return "b"; + } else if (theName.equals("[F")) { + isArray = true; + return "f"; + } else if (theName.equals("[I")) { + isArray = true; + return "i"; + } + + else if (theName.equals("double")) { + return "d"; + } else if (theName.equals("boolean")) { + return "T"; + } else if (theName.equals("long")) { + return "h"; + } + return ""; + } + + private Class<?>[] getArgs(final String theArgs) { + char[] tChar = theArgs.toCharArray(); + int tLen = theArgs.length(); + Class<?>[] tClass = new Class[tLen]; + for (int i = 0; i < tLen; i++) { + switch (tChar[i]) { + case ('i'): + tClass[i] = (isArray == true) ? int[].class : int.class; + break; + case ('S'): + case ('s'): + tClass[i] = (isArray == true) ? String[].class : String.class; + break; + case ('f'): + tClass[i] = (isArray == true) ? float[].class : float.class; + break; + case ('d'): + tClass[i] = double.class; + break; + case ('c'): + tClass[i] = char.class; + break; + case ('h'): + case ('l'): + tClass[i] = long.class; + break; + case ('T'): + tClass[i] = boolean.class; + break; + case ('F'): + tClass[i] = boolean.class; + break; + case ('b'): + tClass[i] = byte[].class; + break; + case ('o'): + _myChecker = CHECK_ADDRPATTERN; + tClass = new Class[] { Object[].class }; + break; + + default: + _isValid = false; + break; + } + } + if (!_isValid) { + tClass = null; + System.out.println("ERROR could't plug method " + _myMethodName); + } + return tClass; + } + +} |