diff options
Diffstat (limited to 'src')
56 files changed, 5816 insertions, 102 deletions
diff --git a/src/bindings/CMakeLists.txt b/src/bindings/CMakeLists.txt new file mode 100644 index 0000000..57388f2 --- /dev/null +++ b/src/bindings/CMakeLists.txt @@ -0,0 +1,46 @@ +# if you build swig from sources on windows, this is where it will end up +# see also: http://www.swig.org/Doc2.0/Windows.html#Windows_mingw_msys +if (CMAKE_CROSSCOMPILING) + return() +endif() + +if (WIN32) + if(EXISTS "${PROJECT_BINARY_DIR}/../swig/") + LIST(APPEND CMAKE_PROGRAM_PATH "${PROJECT_BINARY_DIR}/../swig/") + elseif(EXISTS "${PROJECT_BINARY_DIR}/../../swig/") + LIST(APPEND CMAKE_PROGRAM_PATH "${PROJECT_BINARY_DIR}/../../swig/") + endif() + + file(GLOB POTENTIAL_SWIG "C:/Program Files/swig*" "C:/Program Files (x86)/swig*") + LIST(APPEND CMAKE_PROGRAM_PATH ${POTENTIAL_SWIG}) # swig.exe + # message(FATAL_ERROR "POTENTIAL_SWIG: ${POTENTIAL_SWIG}") + +endif() +LIST(APPEND CMAKE_PROGRAM_PATH $ENV{SWIG_DIR}) + +find_package(SWIG) + +if (SWIG_FOUND) + if(SWIG_VERSION VERSION_GREATER 2.0.4) + MARK_AS_ADVANCED(SWIG_DIR SWIG_EXECUTABLE SWIG_VERSION) + INCLUDE(${SWIG_USE_FILE}) + if (BUILD_BINDING_JAVA) + add_subdirectory(swig/java) + endif() + # if (BUILD_BINDING_CSHARP) + # add_subdirectory(swig/csharp) + # endif() + # if (BUILD_BINDING_PHP) + # add_subdirectory(swig/php) + # endif() + + if(SWIG_VERSION VERSION_LESS 3.0.0) + message(STATUS "SWIG version > 3.0 is recommended, found ${SWIG_VERSION}") + endif() + else() + message(STATUS "SWIG version 2.0.5 is required, found ${SWIG_VERSION} - skipping wrapper generation") + endif() +else() + message(STATUS "SWIG not found - skipping wrapper generation") +endif() +set(USCXML_LANGUAGE_BINDINGS ${USCXML_LANGUAGE_BINDINGS} PARENT_SCOPE) diff --git a/src/bindings/swig/csharp/CMakeLists.txt b/src/bindings/swig/csharp/CMakeLists.txt new file mode 100644 index 0000000..384507b --- /dev/null +++ b/src/bindings/swig/csharp/CMakeLists.txt @@ -0,0 +1,88 @@ +# generate JNI library and create a jar +# Make from within Eclipse fails miserably with the whole thing + +if (WIN32) + LIST(APPEND CMAKE_PROGRAM_PATH "C:/Windows/Microsoft.NET/Framework/v3.5") # CSharp compiler + LIST(APPEND CMAKE_PROGRAM_PATH "C:/Windows/Microsoft.NET/Framework/v4.0.30319") # CSharp compiler +endif() + +FIND_PROGRAM(DMCS_EXECUTABLE dmcs PATHS $ENV{DMCS_HOME} ENV PATH ) # Mono compiler +FIND_PROGRAM(CSC_EXECUTABLE csc PATHS $ENV{CSC_HOME} ENV PATH ) # CSharp compiler + +if (DMCS_EXECUTABLE OR CSC_EXECUTABLE) + + # unset all library suffixes as swig will hardcode a library without + SET(LIB_POSTFIX ${CMAKE_LIBRARY_POSTFIX}) + + SET(CMAKE_DEBUG_POSTFIX "") + SET(CMAKE_RELEASE_POSTFIX "") + SET(CMAKE_RELWITHDEBINFO_POSTFIX "") + SET(CMAKE_MINSIZEREL_POSTFIX "") + SET(CMAKE_LIBRARY_POSTFIX "") + + if (MSVC) + # MSVC does not include inttypes.h but SWIG needs it + include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../msvc) + endif() + + include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + + SET(CMAKE_SWIG_FLAGS "") + SET(USCXML_CSHARP_NAMESPACE "org.uscxml") + SET(USCXML_CSHARP_DIR "org/uscxml") + + if (CMAKE_BUILD_TYPE STREQUAL "Debug") + list(APPEND CMAKE_SWIG_FLAGS "-DDEBUG") + endif() + + + # we need ; to produce a space with the package .. weird + SET_SOURCE_FILES_PROPERTIES(uscxml.i PROPERTIES SWIG_FLAGS "-w401;-namespace;${USCXML_CSHARP_NAMESPACE}") + SET_SOURCE_FILES_PROPERTIES(uscxml.i PROPERTIES CPLUSPLUS ON) + SET(CMAKE_SWIG_OUTDIR "${CMAKE_CURRENT_BINARY_DIR}/${USCXML_CSHARP_DIR}") + + set(USCXML_LANGUAGE_BINDINGS "csharp ${USCXML_LANGUAGE_BINDINGS}") + + SWIG_ADD_MODULE(uscxmlNativeCSharp csharp uscxml.i) + set_target_properties(uscxmlNativeCSharp PROPERTIES FOLDER "Bindings") + set_target_properties(uscxmlNativeCSharp + PROPERTIES + ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/csharp${LIB_POSTFIX}" + LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/csharp${LIB_POSTFIX}" + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/csharp${LIB_POSTFIX}" + ) + + set_target_properties(uscxmlNativeCSharp PROPERTIES COMPILE_FLAGS "-DSWIG") + swig_link_libraries(uscxmlNativeCSharp uscxml) + + # build managed code part + if (CSC_EXECUTABLE) + ADD_CUSTOM_TARGET(csharp + COMMAND ${CMAKE_COMMAND} -E + copy ${CMAKE_CURRENT_SOURCE_DIR}/org/uscxml/InterpreterException.cs ${PROJECT_BINARY_DIR}/src/bindings/swig/csharp/org/uscxml + COMMAND ${CSC_EXECUTABLE} + /target:library + /out:${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/uscxmlCSharp.dll + *.cs + WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/src/bindings/swig/csharp/org/uscxml + COMMENT "Creating umundoCSharp.dll for C# ...") + else() + ADD_CUSTOM_TARGET(csharp + COMMAND ${CMAKE_COMMAND} -E + copy ${CMAKE_CURRENT_SOURCE_DIR}/org/uscxml/InterpreterException.cs ${PROJECT_BINARY_DIR}/src/bindings/swig/csharp/org/uscxml + COMMAND ${DMCS_EXECUTABLE} + -target:library + /out:${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/uscxmlCSharp.dll + *.cs + WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/src/bindings/swig/csharp/org/uscxml + COMMENT "Creating umundoCSharp.dll for Mono ...") + endif() + + add_dependencies(csharp uscxmlNativeCSharp) + if (BUILD_TESTS) + add_dependencies(ALL_TESTS csharp) + endif() + set_target_properties(csharp PROPERTIES FOLDER "Bindings") + + set(USCXML_LANGUAGE_BINDINGS ${USCXML_LANGUAGE_BINDINGS} PARENT_SCOPE) +endif()
\ No newline at end of file diff --git a/src/bindings/swig/csharp/org/uscxml/InterpreterException.cs b/src/bindings/swig/csharp/org/uscxml/InterpreterException.cs new file mode 100644 index 0000000..38430d8 --- /dev/null +++ b/src/bindings/swig/csharp/org/uscxml/InterpreterException.cs @@ -0,0 +1,7 @@ +namespace org.uscxml { + public class InterpreterException : System.ApplicationException { + public InterpreterException(string message) + : base(message) { + } + } +}
\ No newline at end of file diff --git a/src/bindings/swig/csharp/uscxml.i b/src/bindings/swig/csharp/uscxml.i new file mode 100644 index 0000000..fbc5f20 --- /dev/null +++ b/src/bindings/swig/csharp/uscxml.i @@ -0,0 +1,429 @@ +%module(directors="1", allprotected="1") uscxmlNativeCSharp + +// provide a macro for the header files +#define SWIGIMPORTED 1 + +%include <stl.i> +%include <std_map.i> +%include <std_string.i> +%include <inttypes.i> +%include "../stl_set.i" +%include "../stl_list.i" + +%include <boost_shared_ptr.i> + +// these are needed at least for the templates to work +typedef uscxml::Blob Blob; +typedef uscxml::Data Data; +typedef uscxml::Event Event; +typedef uscxml::InvokeRequest InvokeRequest; +typedef uscxml::SendRequest SendRequest; +typedef uscxml::Invoker Invoker; +typedef uscxml::IOProcessor IOProcessor; +typedef uscxml::DataModel DataModel; +typedef uscxml::DataModelExtension DataModelExtension; +typedef uscxml::ExecutableContent ExecutableContent; +typedef uscxml::InvokerImpl InvokerImpl; +typedef uscxml::IOProcessorImpl IOProcessorImpl; +typedef uscxml::DataModelImpl DataModelImpl; +typedef uscxml::ExecutableContentImpl ExecutableContentImpl; +typedef uscxml::InterpreterIssue InterpreterIssue; + +%feature("director") uscxml::WrappedInvoker; +%feature("director") uscxml::WrappedDataModel; +%feature("director") uscxml::WrappedDataModelExtension; +%feature("director") uscxml::WrappedIOProcessor; +%feature("director") uscxml::WrappedExecutableContent; +%feature("director") uscxml::WrappedInterpreterMonitor; + +// disable warnings + +// unknown base class +#pragma SWIG nowarn=401 +// override symbols via extend +#pragma SWIG nowarn=302 +// ignoring overrided method +#pragma SWIG nowarn=516 +// pointer from director +#pragma SWIG nowarn=473 +// renamed params -> _params +#pragma SWIG nowarn=314 + +%csconst(1); + +%rename(equals) operator==; +%rename(isValid) operator bool; + + +//************************************************** +// This ends up in the generated wrapper code +//************************************************** + +%{ + +#include "../../../uscxml/Message.h" +#include "../../../uscxml/Factory.h" +#include "../../../uscxml/Interpreter.h" +#include "../../../uscxml/concurrency/BlockingQueue.h" +#include "../../../uscxml/server/HTTPServer.h" +//#include "../../../uscxml/debug/DebuggerServlet.h" + +#include "../wrapped/WrappedInvoker.h" +#include "../wrapped/WrappedDataModel.h" +#include "../wrapped/WrappedExecutableContent.h" +#include "../wrapped/WrappedIOProcessor.h" +#include "../wrapped/WrappedInterpreterMonitor.h" + +using namespace uscxml; +using namespace Arabica::DOM; + +// the wrapped* C++ classes get rid of DOM nodes and provide more easily wrapped base classes +#include "../wrapped/WrappedInvoker.cpp" +#include "../wrapped/WrappedDataModel.cpp" +#include "../wrapped/WrappedExecutableContent.cpp" +#include "../wrapped/WrappedIOProcessor.cpp" +#include "../wrapped/WrappedInterpreterMonitor.cpp" + +%} + +// see http://binf.gmu.edu/software/SWIG/CSharp.html#csharp_exceptions +%insert(runtime) %{ + // Code to handle throwing of C# CustomApplicationException from C/C++ code. + // The equivalent delegate to the callback, CSharpExceptionCallback_t, is CustomExceptionDelegate + // and the equivalent customExceptionCallback instance is customDelegate + typedef void (SWIGSTDCALL* CSharpExceptionCallback_t)(const char *); + CSharpExceptionCallback_t customExceptionCallback = NULL; + + extern "C" SWIGEXPORT + void SWIGSTDCALL CustomExceptionRegisterCallback(CSharpExceptionCallback_t customCallback) { + customExceptionCallback = customCallback; + } + + // Note that SWIG detects any method calls named starting with + // SWIG_CSharpSetPendingException for warning 845 + static void SWIG_CSharpSetPendingExceptionCustom(const char *msg) { + customExceptionCallback(msg); + } +%} + +%pragma(csharp) imclasscode=%{ + class CustomExceptionHelper { + // C# delegate for the C/C++ customExceptionCallback + public delegate void CustomExceptionDelegate(string message); + static CustomExceptionDelegate customDelegate = + new CustomExceptionDelegate(SetPendingCustomException); + + [System.Runtime.InteropServices.DllImport("$dllimport", EntryPoint="CustomExceptionRegisterCallback")] + public static extern + void CustomExceptionRegisterCallback(CustomExceptionDelegate customCallback); + + static void SetPendingCustomException(string message) { + SWIGPendingException.Set(new org.uscxml.InterpreterException(message)); + } + + static CustomExceptionHelper() { + CustomExceptionRegisterCallback(customDelegate); + } + } + static CustomExceptionHelper exceptionHelper = new CustomExceptionHelper(); +%} + + +%define WRAP_THROW_EXCEPTION( MATCH ) +%exception MATCH %{ +try { + $action +} catch (uscxml::Event& e) { + std::stringstream ss; + ss << std::endl << e; + SWIG_CSharpSetPendingExceptionCustom(ss.str().c_str()); +} +%} +%enddef + +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromXML); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromURI); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::step); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::interpret); + + +%define WRAP_TO_STRING( CLASSNAME ) +%csmethodmodifiers CLASSNAME::ToString() "public override"; +%extend CLASSNAME { + virtual std::string ToString() { + std::stringstream ss; + ss << *self; + return ss.str(); + } +}; +%enddef + +WRAP_TO_STRING(uscxml::Event); +WRAP_TO_STRING(uscxml::Data); +WRAP_TO_STRING(uscxml::SendRequest); +WRAP_TO_STRING(uscxml::InvokeRequest); +WRAP_TO_STRING(uscxml::InterpreterIssue); + +%include "../uscxml_ignores.i" + +// InterpreterMonitor -> StateTransitionMonitor +%ignore uscxml::StateTransitionMonitor; + +//*********************************************** +// Beautify important classes +//*********************************************** + + +// byte[] signature for Blob get/setData +// see http://permalink.gmane.org/gmane.comp.programming.swig/5804 + +%csmethodmodifiers uscxml::Blob::setData(const char* data, size_t length) "private"; +%csmethodmodifiers uscxml::Blob::setMimeType(const std::string& mimeType) "private"; +%csmethodmodifiers uscxml::Blob::Blob(const char* data, size_t size, const std::string& mimeType) "private"; +%csmethodmodifiers uscxml::Blob::Blob(const char* data, size_t size) "private"; + +%typemap(cscode) uscxml::Blob %{ + public Blob(byte[] data, string mimeType) : this(uscxmlNativeCSharpPINVOKE.new_Blob__SWIG_2(data, (uint)data.Length, mimeType), true) { + if (uscxmlNativeCSharpPINVOKE.SWIGPendingException.Pending) throw uscxmlNativeCSharpPINVOKE.SWIGPendingException.Retrieve(); + } + +%} + +%typemap(imtype, out="System.IntPtr") const char *data "byte[]" +%typemap(cstype) const char *data "byte[]" +%typemap(in) const char *data %{ $1 = ($1_ltype)$input; %} +%typemap(csin) const char *data "$csinput" + +%typemap(imtype, out="System.IntPtr") char* getData "byte[]" +%typemap(cstype) char* getData "byte[]" + +%typemap(csout) char* getData %{ + { + byte[] ret = new byte[this.getSize()]; + System.IntPtr data = $imcall; + System.Runtime.InteropServices.Marshal.Copy(data, ret, 0, (int)this.getSize()); + return ret; + } +%} + +// make sure we do not get the default with SWIG_csharp_string_callback +%typemap(out) char* getData { + $result = (char *)result; +} + + + +%csmethodmodifiers uscxml::Event::getParamMap() "private"; +%csmethodmodifiers uscxml::Event::getParamMapKeys() "private"; +%csmethodmodifiers uscxml::Event::setParamMap(const std::map<std::string, std::list<uscxml::Data> >&) "private"; +%csmethodmodifiers uscxml::Event::getNameListKeys() "private"; +%csmethodmodifiers uscxml::Interpreter::getIOProcessorKeys() "private"; +%csmethodmodifiers uscxml::Interpreter::getInvokerKeys() "private"; +%csmethodmodifiers uscxml::Interpreter::getInvokers() "private"; +%csmethodmodifiers uscxml::Interpreter::getIOProcessors() "private"; +%csmethodmodifiers uscxml::Data::getCompoundKeys() "private"; + +%include "../uscxml_beautify.i" + +%typemap(csimports) uscxml::Interpreter %{ +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +%} + +%typemap(cscode) uscxml::Interpreter %{ + public Dictionary<string, NativeIOProcessor> getIOProcessors() { + Dictionary<string, NativeIOProcessor> ioProcs = new Dictionary<string, NativeIOProcessor>(); + StringVector keys = getIOProcessorKeys(); + IOProcMap ioProcMap = getIOProcessorsNative(); + for (size_t i = 0; i < keys.Count; i++) { + ioProcs[keys[i]] = ioProcMap[keys[i]]; + } + return ioProcs; + } + + public Dictionary<string, NativeInvoker> getInvokers() { + Dictionary<string, NativeInvoker> invokers = new Dictionary<string, NativeInvoker>(); + StringVector keys = getInvokerKeys(); + InvokerMap invokerMap = getInvokersNative(); + for (size_t i = 0; i < keys.Count; i++) { + invokers[keys[i]] = invokerMap[keys[i]]; + } + return invokers; + } + +%} + + +%rename(getCompoundNative) uscxml::Data::getCompound(); +%rename(getArrayNative) uscxml::Data::getArray(); +%rename(setCompoundNative) uscxml::Data::setCompound(const std::map<std::string, Data>&); +%rename(setArrayNative) uscxml::Data::setArray(const std::list<Data>&); +%csmethodmodifiers uscxml::Data::getCompound() "private"; +%csmethodmodifiers uscxml::Data::getArray() "private"; +%csmethodmodifiers uscxml::Data::setCompound(const std::map<std::string, Data>&) "private"; +%csmethodmodifiers uscxml::Data::setArray(const std::list<Data>&) "private"; +%csmethodmodifiers uscxml::Data::getCompoundKeys() "private"; + +%typemap(csimports) uscxml::Data %{ +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +%} + +%typemap(cscode) uscxml::Data %{ + public Data(byte[] data, String mimeType) : this() { + setBinary(new Blob(data, mimeType)); + } + + public Data(List<Data> arr) : this() { + setArray(arr); + } + + public Data(Dictionary<string, Data> compound) : this() { + setCompound(compound); + } + + public Dictionary<string, Data> getCompound() { + Dictionary<string, Data> compound = new Dictionary<string, Data>(); + DataMap dataMap = getCompoundNative(); + StringVector dataMapKeys = getCompoundKeys(); + for (size_t i = 0; i < dataMapKeys.Count; i++) { + compound[dataMapKeys[i]] = dataMap[dataMapKeys[i]]; + } + return compound; + } + + public void setCompound(Dictionary<string, Data> compound) { + DataMap dataMap = new DataMap(); + foreach(KeyValuePair<string, Data> entry in compound) { + dataMap.Add(entry); + } + setCompoundNative(dataMap); + } + + public List<Data> getArray() { + List<Data> arr = new List<Data>(); + DataList dataList = getArrayNative(); + for (size_t i = 0; i < dataList.size(); i++) { + arr.Add(dataList.get(i)); + } + return arr; + } + + public void setArray(List<Data> arr) { + DataList dataList = new DataList(); + foreach (Data data in arr) { + dataList.add(data); + } + setArrayNative(dataList); + } + +%} + +%rename(getNameListNative) uscxml::Event::getNameList(); +%rename(getParamsNative) uscxml::Event::getParams(); +%rename(setNameListNative) uscxml::Event::setNameList(const std::map<std::string, Data>&); +%rename(setParamsNative) uscxml::Event::setParams(const std::multimap<std::string, Data>&); +%csmethodmodifiers uscxml::Event::getNameList() "private"; +%csmethodmodifiers uscxml::Event::getNameListKeys() "private"; +%csmethodmodifiers uscxml::Event::getParams() "private"; +%csmethodmodifiers uscxml::Event::setNameList(const std::map<std::string, Data>&) "private"; +%csmethodmodifiers uscxml::Event::setParams(const std::multimap<std::string, Data>&) "private"; + +%typemap(csimports) uscxml::Event %{ + using System; + using System.Collections.Generic; + using System.Runtime.InteropServices; +%} + +%typemap(cscode) uscxml::Event %{ + public Dictionary<string, List<Data> > getParams() { + Dictionary<string, List<Data>> parameters = new Dictionary<string, List<Data>>(); + ParamMap paramMap = getParamMap(); + + foreach (KeyValuePair<string, DataList> entry in paramMap) { + DataList dataList = entry.Value; + List<Data> paramList = new List<Data>(); + for (size_t i = 0; i < dataList.size(); i++) { + Data data = dataList.get(i); + paramList.Add(data); + } + parameters.Add(entry.Key, paramList); + } + return parameters; + } + + public void setParams(Dictionary<string, List<Data>> parameters) { + ParamMap paramMap = new ParamMap(); + foreach(KeyValuePair<string, List<Data>> entry in parameters) { + DataList dataList = new DataList(); + foreach (Data data in entry.Value) { + dataList.add(data); + } + paramMap.Add(entry.Key, dataList); + } + setParamMap(paramMap); + } + + public Dictionary<string, Data> getNameList() { + Dictionary<string, Data> nameList = new Dictionary<string, Data>(); + DataMap nameListMap = getNameListNative(); + StringVector nameListMapKeys = getNameListKeys(); + for (size_t i = 0; i < nameListMapKeys.Count; i++) { + nameList[nameListMapKeys[i]] = nameListMap[nameListMapKeys[i]]; + } + return nameList; + } + + public void setNameList(Dictionary<string, Data> nameList) { + DataMap dataMap = new DataMap(); + foreach (KeyValuePair<string, Data> entry in nameList) { + dataMap.Add(entry); + } + setNameListNative(dataMap); + } +%} + +//*********************************************** +// Parse the header file to generate wrappers +//*********************************************** + +%include "../../../uscxml/Common.h" +%include "../../../uscxml/Factory.h" +%include "../../../uscxml/Message.h" +%include "../../../uscxml/Interpreter.h" +%include "../../../uscxml/concurrency/BlockingQueue.h" +%include "../../../uscxml/server/HTTPServer.h" +//%include "../../../uscxml/debug/DebuggerServlet.h" +%include "../../../uscxml/debug/InterpreterIssue.h" + +%include "../../../uscxml/messages/Blob.h" +%include "../../../uscxml/messages/Data.h" +%include "../../../uscxml/messages/Event.h" +%include "../../../uscxml/messages/InvokeRequest.h" +%include "../../../uscxml/messages/SendRequest.h" + +%include "../../../uscxml/plugins/DataModel.h" +%include "../../../uscxml/plugins/EventHandler.h" +%include "../../../uscxml/plugins/ExecutableContent.h" +%include "../../../uscxml/plugins/Invoker.h" +%include "../../../uscxml/plugins/IOProcessor.h" + +%include "../wrapped/WrappedInvoker.h" +%include "../wrapped/WrappedDataModel.h" +%include "../wrapped/WrappedExecutableContent.h" +%include "../wrapped/WrappedIOProcessor.h" +%include "../wrapped/WrappedInterpreterMonitor.h" + + +%template(IssueList) std::list<uscxml::InterpreterIssue>; +%template(DataList) std::list<uscxml::Data>; +%template(DataMap) std::map<std::string, uscxml::Data>; +%template(StringSet) std::set<std::string>; +%template(StringVector) std::vector<std::string>; +%template(StringList) std::list<std::string>; +%template(ParamMap) std::map<std::string, std::list<uscxml::Data> >; +%template(IOProcMap) std::map<std::string, IOProcessor>; +%template(InvokerMap) std::map<std::string, Invoker>; +%template(ParentQueue) uscxml::concurrency::BlockingQueue<uscxml::SendRequest>; diff --git a/src/bindings/swig/java/CMakeLists.txt b/src/bindings/swig/java/CMakeLists.txt new file mode 100644 index 0000000..148199e --- /dev/null +++ b/src/bindings/swig/java/CMakeLists.txt @@ -0,0 +1,77 @@ +# generate JNI library and create a jar +# Make from within Eclipse fails miserably with the whole thing + +find_package(JNI) +if(JNI_FOUND) + include_directories(${JNI_INCLUDE_DIRS}) +else() + message(STATUS "No JNI libraries found - not building Java wrappers") + return() +endif() + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + +SET(CMAKE_SWIG_FLAGS "") +SET(USCXML_JAVA_PACKAGE "org.uscxml") +SET(USCXML_JAVA_DIR "org/uscxml") + +# we need ; to produce a space with the package .. weird +SET_SOURCE_FILES_PROPERTIES(uscxml.i PROPERTIES SWIG_FLAGS "-w473;-package;${USCXML_JAVA_PACKAGE}") +SET_SOURCE_FILES_PROPERTIES(uscxml.i PROPERTIES CPLUSPLUS ON) +SET(CMAKE_SWIG_OUTDIR "${CMAKE_CURRENT_BINARY_DIR}/${USCXML_JAVA_DIR}") + +SWIG_ADD_MODULE(uscxmlNativeJava java uscxml.i) +foreach(JNI_LIBRARY ${JNI_LIBRARIES}) + if (NOT ${JNI_LIBRARY} MATCHES ".*jawt.*") + SWIG_LINK_LIBRARIES(uscxmlNativeJava ${JNI_LIBRARY}) + endif() +endforeach() +set_target_properties(uscxmlNativeJava PROPERTIES FOLDER "Bindings") +set_target_properties(uscxmlNativeJava PROPERTIES COMPILE_FLAGS "-DSWIG") + +swig_link_libraries(uscxmlNativeJava uscxml) + +file(GLOB POTENTIAL_ANT "C:/Program Files/apache-ant**/bin" "C:/Program Files (x86)/apache-ant**/bin") + +FIND_PROGRAM(ANT_EXECUTABLE ant PATHS $ENV{ANT_HOME}/bin ${POTENTIAL_ANT} ENV PATH ) +if (ANT_EXECUTABLE) + set(USCXML_LANGUAGE_BINDINGS "java ${USCXML_LANGUAGE_BINDINGS}") + + set(JAR_EXCLUDE_DEBUG OFF) + set(JAR_EXCLUDE_JNI OFF) + + # include all the JNI libraries prepared from DIST_PREPARE builds on the various desktop platforms + if (DIST_PREPARE) + if (CMAKE_CROSSCOMPILING) + if (ANDROID) + set(JAR_EXCLUDE_JNI ON) # JNI inside jar not allowed with Android + SET(JAR_JNI_ROOT_PATH ${PROJECT_SOURCE_DIR}/package/cross-compiled/android) + else() + SET(JAR_JNI_ROOT_PATH ${PROJECT_SOURCE_DIR}/package/cross-compiled/${CMAKE_CROSSCOMPILING_TARGET_LC}) + endif() + else() + SET(JAR_JNI_ROOT_PATH ${PROJECT_SOURCE_DIR}/package) + endif() + else() + # when not preparing a distribution, just put the jar into the libs + SET(JAR_JNI_ROOT_PATH ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}) + endif() + + ADD_CUSTOM_TARGET(java + COMMAND ${ANT_EXECUTABLE} + -Dlib.dir=${JAR_JNI_ROOT_PATH} + -Dsrc.dir=${PROJECT_SOURCE_DIR} + -Dbuild.dir=${PROJECT_BINARY_DIR} + -Dbuild.type=${CMAKE_BUILD_TYPE} + -Dexclude.debug=${JAR_EXCLUDE_DEBUG} + -Dexclude.jni=${JAR_EXCLUDE_JNI} + -f build-java.xml + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/contrib/java + COMMENT "Creating the jar ...") + + set_target_properties(java PROPERTIES FOLDER "Bindings") +else() + message(STATUS "Could not find ant binary - will not build jars") +endif() + +set(USCXML_LANGUAGE_BINDINGS ${USCXML_LANGUAGE_BINDINGS} PARENT_SCOPE) diff --git a/src/bindings/swig/java/org/uscxml/InterpreterException.java b/src/bindings/swig/java/org/uscxml/InterpreterException.java new file mode 100644 index 0000000..b2baa99 --- /dev/null +++ b/src/bindings/swig/java/org/uscxml/InterpreterException.java @@ -0,0 +1,11 @@ +package org.uscxml; + +public class InterpreterException extends Exception { + private static final long serialVersionUID = -3534919496547591015L; + + public InterpreterException(String name, String msg) { + super(msg); + } + + public String name; +} diff --git a/src/bindings/swig/java/uscxml.i b/src/bindings/swig/java/uscxml.i new file mode 100644 index 0000000..03d8232 --- /dev/null +++ b/src/bindings/swig/java/uscxml.i @@ -0,0 +1,284 @@ +%module(directors="1", allprotected="1") uscxmlNativeJava + +// provide a macro for the header files +#define SWIGIMPORTED 1 + +%include <stl.i> +%include <std_map.i> +%include <std_string.i> +%include <inttypes.i> +%include "../stl_set.i" +%include "../stl_list.i" +%include "enums.swg" + +%include <std_shared_ptr.i> + +// these are needed at least for the templates to work +typedef uscxml::Blob Blob; +typedef uscxml::Data Data; +typedef uscxml::Event Event; +typedef uscxml::Invoker Invoker; +typedef uscxml::IOProcessor IOProcessor; +typedef uscxml::DataModel DataModel; +typedef uscxml::DataModelExtension DataModelExtension; +typedef uscxml::ExecutableContent ExecutableContent; +typedef uscxml::InvokerImpl InvokerImpl; +typedef uscxml::IOProcessorImpl IOProcessorImpl; +typedef uscxml::DataModelImpl DataModelImpl; +typedef uscxml::ExecutableContentImpl ExecutableContentImpl; +typedef uscxml::InterpreterIssue InterpreterIssue; + +%feature("director") uscxml::WrappedInvoker; +%feature("director") uscxml::WrappedDataModel; +%feature("director") uscxml::WrappedDataModelExtension; +%feature("director") uscxml::WrappedIOProcessor; +%feature("director") uscxml::WrappedExecutableContent; +%feature("director") uscxml::WrappedInterpreterMonitor; + +// disable warning related to unknown base class +#pragma SWIG nowarn=401 +// do not warn when we override symbols via extend +#pragma SWIG nowarn=302 +// do not warn when ignoring overrided method +#pragma SWIG nowarn=516 + +%javaconst(1); + +%rename(equals) operator==; // signature is wrong, still useful +%rename(isValid) operator bool; + +//************************************************** +// This ends up in the generated wrapper code +//************************************************** + +%{ + +#include "uscxml/config.h" +#include "../../../uscxml/Interpreter.h" +#include "../../../uscxml/debug/InterpreterIssue.h" +#include "../../../uscxml/interpreter/InterpreterState.h" +#include "../../../uscxml/interpreter/InterpreterMonitor.h" + +#include "../../../uscxml/messages/Data.h" +#include "../../../uscxml/messages/Event.h" +#include "../../../uscxml/util/DOM.h" + +#include "../../../uscxml/plugins/Factory.h" +#include "../../../uscxml/plugins/DataModelImpl.h" + +#include "../wrapped/WrappedInvoker.h" +#include "../wrapped/WrappedDataModel.h" +#include "../wrapped/WrappedExecutableContent.h" +#include "../wrapped/WrappedIOProcessor.h" +#include "../wrapped/WrappedInterpreterMonitor.h" + +using namespace uscxml; +using namespace XERCESC_NS; + +// the wrapped* C++ classes get rid of DOM nodes and provide more easily wrapped base classes +#include "../wrapped/WrappedInvoker.cpp" +#include "../wrapped/WrappedDataModel.cpp" +#include "../wrapped/WrappedExecutableContent.cpp" +#include "../wrapped/WrappedIOProcessor.cpp" +#include "../wrapped/WrappedInterpreterMonitor.cpp" + +%} + +// throw from c++ to java +%define WRAP_THROW_EXCEPTION( MATCH ) +%javaexception("org.uscxml.InterpreterException") MATCH { + try { + $action + } + catch ( uscxml::Event& e ) { + jclass eclass = jenv->FindClass("org/uscxml/InterpreterException"); + if ( eclass ) { + std::stringstream ss; + jenv->ThrowNew( eclass, ss.str().c_str() ); + } + } +} +%enddef + +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromXML); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromURL); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::step); + +// throw from java directors to c++ +%typemap(javabase) uscxml::Event "java.lang.RuntimeException"; +%rename(getMessage) uscxml::ErrorEvent::toString; + +%define WRAP_THROWS_ERROREVENT( MATCH ) +%feature("director:except") MATCH { + jthrowable swigerror = jenv->ExceptionOccurred(); + if (Swig::ExceptionMatches(jenv, swigerror, "org/uscxml/ErrorEvent")) { + jenv->ExceptionClear(); + jenv->DeleteLocalRef(swigjobj); + ERROR_EXECUTION_THROW(Swig::JavaExceptionMessage(jenv, swigerror).message()); + } +} +%enddef +WRAP_THROWS_ERROREVENT(uscxml::WrappedDataModel::getLength); +WRAP_THROWS_ERROREVENT(uscxml::WrappedDataModel::setForeach); + + +%typemap(directorthrows) uscxml::ErrorEvent %{ + if (Swig::ExceptionMatches(jenv, $error, "$packagepath/$javaclassname")) + throw $1_type(Swig::JavaExceptionMessage(jenv, $error).message()); +%} + +%catches(uscxml::ErrorEvent) uscxml::WrappedDataModel::getLength; + + +// provide a hashcode +%define WRAP_HASHCODE( CLASSNAME ) +%extend CLASSNAME { + virtual int hashCode() { +/* std::cout << "Calc hashcode as " << (int)(size_t)self->getImpl().get() << std::endl << std::flush;*/ + return (int)(size_t)self->getImpl().get(); + } +}; +%enddef + +%define WRAP_TO_STRING( CLASSNAME ) +%extend CLASSNAME { + virtual std::string toString() { + std::stringstream ss; + ss << *self; + return ss.str(); + } +}; +%enddef + +WRAP_TO_STRING(uscxml::Event); +WRAP_TO_STRING(uscxml::Data); +WRAP_TO_STRING(uscxml::InterpreterIssue); + +WRAP_HASHCODE(uscxml::Interpreter); + +%include "../uscxml_ignores.i" + +#if 0 +// see http://swig.org/Doc2.0/Java.html#Java_date_marshalling +%define BEAUTIFY_NATIVE( MATCH, WRAPPER, NATIVE ) + +%rename WRAPPER NATIVE; + +%typemap(jstype) const MATCH & "WRAPPER" +%typemap(jstype) MATCH "WRAPPER" + +%typemap(javain, + pre=" NATIVE temp$javainput = $javainput.toNative();", + pgcppname="temp$javainput") const MATCH & + "$javaclassname.getCPtr(temp$javainput)" + + %typemap(javain, + pre=" NATIVE temp$javainput = $javainput.toNative();", + pgcppname="temp$javainput") MATCH + "$javaclassname.getCPtr(temp$javainput)" + +%typemap(javaout) const MATCH & { + NATIVE nativeData = new NATIVE($jnicall, $owner); + return new WRAPPER(nativeData); +} + +%typemap(javaout) MATCH { + NATIVE nativeData = new NATIVE($jnicall, $owner); + return new WRAPPER(nativeData); +} + +%typemap(javadirectorout) MATCH "NATIVE.getCPtr($javacall.toNative())" + +%typemap(javadirectorin) MATCH "WRAPPER.fromNative(new NATIVE($jniinput, false))"; +%typemap(javadirectorin) const MATCH & "WRAPPER.fromNative(new NATIVE($jniinput, false))"; + +%typemap(directorin,descriptor="L/org/uscxml/"##"WRAPPER;") const MATCH & "*(MATCH **)&$input = (MATCH *) &$1;" + +%typemap(directorout) MATCH ($&1_type argp) +%{ argp = *($&1_ltype*)&$input; + if (!argp) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type"); + return $null; + } + $result = *argp; %} + +%enddef + +/* +// not used as it will not work for directors :( +BEAUTIFY_NATIVE(uscxml::Data, Data, DataNative); +BEAUTIFY_NATIVE(uscxml::Event, Event, EventNative); +*/ +#endif + +// bytearray for Blob::data +// see: http://stackoverflow.com/questions/9934059/swig-technique-to-wrap-unsigned-binary-data + +%apply (char *STRING, size_t LENGTH) { (const char* data, size_t size) }; + +%typemap(jni) char* getData "jbyteArray" +%typemap(jtype) char* getData "byte[]" +%typemap(jstype) char* getData "byte[]" +%typemap(javaout) char* getData { + return $jnicall; +} + +%typemap(out) char* getData { + $result = JCALL1(NewByteArray, jenv, ((uscxml::Blob const *)arg1)->getSize()); + JCALL4(SetByteArrayRegion, jenv, $result, 0, ((uscxml::Blob const *)arg1)->getSize(), (jbyte *)$1); +} + +//*********************************************** +// Beautify important classes +//*********************************************** + + +%include "../uscxml_beautify.i" + + +//*********************************************** +// Parse the header file to generate wrappers +//*********************************************** + +%include "../../../uscxml/Common.h" +%include "../../../uscxml/messages/Blob.h" +%include "../../../uscxml/messages/Data.h" +%include "../../../uscxml/messages/Event.h" + +%include "../../../uscxml/plugins/Factory.h" +%include "../../../uscxml/interpreter/InterpreterState.h" +%include "../../../uscxml/interpreter/InterpreterMonitor.h" + +//%include "../../../uscxml/interpreter/MicroStep.h" +//%include "../../../uscxml/interpreter/ContentExecutor.h" + +%include "../../../uscxml/Interpreter.h" +%include "../../../uscxml/debug/InterpreterIssue.h" + +%include "../../../uscxml/plugins/EventHandler.h" + +%include "../../../uscxml/plugins/DataModel.h" +%include "../../../uscxml/plugins/DataModelImpl.h" +%include "../../../uscxml/plugins/ExecutableContent.h" +%include "../../../uscxml/plugins/ExecutableContentImpl.h" +%include "../../../uscxml/plugins/Invoker.h" +%include "../../../uscxml/plugins/InvokerImpl.h" +%include "../../../uscxml/plugins/IOProcessor.h" +%include "../../../uscxml/plugins/IOProcessorImpl.h" + +%include "../wrapped/WrappedInvoker.h" +%include "../wrapped/WrappedDataModel.h" +%include "../wrapped/WrappedExecutableContent.h" +%include "../wrapped/WrappedIOProcessor.h" +%include "../wrapped/WrappedInterpreterMonitor.h" + + +%template(IssueList) std::list<uscxml::InterpreterIssue>; +%template(DataList) std::list<uscxml::Data>; +%template(DataMap) std::map<std::string, uscxml::Data>; +%template(StringSet) std::set<std::string>; +%template(StringVector) std::vector<std::string>; +%template(StringList) std::list<std::string>; +%template(ParamMap) std::map<std::string, std::list<uscxml::Data> >; +%template(IOProcMap) std::map<std::string, IOProcessor>; +%template(InvokerMap) std::map<std::string, Invoker>; diff --git a/src/bindings/swig/php/CMakeLists.txt b/src/bindings/swig/php/CMakeLists.txt new file mode 100644 index 0000000..802f3a2 --- /dev/null +++ b/src/bindings/swig/php/CMakeLists.txt @@ -0,0 +1,100 @@ +# generate PHP module + +find_package(PHP5) +if(PHP5_FOUND) + include_directories(${PHP5_INCLUDE_PATH}) +else() + message(STATUS "No PHP5 libraries found - not building php module") + return() +endif() + +# copied from cmake's FindPHP4.cmake and adapted +if(APPLE) + # this is a hack for now + set(PHP_MODULE_CXX_FLAGS "${CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS} -Wl") + foreach(symbol + __efree + __emalloc + __estrdup + __estrndup + __object_init + __object_init_ex + __zend_get_parameters_array_ex + __zend_list_find + __zval_copy_ctor + __zval_copy_ctor_func + _add_property_zval_ex + _alloc_globals + _compiler_globals + _convert_to_double + _convert_to_long + _convert_to_boolean + __convert_to_string + _gc_remove_zval_from_buffer + _call_user_function + _php_sprintf + _executor_globals + _zend_get_constant + _zend_lookup_class + _zend_register_long_constant + _zval_is_true + _zend_error + _zend_hash_find + __zend_hash_add_or_update + _zend_register_internal_class_ex + _zend_register_list_destructors_ex + _zend_register_resource + _zend_rsrc_list_get_rsrc_type + _zend_wrong_param_count + _zend_throw_exception + _zval_used_for_init + ) + set(PHP_MODULE_CXX_FLAGS + "${PHP_MODULE_CXX_FLAGS},-U,${symbol}") + endforeach() +endif() + +#message(FATAL_ERROR "PHP_LDFLAGS: ${PHP_LDFLAGS}") + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) +include_directories(${PHP_INCLUDE_DIRS}) + +SET(CMAKE_SWIG_FLAGS "") + +# we need ; to produce a space with the package .. weird +SET_SOURCE_FILES_PROPERTIES(uscxml.i PROPERTIES CPLUSPLUS ON) + +SWIG_ADD_MODULE(uscxmlNativePHP php5 uscxml.i) +foreach(PHP_LIBRARY ${PHP_LIBRARIES}) +# SWIG_LINK_LIBRARIES(uscxmlNativePHP ${PHP_LIBRARY}) +endforeach() +SWIG_LINK_LIBRARIES(uscxmlNativePHP uscxml) + +if (APPLE) + set_target_properties(uscxmlNativePHP PROPERTIES LINK_FLAGS ${PHP_MODULE_CXX_FLAGS}) +endif() + +set(PHP_COMPILE_FLAGS "-DSWIG") + +if (PHP_ZTS_ENABLED) + # we are only building php bindings for unices anyhow + set(PHP_COMPILE_FLAGS "${PHP_COMPILE_FLAGS} -DZTS") + set(PHP_COMPILE_FLAGS "${PHP_COMPILE_FLAGS} -DPTHREADS") +endif() +if (PHP_DEBUG_ENABLED) + set(PHP_COMPILE_FLAGS "${PHP_COMPILE_FLAGS} -DZEND_DEBUG") +endif() + +ADD_CUSTOM_COMMAND( + TARGET uscxmlNativePHP + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_BINARY_DIR}/uscxmlNativePHP.php + ${PROJECT_SOURCE_DIR}/src/bindings/swig/php/uscxmlNativePHP.php +) + +set_target_properties(uscxmlNativePHP PROPERTIES COMPILE_FLAGS ${PHP_COMPILE_FLAGS}) +set_target_properties(uscxmlNativePHP PROPERTIES FOLDER "Bindings") + +set(USCXML_LANGUAGE_BINDINGS "php ${USCXML_LANGUAGE_BINDINGS}") +set(USCXML_LANGUAGE_BINDINGS ${USCXML_LANGUAGE_BINDINGS} PARENT_SCOPE) diff --git a/src/bindings/swig/php/test.php b/src/bindings/swig/php/test.php new file mode 100644 index 0000000..739c6a1 --- /dev/null +++ b/src/bindings/swig/php/test.php @@ -0,0 +1,85 @@ +<?php + +require_once('uscxmlNativePHP.php'); + +// $exts = get_loaded_extensions(); +// foreach ($exts as $e) +// { +// echo "Name: ".$e." --"; +// print_r(get_extension_funcs($e)); +// } + +class MyMonitor extends InterpreterMonitor { + function beforeExitingStates($interpreter,$statesToExit) { + print "MyMonitor.beforeExitingStates()\n"; + } + function afterExitingStates($interpreter) { + print "MyMonitor.afterExitingStates()\n"; + } + function beforeEnteringStates($interpreter,$statesToEnter) { + print "MyMonitor.beforeEnteringStates()\n"; + } + function afterEnteringStates($interpreter) { + print "MyMonitor.afterEnteringStates()\n"; + } + function onStableConfiguration($interpreter) { + print "MyMonitor.onStableConfiguration()\n"; + } + function beforeCompletion($interpreter) { + print "MyMonitor.beforeCompletion()\n"; + } + function afterCompletion($interpreter) { + print "MyMonitor.afterCompletion()\n"; + } + function beforeMicroStep($interpreter) { + print "MyMonitor.beforeMicroStep()\n"; + } + function afterMicroStep($interpreter) { + print "MyMonitor.afterMicroStep()\n"; + } + function beforeTakingTransitions($interpreter,$transitions) { + print "MyMonitor.beforeTakingTransitions()\n"; + } +} + +$monitor = new MyMonitor(); + +// run interpreter in blocking mode +$interpreter = Interpreter::fromURL('https://raw.githubusercontent.com/tklab-tud/uscxml/master/test/uscxml/test-invoked.scxml'); +$interpreter->addMonitor($monitor); +$interpreter->interpret(); + +// interleave interpreter execution with this thread +$interpreter = Interpreter::fromURL('https://raw.githubusercontent.com/tklab-tud/uscxml/master/test/uscxml/test-invoked.scxml'); +$parentQueue = new ParentQueue(); +$interpreter->setParentQueue($parentQueue); + +while($interpreter->step() > 0) { + $event = $parentQueue->pop(); + print("Name: " . $event->getName() . "\n"); + print("Type: " . $event->getType() . "\n"); + print("Origin: " . $event->getOrigin() . "\n"); + print("OriginType: " . $event->getOriginType() . "\n"); + print("Content " . strlen($event->getContent()) . " bytes: \n'" . $event->getContent() . "'\n"); + + $namelist = $event->getNameList(); + print("Namelist ".$namelist->size()." elements: \n"); + $keys = $event->getNameListKeys(); + for ($i = 0; $i < $keys->size(); $i++) { + print($keys->get($i) . "\t" . Data::toJSON($namelist->get($keys->get($i))) . "\n"); + } + + $params = $event->getParamMap(); + print("Params ". $params->size() ." elements: \n"); + $keys = $event->getParamMapKeys(); + for ($i = 0; $i < $keys->size(); $i++) { + print($keys->get($i)."\n"); + $paramList = $params->get($keys->get($i)); + for ($j = 0; $j < $paramList->size(); $j++) { + print("\t" . Data::toJSON($paramList->get($i)) . "\n"); + } + } + +} + +?>
\ No newline at end of file diff --git a/src/bindings/swig/php/uscxml.i b/src/bindings/swig/php/uscxml.i new file mode 100644 index 0000000..12a29e9 --- /dev/null +++ b/src/bindings/swig/php/uscxml.i @@ -0,0 +1,400 @@ +%module(directors="1", allprotected="1") uscxmlNativePHP + +// provide a macro for the header files +#define SWIGIMPORTED 1 + +%include <stl.i> +%include <std_map.i> +%include <std_string.i> +%include <inttypes.i> +%include "../stl_set.i" +%include "../stl_list.i" + +//%include <boost_shared_ptr.i> + +// these are needed at least for the templates to work +typedef uscxml::Blob Blob; +typedef uscxml::Data Data; +typedef uscxml::Event Event; +typedef uscxml::Invoker Invoker; +typedef uscxml::IOProcessor IOProcessor; +typedef uscxml::DataModel DataModel; +typedef uscxml::DataModelExtension DataModelExtension; +typedef uscxml::ExecutableContent ExecutableContent; +typedef uscxml::InvokerImpl InvokerImpl; +typedef uscxml::IOProcessorImpl IOProcessorImpl; +typedef uscxml::DataModelImpl DataModelImpl; +typedef uscxml::ExecutableContentImpl ExecutableContentImpl; +typedef uscxml::InterpreterIssue InterpreterIssue; + +%feature("director") uscxml::WrappedInvoker; +%feature("director") uscxml::WrappedDataModel; +%feature("director") uscxml::WrappedDataModelExtension; +%feature("director") uscxml::WrappedIOProcessor; +%feature("director") uscxml::WrappedExecutableContent; +%feature("director") uscxml::WrappedInterpreterMonitor; + +// disable warning related to unknown base class +#pragma SWIG nowarn=401 +// do not warn when we override symbols via extend +#pragma SWIG nowarn=302 +// do not warn when ignoring overrided method +#pragma SWIG nowarn=516 + +//%javaconst(1); + +%rename(equals) operator==; // signature is wrong, still useful +%rename(isValid) operator bool; + +//************************************************** +// This ends up in the generated wrapper code +//************************************************** + +%{ + +#include "../../../uscxml/Message.h" +#include "../../../uscxml/Factory.h" +#include "../../../uscxml/Interpreter.h" +#include "../../../uscxml/concurrency/BlockingQueue.h" +#include "../../../uscxml/server/HTTPServer.h" +//#include "../../../uscxml/debug/DebuggerServlet.h" + +#include "../wrapped/WrappedInvoker.h" +#include "../wrapped/WrappedDataModel.h" +#include "../wrapped/WrappedExecutableContent.h" +#include "../wrapped/WrappedIOProcessor.h" +#include "../wrapped/WrappedInterpreterMonitor.h" + +using namespace uscxml; +using namespace Arabica::DOM; + +// the wrapped* C++ classes get rid of DOM nodes and provide more easily wrapped base classes +#include "../wrapped/WrappedInvoker.cpp" +#include "../wrapped/WrappedDataModel.cpp" +#include "../wrapped/WrappedExecutableContent.cpp" +#include "../wrapped/WrappedIOProcessor.cpp" +#include "../wrapped/WrappedInterpreterMonitor.cpp" + +%} + +%insert("begin") %{ +void*** tsrm_ls; +%} + +#if 0 +%define WRAP_THROW_EXCEPTION( MATCH ) +%javaexception("org.uscxml.InterpreterException") MATCH { + try { + $action + } + catch ( uscxml::Event& e ) { + jclass eclass = jenv->FindClass("org/uscxml/InterpreterException"); + if ( eclass ) { + std::stringstream ss; + ss << std::endl << e; + jenv->ThrowNew( eclass, ss.str().c_str() ); + } + } +} +%enddef + +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromXML); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::fromURL); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::step); +WRAP_THROW_EXCEPTION(uscxml::Interpreter::interpret); +#endif + +%define WRAP_HASHCODE( CLASSNAME ) +%extend CLASSNAME { + virtual int hashCode() { +/* std::cout << "Calc hashcode as " << (int)(size_t)self->getImpl().get() << std::endl << std::flush;*/ + return (int)(size_t)self->getImpl().get(); + } +}; +%enddef + +%define WRAP_TO_STRING( CLASSNAME ) +%extend CLASSNAME { + virtual std::string toString() { + std::stringstream ss; + ss << *self; + return ss.str(); + } +}; +%enddef + +WRAP_TO_STRING(uscxml::Event); +WRAP_TO_STRING(uscxml::Data); +WRAP_TO_STRING(uscxml::InterpreterIssue); + +WRAP_HASHCODE(uscxml::Interpreter); + +%include "../uscxml_ignores.i" + +// bytearray for Blob::data +// see: http://stackoverflow.com/questions/9934059/swig-technique-to-wrap-unsigned-binary-data + +%apply (char *STRING, size_t LENGTH) { (const char* data, size_t size) }; + +#if 0 +%typemap(jni) char* getData "jbyteArray" +%typemap(jtype) char* getData "byte[]" +%typemap(jstype) char* getData "byte[]" +%typemap(javaout) char* getData { + return $jnicall; +} + +%typemap(out) char* getData { + $result = JCALL1(NewByteArray, jenv, ((uscxml::Blob const *)arg1)->getSize()); + JCALL4(SetByteArrayRegion, jenv, $result, 0, ((uscxml::Blob const *)arg1)->getSize(), (jbyte *)$1); +} +#endif + +//*********************************************** +// Beautify important classes +//*********************************************** + +#if 0 +%javamethodmodifiers uscxml::Event::getParamMap() "private"; +%javamethodmodifiers uscxml::Event::getParamMapKeys() "private"; +%javamethodmodifiers uscxml::Event::setParamMap(const std::map<std::string, std::list<uscxml::Data> >&) "private"; +%javamethodmodifiers uscxml::Event::getNameListKeys() "private"; +%javamethodmodifiers uscxml::Interpreter::getIOProcessorKeys() "private"; +%javamethodmodifiers uscxml::Interpreter::getInvokerKeys() "private"; +%javamethodmodifiers uscxml::Interpreter::getInvokers() "private"; +%javamethodmodifiers uscxml::Interpreter::getIOProcessors() "private"; +%javamethodmodifiers uscxml::Data::getCompoundKeys() "private"; + +%javamethodmodifiers uscxml::Blob::setData(const char* data, size_t length) "private"; +%javamethodmodifiers uscxml::Blob::setMimeType(const std::string& mimeType) "private"; +#endif + +%include "../uscxml_beautify.i" + + +%typemap(javaimports) uscxml::Interpreter %{ +import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.LinkedList; +import java.net.URL; +%} + +%typemap(javacode) uscxml::Interpreter %{ + public static Interpreter fromURL(URL uri) throws org.uscxml.InterpreterException { + return Interpreter.fromURL(uri.toString()); + } + + public Map<String, NativeIOProcessor> getIOProcessors() { + Map<String, NativeIOProcessor> ioProcs = new HashMap<String, NativeIOProcessor>(); + StringVector keys = getIOProcessorKeys(); + IOProcMap ioProcMap = getIOProcessorsNative(); + for (int i = 0; i < keys.size(); i++) { + ioProcs.put(keys.get(i), ioProcMap.get(keys.get(i))); + } + return ioProcs; + } + + public Map<String, NativeInvoker> getInvokers() { + Map<String, NativeInvoker> invokers = new HashMap<String, NativeInvoker>(); + StringVector keys = getInvokerKeys(); + InvokerMap invokerMap = getInvokersNative(); + for (int i = 0; i < keys.size(); i++) { + invokers.put(keys.get(i), invokerMap.get(keys.get(i))); + } + return invokers; + } + + @Override + public boolean equals(Object other) { + if (other instanceof Interpreter) { + return equals((Interpreter)other); + } + return hashCode() == other.hashCode(); + } +%} + +#if 0 +%rename(getCompoundNative) uscxml::Data::getCompound(); +%rename(getArrayNative) uscxml::Data::getArray(); +%rename(setCompoundNative) uscxml::Data::setCompound(const std::map<std::string, Data>&); +%rename(setArrayNative) uscxml::Data::setArray(const std::list<Data>&); +%javamethodmodifiers uscxml::Data::getCompound() "private"; +%javamethodmodifiers uscxml::Data::getArray() "private"; +%javamethodmodifiers uscxml::Data::setCompound(const std::map<std::string, Data>&) "private"; +%javamethodmodifiers uscxml::Data::setArray(const std::list<Data>&) "private"; +%javamethodmodifiers uscxml::Data::getCompoundKeys() "private"; +#endif + +%typemap(javaimports) uscxml::Data %{ +import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.LinkedList; +%} + +%typemap(javacode) uscxml::Data %{ + public Data(byte[] data, String mimeType) { + this(uscxmlNativeJavaJNI.new_Data__SWIG_0(), true); + setBinary(new Blob(data, mimeType)); + } + + public Data(Map<String, Data> compound) { + this(uscxmlNativeJavaJNI.new_Data__SWIG_0(), true); + setCompound(compound); + } + + public Data(List<Data> array) { + this(uscxmlNativeJavaJNI.new_Data__SWIG_0(), true); + setArray(array); + } + + public Map<String, Data> getCompound() { + Map<String, Data> compound = new HashMap<String, Data>(); + DataMap dataMap = getCompoundNative(); + StringVector dataMapKeys = getCompoundKeys(); + for (int i = 0; i < dataMapKeys.size(); i++) { + compound.put(dataMapKeys.get(i), dataMap.get(dataMapKeys.get(i))); + } + return compound; + } + + public void setCompound(Map<String, Data> compound) { + DataMap dataMap = new DataMap(); + for (String key : compound.keySet()) { + dataMap.set(key, compound.get(key)); + } + setCompoundNative(dataMap); + } + + public List<Data> getArray() { + List<Data> array = new LinkedList<Data>(); + DataList dataList = getArrayNative(); + for (int i = 0; i < dataList.size(); i++) { + array.add(dataList.get(i)); + } + return array; + } + + public void setArray(List<Data> array) { + DataList dataList = new DataList(); + for (Data data : array) { + dataList.add(data); + } + setArrayNative(dataList); + } + +%} + +#if 0 +%rename(getNameListNative) uscxml::Event::getNameList(); +%rename(getParamsNative) uscxml::Event::getParams(); +%rename(setNameListNative) uscxml::Event::setNameList(const std::map<std::string, Data>&); +%rename(setParamsNative) uscxml::Event::setParams(const std::multimap<std::string, Data>&); +%javamethodmodifiers uscxml::Event::getNameList() "private"; +%javamethodmodifiers uscxml::Event::getNameListKeys() "private"; +%javamethodmodifiers uscxml::Event::getParams() "private"; +%javamethodmodifiers uscxml::Event::setNameList(const std::map<std::string, Data>&) "private"; +%javamethodmodifiers uscxml::Event::setParams(const std::multimap<std::string, Data>&) "private"; +#endif + +%typemap(javaimports) uscxml::Event %{ +import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.LinkedList; +%} + +%typemap(javacode) uscxml::Event %{ + public Map<String, List<Data>> getParams() { + Map<String, List<Data>> params = new HashMap<String, List<Data>>(); + ParamMap paramMap = getParamMap(); + StringVector paramMapKeys = getParamMapKeys(); + + for (int i = 0; i < paramMapKeys.size(); i++) { + String key = paramMapKeys.get(i); + DataList dataList = paramMap.get(key); + + for (int j = 0; j < dataList.size(); j++) { + Data data = dataList.get(j); + if (!params.containsKey(key)) + params.put(key, new LinkedList<Data>()); + params.get(key).add(data); + } + } + return params; + } + + public void setParams(Map<String, List<Data>> params) { + ParamMap paramMap = new ParamMap(); + for (String key : params.keySet()) { + DataList datalist = new DataList(); + for (Data data : params.get(key)) { + datalist.add(data); + } + paramMap.set(key, datalist); + } + setParamMap(paramMap); + } + + public Map<String, Data> getNameList() { + Map<String, Data> namelist = new HashMap<String, Data>(); + StringVector nameMapKeys = getNameListKeys(); + DataMap nameMap = getNameListNative(); + + for (int i = 0; i < nameMapKeys.size(); i++) { + namelist.put(nameMapKeys.get(i), nameMap.get(nameMapKeys.get(i))); + } + return namelist; + } + + public void setNameList(Map<String, Data> namelist) { + DataMap nameListMap = new DataMap(); + for (String key : namelist.keySet()) { + nameListMap.set(key, namelist.get(key)); + } + setNameListNative(nameListMap); + } +%} + + +//*********************************************** +// Parse the header file to generate wrappers +//*********************************************** + +%include "../../../uscxml/Common.h" +%include "../../../uscxml/Factory.h" +%include "../../../uscxml/Message.h" +%include "../../../uscxml/Interpreter.h" +%include "../../../uscxml/interpreter/InterpreterState.h" +%include "../../../uscxml/concurrency/BlockingQueue.h" +%include "../../../uscxml/server/HTTPServer.h" +//%include "../../../uscxml/debug/DebuggerServlet.h" +%include "../../../uscxml/debug/InterpreterIssue.h" + +%include "../../../uscxml/messages/Blob.h" +%include "../../../uscxml/messages/Data.h" +%include "../../../uscxml/messages/Event.h" + +%include "../../../uscxml/plugins/DataModel.h" +%include "../../../uscxml/plugins/EventHandler.h" +%include "../../../uscxml/plugins/ExecutableContent.h" +%include "../../../uscxml/plugins/Invoker.h" +%include "../../../uscxml/plugins/IOProcessor.h" + +%include "../wrapped/WrappedInvoker.h" +%include "../wrapped/WrappedDataModel.h" +%include "../wrapped/WrappedExecutableContent.h" +%include "../wrapped/WrappedIOProcessor.h" +%include "../wrapped/WrappedInterpreterMonitor.h" + + +%template(IssueList) std::list<uscxml::InterpreterIssue>; +%template(DataList) std::list<uscxml::Data>; +%template(DataMap) std::map<std::string, uscxml::Data>; +%template(StringSet) std::set<std::string>; +%template(StringVector) std::vector<std::string>; +%template(StringList) std::list<std::string>; +%template(ParamMap) std::map<std::string, std::list<uscxml::Data> >; +%template(IOProcMap) std::map<std::string, IOProcessor>; +%template(InvokerMap) std::map<std::string, Invoker>; diff --git a/src/bindings/swig/php/uscxmlNativePHP.php b/src/bindings/swig/php/uscxmlNativePHP.php new file mode 100644 index 0000000..eac292b --- /dev/null +++ b/src/bindings/swig/php/uscxmlNativePHP.php @@ -0,0 +1,3121 @@ +<?php + +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 3.0.7 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +// Try to load our extension if it's not already loaded. +if (!extension_loaded('uscxmlNativePHP')) { + if (strtolower(substr(PHP_OS, 0, 3)) === 'win') { + if (!dl('php_uscxmlNativePHP.dll')) return; + } else { + // PHP_SHLIB_SUFFIX gives 'dylib' on MacOS X but modules are 'so'. + if (PHP_SHLIB_SUFFIX === 'dylib') { + if (!dl('uscxmlNativePHP.so')) return; + } else { + if (!dl('uscxmlNativePHP.'.PHP_SHLIB_SUFFIX)) return; + } + } +} + + + +abstract class uscxmlNativePHP { + const SWIGIMPORTED = SWIGIMPORTED; + + static function imaxabs($n) { + return imaxabs($n); + } + + static function imaxdiv($numer,$denom) { + $r=imaxdiv($numer,$denom); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new imaxdiv_t($r); + } + return $r; + } + + static function strtoimax($nptr,$endptr,$base) { + return strtoimax($nptr,$endptr,$base); + } + + static function strtoumax($nptr,$endptr,$base) { + return strtoumax($nptr,$endptr,$base); + } + + const CAN_NOTHING = 0; + + const CAN_BASIC_HTTP = 1; + + const CAN_GENERIC_HTTP = 2; + + const USCXML_DESTROYED = -2; + + const USCXML_FINISHED = -1; + + const USCXML_IDLE = 0; + + const USCXML_INSTANTIATED = 1; + + const USCXML_MICROSTEPPED = 2; + + const USCXML_MACROSTEPPED = 4; + + static function _dataIndentation_set($_dataIndentation) { + _dataIndentation_set($_dataIndentation); + } + + static function _dataIndentation_get() { + return _dataIndentation_get(); + } +} + +/* PHP Proxy Classes */ +class imaxdiv_t { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'quot') return imaxdiv_t_quot_set($this->_cPtr,$value); + if ($var === 'rem') return imaxdiv_t_rem_set($this->_cPtr,$value); + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'quot') return imaxdiv_t_quot_get($this->_cPtr); + if ($var === 'rem') return imaxdiv_t_rem_get($this->_cPtr); + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('imaxdiv_t_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_imaxdiv_t') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_imaxdiv_t(); + } +} + +class Factory { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($parentFactory_or_pluginPath,$parentFactory=null) { + if (is_resource($parentFactory_or_pluginPath) && get_resource_type($parentFactory_or_pluginPath) === '_p_uscxml__Factory') { + $this->_cPtr=$parentFactory_or_pluginPath; + return; + } + switch (func_num_args()) { + case 1: $this->_cPtr=new_Factory($parentFactory_or_pluginPath); break; + default: $this->_cPtr=new_Factory($parentFactory_or_pluginPath,$parentFactory); + } + } + + function registerIOProcessor($ioProcessor) { + Factory_registerIOProcessor($this->_cPtr,$ioProcessor); + } + + function registerDataModel($dataModel) { + Factory_registerDataModel($this->_cPtr,$dataModel); + } + + function registerInvoker($invoker) { + Factory_registerInvoker($this->_cPtr,$invoker); + } + + function registerExecutableContent($executableContent) { + Factory_registerExecutableContent($this->_cPtr,$executableContent); + } + + function hasDataModel($type) { + return Factory_hasDataModel($this->_cPtr,$type); + } + + function hasIOProcessor($type) { + return Factory_hasIOProcessor($this->_cPtr,$type); + } + + function hasInvoker($type) { + return Factory_hasInvoker($this->_cPtr,$type); + } + + function hasExecutableContent($localName,$nameSpace) { + return Factory_hasExecutableContent($this->_cPtr,$localName,$nameSpace); + } + + function listComponents() { + Factory_listComponents($this->_cPtr); + } + + static function getInstance() { + $r=Factory_getInstance(); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Factory($r); + } + return $r; + } + + static function setDefaultPluginPath($path) { + Factory_setDefaultPluginPath($path); + } + + static function getDefaultPluginPath() { + return Factory_getDefaultPluginPath(); + } +} + +class InterpreterOptions { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + $func = 'InterpreterOptions_'.$var.'_set'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr,$value); + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + $func = 'InterpreterOptions_'.$var.'_get'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr); + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('InterpreterOptions_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__InterpreterOptions') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_InterpreterOptions(); + } + + function isValid() { + return InterpreterOptions_isValid($this->_cPtr); + } + + static function printUsageAndExit($progName) { + InterpreterOptions_printUsageAndExit($progName); + } + + function getCapabilities() { + return InterpreterOptions_getCapabilities($this->_cPtr); + } +} + +class NameSpaceInfo { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__NameSpaceInfo') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NameSpaceInfo(); + } + + function getXMLPrefixForNS($ns) { + return NameSpaceInfo_getXMLPrefixForNS($this->_cPtr,$ns); + } +} + +class Interpreter { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + static function fromXML($xml,$sourceURL) { + $r=Interpreter_fromXML($xml,$sourceURL); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Interpreter($r); + } + return $r; + } + + static function fromURL($URL) { + $r=Interpreter_fromURL($URL); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Interpreter($r); + } + return $r; + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__Interpreter') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_Interpreter(); + } + + function isValid() { + return Interpreter_isValid($this->_cPtr); + } + + function equals($other) { + return Interpreter_equals($this->_cPtr,$other); + } + + function writeTo($stream) { + Interpreter_writeTo($this->_cPtr,$stream); + } + + function reset() { + Interpreter_reset($this->_cPtr); + } + + function interpret() { + Interpreter_interpret($this->_cPtr); + } + + function step($waitForMS_or_blocking=null) { + switch (func_num_args()) { + case 0: $r=Interpreter_step($this->_cPtr); break; + default: $r=Interpreter_step($this->_cPtr,$waitForMS_or_blocking); + } + return $r; + } + + function validate() { + $r=Interpreter_validate($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new IssueList($r); + } + return $r; + } + + function getState() { + return Interpreter_getState($this->_cPtr); + } + + function addMonitor($monitor) { + Interpreter_addMonitor($this->_cPtr,$monitor); + } + + function removeMonitor($monitor) { + Interpreter_removeMonitor($this->_cPtr,$monitor); + } + + function setSourceURL($sourceURL) { + Interpreter_setSourceURL($this->_cPtr,$sourceURL); + } + + function getSourceURL() { + return Interpreter_getSourceURL($this->_cPtr); + } + + function getBaseURL($xpathExpr=null) { + switch (func_num_args()) { + case 0: $r=Interpreter_getBaseURL($this->_cPtr); break; + default: $r=Interpreter_getBaseURL($this->_cPtr,$xpathExpr); + } + return $r; + } + + function setNameSpaceInfo($nsInfo) { + Interpreter_setNameSpaceInfo($this->_cPtr,$nsInfo); + } + + function getNameSpaceInfo() { + $r=Interpreter_getNameSpaceInfo($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NameSpaceInfo($r); + } + return $r; + } + + function getCmdLineOptions() { + $r=Interpreter_getCmdLineOptions($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function getDataModel() { + $r=Interpreter_getDataModel($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NativeDataModel($r); + } + return $r; + } + + function getIOProcessorsNative() { + $r=Interpreter_getIOProcessorsNative($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new IOProcMap($r); + } + return $r; + } + + function getInvokersNative() { + $r=Interpreter_getInvokersNative($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new InvokerMap($r); + } + return $r; + } + + function addDataModelExtension($ext) { + Interpreter_addDataModelExtension($this->_cPtr,$ext); + } + + function setParentQueue($parentQueue) { + Interpreter_setParentQueue($this->_cPtr,$parentQueue); + } + + function setFactory($factory) { + Interpreter_setFactory($this->_cPtr,$factory); + } + + function getFactory() { + $r=Interpreter_getFactory($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Factory($r); + } + return $r; + } + + function receiveInternal($event) { + Interpreter_receiveInternal($this->_cPtr,$event); + } + + function receive($event,$toFront=false) { + Interpreter_receive($this->_cPtr,$event,$toFront); + } + + function getCurrentEvent() { + $r=Interpreter_getCurrentEvent($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Event($r); + } + return $r; + } + + function isInState($stateId) { + return Interpreter_isInState($this->_cPtr,$stateId); + } + + function setInitalConfiguration($states) { + Interpreter_setInitalConfiguration($this->_cPtr,$states); + } + + function setCapabilities($capabilities) { + Interpreter_setCapabilities($this->_cPtr,$capabilities); + } + + function setName($name) { + Interpreter_setName($this->_cPtr,$name); + } + + function getName() { + return Interpreter_getName($this->_cPtr); + } + + function getSessionId() { + return Interpreter_getSessionId($this->_cPtr); + } + + function hasLegalConfiguration() { + return Interpreter_hasLegalConfiguration($this->_cPtr); + } + + function isLegalConfiguration($config) { + return Interpreter_isLegalConfiguration($this->_cPtr,$config); + } + + function hashCode() { + return Interpreter_hashCode($this->_cPtr); + } + + function addIOProcessor($ioProc) { + Interpreter_addIOProcessor($this->_cPtr,$ioProc); + } + + function setDataModel($dataModel) { + Interpreter_setDataModel($this->_cPtr,$dataModel); + } + + function setInvoker($invokeId,$invoker) { + Interpreter_setInvoker($this->_cPtr,$invokeId,$invoker); + } + + function getBasicConfiguration() { + $r=Interpreter_getBasicConfiguration($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getConfiguration() { + $r=Interpreter_getConfiguration($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getIOProcessorKeys() { + $r=Interpreter_getIOProcessorKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getInvokerKeys() { + $r=Interpreter_getInvokerKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } +} + +class NativeInterpreterMonitor { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__InterpreterMonitor') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeInterpreterMonitor(); + } + + function beforeProcessingEvent($interpreter,$event) { + NativeInterpreterMonitor_beforeProcessingEvent($this->_cPtr,$interpreter,$event); + } + + function beforeMicroStep($interpreter) { + NativeInterpreterMonitor_beforeMicroStep($this->_cPtr,$interpreter); + } + + function afterMicroStep($interpreter) { + NativeInterpreterMonitor_afterMicroStep($this->_cPtr,$interpreter); + } + + function onStableConfiguration($interpreter) { + NativeInterpreterMonitor_onStableConfiguration($this->_cPtr,$interpreter); + } + + function beforeCompletion($interpreter) { + NativeInterpreterMonitor_beforeCompletion($this->_cPtr,$interpreter); + } + + function afterCompletion($interpreter) { + NativeInterpreterMonitor_afterCompletion($this->_cPtr,$interpreter); + } + + function reportIssue($interpreter,$issue) { + NativeInterpreterMonitor_reportIssue($this->_cPtr,$interpreter,$issue); + } + + function copyToInvokers($copy=null) { + switch (func_num_args()) { + case 0: $r=NativeInterpreterMonitor_copyToInvokers($this->_cPtr); break; + default: $r=NativeInterpreterMonitor_copyToInvokers($this->_cPtr,$copy); + } + return $r; + } +} + +class StateTransitionMonitor extends NativeInterpreterMonitor { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + NativeInterpreterMonitor::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return NativeInterpreterMonitor::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return NativeInterpreterMonitor::__isset($var); + } + + function beforeTakingTransition($interpreter,$transition,$moreComing) { + StateTransitionMonitor_beforeTakingTransition($this->_cPtr,$interpreter,$transition,$moreComing); + } + + function onStableConfiguration($interpreter) { + StateTransitionMonitor_onStableConfiguration($this->_cPtr,$interpreter); + } + + function beforeProcessingEvent($interpreter,$event) { + StateTransitionMonitor_beforeProcessingEvent($this->_cPtr,$interpreter,$event); + } + + function beforeExitingState($interpreter,$state,$moreComing) { + StateTransitionMonitor_beforeExitingState($this->_cPtr,$interpreter,$state,$moreComing); + } + + function beforeEnteringState($interpreter,$state,$moreComing) { + StateTransitionMonitor_beforeEnteringState($this->_cPtr,$interpreter,$state,$moreComing); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__StateTransitionMonitor') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_StateTransitionMonitor(); + } +} + +class HTTPServer { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + const HTTPS = 0; + + const HTTP = HTTPServer_HTTP; + + const WebSockets = HTTPServer_WebSockets; + + static function getInstance($port=null,$wsPort=null,$sslConf=null) { + switch (func_num_args()) { + case 0: $r=HTTPServer_getInstance(); break; + case 1: $r=HTTPServer_getInstance($port); break; + default: $r=HTTPServer_getInstance($port,$wsPort,$sslConf); + } + if (!is_resource($r)) return $r; + return new HTTPServer($r); + } + + static function getBaseURL($type=null) { + switch (func_num_args()) { + case 0: $r=HTTPServer_getBaseURL(); break; + default: $r=HTTPServer_getBaseURL($type); + } + return $r; + } + + static function registerServlet($path,$servlet) { + return HTTPServer_registerServlet($path,$servlet); + } + + static function unregisterServlet($servlet) { + HTTPServer_unregisterServlet($servlet); + } +} + +abstract class HTTPServlet { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function httpRecvRequest($request) { + return HTTPServlet_httpRecvRequest($this->_cPtr,$request); + } + + function setURL($url) { + HTTPServlet_setURL($this->_cPtr,$url); + } + + function canAdaptPath() { + return HTTPServlet_canAdaptPath($this->_cPtr); + } +} + +abstract class WebSocketServlet { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function wsRecvRequest($conn,$frame) { + return WebSocketServlet_wsRecvRequest($this->_cPtr,$conn,$frame); + } + + function setURL($url) { + WebSocketServlet_setURL($this->_cPtr,$url); + } + + function canAdaptPath() { + return WebSocketServlet_canAdaptPath($this->_cPtr); + } +} + +class InterpreterIssue { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + $func = 'InterpreterIssue_'.$var.'_set'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr,$value); + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + $func = 'InterpreterIssue_'.$var.'_get'; + if (function_exists($func)) return call_user_func($func,$this->_cPtr); + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if (function_exists('InterpreterIssue_'.$var.'_get')) return true; + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + const USCXML_ISSUE_FATAL = 0; + + const USCXML_ISSUE_WARNING = InterpreterIssue_USCXML_ISSUE_WARNING; + + const USCXML_ISSUE_INFO = InterpreterIssue_USCXML_ISSUE_INFO; + + function __construct($msg,$node,$severity,$specRef=null) { + if (is_resource($msg) && get_resource_type($msg) === '_p_uscxml__InterpreterIssue') { + $this->_cPtr=$msg; + return; + } + switch (func_num_args()) { + case 3: $this->_cPtr=new_InterpreterIssue($msg,$node,$severity); break; + default: $this->_cPtr=new_InterpreterIssue($msg,$node,$severity,$specRef); + } + } + + function toString() { + return InterpreterIssue_toString($this->_cPtr); + } +} + +class Blob { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($other_or_data=null,$mimeType=null) { + if (is_resource($other_or_data) && get_resource_type($other_or_data) === '_p_uscxml__Blob') { + $this->_cPtr=$other_or_data; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_Blob(); break; + case 1: $this->_cPtr=new_Blob($other_or_data); break; + default: $this->_cPtr=new_Blob($other_or_data,$mimeType); + } + } + + function isValid() { + return Blob_isValid($this->_cPtr); + } + + function equals($other) { + return Blob_equals($this->_cPtr,$other); + } + + static function fromBase64($base64,$mimeType=null) { + switch (func_num_args()) { + case 1: $r=Blob_fromBase64($base64); break; + default: $r=Blob_fromBase64($base64,$mimeType); + } + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Blob($r); + } + return $r; + } + + function base64() { + return Blob_base64($this->_cPtr); + } + + function md5() { + return Blob_md5($this->_cPtr); + } + + function getData() { + return Blob_getData($this->_cPtr); + } + + function getSize() { + return Blob_getSize($this->_cPtr); + } + + function getMimeType() { + return Blob_getMimeType($this->_cPtr); + } + + function setMimeType($mimeType) { + Blob_setMimeType($this->_cPtr,$mimeType); + } +} + +class Data { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + const VERBATIM = 0; + + const INTERPRETED = Data_INTERPRETED; + + function __construct($atom=null,$type=null) { + if (is_resource($atom) && get_resource_type($atom) === '_p_uscxml__Data') { + $this->_cPtr=$atom; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_Data(); break; + case 1: $this->_cPtr=new_Data($atom); break; + default: $this->_cPtr=new_Data($atom,$type); + } + } + + function c_empty() { + return Data_c_empty($this->_cPtr); + } + + function merge($other) { + Data_merge($this->_cPtr,$other); + } + + function hasKey($key) { + return Data_hasKey($this->_cPtr,$key); + } + + function at($key) { + $r=Data_at($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function item($index) { + $r=Data_item($this->_cPtr,$index); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function put($key_or_index,$data) { + Data_put($this->_cPtr,$key_or_index,$data); + } + + function equals($other) { + return Data_equals($this->_cPtr,$other); + } + + static function fromJSON($jsonString) { + $r=Data_fromJSON($jsonString); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + static function toJSON($data) { + return Data_toJSON($data); + } + + static function fromXML($xmlString) { + $r=Data_fromXML($xmlString); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function toXMLString() { + return Data_toXMLString($this->_cPtr); + } + + function getCompound() { + $r=Data_getCompound($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataMap($r); + } + return $r; + } + + function setCompound($compound) { + Data_setCompound($this->_cPtr,$compound); + } + + function getArray() { + $r=Data_getArray($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataList($r); + } + return $r; + } + + function setArray($array) { + Data_setArray($this->_cPtr,$array); + } + + function getAtom() { + return Data_getAtom($this->_cPtr); + } + + function setAtom($atom) { + Data_setAtom($this->_cPtr,$atom); + } + + function getBinary() { + $r=Data_getBinary($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Blob($r); + } + return $r; + } + + function setBinary($binary) { + Data_setBinary($this->_cPtr,$binary); + } + + function getType() { + return Data_getType($this->_cPtr); + } + + function setType($type) { + Data_setType($this->_cPtr,$type); + } + + function toString() { + return Data_toString($this->_cPtr); + } + + function getCompoundKeys() { + $r=Data_getCompoundKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function getXML() { + return Data_getXML($this->_cPtr); + } + + function setXML($xml) { + Data_setXML($this->_cPtr,$xml); + } +} + +class Event { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + const INTERNAL = 1; + + const EXTERNAL = 2; + + const PLATFORM = 3; + + function __construct($name=null,$type=null) { + if (is_resource($name) && get_resource_type($name) === '_p_uscxml__Event') { + $this->_cPtr=$name; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_Event(); break; + case 1: $this->_cPtr=new_Event($name); break; + default: $this->_cPtr=new_Event($name,$type); + } + } + + function equals($other) { + return Event_equals($this->_cPtr,$other); + } + + function getName() { + return Event_getName($this->_cPtr); + } + + function setName($name) { + Event_setName($this->_cPtr,$name); + } + + function getEventType() { + return Event_getEventType($this->_cPtr); + } + + function setEventType($type) { + Event_setEventType($this->_cPtr,$type); + } + + function getOrigin() { + return Event_getOrigin($this->_cPtr); + } + + function setOrigin($origin) { + Event_setOrigin($this->_cPtr,$origin); + } + + function getOriginType() { + return Event_getOriginType($this->_cPtr); + } + + function setOriginType($originType) { + Event_setOriginType($this->_cPtr,$originType); + } + + function getDOM() { + return Event_getDOM($this->_cPtr); + } + + function getRaw() { + return Event_getRaw($this->_cPtr); + } + + function setRaw($raw) { + Event_setRaw($this->_cPtr,$raw); + } + + function getContent() { + return Event_getContent($this->_cPtr); + } + + function setContent($content) { + Event_setContent($this->_cPtr,$content); + } + + function getXML() { + return Event_getXML($this->_cPtr); + } + + function setXML($xml) { + Event_setXML($this->_cPtr,$xml); + } + + function getSendId() { + return Event_getSendId($this->_cPtr); + } + + function setSendId($sendId) { + Event_setSendId($this->_cPtr,$sendId); + } + + function getInvokeId() { + return Event_getInvokeId($this->_cPtr); + } + + function setInvokeId($invokeId) { + Event_setInvokeId($this->_cPtr,$invokeId); + } + + function getData() { + $r=Event_getData($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function setData($data) { + Event_setData($this->_cPtr,$data); + } + + static function fromXML($xmlString) { + $r=Event_fromXML($xmlString); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Event($r); + } + return $r; + } + + function toXMLString() { + return Event_toXMLString($this->_cPtr); + } + + function getNameList() { + $r=Event_getNameList($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataMap($r); + } + return $r; + } + + function setNameList($nameList) { + Event_setNameList($this->_cPtr,$nameList); + } + + function toString() { + return Event_toString($this->_cPtr); + } + + function getParamMap() { + $r=Event_getParamMap($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new ParamMap($r); + } + return $r; + } + + function getParamMapKeys() { + $r=Event_getParamMapKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } + + function setParamMap($paramMap) { + Event_setParamMap($this->_cPtr,$paramMap); + } + + function getNameListKeys() { + $r=Event_getNameListKeys($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringVector($r); + } + return $r; + } +} + +class InvokeRequest extends Event { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + Event::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return Event::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return Event::__isset($var); + } + + function __construct($event=null) { + if (is_resource($event) && get_resource_type($event) === '_p_uscxml__InvokeRequest') { + $this->_cPtr=$event; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_InvokeRequest(); break; + default: $this->_cPtr=new_InvokeRequest($event); + } + } + + function getType() { + return InvokeRequest_getType($this->_cPtr); + } + + function setType($type) { + InvokeRequest_setType($this->_cPtr,$type); + } + + function getSource() { + return InvokeRequest_getSource($this->_cPtr); + } + + function setSource($src) { + InvokeRequest_setSource($this->_cPtr,$src); + } + + function isAutoForwarded() { + return InvokeRequest_isAutoForwarded($this->_cPtr); + } + + function setAutoForwarded($autoForward) { + InvokeRequest_setAutoForwarded($this->_cPtr,$autoForward); + } + + function toXMLString() { + return InvokeRequest_toXMLString($this->_cPtr); + } + + function toString() { + return InvokeRequest_toString($this->_cPtr); + } +} + +class SendRequest extends Event { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + Event::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return Event::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return Event::__isset($var); + } + + function __construct($event=null) { + if (is_resource($event) && get_resource_type($event) === '_p_uscxml__SendRequest') { + $this->_cPtr=$event; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_SendRequest(); break; + default: $this->_cPtr=new_SendRequest($event); + } + } + + function getTarget() { + return SendRequest_getTarget($this->_cPtr); + } + + function setTarget($target) { + SendRequest_setTarget($this->_cPtr,$target); + } + + function getType() { + return SendRequest_getType($this->_cPtr); + } + + function setType($type) { + SendRequest_setType($this->_cPtr,$type); + } + + function getDelayMs() { + return SendRequest_getDelayMs($this->_cPtr); + } + + function setDelayMs($delayMs) { + SendRequest_setDelayMs($this->_cPtr,$delayMs); + } + + function toXMLString() { + return SendRequest_toXMLString($this->_cPtr); + } + + function toString() { + return SendRequest_toString($this->_cPtr); + } +} + +abstract class NativeDataModelExtension { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function provides() { + return NativeDataModelExtension_provides($this->_cPtr); + } + + function getValueOf($member) { + $r=NativeDataModelExtension_getValueOf($this->_cPtr,$member); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function setValueOf($member,$data) { + NativeDataModelExtension_setValueOf($this->_cPtr,$member,$data); + } +} + +abstract class DataModelImpl { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function getNames() { + $r=DataModelImpl_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function validate($location,$schema) { + return DataModelImpl_validate($this->_cPtr,$location,$schema); + } + + function isLocation($expr) { + return DataModelImpl_isLocation($this->_cPtr,$expr); + } + + function isValidSyntax($expr) { + return DataModelImpl_isValidSyntax($this->_cPtr,$expr); + } + + function setEvent($event) { + DataModelImpl_setEvent($this->_cPtr,$event); + } + + function getStringAsData($content) { + $r=DataModelImpl_getStringAsData($this->_cPtr,$content); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function getLength($expr) { + return DataModelImpl_getLength($this->_cPtr,$expr); + } + + function setForeach($item,$array,$index,$iteration) { + DataModelImpl_setForeach($this->_cPtr,$item,$array,$index,$iteration); + } + + function pushContext() { + DataModelImpl_pushContext($this->_cPtr); + } + + function popContext() { + DataModelImpl_popContext($this->_cPtr); + } + + function evalAsString($expr) { + return DataModelImpl_evalAsString($this->_cPtr,$expr); + } + + function evalAsBool($scriptNode_or_expr,$expr=null) { + switch (func_num_args()) { + case 1: $r=DataModelImpl_evalAsBool($this->_cPtr,$scriptNode_or_expr); break; + default: $r=DataModelImpl_evalAsBool($this->_cPtr,$scriptNode_or_expr,$expr); + } + return $r; + } + + function isDeclared($expr) { + return DataModelImpl_isDeclared($this->_cPtr,$expr); + } + + function addExtension($ext) { + DataModelImpl_addExtension($this->_cPtr,$ext); + } + + function andExpressions($arg1) { + return DataModelImpl_andExpressions($this->_cPtr,$arg1); + } +} + +class NativeDataModel { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__DataModel') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeDataModel(); + } + + function isValid() { + return NativeDataModel_isValid($this->_cPtr); + } + + function equals($other) { + return NativeDataModel_equals($this->_cPtr,$other); + } + + function getNames() { + $r=NativeDataModel_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function validate($location,$schema) { + return NativeDataModel_validate($this->_cPtr,$location,$schema); + } + + function isLocation($expr) { + return NativeDataModel_isLocation($this->_cPtr,$expr); + } + + function isValidSyntax($expr) { + return NativeDataModel_isValidSyntax($this->_cPtr,$expr); + } + + function setEvent($event) { + NativeDataModel_setEvent($this->_cPtr,$event); + } + + function getStringAsData($content) { + $r=NativeDataModel_getStringAsData($this->_cPtr,$content); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function pushContext() { + NativeDataModel_pushContext($this->_cPtr); + } + + function popContext() { + NativeDataModel_popContext($this->_cPtr); + } + + function evalAsString($expr) { + return NativeDataModel_evalAsString($this->_cPtr,$expr); + } + + function evalAsBool($scriptNode,$expr) { + return NativeDataModel_evalAsBool($this->_cPtr,$scriptNode,$expr); + } + + function getLength($expr) { + return NativeDataModel_getLength($this->_cPtr,$expr); + } + + function setForeach($item,$array,$index,$iteration) { + NativeDataModel_setForeach($this->_cPtr,$item,$array,$index,$iteration); + } + + function assign($location,$data) { + NativeDataModel_assign($this->_cPtr,$location,$data); + } + + function init($location,$data) { + NativeDataModel_init($this->_cPtr,$location,$data); + } + + function isDeclared($expr) { + return NativeDataModel_isDeclared($this->_cPtr,$expr); + } + + function andExpressions($expressions) { + return NativeDataModel_andExpressions($this->_cPtr,$expressions); + } + + function addExtension($ext) { + NativeDataModel_addExtension($this->_cPtr,$ext); + } +} + +abstract class EventHandlerImpl { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function getNames() { + $r=EventHandlerImpl_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function setInvokeId($invokeId) { + EventHandlerImpl_setInvokeId($this->_cPtr,$invokeId); + } + + function setType($type) { + EventHandlerImpl_setType($this->_cPtr,$type); + } + + function getType() { + return EventHandlerImpl_getType($this->_cPtr); + } + + function getDataModelVariables() { + $r=EventHandlerImpl_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + EventHandlerImpl_send($this->_cPtr,$req); + } + + function returnErrorExecution($arg1) { + EventHandlerImpl_returnErrorExecution($this->_cPtr,$arg1); + } + + function returnErrorCommunication($arg1) { + EventHandlerImpl_returnErrorCommunication($this->_cPtr,$arg1); + } + + function returnEvent($event,$internal=false) { + EventHandlerImpl_returnEvent($this->_cPtr,$event,$internal); + } +} + +class EventHandler { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($other=null) { + if (is_resource($other) && get_resource_type($other) === '_p_uscxml__EventHandler') { + $this->_cPtr=$other; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_EventHandler(); break; + default: $this->_cPtr=new_EventHandler($other); + } + } + + function getNames() { + $r=EventHandler_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function getDataModelVariables() { + $r=EventHandler_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + EventHandler_send($this->_cPtr,$req); + } + + function setInvokeId($invokeId) { + EventHandler_setInvokeId($this->_cPtr,$invokeId); + } + + function setType($type) { + EventHandler_setType($this->_cPtr,$type); + } + + function getType() { + return EventHandler_getType($this->_cPtr); + } +} + +abstract class ExecutableContentImpl { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function getLocalName() { + return ExecutableContentImpl_getLocalName($this->_cPtr); + } + + function getNamespace() { + return ExecutableContentImpl_getNamespace($this->_cPtr); + } + + function enterElement($node) { + ExecutableContentImpl_enterElement($this->_cPtr,$node); + } + + function exitElement($node) { + ExecutableContentImpl_exitElement($this->_cPtr,$node); + } + + function processChildren() { + return ExecutableContentImpl_processChildren($this->_cPtr); + } +} + +class NativeExecutableContent { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__ExecutableContent') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeExecutableContent(); + } + + function isValid() { + return NativeExecutableContent_isValid($this->_cPtr); + } + + function equals($other) { + return NativeExecutableContent_equals($this->_cPtr,$other); + } + + function getLocalName() { + return NativeExecutableContent_getLocalName($this->_cPtr); + } + + function getNamespace() { + return NativeExecutableContent_getNamespace($this->_cPtr); + } + + function enterElement($node) { + NativeExecutableContent_enterElement($this->_cPtr,$node); + } + + function exitElement($node) { + NativeExecutableContent_exitElement($this->_cPtr,$node); + } + + function processChildren() { + return NativeExecutableContent_processChildren($this->_cPtr); + } +} + +abstract class InvokerImpl extends EventHandlerImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandlerImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandlerImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandlerImpl::__isset($var); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function invoke($req) { + InvokerImpl_invoke($this->_cPtr,$req); + } + + function uninvoke() { + InvokerImpl_uninvoke($this->_cPtr); + } + + function deleteOnUninvoke() { + return InvokerImpl_deleteOnUninvoke($this->_cPtr); + } +} + +class NativeInvoker extends EventHandler { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandler::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandler::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandler::__isset($var); + } + + function __construct($other=null) { + if (is_resource($other) && get_resource_type($other) === '_p_uscxml__Invoker') { + $this->_cPtr=$other; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_NativeInvoker(); break; + default: $this->_cPtr=new_NativeInvoker($other); + } + } + + function isValid() { + return NativeInvoker_isValid($this->_cPtr); + } + + function equals($other) { + return NativeInvoker_equals($this->_cPtr,$other); + } + + function invoke($req) { + NativeInvoker_invoke($this->_cPtr,$req); + } + + function uninvoke() { + NativeInvoker_uninvoke($this->_cPtr); + } + + function deleteOnUninvoke() { + return NativeInvoker_deleteOnUninvoke($this->_cPtr); + } +} + +abstract class IOProcessorImpl extends EventHandlerImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandlerImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandlerImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandlerImpl::__isset($var); + } + function __construct($h) { + $this->_cPtr=$h; + } +} + +class NativeIOProcessor extends EventHandler { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + EventHandler::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return EventHandler::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return EventHandler::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__IOProcessor') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_NativeIOProcessor(); + } + + function isValid() { + return NativeIOProcessor_isValid($this->_cPtr); + } + + function equals($other) { + return NativeIOProcessor_equals($this->_cPtr,$other); + } +} + +class Invoker extends InvokerImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + InvokerImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return InvokerImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return InvokerImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedInvoker') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'Invoker') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_Invoker($_this); + } + + function getNames() { + $r=Invoker_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function getDataModelVariables() { + $r=Invoker_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + Invoker_send($this->_cPtr,$req); + } + + function invoke($req) { + Invoker_invoke($this->_cPtr,$req); + } + + function uninvoke() { + Invoker_uninvoke($this->_cPtr); + } + + function deleteOnUninvoke() { + return Invoker_deleteOnUninvoke($this->_cPtr); + } + + function create($interpreter) { + $r=Invoker_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Invoker($r); + } + return $r; + } +} + +class DataModelExtension extends NativeDataModelExtension { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + NativeDataModelExtension::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return NativeDataModelExtension::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return NativeDataModelExtension::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedDataModelExtension') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'DataModelExtension') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_DataModelExtension($_this); + } + + function provides() { + return DataModelExtension_provides($this->_cPtr); + } + + function getValueOf($member) { + $r=DataModelExtension_getValueOf($this->_cPtr,$member); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function setValueOf($member,$data) { + DataModelExtension_setValueOf($this->_cPtr,$member,$data); + } +} + +class DataModel extends DataModelImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + DataModelImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return DataModelImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return DataModelImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedDataModel') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'DataModel') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_DataModel($_this); + } + + function create($interpreter) { + $r=DataModel_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataModel($r); + } + return $r; + } + + function getNames() { + $r=DataModel_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function andExpressions($arg0) { + return DataModel_andExpressions($this->_cPtr,$arg0); + } + + function validate($location,$schema) { + return DataModel_validate($this->_cPtr,$location,$schema); + } + + function setEvent($event) { + DataModel_setEvent($this->_cPtr,$event); + } + + function getStringAsData($content) { + $r=DataModel_getStringAsData($this->_cPtr,$content); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function getLength($expr) { + return DataModel_getLength($this->_cPtr,$expr); + } + + function setForeach($item,$array,$index,$iteration) { + DataModel_setForeach($this->_cPtr,$item,$array,$index,$iteration); + } + + function pushContext() { + DataModel_pushContext($this->_cPtr); + } + + function popContext() { + DataModel_popContext($this->_cPtr); + } + + function evalAsString($expr) { + return DataModel_evalAsString($this->_cPtr,$expr); + } + + function isDeclared($expr) { + return DataModel_isDeclared($this->_cPtr,$expr); + } + + function isLocation($expr) { + return DataModel_isLocation($this->_cPtr,$expr); + } + + function evalAsBool($expr_or_node_or_elem,$expr_or_content=null) { + switch (func_num_args()) { + case 1: $this->_cPtr=DataModel_evalAsBool($this->_cPtr,$expr_or_node_or_elem); break; + default: $this->_cPtr=DataModel_evalAsBool($this->_cPtr,$expr_or_node_or_elem,$expr_or_content); + } + return $r; + } + + function init($dataElem,$location,$content) { + DataModel_init($this->_cPtr,$dataElem,$location,$content); + } + + function assign($assignElem,$location,$content) { + DataModel_assign($this->_cPtr,$assignElem,$location,$content); + } + + function c_eval($scriptElem,$expr) { + DataModel_c_eval($this->_cPtr,$scriptElem,$expr); + } +} + +class ExecutableContent extends ExecutableContentImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + ExecutableContentImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return ExecutableContentImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return ExecutableContentImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedExecutableContent') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'ExecutableContent') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_ExecutableContent($_this); + } + + function create($interpreter) { + $r=ExecutableContent_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new ExecutableContent($r); + } + return $r; + } + + function getLocalName() { + return ExecutableContent_getLocalName($this->_cPtr); + } + + function getNamespace() { + return ExecutableContent_getNamespace($this->_cPtr); + } + + function processChildren() { + return ExecutableContent_processChildren($this->_cPtr); + } + + function enterElement($node) { + ExecutableContent_enterElement($this->_cPtr,$node); + } + + function exitElement($node) { + ExecutableContent_exitElement($this->_cPtr,$node); + } +} + +class IOProcessor extends IOProcessorImpl { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + IOProcessorImpl::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return IOProcessorImpl::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return IOProcessorImpl::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedIOProcessor') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'IOProcessor') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_IOProcessor($_this); + } + + function create($interpreter) { + $r=IOProcessor_create($this->_cPtr,$interpreter); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new IOProcessor($r); + } + return $r; + } + + function getNames() { + $r=IOProcessor_getNames($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new StringList($r); + } + return $r; + } + + function getDataModelVariables() { + $r=IOProcessor_getDataModelVariables($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function send($req) { + IOProcessor_send($this->_cPtr,$req); + } +} + +class InterpreterMonitor extends NativeInterpreterMonitor { + public $_cPtr=null; + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + NativeInterpreterMonitor::__set($var,$value); + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return NativeInterpreterMonitor::__get($var); + } + + function __isset($var) { + if ($var === 'thisown') return true; + return NativeInterpreterMonitor::__isset($var); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__WrappedInterpreterMonitor') { + $this->_cPtr=$res; + return; + } + if (get_class($this) === 'InterpreterMonitor') { + $_this = null; + } else { + $_this = $this; + } + $this->_cPtr=new_InterpreterMonitor($_this); + } + + function beforeExitingState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_beforeExitingState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function afterExitingState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_afterExitingState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function beforeExecutingContent($interpreter,$tagName,$xpath,$element) { + InterpreterMonitor_beforeExecutingContent($this->_cPtr,$interpreter,$tagName,$xpath,$element); + } + + function afterExecutingContent($interpreter,$tagName,$xpath,$element) { + InterpreterMonitor_afterExecutingContent($this->_cPtr,$interpreter,$tagName,$xpath,$element); + } + + function beforeUninvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_beforeUninvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function afterUninvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_afterUninvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function beforeTakingTransition($interpreter,$xpath,$source,$targets,$element,$moreComing) { + InterpreterMonitor_beforeTakingTransition($this->_cPtr,$interpreter,$xpath,$source,$targets,$element,$moreComing); + } + + function afterTakingTransition($interpreter,$xpath,$source,$targets,$element,$moreComing) { + InterpreterMonitor_afterTakingTransition($this->_cPtr,$interpreter,$xpath,$source,$targets,$element,$moreComing); + } + + function beforeEnteringState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_beforeEnteringState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function afterEnteringState($interpreter,$stateId,$xpath,$state,$moreComing) { + InterpreterMonitor_afterEnteringState($this->_cPtr,$interpreter,$stateId,$xpath,$state,$moreComing); + } + + function beforeInvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_beforeInvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function afterInvoking($interpreter,$xpath,$invokeid,$element) { + InterpreterMonitor_afterInvoking($this->_cPtr,$interpreter,$xpath,$invokeid,$element); + } + + function reportIssue($interpreter,$issue) { + InterpreterMonitor_reportIssue($this->_cPtr,$interpreter,$issue); + } +} + +class IssueList { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function c_list($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_std__listT_uscxml__InterpreterIssue_t') { + $this->_cPtr=$res; + return; + } + return new IssueList(new_c_list()); + } + + function size() { + return IssueList_size($this->_cPtr); + } + + function c_empty() { + return IssueList_c_empty($this->_cPtr); + } + + function clear() { + IssueList_clear($this->_cPtr); + } + + function add($x) { + IssueList_add($this->_cPtr,$x); + } + + function get($i) { + $r=IssueList_get($this->_cPtr,$i); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new InterpreterIssue($r); + } + return $r; + } +} + +class DataList { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function size() { + return DataList_size($this->_cPtr); + } + + function c_empty() { + return DataList_c_empty($this->_cPtr); + } + + function clear() { + DataList_clear($this->_cPtr); + } + + function add($x) { + DataList_add($this->_cPtr,$x); + } + + function get($i) { + $r=DataList_get($this->_cPtr,$i); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } +} + +class DataMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_uscxml__Data_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_DataMap(); break; + default: $this->_cPtr=new_DataMap($arg1); + } + } + + function size() { + return DataMap_size($this->_cPtr); + } + + function clear() { + DataMap_clear($this->_cPtr); + } + + function get($key) { + $r=DataMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new Data($r); + } + return $r; + } + + function set($key,$x) { + DataMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + DataMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return DataMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return DataMap_is_empty($this->_cPtr); + } +} + +class StringSet { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__setT_std__string_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_StringSet(); break; + default: $this->_cPtr=new_StringSet($arg1); + } + } + + function size() { + return StringSet_size($this->_cPtr); + } + + function c_empty() { + return StringSet_c_empty($this->_cPtr); + } + + function clear() { + StringSet_clear($this->_cPtr); + } + + function get($key) { + return StringSet_get($this->_cPtr,$key); + } + + function insert($key) { + StringSet_insert($this->_cPtr,$key); + } + + function del($key) { + StringSet_del($this->_cPtr,$key); + } + + function has_key($key) { + return StringSet_has_key($this->_cPtr,$key); + } +} + +class StringVector { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($n=null) { + if (is_resource($n) && get_resource_type($n) === '_p_std__vectorT_std__string_t') { + $this->_cPtr=$n; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_StringVector(); break; + default: $this->_cPtr=new_StringVector($n); + } + } + + function size() { + return StringVector_size($this->_cPtr); + } + + function capacity() { + return StringVector_capacity($this->_cPtr); + } + + function reserve($n) { + StringVector_reserve($this->_cPtr,$n); + } + + function clear() { + StringVector_clear($this->_cPtr); + } + + function push($x) { + StringVector_push($this->_cPtr,$x); + } + + function is_empty() { + return StringVector_is_empty($this->_cPtr); + } + + function pop() { + return StringVector_pop($this->_cPtr); + } + + function get($i) { + return StringVector_get($this->_cPtr,$i); + } + + function set($i,$val) { + StringVector_set($this->_cPtr,$i,$val); + } +} + +class StringList { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + function __construct($h) { + $this->_cPtr=$h; + } + + function size() { + return StringList_size($this->_cPtr); + } + + function c_empty() { + return StringList_c_empty($this->_cPtr); + } + + function clear() { + StringList_clear($this->_cPtr); + } + + function add($x) { + StringList_add($this->_cPtr,$x); + } + + function get($i) { + return StringList_get($this->_cPtr,$i); + } +} + +class ParamMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_std__listT_uscxml__Data_t_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_ParamMap(); break; + default: $this->_cPtr=new_ParamMap($arg1); + } + } + + function size() { + return ParamMap_size($this->_cPtr); + } + + function clear() { + ParamMap_clear($this->_cPtr); + } + + function get($key) { + $r=ParamMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new DataList($r); + } + return $r; + } + + function set($key,$x) { + ParamMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + ParamMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return ParamMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return ParamMap_is_empty($this->_cPtr); + } +} + +class IOProcMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_uscxml__IOProcessor_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_IOProcMap(); break; + default: $this->_cPtr=new_IOProcMap($arg1); + } + } + + function size() { + return IOProcMap_size($this->_cPtr); + } + + function clear() { + IOProcMap_clear($this->_cPtr); + } + + function get($key) { + $r=IOProcMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NativeIOProcessor($r); + } + return $r; + } + + function set($key,$x) { + IOProcMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + IOProcMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return IOProcMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return IOProcMap_is_empty($this->_cPtr); + } +} + +class InvokerMap { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($arg1=null) { + if (is_resource($arg1) && get_resource_type($arg1) === '_p_std__mapT_std__string_uscxml__Invoker_t') { + $this->_cPtr=$arg1; + return; + } + switch (func_num_args()) { + case 0: $this->_cPtr=new_InvokerMap(); break; + default: $this->_cPtr=new_InvokerMap($arg1); + } + } + + function size() { + return InvokerMap_size($this->_cPtr); + } + + function clear() { + InvokerMap_clear($this->_cPtr); + } + + function get($key) { + $r=InvokerMap_get($this->_cPtr,$key); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new NativeInvoker($r); + } + return $r; + } + + function set($key,$x) { + InvokerMap_set($this->_cPtr,$key,$x); + } + + function del($key) { + InvokerMap_del($this->_cPtr,$key); + } + + function has_key($key) { + return InvokerMap_has_key($this->_cPtr,$key); + } + + function is_empty() { + return InvokerMap_is_empty($this->_cPtr); + } +} + +class ParentQueue { + public $_cPtr=null; + protected $_pData=array(); + + function __set($var,$value) { + if ($var === 'thisown') return swig_uscxmlNativePHP_alter_newobject($this->_cPtr,$value); + $this->_pData[$var] = $value; + } + + function __get($var) { + if ($var === 'thisown') return swig_uscxmlNativePHP_get_newobject($this->_cPtr); + return $this->_pData[$var]; + } + + function __isset($var) { + if ($var === 'thisown') return true; + return array_key_exists($var, $this->_pData); + } + + function __construct($res=null) { + if (is_resource($res) && get_resource_type($res) === '_p_uscxml__concurrency__BlockingQueueT_uscxml__SendRequest_t') { + $this->_cPtr=$res; + return; + } + $this->_cPtr=new_ParentQueue(); + } + + function push($elem) { + ParentQueue_push($this->_cPtr,$elem); + } + + function push_front($elem) { + ParentQueue_push_front($this->_cPtr,$elem); + } + + function pop() { + $r=ParentQueue_pop($this->_cPtr); + if (is_resource($r)) { + $c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3)); + if (class_exists($c)) return new $c($r); + return new SendRequest($r); + } + return $r; + } + + function clear() { + ParentQueue_clear($this->_cPtr); + } + + function isEmpty() { + return ParentQueue_isEmpty($this->_cPtr); + } +} + + +?> diff --git a/src/bindings/swig/stl_list.i b/src/bindings/swig/stl_list.i new file mode 100644 index 0000000..aabd448 --- /dev/null +++ b/src/bindings/swig/stl_list.i @@ -0,0 +1,49 @@ +/* ----------------------------------------------------------------------------- + * See the LICENSE file for information on copyright, usage and redistribution + * of SWIG, and the README file for authors - http://www.swig.org/release.html. + * + * std_list.i + * ----------------------------------------------------------------------------- */ + +%include <std_common.i> + +%{ +#include <list> +#include <stdexcept> +%} + +namespace std { + + template<class T> class list { + public: + typedef size_t size_type; + typedef T value_type; + typedef const value_type& const_reference; + list(); + size_type size() const; + %rename(isEmpty) empty; + bool empty() const; + void clear(); + %rename(add) push_back; + void push_back(const value_type& x); + %extend { + const_reference get(int i) throw (std::out_of_range) { + int size = int(self->size()); + int j; + if (i>=0 && i<size) { + std::list<T>::const_iterator p; + p=self->begin(); + for (j=0; j<i; j++) {p++;} + return (*p); + } + else + throw std::out_of_range("list index out of range"); + } + } + }; +} + +%define specialize_std_list(T) +#warning "specialize_std_list - specialization for type T no longer needed" +%enddef + diff --git a/src/bindings/swig/stl_set.i b/src/bindings/swig/stl_set.i new file mode 100644 index 0000000..d009a7b --- /dev/null +++ b/src/bindings/swig/stl_set.i @@ -0,0 +1,73 @@ +/*========================================================================= + + Program: GDCM (Grassroots DICOM). A DICOM library + + Copyright (c) 2006-2011 Mathieu Malaterre + All rights reserved. + See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +/* ----------------------------------------------------------------------------- + * std_set.i + * + * SWIG typemaps for std::set + * ----------------------------------------------------------------------------- */ + +%include <std_common.i> + +// ------------------------------------------------------------------------ +// std::set +// ------------------------------------------------------------------------ + +%{ +#include <set> +#include <algorithm> +#include <stdexcept> +%} + +// exported class + +namespace std { + + template<class V> class set { + // add typemaps here + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef V value_type; + set(); + set(const set<V> &); + + unsigned int size() const; + bool empty() const; + void clear(); + %extend { + const V& get(const V& key) throw (std::out_of_range) { + std::set<V>::iterator i = self->find(key); + if (i != self->end()) + return *i; + else + throw std::out_of_range("key not found"); + } + void insert(const V& key) { // Do NOT call this function 'set' ! + self->insert(key); + } + void del(const V& key) throw (std::out_of_range) { + std::set<V>::iterator i = self->find(key); + if (i != self->end()) + self->erase(i); + else + throw std::out_of_range("key not found"); + } + bool has_key(const V& key) { + std::set<V>::iterator i = self->find(key); + return i != self->end(); + } + } + }; + +}
\ No newline at end of file diff --git a/src/bindings/swig/uscxml_beautify.i b/src/bindings/swig/uscxml_beautify.i new file mode 100644 index 0000000..52c8ec5 --- /dev/null +++ b/src/bindings/swig/uscxml_beautify.i @@ -0,0 +1,54 @@ +%rename(NativeDataModel) DataModel; +%rename(DataModel) WrappedDataModel; +%rename(NativeDataModelExtension) DataModelExtension; +%rename(DataModelExtension) WrappedDataModelExtension; +%rename(NativeExecutableContent) ExecutableContent; +%rename(ExecutableContent) WrappedExecutableContent; +%rename(NativeInvoker) Invoker; +%rename(Invoker) WrappedInvoker; +%rename(NativeIOProcessor) IOProcessor; +%rename(IOProcessor) WrappedIOProcessor; +%rename(NativeInterpreterMonitor) InterpreterMonitor; +%rename(InterpreterMonitor) WrappedInterpreterMonitor; + +%rename(getInvokersNative) uscxml::Interpreter::getInvokers(); +%rename(getIOProcessorsNative) uscxml::Interpreter::getIOProcessors(); + +%extend uscxml::ErrorEvent { + std::string toString() { + std::stringstream ss; + ss << *self; + return ss.str(); + } +}; + +%extend uscxml::Interpreter { + + std::vector<std::string> getConfiguration() { + std::list<XERCESC_NS::DOMElement*> nativeConfig = self->getConfiguration(); + std::vector<std::string> config; + for (auto state : nativeConfig) { + if (HAS_ATTR(state, "id")) + config.push_back(ATTR(state, "id")); + } + return config; + } + +}; + +%{ + #include <easylogging++.h> +%} + +%extend uscxml::Data { + std::vector<std::string> getCompoundKeys() { + std::vector<std::string> keys; + std::map<std::string, Data>::const_iterator iter = self->compound.begin(); + while(iter != self->compound.end()) { + keys.push_back(iter->first); + iter++; + } + return keys; + } + +}; diff --git a/src/bindings/swig/uscxml_ignores.i b/src/bindings/swig/uscxml_ignores.i new file mode 100644 index 0000000..4146a35 --- /dev/null +++ b/src/bindings/swig/uscxml_ignores.i @@ -0,0 +1,155 @@ +%ignore uscxml::NumAttr; +%ignore uscxml::SCXMLParser; +%ignore uscxml::InterpreterImpl; +%ignore uscxml::BlobImpl; +%ignore uscxml::StateTransitionMonitor; +%ignore uscxml::ActionLanguage; + +#if 0 +%ignore uscxml::EventHandlerImpl; +#endif + +%ignore uscxml::EventHandlerImpl::setInterpreter(InterpreterImpl*); +%ignore uscxml::EventHandlerImpl::getInterpreter; +%ignore uscxml::EventHandlerImpl::getElement; +%ignore uscxml::EventHandlerImpl::runOnMainThread; + +%ignore uscxml::EventHandler::EventHandler(const std::shared_ptr<EventHandlerImpl>); +%ignore uscxml::EventHandler::EventHandler(EventHandler&); +%ignore uscxml::EventHandler::setInterpreter(InterpreterImpl*); +%ignore uscxml::EventHandler::getInterpreter; +%ignore uscxml::EventHandler::getElement; +%ignore uscxml::EventHandler::runOnMainThread; + +// interpreter + +%ignore uscxml::Interpreter::Interpreter(const std::shared_ptr<InterpreterImpl>); +%ignore uscxml::Interpreter::Interpreter(const Interpreter&); +%ignore uscxml::Interpreter::fromDocument; +%ignore uscxml::Interpreter::fromElement; +%ignore uscxml::Interpreter::fromClone; +%ignore uscxml::Interpreter::getImpl(); + +%ignore uscxml::InterpreterOptions; + +// InterpreterIssues +%ignore uscxml::InterpreterIssue::node; + + +// InterpreterMonitor + +%ignore uscxml::InterpreterMonitor::beforeExitingState(const XERCESC_NS::DOMElement*); +%ignore uscxml::InterpreterMonitor::afterExitingState(const XERCESC_NS::DOMElement*); +%ignore uscxml::InterpreterMonitor::beforeEnteringState(const XERCESC_NS::DOMElement*); +%ignore uscxml::InterpreterMonitor::afterEnteringState(const XERCESC_NS::DOMElement*); + +%ignore uscxml::InterpreterMonitor::beforeUninvoking(const XERCESC_NS::DOMElement*, const std::string&); +%ignore uscxml::InterpreterMonitor::afterUninvoking(const XERCESC_NS::DOMElement*, const std::string&); +%ignore uscxml::InterpreterMonitor::beforeInvoking(const XERCESC_NS::DOMElement*, const std::string&); +%ignore uscxml::InterpreterMonitor::afterInvoking(const XERCESC_NS::DOMElement*, const std::string&); + +%ignore uscxml::InterpreterMonitor::beforeTakingTransition(const XERCESC_NS::DOMElement*); +%ignore uscxml::InterpreterMonitor::afterTakingTransition(const XERCESC_NS::DOMElement*); + +%ignore uscxml::InterpreterMonitor::beforeExecutingContent(const XERCESC_NS::DOMElement*); +%ignore uscxml::InterpreterMonitor::afterExecutingContent(const XERCESC_NS::DOMElement*); + + +%ignore uscxml::InterpreterOptions::fromCmdLine(int, char**); +%ignore uscxml::InterpreterOptions::additionalParameters; +%ignore uscxml::InterpreterOptions::interpreters; + +// Invoker + +%ignore uscxml::Invoker::Invoker(const std::shared_ptr<InvokerImpl>); +%ignore uscxml::Invoker::setInterpreter(InterpreterImpl*); +%ignore uscxml::Invoker::getInterpreter; + +%ignore uscxml::InvokerImpl::create(InterpreterImpl*); +%ignore uscxml::InvokerImpl::setInterpreter(InterpreterImpl*); +%ignore uscxml::InvokerImpl::getInterpreter; + + +// DataModel + +%ignore uscxml::DataModel::DataModel(const std::shared_ptr<DataModelImpl>); +%ignore uscxml::DataModel::DataModel(const DataModel&); + + +%ignore uscxml::WrappedDataModel::create(DataModelCallbacks*); +%ignore uscxml::DataModelExtension::dm; + +// Executable Content + +%ignore uscxml::ExecutableContent::ExecutableContent(const std::shared_ptr<ExecutableContentImpl>); +%ignore uscxml::ExecutableContent::ExecutableContent(const ExecutableContent&); +%ignore uscxml::ExecutableContent::setInterpreter(InterpreterImpl*); +%ignore uscxml::ExecutableContent::getInterpreter; +%ignore uscxml::ExecutableContent::enterElement(const XERCESC_NS::DOMElement*); +%ignore uscxml::ExecutableContent::exitElement(const XERCESC_NS::DOMElement*s); + +%ignore uscxml::ExecutableContentImpl::create(InterpreterImpl*); +%ignore uscxml::ExecutableContentImpl::enterElement(const XERCESC_NS::DOMElement*); +%ignore uscxml::ExecutableContentImpl::exitElement(const XERCESC_NS::DOMElement*); +%ignore uscxml::ExecutableContentImpl::setInterpreter(InterpreterImpl*); +%ignore uscxml::ExecutableContentImpl::getInterpreter; + +%ignore uscxml::WrappedExecutableContent::create(InterpreterImpl*); +%ignore uscxml::WrappedExecutableContent::enterElement(const XERCESC_NS::DOMElement*); +%ignore uscxml::WrappedExecutableContent::exitElement(const XERCESC_NS::DOMElement*); + + +// IOProcessor + +%ignore uscxml::IOProcessorImpl::create(InterpreterImpl*); + +%ignore uscxml::IOProcessor::IOProcessor(const std::shared_ptr<IOProcessorImpl>); +%ignore uscxml::IOProcessor::IOProcessor(const IOProcessor&); + +%ignore uscxml::WrappedIOProcessor::create(InterpreterImpl*); + + +// Factory + +%ignore uscxml::Factory::createDataModel; +%ignore uscxml::Factory::createIOProcessor; +%ignore uscxml::Factory::createInvoker; +%ignore uscxml::Factory::createExecutableContent; +%ignore uscxml::Factory::getIOProcessors; + +// Event + +%ignore uscxml::Event::getParams(); +%ignore uscxml::Event::getParam; +%ignore uscxml::Event::setParams; + +// HTTPServer + +%ignore uscxml::HTTPServer::wsSend; +%ignore uscxml::HTTPServer::wsBroadcast; +%ignore uscxml::HTTPServer::reply; + + +// Data + +%ignore uscxml::Data::toDocument; +%ignore uscxml::Data::Data(const XERCESC_NS::DOMElement*); +%ignore uscxml::Data::Data(const char* data, size_t size, const std::string& mimeType, bool adopt); +%ignore uscxml::Data::Data(const char* data, size_t size, const std::string& mimeType); + +// Blob + +%ignore uscxml::Blob::Blob(size_t size); +%ignore uscxml::Blob::Blob(const char* data, size_t size, const std::string& mimeType, bool adopt); +%ignore uscxml::Blob::Blob(const std::shared_ptr<BlobImpl>); + + +%ignore operator!=; +%ignore operator<; +%ignore operator=; +%ignore operator[]; +%ignore operator std::list<Data>; +%ignore operator std::string; +%ignore operator std::map<std::string,Data>; +%ignore operator<<; + diff --git a/src/bindings/swig/wrapped/WrappedDataModel.cpp b/src/bindings/swig/wrapped/WrappedDataModel.cpp new file mode 100644 index 0000000..8ba57be --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedDataModel.cpp @@ -0,0 +1,27 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#include "WrappedDataModel.h" + +namespace uscxml { + +WrappedDataModel::WrappedDataModel() {} +WrappedDataModel::~WrappedDataModel() {} + +}
\ No newline at end of file diff --git a/src/bindings/swig/wrapped/WrappedDataModel.h b/src/bindings/swig/wrapped/WrappedDataModel.h new file mode 100644 index 0000000..49a3482 --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedDataModel.h @@ -0,0 +1,98 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#ifndef WRAPPEDDATAMODEL_H_DBAAD6AF +#define WRAPPEDDATAMODEL_H_DBAAD6AF + +#include <vector> +#include <list> +#include <ostream> +#include <string> +#include <iostream> + +#include <xercesc/dom/DOM.hpp> + +#include "../../../uscxml/plugins/DataModelImpl.h" + +namespace uscxml { + +class WrappedDataModel : public DataModelImpl { +public: + + WrappedDataModel(); + virtual ~WrappedDataModel(); + + virtual std::shared_ptr<DataModelImpl> create(DataModelCallbacks* callbacks) { + std::shared_ptr<WrappedDataModel> dm(create()); + dm->callbacks = callbacks; + return dm; + } + + virtual std::list<std::string> getNames() { + return std::list<std::string>(); + } + + virtual WrappedDataModel* create() { + return new WrappedDataModel(); + } + + virtual bool isValidSyntax(const std::string& expr) { + return true; + } + + virtual void setEvent(const Event& event) {} + + // foreach + virtual uint32_t getLength(const std::string& expr) { + return 0; + } + + virtual void setForeach(const std::string& item, + const std::string& array, + const std::string& index, + uint32_t iteration) {} + + virtual Data getAsData(const std::string& content) { + return Data(); + } + virtual Data evalAsData(const std::string& expr) { + return Data(); + } + virtual bool evalAsBool(const std::string& expr) { + return true; + } + + virtual bool isDeclared(const std::string& expr) { + return true; + } + + virtual void assign(const std::string& location, const Data& data) {} + virtual void init(const std::string& location, const Data& data) {} + + virtual std::string andExpressions(std::list<std::string>) { + return ""; + } + +protected: + DataModelCallbacks* callbacks; +}; + +} + +#endif /* end of include guard: WRAPPEDDATAMODEL_H_DBAAD6AF */ diff --git a/src/bindings/swig/wrapped/WrappedExecutableContent.cpp b/src/bindings/swig/wrapped/WrappedExecutableContent.cpp new file mode 100644 index 0000000..09aa6fd --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedExecutableContent.cpp @@ -0,0 +1,43 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#include "WrappedExecutableContent.h" +#include "uscxml/util/DOM.h" +#include <xercesc/dom/DOM.hpp> +#include <ostream> + +namespace uscxml { + +WrappedExecutableContent::WrappedExecutableContent() {} +WrappedExecutableContent::~WrappedExecutableContent() {} + +void WrappedExecutableContent::enterElement(XERCESC_NS::DOMElement* element) { + std::stringstream ss; + ss << *element; + enterElement(ss.str()); +} + +void WrappedExecutableContent::exitElement(XERCESC_NS::DOMElement* element) { + std::stringstream ss; + ss << *element; + exitElement(ss.str()); +} + + +}
\ No newline at end of file diff --git a/src/bindings/swig/wrapped/WrappedExecutableContent.h b/src/bindings/swig/wrapped/WrappedExecutableContent.h new file mode 100644 index 0000000..0ba8d3e --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedExecutableContent.h @@ -0,0 +1,66 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#ifndef WRAPPEDEXECUTABLECONTENT_H_F690F480 +#define WRAPPEDEXECUTABLECONTENT_H_F690F480 + +#include <string> + + +#include "../../../uscxml/messages/Event.h" +#include "../../../uscxml/plugins/Factory.h" +#include "../../../uscxml/plugins/ExecutableContentImpl.h" + +namespace uscxml { + +class WrappedExecutableContent : public ExecutableContentImpl { +public: + WrappedExecutableContent(); + virtual ~WrappedExecutableContent(); + + virtual std::shared_ptr<ExecutableContentImpl> create(InterpreterImpl* interpreter) { + std::shared_ptr<WrappedExecutableContent> ec(new WrappedExecutableContent()); + return ec; + } + + virtual std::string getLocalName() { + return ""; + } + + virtual std::string getNamespace() { + return "http://www.w3.org/2005/07/scxml"; + } + + + void enterElement(XERCESC_NS::DOMElement* element); + virtual void enterElement(const std::string& elementXML) {} + + void exitElement(XERCESC_NS::DOMElement* element); + virtual void exitElement(const std::string& elementXML) {} + + virtual bool processChildren() { + return true; + } + +}; + +} + + +#endif /* end of include guard: WRAPPEDEXECUTABLECONTENT_H_F690F480 */ diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.cpp b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp new file mode 100644 index 0000000..d034bc3 --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedIOProcessor.cpp @@ -0,0 +1,29 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#include "WrappedIOProcessor.h" + +namespace uscxml { + +WrappedIOProcessor::WrappedIOProcessor(InterpreterImpl* interpreter) { + _interpreter = interpreter; +} +WrappedIOProcessor::~WrappedIOProcessor() {} + +}
\ No newline at end of file diff --git a/src/bindings/swig/wrapped/WrappedIOProcessor.h b/src/bindings/swig/wrapped/WrappedIOProcessor.h new file mode 100644 index 0000000..aa5f967 --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedIOProcessor.h @@ -0,0 +1,64 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#ifndef WRAPPEDIOPROCESSOR_H_AE98064A +#define WRAPPEDIOPROCESSOR_H_AE98064A + +#include <vector> +#include <list> +#include <ostream> +#include <string> + +#include <xercesc/dom/DOM.hpp> + +#include "../../../uscxml/messages/Event.h" +#include "../../../uscxml/plugins/Factory.h" +#include "../../../uscxml/plugins/IOProcessorImpl.h" +#include "../../../uscxml/Interpreter.h" + +namespace uscxml { + +class WrappedIOProcessor : public IOProcessorImpl { +public: + WrappedIOProcessor(InterpreterImpl* interpreter); + virtual ~WrappedIOProcessor(); + + virtual std::list<std::string> getNames() { + return std::list<std::string>(); + }; + + virtual std::shared_ptr<IOProcessorImpl> create(InterpreterImpl* interpreter) { + std::shared_ptr<IOProcessorImpl> ioProc = std::shared_ptr<IOProcessorImpl>(new WrappedIOProcessor(interpreter)); + return ioProc; + } + + virtual void eventFromSCXML(const std::string& target, const Event& event) {} + virtual bool isValidTarget(const std::string& target) { + return true; + } + + virtual Data getDataModelVariables() { + return Data(); + } +}; + +} + + +#endif /* end of include guard: WRAPPEDIOPROCESSOR_H_AE98064A */ diff --git a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp new file mode 100644 index 0000000..f066a72 --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.cpp @@ -0,0 +1,147 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#include "WrappedInterpreterMonitor.h" +#include "uscxml/util/Predicates.h" +#include "uscxml/util/DOM.h" +#include <xercesc/dom/DOM.hpp> +#include <ostream> + +namespace uscxml { + +using namespace XERCESC_NS; + +WrappedInterpreterMonitor::WrappedInterpreterMonitor() {} +WrappedInterpreterMonitor::~WrappedInterpreterMonitor() {} + +void WrappedInterpreterMonitor::beforeExitingState(const XERCESC_NS::DOMElement* state) { + std::stringstream ss; + ss << *state; + beforeExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str()); +} + +void WrappedInterpreterMonitor::afterExitingState(const XERCESC_NS::DOMElement* state) { + std::stringstream ss; + ss << *state; + afterExitingState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str()); +} + +void WrappedInterpreterMonitor::beforeExecutingContent(const XERCESC_NS::DOMElement* content) { + std::stringstream ss; + ss << *content; + beforeExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str()); +} + +void WrappedInterpreterMonitor::afterExecutingContent(const XERCESC_NS::DOMElement* content) { + std::stringstream ss; + ss << *content; + afterExecutingContent(TAGNAME(content), DOMUtils::xPathForNode(content), ss.str()); +} + +void WrappedInterpreterMonitor::beforeUninvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) { + std::stringstream ss; + ss << *invoker; + std::string invokeId; + if (invoker->getUserData(X("invokeid")) != NULL) { + invokeId = (char*)invoker->getUserData(X("invokeid")); + } + + beforeUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str()); +} + +void WrappedInterpreterMonitor::afterUninvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) { + std::stringstream ss; + ss << *invoker; + std::string invokeId; + if (invoker->getUserData(X("invokeid")) != NULL) { + invokeId = (char*)invoker->getUserData(X("invokeid")); + } + + afterUninvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str()); +} + +void WrappedInterpreterMonitor::beforeTakingTransition(const XERCESC_NS::DOMElement* transition) { + XERCESC_NS::DOMElement* sourceState = getSourceState(transition); + const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml"); + + std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root); + + std::stringstream ss; + ss << *transition; + + std::list<std::string> targets; + for (auto t : targetStates) { + targets.push_back(ATTR_CAST(t, "id")); + } + + beforeTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str()); +} + +void WrappedInterpreterMonitor::afterTakingTransition(const XERCESC_NS::DOMElement* transition) { + XERCESC_NS::DOMElement* sourceState = getSourceState(transition); + const XERCESC_NS::DOMElement* root = DOMUtils::getNearestAncestor(transition, "scxml"); + + std::list<XERCESC_NS::DOMElement*> targetStates = getTargetStates(transition, root); + + std::stringstream ss; + ss << *transition; + + std::list<std::string> targets; + for (auto t : targetStates) { + targets.push_back(ATTR_CAST(t, "id")); + } + + afterTakingTransition(DOMUtils::xPathForNode(transition), ATTR_CAST(sourceState, "id"), targets, ss.str()); +} + +void WrappedInterpreterMonitor::beforeEnteringState(const XERCESC_NS::DOMElement* state) { + std::stringstream ss; + ss << *state; + beforeEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str()); +} + +void WrappedInterpreterMonitor::afterEnteringState(const XERCESC_NS::DOMElement* state) { + std::stringstream ss; + ss << *state; + afterEnteringState(ATTR(state, "id"), DOMUtils::xPathForNode(state), ss.str()); +} + +void WrappedInterpreterMonitor::beforeInvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) { + std::stringstream ss; + ss << *invoker; + std::string invokeId; + if (invoker->getUserData(X("invokeid")) != NULL) { + invokeId = (char*)invoker->getUserData(X("invokeid")); + } + + beforeInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str()); +} + +void WrappedInterpreterMonitor::afterInvoking(const XERCESC_NS::DOMElement* invoker, const std::string& invokeid) { + std::stringstream ss; + ss << *invoker; + std::string invokeId; + if (invoker->getUserData(X("invokeid")) != NULL) { + invokeId = (char*)invoker->getUserData(X("invokeid")); + } + + afterInvoking(DOMUtils::xPathForNode(invoker), invokeId, ss.str()); +} + +}
\ No newline at end of file diff --git a/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h new file mode 100644 index 0000000..e83c896 --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedInterpreterMonitor.h @@ -0,0 +1,128 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#ifndef WRAPPEDINTERPRETERMONITOR_H_F5C83A0D +#define WRAPPEDINTERPRETERMONITOR_H_F5C83A0D + +#include <vector> +#include <list> +#include <ostream> +#include <string> + +#include <xercesc/dom/DOM.hpp> + +#include "uscxml/config.h" +#include "../../../uscxml/messages/Event.h" +#include "../../../uscxml/interpreter/InterpreterMonitor.h" +#include "../../../uscxml/util/DOM.h" + +// forward declare +namespace XERCESC_NS { + class DOMElement; +} + +namespace uscxml { + +class WrappedInterpreterMonitor : public InterpreterMonitor { +public: + WrappedInterpreterMonitor(); + virtual ~WrappedInterpreterMonitor(); + + void beforeExitingState(const XERCESC_NS::DOMElement* state); + virtual void beforeExitingState(const std::string& stateId, + const std::string& xpath, + const std::string& stateXML) {} + + + void afterExitingState(const XERCESC_NS::DOMElement* state); + virtual void afterExitingState(const std::string& stateId, + const std::string& xpath, + const std::string& stateXML) {} + + + void beforeExecutingContent(const XERCESC_NS::DOMElement* content); + virtual void beforeExecutingContent(const std::string& tagName, + const std::string& xpath, + const std::string& contentXML) {} + + + void afterExecutingContent(const XERCESC_NS::DOMElement* content); + virtual void afterExecutingContent(const std::string& tagName, + const std::string& xpath, + const std::string& contentXML) {} + + + void beforeUninvoking(const XERCESC_NS::DOMElement* invoker, + const std::string& invokeid); + virtual void beforeUninvoking(const std::string& xpath, + const std::string& invokeid, + const std::string& invokerXML) {} + + + void afterUninvoking(const XERCESC_NS::DOMElement* invoker, + const std::string& invokeid); + virtual void afterUninvoking(const std::string& xpath, + const std::string& invokeid, + const std::string& invokerXML) {} + + + void beforeTakingTransition(const XERCESC_NS::DOMElement* transition); + virtual void beforeTakingTransition(const std::string& xpath, + const std::string& source, + const std::list<std::string>& targets, + const std::string& transitionXML) {} + + void afterTakingTransition(const XERCESC_NS::DOMElement* transition); + virtual void afterTakingTransition(const std::string& xpath, + const std::string& source, + const std::list<std::string>& targets, + const std::string& transitionXML) {} + + + void beforeEnteringState(const XERCESC_NS::DOMElement* state); + virtual void beforeEnteringState(const std::string& stateId, + const std::string& xpath, + const std::string& stateXML) {} + + + void afterEnteringState(const XERCESC_NS::DOMElement* state); + virtual void afterEnteringState(const std::string& stateId, + const std::string& xpath, + const std::string& stateXML) {} + + + void beforeInvoking(const XERCESC_NS::DOMElement* invoker, + const std::string& invokeid); + virtual void beforeInvoking(const std::string& xpath, + const std::string& invokeid, + const std::string& invokerXML) {} + + void afterInvoking(const XERCESC_NS::DOMElement* invoker, + const std::string& invokeid); + virtual void afterInvoking(const std::string& xpath, + const std::string& invokeid, + const std::string& invokerXML) {} + + virtual void reportIssue(const InterpreterIssue& issue) {} +}; + +} + + +#endif /* end of include guard: WRAPPEDINTERPRETERMONITOR_H_F5C83A0D */ diff --git a/src/bindings/swig/wrapped/WrappedInvoker.cpp b/src/bindings/swig/wrapped/WrappedInvoker.cpp new file mode 100644 index 0000000..ba76420 --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedInvoker.cpp @@ -0,0 +1,29 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#include "WrappedInvoker.h" + +namespace uscxml { + +WrappedInvoker::WrappedInvoker(InterpreterImpl* interpreter) { + _interpreter = interpreter; +} +WrappedInvoker::~WrappedInvoker() {} + +}
\ No newline at end of file diff --git a/src/bindings/swig/wrapped/WrappedInvoker.h b/src/bindings/swig/wrapped/WrappedInvoker.h new file mode 100644 index 0000000..3eb4a22 --- /dev/null +++ b/src/bindings/swig/wrapped/WrappedInvoker.h @@ -0,0 +1,84 @@ +/** + * @file + * @author 2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de) + * @copyright Simplified BSD + * + * @cond + * This program is free software: you can redistribute it and/or modify + * it under the terms of the FreeBSD license as published by the FreeBSD + * project. + * + * 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. + * + * You should have received a copy of the FreeBSD license along with this + * program. If not, see <http://www.opensource.org/licenses/bsd-license>. + * @endcond + */ + +#ifndef WRAPPEDINVOKER_H_F9725D47 +#define WRAPPEDINVOKER_H_F9725D47 + +#include <vector> +#include <list> +#include <ostream> +#include <string> + +#include <xercesc/dom/DOM.hpp> + +#include "../../../uscxml/messages/Event.h" +#include "../../../uscxml/plugins/Factory.h" +#include "../../../uscxml/plugins/InvokerImpl.h" + +// forward declare +namespace XERCESC_NS { + class DOMElement; +} + +namespace uscxml { + +class WrappedInvoker : public InvokerImpl { +public: + WrappedInvoker(InterpreterImpl* interpreter); + virtual ~WrappedInvoker(); + + virtual std::list<std::string> getNames() { + return std::list<std::string>(); + }; + + virtual std::shared_ptr<InvokerImpl> create(InterpreterImpl* interpreter) { + std::shared_ptr<InvokerImpl> inv = std::shared_ptr<InvokerImpl>(new WrappedInvoker(interpreter)); + return inv; + } + virtual void invoke(const std::string& source, const Event& invokeEvent) {} + virtual void uninvoke() {} + + virtual void eventFromSCXML(const Event& event) {} + + virtual XERCESC_NS::DOMElement* getFinalize() { + return _finalize; + } + virtual void setFinalize(XERCESC_NS::DOMElement* finalize) { + _finalize = finalize; + } + virtual void setInvokeId(const std::string& invokeId) { + _invokeId = invokeId; + } + + virtual Data getDataModelVariables() { + return Data(); + } + + void eventToSCXML(Event& event, const std::string& type, const std::string& invokeId, bool internal = false) { + + } + +private: + InterpreterImpl* _interpreter; + +}; + +} + +#endif /* end of include guard: WRAPPEDINVOKER_H_F9725D47 */ diff --git a/src/uscxml/Interpreter.cpp b/src/uscxml/Interpreter.cpp index 05fb1fc..a050401 100644 --- a/src/uscxml/Interpreter.cpp +++ b/src/uscxml/Interpreter.cpp @@ -192,8 +192,8 @@ void Interpreter::reset() { return _impl->reset(); } -InterpreterState Interpreter::step(bool blocking) { - return _impl->step(blocking); +InterpreterState Interpreter::step(size_t blockMs) { + return _impl->step(blockMs); }; void Interpreter::cancel() { @@ -239,7 +239,7 @@ static void printNodeSet(const std::list<XERCESC_NS::DOMElement*> nodes) { } } #endif - + void StateTransitionMonitor::beforeTakingTransition(const XERCESC_NS::DOMElement* transition) { std::lock_guard<std::recursive_mutex> lock(_mutex); std::cerr << "Transition: " << uscxml::DOMUtils::xPathForNode(transition) << std::endl; diff --git a/src/uscxml/Interpreter.h b/src/uscxml/Interpreter.h index 1596914..bab0ebc 100644 --- a/src/uscxml/Interpreter.h +++ b/src/uscxml/Interpreter.h @@ -154,13 +154,19 @@ public: PIMPL_OPERATORS(Interpreter); /** - * Perform a single microstep and return. - * @param blocking Whether or not to block the thread when waiting for events - * @return The new state of the interpreter object. + * Advance the state-machine by a single microstep and return. + * + * This is the central function to drive the state machine. Calling step() + * will perform one *microstep* and return the current state of the + * interpreter. Here, the state is not to be confused with the interpreter's + * configuration. * - * @todo Have Interpreter::step() take a duration to block + * \snippet test-snippets.cpp Performing a microstep + * + * @param blockMs The maximum duration in milli-seconds to wait for an event to become available. + * @return The new state of the interpreter object. */ - InterpreterState step(bool blocking = true); + InterpreterState step(size_t blockMs = std::numeric_limits<size_t>::max()); /** * Unblock and mark for finalize. @@ -177,14 +183,14 @@ public: * @return A list of XML elements of the active states. */ std::list<XERCESC_NS::DOMElement*> getConfiguration(); - + /** * Determine whether the state with the given `id` is in the active configuration. * @param id An identifier for a state from the SCXML document. * @return Whether the interpreter is in state `id`. */ bool isInState(const std::string& stateId); - + /** * The current state of the interpreter, not to be confused with its configuration. * @return The current state of the interpreter object. @@ -202,12 +208,12 @@ public: * @event An event to be enqueued */ void receive(const Event& event); - + /** * Adapt the constituting components for a SCXML interpreter. */ void setActionLanguage(ActionLanguage actionLanguage); - + /** * Attach a monitor to make more details of the interpreter observable. */ diff --git a/src/uscxml/debug/InterpreterIssue.h b/src/uscxml/debug/InterpreterIssue.h index c807acc..7eede09 100644 --- a/src/uscxml/debug/InterpreterIssue.h +++ b/src/uscxml/debug/InterpreterIssue.h @@ -29,7 +29,7 @@ // forward declare namespace XERCESC_NS { - class DOMNode; +class DOMNode; } namespace uscxml { @@ -54,10 +54,10 @@ public: IssueSeverity severity; ///< Severity of the issue std::string specRef; ///< If applicable, the violated section from the standard - /** - * Constructor is solely used to report issues at runtime. - */ - InterpreterIssue(const std::string& msg, XERCESC_NS::DOMNode* node, IssueSeverity severity, const std::string& specRef = ""); + /** + * Constructor is solely used to report issues at runtime. + */ + InterpreterIssue(const std::string& msg, XERCESC_NS::DOMNode* node, IssueSeverity severity, const std::string& specRef = ""); private: diff --git a/src/uscxml/interpreter/BasicEventQueue.cpp b/src/uscxml/interpreter/BasicEventQueue.cpp index 5d3fa2d..ee2346d 100644 --- a/src/uscxml/interpreter/BasicEventQueue.cpp +++ b/src/uscxml/interpreter/BasicEventQueue.cpp @@ -31,13 +31,20 @@ BasicEventQueue::BasicEventQueue() { BasicEventQueue::~BasicEventQueue() { } -Event BasicEventQueue::dequeue(bool blocking) { +Event BasicEventQueue::dequeue(size_t blockMs) { std::lock_guard<std::recursive_mutex> lock(_mutex); - if (blocking) { - while (_queue.empty()) { - _cond.wait(_mutex); + + if (blockMs > 0) { + // block for given milliseconds or until queue is filled + std::chrono::time_point<std::chrono::system_clock> end, now; + now = std::chrono::system_clock::now(); + end = now + std::chrono::milliseconds(blockMs); + + while (std::chrono::system_clock::now() < end && _queue.empty()) { + _cond.wait_for(_mutex, std::chrono::system_clock::now() - end); } } + if (_queue.size() > 0) { Event event = _queue.front(); _queue.pop_front(); diff --git a/src/uscxml/interpreter/BasicEventQueue.h b/src/uscxml/interpreter/BasicEventQueue.h index cfb2b5d..15a1c3c 100644 --- a/src/uscxml/interpreter/BasicEventQueue.h +++ b/src/uscxml/interpreter/BasicEventQueue.h @@ -42,7 +42,7 @@ class USCXML_API BasicEventQueue : public EventQueueImpl { public: BasicEventQueue(); virtual ~BasicEventQueue(); - virtual Event dequeue(bool blocking); + virtual Event dequeue(size_t blockMs); virtual void enqueue(const Event& event); protected: @@ -62,8 +62,8 @@ public: virtual void enqueueDelayed(const Event& event, size_t delayMs, const std::string& eventUUID); virtual void cancelDelayed(const std::string& eventId); virtual void cancelAllDelayed(); - virtual Event dequeue(bool blocking) { - return BasicEventQueue::dequeue(blocking); + virtual Event dequeue(size_t blockMs) { + return BasicEventQueue::dequeue(blockMs); } virtual void enqueue(const Event& event) { return BasicEventQueue::enqueue(event); diff --git a/src/uscxml/interpreter/ContentExecutor.h b/src/uscxml/interpreter/ContentExecutor.h index 64f5a95..be0de78 100644 --- a/src/uscxml/interpreter/ContentExecutor.h +++ b/src/uscxml/interpreter/ContentExecutor.h @@ -28,7 +28,7 @@ // forward declare namespace XERCESC_NS { - class DOMElement; +class DOMElement; } namespace uscxml { diff --git a/src/uscxml/interpreter/EventQueue.cpp b/src/uscxml/interpreter/EventQueue.cpp index 9b9fa88..c460e02 100644 --- a/src/uscxml/interpreter/EventQueue.cpp +++ b/src/uscxml/interpreter/EventQueue.cpp @@ -32,8 +32,8 @@ namespace uscxml { -Event EventQueue::dequeue(bool blocking) { - return _impl->dequeue(blocking); +Event EventQueue::dequeue(size_t blockMs) { + return _impl->dequeue(blockMs); } void EventQueue::enqueue(const Event& event) { return _impl->enqueue(event); diff --git a/src/uscxml/interpreter/EventQueue.h b/src/uscxml/interpreter/EventQueue.h index 4409b72..1e8b018 100644 --- a/src/uscxml/interpreter/EventQueue.h +++ b/src/uscxml/interpreter/EventQueue.h @@ -36,7 +36,7 @@ class USCXML_API EventQueue { public: PIMPL_OPERATORS(EventQueue); - virtual Event dequeue(bool blocking); + virtual Event dequeue(size_t blockMs); virtual void enqueue(const Event& event); protected: diff --git a/src/uscxml/interpreter/EventQueueImpl.h b/src/uscxml/interpreter/EventQueueImpl.h index 1cafd4d..1ccd3f1 100644 --- a/src/uscxml/interpreter/EventQueueImpl.h +++ b/src/uscxml/interpreter/EventQueueImpl.h @@ -40,7 +40,7 @@ namespace uscxml { */ class USCXML_API EventQueueImpl { public: - virtual Event dequeue(bool blocking) = 0; + virtual Event dequeue(size_t blockMs) = 0; virtual void enqueue(const Event& event) = 0; }; diff --git a/src/uscxml/interpreter/FastMicroStep.cpp b/src/uscxml/interpreter/FastMicroStep.cpp index bf58f7b..3ad5515 100644 --- a/src/uscxml/interpreter/FastMicroStep.cpp +++ b/src/uscxml/interpreter/FastMicroStep.cpp @@ -290,23 +290,23 @@ void FastMicroStep::init(XERCESC_NS::DOMElement* scxml) { if (parent && parent->getNodeType() == DOMNode::ELEMENT_NODE) { State* uscxmlState = (State*)parent->getUserData(X("uscxmlState")); // parent maybe a content element - if (uscxmlState != NULL) { - _states[i]->parent = uscxmlState->documentOrder; - } + if (uscxmlState != NULL) { + _states[i]->parent = uscxmlState->documentOrder; + } } while(parent && parent->getNodeType() == DOMNode::ELEMENT_NODE) { State* uscxmlState = (State*)parent->getUserData(X("uscxmlState")); - if (uscxmlState == NULL) - break; + if (uscxmlState == NULL) + break; - // ancestors - BIT_SET_AT(uscxmlState->documentOrder, _states[i]->ancestors); + // ancestors + BIT_SET_AT(uscxmlState->documentOrder, _states[i]->ancestors); - // children - BIT_SET_AT(i, uscxmlState->children); - parent = parent->getParentNode(); + // children + BIT_SET_AT(i, uscxmlState->children); + parent = parent->getParentNode(); } } @@ -403,7 +403,7 @@ void FastMicroStep::markAsCancelled() { _isCancelled = true; } -InterpreterState FastMicroStep::step(bool blocking) { +InterpreterState FastMicroStep::step(size_t blockMs) { if (!_isInitialized) { init(_scxml); return USCXML_INITIALIZED; @@ -517,7 +517,7 @@ InterpreterState FastMicroStep::step(bool blocking) { _flags |= USCXML_CTX_STABLE; } - if ((_event = _callbacks->dequeueExternal(blocking))) { + if ((_event = _callbacks->dequeueExternal(blockMs))) { USCXML_MONITOR_CALLBACK1(_callbacks->getMonitor(), beforeProcessingEvent, _event); goto SELECT_TRANSITIONS; } diff --git a/src/uscxml/interpreter/FastMicroStep.h b/src/uscxml/interpreter/FastMicroStep.h index 3789af9..023bb8f 100644 --- a/src/uscxml/interpreter/FastMicroStep.h +++ b/src/uscxml/interpreter/FastMicroStep.h @@ -42,7 +42,7 @@ public: FastMicroStep(MicroStepCallbacks* callbacks); virtual ~FastMicroStep(); - virtual InterpreterState step(bool blocking); + virtual InterpreterState step(size_t blockMs); virtual void reset(); virtual bool isInState(const std::string& stateId); virtual std::list<XERCESC_NS::DOMElement*> getConfiguration(); diff --git a/src/uscxml/interpreter/InterpreterImpl.cpp b/src/uscxml/interpreter/InterpreterImpl.cpp index 880afbc..3383411 100644 --- a/src/uscxml/interpreter/InterpreterImpl.cpp +++ b/src/uscxml/interpreter/InterpreterImpl.cpp @@ -259,8 +259,8 @@ bool InterpreterImpl::checkValidSendType(const std::string& type, const std::str return true; } -Event InterpreterImpl::dequeueExternal(bool blocking) { - _currEvent = _externalQueue.dequeue(blocking); +Event InterpreterImpl::dequeueExternal(size_t blockMs) { + _currEvent = _externalQueue.dequeue(blockMs); if (_currEvent) { _dataModel.setEvent(_currEvent); diff --git a/src/uscxml/interpreter/InterpreterImpl.h b/src/uscxml/interpreter/InterpreterImpl.h index e1abf9b..e693bbf 100644 --- a/src/uscxml/interpreter/InterpreterImpl.h +++ b/src/uscxml/interpreter/InterpreterImpl.h @@ -65,12 +65,12 @@ public: void cloneFrom(InterpreterImpl* other); void cloneFrom(std::shared_ptr<InterpreterImpl> other); - virtual InterpreterState step(bool blocking) { + virtual InterpreterState step(size_t blockMs) { if (!_isInitialized) { init(); _state = USCXML_INITIALIZED; } else { - _state = _microStepper.step(blocking); + _state = _microStepper.step(blockMs); } return _state; } @@ -107,7 +107,7 @@ public: _dataModel.setEvent(_currEvent); return _currEvent; } - virtual Event dequeueExternal(bool blocking); + virtual Event dequeueExternal(size_t blockMs); virtual bool isTrue(const std::string& expr); virtual void raiseDoneEvent(XERCESC_NS::DOMElement* state, XERCESC_NS::DOMElement* doneData) { diff --git a/src/uscxml/interpreter/InterpreterMonitor.h b/src/uscxml/interpreter/InterpreterMonitor.h index 901e1eb..8dac445 100644 --- a/src/uscxml/interpreter/InterpreterMonitor.h +++ b/src/uscxml/interpreter/InterpreterMonitor.h @@ -20,6 +20,7 @@ #ifndef INTERPRETERMONITOR_H_D3F21429 #define INTERPRETERMONITOR_H_D3F21429 +#include "uscxml/config.h" #include "uscxml/Common.h" #include "uscxml/messages/Event.h" #include "uscxml/debug/InterpreterIssue.h" @@ -41,6 +42,11 @@ if (callback) { callback->function(arg1); } #define USCXML_MONITOR_CALLBACK2(callback, function, arg1, arg2) \ if (callback) { callback->function(arg1, arg2); } +// forward declare +namespace XERCESC_NS { + class DOMElement; +} + namespace uscxml { class USCXML_API InterpreterMonitor { diff --git a/src/uscxml/interpreter/InterpreterState.h b/src/uscxml/interpreter/InterpreterState.h index a4741ed..5acbd74 100644 --- a/src/uscxml/interpreter/InterpreterState.h +++ b/src/uscxml/interpreter/InterpreterState.h @@ -27,8 +27,7 @@ namespace uscxml { enum InterpreterState { - USCXML_FINISHED = -2, ///< machine reached a final configuration and is done - USCXML_INTERRUPTED = -1, ///< machine received the empty event on the external queue + USCXML_FINISHED = -1, ///< machine reached a final configuration and is done USCXML_UNDEF = 0, ///< not an actual state USCXML_IDLE = 1, ///< stable configuration and queues empty USCXML_INITIALIZED = 2, ///< DOM is setup and all external components instantiated diff --git a/src/uscxml/interpreter/MicroStep.cpp b/src/uscxml/interpreter/MicroStep.cpp index aa75c91..2876be5 100644 --- a/src/uscxml/interpreter/MicroStep.cpp +++ b/src/uscxml/interpreter/MicroStep.cpp @@ -22,8 +22,8 @@ namespace uscxml { -InterpreterState MicroStep::step(bool blocking) { - return _impl->step(blocking); +InterpreterState MicroStep::step(size_t blockMs) { + return _impl->step(blockMs); } void MicroStep::reset() { return _impl->reset(); diff --git a/src/uscxml/interpreter/MicroStep.h b/src/uscxml/interpreter/MicroStep.h index c20e994..a8ea4f0 100644 --- a/src/uscxml/interpreter/MicroStep.h +++ b/src/uscxml/interpreter/MicroStep.h @@ -33,7 +33,7 @@ // forward declare namespace XERCESC_NS { - class DOMElement; +class DOMElement; } namespace uscxml { @@ -48,7 +48,7 @@ class USCXML_API MicroStep { public: PIMPL_OPERATORS(MicroStep); - virtual InterpreterState step(bool blocking); + virtual InterpreterState step(size_t blockMs); virtual void reset(); virtual bool isInState(const std::string& stateId); diff --git a/src/uscxml/interpreter/MicroStepImpl.h b/src/uscxml/interpreter/MicroStepImpl.h index e4cde5d..be9d974 100644 --- a/src/uscxml/interpreter/MicroStepImpl.h +++ b/src/uscxml/interpreter/MicroStepImpl.h @@ -41,7 +41,7 @@ class USCXML_API MicroStepCallbacks { public: /** Event Queues / Matching */ virtual Event dequeueInternal() = 0; - virtual Event dequeueExternal(bool blocking) = 0; + virtual Event dequeueExternal(size_t blockMs) = 0; virtual bool isMatched(const Event& event, const std::string& eventDesc) = 0; virtual void raiseDoneEvent(XERCESC_NS::DOMElement* state, XERCESC_NS::DOMElement* doneData) = 0; @@ -73,7 +73,7 @@ public: MicroStepImpl(MicroStepCallbacks* callbacks) : _callbacks(callbacks) {} - virtual InterpreterState step(bool blocking) = 0; + virtual InterpreterState step(size_t blockMs) = 0; virtual void reset() = 0; ///< Reset state machine virtual bool isInState(const std::string& stateId) = 0; virtual std::list<XERCESC_NS::DOMElement*> getConfiguration() = 0; diff --git a/src/uscxml/messages/Data.h b/src/uscxml/messages/Data.h index 6ab3bec..73640f0 100644 --- a/src/uscxml/messages/Data.h +++ b/src/uscxml/messages/Data.h @@ -33,8 +33,8 @@ // forward declare namespace XERCESC_NS { - class DOMDocument; - class DOMNode; +class DOMDocument; +class DOMNode; } namespace uscxml { diff --git a/src/uscxml/plugins/DataModel.h b/src/uscxml/plugins/DataModel.h index 03e557c..7716ad7 100644 --- a/src/uscxml/plugins/DataModel.h +++ b/src/uscxml/plugins/DataModel.h @@ -43,7 +43,7 @@ public: PIMPL_OPERATORS(DataModel); /// @copydoc DataModelImpl::getNames() - virtual std::list<std::string> getNames(); + virtual std::list<std::string> getNames(); /// @copydoc DataModelImpl::isValidSyntax() virtual bool isValidSyntax(const std::string& expr); diff --git a/src/uscxml/plugins/DataModelImpl.h b/src/uscxml/plugins/DataModelImpl.h index c3f5390..403a213 100644 --- a/src/uscxml/plugins/DataModelImpl.h +++ b/src/uscxml/plugins/DataModelImpl.h @@ -69,11 +69,11 @@ public: class USCXML_API DataModelImpl { public: virtual ~DataModelImpl() {} - + /** * The Factory wants to instantiate a new instance. - * This function will have to initialize the object. The actual constructor - * is called from within here. The only one who calls the constructor directly + * This function will have to initialize the object. The actual constructor + * is called from within here. The only one who calls the constructor directly * is the Factory for the prototype object. * * @param callbacks The callbacks available to the datamodel @@ -87,7 +87,7 @@ public: virtual std::list<std::string> getNames() = 0; /** - * Determine whether a given string constitutes valid syntax in the + * Determine whether a given string constitutes valid syntax in the * data-model's language. * @param expr A string, supposedly containing an expression of the data-model. * @return Whether expr is in L(DM). @@ -95,7 +95,7 @@ public: virtual bool isValidSyntax(const std::string& expr) { return true; // overwrite when datamodel supports it } - + /** * Set the given event as `_event` in the data-model's global scope. * @param event The event as it was dequeued from either the internal or external queue. @@ -104,7 +104,7 @@ public: /** * Experimental extension to have dynamic content in string literals. - * This function was used to replace ${foo} expressions on the data-model, + * This function was used to replace ${foo} expressions on the data-model, * e.g. in text nodes. It will eventually make a reappearance I guess. * @param content The string with tokens to replace. * @return How many occurences where replaced. @@ -116,8 +116,8 @@ public: * @param expr Anything that possibly evaluates to an enumerable object. * @return The number of items in the enumerable object. */ - virtual uint32_t getLength(const std::string& expr) = 0; - + virtual uint32_t getLength(const std::string& expr) = 0; + /** * Set a given item to the object at a given index for one iteration. * @param item A variable or location to assign the current object to. @@ -143,7 +143,7 @@ public: * @return An evaluated structure representing the given compound or literal. */ virtual Data evalAsData(const std::string& content) = 0; - + /** * Evaluate a given expression as a boolean. * This function is a subset of evalAsData() but saves on creating and copying a Data object. @@ -162,28 +162,28 @@ public: /** * Assign a data object to a location in the data-model. * There are different occurences in the SCXML IRP tests, e.g. -\verbatim -test147: - <data id="Var1" expr="0"/> - -test150: - <data id="Var3"> - [1,2,3] - </data> - -test277: - <data id="Var1" expr="return"/> -\endverbatim + \verbatim + test147: + <data id="Var1" expr="0"/> + + test150: + <data id="Var3"> + [1,2,3] + </data> + + test277: + <data id="Var1" expr="return"/> + \endverbatim * @param location A variable or locatio to assign to. * @param data The Data object with the respective data. */ virtual void assign(const std::string& location, const Data& data) = 0; - + /** * Initialize a variable / location in the data-model with a given data object. - * This is, semantically, very close to assign() but does not assume the + * This is, semantically, very close to assign() but does not assume the * location to be declared first. - * + * * @param location A variable or locatio to assign to. * @param data The Data object with the respective data. */ @@ -194,10 +194,10 @@ test277: * @todo This is currently unsupported */ virtual void addExtension(DataModelExtension* ext); - + /** * Concat the given terms into a conjunctive form. - * @todo This is required to automatically transform a state-chart into a + * @todo This is required to automatically transform a state-chart into a * state-machine. Actual transformation is still only available in legacy though. */ virtual std::string andExpressions(std::list<std::string>) { diff --git a/src/uscxml/plugins/EventHandler.h b/src/uscxml/plugins/EventHandler.h index e08b1ad..436f878 100644 --- a/src/uscxml/plugins/EventHandler.h +++ b/src/uscxml/plugins/EventHandler.h @@ -47,7 +47,7 @@ public: * Return a list of names for types we implement. */ virtual std::list<std::string> getNames() = 0; - + /** * Export a Data object for the `_x['name']` data-model namespace * @return An object to be represented at `_x['name']` diff --git a/src/uscxml/plugins/ExecutableContent.h b/src/uscxml/plugins/ExecutableContent.h index 14c1d5d..5fb2ac6 100644 --- a/src/uscxml/plugins/ExecutableContent.h +++ b/src/uscxml/plugins/ExecutableContent.h @@ -29,7 +29,7 @@ // forward declare namespace XERCESC_NS { - class DOMElement; +class DOMElement; } namespace uscxml { @@ -50,7 +50,7 @@ public: void enterElement(XERCESC_NS::DOMElement* node); void exitElement(XERCESC_NS::DOMElement* node); bool processChildren(); - + protected: std::shared_ptr<ExecutableContentImpl> _impl; diff --git a/src/uscxml/plugins/IOProcessor.h b/src/uscxml/plugins/IOProcessor.h index 558edfa..c2b6e30 100644 --- a/src/uscxml/plugins/IOProcessor.h +++ b/src/uscxml/plugins/IOProcessor.h @@ -41,7 +41,7 @@ public: /// @copydoc IOProcessorImpl::eventFromSCXML virtual void eventFromSCXML(const std::string& target, const Event& event); - + /// @copydoc IOProcessorImpl::isValidTarget virtual bool isValidTarget(const std::string& target); diff --git a/src/uscxml/plugins/IOProcessorImpl.h b/src/uscxml/plugins/IOProcessorImpl.h index 0e5b44a..bd28406 100644 --- a/src/uscxml/plugins/IOProcessorImpl.h +++ b/src/uscxml/plugins/IOProcessorImpl.h @@ -24,6 +24,7 @@ #include "uscxml/Common.h" #include "uscxml/plugins/EventHandler.h" #include "uscxml/messages/Event.h" +#include "uscxml/interpreter/InterpreterImpl.h" namespace uscxml { @@ -48,7 +49,7 @@ public: * @param event The event to deliver. */ virtual void eventFromSCXML(const std::string& target, const Event& event) = 0; - + /** * Determine whether the given target is a valid destination for events. * @param target A target where the Interpreter wants to deliver Event%s to. @@ -63,7 +64,7 @@ protected: * @param type The type of this I/O Processor for `event.origintype`. * @param origin The origin of this I/O Processor for `event.origin`. * @param internal If the event is to be delivered to the Interpreter's internal queue instead. - */ + */ void eventToSCXML(Event& event, const std::string& type, const std::string& origin, bool internal = false); }; diff --git a/src/uscxml/plugins/Invoker.h b/src/uscxml/plugins/Invoker.h index 33a89d6..f5c55d5 100644 --- a/src/uscxml/plugins/Invoker.h +++ b/src/uscxml/plugins/Invoker.h @@ -28,8 +28,8 @@ #include <xercesc/dom/DOM.hpp> namespace XERCESC_NS { - class DOMDocument; - class DOMNode; +class DOMDocument; +class DOMNode; } namespace uscxml { diff --git a/src/uscxml/plugins/InvokerImpl.h b/src/uscxml/plugins/InvokerImpl.h index d8a3410..7f2e578 100644 --- a/src/uscxml/plugins/InvokerImpl.h +++ b/src/uscxml/plugins/InvokerImpl.h @@ -25,6 +25,7 @@ #include "uscxml/Common.h" #include "uscxml/plugins/EventHandler.h" #include "uscxml/messages/Event.h" +#include "uscxml/interpreter/InterpreterImpl.h" namespace uscxml { @@ -39,7 +40,7 @@ class USCXML_API InvokerImpl : public EventHandlerImpl { public: InvokerImpl() : _finalize(NULL) {}; virtual ~InvokerImpl() {} - + virtual std::list<std::string> getNames() = 0; /** @@ -72,7 +73,7 @@ public: virtual XERCESC_NS::DOMElement* getFinalize() { return _finalize; } - + /** * Set the finalize XML element associated with this invoker. * @param finalize The finalize XMl element. @@ -80,7 +81,7 @@ public: virtual void setFinalize(XERCESC_NS::DOMElement* finalize) { _finalize = finalize; } - + /** * Set the invocation identifier as required when returning events. * @param invokeId The invocation identifier. @@ -96,7 +97,7 @@ protected: * @param type The type of this I/O Processor for `event.origintype`. * @param invokeId The invocation identifier of this invocation for `event.invokeid`. * @param internal If the event is to be delivered to the Interpreter's internal queue instead. - */ + */ void eventToSCXML(Event& event, const std::string& type, const std::string& invokeId, bool internal = false); XERCESC_NS::DOMElement* _finalize; diff --git a/src/uscxml/util/DOM.cpp b/src/uscxml/util/DOM.cpp index 0e1e9fa..ecf0960 100644 --- a/src/uscxml/util/DOM.cpp +++ b/src/uscxml/util/DOM.cpp @@ -194,12 +194,12 @@ bool DOMUtils::isMember(const DOMElement* node, return false; } -const DOMNode* DOMUtils::getNearestAncestor(const DOMNode* node, const std::string tagName) { +const DOMElement* DOMUtils::getNearestAncestor(const DOMNode* node, const std::string tagName) { const DOMNode* parent = node->getParentNode(); while(parent) { if (parent->getNodeType() == DOMNode::ELEMENT_NODE && iequals(TAGNAME_CAST(parent), tagName)) { - return parent; + return static_cast<const DOMElement*>(parent); } parent = parent->getParentNode(); } diff --git a/src/uscxml/util/DOM.h b/src/uscxml/util/DOM.h index 0e8621c..f259ea0 100644 --- a/src/uscxml/util/DOM.h +++ b/src/uscxml/util/DOM.h @@ -59,7 +59,7 @@ namespace uscxml { class USCXML_API DOMUtils { public: - static const XERCESC_NS::DOMNode* getNearestAncestor(const XERCESC_NS::DOMNode* node, const std::string tagName); + static const XERCESC_NS::DOMElement* getNearestAncestor(const XERCESC_NS::DOMNode* node, const std::string tagName); static bool isDescendant(const XERCESC_NS::DOMNode* s1, const XERCESC_NS::DOMNode* s2); diff --git a/src/uscxml/util/URL.cpp b/src/uscxml/util/URL.cpp index 561b9aa..a76c772 100644 --- a/src/uscxml/util/URL.cpp +++ b/src/uscxml/util/URL.cpp @@ -144,9 +144,9 @@ URL URLImpl::resolveWithCWD(URLImpl* relative) { #if WIN32 std::shared_ptr<URLImpl> cwdURL(new URLImpl(std::string(currPath))); #else - std::shared_ptr<URLImpl> cwdURL(new URLImpl(std::string("file://") + currPath + PATH_SEPERATOR)); + std::shared_ptr<URLImpl> cwdURL(new URLImpl(std::string("file://") + currPath + PATH_SEPERATOR)); #endif - + return resolve(relative, cwdURL.get()); } diff --git a/src/uscxml/util/URL.h b/src/uscxml/util/URL.h index dba8e3d..8127892 100644 --- a/src/uscxml/util/URL.h +++ b/src/uscxml/util/URL.h @@ -191,7 +191,7 @@ protected: class USCXML_API URL { public: PIMPL_OPERATORS(URL); - + URL(const std::string url) : _impl(new URLImpl(url)) {} bool isAbsolute() { |