Bump version to 2.8.0

since "next" is already frozen for 2.8 and is prepared for building the
first release candidate.
For details on versions see http://wiki.flightgear.org/Release_plan

.gitignore

@@ -1,5 +1,4 @@
 Makefile
-INSTALL
 SimGear.spec
 *.o
 lib*.a
@@ -12,5 +11,5 @@ CPackSourceConfig.cmake
 cmake_uninstall.cmake
 CTestTestfile.cmake
 install_manifest.txt
-build
+build*
 Build

CMakeLists.txt

@@ -60,12 +60,12 @@ else(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
 endif(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
 message(STATUS "Library installation directory: ${CMAKE_INSTALL_LIBDIR}")
 
-option(SIMGEAR_SHARED "Set to ON to build SimGear as a shared library/framework" OFF)
+option(SIMGEAR_SHARED   "Set to ON to build SimGear as a shared library/framework" OFF)
 option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
-option(JPEG_FACTORY "Enable JPEG-factory support" OFF)
-option(ENABLE_LIBSVN "Set to ON to build SimGear with libsvnclient support" ON)
-option(ENABLE_RTI "Set to ON to build SimGear with RTI support" OFF)
-option(ENABLE_TESTS "Set to OFF to disable building SimGear's test applications" ON)
+option(JPEG_FACTORY     "Enable JPEG-factory support" OFF)
+option(ENABLE_LIBSVN    "Set to ON to build SimGear with libsvnclient support" ON)
+option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
+option(ENABLE_TESTS     "Set to OFF to disable building SimGear's test applications" ON)
 
 if (MSVC)
   GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_SOURCE_DIR} PATH)
@@ -104,7 +104,7 @@ if (MSVC AND MSVC_3RDPARTY_ROOT)
   message(STATUS "BOOST_ROOT is ${BOOST_ROOT}")
   set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
   set (ALUT_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
-  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib) 
+  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
 endif (MSVC AND MSVC_3RDPARTY_ROOT)
 
 find_package(Boost REQUIRED)
@@ -114,9 +114,9 @@ find_package(ZLIB REQUIRED)
 find_package(Threads REQUIRED)
 
 if(SIMGEAR_HEADLESS)
-    message(STATUS "headless mode")
-    set(NO_OPENSCENEGRAPH_INTERFACE 1)
+    message(STATUS "SimGear mode: HEADLESS")
 else()
+    message(STATUS "SimGear mode: NORMAL")
     find_package(OpenGL REQUIRED)
     find_package(OpenAL REQUIRED)
     find_package(ALUT REQUIRED)
@@ -124,21 +124,28 @@ else()
 endif(SIMGEAR_HEADLESS)
 
 if(JPEG_FACTORY)
-    message(STATUS "JPEG-factory enabled")
+    message(STATUS "JPEG-factory: ENABLED")
     find_package(JPEG REQUIRED)
     include_directories(${JPEG_INCLUDE_DIR})
+else()
+    message(STATUS "JPEG-factory: DISABLED")
 endif(JPEG_FACTORY)
 
 if(ENABLE_LIBSVN)
-	find_package(SvnClient)
+    find_package(SvnClient)
 
-	if(LIBSVN_FOUND)
-		message(STATUS "libsvn found, enabling in SimGear")
-		set(HAVE_SVN_CLIENT_H 1)
-		set(HAVE_LIBSVN_CLIENT_1 1)
-	else()
-		message(STATUS "Missing libsvn, unable to enable SVN in SimGear")
-	endif(LIBSVN_FOUND)
+    if(LIBSVN_FOUND)
+        message(STATUS "Subversion client support: ENABLED")
+        set(HAVE_SVN_CLIENT_H 1)
+        set(HAVE_LIBSVN_CLIENT_1 1)
+    else()
+        # Oops. ENABLE_LIBSVN is ON, but svn is still missing.
+        # Provide clearly visible warning/hint, so builders know what else they should install (or disable).
+        message(WARNING "Failed to enable subversion client support. Unable to find required subversion client library. Some features may not be available (scenery download).")
+        message(WARNING "Install 'libsvn' library/DLL (libsvn-devel/libsvnclient/...). Otherwise disable subversion support (set 'ENABLE_LIBSVN' to 'OFF').")
+    endif(LIBSVN_FOUND)
+else()
+    message(STATUS "Subversion client support: DISABLED")
 endif(ENABLE_LIBSVN)
 
 check_include_file(sys/time.h HAVE_SYS_TIME_H)
@@ -147,8 +154,11 @@ check_include_file(unistd.h HAVE_UNISTD_H)
 check_include_file(windows.h HAVE_WINDOWS_H)
 
 if(ENABLE_RTI)
-# See if we have any rti library variant installed
+    # See if we have any rti library variant installed
+    message(STATUS "RTI: ENABLED")
     find_package(RTI)
+else()
+    message(STATUS "RTI: DISABLED")
 endif(ENABLE_RTI)
 
 check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
@@ -156,6 +166,8 @@ check_function_exists(ftime HAVE_FTIME)
 check_function_exists(timegm HAVE_TIMEGM)
 check_function_exists(rint HAVE_RINT)
 check_function_exists(mkdtemp HAVE_MKDTEMP)
+check_function_exists(bcopy HAVE_BCOPY)
+check_function_exists(mmap HAVE_MMAP)
 
 if(HAVE_UNISTD_H)
     set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
@@ -167,18 +179,15 @@ if(HAVE_UNISTD_H)
 
         int main() { return 0; }
         "
-        HAVE_CLOCK_GETTIME)    
+        HAVE_CLOCK_GETTIME)
 endif(HAVE_UNISTD_H)
 
 set(RT_LIBRARY "")
 if(HAVE_CLOCK_GETTIME)
-    check_function_exists(clock_gettime CLOCK_GETTIME_IN_LIBC)
-    if(NOT CLOCK_GETTIME_IN_LIBC)
-        check_library_exists(rt clock_gettime "" HAVE_RT)
-        if(HAVE_RT)
-            set(RT_LIBRARY rt)
-        endif(HAVE_RT)
-        endif(NOT CLOCK_GETTIME_IN_LIBC)
+    check_library_exists(rt clock_gettime "" HAVE_RT)
+    if(HAVE_RT)
+        set(RT_LIBRARY rt)
+    endif(HAVE_RT)
 endif(HAVE_CLOCK_GETTIME)
 
 SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
@@ -193,8 +202,9 @@ check_cxx_source_compiles(
     HAVE_ISNAN)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
-    set(WARNING_FLAGS -Wall)
-    
+    set(WARNING_FLAGS_CXX "-Wall")
+    set(WARNING_FLAGS_C   "-Wall")
+
     # certain GCC versions don't provide the atomic builds, and hence
     # require is to provide them in SGAtomic.cxx
     set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
@@ -203,8 +213,17 @@ if(CMAKE_COMPILER_IS_GNUCXX)
         GCC_ATOMIC_BUILTINS_FOUND)
 endif(CMAKE_COMPILER_IS_GNUCXX)
 
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+   set(WARNING_FLAGS_CXX "-Wall -Wno-overloaded-virtual")
+   set(WARNING_FLAGS_C   "-Wall")
+endif()
+
 if(WIN32)
 
+    if(MINGW)
+        add_definitions(-D_WIN32_WINNT=0x501)
+    endif()
+
     if(MSVC)
         # turn off various warnings
         # foreach(warning 4244 4251 4267 4275 4290 4786 4305 4996)
@@ -219,20 +238,21 @@ if(WIN32)
     
     set( WINSOCK_LIBRARY "ws2_32.lib" )
     set( RT_LIBRARY "winmm" )
-endif(WIN32)    
+endif(WIN32)
 
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS_CXX} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
 
 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_BINARY_DIR}/simgear)
+include_directories(${PROJECT_BINARY_DIR}/simgear/xml)
 
 include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
     ${Boost_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIR} 
     ${ALUT_INCLUDE_DIR} ${OPENAL_INCLUDE_DIR} )
 
-
 add_definitions(-DHAVE_CONFIG_H)
+add_definitions(-DHAVE_EXPAT_CONFIG_H)
 
 # configure a header file to pass some of the CMake settings
 # to the source code
@@ -241,11 +261,19 @@ configure_file (
   "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
   )
 
-if(ENABLE_TESTS)
-# enable CTest / make test target
+configure_file (
+    "${PROJECT_SOURCE_DIR}/simgear/xml/expat_config_cmake.in"
+    "${PROJECT_BINARY_DIR}/simgear/xml/expat_config.h"
+)
 
-include (Dart)
-enable_testing()
+if(ENABLE_TESTS)
+    # enable CTest / make test target
+    message(STATUS "Tests: ENABLED")
+
+    include (Dart)
+        enable_testing()
+else()
+    message(STATUS "Tests: DISABLED")
 endif(ENABLE_TESTS)
 
 install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
@@ -260,4 +288,3 @@ CONFIGURE_FILE(
   IMMEDIATE @ONLY)
 ADD_CUSTOM_TARGET(uninstall
   "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
-

CMakeModules/FindALUT.cmake

@@ -34,18 +34,6 @@
 # OPENAL_LIBRARY to override this selection or set the CMake environment
 # CMAKE_INCLUDE_PATH to modify the search paths.
 
-FIND_PATH(ALUT_INCLUDE_DIR alut.h
-  HINTS
-  $ENV{ALUTDIR}
-  PATH_SUFFIXES include/AL include/ALUT include
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt
-)
-
 FIND_LIBRARY(ALUT_LIBRARY 
   NAMES ALUT alut
   HINTS
@@ -59,9 +47,21 @@ FIND_LIBRARY(ALUT_LIBRARY
   /opt
 )
 
+FIND_PATH(ALUT_INCLUDE_DIR 
+  NAMES ALUT/alut.h alut.h
+  HINTS
+  $ENV{ALUTDIR}
+  PATH_SUFFIXES include/AL include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
 
-SET(ALUT_FOUND "NO")
-IF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
-  SET(ALUT_FOUND "YES")
-ENDIF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ALUT  DEFAULT_MSG  ALUT_LIBRARY ALUT_INCLUDE_DIR)
+
+MARK_AS_ADVANCED(ALUT_LIBRARY ALUT_INCLUDE_DIR)
 

COPYING

@@ -2,7 +2,7 @@
                        Version 2, June 1991
 
  Copyright (C) 1991 Free Software Foundation, Inc.
-                    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -464,7 +464,7 @@ convey the exclusion of warranty; and each file should have at least the
 
     You should have received a copy of the GNU Library General Public
     License along with this library; if not, write to the Free
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 
 Also add information on how to contact you by electronic and paper mail.
 

INSTALL

@@ -0,0 +1,57 @@
+How to build SimGear
+====================
+
+SimGear uses the CMake build system to generate a platform-specific
+build environment.  CMake reads the CMakeLists.txt files that you'll
+find throughout the source directories, checks for installed
+dependencies and then generates the appropriate build system.
+
+If you don't already have CMake installed on your system you can grab
+it from http://www.cmake.org, use version 2.6.4 or later.
+
+Under unices (i.e. Linux, Solaris, Free-BSD, HP-Ux, OSX) use the cmake
+or ccmake command-line utils. Preferably, create an out-of-source
+build directory and run cmake or ccmake from there. The advantage to
+this approach is that the temporary files created by CMake won't
+clutter the source directory, and also makes it possible to have
+multiple independent build targets by creating multiple build
+directories. In a directory alongside the SimGear source directory
+use:
+
+    mkdir sgbuild
+    cd sgbuild
+    cmake ../simgear -DCMAKE_BUILD_TYPE=Release
+    make
+    sudo make install
+
+
+Build Dependencies
+==================
+SimGear depends on a number of 3rd party libraries, the most notable
+being:
+
+* OpenSceneGraph (OSG) - see README.OSG
+* Portable Games Library (PLIB) - see README.plib
+* zlib compression library - see README.zlib
+* Open Audio Library (OpenAL) - see README.OpenAL
+* Subversion Client Library (optional dependency)
+
+
+Further information
+===================
+* README.cmake
+  for more detailed CMake instructions
+
+* README.msvc
+  in the FlightGear source package for more Windows-specific instructions
+
+* FlightGear Wiki
+  http://wiki.flightgear.org/Building_Flightgear
+
+* FlightGear Forums
+  For help on building see: http://www.flightgear.org/forums
+  => Support/Compiling
+
+* FlightGear Mailing lists
+  http://wiki.flightgear.org/index.php/Mailing_list
+

README

@@ -1 +1,15 @@
-[ Nothing here at this time. ]
+SimGear - Simulator Construction Tools
+======================================
+http://www.flightgear.org
+
+SimGear is a set of open-source libraries designed to be used as building
+blocks for quickly assembling 3d simulations, games, and visualization
+applications.
+
+SimGear is developed by the FlightGear project and also provides the base
+for the FlightGear Flight Simulator.
+
+Source code for SimGear is released under the GNU Library General Public
+License (LGPL) - see COPYING for license details.
+
+See INSTALL file for help on building SimGear.

README.OSG

@@ -3,7 +3,7 @@
 You *must* have OpenSceneGraph (OSG) installed to build this version of
 FlightGear.
 
-Notice that FlightGear 2.6.0 requires at least version 3.0.0.
+Notice that this version of SimGear/FlightGear requires at least OSG 3.0.0.
 
 You can get the latest version of OSG from:
 

README.cmake

@@ -0,0 +1,161 @@
+Getting started with CMake
+==========================
+
+(These instructions apply to Unix-like systems, including Cygwin and Mac. To
+build using Visual Studio or some other IDE supported by CMake, most of the
+information below still applies. Otherwise see
+http://wiki.flightgear.org/Building_Flightgear for Windows specific build
+instructions.)
+
+Always compile in a separate directory to the code. For example, if the
+code (eg, from Git) is at /home/curt/projects/simgear, you might create
+/home/curt/projects/sgbuild. Change into the new directory, and run
+
+    cmake ../simgear
+
+To generate standard Unix Makefiles in sgbuild.
+
+Probably you want to specify an install prefix:
+
+    cmake ../simgear -DCMAKE_INSTALL_PREFIX=/usr
+
+Note the install prefix is automatically searched for required libraries
+and header files, so if you install PLIB, OpenSceneGraph to the
+same prefix, most configuration options are unnecessary.
+
+If for some reason you have a dependency (or several) at a different prefix,
+you can specify one or more via CMAKE_PREFIX_PATH:
+
+    cmake ../simgear -DCMAKE_PREFIX_PATH="/opt/local;/opt/fgfs"
+
+(note the use of semi-colons to specify multiple prefix paths)
+
+Standard prefixes are searched automatically (/usr, /usr/local, /opt/local)
+
+Most dependencies also expose an environment variable to specify their
+installation directory explicitly eg OSG_DIR or PLIBDIR. Any of the methods
+described above will work, but specifying an INSTALL_PREFIX or PREFIX_PATH is
+usually simpler.
+
+By default, we select a release build. To create a debug build, use
+
+    cmake ../simgear -DCMAKE_BUILD_TYPE=Debug
+
+(or MinSizeRel, or RelWithDbg)
+
+Debug builds will automatically use corresponding debug builds of required
+libraries, if they are available. For example you can install debug builds of
+OpenSceneGraph, and a debug SimGear build will use them.
+
+(Debug builds of libraries have the 'd' suffix by default - Release builds
+have no additional suffix)
+
+Note most IDE projects (eg Xcode and Visual Studio) support building all the
+build types from the same project, so you can omit the CMAKE_BUILD_TYPE option
+when running cmake, and simply pick the build configuration as normal in the
+IDE.
+
+It's common to have several build directories with different build
+configurations, eg
+
+    /home/curt/projects/simgear (the git clone)
+    /home/curt/projects/sgdebug
+    /home/curt/projects/sgrelease
+    /home/curt/projects/sg-with-svn-osg
+
+To set an optional feature, do
+
+    cmake ../simgear -DFEATURE_NAME=ON
+
+(or 'OFF' to disable )
+
+To see the variables that can be configured / are currently defined, you can
+run one of the GUI front ends, or the following command:
+
+    cmake ../simgear -L
+
+Add 'A' to see all the options (including advanced options), or 'H' to see
+the help for each option (similar to running configure --help under autoconf):
+
+    cmake ../simgear -LH
+
+
+Build Targets
+=============
+
+For a Unix makefile build, 'make dist', 'make uninstall' and 'make test' are
+all available and should work as expected. 'make clean' is also as normal,
+but there is *no* 'make distclean' target. The equivalent is to completely
+remove your build directory, and start with a fresh one.
+
+Adding new files to the build
+
+Add source files to the SOURCES list, and headers to the HEADERS list. Note
+technically you only need to add source files, but omitting headers confuses
+project generation and distribution / packaging targets.
+
+For target conditional files, you can append to the SOURCES or HEADERS lists
+inside an if() test, for example:
+
+    if(APPLE)
+        list(APPEND SOURCES extraFile1.cxx extraFile2.cxx)
+    endif()
+
+Setting include directories
+
+In any CMakeList.txt, you can do the following:
+
+    include_directories(${PROJECT_SOURCE_DIR}/some/path)
+
+For example, this can be done in particular subdirectory, or at the project
+root, or an intermediate level.
+
+Setting target specific compile flags, includes or defines
+
+Use set_target_property(), for example
+
+    set_target_property(fgfs PROPERTIES
+            COMPILE_DEFINITIONS FOO BAR=1)
+
+You can set a property on an individual source file:
+
+    set_property(SOURCE myfile.cxx PROPERTY COMPILE_FLAGS "-Wno-unsigned-compare")
+
+Detecting Features / Libraries
+
+For most standard libraries (Gtk, wxWidget, Python, GDAL, Qt, libXml, Boost),
+cmake provides a standard helper. To see the available modules, run:
+
+     cmake --help-module-list
+
+In the root CMakeLists file, use a statement like:
+
+    find_package(OpenGL REQUIRED)
+
+Each package helper sets various variables such aaa_FOUND, aaa_INCLUDE_DIR,
+and aaa_LIBRARY. Depending on the complexity of the package, these variables
+might have different names (eg, OPENSCENEGRAPH_LIBRARIES).
+
+If there's no standard helper for a library you need, find a similar one, copy
+it to CMakeModules/FindABC.cmake, and modify the code to fit. Generally this
+is pretty straightforward. The built-in modules reside in the Cmake 'share'
+directory, eg /usr/share/cmake/modules on Unix systems.
+
+Note libraries support by pkg-config can be handled directly, with no need
+to create a custom FindABC helper.
+
+Adding a new executable target
+
+    add_executable(myexecutable ${SOURCES} ${HEADERS})
+    target_link_libraries(myexecutable .... libraries ... )
+    install(TARGETS myexecutable RUNTIME DESTINATION bin)
+
+(If the executable should not be installed, omit the final line above)
+
+If you add an additional line
+
+    add_test(testname ${EXECUTABLE_OUTPUT_PATH}/myexecutable)
+
+Then running 'make test' will run your executable as a unit test. The
+executable should return either a success or failure result code.
+

TODO

@@ -1 +0,0 @@
-03/25/2001 - Resolve location of Sky dome implimentation documentation.

projects/VC100/README

@@ -1,2 +0,0 @@
-The handmade VS2010 project files have been replaced by the Cmake build system.
-Please use Cmake to build FlightGear with Visual Studio 2010.

projects/VC90/.gitignore

@@ -1,3 +0,0 @@
-*.user
-Win32
-x64

simgear/.gitignore

@@ -1,3 +1,2 @@
 simgear_config.h
-simgear_config.h.*
 version.h

simgear/CMakeLists.txt

@@ -11,7 +11,6 @@ foreach( mylibfolder
         misc
         nasal
         props
-        route
         serial
         structure
         threads
@@ -40,14 +39,13 @@ set(HEADERS compiler.h constants.h sg_inlines.h ${PROJECT_BINARY_DIR}/simgear/ve
 install (FILES ${HEADERS}  DESTINATION include/simgear/)
 
 if(SIMGEAR_SHARED)
-    message(STATUS "building shared library")
+    message(STATUS "Library building mode: SHARED LIBRARIES")
     get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
     get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
     get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
 
     add_library(SimGearCore SHARED ${coreSources})
-    set_property(TARGET SimGearCore PROPERTY COMPILE_FLAGS "-DNO_OPENSCENEGRAPH_INTERFACE=1")
-    
+
   # set_property(TARGET SimGearCore PROPERTY FRAMEWORK 1)
   #  message(STATUS "public header: ${publicHeaders}")
   #  set_property(TARGET SimGearCore PROPERTY PUBLIC_HEADER "${publicHeaders}")
@@ -59,39 +57,37 @@ if(SIMGEAR_SHARED)
     target_link_libraries(SimGearCore ${ZLIB_LIBRARY} ${RT_LIBRARY})
     install(TARGETS SimGearCore LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
-    if(NOT SIMGEAR_HEADLESS)
-        if(LIBSVN_FOUND)
-            add_definitions(${APR_CFLAGS})
+    if(LIBSVN_FOUND)
+        add_definitions(${APR_CFLAGS})
 
-            IF(APPLE)
-                set_property(SOURCE scene/tsync/terrasync.cxx PROPERTY COMPILE_FLAGS "-iwithsysroot ${LIBSVN_INCLUDE_DIR}")
-            ELSE()
-                include_directories(${LIBSVN_INCLUDE_DIR})
-            ENDIF(APPLE)
-        endif(LIBSVN_FOUND)
-        
-        list(APPEND sceneSources scene/util/SGCoreOSGDependant.cxx)
-        
+        IF(APPLE)
+            set_property(SOURCE scene/tsync/terrasync.cxx PROPERTY COMPILE_FLAGS "-iwithsysroot ${LIBSVN_INCLUDE_DIR}")
+        ELSE()
+            include_directories(${LIBSVN_INCLUDE_DIR})
+        ENDIF(APPLE)
+        target_link_libraries(SimGearCore ${LIBSVN_LIBRARIES})
+    endif(LIBSVN_FOUND)
+
+    if(NOT SIMGEAR_HEADLESS)
         add_library(SimGearScene SHARED ${sceneSources})
       # set_property(TARGET SimGearScene PROPERTY FRAMEWORK 1)
       # set_property(TARGET SimGearScene PROPERTY PUBLIC_HEADER "${publicHeaders}")
         set_property(TARGET SimGearScene PROPERTY LINKER_LANGUAGE CXX)
         set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
         set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
-    
-        target_link_libraries(SimGearScene 
-            SimGearCore
-            ${ZLIB_LIBRARY} 
-            ${OPENSCENEGRAPH_LIBRARIES} 
-            ${OPENAL_LIBRARY} ${ALUT_LIBRARY}
-            ${OPENGL_LIBRARY})
-    
-        if(LIBSVN_FOUND)
-            target_link_libraries(SimGearScene ${LIBSVN_LIBRARIES})
-        endif(LIBSVN_FOUND)
 
+        target_link_libraries(SimGearScene
+            SimGearCore
+            ${ZLIB_LIBRARY}
+            ${OPENSCENEGRAPH_LIBRARIES}
+            ${OPENAL_LIBRARY} ${ALUT_LIBRARY}
+            ${OPENGL_LIBRARY}
+            ${JPEG_LIBRARY})
+    
         install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
     endif()
-   
+
+else()
+    message(STATUS "Library building mode: STATIC LIBRARIES")
 endif(SIMGEAR_SHARED)
-    
+

simgear/hla/CMakeLists.txt

@@ -22,8 +22,11 @@ set(HLA_HEADERS
     HLAOMTXmlVisitor.hxx
     HLAPropertyDataElement.hxx
     HLARawDataElement.hxx
+    HLATypes.hxx
     HLAVariantDataElement.hxx
     HLAVariantDataType.hxx
+    HLAVariantRecordDataElement.hxx
+    HLAVariantRecordDataType.hxx
     )
 
 set(HLA_SOURCES
@@ -37,6 +40,7 @@ set(HLA_SOURCES
     HLAEnumeratedDataElement.cxx
     HLAEnumeratedDataType.cxx
     HLAFederate.cxx
+    HLAInteractionClass.cxx
     HLAFixedRecordDataElement.cxx
     HLAFixedRecordDataType.cxx
     HLAObjectClass.cxx
@@ -44,24 +48,29 @@ set(HLA_SOURCES
     HLAOMTXmlVisitor.cxx
     HLAPropertyDataElement.cxx
     HLARawDataElement.cxx
-    HLAVariantDataElement.cxx
-    HLAVariantDataType.cxx
+    HLAVariantRecordDataElement.cxx
+    HLAVariantRecordDataType.cxx
     )
 simgear_component(hla hla "${HLA_SOURCES}" "${HLA_HEADERS}")
 
 if(RTI_FOUND)
   set(RTI13_SOURCES
+    RTI13InteractionClass.cxx
     RTI13ObjectClass.cxx
     RTI13ObjectInstance.cxx
     RTI13Federate.cxx
+    RTI13FederateFactory.cxx
     )
   simgear_component(rti13 hla "${RTI13_SOURCES}" "")
   set_property(TARGET sgrti13 APPEND PROPERTY COMPILE_FLAGS "-I${RTI_INCLUDE_DIR}")
 endif()
 
 set(RTI_SOURCES
+  RTIInteractionClass.cxx
   RTIObjectClass.cxx
   RTIObjectInstance.cxx
   RTIFederate.cxx
+  RTIFederateFactory.cxx
+  RTIFederateFactoryRegistry.cxx
   )
 simgear_component(rti hla "${RTI_SOURCES}" "")

simgear/hla/HLAArrayDataElement.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAArrayDataElement.hxx"
 
 #include <simgear/debug/logstream.hxx>
@@ -99,6 +105,7 @@ HLAArrayDataElement::HLAArrayDataElement(const HLAArrayDataType* dataType) :
 
 HLAArrayDataElement::~HLAArrayDataElement()
 {
+    clearStamp();
 }
 
 bool
@@ -110,6 +117,7 @@ HLAArrayDataElement::setNumElements(unsigned size)
     _elementVector.resize(size);
     for (unsigned i = oldSize; i < size; ++i)
         _elementVector[i] = newElement(i);
+    setDirty(true);
     return true;
 }
 
@@ -171,7 +179,12 @@ HLAArrayDataElement::setElement(unsigned index, HLADataElement* value)
         for (unsigned j = oldSize; j < index; ++j)
             _elementVector[j] = newElement(j);
     }
+    if (_elementVector[index].valid())
+        _elementVector[index]->clearStamp();
     _elementVector[index] = value;
+    if (value)
+        value->attachStamp(*this);
+    setDirty(true);
 }
 
 void
@@ -186,12 +199,27 @@ HLAArrayDataElement::getDataElementFactory()
     return _dataElementFactory.get();
 }
 
+void
+HLAArrayDataElement::_setStamp(Stamp* stamp)
+{
+    HLAAbstractArrayDataElement::_setStamp(stamp);
+    for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
+        if (!i->valid())
+            continue;
+        (*i)->attachStamp(*this);
+    }
+}
+
 HLADataElement*
 HLAArrayDataElement::newElement(unsigned index)
 {
     if (!_dataElementFactory.valid())
         return 0;
-    return _dataElementFactory->createElement(*this, index);
+    HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
+    if (!dataElement)
+        return 0;
+    dataElement->attachStamp(*this);
+    return dataElement;
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -203,6 +231,7 @@ HLAVariantArrayDataElement::HLAVariantArrayDataElement() :
 
 HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
 {
+    clearStamp();
 }
 
 bool
@@ -213,8 +242,8 @@ HLAVariantArrayDataElement::setDataType(const HLADataType* dataType)
         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
         return false;
     }
-    const HLAVariantDataType* variantDataType = arrayDataType->getElementDataType()->toVariantDataType();
-    if (!variantDataType) {
+    const HLAVariantRecordDataType* variantRecordDataType = arrayDataType->getElementDataType()->toVariantRecordDataType();
+    if (!variantRecordDataType) {
         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type: arrayDataTypes element data type is no a variant data type!");
         return false;
     }
@@ -231,13 +260,14 @@ HLAVariantArrayDataElement::setNumElements(unsigned size)
     _elementVector.resize(size);
     for (unsigned i = oldSize; i < size; ++i)
         _elementVector[i] = newElement();
+    setDirty(true);
     return true;
 }
 
 bool
 HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
 {
-    HLAVariantDataElement* dataElement = getElement(i);
+    HLAVariantRecordDataElement* dataElement = getElement(i);
     if (!dataElement)
         return false;
     return dataElement->decode(stream);
@@ -258,7 +288,7 @@ HLAVariantArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) c
     return dataElement->encode(stream);
 }
 
-const HLAVariantDataElement*
+const HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::getElement(unsigned index) const
 {
     if (_elementVector.size() <= index)
@@ -266,7 +296,7 @@ HLAVariantArrayDataElement::getElement(unsigned index) const
     return _elementVector[index].get();
 }
 
-HLAVariantDataElement*
+HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::getElement(unsigned index)
 {
     if (_elementVector.size() <= index)
@@ -274,7 +304,7 @@ HLAVariantArrayDataElement::getElement(unsigned index)
     return _elementVector[index].get();
 }
 
-HLAVariantDataElement*
+HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
 {
     if (_elementVector.size() <= index)
@@ -284,7 +314,7 @@ HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
 }
 
 void
-HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantDataElement* value)
+HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantRecordDataElement* value)
 {
     unsigned oldSize = _elementVector.size();
     if (oldSize <= index) {
@@ -292,7 +322,12 @@ HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantDataElement* va
         for (unsigned j = oldSize; j < index; ++j)
             _elementVector[j] = newElement();
     }
+    if (_elementVector[index].valid())
+        _elementVector[index]->clearStamp();
     _elementVector[index] = value;
+    if (value)
+        value->attachStamp(*this);
+    setDirty(true);
 }
 
 void
@@ -307,7 +342,18 @@ HLAVariantArrayDataElement::getAlternativeDataElementFactory()
     return _alternativeDataElementFactory.get();
 }
 
-HLAVariantDataElement*
+void
+HLAVariantArrayDataElement::_setStamp(Stamp* stamp)
+{
+    HLAAbstractArrayDataElement::_setStamp(stamp);
+    for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
+        if (!i->valid())
+            continue;
+        (*i)->attachStamp(*this);
+    }
+}
+
+HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::newElement()
 {
     const HLAArrayDataType* arrayDataType = getDataType();
@@ -316,12 +362,13 @@ HLAVariantArrayDataElement::newElement()
     const HLADataType* elementDataType = arrayDataType->getElementDataType();
     if (!elementDataType)
         return 0;
-    const HLAVariantDataType* variantDataType = elementDataType->toVariantDataType();
-    if (!variantDataType)
+    const HLAVariantRecordDataType* variantRecordDataType = elementDataType->toVariantRecordDataType();
+    if (!variantRecordDataType)
         return 0;
-    HLAVariantDataElement* variantDataElement = new HLAVariantDataElement(variantDataType);
-    variantDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
-    return variantDataElement;
+    HLAVariantRecordDataElement* variantRecordDataElement = new HLAVariantRecordDataElement(variantRecordDataType);
+    variantRecordDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
+    variantRecordDataElement->attachStamp(*this);
+    return variantRecordDataElement;
 }
 
 }

simgear/hla/HLAArrayDataElement.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -23,7 +23,7 @@
 #include <simgear/math/SGMath.hxx>
 #include "HLAArrayDataType.hxx"
 #include "HLADataElement.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 #include "HLADataTypeVisitor.hxx"
 
 namespace simgear {
@@ -78,6 +78,9 @@ public:
     void setDataElementFactory(DataElementFactory* dataElementFactory);
     DataElementFactory* getDataElementFactory();
 
+protected:
+    virtual void _setStamp(Stamp* stamp);
+
 private:
     HLADataElement* newElement(unsigned index);
 
@@ -102,20 +105,23 @@ public:
     virtual unsigned getNumElements() const;
     virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
 
-    const HLAVariantDataElement* getElement(unsigned index) const;
-    HLAVariantDataElement* getElement(unsigned index);
-    HLAVariantDataElement* getOrCreateElement(unsigned index);
-    void setElement(unsigned index, HLAVariantDataElement* value);
+    const HLAVariantRecordDataElement* getElement(unsigned index) const;
+    HLAVariantRecordDataElement* getElement(unsigned index);
+    HLAVariantRecordDataElement* getOrCreateElement(unsigned index);
+    void setElement(unsigned index, HLAVariantRecordDataElement* value);
 
-    typedef HLAVariantDataElement::DataElementFactory AlternativeDataElementFactory;
+    typedef HLAVariantRecordDataElement::DataElementFactory AlternativeDataElementFactory;
 
     void setAlternativeDataElementFactory(AlternativeDataElementFactory* alternativeDataElementFactory);
     AlternativeDataElementFactory* getAlternativeDataElementFactory();
 
-private:
-    HLAVariantDataElement* newElement();
+protected:
+    virtual void _setStamp(Stamp* stamp);
 
-    typedef std::vector<SGSharedPtr<HLAVariantDataElement> > ElementVector;
+private:
+    HLAVariantRecordDataElement* newElement();
+
+    typedef std::vector<SGSharedPtr<HLAVariantRecordDataElement> > ElementVector;
     ElementVector _elementVector;
 
     SGSharedPtr<AlternativeDataElementFactory> _alternativeDataElementFactory;
@@ -133,7 +139,7 @@ public:
     const std::string& getValue() const
     { return _value; }
     void setValue(const std::string& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
 
     virtual bool setNumElements(unsigned count)
     {
@@ -210,11 +216,11 @@ public:
     const SGVec2<T>& getValue() const
     { return _value; }
     void setValue(const SGVec2<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
 
     virtual bool setNumElements(unsigned count)
     {
-        for (unsigned i = 2; i < count; ++i)
+        for (unsigned i = count; i < 2; ++i)
             _value[i] = 0;
         return true;
     }
@@ -302,11 +308,11 @@ public:
     const SGVec3<T>& getValue() const
     { return _value; }
     void setValue(const SGVec3<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
 
     virtual bool setNumElements(unsigned count)
     {
-        for (unsigned i = 3; i < count; ++i)
+        for (unsigned i = count; i < 3; ++i)
             _value[i] = 0;
         return true;
     }
@@ -394,11 +400,11 @@ public:
     const SGVec4<T>& getValue() const
     { return _value; }
     void setValue(const SGVec4<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
 
     virtual bool setNumElements(unsigned count)
     {
-        for (unsigned i = 4; i < count; ++i)
+        for (unsigned i = count; i < 4; ++i)
             _value[i] = 0;
         return true;
     }
@@ -486,11 +492,11 @@ public:
     const SGQuat<T>& getValue() const
     { return _value; }
     void setValue(const SGQuat<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
 
     virtual bool setNumElements(unsigned count)
     {
-        for (unsigned i = 4; i < count; ++i)
+        for (unsigned i = count; i < 4; ++i)
             _value[i] = 0;
         return true;
     }

simgear/hla/HLAArrayDataType.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAArrayDataType.hxx"
 
 #include "HLAArrayDataElement.hxx"
@@ -44,12 +50,16 @@ HLAArrayDataType::toArrayDataType() const
     return this;
 }
 
+void
+HLAArrayDataType::releaseDataTypeReferences()
+{
+    _elementDataType = 0;
+    HLADataType::releaseDataTypeReferences();
+}
+
 void
 HLAArrayDataType::setElementDataType(const HLADataType* elementDataType)
 {
-    // FIXME this only works if we do not reset the alignment to something smaller
-    if (getAlignment() < elementDataType->getAlignment())
-        setAlignment(elementDataType->getAlignment());
     _elementDataType = elementDataType;
 }
 
@@ -65,6 +75,15 @@ HLAArrayDataType::setIsString(bool isString)
     _isString = isString;
 }
 
+void
+HLAArrayDataType::_recomputeAlignmentImplementation()
+{
+    unsigned alignment = 1;
+    if (const HLADataType* dataType = getElementDataType())
+        alignment = std::max(alignment, dataType->getAlignment());
+    setAlignment(alignment);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////
 
 HLAFixedArrayDataType::HLAFixedArrayDataType(const std::string& name) :
@@ -160,13 +179,20 @@ HLAVariableArrayDataType::encode(HLAEncodeStream& stream, const HLAAbstractArray
 }
 
 void
-HLAVariableArrayDataType::setSizeDataType(const HLADataType* sizeDataType)
+HLAVariableArrayDataType::setSizeDataType(const HLABasicDataType* sizeDataType)
 {
-    // FIXME this only works if we do not reset the alignment to something smaller
-    if (getAlignment() < sizeDataType->getAlignment())
-        setAlignment(sizeDataType->getAlignment());
     _sizeDataType = sizeDataType;
-    // setAlignment(SGMisc<unsigned>::max(_sizeDataType->getAlignment(), _elementDataType->getAlignment());
+}
+
+void
+HLAVariableArrayDataType::_recomputeAlignmentImplementation()
+{
+    unsigned alignment = 1;
+    if (const HLADataType* dataType = getElementDataType())
+        alignment = std::max(alignment, dataType->getAlignment());
+    if (const HLADataType* dataType = getSizeDataType())
+        alignment = std::max(alignment, dataType->getAlignment());
+    setAlignment(alignment);
 }
 
 } // namespace simgear

simgear/hla/HLAArrayDataType.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -35,6 +35,8 @@ public:
 
     virtual const HLAArrayDataType* toArrayDataType() const;
 
+    virtual void releaseDataTypeReferences();
+
     virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const = 0;
     virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const = 0;
 
@@ -50,6 +52,9 @@ public:
     bool getIsString() const
     { return _isString; }
 
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
 private:
     SGSharedPtr<const HLADataType> _elementDataType;
     bool _isOpaque;
@@ -85,12 +90,15 @@ public:
     virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
     virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
 
-    void setSizeDataType(const HLADataType* sizeDataType);
-    const HLADataType* getSizeDataType() const
+    void setSizeDataType(const HLABasicDataType* sizeDataType);
+    const HLABasicDataType* getSizeDataType() const
     { return _sizeDataType.get(); }
 
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
 private:
-    SGSharedPtr<const HLADataType> _sizeDataType;
+    SGSharedPtr<const HLABasicDataType> _sizeDataType;
 };
 
 } // namespace simgear

simgear/hla/HLABasicDataElement.cxx

@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLABasicDataElement.hxx"
 
 #include "HLADataElementVisitor.hxx"
@@ -125,6 +131,7 @@ void
 HLA##type##DataElement::setValue(ctype value)                                                     \
 {                                                                                                 \
     _value = value;                                                                               \
+    setDirty(true);                                                                               \
 }
 
 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);

simgear/hla/HLABasicDataType.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLABasicDataType.hxx"
 
 #include "HLADataType.hxx"

simgear/hla/HLABasicDataType.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public

simgear/hla/HLADataElement.cxx

@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLADataElement.hxx"
 
 #include <simgear/debug/logstream.hxx>
@@ -131,6 +137,51 @@ HLADataElement::~HLADataElement()
 {
 }
 
+void
+HLADataElement::setTimeStamp(const SGTimeStamp& timeStamp)
+{
+    if (!_stamp.valid())
+        return;
+    _stamp->setTimeStamp(timeStamp);
+}
+
+void
+HLADataElement::setTimeStampValid(bool timeStampValid)
+{
+    if (!_stamp.valid())
+        return;
+    _stamp->setTimeStampValid(timeStampValid);
+}
+
+double
+HLADataElement::getTimeDifference(const SGTimeStamp& timeStamp) const
+{
+    if (!_stamp.valid())
+        return 0;
+    if (!_stamp->getTimeStampValid())
+        return 0;
+    return (timeStamp - _stamp->getTimeStamp()).toSecs();
+}
+
+void
+HLADataElement::createStamp()
+{
+    _setStamp(new Stamp);
+    setDirty(true);
+}
+
+void
+HLADataElement::attachStamp(HLADataElement& dataElement)
+{
+    _setStamp(dataElement._getStamp());
+}
+
+void
+HLADataElement::clearStamp()
+{
+    _setStamp(0);
+}
+
 void
 HLADataElement::accept(HLADataElementVisitor& visitor)
 {
@@ -152,11 +203,11 @@ HLADataElement::toString(const Path& path)
     return s;
 }
 
-HLADataElement::AttributePathPair
-HLADataElement::toAttributePathPair(const std::string& s)
+HLADataElement::StringPathPair
+HLADataElement::toStringPathPair(const std::string& s)
 {
     Path path;
-    // Skip the initial attribute name if given
+    // Skip the initial attribute/parameter name if given
     std::string::size_type i = s.find_first_of("[.");
     std::string attribute = s.substr(0, i);
     while (i < s.size()) {
@@ -171,7 +222,7 @@ HLADataElement::toAttributePathPair(const std::string& s)
                 if (10 <= v) {
                     SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid character in array subscript for \""
                            << s << "\" at \"" << attribute << toString(path) << "\"!");
-                    return AttributePathPair();
+                    return StringPathPair();
                 }
                 index *= 10;
                 index += v;
@@ -186,7 +237,7 @@ HLADataElement::toAttributePathPair(const std::string& s)
             if (s.size() <= ++i) {
                 SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid terminating '.' for \""
                        << s << "\"!");
-                return AttributePathPair();
+                return StringPathPair();
             }
             std::string::size_type e = s.find_first_of("[.", i);
             path.push_back(s.substr(i, e - i));
@@ -195,7 +246,13 @@ HLADataElement::toAttributePathPair(const std::string& s)
         }
     }
 
-    return AttributePathPair(attribute, path);
+    return StringPathPair(attribute, path);
+}
+
+void
+HLADataElement::_setStamp(HLADataElement::Stamp* stamp)
+{
+    _stamp = stamp;
 }
 
 }

simgear/hla/HLADataElement.hxx

@@ -46,34 +46,30 @@ public:
     virtual const HLADataType* getDataType() const = 0;
     virtual bool setDataType(const HLADataType* dataType) = 0;
 
-    // Container for the timestamp the originating attribute was last updated for
-    // class TimeStamp : public SGReferenced {
-    // public:
-    //     const SGTimeStamp& getTimeStamp() const
-    //     { return _timeStamp; }
-    //     void setTimeStamp(const SGTimeStamp& timeStamp)
-    //     { _timeStamp = timeStamp; }
-    // private:
-    //     SGTimeStamp _timeStamp;
-    // };
+    /// Returns the time stamp if this data element.
+    /// Do not access this getter if the getTimeStampValid() method returns false.
+    const SGTimeStamp& getTimeStamp() const
+    { return _stamp->getTimeStamp(); }
+    void setTimeStamp(const SGTimeStamp& timeStamp);
 
-    // const TimeStamp* getTimeStamp() const
-    // { return _timeStamp.get(); }
-    // void setTimeStamp(const TimeStamp* timeStamp)
-    // { _timeStamp = timeStamp; }
+    bool getTimeStampValid() const
+    { if (!_stamp.valid()) return false; return _stamp->getTimeStampValid(); }
+    void setTimeStampValid(bool timeStampValid);
 
-    // struct ChangeCount : public SGReferenced {
-    //     ChangeCount() : _value(0) {}
-    //     unsigned _value;
-    // };
-    // SGSharedPtr<ChangeCount> _changeCount;
-    // unsigned getChangeCount() const
-    // {
-    //     // If we don't have return allways the same
-    //     if (!_changeCount.valid())
-    //         return 0;
-    //     return _changeCount->_value;
-    // }
+    /// Convenience function that gives the time difference in seconds to a given timestamp
+    /// This function returns 0 if the timestamp is not valid.
+    double getTimeDifference(const SGTimeStamp& timeStamp) const;
+
+    /// Dirty tracking of the attribute/parameter that this data element belongs to
+    bool getDirty() const
+    { if (!_stamp.valid()) return true; return _stamp->getDirty(); }
+    void setDirty(bool dirty)
+    { if (!_stamp.valid()) return; _stamp->setDirty(dirty); }
+
+    /// Stamp handling
+    void createStamp();
+    void attachStamp(HLADataElement& dataElement);
+    void clearStamp();
 
     /// HLADataElements could be identified by path
     /// These paths are composed of structure field names and array indices in the
@@ -150,18 +146,55 @@ public:
         SGSharedPtr<Data> _data;
     };
     typedef std::list<PathElement> Path;
-    typedef std::pair<std::string, Path> AttributePathPair;
+    typedef std::pair<std::string, Path> StringPathPair;
+    typedef StringPathPair AttributePathPair; // deprecated
     typedef std::pair<unsigned, Path> IndexPathPair;
 
     static std::string toString(const Path& path);
-    static std::string toString(const AttributePathPair& path)
+    static std::string toString(const StringPathPair& path)
     { return path.first + toString(path.second); }
-    static AttributePathPair toAttributePathPair(const std::string& s);
+    static StringPathPair toStringPathPair(const std::string& s);
+    static AttributePathPair toAttributePathPair(const std::string& s) // deprecated
+    { return toStringPathPair(s); }
     static Path toPath(const std::string& s)
-    { return toAttributePathPair(s).second; }
+    { return toStringPathPair(s).second; }
+
+protected:
+    // Container for the timestamp the originating attribute was last updated for
+    class Stamp : public SGReferenced {
+    public:
+        Stamp() : _timeStampValid(false), _dirty(true)
+        { }
+
+        const SGTimeStamp& getTimeStamp() const
+        { return _timeStamp; }
+        void setTimeStamp(const SGTimeStamp& timeStamp)
+        { _timeStamp = timeStamp; }
+
+        bool getTimeStampValid() const
+        { return _timeStampValid; }
+        void setTimeStampValid(bool timeStampValid)
+        { _timeStampValid = timeStampValid; }
+
+        bool getDirty() const
+        { return _dirty; }
+        void setDirty(bool dirty)
+        { _dirty = dirty; }
+
+    private:
+        SGTimeStamp _timeStamp;
+        bool _timeStampValid;
+        bool _dirty;
+    };
+
+    /// get the stamp
+    Stamp* _getStamp() const
+    { return _stamp.get(); }
+    /// Set the stamp
+    virtual void _setStamp(Stamp* stamp);
 
 private:
-    // SGSharedPtr<const TimeStamp> _timeStamp;
+    SGSharedPtr<Stamp> _stamp;
 };
 
 class HLADataElementProvider {

simgear/hla/HLADataElementVisitor.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -24,7 +24,7 @@ class HLABasicDataElement;
 class HLAAbstractEnumeratedDataElement;
 class HLAAbstractFixedRecordDataElement;
 class HLAAbstractArrayDataElement;
-class HLAAbstractVariantDataElement;
+class HLAAbstractVariantRecordDataElement;
 
 class HLADataElementVisitor {
 public:
@@ -36,7 +36,7 @@ public:
     virtual void apply(HLAAbstractEnumeratedDataElement&);
     virtual void apply(HLAAbstractArrayDataElement&);
     virtual void apply(HLAAbstractFixedRecordDataElement&);
-    virtual void apply(HLAAbstractVariantDataElement&);
+    virtual void apply(HLAAbstractVariantRecordDataElement&);
 };
 
 class HLAConstDataElementVisitor {
@@ -49,7 +49,7 @@ public:
     virtual void apply(const HLAAbstractEnumeratedDataElement&);
     virtual void apply(const HLAAbstractArrayDataElement&);
     virtual void apply(const HLAAbstractFixedRecordDataElement&);
-    virtual void apply(const HLAAbstractVariantDataElement&);
+    virtual void apply(const HLAAbstractVariantRecordDataElement&);
 };
 
 }

simgear/hla/HLADataType.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLADataType.hxx"
 
 #include "HLADataElement.hxx"
@@ -39,12 +45,6 @@ HLADataType::accept(HLADataTypeVisitor& visitor) const
     visitor.apply(*this);
 }
 
-const HLADataTypeReference*
-HLADataType::toDataTypeReference() const
-{
-    return 0;
-}
-
 const HLABasicDataType*
 HLADataType::toBasicDataType() const
 {
@@ -69,12 +69,25 @@ HLADataType::toFixedRecordDataType() const
     return 0;
 }
 
-const HLAVariantDataType*
-HLADataType::toVariantDataType() const
+const HLAVariantRecordDataType*
+HLADataType::toVariantRecordDataType() const
 {
     return 0;
 }
 
+bool
+HLADataType::recomputeAlignment()
+{
+    unsigned alignment = getAlignment();
+    _recomputeAlignmentImplementation();
+    return alignment != getAlignment();
+}
+
+void
+HLADataType::releaseDataTypeReferences()
+{
+}
+
 void
 HLADataType::setAlignment(unsigned alignment)
 {
@@ -85,20 +98,9 @@ HLADataType::setAlignment(unsigned alignment)
         _alignment = alignment;
 }
 
-HLADataTypeReference::~HLADataTypeReference()
-{
-}
-
 void
-HLADataTypeReference::accept(HLADataTypeVisitor& visitor) const
+HLADataType::_recomputeAlignmentImplementation()
 {
-    visitor.apply(*this);
-}
-
-const HLADataTypeReference*
-HLADataTypeReference::toDataTypeReference() const
-{
-    return this;
 }
 
 }

simgear/hla/HLADataType.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -27,19 +27,11 @@ namespace simgear {
 
 class HLADataTypeVisitor;
 
-class HLADataTypeReference;
 class HLABasicDataType;
 class HLAArrayDataType;
 class HLAEnumeratedDataType;
 class HLAFixedRecordDataType;
-class HLAVariantDataType;
-
-enum HLAUpdateType {
-    HLAStaticUpdate,
-    HLAPeriodicUpdate,
-    HLAConditionalUpdate,
-    HLAUndefinedUpdate
-};
+class HLAVariantRecordDataType;
 
 class HLADataType : public SGWeakReferenced {
 public:
@@ -58,42 +50,33 @@ public:
 
     virtual void accept(HLADataTypeVisitor& visitor) const;
 
-    virtual const HLADataTypeReference* toDataTypeReference() const;
     virtual const HLABasicDataType* toBasicDataType() const;
     virtual const HLAArrayDataType* toArrayDataType() const;
     virtual const HLAEnumeratedDataType* toEnumeratedDataType() const;
     virtual const HLAFixedRecordDataType* toFixedRecordDataType() const;
-    virtual const HLAVariantDataType* toVariantDataType() const;
+    /// deprecated
+    const HLAVariantRecordDataType* toVariantDataType() const { return toVariantRecordDataType(); }
+    virtual const HLAVariantRecordDataType* toVariantRecordDataType() const;
+
+    /// Recompute the alignment value of this data type.
+    /// Return true if the alignment changed, false otherwise.
+    bool recomputeAlignment();
+    /// Release references to other data types. Since we can have cycles this is
+    /// required for propper feeing of memory.
+    virtual void releaseDataTypeReferences();
 
 protected:
     HLADataType(const std::string& name, unsigned alignment = 1);
     void setAlignment(unsigned alignment);
 
+    virtual void _recomputeAlignmentImplementation();
+
 private:
     std::string _name;
     std::string _semantics;
     unsigned _alignment;
 };
 
-// Weak reference to a data type. Used to implement self referencing data types
-class HLADataTypeReference : public HLADataType {
-public:
-    HLADataTypeReference(const SGSharedPtr<HLADataType>& dataType) :
-        HLADataType(dataType->getName(), dataType->getAlignment()),
-        _dataType(dataType)
-    { }
-    virtual ~HLADataTypeReference();
-
-    SGSharedPtr<const HLADataType> getDataType() const
-    { return _dataType.lock(); }
-
-    virtual void accept(HLADataTypeVisitor& visitor) const;
-    virtual const HLADataTypeReference* toDataTypeReference() const;
-
-private:
-    SGWeakPtr<const HLADataType> _dataType;
-};
-
 } // namespace simgear
 
 #endif

simgear/hla/HLADataTypeVisitor.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLADataTypeVisitor.hxx"
 
 #include "HLAArrayDataElement.hxx"
@@ -22,7 +28,7 @@
 #include "HLADataTypeVisitor.hxx"
 #include "HLAEnumeratedDataElement.hxx"
 #include "HLAFixedRecordDataElement.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 
 namespace simgear {
 
@@ -160,11 +166,11 @@ HLADataElementFactoryVisitor::apply(const HLAFixedRecordDataType& dataType)
     _dataElement = recordDataElement;
 }
 
-class HLADataElementFactoryVisitor::VariantDataElementFactory : public HLAVariantDataElement::DataElementFactory {
+class HLADataElementFactoryVisitor::VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
 public:
-    virtual HLADataElement* createElement(const HLAVariantDataElement& element, unsigned index)
+    virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
     {
-        const HLAVariantDataType* dataType = element.getDataType();
+        const HLAVariantRecordDataType* dataType = element.getDataType();
         if (!dataType)
             return 0;
         const HLADataType* alternativeDataType = element.getAlternativeDataType();
@@ -177,12 +183,12 @@ public:
 };
 
 void
-HLADataElementFactoryVisitor::apply(const HLAVariantDataType& dataType)
+HLADataElementFactoryVisitor::apply(const HLAVariantRecordDataType& dataType)
 {
-    SGSharedPtr<HLAVariantDataElement> variantDataElement;
-    variantDataElement = new HLAVariantDataElement(&dataType);
-    variantDataElement->setDataElementFactory(new VariantDataElementFactory);
-    _dataElement = variantDataElement;
+    SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
+    variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
+    variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory);
+    _dataElement = variantRecordDataElement;
 }
 
 } // namespace simgear

simgear/hla/HLADataTypeVisitor.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -27,7 +27,7 @@
 #include "HLADataElement.hxx"
 #include "HLAEnumeratedDataType.hxx"
 #include "HLAFixedRecordDataType.hxx"
-#include "HLAVariantDataType.hxx"
+#include "HLAVariantRecordDataType.hxx"
 
 namespace simgear {
 
@@ -38,16 +38,6 @@ public:
     virtual void apply(const HLADataType& dataType)
     { }
 
-    virtual void apply(const HLADataTypeReference& dataType)
-    {
-        SGSharedPtr<const HLADataType> dataTypeReference = dataType.getDataType();
-        if (!dataTypeReference.valid()) {
-            SG_LOG(SG_NETWORK, SG_WARN, "HLADataTypeReference weak reference vanished!");
-            return;
-        }
-        dataTypeReference->accept(*this);
-    }
-
     virtual void apply(const HLABasicDataType& dataType)
     { apply(static_cast<const HLADataType&>(dataType)); }
     virtual void apply(const HLAInt8DataType& dataType)
@@ -84,7 +74,7 @@ public:
     virtual void apply(const HLAFixedRecordDataType& dataType)
     { apply(static_cast<const HLADataType&>(dataType)); }
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     { apply(static_cast<const HLADataType&>(dataType)); }
 };
 
@@ -145,7 +135,7 @@ public:
         }
     }
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     { assert(0); }
 
 protected:
@@ -188,7 +178,7 @@ public:
             dataType.getFieldDataType(i)->accept(*this);
     }
 
-    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+    virtual void apply(const HLAVariantRecordDataType& dataType) { assert(0); }
 
 protected:
     HLADecodeStream& _stream;
@@ -232,7 +222,7 @@ public:
             dataType.getFieldDataType(i)->accept(*this);
     }
 
-    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+    virtual void apply(const HLAVariantRecordDataType& dataType) { assert(0); }
 
 protected:
     HLAEncodeStream& _stream;
@@ -269,7 +259,7 @@ public:
         HLADataTypeDecodeVisitor::apply(dataType);
     }
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     {
         SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
         HLADataTypeDecodeVisitor::apply(dataType);
@@ -305,7 +295,7 @@ public:
         HLADataTypeEncodeVisitor::apply(dataType);
     }
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     {
         SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
         HLADataTypeEncodeVisitor::apply(dataType);
@@ -386,7 +376,7 @@ public:
         HLADataTypeDecodeVisitor::apply(dataType);
     }
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     {
         SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
         HLADataTypeDecodeVisitor::apply(dataType);
@@ -467,7 +457,7 @@ public:
         HLADataTypeEncodeVisitor::apply(dataType);
     }
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     {
         SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
         HLADataTypeEncodeVisitor::apply(dataType);
@@ -654,14 +644,14 @@ public:
 
     virtual void apply(const HLAFixedRecordDataType& dataType);
 
-    virtual void apply(const HLAVariantDataType& dataType);
+    virtual void apply(const HLAVariantRecordDataType& dataType);
 
     HLADataElement* getDataElement()
     { return _dataElement.release(); }
 
 protected:
     class ArrayDataElementFactory;
-    class VariantDataElementFactory;
+    class VariantRecordDataElementFactory;
 
     SGSharedPtr<HLADataElement> _dataElement;
 };

simgear/hla/HLAEnumeratedDataElement.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAEnumeratedDataElement.hxx"
 
 #include <simgear/debug/logstream.hxx>

simgear/hla/HLAEnumeratedDataType.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAEnumeratedDataType.hxx"
 
 #include <map>
@@ -176,5 +182,14 @@ HLAEnumeratedDataType::setRepresentation(HLABasicDataType* representation)
     _map.swap(representationVisitor._map);
 }
 
+void
+HLAEnumeratedDataType::_recomputeAlignmentImplementation()
+{
+    unsigned alignment = 1;
+    if (const HLADataType* dataType = getRepresentation())
+        alignment = std::max(alignment, dataType->getAlignment());
+    setAlignment(alignment);
+}
+
 } // namespace simgear
 

simgear/hla/HLAEnumeratedDataType.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -70,6 +70,9 @@ public:
         return _map->getDataType();
     }
 
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
 private:
     class AbstractMap : public SGReferenced {
     public:

simgear/hla/HLAFederate.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,10 +15,21 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAFederate.hxx"
 
-#include "RTI13Federate.hxx"
+#include <algorithm>
+
+#include "simgear/debug/logstream.hxx"
+
 #include "RTIFederate.hxx"
+#include "RTIFederateFactoryRegistry.hxx"
+#include "RTI13FederateFactory.hxx"
 #include "RTIInteractionClass.hxx"
 #include "RTIObjectClass.hxx"
 #include "HLADataElement.hxx"
@@ -35,10 +46,19 @@ HLAFederate::HLAFederate() :
     _timeConstrainedByLocalClock(false),
     _done(false)
 {
+    // For now instantiate the current only available factory here explicitly
+    RTI13FederateFactory::instance();
 }
 
 HLAFederate::~HLAFederate()
 {
+    _clearRTI();
+
+    // Remove the data type references from the data types.
+    // This is to remove the cycles from the data types that might happen if a data type references itself
+    for (DataTypeMap::iterator i = _dataTypeMap.begin(); i != _dataTypeMap.end(); ++i) {
+        i->second->releaseDataTypeReferences();
+    }
 }
 
 HLAFederate::Version
@@ -58,6 +78,22 @@ HLAFederate::setVersion(HLAFederate::Version version)
     return true;
 }
 
+bool
+HLAFederate::setVersion(const std::string& version)
+{
+    if (version == "RTI13")
+        return setVersion(RTI13);
+    else if (version == "RTI1516")
+        return setVersion(RTI1516);
+    else if (version == "RTI1516E")
+        return setVersion(RTI1516E);
+    else {
+        /// at some time think about routing these down to the factory
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Unknown version string in HLAFederate::setVersion!");
+        return false;
+    }
+}
+
 const std::list<std::string>&
 HLAFederate::getConnectArguments() const
 {
@@ -159,28 +195,9 @@ HLAFederate::setFederateName(const std::string& federateName)
 bool
 HLAFederate::connect(Version version, const std::list<std::string>& stringList)
 {
-    if (_rtiFederate.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLA: Trying to connect to already connected federate!");
-        return false;
-    }
-    switch (version) {
-    case RTI13:
-        _rtiFederate = new RTI13Federate(stringList);
-        _version = version;
-        _connectArguments = stringList;
-        break;
-    case RTI1516:
-        SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516 not yet(!?) supported.");
-        // _rtiFederate = new RTI1516Federate(stringList);
-        break;
-    case RTI1516E:
-        SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516E not yet(!?) supported.");
-        // _rtiFederate = new RTI1516eFederate(stringList);
-        break;
-    default:
-        SG_LOG(SG_NETWORK, SG_WARN, "HLA: Unknown rti version in connect!");
-    }
-    return _rtiFederate.valid();
+    _version = version;
+    _connectArguments = stringList;
+    return connect();
 }
 
 bool
@@ -190,17 +207,22 @@ HLAFederate::connect()
         SG_LOG(SG_NETWORK, SG_WARN, "HLA: Trying to connect to already connected federate!");
         return false;
     }
+
+    SGSharedPtr<RTIFederateFactoryRegistry> registry = RTIFederateFactoryRegistry::instance();
+    if (!registry) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLA: RTIFederateFactoryRegistry is no longer available!");
+        return false;
+    }
+
     switch (_version) {
     case RTI13:
-        _rtiFederate = new RTI13Federate(_connectArguments);
+        _rtiFederate = registry->create("RTI13", _connectArguments);
         break;
     case RTI1516:
-        SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516 not yet(!?) supported.");
-        // _rtiFederate = new RTI1516Federate(_connectArguments);
+        _rtiFederate = registry->create("RTI1516", _connectArguments);
         break;
     case RTI1516E:
-        SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516E not yet(!?) supported.");
-        // _rtiFederate = new RTI1516eFederate(_connectArguments);
+        _rtiFederate = registry->create("RTI1516E", _connectArguments);
         break;
     default:
         SG_LOG(SG_NETWORK, SG_WARN, "HLA: Unknown rti version in connect!");
@@ -215,7 +237,8 @@ HLAFederate::disconnect()
         SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
         return false;
     }
-    _rtiFederate = 0;
+
+    _clearRTI();
     return true;
 }
 
@@ -648,14 +671,11 @@ HLAFederate::timeAdvanceAvailable()
     }
 
     SGTimeStamp timeStamp;
-    if (!_rtiFederate->queryGALT(timeStamp)) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLA: Could not query GALT!");
-        return false;
-    }
-
-    if (!_rtiFederate->timeAdvanceRequestAvailable(timeStamp)) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLA: Time advance request failed!");
-        return false;
+    if (_rtiFederate->queryGALT(timeStamp)) {
+        if (!_rtiFederate->timeAdvanceRequestAvailable(timeStamp)) {
+            SG_LOG(SG_NETWORK, SG_WARN, "HLA: Time advance request failed!");
+            return false;
+        }
     }
 
     return processMessages();
@@ -748,11 +768,6 @@ bool
 HLAFederate::readObjectModelTemplate(const std::string& objectModel,
                                      HLAFederate::ObjectModelFactory& objectModelFactory)
 {
-    if (!_rtiFederate.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
-        return false;
-    }
-
     // The XML version of the federate object model.
     // This one covers the generic attributes, parameters and data types.
     HLAOMTXmlVisitor omtXmlVisitor;
@@ -767,6 +782,8 @@ HLAFederate::readObjectModelTemplate(const std::string& objectModel,
         return false;
     }
 
+    omtXmlVisitor.setDataTypesToFederate(*this);
+
     unsigned numObjectClasses = omtXmlVisitor.getNumObjectClasses();
     for (unsigned i = 0; i < numObjectClasses; ++i) {
         const HLAOMTXmlVisitor::ObjectClass* objectClass = omtXmlVisitor.getObjectClass(i);
@@ -781,72 +798,145 @@ HLAFederate::readObjectModelTemplate(const std::string& objectModel,
         bool publish = objectModelFactory.publishObjectClass(objectClassName, objectClass->getSharing());
         bool subscribe = objectModelFactory.subscribeObjectClass(objectClassName, objectClass->getSharing());
 
-        std::set<unsigned> subscriptions;
-        std::set<unsigned> publications;
-
         // process the attributes
         for (unsigned j = 0; j < objectClass->getNumAttributes(); ++j) {
             const simgear::HLAOMTXmlVisitor::Attribute* attribute;
             attribute = objectClass->getAttribute(j);
 
             std::string attributeName = attribute->getName();
-            unsigned index = hlaObjectClass->getAttributeIndex(attributeName);
+            unsigned index = hlaObjectClass->addAttribute(attributeName);
 
             if (index == ~0u) {
                 SG_LOG(SG_IO, SG_WARN, "RTI does not know the \"" << attributeName << "\" attribute!");
                 continue;
             }
 
-            SGSharedPtr<HLADataType> dataType;
-            dataType = omtXmlVisitor.getAttributeDataType(objectClassName, attributeName);
+            // the attributes datatype
+            SGSharedPtr<const HLADataType> dataType = getDataType(attribute->getDataType());
             if (!dataType.valid()) {
                 SG_LOG(SG_IO, SG_WARN, "Could not find data type for attribute \""
                        << attributeName << "\" in object class \"" << objectClassName << "\"!");
             }
             hlaObjectClass->setAttributeDataType(index, dataType);
-
-            HLAUpdateType updateType = HLAUndefinedUpdate;
-            if (attribute->_updateType == "Periodic")
-                updateType = HLAPeriodicUpdate;
-            else if (attribute->_updateType == "Static")
-                updateType = HLAStaticUpdate;
-            else if (attribute->_updateType == "Conditional")
-                updateType = HLAConditionalUpdate;
-            hlaObjectClass->setAttributeUpdateType(index, updateType);
-
+            hlaObjectClass->setAttributeUpdateType(index, attribute->getUpdateType());
             if (subscribe && objectModelFactory.subscribeAttribute(objectClassName, attributeName, attribute->_sharing))
-                subscriptions.insert(index);
+                hlaObjectClass->setAttributeSubscriptionType(index, attribute->getSubscriptionType());
             if (publish && objectModelFactory.publishAttribute(objectClassName, attributeName, attribute->_sharing))
-                publications.insert(index);
+                hlaObjectClass->setAttributePublicationType(index, attribute->getPublicationType());
         }
 
         if (publish)
-            hlaObjectClass->publish(publications);
+            hlaObjectClass->publish();
         if (subscribe)
-            hlaObjectClass->subscribe(subscriptions, true);
+            hlaObjectClass->subscribe();
 
-        _objectClassMap[objectClassName] = hlaObjectClass;
+    }
+
+    return resolveObjectModel();
+}
+
+bool
+HLAFederate::readRTI13ObjectModelTemplate(const std::string& objectModel)
+{
+    SG_LOG(SG_IO, SG_ALERT, "HLA version RTI13 not yet(!?) supported.");
+    return false;
+}
+
+bool
+HLAFederate::readRTI1516ObjectModelTemplate(const std::string& objectModel)
+{
+    // The XML version of the federate object model.
+    // This one covers the generic attributes, parameters and data types.
+    HLAOMTXmlVisitor omtXmlVisitor;
+    try {
+        readXML(objectModel, omtXmlVisitor);
+    } catch (const sg_throwable& e) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file: "
+               << e.getMessage());
+        return false;
+    } catch (...) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file");
+        return false;
+    }
+
+    omtXmlVisitor.setToFederate(*this);
+
+    return resolveObjectModel();
+}
+
+bool
+HLAFederate::readRTI1516EObjectModelTemplate(const std::string& objectModel)
+{
+    SG_LOG(SG_IO, SG_ALERT, "HLA version RTI1516E not yet(!?) supported.");
+    return false;
+}
+
+bool
+HLAFederate::resolveObjectModel()
+{
+    if (!_rtiFederate.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLA: Accessing unconnected federate!");
+        return false;
+    }
+
+    for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i) {
+        RTIInteractionClass* rtiInteractionClass = _rtiFederate->createInteractionClass(i->second->getName(), i->second.get());
+        if (!rtiInteractionClass) {
+            SG_LOG(SG_NETWORK, SG_ALERT, "HLAFederate::_insertInteractionClass(): "
+                   "No RTIInteractionClass found for \"" << i->second->getName() << "\"!");
+            return false;
+        }
+        i->second->_setRTIInteractionClass(rtiInteractionClass);
+    }
+
+    for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i) {
+        RTIObjectClass* rtiObjectClass = _rtiFederate->createObjectClass(i->second->getName(), i->second.get());
+        if (!rtiObjectClass) {
+            SG_LOG(SG_NETWORK, SG_ALERT, "HLAFederate::_insertObjectClass(): "
+                   "No RTIObjectClass found for \"" << i->second->getName() << "\"!");
+            return false;
+        }
+        i->second->_setRTIObjectClass(rtiObjectClass);
     }
 
     return true;
 }
 
-HLAObjectClass*
-HLAFederate::getObjectClass(const std::string& name)
+const HLADataType*
+HLAFederate::getDataType(const std::string& name) const
 {
-    ObjectClassMap::const_iterator i = _objectClassMap.find(name);
-    if (i == _objectClassMap.end())
+    DataTypeMap::const_iterator i = _dataTypeMap.find(name);
+    if (i == _dataTypeMap.end())
         return 0;
     return i->second.get();
 }
 
-const HLAObjectClass*
-HLAFederate::getObjectClass(const std::string& name) const
+bool
+HLAFederate::insertDataType(const std::string& name, const SGSharedPtr<HLADataType>& dataType)
 {
-    ObjectClassMap::const_iterator i = _objectClassMap.find(name);
-    if (i == _objectClassMap.end())
-        return 0;
-    return i->second.get();
+    if (!dataType.valid())
+        return false;
+    if (_dataTypeMap.find(name) != _dataTypeMap.end()) {
+        SG_LOG(SG_IO, SG_ALERT, "HLAFederate::insertDataType: data type with name \""
+               << name << "\" already known to federate!");
+        return false;
+    }
+    _dataTypeMap.insert(DataTypeMap::value_type(name, dataType));
+    return true;
+}
+
+void
+HLAFederate::recomputeDataTypeAlignment()
+{
+    // Finish alignment computations
+    bool changed;
+    do {
+        changed = false;
+        for (DataTypeMap::iterator i = _dataTypeMap.begin(); i != _dataTypeMap.end(); ++i) {
+            if (i->second->recomputeAlignment())
+                changed = true;
+        }
+    } while (changed);
 }
 
 HLAInteractionClass*
@@ -867,6 +957,60 @@ HLAFederate::getInteractionClass(const std::string& name) const
     return i->second.get();
 }
 
+HLAInteractionClass*
+HLAFederate::createInteractionClass(const std::string& name)
+{
+    return new HLAInteractionClass(name, this);
+}
+
+HLAObjectClass*
+HLAFederate::getObjectClass(const std::string& name)
+{
+    ObjectClassMap::const_iterator i = _objectClassMap.find(name);
+    if (i == _objectClassMap.end())
+        return 0;
+    return i->second.get();
+}
+
+const HLAObjectClass*
+HLAFederate::getObjectClass(const std::string& name) const
+{
+    ObjectClassMap::const_iterator i = _objectClassMap.find(name);
+    if (i == _objectClassMap.end())
+        return 0;
+    return i->second.get();
+}
+
+HLAObjectClass*
+HLAFederate::createObjectClass(const std::string& name)
+{
+    return new HLAObjectClass(name, this);
+}
+
+HLAObjectInstance*
+HLAFederate::getObjectInstance(const std::string& name)
+{
+    ObjectInstanceMap::const_iterator i = _objectInstanceMap.find(name);
+    if (i == _objectInstanceMap.end())
+        return 0;
+    return i->second.get();
+}
+
+const HLAObjectInstance*
+HLAFederate::getObjectInstance(const std::string& name) const
+{
+    ObjectInstanceMap::const_iterator i = _objectInstanceMap.find(name);
+    if (i == _objectInstanceMap.end())
+        return 0;
+    return i->second.get();
+}
+
+HLAObjectInstance*
+HLAFederate::createObjectInstance(HLAObjectClass* objectClass, const std::string& name)
+{
+    return new HLAObjectInstance(objectClass);
+}
+
 void
 HLAFederate::setDone(bool done)
 {
@@ -882,22 +1026,62 @@ HLAFederate::getDone() const
 bool
 HLAFederate::readObjectModel()
 {
-    /// Currently empty, but is called at the right time so that
-    /// the object model is present when it is needed
-    return true;
+    // Depending on the actual version, try to find an apropriate
+    // file format for the given file. The first one is always the
+    // version native object model file format.
+    switch (getVersion()) {
+    case RTI13:
+        if (readRTI13ObjectModelTemplate(getFederationObjectModel()))
+            return true;
+        if (readRTI1516ObjectModelTemplate(getFederationObjectModel()))
+            return true;
+        return readRTI1516EObjectModelTemplate(getFederationObjectModel());
+    case RTI1516:
+        if (readRTI1516ObjectModelTemplate(getFederationObjectModel()))
+            return true;
+        if (readRTI1516EObjectModelTemplate(getFederationObjectModel()))
+            return true;
+        return readRTI13ObjectModelTemplate(getFederationObjectModel());
+    case RTI1516E:
+        if (readRTI1516EObjectModelTemplate(getFederationObjectModel()))
+            return true;
+        if (readRTI1516ObjectModelTemplate(getFederationObjectModel()))
+            return true;
+        return readRTI13ObjectModelTemplate(getFederationObjectModel());
+    default:
+        return false;
+    }
 }
 
 bool
 HLAFederate::subscribe()
 {
-    /// Currently empty, but is called at the right time
+    for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i) {
+        if (!i->second->subscribe())
+            return false;
+    }
+
+    for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i) {
+        if (!i->second->subscribe())
+            return false;
+    }
+
     return true;
 }
 
 bool
 HLAFederate::publish()
 {
-    /// Currently empty, but is called at the right time
+    for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i) {
+        if (!i->second->publish())
+            return false;
+    }
+
+    for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i) {
+        if (!i->second->publish())
+            return false;
+    }
+
     return true;
 }
 
@@ -1009,4 +1193,75 @@ HLAFederate::exec()
     return true;
 }
 
+void
+HLAFederate::_clearRTI()
+{
+    for (InteractionClassMap::iterator i = _interactionClassMap.begin(); i != _interactionClassMap.end(); ++i)
+        i->second->_clearRTIInteractionClass();
+    for (ObjectInstanceMap::iterator i = _objectInstanceMap.begin(); i != _objectInstanceMap.end(); ++i)
+        i->second->_clearRTIObjectInstance();
+    for (ObjectClassMap::iterator i = _objectClassMap.begin(); i != _objectClassMap.end(); ++i)
+        i->second->_clearRTIObjectClass();
+
+    _rtiFederate = 0;
+}
+
+bool
+HLAFederate::_insertInteractionClass(const SGSharedPtr<HLAInteractionClass>& interactionClass)
+{
+    if (!interactionClass.valid())
+        return false;
+    if (_interactionClassMap.find(interactionClass->getName()) != _interactionClassMap.end()) {
+        SG_LOG(SG_IO, SG_ALERT, "HLA: _insertInteractionClass: object instance with name \""
+               << interactionClass->getName() << "\" already known to federate!");
+        return false;
+    }
+    _interactionClassMap.insert(InteractionClassMap::value_type(interactionClass->getName(), interactionClass));
+    return true;
+}
+
+bool
+HLAFederate::_insertObjectClass(const SGSharedPtr<HLAObjectClass>& objectClass)
+{
+    if (!objectClass.valid())
+        return false;
+    if (_objectClassMap.find(objectClass->getName()) != _objectClassMap.end()) {
+        SG_LOG(SG_IO, SG_ALERT, "HLA: _insertObjectClass: object instance with name \""
+               << objectClass->getName() << "\" already known to federate!");
+        return false;
+    }
+    _objectClassMap.insert(ObjectClassMap::value_type(objectClass->getName(), objectClass));
+    return true;
+}
+
+bool
+HLAFederate::_insertObjectInstance(const SGSharedPtr<HLAObjectInstance>& objectInstance)
+{
+    if (!objectInstance.valid())
+        return false;
+    if (objectInstance->getName().empty()) {
+        SG_LOG(SG_IO, SG_ALERT, "HLA: _insertObjectInstance: trying to insert object instance with empty name!");
+        return false;
+    }
+    if (_objectInstanceMap.find(objectInstance->getName()) != _objectInstanceMap.end()) {
+        SG_LOG(SG_IO, SG_WARN, "HLA: _insertObjectInstance: object instance with name \""
+               << objectInstance->getName() << "\" already known to federate!");
+        return false;
+    }
+    _objectInstanceMap.insert(ObjectInstanceMap::value_type(objectInstance->getName(), objectInstance));
+    return true;
+}
+
+void
+HLAFederate::_eraseObjectInstance(const std::string& name)
+{
+    ObjectInstanceMap::iterator i = _objectInstanceMap.find(name);
+    if (i == _objectInstanceMap.end()) {
+        SG_LOG(SG_IO, SG_WARN, "HLA: _eraseObjectInstance: object instance with name \""
+               << name << "\" not known to federate!");
+        return;
+    }
+    _objectInstanceMap.erase(i);
+}
+
 } // namespace simgear

simgear/hla/HLAFederate.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -44,6 +44,7 @@ public:
     /// The rti version backend to connect
     Version getVersion() const;
     bool setVersion(HLAFederate::Version version);
+    bool setVersion(const std::string& version);
 
     /// The rti backends connect arguments, depends on the version
     const std::list<std::string>& getConnectArguments() const;
@@ -161,7 +162,7 @@ public:
     /// a pending time advance is granted.
     bool processMessages();
 
-    /// Legacy tick call
+    /// Legacy tick call - deprecated
     bool tick(const double& minimum, const double& maximum);
 
     class ObjectModelFactory {
@@ -170,7 +171,7 @@ public:
         { }
 
         virtual HLAObjectClass* createObjectClass(const std::string& name, HLAFederate& federate)
-        { return new HLAObjectClass(name, federate); }
+        { return federate.createObjectClass(name); }
         virtual bool subscribeObjectClass(const std::string& objectClassName, const std::string& sharing)
         { return sharing.find("Subscribe") != std::string::npos; }
         virtual bool publishObjectClass(const std::string& objectClassName, const std::string& sharing)
@@ -182,22 +183,56 @@ public:
 
     };
 
-    /// Read an omt xml file
+    /// Read an omt xml file - deprecated
     bool readObjectModelTemplate(const std::string& objectModel,
                                  ObjectModelFactory& objectModelFactory);
 
-    /// Get the object class of a given name
-    HLAObjectClass* getObjectClass(const std::string& name);
-    const HLAObjectClass* getObjectClass(const std::string& name) const;
+    /// Read an rti1.3 omt xml file
+    bool readRTI13ObjectModelTemplate(const std::string& objectModel);
+    /// Read an rti1516 omt xml file
+    bool readRTI1516ObjectModelTemplate(const std::string& objectModel);
+    /// Read an rti1516e omt xml file
+    bool readRTI1516EObjectModelTemplate(const std::string& objectModel);
+
+    /// Is called past a successful join to populate the rti classes
+    bool resolveObjectModel();
+
+    /// Access data types
+    const HLADataType* getDataType(const std::string& name) const;
+    // virtual const HLADataType* createDataType(const std::string& name);
+    bool insertDataType(const std::string& name, const SGSharedPtr<HLADataType>& dataType);
+    void recomputeDataTypeAlignment();
 
     /// Get the interaction class of a given name
     HLAInteractionClass* getInteractionClass(const std::string& name);
     const HLAInteractionClass* getInteractionClass(const std::string& name) const;
+    /// Default create function. Creates a default interaction class
+    virtual HLAInteractionClass* createInteractionClass(const std::string& name);
+
+    /// Get the object class of a given name
+    HLAObjectClass* getObjectClass(const std::string& name);
+    const HLAObjectClass* getObjectClass(const std::string& name) const;
+    /// Default create function. Creates a default object class
+    virtual HLAObjectClass* createObjectClass(const std::string& name);
+
+    /// Get the object instance of a given name
+    HLAObjectInstance* getObjectInstance(const std::string& name);
+    const HLAObjectInstance* getObjectInstance(const std::string& name) const;
+    virtual HLAObjectInstance* createObjectInstance(HLAObjectClass* objectClass, const std::string& name);
 
     /// Tells the main exec loop to continue or not.
     void setDone(bool done);
     bool getDone() const;
 
+    /// The user overridable slot that is called to set up an object model
+    /// By default, depending on the set up rti version, the apropriate
+    ///  bool read{RTI13,RTI1516,RTI1516E}ObjectModelTemplate(const std::string& objectModel);
+    /// method is called.
+    /// Note that the RTI13 files do not contain any information about the data types.
+    /// A user needs to set up the data types and assign them to the object classes/
+    /// interaction classes theirselves.
+    /// Past reading the object model, it is still possible to change the subscription/publication
+    /// types without introducing traffic on the backend rti.
     virtual bool readObjectModel();
 
     virtual bool subscribe();
@@ -213,6 +248,16 @@ private:
     HLAFederate(const HLAFederate&);
     HLAFederate& operator=(const HLAFederate&);
 
+    void _clearRTI();
+
+    /// Internal helpers for interaction classes
+    bool _insertInteractionClass(const SGSharedPtr<HLAInteractionClass>& interactionClass);
+    /// Internal helpers for object classes
+    bool _insertObjectClass(const SGSharedPtr<HLAObjectClass>& objectClass);
+    /// Internal helpers for object instances
+    bool _insertObjectInstance(const SGSharedPtr<HLAObjectInstance>& objectInstance);
+    void _eraseObjectInstance(const std::string& name);
+
     /// The underlying interface to the rti implementation
     SGSharedPtr<RTIFederate> _rtiFederate;
 
@@ -247,14 +292,27 @@ private:
     /// If true the exec method returns.
     bool _done;
 
-    typedef std::map<std::string, SGSharedPtr<HLAObjectClass> > ObjectClassMap;
-    ObjectClassMap _objectClassMap;
+    /// The Data Types by name
+    typedef std::map<std::string, SGSharedPtr<HLADataType> > DataTypeMap;
+    DataTypeMap _dataTypeMap;
 
+    /// The Interaction Classes by name
     typedef std::map<std::string, SGSharedPtr<HLAInteractionClass> > InteractionClassMap;
     InteractionClassMap _interactionClassMap;
 
+    /// The Object Classes by name
+    typedef std::map<std::string, SGSharedPtr<HLAObjectClass> > ObjectClassMap;
+    ObjectClassMap _objectClassMap;
+
+    /// The Object Instances by name
+    typedef std::map<std::string, SGSharedPtr<HLAObjectInstance> > ObjectInstanceMap;
+    ObjectInstanceMap _objectInstanceMap;
+    /// The Object Instances by name, the ones that have an explicit given name, may be not yet registered
+    // ObjectInstanceMap _explicitNamedObjectInstanceMap;
+
     friend class HLAInteractionClass;
     friend class HLAObjectClass;
+    friend class HLAObjectInstance;
 };
 
 } // namespace simgear

simgear/hla/HLAFixedRecordDataElement.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAFixedRecordDataElement.hxx"
 
 #include <string>
@@ -120,6 +126,7 @@ HLAFixedRecordDataElement::HLAFixedRecordDataElement(const HLAFixedRecordDataTyp
 
 HLAFixedRecordDataElement::~HLAFixedRecordDataElement()
 {
+    clearStamp();
 }
 
 bool
@@ -181,7 +188,12 @@ HLAFixedRecordDataElement::setField(unsigned index, HLADataElement* value)
 {
     if (getNumFields() <= index)
         return;
+    if (_fieldVector[index].valid())
+        _fieldVector[index]->clearStamp();
     _fieldVector[index] = value;
+    if (value)
+        value->attachStamp(*this);
+    setDirty(true);
 }
 
 void
@@ -190,4 +202,15 @@ HLAFixedRecordDataElement::setField(const std::string& name, HLADataElement* val
     setField(getFieldNumber(name), value);
 }
 
+void
+HLAFixedRecordDataElement::_setStamp(Stamp* stamp)
+{
+    HLAAbstractFixedRecordDataElement::_setStamp(stamp);
+    for (FieldVector::iterator i = _fieldVector.begin(); i != _fieldVector.end(); ++i) {
+        if (!i->valid())
+            continue;
+        (*i)->attachStamp(*this);
+    }
+}
+
 }

simgear/hla/HLAFixedRecordDataElement.hxx

@@ -70,6 +70,9 @@ public:
     void setField(unsigned index, HLADataElement* value);
     void setField(const std::string& name, HLADataElement* value);
 
+protected:
+    virtual void _setStamp(Stamp* stamp);
+
 private:
     typedef std::vector<SGSharedPtr<HLADataElement> > FieldVector;
     FieldVector _fieldVector;

simgear/hla/HLAFixedRecordDataType.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAFixedRecordDataType.hxx"
 
 #include "HLADataTypeVisitor.hxx"
@@ -43,6 +49,14 @@ HLAFixedRecordDataType::toFixedRecordDataType() const
     return this;
 }
 
+void
+HLAFixedRecordDataType::releaseDataTypeReferences()
+{
+    unsigned numFields = getNumFields();
+    for (unsigned i = 0; i < numFields; ++i)
+        _fieldList[i].releaseDataTypeReferences();
+}
+
 bool
 HLAFixedRecordDataType::decode(HLADecodeStream& stream, HLAAbstractFixedRecordDataElement& value) const
 {
@@ -68,10 +82,18 @@ HLAFixedRecordDataType::encode(HLAEncodeStream& stream, const HLAAbstractFixedRe
 void
 HLAFixedRecordDataType::addField(const std::string& name, const HLADataType* dataType)
 {
-    // FIXME this only works if we do not reset the alignment to something smaller
-    if (getAlignment() < dataType->getAlignment())
-        setAlignment(dataType->getAlignment());
     _fieldList.push_back(Field(name, dataType));
 }
 
+void
+HLAFixedRecordDataType::_recomputeAlignmentImplementation()
+{
+    unsigned alignment = 1;
+    for (unsigned i = 0; i < getNumFields(); ++i) {
+        if (const HLADataType* dataType = getFieldDataType(i))
+            alignment = std::max(alignment, dataType->getAlignment());
+    }
+    setAlignment(alignment);
+}
+
 } // namespace simgear

simgear/hla/HLAFixedRecordDataType.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -36,6 +36,8 @@ public:
 
     virtual const HLAFixedRecordDataType* toFixedRecordDataType() const;
 
+    virtual void releaseDataTypeReferences();
+
     virtual bool decode(HLADecodeStream& stream, HLAAbstractFixedRecordDataElement& value) const;
     virtual bool encode(HLAEncodeStream& stream, const HLAAbstractFixedRecordDataElement& value) const;
 
@@ -67,6 +69,9 @@ public:
 
     void addField(const std::string& name, const HLADataType* dataType);
 
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
 private:
     struct Field {
         Field(const std::string& name, const HLADataType* dataType) :
@@ -76,6 +81,8 @@ private:
 
         const HLADataType* getDataType() const
         { return _dataType.get(); }
+        void releaseDataTypeReferences()
+        { _dataType = 0; }
 
     private:
         std::string _name;

simgear/hla/HLAInteractionClass.cxx

@@ -0,0 +1,251 @@
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "HLAInteractionClass.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElement.hxx"
+#include "HLAFederate.hxx"
+
+#include "RTIInteractionClass.hxx"
+
+namespace simgear {
+
+HLAInteractionClass::HLAInteractionClass(const std::string& name, HLAFederate* federate) :
+    _federate(federate),
+    _rtiInteractionClass(0),
+    _name(name),
+    _subscriptionType(HLAUnsubscribed),
+    _publicationType(HLAUnpublished)
+{
+    if (!federate) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAInteractionClass::HLAInteractionClass(): "
+               "No parent federate given for interaction class \"" << getName() << "\"!");
+        return;
+    }
+    federate->_insertInteractionClass(this);
+}
+
+HLAInteractionClass::~HLAInteractionClass()
+{
+    // HLAInteractionClass objects only get deleted when the parent federate
+    // dies. So we do not need to deregister there.
+
+    _clearRTIInteractionClass();
+}
+
+const std::string&
+HLAInteractionClass::getName() const
+{
+    return _name;
+}
+
+const SGWeakPtr<HLAFederate>&
+HLAInteractionClass::getFederate() const
+{
+    return _federate;
+}
+
+HLASubscriptionType
+HLAInteractionClass::getSubscriptionType() const
+{
+    return _subscriptionType;
+}
+
+void
+HLAInteractionClass::setSubscriptionType(HLASubscriptionType subscriptionType)
+{
+    _subscriptionType = subscriptionType;
+}
+
+HLAPublicationType
+HLAInteractionClass::getPublicationType() const
+{
+    return _publicationType;
+}
+
+void
+HLAInteractionClass::setPublicationType(HLAPublicationType publicationType)
+{
+    _publicationType = publicationType;
+}
+
+unsigned
+HLAInteractionClass::getNumParameters() const
+{
+    return _parameterVector.size();
+}
+
+unsigned
+HLAInteractionClass::addParameter(const std::string& name)
+{
+    unsigned index = _parameterVector.size();
+    _nameIndexMap[name] = index;
+    _parameterVector.push_back(Parameter(name));
+    _resolveParameterIndex(name, index);
+    return index;
+}
+
+unsigned
+HLAInteractionClass::getParameterIndex(const std::string& name) const
+{
+    NameIndexMap::const_iterator i = _nameIndexMap.find(name);
+    if (i == _nameIndexMap.end())
+        return ~0u;
+    return i->second;
+}
+
+std::string
+HLAInteractionClass::getParameterName(unsigned index) const
+{
+    if (_parameterVector.size() <= index)
+        return std::string();
+    return _parameterVector[index]._name;
+}
+
+const HLADataType*
+HLAInteractionClass::getParameterDataType(unsigned index) const
+{
+    if (_parameterVector.size() <= index)
+        return 0;
+    return _parameterVector[index]._dataType.get();
+}
+
+void
+HLAInteractionClass::setParameterDataType(unsigned index, const SGSharedPtr<const HLADataType>& dataType)
+{
+    if (_parameterVector.size() <= index)
+        return;
+    _parameterVector[index]._dataType = dataType;
+}
+
+HLADataElement::IndexPathPair
+HLAInteractionClass::getIndexPathPair(const HLADataElement::StringPathPair& stringPathPair) const
+{
+    unsigned index = getParameterIndex(stringPathPair.first);
+    if (getNumParameters() <= index) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAInteractionClass::getIndexPathPair(\""
+               << HLADataElement::toString(stringPathPair)
+               << "\"): Could not resolve attribute \"" << stringPathPair.first
+               << "\" for interaction class \"" << getName() << "\"!");
+    }
+    return HLADataElement::IndexPathPair(index, stringPathPair.second);
+}
+
+HLADataElement::IndexPathPair
+HLAInteractionClass::getIndexPathPair(const std::string& path) const
+{
+    return getIndexPathPair(HLADataElement::toStringPathPair(path));
+}
+
+bool
+HLAInteractionClass::subscribe()
+{
+    if (!_rtiInteractionClass) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAInteractionClass::subscribe(): No RTIInteractionClass!");
+        return false;
+    }
+    switch (_subscriptionType) {
+    case HLAUnsubscribed:
+        return _rtiInteractionClass->unsubscribe();
+    case HLASubscribedActive:
+        return _rtiInteractionClass->subscribe(true);
+    case HLASubscribedPassive:
+        return _rtiInteractionClass->subscribe(false);
+    }
+    return false;
+}
+
+bool
+HLAInteractionClass::unsubscribe()
+{
+    if (!_rtiInteractionClass) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAInteractionClass::unsubscribe(): No RTIInteractionClass!");
+        return false;
+    }
+    return _rtiInteractionClass->unsubscribe();
+}
+
+bool
+HLAInteractionClass::publish()
+{
+    if (!_rtiInteractionClass) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAInteractionClass::publish(): No RTIInteractionClass\"!");
+        return false;
+    }
+    switch (_publicationType) {
+    case HLAUnpublished:
+        return _rtiInteractionClass->unpublish();
+    case HLAPublished:
+        return _rtiInteractionClass->publish();
+    }
+    return false;
+}
+
+bool
+HLAInteractionClass::unpublish()
+{
+    if (!_rtiInteractionClass) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAInteractionClass::unpublish(): No RTIInteractionClass\"!");
+        return false;
+    }
+    return _rtiInteractionClass->unpublish();
+}
+
+void
+HLAInteractionClass::_setRTIInteractionClass(RTIInteractionClass* interactionClass)
+{
+    if (_rtiInteractionClass) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAInteractionClass: Setting RTIInteractionClass twice for interaction class \"" << getName() << "\"!");
+        return;
+    }
+    _rtiInteractionClass = interactionClass;
+    if (_rtiInteractionClass->_interactionClass != this) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAInteractionClass: backward reference does not match!");
+        return;
+    }
+    for (unsigned i = 0; i < _parameterVector.size(); ++i)
+        _resolveParameterIndex(_parameterVector[i]._name, i);
+}
+
+void
+HLAInteractionClass::_resolveParameterIndex(const std::string& name, unsigned index)
+{
+    if (!_rtiInteractionClass)
+        return;
+    if (!_rtiInteractionClass->resolveParameterIndex(name, index))
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAInteractionClass: Could not resolve parameter \""
+               << name << "\" for interaction class \"" << getName() << "\"!");
+}
+
+void
+HLAInteractionClass::_clearRTIInteractionClass()
+{
+    if (!_rtiInteractionClass)
+        return;
+    _rtiInteractionClass->_interactionClass = 0;
+    _rtiInteractionClass = 0;
+}
+
+} // namespace simgear

simgear/hla/HLAInteractionClass.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,17 +18,92 @@
 #ifndef HLAInteractionClass_hxx
 #define HLAInteractionClass_hxx
 
+#include <map>
+#include <string>
+#include <vector>
+
+#include <simgear/structure/SGWeakReferenced.hxx>
+
+#include "HLADataElement.hxx"
+#include "HLADataType.hxx"
+#include "HLATypes.hxx"
+
 namespace simgear {
 
 class RTIInteractionClass;
+class HLADataType;
+class HLAFederate;
 
 class HLAInteractionClass : public SGWeakReferenced {
 public:
-    virtual ~HLAInteractionClass() {}
+    HLAInteractionClass(const std::string& name, HLAFederate* federate);
+    virtual ~HLAInteractionClass();
+
+    const std::string& getName() const;
+
+    /// return the federate this interaction class belongs to
+    const SGWeakPtr<HLAFederate>& getFederate() const;
+
+    HLASubscriptionType getSubscriptionType() const;
+    void setSubscriptionType(HLASubscriptionType subscriptionType);
+
+    HLAPublicationType getPublicationType() const;
+    void setPublicationType(HLAPublicationType publicationType);
+
+    unsigned getNumParameters() const;
+    unsigned addParameter(const std::string& name);
+
+    unsigned getParameterIndex(const std::string& name) const;
+    std::string getParameterName(unsigned index) const;
+
+    const HLADataType* getParameterDataType(unsigned index) const;
+    void setParameterDataType(unsigned index, const SGSharedPtr<const HLADataType>& dataType);
+
+    HLADataElement::IndexPathPair getIndexPathPair(const HLADataElement::StringPathPair& stringPathPair) const;
+    HLADataElement::IndexPathPair getIndexPathPair(const std::string& path) const;
+
+    virtual bool subscribe();
+    virtual bool unsubscribe();
+
+    virtual bool publish();
+    virtual bool unpublish();
 
 private:
     HLAInteractionClass(const HLAInteractionClass&);
     HLAInteractionClass& operator=(const HLAInteractionClass&);
+
+    void _setRTIInteractionClass(RTIInteractionClass* interactionClass);
+    void _resolveParameterIndex(const std::string& name, unsigned index);
+    void _clearRTIInteractionClass();
+
+    struct Parameter {
+        Parameter() {}
+        Parameter(const std::string& name) : _name(name) {}
+        std::string _name;
+        SGSharedPtr<const HLADataType> _dataType;
+    };
+    typedef std::vector<Parameter> ParameterVector;
+    typedef std::map<std::string,unsigned> NameIndexMap;
+
+    /// The parent federate.
+    SGWeakPtr<HLAFederate> _federate;
+
+    /// The rti class if already instantiated.
+    RTIInteractionClass* _rtiInteractionClass;
+
+    /// The interaction class name
+    std::string _name;
+
+    /// The configured subscription and publication type
+    HLASubscriptionType _subscriptionType;
+    HLAPublicationType _publicationType;
+
+    /// The parameter data
+    ParameterVector _parameterVector;
+    /// The mapping from parameter names to parameter indices
+    NameIndexMap _nameIndexMap;
+
+    friend class HLAFederate;
 };
 
 } // namespace simgear

simgear/hla/HLAOMTXmlVisitor.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAOMTXmlVisitor.hxx"
 
 #include <map>
@@ -27,8 +33,9 @@
 #include "HLABasicDataType.hxx"
 #include "HLADataTypeVisitor.hxx"
 #include "HLAEnumeratedDataType.hxx"
+#include "HLAFederate.hxx"
 #include "HLAFixedRecordDataType.hxx"
-#include "HLAVariantDataType.hxx"
+#include "HLAVariantRecordDataType.hxx"
 
 namespace simgear {
 
@@ -68,18 +75,6 @@ HLAOMTXmlVisitor::ObjectClass::getAttribute(unsigned index) const
     return _attributes[index];
 }
 
-const HLAOMTXmlVisitor::Attribute*
-HLAOMTXmlVisitor::ObjectClass::getAttribute(const std::string& name) const
-{
-    for (AttributeList::const_iterator i = _attributes.begin(); i != _attributes.end(); ++i) {
-        if ((*i)->_name != name)
-            continue;
-        return i->get();
-    }
-    SG_LOG(SG_IO, SG_ALERT, "Could not find class attribute \"" << name << "\".");
-    return 0;
-}
-
 const HLAOMTXmlVisitor::ObjectClass*
 HLAOMTXmlVisitor::ObjectClass::getParentObjectClass() const
 {
@@ -107,6 +102,12 @@ HLAOMTXmlVisitor::InteractionClass::getDimensions() const
     return _dimensions;
 }
 
+const std::string&
+HLAOMTXmlVisitor::InteractionClass::getSharing() const
+{
+    return _sharing;
+}
+
 const std::string&
 HLAOMTXmlVisitor::InteractionClass::getTransportation() const
 {
@@ -133,18 +134,6 @@ HLAOMTXmlVisitor::InteractionClass::getParameter(unsigned index) const
     return _parameters[index];
 }
 
-const HLAOMTXmlVisitor::Parameter*
-HLAOMTXmlVisitor::InteractionClass::getParameter(const std::string& name) const
-{
-    for (ParameterList::const_iterator i = _parameters.begin(); i != _parameters.end(); ++i) {
-        if ((*i)->_name != name)
-            continue;
-        return i->get();
-    }
-    SG_LOG(SG_IO, SG_ALERT, "Could not find parameter \"" << name << "\".");
-    return 0;
-}
-
 const HLAOMTXmlVisitor::InteractionClass*
 HLAOMTXmlVisitor::InteractionClass::getParentInteractionClass() const
 {
@@ -159,6 +148,81 @@ HLAOMTXmlVisitor::~HLAOMTXmlVisitor()
 {
 }
 
+void
+HLAOMTXmlVisitor::setDataTypesToFederate(HLAFederate& federate)
+{
+    // Provide all the data types
+    for (BasicDataMap::iterator i = _basicDataMap.begin(); i != _basicDataMap.end(); ++i)
+        federate.insertDataType(i->first, getDataType(i->first));
+    for (SimpleDataMap::iterator i = _simpleDataMap.begin(); i != _simpleDataMap.end(); ++i)
+        federate.insertDataType(i->first, getDataType(i->first));
+    for (EnumeratedDataMap::iterator i = _enumeratedDataMap.begin(); i != _enumeratedDataMap.end(); ++i)
+        federate.insertDataType(i->first, getDataType(i->first));
+    for (ArrayDataMap::iterator i = _arrayDataMap.begin(); i != _arrayDataMap.end(); ++i)
+        federate.insertDataType(i->first, getDataType(i->first));
+    for (FixedRecordDataMap::iterator i = _fixedRecordDataMap.begin(); i != _fixedRecordDataMap.end(); ++i)
+        federate.insertDataType(i->first, getDataType(i->first));
+    for (VariantRecordDataMap::iterator i = _variantRecordDataMap.begin(); i != _variantRecordDataMap.end(); ++i)
+        federate.insertDataType(i->first, getDataType(i->first));
+
+    // Finish alignment computations
+    federate.recomputeDataTypeAlignment();
+}
+
+void
+HLAOMTXmlVisitor::setToFederate(HLAFederate& federate)
+{
+    setDataTypesToFederate(federate);
+
+    // Provide all interaction classes
+    unsigned numInteractionClasses = getNumInteractionClasses();
+    for (unsigned i = 0; i < numInteractionClasses; ++i) {
+        const InteractionClass* interactionClass = getInteractionClass(i);
+
+        SGSharedPtr<HLAInteractionClass> hlaInteractionClass;
+        hlaInteractionClass = federate.createInteractionClass(interactionClass->getName());
+        if (!hlaInteractionClass.valid()) {
+            SG_LOG(SG_IO, SG_INFO, "Ignoring Interaction class \"" << interactionClass->getName() << "\".");
+            continue;
+        }
+
+        hlaInteractionClass->setSubscriptionType(interactionClass->getSubscriptionType());
+        hlaInteractionClass->setPublicationType(interactionClass->getPublicationType());
+
+        // process the parameters
+        for (unsigned j = 0; j < interactionClass->getNumParameters(); ++j) {
+            const Parameter* parameter = interactionClass->getParameter(j);
+            unsigned index = hlaInteractionClass->addParameter(parameter->getName());
+            hlaInteractionClass->setParameterDataType(index, federate.getDataType(parameter->getDataType()));
+        }
+    }
+
+    // Provide all object classes
+    unsigned numObjectClasses = getNumObjectClasses();
+    for (unsigned i = 0; i < numObjectClasses; ++i) {
+        const ObjectClass* objectClass = getObjectClass(i);
+
+        SGSharedPtr<HLAObjectClass> hlaObjectClass;
+        hlaObjectClass = federate.createObjectClass(objectClass->getName());
+        if (!hlaObjectClass.valid()) {
+            SG_LOG(SG_IO, SG_INFO, "Ignoring Object class \"" << objectClass->getName() << "\".");
+            continue;
+        }
+
+        // process the attributes
+        for (unsigned j = 0; j < objectClass->getNumAttributes(); ++j) {
+            const Attribute* attribute = objectClass->getAttribute(j);
+
+            unsigned index = hlaObjectClass->addAttribute(attribute->getName());
+            hlaObjectClass->setAttributeDataType(index, federate.getDataType(attribute->getDataType()));
+
+            hlaObjectClass->setAttributeSubscriptionType(index, attribute->getSubscriptionType());
+            hlaObjectClass->setAttributePublicationType(index, attribute->getPublicationType());
+            hlaObjectClass->setAttributeUpdateType(index, attribute->getUpdateType());
+        }
+    }
+}
+
 unsigned
 HLAOMTXmlVisitor::getNumObjectClasses() const
 {
@@ -173,36 +237,6 @@ HLAOMTXmlVisitor::getObjectClass(unsigned i) const
     return _objectClassList[i];
 }
 
-const HLAOMTXmlVisitor::ObjectClass*
-HLAOMTXmlVisitor::getObjectClass(const std::string& name) const
-{
-    for (ObjectClassList::const_iterator i = _objectClassList.begin(); i != _objectClassList.end(); ++i) {
-        if ((*i)->_name != name)
-            continue;
-        return i->get();
-    }
-    SG_LOG(SG_IO, SG_ALERT, "Could not resolve ObjectClass \"" << name << "\".");
-    return 0;
-}
-
-const HLAOMTXmlVisitor::Attribute*
-HLAOMTXmlVisitor::getAttribute(const std::string& objectClassName, const std::string& attributeName) const
-{
-    const ObjectClass* objectClass = getObjectClass(objectClassName);
-    if (!objectClass)
-        return 0;
-    return objectClass->getAttribute(attributeName);
-}
-
-HLADataType*
-HLAOMTXmlVisitor::getAttributeDataType(const std::string& objectClassName, const std::string& attributeName) const
-{
-    const Attribute* attribute = getAttribute(objectClassName, attributeName);
-    if (!attribute)
-        return 0;
-    return getDataType(attribute->_dataType);
-}
-
 unsigned
 HLAOMTXmlVisitor::getNumInteractionClasses() const
 {
@@ -217,59 +251,19 @@ HLAOMTXmlVisitor::getInteractionClass(unsigned i) const
     return _interactionClassList[i];
 }
 
-const HLAOMTXmlVisitor::InteractionClass*
-HLAOMTXmlVisitor::getInteractionClass(const std::string& name) const
-{
-    for (InteractionClassList::const_iterator i = _interactionClassList.begin(); i != _interactionClassList.end(); ++i) {
-        if ((*i)->_name != name)
-            continue;
-        return i->get();
-    }
-    SG_LOG(SG_IO, SG_ALERT, "Could not resolve InteractionClass \"" << name << "\".");
-    return 0;
-}
-
-const HLAOMTXmlVisitor::Parameter*
-HLAOMTXmlVisitor::getParameter(const std::string& interactionClassName, const std::string& parameterName) const
-{
-    const InteractionClass* interactionClass = getInteractionClass(interactionClassName);
-    if (!interactionClass)
-        return 0;
-    return interactionClass->getParameter(parameterName);
-}
-
-HLADataType*
-HLAOMTXmlVisitor::getParameterDataType(const std::string& interactionClassName, const std::string& parameterName) const
-{
-    const Parameter* parameter = getParameter(interactionClassName, parameterName);
-    if (!parameter)
-        return 0;
-    return getDataType(parameter->_dataType);
-}
-
-HLADataType*
-HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName) const
-{
-    SGSharedPtr<HLADataType> dataType;
-    {
-        // Playing dirty things with reference counts
-        StringDataTypeMap dataTypeMap;
-        dataType = getDataType(dataTypeName, dataTypeMap);
-    }
-    return dataType.release();
-}
-
 SGSharedPtr<HLADataType>
-HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName)
 {
-    StringDataTypeMap::const_iterator i = dataTypeMap.find(dataTypeName);
-    if (i != dataTypeMap.end())
-        return new HLADataTypeReference(i->second);
+    StringDataTypeMap::const_iterator i = _dataTypeMap.find(dataTypeName);
+    if (i != _dataTypeMap.end())
+        return i->second;
 
     SGSharedPtr<HLADataType> dataType;
     dataType = getBasicDataType(dataTypeName);
-    if (dataType.valid())
+    if (dataType.valid()) {
+        _dataTypeMap[dataTypeName] = dataType;
         return dataType;
+    }
 
     dataType = getSimpleDataType(dataTypeName);
     if (dataType.valid())
@@ -279,15 +273,15 @@ HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName, HLAOMTXmlVisitor:
     if (dataType.valid())
         return dataType;
 
-    dataType = getArrayDataType(dataTypeName, dataTypeMap);
+    dataType = getArrayDataType(dataTypeName);
     if (dataType.valid())
         return dataType;
 
-    dataType = getFixedRecordDataType(dataTypeName, dataTypeMap);
+    dataType = getFixedRecordDataType(dataTypeName);
     if (dataType.valid())
         return dataType;
 
-    dataType = getVariantDataType(dataTypeName, dataTypeMap);
+    dataType = getVariantRecordDataType(dataTypeName);
     if (dataType.valid())
         return dataType;
 
@@ -296,7 +290,7 @@ HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName, HLAOMTXmlVisitor:
 }
 
 SGSharedPtr<HLABasicDataType>
-HLAOMTXmlVisitor::getBasicDataType(const std::string& dataTypeName) const
+HLAOMTXmlVisitor::getBasicDataType(const std::string& dataTypeName)
 {
     BasicDataMap::const_iterator i = _basicDataMap.find(dataTypeName);
     if (i == _basicDataMap.end())
@@ -369,7 +363,7 @@ HLAOMTXmlVisitor::getBasicDataType(const std::string& dataTypeName) const
 }
 
 SGSharedPtr<HLADataType>
-HLAOMTXmlVisitor::getSimpleDataType(const std::string& dataTypeName) const
+HLAOMTXmlVisitor::getSimpleDataType(const std::string& dataTypeName)
 {
     SimpleDataMap::const_iterator i = _simpleDataMap.find(dataTypeName);
     if (i == _simpleDataMap.end())
@@ -378,13 +372,14 @@ HLAOMTXmlVisitor::getSimpleDataType(const std::string& dataTypeName) const
 }
 
 SGSharedPtr<HLAEnumeratedDataType>
-HLAOMTXmlVisitor::getEnumeratedDataType(const std::string& dataTypeName) const
+HLAOMTXmlVisitor::getEnumeratedDataType(const std::string& dataTypeName)
 {
     EnumeratedDataMap::const_iterator i = _enumeratedDataMap.find(dataTypeName);
     if (i == _enumeratedDataMap.end())
         return 0;
 
     SGSharedPtr<HLAEnumeratedDataType> enumeratedDataType = new HLAEnumeratedDataType(dataTypeName);
+    _dataTypeMap[dataTypeName] = enumeratedDataType;
     enumeratedDataType->setRepresentation(getBasicDataType(i->second._representation));
 
     for (EnumeratorList::const_iterator j = i->second._enumeratorList.begin();
@@ -400,7 +395,7 @@ HLAOMTXmlVisitor::getEnumeratedDataType(const std::string& dataTypeName) const
 }
 
 SGSharedPtr<HLADataType>
-HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName)
 {
     ArrayDataMap::const_iterator i = _arrayDataMap.find(dataTypeName);
     if (i == _arrayDataMap.end())
@@ -428,13 +423,13 @@ HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName, HLAOMTXmlVis
         return 0;
     }
 
-    dataTypeMap[dataTypeName] = arrayDataType;
-    SGSharedPtr<HLADataType> elementDataType = getDataType(i->second._dataType, dataTypeMap);
+    _dataTypeMap[dataTypeName] = arrayDataType;
+    SGSharedPtr<HLADataType> elementDataType = getDataType(i->second._dataType);
     if (!elementDataType.valid()) {
         SG_LOG(SG_IO, SG_ALERT, "Could not interpret dataType \""
                << i->second._dataType << "\" for array data type \""
                << dataTypeName << "\".");
-        dataTypeMap.erase(dataTypeName);
+        _dataTypeMap.erase(dataTypeName);
         return 0;
     }
     arrayDataType->setElementDataType(elementDataType.get());
@@ -452,20 +447,20 @@ HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName, HLAOMTXmlVis
 }
 
 SGSharedPtr<HLAFixedRecordDataType>
-HLAOMTXmlVisitor::getFixedRecordDataType(const std::string& dataTypeName, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+HLAOMTXmlVisitor::getFixedRecordDataType(const std::string& dataTypeName)
 {
     FixedRecordDataMap::const_iterator i = _fixedRecordDataMap.find(dataTypeName);
     if (i == _fixedRecordDataMap.end())
         return 0;
 
     SGSharedPtr<HLAFixedRecordDataType> dataType = new HLAFixedRecordDataType(dataTypeName);
-    dataTypeMap[dataTypeName] = dataType;
+    _dataTypeMap[dataTypeName] = dataType;
     for (FieldList::size_type j = 0; j < i->second._fieldList.size(); ++j) {
-        SGSharedPtr<HLADataType> fieldDataType = getDataType(i->second._fieldList[j]._dataType, dataTypeMap);
+        SGSharedPtr<HLADataType> fieldDataType = getDataType(i->second._fieldList[j]._dataType);
         if (!fieldDataType.valid()) {
             SG_LOG(SG_IO, SG_ALERT, "Could not get data type \"" << i->second._fieldList[j]._dataType
                    << "\" for field " << j << "of fixed record data type \"" << dataTypeName << "\".");
-            dataTypeMap.erase(dataTypeName);
+            _dataTypeMap.erase(dataTypeName);
             return 0;
         }
         dataType->addField(i->second._fieldList[j]._name, fieldDataType.get());
@@ -473,14 +468,14 @@ HLAOMTXmlVisitor::getFixedRecordDataType(const std::string& dataTypeName, HLAOMT
     return dataType;
 }
 
-SGSharedPtr<HLAVariantDataType>
-HLAOMTXmlVisitor::getVariantDataType(const std::string& dataTypeName, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+SGSharedPtr<HLAVariantRecordDataType>
+HLAOMTXmlVisitor::getVariantRecordDataType(const std::string& dataTypeName)
 {
     VariantRecordDataMap::const_iterator i = _variantRecordDataMap.find(dataTypeName);
     if (i == _variantRecordDataMap.end())
         return 0;
-    SGSharedPtr<HLAVariantDataType> dataType = new HLAVariantDataType(dataTypeName);
-    dataTypeMap[dataTypeName] = dataType;
+    SGSharedPtr<HLAVariantRecordDataType> dataType = new HLAVariantRecordDataType(dataTypeName);
+    _dataTypeMap[dataTypeName] = dataType;
 
     SGSharedPtr<HLAEnumeratedDataType> enumeratedDataType = getEnumeratedDataType(i->second._dataType);
     if (!enumeratedDataType.valid()) {
@@ -492,11 +487,11 @@ HLAOMTXmlVisitor::getVariantDataType(const std::string& dataTypeName, HLAOMTXmlV
 
     for (AlternativeList::const_iterator j = i->second._alternativeList.begin();
          j != i->second._alternativeList.end(); ++j) {
-        SGSharedPtr<HLADataType> alternativeDataType = getDataType(j->_dataType, dataTypeMap);
+        SGSharedPtr<HLADataType> alternativeDataType = getDataType(j->_dataType);
         if (!alternativeDataType.valid()) {
             SG_LOG(SG_IO, SG_ALERT, "Could not resolve alternative dataType \"" << j->_dataType
                    << "\" for alternative \"" << j->_name << "\".");
-            dataTypeMap.erase(dataTypeName);
+            _dataTypeMap.erase(dataTypeName);
             return 0;
         }
         if (!dataType->addAlternative(j->_name, j->_enumerator, alternativeDataType.get(), j->_semantics)) {
@@ -540,26 +535,26 @@ HLAOMTXmlVisitor::endXML()
         throw sg_exception("Internal parse error!");
 
     // propagate parent attributes to the derived classes
+    // Note that this preserves the order of the attributes starting from the root object
     for (ObjectClassList::const_iterator i = _objectClassList.begin(); i != _objectClassList.end(); ++i) {
         SGSharedPtr<const ObjectClass> objectClass = (*i)->_parentObjectClass;
-        while (objectClass) {
-            for (AttributeList::const_reverse_iterator j = objectClass->_attributes.rbegin();
-                 j != objectClass->_attributes.rend(); ++j) {
-                (*i)->_attributes.insert((*i)->_attributes.begin(), *j);
-            }
-            objectClass = objectClass->_parentObjectClass;
+        if (!objectClass.valid())
+            continue;
+        for (AttributeList::const_reverse_iterator j = objectClass->_attributes.rbegin();
+             j != objectClass->_attributes.rend(); ++j) {
+            (*i)->_attributes.insert((*i)->_attributes.begin(), *j);
         }
     }
 
     // propagate parent parameter to the derived interactions
+    // Note that this preserves the order of the parameters starting from the root object
     for (InteractionClassList::const_iterator i = _interactionClassList.begin(); i != _interactionClassList.end(); ++i) {
         SGSharedPtr<const InteractionClass> interactionClass = (*i)->_parentInteractionClass;
-        while (interactionClass) {
-            for (ParameterList::const_reverse_iterator j = interactionClass->_parameters.rbegin();
-                 j != interactionClass->_parameters.rend(); ++j) {
-                (*i)->_parameters.insert((*i)->_parameters.begin(), *j);
-            }
-            interactionClass = interactionClass->_parentInteractionClass;
+        if (!interactionClass.valid())
+            continue;
+        for (ParameterList::const_reverse_iterator j = interactionClass->_parameters.rbegin();
+             j != interactionClass->_parameters.rend(); ++j) {
+            (*i)->_parameters.insert((*i)->_parameters.begin(), *j);
         }
     }
 }
@@ -729,11 +724,6 @@ HLAOMTXmlVisitor::startElement(const char* name, const XMLAttributes& atts)
             throw sg_exception("enumeratedDataTypes tag outside dataTypes!");
         pushMode(EnumeratedDataTypesMode);
 
-        Enumerator enumerator;
-        enumerator._name = getAttribute("name", atts);
-        enumerator._values = getAttribute("values", atts);
-        _enumeratedDataMap[_enumeratedDataName]._enumeratorList.push_back(enumerator);
-
     } else if (strcmp(name, "arrayData") == 0) {
         if (getCurrentMode() != ArrayDataTypesMode)
             throw sg_exception("arrayData tag outside arrayDataTypes!");

simgear/hla/HLAOMTXmlVisitor.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -25,9 +25,12 @@
 #include <simgear/structure/SGSharedPtr.hxx>
 #include <simgear/xml/easyxml.hxx>
 #include "HLADataType.hxx"
+#include "HLATypes.hxx"
 
 namespace simgear {
 
+class HLAFederate;
+
 class HLAOMTXmlVisitor : public XMLVisitor {
 public:
     /// structures representing the federate object model data
@@ -37,6 +40,10 @@ public:
         { }
         const std::string& getName() const
         { return _name; }
+        const std::string& getDataType() const
+        { return _dataType; }
+        const std::string& getSharing() const
+        { return _sharing; }
         const std::string& getDimensions() const
         { return _dimensions; }
         const std::string& getTransportation() const
@@ -44,6 +51,34 @@ public:
         const std::string& getOrder() const
         { return _order; }
 
+        HLASubscriptionType getSubscriptionType() const
+        {
+            if (_sharing.find("Subscribe") != std::string::npos)
+                return HLASubscribedActive;
+            else
+                return HLAUnsubscribed;
+        }
+
+        HLAPublicationType getPublicationType() const
+        {
+            if (_sharing.find("Publish") != std::string::npos)
+                return HLAPublished;
+            else
+                return HLAUnpublished;
+        }
+
+        HLAUpdateType getUpdateType() const
+        {
+            if (_updateType == "Periodic")
+                return HLAPeriodicUpdate;
+            else if (_updateType == "Static")
+                return HLAStaticUpdate;
+            else if (_updateType == "Conditional")
+                return HLAConditionalUpdate;
+            else
+                return HLAUndefinedUpdate;
+        }
+
         std::string _name;
         std::string _dataType;
         std::string _updateType;
@@ -66,7 +101,6 @@ public:
 
         unsigned getNumAttributes() const;
         const Attribute* getAttribute(unsigned index) const;
-        const Attribute* getAttribute(const std::string& name) const;
 
         const ObjectClass* getParentObjectClass() const;
 
@@ -101,12 +135,28 @@ public:
 
         const std::string& getName() const;
         const std::string& getDimensions() const;
+        const std::string& getSharing() const;
         const std::string& getTransportation() const;
         const std::string& getOrder() const;
 
+        HLASubscriptionType getSubscriptionType() const
+        {
+            if (_sharing.find("Subscribe") != std::string::npos)
+                return HLASubscribedActive;
+            else
+                return HLAUnsubscribed;
+        }
+
+        HLAPublicationType getPublicationType() const
+        {
+            if (_sharing.find("Publish") != std::string::npos)
+                return HLAPublished;
+            else
+                return HLAUnpublished;
+        }
+
         unsigned getNumParameters() const;
         const Parameter* getParameter(unsigned index) const;
-        const Parameter* getParameter(const std::string& name) const;
 
         const InteractionClass* getParentInteractionClass() const;
 
@@ -114,6 +164,7 @@ public:
         friend class HLAOMTXmlVisitor;
         std::string _name;
         std::string _dimensions;
+        std::string _sharing;
         std::string _transportation;
         std::string _order;
         ParameterList _parameters;
@@ -124,36 +175,23 @@ public:
     HLAOMTXmlVisitor();
     ~HLAOMTXmlVisitor();
 
+    void setDataTypesToFederate(HLAFederate& federate);
+    void setToFederate(HLAFederate& federate);
+
     unsigned getNumObjectClasses() const;
     const ObjectClass* getObjectClass(unsigned i) const;
-    const ObjectClass* getObjectClass(const std::string& name) const;
-
-    /// Return the data type from the fom data
-    const Attribute* getAttribute(const std::string& objectClassName, const std::string& attributeName) const;
-    /// Return the data type from the fom data
-    HLADataType* getAttributeDataType(const std::string& objectClassName, const std::string& attributeName) const;
 
     unsigned getNumInteractionClasses() const;
     const InteractionClass* getInteractionClass(unsigned i) const;
-    const InteractionClass* getInteractionClass(const std::string& name) const;
-
-    /// Return the data type from the fom data
-    const Parameter* getParameter(const std::string& interactionClassName, const std::string& parameterName) const;
-
-    /// Return the data type from the fom data
-    HLADataType* getParameterDataType(const std::string& interactionClassName, const std::string& parameterName) const;
-
-    HLADataType* getDataType(const std::string& dataTypeName) const;
 
 private:
-    typedef std::map<std::string, SGSharedPtr<HLADataType> > StringDataTypeMap;
-    SGSharedPtr<HLADataType> getDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
-    SGSharedPtr<HLABasicDataType> getBasicDataType(const std::string& dataTypeName) const;
-    SGSharedPtr<HLADataType> getSimpleDataType(const std::string& dataTypeName) const;
-    SGSharedPtr<HLAEnumeratedDataType> getEnumeratedDataType(const std::string& dataTypeName) const;
-    SGSharedPtr<HLADataType> getArrayDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
-    SGSharedPtr<HLAFixedRecordDataType> getFixedRecordDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
-    SGSharedPtr<HLAVariantDataType> getVariantDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+    SGSharedPtr<HLADataType> getDataType(const std::string& dataTypeName);
+    SGSharedPtr<HLABasicDataType> getBasicDataType(const std::string& dataTypeName);
+    SGSharedPtr<HLADataType> getSimpleDataType(const std::string& dataTypeName);
+    SGSharedPtr<HLAEnumeratedDataType> getEnumeratedDataType(const std::string& dataTypeName);
+    SGSharedPtr<HLADataType> getArrayDataType(const std::string& dataTypeName);
+    SGSharedPtr<HLAFixedRecordDataType> getFixedRecordDataType(const std::string& dataTypeName);
+    SGSharedPtr<HLAVariantRecordDataType> getVariantRecordDataType(const std::string& dataTypeName);
 
     enum Mode {
         UnknownMode,
@@ -195,8 +233,8 @@ private:
     virtual void startElement(const char* name, const XMLAttributes& atts);
     virtual void endElement(const char* name);
 
-    std::string getAttribute(const char* name, const XMLAttributes& atts);
-    std::string getAttribute(const std::string& name, const XMLAttributes& atts);
+    static std::string getAttribute(const char* name, const XMLAttributes& atts);
+    static std::string getAttribute(const std::string& name, const XMLAttributes& atts);
 
     struct BasicData {
         // std::string _name;
@@ -276,6 +314,9 @@ private:
     InteractionClassList _interactionClassList;
     InteractionClassList _interactionClassStack;
 
+    typedef std::map<std::string, SGSharedPtr<HLADataType> > StringDataTypeMap;
+    StringDataTypeMap _dataTypeMap;
+
     /// DataType definitions
     BasicDataMap _basicDataMap;
     SimpleDataMap _simpleDataMap;

simgear/hla/HLAObjectClass.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,8 +15,15 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAObjectClass.hxx"
 
+#include "simgear/debug/logstream.hxx"
 #include "RTIFederate.hxx"
 #include "RTIObjectClass.hxx"
 #include "RTIObjectInstance.hxx"
@@ -54,143 +61,226 @@ HLAObjectClass::RegistrationCallback::~RegistrationCallback()
 {
 }
 
-HLAObjectClass::HLAObjectClass(const std::string& name, HLAFederate& federate) :
+HLAObjectClass::HLAObjectClass(const std::string& name, HLAFederate* federate) :
+    _federate(federate),
     _name(name)
 {
-    _rtiObjectClass = federate._rtiFederate->createObjectClass(name, this);
-    if (!_rtiObjectClass.valid())
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::HLAObjectClass(): No RTIObjectClass found for \"" << name << "\"!");
+    if (!federate) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::HLAObjectClass(): "
+               "No parent federate given for object class \"" << getName() << "\"!");
+        return;
+    }
+    federate->_insertObjectClass(this);
 }
 
 HLAObjectClass::~HLAObjectClass()
 {
+    // HLAObjectClass objects only get deleted when the parent federate
+    // dies. So we do not need to deregister there.
+
+    _clearRTIObjectClass();
+}
+
+const std::string&
+HLAObjectClass::getName() const
+{
+    return _name;
+}
+
+const SGWeakPtr<HLAFederate>&
+HLAObjectClass::getFederate() const
+{
+    return _federate;
 }
 
 unsigned
 HLAObjectClass::getNumAttributes() const
 {
-    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
-        return 0;
-    }
-    return _rtiObjectClass->getNumAttributes();
+    return _attributeVector.size();
+}
+
+unsigned
+HLAObjectClass::addAttribute(const std::string& name)
+{
+    unsigned index = _attributeVector.size();
+    _nameIndexMap[name] = index;
+    _attributeVector.push_back(Attribute(name));
+    _resolveAttributeIndex(name, index);
+    return index;
 }
 
 unsigned
 HLAObjectClass::getAttributeIndex(const std::string& name) const
 {
-    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
+    NameIndexMap::const_iterator i = _nameIndexMap.find(name);
+    if (i == _nameIndexMap.end())
         return ~0u;
-    }
-    return _rtiObjectClass->getOrCreateAttributeIndex(name);
+    return i->second;
 }
 
 std::string
 HLAObjectClass::getAttributeName(unsigned index) const
 {
-    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
-        return 0;
-    }
-    return _rtiObjectClass->getAttributeName(index);
+    if (_attributeVector.size() <= index)
+        return std::string();
+    return _attributeVector[index]._name;
 }
 
 const HLADataType*
 HLAObjectClass::getAttributeDataType(unsigned index) const
 {
-    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeDataType(): No RTIObject class for object class \"" << getName() << "\"!");
+    if (_attributeVector.size() <= index)
         return 0;
-    }
-    return _rtiObjectClass->getAttributeDataType(index);
+    return _attributeVector[index]._dataType.get();
 }
 
 void
 HLAObjectClass::setAttributeDataType(unsigned index, const HLADataType* dataType)
 {
-    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::setAttributeDataType(): No RTIObject class for object class \"" << getName() << "\"!");
+    if (_attributeVector.size() <= index)
         return;
-    }
-    _rtiObjectClass->setAttributeDataType(index, dataType);
+    _attributeVector[index]._dataType = dataType;
 }
 
 HLAUpdateType
 HLAObjectClass::getAttributeUpdateType(unsigned index) const
 {
-    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeUpdateType(): No RTIObject class for object class \"" << getName() << "\"!");
+    if (_attributeVector.size() <= index)
         return HLAUndefinedUpdate;
-    }
-    return _rtiObjectClass->getAttributeUpdateType(index);
+    return _attributeVector[index]._updateType;
 }
 
 void
 HLAObjectClass::setAttributeUpdateType(unsigned index, HLAUpdateType updateType)
 {
-    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::setAttributeUpdateType(): "
-               "No RTIObject class for object class \"" << getName() << "\"!");
+    if (_attributeVector.size() <= index)
         return;
-    }
-    _rtiObjectClass->setAttributeUpdateType(index, updateType);
+    _attributeVector[index]._updateType = updateType;
+}
+
+HLASubscriptionType
+HLAObjectClass::getAttributeSubscriptionType(unsigned index) const
+{
+    if (_attributeVector.size() <= index)
+        return HLAUnsubscribed;
+    return _attributeVector[index]._subscriptionType;
+}
+
+void
+HLAObjectClass::setAttributeSubscriptionType(unsigned index, HLASubscriptionType subscriptionType)
+{
+    if (_attributeVector.size() <= index)
+        return;
+    _attributeVector[index]._subscriptionType = subscriptionType;
+}
+
+HLAPublicationType
+HLAObjectClass::getAttributePublicationType(unsigned index) const
+{
+    if (_attributeVector.size() <= index)
+        return HLAUnpublished;
+    return _attributeVector[index]._publicationType;
+}
+
+void
+HLAObjectClass::setAttributePublicationType(unsigned index, HLAPublicationType publicationType)
+{
+    if (_attributeVector.size() <= index)
+        return;
+    _attributeVector[index]._publicationType = publicationType;
 }
 
 HLADataElement::IndexPathPair
-HLAObjectClass::getIndexPathPair(const HLADataElement::AttributePathPair& attributePathPair) const
+HLAObjectClass::getIndexPathPair(const HLADataElement::StringPathPair& stringPathPair) const
 {
-    unsigned index = getAttributeIndex(attributePathPair.first);
+    unsigned index = getAttributeIndex(stringPathPair.first);
     if (getNumAttributes() <= index) {
         SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::getIndexPathPair(\""
-               << HLADataElement::toString(attributePathPair)
-               << "\"): Could not resolve attribute \"" << attributePathPair.first
+               << HLADataElement::toString(stringPathPair)
+               << "\"): Could not resolve attribute \"" << stringPathPair.first
                << "\" for object class \"" << getName() << "\"!");
     }
-    return HLADataElement::IndexPathPair(index, attributePathPair.second);
+    return HLADataElement::IndexPathPair(index, stringPathPair.second);
 }
 
 HLADataElement::IndexPathPair
 HLAObjectClass::getIndexPathPair(const std::string& path) const
 {
-    return getIndexPathPair(HLADataElement::toAttributePathPair(path));
+    return getIndexPathPair(HLADataElement::toStringPathPair(path));
 }
 
 bool
-HLAObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
+HLAObjectClass::subscribe()
 {
     if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): "
+               "No RTIObject class for object class \"" << getName() << "\"!");
         return false;
     }
-    return _rtiObjectClass->subscribe(indexSet, active);
+
+    HLAIndexList indexList;
+    for (unsigned i = 1; i < getNumAttributes(); ++i) {
+        if (_attributeVector[i]._subscriptionType != HLASubscribedActive)
+            continue;
+        indexList.push_back(i);
+    }
+    if (!indexList.empty()) {
+        if (!_rtiObjectClass->subscribe(indexList, true))
+            return false;
+    }
+
+    indexList.clear();
+    for (unsigned i = 1; i < getNumAttributes(); ++i) {
+        if (_attributeVector[i]._subscriptionType != HLASubscribedPassive)
+            continue;
+        indexList.push_back(i);
+    }
+    if (!indexList.empty()) {
+        if (!_rtiObjectClass->subscribe(indexList, false))
+            return false;
+    }
+    return true;
 }
 
 bool
 HLAObjectClass::unsubscribe()
 {
     if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unsubscribe(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unsubscribe(): "
+               "No RTIObject class for object class \"" << getName() << "\"!");
         return false;
     }
     return _rtiObjectClass->unsubscribe();
 }
 
 bool
-HLAObjectClass::publish(const std::set<unsigned>& indexSet)
+HLAObjectClass::publish()
 {
     if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): "
+               "No RTIObject class for object class \"" << getName() << "\"!");
         return false;
     }
-    return _rtiObjectClass->publish(indexSet);
+
+    HLAIndexList indexList;
+    for (unsigned i = 1; i < getNumAttributes(); ++i) {
+        if (_attributeVector[i]._publicationType == HLAUnpublished)
+            continue;
+        indexList.push_back(i);
+    }
+    if (indexList.empty())
+        return true;
+    if (!_rtiObjectClass->publish(indexList))
+        return false;
+    return true;
 }
 
 bool
 HLAObjectClass::unpublish()
 {
     if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unpublish(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unpublish(): "
+               "No RTIObject class for object class \"" << getName() << "\"!");
         return false;
     }
     return _rtiObjectClass->unpublish();
@@ -207,82 +297,135 @@ HLAObjectClass::stopRegistration() const
 }
 
 HLAObjectInstance*
-HLAObjectClass::createObjectInstance(RTIObjectInstance* rtiObjectInstance)
+HLAObjectClass::createObjectInstance(const std::string& name)
 {
-    return new HLAObjectInstance(this, rtiObjectInstance);
+    HLAObjectInstance* objectInstance = createObjectInstance();
+    if (objectInstance)
+        return objectInstance;
+    SGSharedPtr<HLAFederate> federate = _federate.lock();
+    if (!federate.valid())
+        return 0;
+    return federate->createObjectInstance(this, name);
+}
+
+HLAObjectInstance*
+HLAObjectClass::createObjectInstance()
+{
+    return 0;
 }
 
 void
-HLAObjectClass::discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag)
+HLAObjectClass::_setRTIObjectClass(RTIObjectClass* objectClass)
 {
-    SGSharedPtr<HLAObjectInstance> hlaObjectInstance = createObjectInstance(objectInstance);
-    if (hlaObjectInstance.valid()) {
-        SG_LOG(SG_NETWORK, SG_INFO, "RTI: create new object instance for discovered \""
-               << hlaObjectInstance->getName() << "\" object");
-        _objectInstanceSet.insert(hlaObjectInstance);
-        discoverInstanceCallback(*hlaObjectInstance, tag);
-    } else {
-        SG_LOG(SG_NETWORK, SG_INFO, "RTI: local delete of \"" << objectInstance->getName() << "\"");
-        objectInstance->localDeleteObjectInstance();
+    if (_rtiObjectClass) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Setting RTIObjectClass twice for object class \"" << getName() << "\"!");
+        return;
     }
-}
-
-void
-HLAObjectClass::removeInstance(HLAObjectInstance& hlaObjectInstance, const RTIData& tag)
-{
-    SG_LOG(SG_NETWORK, SG_INFO, "RTI: remove object instance \"" << hlaObjectInstance.getName() << "\"");
-    removeInstanceCallback(hlaObjectInstance, tag);
-    _objectInstanceSet.erase(&hlaObjectInstance);
-}
-
-void
-HLAObjectClass::registerInstance(HLAObjectInstance& objectInstance)
-{
-    _objectInstanceSet.insert(&objectInstance);
-    registerInstanceCallback(objectInstance);
-}
-
-void
-HLAObjectClass::deleteInstance(HLAObjectInstance& objectInstance)
-{
-    deleteInstanceCallback(objectInstance);
-    _objectInstanceSet.erase(&objectInstance);
-}
-
-void
-HLAObjectClass::discoverInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const
-{
-    if (!_instanceCallback.valid())
+    _rtiObjectClass = objectClass;
+    if (_rtiObjectClass->_objectClass != this) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: backward reference does not match!");
         return;
-    _instanceCallback->discoverInstance(*this, objectInstance, tag);
+    }
+    for (unsigned i = 0; i < _attributeVector.size(); ++i)
+        _resolveAttributeIndex(_attributeVector[i]._name, i);
 }
 
 void
-HLAObjectClass::removeInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const
+HLAObjectClass::_resolveAttributeIndex(const std::string& name, unsigned index)
 {
-    if (!_instanceCallback.valid())
+    if (!_rtiObjectClass)
         return;
-    _instanceCallback->removeInstance(*this, objectInstance, tag);
+    if (!_rtiObjectClass->resolveAttributeIndex(name, index))
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Could not resolve attribute \""
+               << name << "\" for object class \"" << getName() << "\"!");
 }
 
 void
-HLAObjectClass::registerInstanceCallback(HLAObjectInstance& objectInstance) const
+HLAObjectClass::_clearRTIObjectClass()
 {
-    if (!_instanceCallback.valid())
+    if (!_rtiObjectClass.valid())
         return;
-    _instanceCallback->registerInstance(*this, objectInstance);
+    _rtiObjectClass->_objectClass = 0;
+    _rtiObjectClass = 0;
 }
 
 void
-HLAObjectClass::deleteInstanceCallback(HLAObjectInstance& objectInstance) const
+HLAObjectClass::_discoverInstance(RTIObjectInstance* rtiObjectInstance, const RTIData& tag)
 {
-    if (!_instanceCallback.valid())
+    SGSharedPtr<HLAFederate> federate = _federate.lock();
+    if (!federate.valid()) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while discovering object instance");
         return;
-    _instanceCallback->deleteInstance(*this, objectInstance);
+    }
+
+    SGSharedPtr<HLAObjectInstance> objectInstance = createObjectInstance(rtiObjectInstance->getName());
+    if (!objectInstance.valid()) {
+        SG_LOG(SG_NETWORK, SG_INFO, "RTI: could not create new object instance for discovered \""
+               << rtiObjectInstance->getName() << "\" object");
+        return;
+    }
+    SG_LOG(SG_NETWORK, SG_INFO, "RTI: create new object instance for discovered \""
+           << rtiObjectInstance->getName() << "\" object");
+    objectInstance->_setRTIObjectInstance(rtiObjectInstance);
+    if (!federate->_insertObjectInstance(objectInstance)) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not insert new object instance for discovered \""
+               << rtiObjectInstance->getName() << "\" object");
+        return;
+    }
+    if (_instanceCallback.valid())
+        _instanceCallback->discoverInstance(*this, *objectInstance, tag);
 }
 
 void
-HLAObjectClass::startRegistrationCallback()
+HLAObjectClass::_removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag)
+{
+    SGSharedPtr<HLAFederate> federate = _federate.lock();
+    if (!federate.valid()) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while removing object instance");
+        return;
+    }
+    SG_LOG(SG_NETWORK, SG_INFO, "RTI: remove object instance \"" << objectInstance.getName() << "\"");
+    if (_instanceCallback.valid())
+        _instanceCallback->removeInstance(*this, objectInstance, tag);
+    federate->_eraseObjectInstance(objectInstance.getName());
+}
+
+void
+HLAObjectClass::_registerInstance(HLAObjectInstance* objectInstance)
+{
+    SGSharedPtr<HLAFederate> federate = _federate.lock();
+    if (!federate.valid()) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while registering object instance");
+        return;
+    }
+    if (!objectInstance)
+        return;
+    // We can only register object instances with a valid name at the rti.
+    // So, we cannot do that at HLAObjectInstance creation time.
+    if (!federate->_insertObjectInstance(objectInstance)) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not insert new object instance \""
+               << objectInstance->getName() << "\" object");
+        return;
+    }
+    if (_instanceCallback.valid())
+        _instanceCallback->registerInstance(*this, *objectInstance);
+}
+
+void
+HLAObjectClass::_deleteInstance(HLAObjectInstance& objectInstance)
+{
+    SGSharedPtr<HLAFederate> federate = _federate.lock();
+    if (!federate.valid()) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "RTI: could not find parent federate while deleting object instance");
+        return;
+    }
+    if (_instanceCallback.valid())
+        _instanceCallback->deleteInstance(*this, objectInstance);
+    federate->_eraseObjectInstance(objectInstance.getName());
+}
+
+void
+HLAObjectClass::_startRegistration()
 {
     if (_registrationCallback.valid())
         _registrationCallback->startRegistration(*this);
@@ -291,7 +434,7 @@ HLAObjectClass::startRegistrationCallback()
 }
 
 void
-HLAObjectClass::stopRegistrationCallback()
+HLAObjectClass::_stopRegistration()
 {
     if (_registrationCallback.valid())
         _registrationCallback->stopRegistration(*this);

simgear/hla/HLAObjectClass.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,12 +18,12 @@
 #ifndef HLAObjectClass_hxx
 #define HLAObjectClass_hxx
 
-#include <set>
 #include <string>
 #include <vector>
 
 #include "HLADataType.hxx"
 #include "HLAObjectInstance.hxx"
+#include "HLATypes.hxx"
 
 namespace simgear {
 
@@ -32,30 +32,56 @@ class HLAFederate;
 
 class HLAObjectClass : public SGWeakReferenced {
 public:
-    HLAObjectClass(const std::string& name, HLAFederate& federate);
+    HLAObjectClass(const std::string& name, HLAFederate* federate);
     virtual ~HLAObjectClass();
 
-    const std::string& getName() const
-    { return _name; }
+    /// Return the name of this object class
+    const std::string& getName() const;
 
+    /// return the federate this class belongs to
+    const SGWeakPtr<HLAFederate>& getFederate() const;
+
+    /// Return the number of attributes in this object class
     unsigned getNumAttributes() const;
+
+    /// Adds a new attribute to this object class, return the index
+    unsigned addAttribute(const std::string& name);
+
+    /// Return the attribute index for the attribute with the given name
     unsigned getAttributeIndex(const std::string& name) const;
+    /// Return the attribute name for the attribute with the given index
     std::string getAttributeName(unsigned index) const;
 
+    /// Return the data type of the attribute with the given index
     const HLADataType* getAttributeDataType(unsigned index) const;
-    void setAttributeDataType(unsigned index, const HLADataType*);
+    /// Sets the data type of the attribute with the given index to dataType
+    void setAttributeDataType(unsigned index, const HLADataType* dataType);
 
+    /// Return the update type of the attribute with the given index
     HLAUpdateType getAttributeUpdateType(unsigned index) const;
+    /// Sets the update type of the attribute with the given index to updateType
     void setAttributeUpdateType(unsigned index, HLAUpdateType updateType);
 
-    HLADataElement::IndexPathPair getIndexPathPair(const HLADataElement::AttributePathPair&) const;
+    /// Return the subscription type of the attribute with the given index
+    HLASubscriptionType getAttributeSubscriptionType(unsigned index) const;
+    /// Sets the subscription type of the attribute with the given index to subscriptionType
+    void setAttributeSubscriptionType(unsigned index, HLASubscriptionType subscriptionType);
+
+    /// Return the publication type of the attribute with the given index
+    HLAPublicationType getAttributePublicationType(unsigned index) const;
+    /// Sets the publication type of the attribute with the given index to publicationType
+    void setAttributePublicationType(unsigned index, HLAPublicationType publicationType);
+
+    /// Return the index, path pair for the given string path pair
+    HLADataElement::IndexPathPair getIndexPathPair(const HLADataElement::StringPathPair&) const;
+    /// Return the index, path pair for the given string path
     HLADataElement::IndexPathPair getIndexPathPair(const std::string& path) const;
 
-    bool subscribe(const std::set<unsigned>& indexSet, bool active);
-    bool unsubscribe();
+    virtual bool subscribe();
+    virtual bool unsubscribe();
 
-    bool publish(const std::set<unsigned>& indexSet);
-    bool unpublish();
+    virtual bool publish();
+    virtual bool unpublish();
 
     // Object instance creation and destruction
     class InstanceCallback : public SGReferenced {
@@ -74,6 +100,11 @@ public:
     const SGSharedPtr<InstanceCallback>& getInstanceCallback() const
     { return _instanceCallback; }
 
+    // Is called by the default registration callback if installed
+    // Should register the already known object instances of this class.
+    virtual void startRegistration() const;
+    virtual void stopRegistration() const;
+
     // Handles startRegistrationForObjectClass and stopRegistrationForObjectClass events
     class RegistrationCallback : public SGReferenced {
     public:
@@ -87,46 +118,61 @@ public:
     const SGSharedPtr<RegistrationCallback>& getRegistrationCallback() const
     { return _registrationCallback; }
 
-    // Is called by the default registration callback if installed
-    void startRegistration() const;
-    void stopRegistration() const;
-
-protected:
-    virtual HLAObjectInstance* createObjectInstance(RTIObjectInstance* rtiObjectInstance);
+    /// Create a new instance of this class.
+    virtual HLAObjectInstance* createObjectInstance(const std::string& name);
+    virtual HLAObjectInstance* createObjectInstance(); // deprecated
 
 private:
     HLAObjectClass(const HLAObjectClass&);
     HLAObjectClass& operator=(const HLAObjectClass&);
 
+    void _setRTIObjectClass(RTIObjectClass* objectClass);
+    void _resolveAttributeIndex(const std::string& name, unsigned index);
+    void _clearRTIObjectClass();
+
     // The internal entry points from the RTILObjectClass callback functions
-    void discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag);
-    void removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag);
-    void registerInstance(HLAObjectInstance& objectInstance);
-    void deleteInstance(HLAObjectInstance& objectInstance);
+    void _discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag);
+    void _removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag);
+    void _registerInstance(HLAObjectInstance* objectInstance);
+    void _deleteInstance(HLAObjectInstance& objectInstance);
 
-    void discoverInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const;
-    void removeInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const;
-    void registerInstanceCallback(HLAObjectInstance& objectInstance) const;
-    void deleteInstanceCallback(HLAObjectInstance& objectInstance) const;
+    void _startRegistration();
+    void _stopRegistration();
 
-    void startRegistrationCallback();
-    void stopRegistrationCallback();
     friend class HLAObjectInstance;
     friend class RTIObjectClass;
 
-    // The object class name
+    struct Attribute {
+        Attribute() : _subscriptionType(HLAUnsubscribed), _publicationType(HLAUnpublished), _updateType(HLAUndefinedUpdate) {}
+        Attribute(const std::string& name) : _name(name), _subscriptionType(HLAUnsubscribed), _publicationType(HLAUnpublished), _updateType(HLAUndefinedUpdate) {}
+        std::string _name;
+        SGSharedPtr<const HLADataType> _dataType;
+        HLASubscriptionType _subscriptionType;
+        HLAPublicationType _publicationType;
+        HLAUpdateType _updateType;
+    };
+    typedef std::vector<Attribute> AttributeVector;
+    typedef std::map<std::string,unsigned> NameIndexMap;
+
+    /// The parent federate.
+    SGWeakPtr<HLAFederate> _federate;
+
+    /// The object class name
     std::string _name;
 
-    // The underlying rti dispatcher class
+    /// The underlying rti dispatcher class
     SGSharedPtr<RTIObjectClass> _rtiObjectClass;
 
+    /// The attribute data
+    AttributeVector _attributeVector;
+    /// The mapping from attribute names to attribute indices
+    NameIndexMap _nameIndexMap;
+
     // Callback classes
     SGSharedPtr<InstanceCallback> _instanceCallback;
     SGSharedPtr<RegistrationCallback> _registrationCallback;
 
-    // The set of active objects
-    typedef std::set<SGSharedPtr<HLAObjectInstance> > ObjectInstanceSet;
-    ObjectInstanceSet _objectInstanceSet;
+    friend class HLAFederate;
 };
 
 } // namespace simgear

simgear/hla/HLAObjectInstance.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,112 +15,145 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAObjectInstance.hxx"
 
 #include <algorithm>
+#include "simgear/debug/logstream.hxx"
 #include "HLAArrayDataElement.hxx"
 #include "HLABasicDataElement.hxx"
 #include "HLADataElement.hxx"
 #include "HLAEnumeratedDataElement.hxx"
+#include "HLAFederate.hxx"
 #include "HLAFixedRecordDataElement.hxx"
 #include "HLAObjectClass.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 #include "RTIObjectClass.hxx"
 #include "RTIObjectInstance.hxx"
 
 namespace simgear {
 
-HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass) :
-    _objectClass(objectClass)
+HLAObjectInstance::UpdateCallback::~UpdateCallback()
 {
 }
 
-HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass, RTIObjectInstance* rtiObjectInstance) :
-    _objectClass(objectClass),
-    _rtiObjectInstance(rtiObjectInstance)
+HLAObjectInstance::ReflectCallback::~ReflectCallback()
 {
-    _rtiObjectInstance->_hlaObjectInstance = this;
-    _name = _rtiObjectInstance->getName();
+}
+
+HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass) :
+    _objectClass(objectClass)
+{
+    if (objectClass)
+        _federate = objectClass->_federate;
 }
 
 HLAObjectInstance::~HLAObjectInstance()
 {
+    _clearRTIObjectInstance();
 }
 
-SGSharedPtr<HLAObjectClass>
+const std::string&
+HLAObjectInstance::getName() const
+{
+    return _name;
+}
+
+const SGWeakPtr<HLAFederate>&
+HLAObjectInstance::getFederate() const
+{
+    return _federate;
+}
+
+const SGSharedPtr<HLAObjectClass>&
 HLAObjectInstance::getObjectClass() const
 {
-    return _objectClass.lock();
+    return _objectClass;
 }
 
 unsigned
 HLAObjectInstance::getNumAttributes() const
 {
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_ALERT, "Trying to get number of attributes for inactive object!");
+    if (!_objectClass.valid())
         return 0;
-    }
-    return _rtiObjectInstance->getNumAttributes();
+    return _objectClass->getNumAttributes();
 }
 
 unsigned
 HLAObjectInstance::getAttributeIndex(const std::string& name) const
 {
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute index for inactive object!");
-        return 0;
-    }
-    return _rtiObjectInstance->getAttributeIndex(name);
+    if (!_objectClass.valid())
+        return ~0u;
+    return _objectClass->getAttributeIndex(name);
 }
 
 std::string
 HLAObjectInstance::getAttributeName(unsigned index) const
 {
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute name for inactive object!");
+    if (!_objectClass.valid())
         return std::string();
-    }
-    return _rtiObjectInstance->getAttributeName(index);
+    return _objectClass->getAttributeName(index);
+}
+
+bool
+HLAObjectInstance::getAttributeOwned(unsigned index) const
+{
+    if (!_rtiObjectInstance.valid())
+        return false;
+    return _rtiObjectInstance->getAttributeOwned(index);
 }
 
 const HLADataType*
 HLAObjectInstance::getAttributeDataType(unsigned index) const
 {
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute index for inactive object!");
+    if (!_objectClass.valid())
         return 0;
-    }
-    return _rtiObjectInstance->getAttributeDataType(index);
-}
-
-void
-HLAObjectInstance::setAttributeDataElement(unsigned index, SGSharedPtr<HLADataElement> dataElement)
-{
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
-        return;
-    }
-    _rtiObjectInstance->setDataElement(index, dataElement);
+    return _objectClass->getAttributeDataType(index);
 }
 
 HLADataElement*
 HLAObjectInstance::getAttributeDataElement(unsigned index)
 {
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
+    if (_attributeVector.size() <= index)
         return 0;
-    }
-    return _rtiObjectInstance->getDataElement(index);
+    return _attributeVector[index]._dataElement.get();
 }
 
 const HLADataElement*
 HLAObjectInstance::getAttributeDataElement(unsigned index) const
 {
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
+    if (_attributeVector.size() <= index)
         return 0;
+    return _attributeVector[index]._dataElement.get();
+}
+
+bool
+HLAObjectInstance::getAttributeData(unsigned index, RTIData& data) const
+{
+    if (!_rtiObjectInstance.valid()) {
+        SG_LOG(SG_IO, SG_ALERT, "Trying to get raw attribute data without rti object instance for \"" << getName() << "\"!");
+        return false;
     }
-    return _rtiObjectInstance->getDataElement(index);
+    return _rtiObjectInstance->getAttributeData(index, data);
+}
+
+void
+HLAObjectInstance::setAttributeDataElement(unsigned index, const SGSharedPtr<HLADataElement>& dataElement)
+{
+    unsigned numAttributes = getNumAttributes();
+    if (numAttributes <= index)
+        return;
+    _attributeVector.resize(numAttributes);
+    if (_attributeVector[index]._dataElement.valid())
+        _attributeVector[index]._dataElement->clearStamp();
+    _attributeVector[index]._dataElement = dataElement;
+    if (_attributeVector[index]._dataElement.valid())
+        _attributeVector[index]._dataElement->createStamp();
 }
 
 class HLAObjectInstance::DataElementFactoryVisitor : public HLADataElementFactoryVisitor {
@@ -312,9 +345,9 @@ public:
         _dataElement = recordDataElement;
     }
 
-    class VariantDataElementFactory : public HLAVariantDataElement::DataElementFactory {
+    class VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
     public:
-        VariantDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
+        VariantRecordDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
             _path(path)
         {
             for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
@@ -325,9 +358,9 @@ public:
                 _pathElementMap.insert(*i);
             }
         }
-        virtual HLADataElement* createElement(const HLAVariantDataElement& element, unsigned index)
+        virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
         {
-            const HLAVariantDataType* dataType = element.getDataType();
+            const HLAVariantRecordDataType* dataType = element.getDataType();
             if (!dataType)
                 return 0;
             const HLADataType* alternativeDataType = element.getAlternativeDataType();
@@ -344,17 +377,17 @@ public:
         HLAPathElementMap _pathElementMap;
     };
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     {
         _dataElement = createDataElement(_path, dataType);
         if (_dataElement.valid())
             return;
 
-        SGSharedPtr<HLAVariantDataElement> variantDataElement;
-        variantDataElement = new HLAVariantDataElement(&dataType);
-        variantDataElement->setDataElementFactory(new VariantDataElementFactory(_path, _pathElementMap));
+        SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
+        variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
+        variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory(_path, _pathElementMap));
 
-        _dataElement = variantDataElement;
+        _dataElement = variantRecordDataElement;
     }
 
 private:
@@ -387,8 +420,8 @@ HLAObjectInstance::setAttribute(unsigned index, const HLAPathElementMap& pathEle
 {
     const HLADataType* dataType = getAttributeDataType(index);
     if (!dataType) {
-        SG_LOG(SG_IO, SG_ALERT, "Cannot get attribute data type for setting attribute at index "
-               << index << "!");
+        SG_LOG(SG_IO, SG_ALERT, "Cannot get attribute data type for setting attribute \""
+               << getAttributeName(index) << "\" at index " << index << "!");
         return;
     }
 
@@ -411,26 +444,36 @@ HLAObjectInstance::setAttributes(const HLAAttributePathElementMap& attributePath
 
 void
 HLAObjectInstance::registerInstance()
+{
+    registerInstance(_objectClass.get());
+}
+
+void
+HLAObjectInstance::registerInstance(HLAObjectClass* objectClass)
 {
     if (_rtiObjectInstance.valid()) {
         SG_LOG(SG_IO, SG_ALERT, "Trying to register object " << getName() << " already known to the RTI!");
         return;
     }
-    SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
-    if (!objectClass.valid()) {
+    if (!objectClass) {
         SG_LOG(SG_IO, SG_ALERT, "Could not register object with unknown object class!");
         return;
     }
-    // This error must have been flagged before
-    if (!objectClass->_rtiObjectClass.valid())
+    if (_objectClass.valid() && objectClass != _objectClass.get()) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not change object class while registering!");
         return;
-    _rtiObjectInstance = objectClass->_rtiObjectClass->registerObjectInstance(this);
+    }
+    _objectClass = objectClass;
+    _federate = _objectClass->_federate;
+    // This error must have been flagged before
+    if (!_objectClass->_rtiObjectClass.valid())
+        return;
+    _setRTIObjectInstance(_objectClass->_rtiObjectClass->registerObjectInstance(this));
     if (!_rtiObjectInstance.valid()) {
         SG_LOG(SG_IO, SG_ALERT, "Could not register object at the RTI!");
         return;
     }
-    _name = _rtiObjectInstance->getName();
-    objectClass->registerInstance(*this);
+    _objectClass->_registerInstance(this);
 }
 
 void
@@ -440,61 +483,224 @@ HLAObjectInstance::deleteInstance(const RTIData& tag)
         SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
         return;
     }
-    SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
-    if (!objectClass.valid())
+    if (!_objectClass.valid())
         return;
-    objectClass->deleteInstance(*this);
+    _objectClass->_deleteInstance(*this);
     _rtiObjectInstance->deleteObjectInstance(tag);
 }
 
 void
 HLAObjectInstance::updateAttributeValues(const RTIData& tag)
 {
-    if (!_rtiObjectInstance.valid()) {
-        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
-        return;
-    }
     if (_attributeCallback.valid())
         _attributeCallback->updateAttributeValues(*this, tag);
-    _rtiObjectInstance->updateAttributeValues(tag);
+    if (_updateCallback.valid()) {
+        _updateCallback->updateAttributeValues(*this, tag);
+    } else {
+        encodeAttributeValues();
+        sendAttributeValues(tag);
+    }
 }
 
 void
 HLAObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
+{
+    if (_attributeCallback.valid())
+        _attributeCallback->updateAttributeValues(*this, tag);
+    if (_updateCallback.valid()) {
+        _updateCallback->updateAttributeValues(*this, timeStamp, tag);
+    } else {
+        encodeAttributeValues();
+        sendAttributeValues(timeStamp, tag);
+    }
+}
+
+void
+HLAObjectInstance::encodeAttributeValues()
+{
+    unsigned numAttributes = _attributeVector.size();
+    for (unsigned i = 0; i < numAttributes;++i) {
+        if (_attributeVector[i]._unconditionalUpdate) {
+            encodeAttributeValue(i);
+        } else if (_attributeVector[i]._enabledUpdate) {
+            const HLADataElement* dataElement = getAttributeDataElement(i);
+            if (dataElement && dataElement->getDirty())
+                encodeAttributeValue(i);
+        }
+    }
+}
+
+void
+HLAObjectInstance::encodeAttributeValue(unsigned index)
+{
+    if (!_rtiObjectInstance.valid()) {
+        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
+        return;
+    }
+    HLADataElement* dataElement = getAttributeDataElement(index);
+    if (!dataElement)
+        return;
+    _rtiObjectInstance->encodeAttributeData(index, *dataElement);
+    dataElement->setDirty(false);
+}
+
+void
+HLAObjectInstance::sendAttributeValues(const RTIData& tag)
+{
+    if (!_rtiObjectInstance.valid()) {
+        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
+        return;
+    }
+    _rtiObjectInstance->updateAttributeValues(tag);
+}
+
+void
+HLAObjectInstance::sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 {
     if (!_rtiObjectInstance.valid()) {
         SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
         return;
     }
-    if (_attributeCallback.valid())
-        _attributeCallback->updateAttributeValues(*this, tag);
     _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
 }
 
 void
-HLAObjectInstance::removeInstance(const RTIData& tag)
+HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 {
-    SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
-    if (!objectClass.valid())
-        return;
-    objectClass->removeInstanceCallback(*this, tag);
+    for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
+        reflectAttributeValue(*i, tag);
 }
 
 void
-HLAObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const RTIData& tag)
-{
-    if (!_attributeCallback.valid())
-        return;
-    _attributeCallback->reflectAttributeValues(*this, dataPairList, tag);
-}
-
-void
-HLAObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList,
+HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
                                           const SGTimeStamp& timeStamp, const RTIData& tag)
 {
-    if (!_attributeCallback.valid())
+    for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
+        reflectAttributeValue(*i, timeStamp, tag);
+}
+
+void
+HLAObjectInstance::reflectAttributeValue(unsigned index, const RTIData& tag)
+{
+    HLADataElement* dataElement = getAttributeDataElement(index);
+    if (!dataElement)
         return;
-    _attributeCallback->reflectAttributeValues(*this, dataPairList, timeStamp, tag);
+    dataElement->setTimeStampValid(false);
+    _rtiObjectInstance->decodeAttributeData(index, *dataElement);
+}
+
+void
+HLAObjectInstance::reflectAttributeValue(unsigned index, const SGTimeStamp& timeStamp, const RTIData& tag)
+{
+    HLADataElement* dataElement = getAttributeDataElement(index);
+    if (!dataElement)
+        return;
+    dataElement->setTimeStamp(timeStamp);
+    dataElement->setTimeStampValid(true);
+    _rtiObjectInstance->decodeAttributeData(index, *dataElement);
+}
+
+void
+HLAObjectInstance::_setRTIObjectInstance(RTIObjectInstance* rtiObjectInstance)
+{
+    if (!_objectClass.valid())
+        return;
+
+    _rtiObjectInstance = rtiObjectInstance;
+    _rtiObjectInstance->setObjectInstance(this);
+    _name = _rtiObjectInstance->getName();
+
+    unsigned numAttributes = getNumAttributes();
+    _attributeVector.resize(numAttributes);
+    for (unsigned i = 0; i < numAttributes; ++i) {
+        HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
+        if (getAttributeOwned(i) && updateType != HLAUndefinedUpdate) {
+            _attributeVector[i]._enabledUpdate = true;
+            _attributeVector[i]._unconditionalUpdate = (updateType == HLAPeriodicUpdate);
+            // In case of an owned attribute, now encode its value
+            encodeAttributeValue(i);
+        } else {
+            _attributeVector[i]._enabledUpdate = false;
+            _attributeVector[i]._unconditionalUpdate = false;
+        }
+    }
+
+    // This makes sense with any new object. Even if we registered one, there might be unpublished attributes.
+    HLAIndexList indexList;
+    for (unsigned i = 0; i < numAttributes; ++i) {
+        HLAUpdateType updateType = _objectClass->getAttributeUpdateType(i);
+        if (getAttributeOwned(i))
+            continue;
+        if (updateType == HLAUndefinedUpdate)
+            continue;
+        if (updateType == HLAPeriodicUpdate)
+            continue;
+        indexList.push_back(i);
+    }
+    _rtiObjectInstance->requestObjectAttributeValueUpdate(indexList);
+}
+
+void
+HLAObjectInstance::_clearRTIObjectInstance()
+{
+    if (!_rtiObjectInstance.valid())
+        return;
+
+    for (unsigned i = 0; i < _attributeVector.size(); ++i) {
+        _attributeVector[i]._enabledUpdate = false;
+        _attributeVector[i]._unconditionalUpdate = false;
+    }
+
+    _rtiObjectInstance->setObjectInstance(0);
+    _rtiObjectInstance = 0;
+}
+
+void
+HLAObjectInstance::_removeInstance(const RTIData& tag)
+{
+    if (!_objectClass.valid())
+        return;
+    _objectClass->_removeInstance(*this, tag);
+}
+
+void
+HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
+{
+    if (_reflectCallback.valid()) {
+        _reflectCallback->reflectAttributeValues(*this, indexList, tag);
+    } else if (_attributeCallback.valid()) {
+        reflectAttributeValues(indexList, tag);
+
+        RTIIndexDataPairList dataPairList;
+        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
+            dataPairList.push_back(RTIIndexDataPair());
+            dataPairList.back().first = *i;
+            getAttributeData(*i, dataPairList.back().second);
+        }
+        _attributeCallback->reflectAttributeValues(*this, dataPairList, tag);
+    } else {
+        reflectAttributeValues(indexList, tag);
+    }
+}
+
+void
+HLAObjectInstance::_reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag)
+{
+    if (_reflectCallback.valid()) {
+        _reflectCallback->reflectAttributeValues(*this, indexList, timeStamp, tag);
+    } else if (_attributeCallback.valid()) {
+        reflectAttributeValues(indexList, timeStamp, tag);
+
+        RTIIndexDataPairList dataPairList;
+        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
+            dataPairList.push_back(RTIIndexDataPair());
+            dataPairList.back().first = *i;
+            getAttributeData(*i, dataPairList.back().second);
+        }
+        _attributeCallback->reflectAttributeValues(*this, dataPairList, timeStamp, tag);
+    } else {
+        reflectAttributeValues(indexList, timeStamp, tag);
+    }
 }
 
 } // namespace simgear

simgear/hla/HLAObjectInstance.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,51 +18,121 @@
 #ifndef HLAObjectInstance_hxx
 #define HLAObjectInstance_hxx
 
+#include <vector>
+
 #include <simgear/structure/SGWeakPtr.hxx>
 
 #include "HLADataElement.hxx"
+#include "HLATypes.hxx"
 
 class SGTimeStamp;
 
 namespace simgear {
 
 class RTIObjectInstance;
+class HLAFederate;
 class HLAObjectClass;
 
 class HLAObjectInstance : public SGWeakReferenced {
 public:
-    HLAObjectInstance(HLAObjectClass* objectClass);
-    HLAObjectInstance(HLAObjectClass* objectClass, RTIObjectInstance* rtiObjectInstance);
+    HLAObjectInstance(HLAObjectClass* objectClass = 0);
     virtual ~HLAObjectInstance();
 
-    const std::string& getName() const
-    { return _name; }
+    /// Return the name of this object instance
+    const std::string& getName() const;
 
-    SGSharedPtr<HLAObjectClass> getObjectClass() const;
+    /// return the federate this instance belongs to
+    const SGWeakPtr<HLAFederate>& getFederate() const;
 
+    /// Return the object class of this instance.
+    /// Should always return a valid object class.
+    const SGSharedPtr<HLAObjectClass>& getObjectClass() const;
+
+    /// Return the number of attributes
     unsigned getNumAttributes() const;
+
+    /// Return the attribute index for the attribute with the given name
     unsigned getAttributeIndex(const std::string& name) const;
+    /// Return the attribute name for the attribute with the given index
     std::string getAttributeName(unsigned index) const;
 
+    /// Return true if the attribute with the given index is owned by
+    /// this federate
+    bool getAttributeOwned(unsigned index) const;
+
+    /// Return the data type of the attribute with the given index
     const HLADataType* getAttributeDataType(unsigned index) const;
 
-    void setAttributeDataElement(unsigned index, SGSharedPtr<HLADataElement> dataElement);
+    /// Return the data element of the attribute with the given index
     HLADataElement* getAttributeDataElement(unsigned index);
     const HLADataElement* getAttributeDataElement(unsigned index) const;
+
+    /// Write the raw attribute data value into data, works only of the object
+    /// is backed up with an rti object instance
+    bool getAttributeData(unsigned index, RTIData& data) const;
+
+    /// Sets the data element of the attribute with the given index to dataElement
+    void setAttributeDataElement(unsigned index, const SGSharedPtr<HLADataElement>& dataElement);
+    /// Sets the data element of the attribute with the given index to the content of pathElementMap
     void setAttribute(unsigned index, const HLAPathElementMap& pathElementMap);
     void setAttributes(const HLAAttributePathElementMap& attributePathElementMap);
 
     void registerInstance();
+    void registerInstance(HLAObjectClass* objectClass);
     void deleteInstance(const RTIData& tag);
 
+    // Push the current values into the RTI
+    virtual void updateAttributeValues(const RTIData& tag);
+    virtual void updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
+    // encode periodic and dirty attribute values for the next sendAttributeValues
+    void encodeAttributeValues();
+    // encode the attribute value at index i for the next sendAttributeValues
+    void encodeAttributeValue(unsigned index);
+
+    // Really sends the prepared attribute update values into the RTI
+    void sendAttributeValues(const RTIData& tag);
+    void sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
+
+    class UpdateCallback : public SGReferenced {
+    public:
+        virtual ~UpdateCallback();
+
+        virtual void updateAttributeValues(HLAObjectInstance&, const RTIData&) = 0;
+        virtual void updateAttributeValues(HLAObjectInstance&, const SGTimeStamp&, const RTIData&) = 0;
+    };
+
+    void setUpdateCallback(const SGSharedPtr<UpdateCallback>& updateCallback)
+    { _updateCallback = updateCallback; }
+    const SGSharedPtr<UpdateCallback>& getUpdateCallback() const
+    { return _updateCallback; }
+
+
+    // Reflects the indices given in the index vector into the attributes HLADataElements.
+    virtual void reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag);
+    virtual void reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag);
+    // Reflect a single attribute value at the given index into the attributes HLADataELement.
+    virtual void reflectAttributeValue(unsigned index, const RTIData& tag);
+    virtual void reflectAttributeValue(unsigned index, const SGTimeStamp& timeStamp, const RTIData& tag);
+
+    class ReflectCallback : public SGReferenced {
+    public:
+        virtual ~ReflectCallback();
+
+        virtual void reflectAttributeValues(HLAObjectInstance&, const HLAIndexList&, const RTIData&) = 0;
+        virtual void reflectAttributeValues(HLAObjectInstance&, const HLAIndexList&, const SGTimeStamp&, const RTIData&) = 0;
+    };
+
+    void setReflectCallback(const SGSharedPtr<ReflectCallback>& reflectCallback)
+    { _reflectCallback = reflectCallback; }
+    const SGSharedPtr<ReflectCallback>& getReflectCallback() const
+    { return _reflectCallback; }
+
+    // deprecated.
     class AttributeCallback : public SGReferenced {
     public:
         virtual ~AttributeCallback() {}
-        // Notification about reflect and whatever TBD
-        // Hmm, don't know yet how this should look like
         virtual void updateAttributeValues(HLAObjectInstance& objectInstance, const RTIData& tag)
         { }
-
         virtual void reflectAttributeValues(HLAObjectInstance& objectInstance,
                                             const RTIIndexDataPairList& dataPairList, const RTIData& tag)
         { }
@@ -76,24 +146,57 @@ public:
     const SGSharedPtr<AttributeCallback>& getAttributeCallback() const
     { return _attributeCallback; }
 
-    // Push the current values into the RTI
-    void updateAttributeValues(const RTIData& tag);
-    void updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
-
 private:
-    void removeInstance(const RTIData& tag);
-    void reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const RTIData& tag);
-    void reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const SGTimeStamp& timeStamp, const RTIData& tag);
-    friend class RTIObjectInstance;
-    friend class HLAObjectClass;
+    void _setRTIObjectInstance(RTIObjectInstance* rtiObjectInstance);
+    void _clearRTIObjectInstance();
+
+    // The callback entry points from the RTI interface classes.
+    void _removeInstance(const RTIData& tag);
+    void _reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag);
+    void _reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag);
 
     class DataElementFactoryVisitor;
 
+    struct Attribute {
+        Attribute() : _enabledUpdate(false), _unconditionalUpdate(false) {}
+        SGSharedPtr<HLADataElement> _dataElement;
+        bool _enabledUpdate;
+        bool _unconditionalUpdate;
+        // HLAIndexList::iterator _unconditionalUpdateAttributeIndexListIterator;
+        // HLAIndexList::iterator _conditionalUpdateAttributeIndexListIterator;
+    };
+    typedef std::vector<Attribute> AttributeVector;
+
+    // At some time we want these: Until then, use the _enabledUpdate and _unconditionalUpdate flags in the Attribute struct.
+    // HLAIndexList _unconditionalUpdateAttributeIndexList;
+    // HLAIndexList _conditionalUpdateAttributeIndexList;
+
+    /// The parent Federate
+    SGWeakPtr<HLAFederate> _federate;
+
+    /// The ObjectClass
+    SGSharedPtr<HLAObjectClass> _objectClass;
+
+    /// The name as known in the RTI
     std::string _name;
 
-    SGWeakPtr<HLAObjectClass> _objectClass;
+    // /// The name as given by the local created instance
+    // std::string _givenName;
+
+    /// The underlying rti dispatcher class
     SGSharedPtr<RTIObjectInstance> _rtiObjectInstance;
+
+    /// The attribute data
+    AttributeVector _attributeVector;
+
+    // Callback classes
+    SGSharedPtr<UpdateCallback> _updateCallback;
+    SGSharedPtr<ReflectCallback> _reflectCallback;
     SGSharedPtr<AttributeCallback> _attributeCallback;
+
+    friend class HLAFederate;
+    friend class HLAObjectClass;
+    friend class RTIObjectInstance;
 };
 
 } // namespace simgear

simgear/hla/HLAPropertyDataElement.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLAPropertyDataElement.hxx"
 
 #include "HLAArrayDataElement.hxx"
@@ -22,7 +28,7 @@
 #include "HLADataElementVisitor.hxx"
 #include "HLADataTypeVisitor.hxx"
 #include "HLAFixedRecordDataElement.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 
 namespace simgear {
 
@@ -373,14 +379,14 @@ public:
         _dataElement = recordDataElement;
     }
 
-    class VariantDataElementFactory : public HLAVariantDataElement::DataElementFactory {
+    class VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
     public:
-        VariantDataElementFactory(SGPropertyNode* propertyNode) :
+        VariantRecordDataElementFactory(SGPropertyNode* propertyNode) :
             _propertyNode(propertyNode)
         { }
-        virtual HLADataElement* createElement(const HLAVariantDataElement& element, unsigned index)
+        virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
         {
-            const HLAVariantDataType* dataType = element.getDataType();
+            const HLAVariantRecordDataType* dataType = element.getDataType();
             if (!dataType)
                 return 0;
             const HLADataType* alternativeDataType = element.getAlternativeDataType();
@@ -394,12 +400,12 @@ public:
         SGSharedPtr<SGPropertyNode> _propertyNode;
     };
 
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
     {
-        SGSharedPtr<HLAVariantDataElement> variantDataElement;
-        variantDataElement = new HLAVariantDataElement(&dataType);
-        variantDataElement->setDataElementFactory(new VariantDataElementFactory(_propertyNode.get()));
-        _dataElement = variantDataElement;
+        SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
+        variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
+        variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory(_propertyNode.get()));
+        _dataElement = variantRecordDataElement;
     }
 
     HLADataElement* getDataElement()

simgear/hla/HLARawDataElement.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "HLARawDataElement.hxx"
 
 namespace simgear {

simgear/hla/HLATypes.hxx

@@ -0,0 +1,47 @@
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLATypes_hxx
+#define HLATypes_hxx
+
+#include <list>
+
+namespace simgear {
+
+enum HLASubscriptionType {
+    HLAUnsubscribed,
+    HLASubscribedActive,
+    HLASubscribedPassive
+};
+
+enum HLAPublicationType {
+    HLAUnpublished,
+    HLAPublished
+};
+
+enum HLAUpdateType {
+    HLAStaticUpdate,
+    HLAPeriodicUpdate,
+    HLAConditionalUpdate,
+    HLAUndefinedUpdate
+};
+
+typedef std::list<unsigned> HLAIndexList;
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAVariantDataElement.cxx

@@ -1,169 +0,0 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Library General Public
-// License as published by the Free Software Foundation; either
-// version 2 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Library General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-
-#include "HLAVariantDataElement.hxx"
-
-#include <simgear/debug/logstream.hxx>
-
-#include "HLADataElementVisitor.hxx"
-
-namespace simgear {
-
-HLAAbstractVariantDataElement::HLAAbstractVariantDataElement(const HLAVariantDataType* dataType) :
-    _dataType(dataType)
-{
-}
-
-HLAAbstractVariantDataElement::~HLAAbstractVariantDataElement()
-{
-}
-
-void
-HLAAbstractVariantDataElement::accept(HLADataElementVisitor& visitor)
-{
-    visitor.apply(*this);
-}
-
-void
-HLAAbstractVariantDataElement::accept(HLAConstDataElementVisitor& visitor) const
-{
-    visitor.apply(*this);
-}
-
-bool
-HLAAbstractVariantDataElement::decode(HLADecodeStream& stream)
-{
-    if (!_dataType.valid())
-        return false;
-    return _dataType->decode(stream, *this);
-}
-
-bool
-HLAAbstractVariantDataElement::encode(HLAEncodeStream& stream) const
-{
-    if (!_dataType.valid())
-        return false;
-    return _dataType->encode(stream, *this);
-}
-
-const HLAVariantDataType*
-HLAAbstractVariantDataElement::getDataType() const
-{
-    return _dataType.get();
-}
-
-bool
-HLAAbstractVariantDataElement::setDataType(const HLADataType* dataType)
-{
-    const HLAVariantDataType* variantDataType = dataType->toVariantDataType();
-    if (!variantDataType) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantDataType: unable to set data type!");
-        return false;
-    }
-    setDataType(variantDataType);
-    return true;
-}
-
-void
-HLAAbstractVariantDataElement::setDataType(const HLAVariantDataType* dataType)
-{
-    _dataType = dataType;
-}
-
-std::string
-HLAAbstractVariantDataElement::getAlternativeName() const
-{
-    if (!_dataType.valid())
-        return std::string();
-    return _dataType->getAlternativeName(getAlternativeIndex());
-}
-
-const HLADataType*
-HLAAbstractVariantDataElement::getAlternativeDataType() const
-{
-    if (!_dataType.valid())
-        return 0;
-    return _dataType->getAlternativeDataType(getAlternativeIndex());
-}
-
-
-HLAVariantDataElement::DataElementFactory::~DataElementFactory()
-{
-}
-
-HLAVariantDataElement::HLAVariantDataElement(const HLAVariantDataType* dataType) :
-    HLAAbstractVariantDataElement(dataType),
-    _alternativeIndex(~0u)
-{
-}
-
-HLAVariantDataElement::~HLAVariantDataElement()
-{
-}
-
-bool
-HLAVariantDataElement::setAlternativeIndex(unsigned index)
-{
-    if (_alternativeIndex == index)
-        return true;
-    SGSharedPtr<HLADataElement> dataElement = newElement(index);
-    if (!dataElement.valid())
-        return false;
-    _dataElement.swap(dataElement);
-    _alternativeIndex = index;
-    return true;
-}
-
-bool
-HLAVariantDataElement::decodeAlternative(HLADecodeStream& stream)
-{
-    return _dataElement->decode(stream);
-}
-
-unsigned
-HLAVariantDataElement::getAlternativeIndex() const
-{
-    return _alternativeIndex;
-}
-
-bool
-HLAVariantDataElement::encodeAlternative(HLAEncodeStream& stream) const
-{
-    return _dataElement->encode(stream);
-}
-
-void
-HLAVariantDataElement::setDataElementFactory(HLAVariantDataElement::DataElementFactory* dataElementFactory)
-{
-    _dataElementFactory = dataElementFactory;
-}
-
-HLAVariantDataElement::DataElementFactory*
-HLAVariantDataElement::getDataElementFactory()
-{
-    return _dataElementFactory;
-}
-
-HLADataElement*
-HLAVariantDataElement::newElement(unsigned index)
-{
-    if (!_dataElementFactory.valid())
-        return 0;
-    return _dataElementFactory->createElement(*this, index);
-}
-
-}

simgear/hla/HLAVariantDataElement.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,67 +18,13 @@
 #ifndef HLAVariantDataElement_hxx
 #define HLAVariantDataElement_hxx
 
-#include <string>
-#include <simgear/structure/SGSharedPtr.hxx>
-#include "HLADataElement.hxx"
 #include "HLAVariantDataType.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 
 namespace simgear {
 
-class HLAAbstractVariantDataElement : public HLADataElement {
-public:
-    HLAAbstractVariantDataElement(const HLAVariantDataType* dataType);
-    virtual ~HLAAbstractVariantDataElement();
-
-    virtual void accept(HLADataElementVisitor& visitor);
-    virtual void accept(HLAConstDataElementVisitor& visitor) const;
-
-    virtual bool decode(HLADecodeStream& stream);
-    virtual bool encode(HLAEncodeStream& stream) const;
-
-    virtual const HLAVariantDataType* getDataType() const;
-    virtual bool setDataType(const HLADataType* dataType);
-    void setDataType(const HLAVariantDataType* dataType);
-
-    std::string getAlternativeName() const;
-    const HLADataType* getAlternativeDataType() const;
-
-    virtual bool setAlternativeIndex(unsigned index) = 0;
-    virtual bool decodeAlternative(HLADecodeStream& stream) = 0;
-    virtual unsigned getAlternativeIndex() const = 0;
-    virtual bool encodeAlternative(HLAEncodeStream& stream) const = 0;
-
-private:
-    SGSharedPtr<const HLAVariantDataType> _dataType;
-};
-
-class HLAVariantDataElement : public HLAAbstractVariantDataElement {
-public:
-    HLAVariantDataElement(const HLAVariantDataType* dataType);
-    virtual ~HLAVariantDataElement();
-
-    virtual bool setAlternativeIndex(unsigned index);
-    virtual bool decodeAlternative(HLADecodeStream& stream);
-    virtual unsigned getAlternativeIndex() const;
-    virtual bool encodeAlternative(HLAEncodeStream& stream) const;
-
-    class DataElementFactory : public SGReferenced {
-    public:
-        virtual ~DataElementFactory();
-        virtual HLADataElement* createElement(const HLAVariantDataElement&, unsigned) = 0;
-    };
-
-    void setDataElementFactory(DataElementFactory* dataElementFactory);
-    DataElementFactory* getDataElementFactory();
-
-private:
-    HLADataElement* newElement(unsigned index);
-
-    SGSharedPtr<HLADataElement> _dataElement;
-    unsigned _alternativeIndex;
-
-    SGSharedPtr<DataElementFactory> _dataElementFactory;
-};
+typedef HLAAbstractVariantRecordDataElement HLAAbstractVariantDataElement;
+typedef HLAVariantRecordDataElement HLAVariantDataElement;
 
 }
 

simgear/hla/HLAVariantDataType.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,84 +18,11 @@
 #ifndef HLAVariantDataType_hxx
 #define HLAVariantDataType_hxx
 
-#include <string>
-#include <vector>
-#include "simgear/structure/SGSharedPtr.hxx"
-#include "HLADataType.hxx"
-#include "HLAEnumeratedDataType.hxx"
+#include "HLAVariantRecordDataType.hxx"
 
 namespace simgear {
 
-class HLAAbstractVariantDataElement;
-
-class HLAVariantDataType : public HLADataType {
-public:
-    HLAVariantDataType(const std::string& name = "HLAVariantDataType");
-    virtual ~HLAVariantDataType();
-
-    virtual void accept(HLADataTypeVisitor& visitor) const;
-
-    virtual const HLAVariantDataType* toVariantDataType() const;
-
-    virtual bool decode(HLADecodeStream& stream, HLAAbstractVariantDataElement& value) const;
-    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractVariantDataElement& value) const;
-
-    const HLAEnumeratedDataType* getEnumeratedDataType() const
-    { return _enumeratedDataType.get(); }
-    void setEnumeratedDataType(HLAEnumeratedDataType* dataType);
-
-    bool addAlternative(const std::string& name, const std::string& enumerator,
-                        const HLADataType* dataType, const std::string& semantics);
-
-    unsigned getNumAlternatives() const
-    { return _alternativeList.size(); }
-
-    unsigned getAlternativeIndex(const std::string& enumerator) const
-    {
-        if (!_enumeratedDataType.valid())
-            return ~unsigned(0);
-        return _enumeratedDataType->getIndex(enumerator);
-    }
-
-    const HLADataType* getAlternativeDataType(unsigned index) const
-    {
-        if (_alternativeList.size() <= index)
-            return 0;
-        return _alternativeList[index]._dataType.get();
-    }
-    const HLADataType* getAlternativeDataType(const std::string& enumerator) const
-    { return getAlternativeDataType(getAlternativeIndex(enumerator)); }
-
-    std::string getAlternativeName(unsigned index) const
-    {
-        if (_alternativeList.size() <= index)
-            return std::string();
-        return _alternativeList[index]._name;
-    }
-    std::string getAlternativeName(const std::string& enumerator) const
-    { return getAlternativeName(getAlternativeIndex(enumerator)); }
-
-    std::string getAlternativeSemantics(unsigned index) const
-    {
-        if (_alternativeList.size() <= index)
-            return std::string();
-        return _alternativeList[index]._semantics;
-    }
-    std::string getAlternativeSemantics(const std::string& enumerator) const
-    { return getAlternativeSemantics(getAlternativeIndex(enumerator)); }
-
-private:
-    SGSharedPtr<HLAEnumeratedDataType> _enumeratedDataType;
-
-    struct Alternative {
-        std::string _name;
-        SGSharedPtr<const HLADataType> _dataType;
-        std::string _semantics;
-    };
-
-    typedef std::vector<Alternative> AlternativeList;
-    AlternativeList _alternativeList;
-};
+typedef HLAVariantRecordDataType HLAVariantDataType;
 
 } // namespace simgear
 

simgear/hla/HLAVariantRecordDataElement.cxx

@@ -0,0 +1,190 @@
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "HLAVariantRecordDataElement.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+
+namespace simgear {
+
+HLAAbstractVariantRecordDataElement::HLAAbstractVariantRecordDataElement(const HLAVariantRecordDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLAAbstractVariantRecordDataElement::~HLAAbstractVariantRecordDataElement()
+{
+}
+
+void
+HLAAbstractVariantRecordDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLAAbstractVariantRecordDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAAbstractVariantRecordDataElement::decode(HLADecodeStream& stream)
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->decode(stream, *this);
+}
+
+bool
+HLAAbstractVariantRecordDataElement::encode(HLAEncodeStream& stream) const
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->encode(stream, *this);
+}
+
+const HLAVariantRecordDataType*
+HLAAbstractVariantRecordDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLAAbstractVariantRecordDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAVariantRecordDataType* variantRecordDataType = dataType->toVariantRecordDataType();
+    if (!variantRecordDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantRecordDataType: unable to set data type!");
+        return false;
+    }
+    setDataType(variantRecordDataType);
+    return true;
+}
+
+void
+HLAAbstractVariantRecordDataElement::setDataType(const HLAVariantRecordDataType* dataType)
+{
+    _dataType = dataType;
+}
+
+std::string
+HLAAbstractVariantRecordDataElement::getAlternativeName() const
+{
+    if (!_dataType.valid())
+        return std::string();
+    return _dataType->getAlternativeName(getAlternativeIndex());
+}
+
+const HLADataType*
+HLAAbstractVariantRecordDataElement::getAlternativeDataType() const
+{
+    if (!_dataType.valid())
+        return 0;
+    return _dataType->getAlternativeDataType(getAlternativeIndex());
+}
+
+
+HLAVariantRecordDataElement::DataElementFactory::~DataElementFactory()
+{
+}
+
+HLAVariantRecordDataElement::HLAVariantRecordDataElement(const HLAVariantRecordDataType* dataType) :
+    HLAAbstractVariantRecordDataElement(dataType),
+    _alternativeIndex(~0u)
+{
+}
+
+HLAVariantRecordDataElement::~HLAVariantRecordDataElement()
+{
+    clearStamp();
+}
+
+bool
+HLAVariantRecordDataElement::setAlternativeIndex(unsigned index)
+{
+    if (_alternativeIndex == index)
+        return true;
+    SGSharedPtr<HLADataElement> dataElement = newElement(index);
+    if (!dataElement.valid())
+        return false;
+    _dataElement.swap(dataElement);
+    _alternativeIndex = index;
+    setDirty(true);
+    return true;
+}
+
+bool
+HLAVariantRecordDataElement::decodeAlternative(HLADecodeStream& stream)
+{
+    return _dataElement->decode(stream);
+}
+
+unsigned
+HLAVariantRecordDataElement::getAlternativeIndex() const
+{
+    return _alternativeIndex;
+}
+
+bool
+HLAVariantRecordDataElement::encodeAlternative(HLAEncodeStream& stream) const
+{
+    return _dataElement->encode(stream);
+}
+
+void
+HLAVariantRecordDataElement::setDataElementFactory(HLAVariantRecordDataElement::DataElementFactory* dataElementFactory)
+{
+    _dataElementFactory = dataElementFactory;
+}
+
+HLAVariantRecordDataElement::DataElementFactory*
+HLAVariantRecordDataElement::getDataElementFactory()
+{
+    return _dataElementFactory;
+}
+
+void
+HLAVariantRecordDataElement::_setStamp(Stamp* stamp)
+{
+    HLAAbstractVariantRecordDataElement::_setStamp(stamp);
+    if (!_dataElement.valid())
+        return;
+    _dataElement->attachStamp(*this);
+}
+
+HLADataElement*
+HLAVariantRecordDataElement::newElement(unsigned index)
+{
+    if (!_dataElementFactory.valid())
+        return 0;
+    HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
+    if (!dataElement)
+        return 0;
+    dataElement->attachStamp(*this);
+    return dataElement;
+}
+
+}

simgear/hla/HLAVariantRecordDataElement.hxx

@@ -0,0 +1,88 @@
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAVariantRecordDataElement_hxx
+#define HLAVariantRecordDataElement_hxx
+
+#include <string>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataElement.hxx"
+#include "HLAVariantRecordDataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractVariantRecordDataElement : public HLADataElement {
+public:
+    HLAAbstractVariantRecordDataElement(const HLAVariantRecordDataType* dataType);
+    virtual ~HLAAbstractVariantRecordDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAVariantRecordDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLAVariantRecordDataType* dataType);
+
+    std::string getAlternativeName() const;
+    const HLADataType* getAlternativeDataType() const;
+
+    virtual bool setAlternativeIndex(unsigned index) = 0;
+    virtual bool decodeAlternative(HLADecodeStream& stream) = 0;
+    virtual unsigned getAlternativeIndex() const = 0;
+    virtual bool encodeAlternative(HLAEncodeStream& stream) const = 0;
+
+private:
+    SGSharedPtr<const HLAVariantRecordDataType> _dataType;
+};
+
+class HLAVariantRecordDataElement : public HLAAbstractVariantRecordDataElement {
+public:
+    HLAVariantRecordDataElement(const HLAVariantRecordDataType* dataType);
+    virtual ~HLAVariantRecordDataElement();
+
+    virtual bool setAlternativeIndex(unsigned index);
+    virtual bool decodeAlternative(HLADecodeStream& stream);
+    virtual unsigned getAlternativeIndex() const;
+    virtual bool encodeAlternative(HLAEncodeStream& stream) const;
+
+    class DataElementFactory : public SGReferenced {
+    public:
+        virtual ~DataElementFactory();
+        virtual HLADataElement* createElement(const HLAVariantRecordDataElement&, unsigned) = 0;
+    };
+
+    void setDataElementFactory(DataElementFactory* dataElementFactory);
+    DataElementFactory* getDataElementFactory();
+
+protected:
+    virtual void _setStamp(Stamp* stamp);
+
+private:
+    HLADataElement* newElement(unsigned index);
+
+    SGSharedPtr<HLADataElement> _dataElement;
+    unsigned _alternativeIndex;
+
+    SGSharedPtr<DataElementFactory> _dataElementFactory;
+};
+
+}
+
+#endif

simgear/hla/HLAVariantRecordDataType.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,36 +15,49 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
-#include "HLAVariantDataType.hxx"
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "HLAVariantRecordDataType.hxx"
 
 #include "HLADataTypeVisitor.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 
 namespace simgear {
 
-HLAVariantDataType::HLAVariantDataType(const std::string& name) :
+HLAVariantRecordDataType::HLAVariantRecordDataType(const std::string& name) :
     HLADataType(name)
 {
 }
 
-HLAVariantDataType::~HLAVariantDataType()
+HLAVariantRecordDataType::~HLAVariantRecordDataType()
 {
 }
 
 void
-HLAVariantDataType::accept(HLADataTypeVisitor& visitor) const
+HLAVariantRecordDataType::accept(HLADataTypeVisitor& visitor) const
 {
     visitor.apply(*this);
 }
 
-const HLAVariantDataType*
-HLAVariantDataType::toVariantDataType() const
+const HLAVariantRecordDataType*
+HLAVariantRecordDataType::toVariantRecordDataType() const
 {
     return this;
 }
 
+void
+HLAVariantRecordDataType::releaseDataTypeReferences()
+{
+    for (AlternativeList::iterator i = _alternativeList.begin(); i != _alternativeList.end(); ++i)
+        i->_dataType = 0;
+}
+
 bool
-HLAVariantDataType::decode(HLADecodeStream& stream, HLAAbstractVariantDataElement& value) const
+HLAVariantRecordDataType::decode(HLADecodeStream& stream, HLAAbstractVariantRecordDataElement& value) const
 {
     if (!stream.alignOffsetForSize(getAlignment()))
         return false;
@@ -61,7 +74,7 @@ HLAVariantDataType::decode(HLADecodeStream& stream, HLAAbstractVariantDataElemen
 }
 
 bool
-HLAVariantDataType::encode(HLAEncodeStream& stream, const HLAAbstractVariantDataElement& value) const
+HLAVariantRecordDataType::encode(HLAEncodeStream& stream, const HLAAbstractVariantRecordDataElement& value) const
 {
     if (!stream.alignOffsetForSize(getAlignment()))
         return false;
@@ -76,14 +89,14 @@ HLAVariantDataType::encode(HLAEncodeStream& stream, const HLAAbstractVariantData
 }
 
 void
-HLAVariantDataType::setEnumeratedDataType(HLAEnumeratedDataType* dataType)
+HLAVariantRecordDataType::setEnumeratedDataType(HLAEnumeratedDataType* dataType)
 {
     _enumeratedDataType = dataType;
 }
 
 bool
-HLAVariantDataType::addAlternative(const std::string& name, const std::string& enumerator,
-                                   const HLADataType* dataType, const std::string& semantics)
+HLAVariantRecordDataType::addAlternative(const std::string& name, const std::string& enumerator,
+                                         const HLADataType* dataType, const std::string& semantics)
 {
     if (!_enumeratedDataType.valid())
         return false;
@@ -94,8 +107,20 @@ HLAVariantDataType::addAlternative(const std::string& name, const std::string& e
     _alternativeList[index]._name = name;
     _alternativeList[index]._dataType = dataType;
     _alternativeList[index]._semantics = semantics;
-    setAlignment(SGMisc<unsigned>::max(getAlignment(), dataType->getAlignment()));
     return true;
 }
 
+void
+HLAVariantRecordDataType::_recomputeAlignmentImplementation()
+{
+    unsigned alignment = 1;
+    if (const HLADataType* dataType = getEnumeratedDataType())
+        alignment = std::max(alignment, dataType->getAlignment());
+    for (unsigned i = 0; i < getNumAlternatives(); ++i) {
+        if (const HLADataType* dataType = getAlternativeDataType(i))
+            alignment = std::max(alignment, dataType->getAlignment());
+    }
+    setAlignment(alignment);
+}
+
 } // namespace simgear

simgear/hla/HLAVariantRecordDataType.hxx

@@ -0,0 +1,107 @@
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAVariantRecordDataType_hxx
+#define HLAVariantRecordDataType_hxx
+
+#include <string>
+#include <vector>
+#include "simgear/structure/SGSharedPtr.hxx"
+#include "HLADataType.hxx"
+#include "HLAEnumeratedDataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractVariantRecordDataElement;
+
+class HLAVariantRecordDataType : public HLADataType {
+public:
+    HLAVariantRecordDataType(const std::string& name = "HLAVariantRecordDataType");
+    virtual ~HLAVariantRecordDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLAVariantRecordDataType* toVariantRecordDataType() const;
+
+    virtual void releaseDataTypeReferences();
+    
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractVariantRecordDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractVariantRecordDataElement& value) const;
+
+    const HLAEnumeratedDataType* getEnumeratedDataType() const
+    { return _enumeratedDataType.get(); }
+    void setEnumeratedDataType(HLAEnumeratedDataType* dataType);
+
+    bool addAlternative(const std::string& name, const std::string& enumerator,
+                        const HLADataType* dataType, const std::string& semantics);
+
+    unsigned getNumAlternatives() const
+    { return _alternativeList.size(); }
+
+    unsigned getAlternativeIndex(const std::string& enumerator) const
+    {
+        if (!_enumeratedDataType.valid())
+            return ~unsigned(0);
+        return _enumeratedDataType->getIndex(enumerator);
+    }
+
+    const HLADataType* getAlternativeDataType(unsigned index) const
+    {
+        if (_alternativeList.size() <= index)
+            return 0;
+        return _alternativeList[index]._dataType.get();
+    }
+    const HLADataType* getAlternativeDataType(const std::string& enumerator) const
+    { return getAlternativeDataType(getAlternativeIndex(enumerator)); }
+
+    std::string getAlternativeName(unsigned index) const
+    {
+        if (_alternativeList.size() <= index)
+            return std::string();
+        return _alternativeList[index]._name;
+    }
+    std::string getAlternativeName(const std::string& enumerator) const
+    { return getAlternativeName(getAlternativeIndex(enumerator)); }
+
+    std::string getAlternativeSemantics(unsigned index) const
+    {
+        if (_alternativeList.size() <= index)
+            return std::string();
+        return _alternativeList[index]._semantics;
+    }
+    std::string getAlternativeSemantics(const std::string& enumerator) const
+    { return getAlternativeSemantics(getAlternativeIndex(enumerator)); }
+
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
+private:
+    SGSharedPtr<HLAEnumeratedDataType> _enumeratedDataType;
+
+    struct Alternative {
+        std::string _name;
+        SGSharedPtr<const HLADataType> _dataType;
+        std::string _semantics;
+    };
+
+    typedef std::vector<Alternative> AlternativeList;
+    AlternativeList _alternativeList;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/RTI13Ambassador.hxx

@@ -71,11 +71,22 @@ public:
     { _rtiAmbassador.publishObjectClass(handle, attributeHandleSet); }
     void unpublishObjectClass(const RTI::ObjectClassHandle& handle)
     { _rtiAmbassador.unpublishObjectClass(handle); }
+
+    void publishInteractionClass(const RTI::InteractionClassHandle& handle)
+    { _rtiAmbassador.publishInteractionClass(handle); }
+    void unpublishInteractionClass(const RTI::InteractionClassHandle& handle)
+    { _rtiAmbassador.unpublishInteractionClass(handle); }
+
     void subscribeObjectClassAttributes(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet, bool active)
     { _rtiAmbassador.subscribeObjectClassAttributes(handle, attributeHandleSet, active ? RTI::RTI_TRUE : RTI::RTI_FALSE); }
     void unsubscribeObjectClass(const RTI::ObjectClassHandle& handle)
     { _rtiAmbassador.unsubscribeObjectClass(handle); }
 
+    void subscribeInteractionClass(const RTI::InteractionClassHandle& handle, bool active)
+    { _rtiAmbassador.subscribeInteractionClass(handle, active ? RTI::RTI_TRUE : RTI::RTI_FALSE); }
+    void unsubscribeInteractionClass(const RTI::InteractionClassHandle& handle)
+    { _rtiAmbassador.unsubscribeInteractionClass(handle); }
+
     RTI::ObjectHandle registerObjectInstance(const RTI::ObjectClassHandle& handle)
     { return _rtiAmbassador.registerObjectInstance(handle); }
     void updateAttributeValues(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandleValuePairSet& attributeValues,
@@ -264,20 +275,8 @@ public:
     //     }
     //     return false;
     // }
-    // bool isAttributeOwnedByFederate(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
-    // {
-    //     try {
-    //         return _rtiAmbassador.isAttributeOwnedByFederate(objectHandle, attributeHandle);
-    //     } catch (RTI::ObjectNotKnown& e) {
-    //     } catch (RTI::AttributeNotDefined& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::SaveInProgress& e) {
-    //     } catch (RTI::RestoreInProgress& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return false;
-    // }
+    bool isAttributeOwnedByFederate(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandle& attributeHandle)
+    { return _rtiAmbassador.isAttributeOwnedByFederate(objectHandle, attributeHandle); }
 
     /// Time Management
 
@@ -347,55 +346,15 @@ public:
     std::string getAttributeName(const RTI::AttributeHandle& attributeHandle, const RTI::ObjectClassHandle& objectClassHandle)
     { return rtiToStdString(_rtiAmbassador.getAttributeName(attributeHandle, objectClassHandle)); }
 
-    // RTIHandle getInteractionClassHandle(const std::string& name)
-    // {
-    //     try {
-    //         return _rtiAmbassador.getInteractionClassHandle(name.c_str());
-    //     } catch (RTI::NameNotFound& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return RTIHandle(-1);
-    // }
-    // std::string getInteractionClassName(const RTIHandle& handle)
-    // {
-    //     std::string name;
-    //     try {
-    //         rtiToStdString(name, _rtiAmbassador.getInteractionClassName(handle));
-    //     } catch (RTI::InteractionClassNotDefined& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return name;
-    // }
+    RTI::InteractionClassHandle getInteractionClassHandle(const std::string& name)
+    { return _rtiAmbassador.getInteractionClassHandle(name.c_str()); }
+    std::string getInteractionClassName(const RTI::InteractionClassHandle& handle)
+    { return rtiToStdString(_rtiAmbassador.getInteractionClassName(handle)); }
 
-    // RTIHandle getParameterHandle(const std::string& parameterName, const RTIHandle& interactionClassHandle)
-    // {
-    //     try {
-    //         return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle);
-    //     } catch (RTI::InteractionClassNotDefined& e) {
-    //     } catch (RTI::NameNotFound& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return RTIHandle(-1);
-    // }
-    // std::string getParameterName(const RTIHandle& parameterHandle, const RTIHandle& interactionClassHandle)
-    // {
-    //     std::string parameterName;
-    //     try {
-    //         rtiToStdString(parameterName, _rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle));
-    //     } catch (RTI::InteractionClassNotDefined& e) {
-    //     } catch (RTI::InteractionParameterNotDefined& e) {
-    //     } catch (RTI::FederateNotExecutionMember& e) {
-    //     } catch (RTI::ConcurrentAccessAttempted& e) {
-    //     } catch (RTI::RTIinternalError& e) {
-    //     }
-    //     return parameterName;
-    // }
+    RTI::ParameterHandle getParameterHandle(const std::string& parameterName, const RTI::InteractionClassHandle& interactionClassHandle)
+    { return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle); }
+    std::string getParameterName(const RTI::ParameterHandle& parameterHandle, const RTI::InteractionClassHandle& interactionClassHandle)
+    { return rtiToStdString(_rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle)); }
 
     RTI::ObjectHandle getObjectInstanceHandle(const std::string& name)
     { return _rtiAmbassador.getObjectInstanceHandle(name.c_str()); }

simgear/hla/RTI13Federate.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "RTI13Federate.hxx"
 
 #include "RTI13Ambassador.hxx"
@@ -222,7 +228,7 @@ struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador {
             return;
         if (!i->second.valid())
             return;
-        SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, _rtiAmbassador.get(), false);
+        SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, _rtiAmbassador.get());
         _objectInstanceMap[objectHandle] = objectInstance;
         i->second->discoverInstance(objectInstance.get(), tag);
     }
@@ -278,7 +284,7 @@ struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador {
             return;
         if (!i->second.valid())
             return;
-        i->second->reflectAttributeValues(attributeHandleDataPairList, timeStamp, tag);
+        i->second->reflectAttributeValues(attributeHandleDataPairList, timeStamp, tag, _indexPool);
     }
 
     class ReflectAttributeValuesCallback : public TagQueueCallback {
@@ -327,7 +333,7 @@ struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador {
             return;
         if (!i->second.valid())
             return;
-        i->second->reflectAttributeValues(attributeHandleDataPairList, tag);
+        i->second->reflectAttributeValues(attributeHandleDataPairList, tag, _indexPool);
     }
 
     virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters,
@@ -855,6 +861,9 @@ struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador {
     void freeAttributeHandleDataPairList(RTI13AttributeHandleDataPairList& attributeHandleDataPairList)
     { _attributeHandleDataPairPool.splice(_attributeHandleDataPairPool.end(), attributeHandleDataPairList); }
 
+    // For attribute reflection, pool or indices
+    HLAIndexList _indexPool;
+
     // Top level information for dispatching federate object attribute updates
     typedef std::map<RTI::ObjectHandle, SGSharedPtr<RTI13ObjectInstance> > ObjectInstanceMap;
     // Map of all available objects
@@ -864,6 +873,10 @@ struct RTI13Federate::FederateAmbassador : public RTI::FederateAmbassador {
     typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
     ObjectClassMap _objectClassMap;
 
+    // Top level information for dispatching creation of federate objects
+    typedef std::map<RTI::InteractionClassHandle, SGSharedPtr<RTI13InteractionClass> > InteractionClassMap;
+    InteractionClassMap _interactionClassMap;
+
     bool _timeRegulationEnabled;
     bool _timeConstrainedEnabled;
     bool _timeAdvancePending;
@@ -1602,6 +1615,35 @@ RTI13Federate::createObjectClass(const std::string& objectClassName, HLAObjectCl
     }
 }
 
+RTI13InteractionClass*
+RTI13Federate::createInteractionClass(const std::string& interactionClassName, HLAInteractionClass* interactionClass)
+{
+    try {
+        RTI::InteractionClassHandle interactionClassHandle;
+        interactionClassHandle = _ambassador->getInteractionClassHandle(interactionClassName);
+        if (_federateAmbassador->_interactionClassMap.find(interactionClassHandle) != _federateAmbassador->_interactionClassMap.end()) {
+            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create interaction class, interaction class already exists!");
+            return 0;
+        }
+        RTI13InteractionClass* rtiInteractionClass;
+        rtiInteractionClass = new RTI13InteractionClass(interactionClass, interactionClassHandle, _ambassador.get());
+        _federateAmbassador->_interactionClassMap[interactionClassHandle] = rtiInteractionClass;
+        return rtiInteractionClass;
+    } catch (RTI::NameNotFound& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class: " << e._name << " " << e._reason);
+        return 0;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class: " << e._name << " " << e._reason);
+        return 0;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class: " << e._name << " " << e._reason);
+        return 0;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class: " << e._name << " " << e._reason);
+        return 0;
+    }
+}
+
 RTI13ObjectInstance*
 RTI13Federate::getObjectInstance(const std::string& objectInstanceName)
 {

simgear/hla/RTI13Federate.hxx

@@ -25,6 +25,7 @@
 #include <RTI.hh>
 
 #include "RTIFederate.hxx"
+#include "RTI13InteractionClass.hxx"
 #include "RTI13ObjectClass.hxx"
 #include "RTI13ObjectInstance.hxx"
 
@@ -78,6 +79,7 @@ public:
     virtual bool processMessages(const double& minimum, const double& maximum);
 
     virtual RTI13ObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass);
+    virtual RTI13InteractionClass* createInteractionClass(const std::string& name, HLAInteractionClass* interactionClass);
 
     virtual RTI13ObjectInstance* getObjectInstance(const std::string& name);
     void insertObjectInstance(RTI13ObjectInstance* objectInstance);

simgear/hla/RTI13FederateFactory.cxx

@@ -0,0 +1,55 @@
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "RTI13FederateFactory.hxx"
+
+#include "RTI13Federate.hxx"
+
+namespace simgear {
+
+RTI13FederateFactory::RTI13FederateFactory()
+{
+    _registerAtFactory();
+}
+
+RTI13FederateFactory::~RTI13FederateFactory()
+{
+}
+
+RTIFederate*
+RTI13FederateFactory::create(const std::string& name, const std::list<std::string>& stringList) const
+{
+    if (name != "RTI13")
+        return 0;
+    return new RTI13Federate(stringList);
+}
+
+const SGSharedPtr<RTI13FederateFactory>&
+RTI13FederateFactory::instance()
+{
+    static SGSharedPtr<RTI13FederateFactory> federateFactory = new RTI13FederateFactory;
+    return federateFactory;
+}
+
+}
+

simgear/hla/RTI13FederateFactory.hxx

@@ -0,0 +1,39 @@
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef RTI13FederateFactory_hxx
+#define RTI13FederateFactory_hxx
+
+#include "RTIFederateFactory.hxx"
+
+#include "simgear/structure/SGSharedPtr.hxx"
+
+namespace simgear {
+
+class RTI13FederateFactory : public RTIFederateFactory {
+public:
+    RTI13FederateFactory();
+    virtual ~RTI13FederateFactory();
+
+    virtual RTIFederate* create(const std::string& name, const std::list<std::string>& stringList) const;
+
+    static const SGSharedPtr<RTI13FederateFactory>& instance();
+};
+
+}
+
+#endif

simgear/hla/RTI13InteractionClass.cxx

@@ -0,0 +1,245 @@
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "RTI13InteractionClass.hxx"
+
+#include "RTI13Ambassador.hxx"
+
+namespace simgear {
+
+RTI13InteractionClass::RTI13InteractionClass(HLAInteractionClass* interactionClass, const RTI::InteractionClassHandle& handle, RTI13Ambassador* ambassador) :
+    RTIInteractionClass(interactionClass),
+    _handle(handle),
+    _ambassador(ambassador)
+{
+}
+
+RTI13InteractionClass::~RTI13InteractionClass()
+{
+}
+
+bool
+RTI13InteractionClass::resolveParameterIndex(const std::string& name, unsigned index)
+{
+    if (!_ambassador.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
+        return false;
+    }
+
+    if (index != _parameterHandleVector.size()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Resolving needs to happen in growing index order!");
+        return false;
+    }
+
+    try {
+        RTI::ParameterHandle parameterHandle = _ambassador->getParameterHandle(name, _handle);
+
+        ParameterHandleIndexMap::const_iterator i = _parameterHandleIndexMap.find(parameterHandle);
+        if (i != _parameterHandleIndexMap.end()) {
+            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Resolving parameterIndex for parameter \"" << name << "\" twice!");
+            return false;
+        }
+
+        _parameterHandleIndexMap[parameterHandle] = index;
+        _parameterHandleVector.push_back(parameterHandle);
+
+        return true;
+
+    } catch (RTI::NameNotFound& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class parameter: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class parameter: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class parameter: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class parameter: " << e._name << " " << e._reason);
+        return false;
+    } catch (...) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get interaction class parameter.");
+        return false;
+    }
+
+    return false;
+}
+
+bool
+RTI13InteractionClass::publish()
+{
+    if (!_ambassador.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
+        return false;
+    }
+
+    try {
+        _ambassador->publishInteractionClass(_handle);
+        return true;
+    } catch (RTI::InteractionClassNotDefined& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::SaveInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RestoreInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (...) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish interaction class.");
+        return false;
+    }
+
+    return false;
+}
+
+bool
+RTI13InteractionClass::unpublish()
+{
+    if (!_ambassador.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
+        return false;
+    }
+
+    try {
+        _ambassador->unpublishInteractionClass(_handle);
+        return true;
+    } catch (RTI::InteractionClassNotDefined& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::InteractionClassNotPublished& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::SaveInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RestoreInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (...) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish interaction class.");
+        return false;
+    }
+
+    return false;
+}
+
+bool
+RTI13InteractionClass::subscribe(bool active)
+{
+    if (!_ambassador.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
+        return false;
+    }
+
+    try {
+        _ambassador->subscribeInteractionClass(_handle, active);
+        return true;
+    } catch (RTI::InteractionClassNotDefined& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateLoggingServiceCalls& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::SaveInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RestoreInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (...) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe interaction class.");
+        return false;
+    }
+
+    return false;
+}
+
+bool
+RTI13InteractionClass::unsubscribe()
+{
+    if (!_ambassador.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
+        return false;
+    }
+
+    try {
+        _ambassador->unsubscribeInteractionClass(_handle);
+        return true;
+    } catch (RTI::InteractionClassNotDefined& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::InteractionClassNotSubscribed& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::SaveInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RestoreInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class: " << e._name << " " << e._reason);
+        return false;
+    } catch (...) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe interaction class.");
+        return false;
+    }
+
+    return false;
+}
+
+}

simgear/hla/RTI13InteractionClass.hxx

@@ -0,0 +1,64 @@
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef RTI13InteractionClass_hxx
+#define RTI13InteractionClass_hxx
+
+#include <map>
+#include <vector>
+
+#ifndef RTI_USES_STD_FSTREAM
+#define RTI_USES_STD_FSTREAM
+#endif
+
+#include <RTI.hh>
+
+#include "RTIInteractionClass.hxx"
+
+#include <simgear/structure/SGSharedPtr.hxx>
+
+namespace simgear {
+
+class RTI13Ambassador;
+
+class RTI13InteractionClass : public RTIInteractionClass {
+public:
+    RTI13InteractionClass(HLAInteractionClass* interactionClass, const RTI::InteractionClassHandle& handle, RTI13Ambassador* ambassador);
+    virtual ~RTI13InteractionClass();
+
+    virtual bool resolveParameterIndex(const std::string& name, unsigned index);
+
+    virtual bool publish();
+    virtual bool unpublish();
+
+    virtual bool subscribe(bool);
+    virtual bool unsubscribe();
+
+private:
+    RTI::InteractionClassHandle _handle;
+    SGSharedPtr<RTI13Ambassador> _ambassador;
+
+    typedef std::map<RTI::ParameterHandle, unsigned> ParameterHandleIndexMap;
+    ParameterHandleIndexMap _parameterHandleIndexMap;
+
+    typedef std::vector<RTI::ParameterHandle> ParameterHandleVector;
+    ParameterHandleVector _parameterHandleVector;
+};
+
+}
+
+#endif

simgear/hla/RTI13ObjectClass.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,33 +15,74 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "RTI13ObjectClass.hxx"
 #include "RTI13Ambassador.hxx"
 
 namespace simgear {
 
-RTI13ObjectClass::RTI13ObjectClass(HLAObjectClass* hlaObjectClass, RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador) :
+RTI13ObjectClass::RTI13ObjectClass(HLAObjectClass* hlaObjectClass, const RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador) :
     RTIObjectClass(hlaObjectClass),
     _handle(handle),
     _ambassador(ambassador)
 {
-    if (0 != getOrCreateAttributeIndex("privilegeToDelete") &&
-        0 != getOrCreateAttributeIndex("HLAprivilegeToDeleteObject"))
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass: Cannot find object root attribute.");
 }
 
 RTI13ObjectClass::~RTI13ObjectClass()
 {
 }
 
-std::string
-RTI13ObjectClass::getName() const
+bool
+RTI13ObjectClass::resolveAttributeIndex(const std::string& name, unsigned index)
 {
     if (!_ambassador.valid()) {
         SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
-        return std::string();
+        return false;
+    }
+
+    if (index != _attributeHandleVector.size()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Resolving needs to happen in growing index order!");
+        return false;
+    }
+
+    try {
+        RTI::AttributeHandle attributeHandle = _ambassador->getAttributeHandle(name, _handle);
+
+        AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle);
+        if (i != _attributeHandleIndexMap.end()) {
+            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Resolving attributeIndex for attribute \"" << name << "\" twice!");
+            return false;
+        }
+
+        _attributeHandleIndexMap[attributeHandle] = index;
+        _attributeHandleVector.push_back(attributeHandle);
+
+        return true;
+
+    } catch (RTI::ObjectClassNotDefined& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::NameNotFound& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
+        return false;
+    } catch (...) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute.");
+        return false;
     }
-    return _ambassador->getObjectClassName(_handle);
 }
 
 unsigned
@@ -50,121 +91,8 @@ RTI13ObjectClass::getNumAttributes() const
     return _attributeHandleVector.size();
 }
 
-unsigned
-RTI13ObjectClass::getAttributeIndex(const std::string& name) const
-{
-    if (!_ambassador.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
-        return ~0u;
-    }
-
-    try {
-        RTI::AttributeHandle attributeHandle = _ambassador->getAttributeHandle(name, _handle);
-
-        AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle);
-        if (i !=  _attributeHandleIndexMap.end())
-            return i->second;
-
-        return ~0u;
-
-    } catch (RTI::ObjectClassNotDefined& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::NameNotFound& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::FederateNotExecutionMember& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::ConcurrentAccessAttempted& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::RTIinternalError& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (...) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute.");
-        return ~0u;
-    }
-}
-
-unsigned
-RTI13ObjectClass::getOrCreateAttributeIndex(const std::string& name)
-{
-    if (!_ambassador.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
-        return ~0u;
-    }
-
-    try {
-        RTI::AttributeHandle attributeHandle = _ambassador->getAttributeHandle(name, _handle);
-
-        AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle);
-        if (i !=  _attributeHandleIndexMap.end())
-            return i->second;
-
-        unsigned index = _attributeHandleVector.size();
-        _attributeHandleIndexMap[attributeHandle] = index;
-        _attributeHandleVector.push_back(attributeHandle);
-        _attributeDataVector.push_back(name);
-
-        return index;
-
-    } catch (RTI::ObjectClassNotDefined& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::NameNotFound& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::FederateNotExecutionMember& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::ConcurrentAccessAttempted& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (RTI::RTIinternalError& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
-        return ~0u;
-    } catch (...) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute.");
-        return ~0u;
-    }
-}
-
-// std::string
-// RTI13ObjectClass::getAttributeName(unsigned index) const
-// {
-//     SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
-//     if (!ambassador.valid()) {
-//         SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
-//         return std::string();
-//     }
-
-//     try {
-//         return ambassador->getAttributeName(getAttributeHandle(index), _handle);
-//     } catch (RTI::ObjectClassNotDefined& e) {
-//         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
-//         return std::string();
-//     } catch (RTI::AttributeNotDefined& e) {
-//         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
-//         return std::string();
-//     } catch (RTI::FederateNotExecutionMember& e) {
-//         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
-//         return std::string();
-//     } catch (RTI::ConcurrentAccessAttempted& e) {
-//         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
-//         return std::string();
-//     } catch (RTI::RTIinternalError& e) {
-//         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
-//         return std::string();
-//     } catch (...) {
-//         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name.");
-//         return std::string();
-//     }
-// }
-
 bool
-RTI13ObjectClass::publish(const std::set<unsigned>& indexSet)
+RTI13ObjectClass::publish(const HLAIndexList& indexList)
 {
     if (!_ambassador.valid()) {
         SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
@@ -172,8 +100,9 @@ RTI13ObjectClass::publish(const std::set<unsigned>& indexSet)
     }
 
     try {
-        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(indexSet.size()));
-        for (std::set<unsigned>::const_iterator i = indexSet.begin(); i != indexSet.end(); ++i) {
+        unsigned numAttributes = getNumAttributes();
+        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
+        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
             if (_attributeHandleVector.size() <= *i) {
                 SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass::publish(): Invalid attribute index!");
                 continue;
@@ -183,10 +112,6 @@ RTI13ObjectClass::publish(const std::set<unsigned>& indexSet)
 
         _ambassador->publishObjectClass(_handle, *attributeHandleSet);
 
-        for (unsigned i = 0; i < getNumAttributes(); ++i) {
-            _attributeDataVector[i]._published = true;
-        }
-
         return true;
     } catch (RTI::ObjectClassNotDefined& e) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not publish object class: " << e._name << " " << e._reason);
@@ -229,10 +154,6 @@ RTI13ObjectClass::unpublish()
     try {
         _ambassador->unpublishObjectClass(_handle);
 
-        for (unsigned i = 0; i < getNumAttributes(); ++i) {
-            _attributeDataVector[i]._published = false;
-        }
-
         return true;
     } catch (RTI::ObjectClassNotDefined& e) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unpublish object class: " << e._name << " " << e._reason);
@@ -265,7 +186,7 @@ RTI13ObjectClass::unpublish()
 }
 
 bool
-RTI13ObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
+RTI13ObjectClass::subscribe(const HLAIndexList& indexList, bool active)
 {
     if (!_ambassador.valid()) {
         SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
@@ -273,9 +194,9 @@ RTI13ObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
     }
 
     try {
-        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(indexSet.size()));
-        for (std::set<unsigned>::const_iterator i = indexSet.begin();
-             i != indexSet.end(); ++i) {
+        unsigned numAttributes = getNumAttributes();
+        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
+        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
             if (_attributeHandleVector.size() <= *i) {
                 SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass::subscribe(): Invalid attribute index!");
                 continue;
@@ -285,10 +206,6 @@ RTI13ObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
 
         _ambassador->subscribeObjectClassAttributes(_handle, *attributeHandleSet, active);
 
-        for (unsigned i = 0; i < getNumAttributes(); ++i) {
-            _attributeDataVector[i]._subscribed = true;
-        }
-
         return true;
     } catch (RTI::ObjectClassNotDefined& e) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not subscribe object class: " << e._name << " " << e._reason);
@@ -328,10 +245,6 @@ RTI13ObjectClass::unsubscribe()
     try {
         _ambassador->unsubscribeObjectClass(_handle);
 
-        for (unsigned i = 0; i < getNumAttributes(); ++i) {
-            _attributeDataVector[i]._subscribed = false;
-        }
-
         return true;
     } catch (RTI::ObjectClassNotDefined& e) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not unsubscribe object class: " << e._name << " " << e._reason);
@@ -376,7 +289,7 @@ RTI13ObjectClass::registerObjectInstance(HLAObjectInstance* hlaObjectInstance)
 
     try {
         RTI::ObjectHandle objectHandle = _ambassador->registerObjectInstance(getHandle());
-        RTI13ObjectInstance* objectInstance = new RTI13ObjectInstance(objectHandle, hlaObjectInstance, this, _ambassador.get(), true);
+        RTI13ObjectInstance* objectInstance = new RTI13ObjectInstance(objectHandle, hlaObjectInstance, this, _ambassador.get());
         federate->insertObjectInstance(objectInstance);
         return objectInstance;
     } catch (RTI::ObjectClassNotDefined& e) {

simgear/hla/RTI13ObjectClass.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -37,17 +37,15 @@ class RTIObjectInstance;
 
 class RTI13ObjectClass : public RTIObjectClass {
 public:
-    RTI13ObjectClass(HLAObjectClass* hlaObjectClass, RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador);
+    RTI13ObjectClass(HLAObjectClass* hlaObjectClass, const RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador);
     virtual ~RTI13ObjectClass();
 
     const RTI::ObjectClassHandle& getHandle() const
     { return _handle; }
 
-    virtual std::string getName() const;
+    virtual bool resolveAttributeIndex(const std::string& name, unsigned index);
 
     virtual unsigned getNumAttributes() const;
-    virtual unsigned getAttributeIndex(const std::string& name) const;
-    virtual unsigned getOrCreateAttributeIndex(const std::string& name);
 
     unsigned getAttributeIndex(const RTI::AttributeHandle& handle) const
     {
@@ -63,10 +61,10 @@ public:
         return _attributeHandleVector[index];
     }
 
-    virtual bool publish(const std::set<unsigned>& indexSet);
+    virtual bool publish(const HLAIndexList& indexList);
     virtual bool unpublish();
 
-    virtual bool subscribe(const std::set<unsigned>& indexSet, bool);
+    virtual bool subscribe(const HLAIndexList& indexList, bool);
     virtual bool unsubscribe();
 
     virtual RTIObjectInstance* registerObjectInstance(HLAObjectInstance* hlaObjectInstance);

simgear/hla/RTI13ObjectInstance.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,20 +15,26 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "RTIObjectInstance.hxx"
 #include "RTI13Ambassador.hxx"
 
 namespace simgear {
 
-RTI13ObjectInstance::RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* hlaObjectInstance,
-                                         const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador, bool owned) :
-    RTIObjectInstance(hlaObjectInstance),
+RTI13ObjectInstance::RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* objectInstance,
+                                         const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador) :
+    RTIObjectInstance(objectInstance),
     _handle(handle),
     _objectClass(objectClass),
     _ambassador(ambassador),
     _attributeValuePairSet(RTI::AttributeSetFactory::create(objectClass->getNumAttributes()))
 {
-    updateAttributesFromClass(owned);
+    _setNumAttributes(getNumAttributes());
 }
 
 RTI13ObjectInstance::~RTI13ObjectInstance()
@@ -177,82 +183,80 @@ RTI13ObjectInstance::localDeleteObjectInstance()
 }
 
 void
-RTI13ObjectInstance::reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList, const RTIData& tag)
+RTI13ObjectInstance::reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
+                                            const RTIData& tag, HLAIndexList& indexPool)
 {
-    // Retrieve an empty update struct from the memory pool
-    RTIIndexDataPairList indexDataPairList;
+    HLAIndexList reflectedIndices;
     for (RTI13AttributeHandleDataPairList::iterator i = attributeHandleDataPairList.begin();
          i != attributeHandleDataPairList.end(); ++i) {
         unsigned index = getAttributeIndex(i->first);
-        // Get a RTIData from the data pool
-        getDataFromPool(indexDataPairList);
-        indexDataPairList.back().first = index;
-        indexDataPairList.back().second.swap(i->second);
+        _attributeData[index]._data.swap(i->second);
+
+        if (indexPool.empty())
+            reflectedIndices.push_back(index);
+        else {
+            reflectedIndices.splice(reflectedIndices.end(), indexPool, indexPool.begin());
+            reflectedIndices.back() = index;
+        }
     }
 
-    RTIObjectInstance::reflectAttributeValues(indexDataPairList, tag);
+    RTIObjectInstance::reflectAttributeValues(reflectedIndices, tag);
 
-    RTIIndexDataPairList::iterator j = indexDataPairList.begin();
-    for (RTI13AttributeHandleDataPairList::iterator i = attributeHandleDataPairList.begin();
-         i != attributeHandleDataPairList.end(); ++i, ++j) {
-        i->second.swap(j->second);
-    }
-
-    // Return the update data back to the pool
-    putDataToPool(indexDataPairList);
+    // Return the index list to the pool
+    indexPool.splice(indexPool.end(), reflectedIndices);
 }
 
 void
 RTI13ObjectInstance::reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
-                                            const SGTimeStamp& timeStamp, const RTIData& tag)
+                                            const SGTimeStamp& timeStamp, const RTIData& tag, HLAIndexList& indexPool)
 {
-    // Retrieve an empty update struct from the memory pool
-    RTIIndexDataPairList indexDataPairList;
+    HLAIndexList reflectedIndices;
     for (RTI13AttributeHandleDataPairList::iterator i = attributeHandleDataPairList.begin();
          i != attributeHandleDataPairList.end(); ++i) {
         unsigned index = getAttributeIndex(i->first);
-        // Get a RTIData from the data pool
-        getDataFromPool(indexDataPairList);
-        indexDataPairList.back().first = index;
-        indexDataPairList.back().second.swap(i->second);
+        _attributeData[index]._data.swap(i->second);
+
+        if (indexPool.empty())
+            reflectedIndices.push_back(index);
+        else {
+            reflectedIndices.splice(reflectedIndices.end(), indexPool, indexPool.begin());
+            reflectedIndices.back() = index;
+        }
     }
 
-    RTIObjectInstance::reflectAttributeValues(indexDataPairList, timeStamp, tag);
+    RTIObjectInstance::reflectAttributeValues(reflectedIndices, timeStamp, tag);
 
-    RTIIndexDataPairList::iterator j = indexDataPairList.begin();
-    for (RTI13AttributeHandleDataPairList::iterator i = attributeHandleDataPairList.begin();
-         i != attributeHandleDataPairList.end(); ++i, ++j) {
-        i->second.swap(j->second);
-    }
-
-    // Return the update data back to the pool
-    putDataToPool(indexDataPairList);
+    // Return the index list to the pool
+    indexPool.splice(indexPool.end(), reflectedIndices);
 }
 
 void
-RTI13ObjectInstance::requestObjectAttributeValueUpdate()
+RTI13ObjectInstance::requestObjectAttributeValueUpdate(const HLAIndexList& indexList)
 {
     if (!_ambassador.valid()) {
         SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
         return;
     }
 
+    if (indexList.empty())
+        return;
+
     try {
         unsigned numAttributes = getNumAttributes();
         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
-        for (unsigned i = 0; i < numAttributes; ++i) {
-            if (!getRequestAttributeUpdate(i))
+        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
+            if (getAttributeOwned(*i)) {
+                SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectInstance::requestObjectAttributeValueUpdate(): "
+                       "Invalid attribute index!");
                 continue;
-            attributeHandleSet->add(getAttributeHandle(i));
+            }
+            attributeHandleSet->add(getAttributeHandle(*i));
         }
         if (!attributeHandleSet->size())
             return;
 
         _ambassador->requestObjectAttributeValueUpdate(_handle, *attributeHandleSet);
 
-        for (unsigned i = 0; i < numAttributes; ++i)
-            setRequestAttributeUpdate(i, false);
-
         return;
     } catch (RTI::ObjectNotKnown& e) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not request attribute update for object instance: " << e._name << " " << e._reason);
@@ -288,7 +292,7 @@ RTI13ObjectInstance::provideAttributeValueUpdate(const std::vector<RTI::Attribut
     size_t numAttribs = attributeHandleSet.size();
     for (RTI::ULong i = 0; i < numAttribs; ++i) {
         unsigned index = getAttributeIndex(attributeHandleSet[i]);
-        setAttributeForceUpdate(index);
+        _attributeData[index]._dirty = true;
     }
 }
 
@@ -306,15 +310,9 @@ RTI13ObjectInstance::updateAttributeValues(const RTIData& tag)
 
         unsigned numAttributes = getNumAttributes();
         for (unsigned i = 0; i < numAttributes; ++i) {
-            if (!getAttributeEffectiveUpdateEnabled(i))
+            if (!_attributeData[i]._dirty)
                 continue;
-            const HLADataElement* dataElement = getDataElement(i);
-            if (!dataElement)
-                continue;
-            // FIXME cache somewhere
-            RTIData data;
-            HLAEncodeStream stream(data);
-            dataElement->encode(stream);
+            const RTIData& data = _attributeData[i]._data;
             _attributeValuePairSet->add(getAttributeHandle(i), data.data(), data.size());
         }
 
@@ -324,7 +322,7 @@ RTI13ObjectInstance::updateAttributeValues(const RTIData& tag)
         _ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, tag);
 
         for (unsigned i = 0; i < numAttributes; ++i) {
-            setAttributeUpdated(i);
+            _attributeData[i]._dirty = false;
         }
 
     } catch (RTI::ObjectNotKnown& e) {
@@ -363,15 +361,9 @@ RTI13ObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const R
 
         unsigned numAttributes = getNumAttributes();
         for (unsigned i = 0; i < numAttributes; ++i) {
-            if (!getAttributeEffectiveUpdateEnabled(i))
+            if (!_attributeData[i]._dirty)
                 continue;
-            const HLADataElement* dataElement = getDataElement(i);
-            if (!dataElement)
-                continue;
-            // FIXME cache somewhere
-            RTIData data;
-            HLAEncodeStream stream(data);
-            dataElement->encode(stream);
+            const RTIData& data = _attributeData[i]._data;
             _attributeValuePairSet->add(getAttributeHandle(i), data.data(), data.size());
         }
 
@@ -381,7 +373,7 @@ RTI13ObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const R
         _ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, timeStamp, tag);
 
         for (unsigned i = 0; i < numAttributes; ++i) {
-            setAttributeUpdated(i);
+            _attributeData[i]._dirty = false;
         }
 
     } catch (RTI::ObjectNotKnown& e) {
@@ -448,6 +440,48 @@ RTI13ObjectInstance::turnUpdatesOffForObjectInstance(const std::vector<RTI::Attr
     }
 }
 
+bool
+RTI13ObjectInstance::isAttributeOwnedByFederate(unsigned index) const
+{
+    if (!_ambassador.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
+        return false;
+    }
+    try {
+        RTI::AttributeHandle attributeHandle = getAttributeHandle(index);
+        return _ambassador->isAttributeOwnedByFederate(_handle, attributeHandle);
+    } catch (RTI::ObjectNotKnown& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
+               << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::AttributeNotDefined& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
+               << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::FederateNotExecutionMember& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
+               << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::ConcurrentAccessAttempted& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
+               << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::SaveInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
+               << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RestoreInProgress& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
+               << e._name << " " << e._reason);
+        return false;
+    } catch (RTI::RTIinternalError& e) {
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
+               << e._name << " " << e._reason);
+        return false;
+    }
+    return false;
+ }
+
 void
 RTI13ObjectInstance::requestAttributeOwnershipAssumption(const std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag)
 {

simgear/hla/RTI13ObjectInstance.hxx

@@ -42,7 +42,7 @@ typedef std::list<RTI13AttributeHandleDataPair> RTI13AttributeHandleDataPairList
 
 class RTI13ObjectInstance : public RTIObjectInstance {
 public:
-    RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* hlaObjectInstance, const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador, bool owned);
+    RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* hlaObjectInstance, const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador);
     virtual ~RTI13ObjectInstance();
 
     const RTI::ObjectHandle& getHandle() const
@@ -55,8 +55,6 @@ public:
 
     unsigned getNumAttributes() const
     { return get13ObjectClass()->getNumAttributes(); }
-    unsigned getAttributeIndex(const std::string& name) const
-    { return get13ObjectClass()->getAttributeIndex(name); }
     unsigned getAttributeIndex(const RTI::AttributeHandle& handle) const
     { return get13ObjectClass()->getAttributeIndex(handle); }
     RTI::AttributeHandle getAttributeHandle(unsigned index) const
@@ -68,14 +66,18 @@ public:
     virtual void deleteObjectInstance(const SGTimeStamp& timeStamp, const RTIData& tag);
     virtual void localDeleteObjectInstance();
 
-    void reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList, const RTIData& tag);
-    void reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList, const SGTimeStamp& timeStamp, const RTIData& tag);
-    virtual void requestObjectAttributeValueUpdate();
+    void reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
+                                const RTIData& tag, HLAIndexList& indexPool);
+    void reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
+                                const SGTimeStamp& timeStamp, const RTIData& tag, HLAIndexList& indexPool);
+    virtual void requestObjectAttributeValueUpdate(const HLAIndexList& indexList);
     void provideAttributeValueUpdate(const std::vector<RTI::AttributeHandle>& attributes);
 
     virtual void updateAttributeValues(const RTIData& tag);
     virtual void updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
 
+    virtual bool isAttributeOwnedByFederate(unsigned index) const;
+
     void attributesInScope(const std::vector<RTI::AttributeHandle>& attributes);
     void attributesOutOfScope(const std::vector<RTI::AttributeHandle>& attributes);
 

simgear/hla/RTIFederate.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "RTIFederate.hxx"
 
 namespace simgear {

simgear/hla/RTIFederate.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2011  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -20,6 +20,7 @@
 
 #include <string>
 #include "simgear/structure/SGWeakReferenced.hxx"
+#include "RTIInteractionClass.hxx"
 #include "RTIObjectClass.hxx"
 #include "RTIObjectInstance.hxx"
 
@@ -79,7 +80,7 @@ public:
     virtual bool processMessages(const double& minimum, const double& maximum) = 0;
 
     virtual RTIObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass) = 0;
-    // virtual RTIInteractionClass* createInteractionClass(const std::string& name) = 0;
+    virtual RTIInteractionClass* createInteractionClass(const std::string& name, HLAInteractionClass* interactionClass) = 0;
 
     virtual RTIObjectInstance* getObjectInstance(const std::string& name) = 0;
 

simgear/hla/RTIFederateFactory.cxx

@@ -1,5 +1,4 @@
-// PathOptions.cxx -- make an osgDB Options object from a path
-// Copyright (C) 2007  Tim Moore timoore@redhat.com
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,23 +14,30 @@
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
-// $Id$
 
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 
-#include <osgDB/Registry>
+#include <simgear/compiler.h>
 
-#include "PathOptions.hxx"
+#include "RTIFederateFactory.hxx"
 
-using namespace simgear;
+#include "RTIFederateFactoryRegistry.hxx"
 
-osgDB::ReaderWriter::Options* simgear::makeOptionsFromPath(const SGPath& path)
+namespace simgear {
+
+RTIFederateFactory::~RTIFederateFactory()
 {
-    using namespace osgDB;
-    ReaderWriter::Options *options
-        = new ReaderWriter::Options(*(Registry::instance()->getOptions()));
-    options->setDatabasePath(path.str());
-    return options;
+}
+
+void
+RTIFederateFactory::_registerAtFactory()
+{
+    SGSharedPtr<RTIFederateFactoryRegistry> registry = RTIFederateFactoryRegistry::instance();
+    if (!registry.valid())
+        return;
+    registry->registerFactory(this);
+}
+
 }

simgear/hla/RTIFederateFactory.hxx

@@ -0,0 +1,40 @@
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef RTIFederateFactory_hxx
+#define RTIFederateFactory_hxx
+
+#include <list>
+#include <string>
+#include "simgear/structure/SGReferenced.hxx"
+
+namespace simgear {
+
+class RTIFederate;
+
+class RTIFederateFactory : public SGReferenced {
+public:
+    virtual ~RTIFederateFactory();
+    virtual RTIFederate* create(const std::string& name, const std::list<std::string>& stringList) const = 0;
+
+protected:
+    void _registerAtFactory();
+};
+
+}
+
+#endif

simgear/hla/RTIFederateFactoryRegistry.cxx

@@ -0,0 +1,66 @@
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "RTIFederateFactoryRegistry.hxx"
+
+#include "simgear/threads/SGGuard.hxx"
+#include "RTIFederate.hxx"
+
+namespace simgear {
+
+RTIFederateFactoryRegistry::RTIFederateFactoryRegistry()
+{
+}
+
+RTIFederateFactoryRegistry::~RTIFederateFactoryRegistry()
+{
+}
+
+SGSharedPtr<RTIFederate>
+RTIFederateFactoryRegistry::create(const std::string& name, const std::list<std::string>& stringList) const
+{
+    SGGuard<SGMutex> guard(_mutex);
+    for (FederateFactoryList::const_iterator i = _federateFactoryList.begin(); i != _federateFactoryList.end(); ++i) {
+        SGSharedPtr<RTIFederate> federate = (*i)->create(name, stringList);
+        if (!federate.valid())
+            continue;
+        return federate;
+    }
+    return NULL;
+}
+
+void
+RTIFederateFactoryRegistry::registerFactory(RTIFederateFactory* factory)
+{
+    SGGuard<SGMutex> guard(_mutex);
+    _federateFactoryList.push_back(factory);
+}
+
+const SGSharedPtr<RTIFederateFactoryRegistry>&
+RTIFederateFactoryRegistry::instance()
+{
+    static SGSharedPtr<RTIFederateFactoryRegistry> registry = new RTIFederateFactoryRegistry;
+    return registry;
+}
+
+}

simgear/hla/RTIFederateFactoryRegistry.hxx

@@ -0,0 +1,54 @@
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef RTIFederateFactoryRegistry_hxx
+#define RTIFederateFactoryRegistry_hxx
+
+#include <list>
+#include <string>
+#include "simgear/structure/SGReferenced.hxx"
+#include "simgear/structure/SGSharedPtr.hxx"
+#include "RTIFederateFactory.hxx"
+
+#include "simgear/threads/SGThread.hxx"
+
+namespace simgear {
+
+class RTIFederateFactoryRegistry : public SGReferenced {
+public:
+    ~RTIFederateFactoryRegistry();
+
+    SGSharedPtr<RTIFederate> create(const std::string& name, const std::list<std::string>& stringList) const;
+
+    void registerFactory(RTIFederateFactory* factory);
+
+    static const SGSharedPtr<RTIFederateFactoryRegistry>& instance();
+
+private:
+    RTIFederateFactoryRegistry();
+
+    RTIFederateFactoryRegistry(const RTIFederateFactoryRegistry&);
+    RTIFederateFactoryRegistry& operator=(const RTIFederateFactoryRegistry&);
+
+    mutable SGMutex _mutex;
+    typedef std::list<SGSharedPtr<RTIFederateFactory> > FederateFactoryList;
+    FederateFactoryList _federateFactoryList;
+};
+
+}
+
+#endif

simgear/hla/RTIInteractionClass.cxx

@@ -1,5 +1,4 @@
-// PathOptions.hxx -- make an osgDB Options object from a path
-// Copyright (C) 2007  Tim Moore timoore@redhat.com
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,17 +14,25 @@
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
-// $Id$
 
-#ifndef PATHOPTIONSHXX
-#define PATHOPTIONSHXX 1
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
 
-#include <osgDB/ReaderWriter>
-#include <simgear/misc/sg_path.hxx>
+#include <simgear/compiler.h>
 
-namespace simgear
+#include "RTIInteractionClass.hxx"
+
+namespace simgear {
+
+RTIInteractionClass::RTIInteractionClass(HLAInteractionClass* interactionClass) :
+    _interactionClass(interactionClass)
 {
-osgDB::ReaderWriter::Options* makeOptionsFromPath(const SGPath&);
 }
 
-#endif
+RTIInteractionClass::~RTIInteractionClass()
+{
+    _interactionClass = 0;
+}
+
+}

simgear/hla/RTIInteractionClass.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,44 +18,33 @@
 #ifndef RTIInteractionClass_hxx
 #define RTIInteractionClass_hxx
 
-#include <set>
 #include <string>
-#include <vector>
 #include "simgear/structure/SGReferenced.hxx"
-#include "simgear/structure/SGSharedPtr.hxx"
-#include "simgear/structure/SGReferenced.hxx"
-#include "RTIData.hxx"
 
 namespace simgear {
 
+class HLAInteractionClass;
+
 class RTIInteractionClass : public SGReferenced {
 public:
-    RTIInteractionClass(const std::string& name);
+    RTIInteractionClass(HLAInteractionClass* interactionClass);
     virtual ~RTIInteractionClass();
 
-    const std::string& getName() const
-    { return _name; }
+    virtual bool resolveParameterIndex(const std::string& name, unsigned index) = 0;
 
-    virtual unsigned getNumParameters() const = 0;
-    virtual unsigned getParameterIndex(const std::string& name) const = 0;
-    virtual unsigned getOrCreateParameterIndex(const std::string& name) = 0;
-
-    virtual bool publish(const std::set<unsigned>& indexSet) = 0;
+    virtual bool publish() = 0;
     virtual bool unpublish() = 0;
 
-    virtual bool subscribe(const std::set<unsigned>& indexSet, bool) = 0;
+    virtual bool subscribe(bool) = 0;
     virtual bool unsubscribe() = 0;
 
-    virtual void send(const RTIData& tag) = 0;
-    virtual void send(const SGTimeStamp& timeStamp, const RTIData& tag) = 0;
-
-    class ReceiveCallback : public SGReferenced {
-    public:
-        virtual ~ReceiveCallback() {}
-    };
+    // virtual void send(const RTIData& tag) = 0;
+    // virtual void send(const SGTimeStamp& timeStamp, const RTIData& tag) = 0;
 
 private:
-    std::string _name;
+    HLAInteractionClass* _interactionClass;
+
+    friend class HLAInteractionClass;
 };
 
 }

simgear/hla/RTIObjectClass.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,14 +15,21 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "RTIObjectClass.hxx"
 
+#include "simgear/debug/logstream.hxx"
 #include "RTIObjectInstance.hxx"
 
 namespace simgear {
 
-RTIObjectClass::RTIObjectClass(HLAObjectClass* hlaObjectClass) :
-    _hlaObjectClass(hlaObjectClass)
+RTIObjectClass::RTIObjectClass(HLAObjectClass* objectClass) :
+    _objectClass(objectClass)
 {
 }
 
@@ -33,35 +40,31 @@ RTIObjectClass::~RTIObjectClass()
 void
 RTIObjectClass::discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag) const
 {
-    SGSharedPtr<HLAObjectClass> hlaObjectClass = _hlaObjectClass.lock();
-    if (!hlaObjectClass.valid()) {
+    if (!_objectClass) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Invalid hla object class pointer in RTIObjectClass::discoverInstance().");
         return;
     }
-    hlaObjectClass->discoverInstance(objectInstance, tag);
-    objectInstance->requestObjectAttributeValueUpdate();
+    _objectClass->_discoverInstance(objectInstance, tag);
 }
 
 void
 RTIObjectClass::startRegistration() const
 {
-    SGSharedPtr<HLAObjectClass> hlaObjectClass = _hlaObjectClass.lock();
-    if (!hlaObjectClass.valid()) {
+    if (!_objectClass) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Invalid hla object class pointer in RTIObjectClass::startRegstration().");
         return;
     }
-    hlaObjectClass->startRegistrationCallback();
+    _objectClass->_startRegistration();
 }
 
 void
 RTIObjectClass::stopRegistration() const
 {
-    SGSharedPtr<HLAObjectClass> hlaObjectClass = _hlaObjectClass.lock();
-    if (!hlaObjectClass.valid()) {
+    if (!_objectClass) {
         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Invalid hla object class pointer in RTIObjectClass::stopRegistration().");
         return;
     }
-    hlaObjectClass->stopRegistrationCallback();
+    _objectClass->_stopRegistration();
 }
 
 }

simgear/hla/RTIObjectClass.hxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -19,102 +19,44 @@
 #define RTIObjectClass_hxx
 
 #include <string>
-#include <vector>
 #include "simgear/structure/SGReferenced.hxx"
-#include "simgear/structure/SGSharedPtr.hxx"
-#include "simgear/structure/SGWeakPtr.hxx"
 #include "RTIData.hxx"
 #include "HLAObjectClass.hxx"
 
 namespace simgear {
 
+class RTIData;
 class RTIObjectInstance;
 class HLAObjectClass;
 
 class RTIObjectClass : public SGReferenced {
 public:
-    RTIObjectClass(HLAObjectClass* hlaObjectClass);
+    RTIObjectClass(HLAObjectClass* objectClass);
     virtual ~RTIObjectClass();
 
-    virtual std::string getName() const = 0;
+    virtual bool resolveAttributeIndex(const std::string& name, unsigned index) = 0;
 
     virtual unsigned getNumAttributes() const = 0;
-    virtual unsigned getAttributeIndex(const std::string& name) const = 0;
-    virtual unsigned getOrCreateAttributeIndex(const std::string& name) = 0;
 
-    virtual bool publish(const std::set<unsigned>& indexSet) = 0;
+    virtual bool publish(const HLAIndexList& indexList) = 0;
     virtual bool unpublish() = 0;
 
-    virtual bool subscribe(const std::set<unsigned>& indexSet, bool) = 0;
+    virtual bool subscribe(const HLAIndexList& indexList, bool) = 0;
     virtual bool unsubscribe() = 0;
 
     // Factory to create an object instance that can be used in this current federate
     virtual RTIObjectInstance* registerObjectInstance(HLAObjectInstance*) = 0;
 
+    // Call back into HLAObjectClass
     void discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag) const;
 
     void startRegistration() const;
     void stopRegistration() const;
 
-    void setAttributeDataType(unsigned index, SGSharedPtr<const HLADataType> dataType)
-    {
-        if (_attributeDataVector.size() <= index)
-            return;
-        _attributeDataVector[index]._dataType = dataType;
-    }
-    const HLADataType* getAttributeDataType(unsigned index) const
-    {
-        if (_attributeDataVector.size() <= index)
-            return 0;
-        return _attributeDataVector[index]._dataType.get();
-    }
-
-    HLAUpdateType getAttributeUpdateType(unsigned index) const
-    {
-        if (_attributeDataVector.size() <= index)
-            return HLAUndefinedUpdate;
-        return _attributeDataVector[index]._updateType;
-    }
-    void setAttributeUpdateType(unsigned index, HLAUpdateType updateType)
-    {
-        if (_attributeDataVector.size() <= index)
-            return;
-        _attributeDataVector[index]._updateType = updateType;
-    }
-
-    bool getAttributeSubscribed(unsigned index) const
-    {
-        if (_attributeDataVector.size() <= index)
-            return false;
-        return _attributeDataVector[index]._subscribed;
-    }
-    bool getAttributePublished(unsigned index) const
-    {
-        if (_attributeDataVector.size() <= index)
-            return false;
-        return _attributeDataVector[index]._published;
-    }
-    std::string getAttributeName(unsigned index) const
-    {
-        if (_attributeDataVector.size() <= index)
-            return std::string();
-        return _attributeDataVector[index]._name;
-    }
-
-protected:
-    struct AttributeData {
-        AttributeData(const std::string& name) : _name(name), _subscribed(false), _published(false), _updateType(HLAUndefinedUpdate) {}
-        std::string _name;
-        SGSharedPtr<const HLADataType> _dataType;
-        bool _subscribed;
-        bool _published;
-        HLAUpdateType _updateType;
-    };
-    typedef std::vector<AttributeData> AttributeDataVector;
-    AttributeDataVector _attributeDataVector;
-
 private:
-    SGWeakPtr<HLAObjectClass> _hlaObjectClass;
+    HLAObjectClass* _objectClass;
+
+    friend class HLAObjectClass;
 };
 
 }

simgear/hla/RTIObjectInstance.cxx

@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
 #include "RTIObjectInstance.hxx"
 #include "RTIObjectClass.hxx"
 #include "HLAObjectInstance.hxx"
@@ -22,8 +28,7 @@
 namespace simgear {
 
 RTIObjectInstance::RTIObjectInstance(HLAObjectInstance* hlaObjectInstance) :
-    _hlaObjectInstance(hlaObjectInstance),
-    _pendingAttributeUpdateRequest(false)
+    _objectInstance(hlaObjectInstance)
 {
 }
 
@@ -37,54 +42,29 @@ RTIObjectInstance::getNumAttributes() const
     return getObjectClass()->getNumAttributes();
 }
 
-unsigned
-RTIObjectInstance::getAttributeIndex(const std::string& name) const
-{
-    return getObjectClass()->getAttributeIndex(name);
-}
-
-std::string
-RTIObjectInstance::getAttributeName(unsigned index) const
-{
-    return getObjectClass()->getAttributeName(index);
-}
-
 void
 RTIObjectInstance::removeInstance(const RTIData& tag)
 {
-    SGSharedPtr<HLAObjectInstance> hlaObjectInstance =  _hlaObjectInstance.lock();
-    if (!hlaObjectInstance.valid())
+    if (!_objectInstance)
         return;
-    hlaObjectInstance->removeInstance(tag);
+    _objectInstance->_removeInstance(tag);
 }
 
 void
-RTIObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const RTIData& tag)
+RTIObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 {
-    for (RTIIndexDataPairList::const_iterator i = dataPairList.begin();
-         i != dataPairList.end(); ++i) {
-        reflectAttributeValue(i->first, i->second);
-    }
-
-    SGSharedPtr<HLAObjectInstance> hlaObjectInstance =  _hlaObjectInstance.lock();
-    if (!hlaObjectInstance.valid())
+    if (!_objectInstance)
         return;
-    hlaObjectInstance->reflectAttributeValues(dataPairList, tag);
+    _objectInstance->_reflectAttributeValues(indexList, tag);
 }
 
 void
-RTIObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList,
+RTIObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
                                           const SGTimeStamp& timeStamp, const RTIData& tag)
 {
-    for (RTIIndexDataPairList::const_iterator i = dataPairList.begin();
-         i != dataPairList.end(); ++i) {
-        reflectAttributeValue(i->first, i->second);
-    }
-
-    SGSharedPtr<HLAObjectInstance> hlaObjectInstance =  _hlaObjectInstance.lock();
-    if (!hlaObjectInstance.valid())
+    if (!_objectInstance)
         return;
-    hlaObjectInstance->reflectAttributeValues(dataPairList, timeStamp, tag);
+    _objectInstance->_reflectAttributeValues(indexList, timeStamp, tag);
 }
 
 }

simgear/hla/RTIObjectInstance.hxx

@@ -18,13 +18,9 @@
 #ifndef RTIObjectInstance_hxx
 #define RTIObjectInstance_hxx
 
-#include <list>
-#include <map>
 #include <string>
 #include <vector>
-#include "simgear/debug/logstream.hxx"
 #include "simgear/structure/SGReferenced.hxx"
-#include "simgear/structure/SGWeakPtr.hxx"
 #include "simgear/timing/timestamp.hxx"
 #include "RTIData.hxx"
 #include "RTIObjectClass.hxx"
@@ -39,247 +35,117 @@ class HLAObjectInstance;
 
 class RTIObjectInstance : public SGReferenced {
 public:
-    RTIObjectInstance(HLAObjectInstance* hlaObjectInstance);
+    RTIObjectInstance(HLAObjectInstance* objectInstance);
     virtual ~RTIObjectInstance();
 
+    void setObjectInstance(HLAObjectInstance* objectInstance)
+    { _objectInstance = objectInstance; }
+
     virtual const RTIObjectClass* getObjectClass() const = 0;
 
     virtual std::string getName() const = 0;
 
     unsigned getNumAttributes() const;
-    unsigned getAttributeIndex(const std::string& name) const;
-    std::string getAttributeName(unsigned index) const;
 
     virtual void deleteObjectInstance(const RTIData& tag) = 0;
     virtual void deleteObjectInstance(const SGTimeStamp& timeStamp, const RTIData& tag) = 0;
     virtual void localDeleteObjectInstance() = 0;
 
-    virtual void requestObjectAttributeValueUpdate() = 0;
+    virtual void requestObjectAttributeValueUpdate(const HLAIndexList& indexList) = 0;
 
     virtual void updateAttributeValues(const RTIData& tag) = 0;
     virtual void updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag) = 0;
 
+    virtual bool isAttributeOwnedByFederate(unsigned index) const = 0;
+
     void removeInstance(const RTIData& tag);
-    void reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const RTIData& tag);
-    void reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const SGTimeStamp& timeStamp, const RTIData& tag);
-    void reflectAttributeValue(unsigned i, const RTIData& data)
+    void reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag);
+    void reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag);
+
+    bool encodeAttributeData(unsigned index, const HLADataElement& dataElement)
     {
-        if (_attributeData.size() <= i)
-            return;
-        HLADataElement* dataElement = _attributeData[i]._dataElement.get();
-        if (!dataElement)
-            return;
-        HLADecodeStream stream(data);
-        dataElement->decode(stream);
+        if (_attributeData.size() <= index)
+            return false;
+        return _attributeData[index].encodeAttributeData(dataElement);
     }
 
-    const HLADataType* getAttributeDataType(unsigned i) const
+    bool decodeAttributeData(unsigned index, HLADataElement& dataElement) const
     {
-        return getObjectClass()->getAttributeDataType(i);
-    }
-    HLAUpdateType getAttributeUpdateType(unsigned i) const
-    {
-        return getObjectClass()->getAttributeUpdateType(i);
-    }
-    bool getAttributeSubscribed(unsigned i) const
-    {
-        return getObjectClass()->getAttributeSubscribed(i);
-    }
-    bool getAttributePublished(unsigned i) const
-    {
-        return getObjectClass()->getAttributePublished(i);
+        if (_attributeData.size() <= index)
+            return false;
+        return _attributeData[index].decodeAttributeData(dataElement);
     }
 
-    HLADataElement* getDataElement(unsigned i)
+    bool getAttributeData(unsigned index, RTIData& data) const
     {
-        if (_attributeData.size() <= i)
-            return 0;
-        return _attributeData[i]._dataElement.get();
-    }
-    const HLADataElement* getDataElement(unsigned i) const
-    {
-        if (_attributeData.size() <= i)
-            return 0;
-        return _attributeData[i]._dataElement.get();
-    }
-    void setDataElement(unsigned i, HLADataElement* dataElement)
-    {
-        if (_attributeData.size() <= i)
-            return;
-        _attributeData[i]._dataElement = dataElement;
+        if (_attributeData.size() <= index)
+            return false;
+        data = _attributeData[index]._data;
+        return true;
     }
 
-    void updateAttributesFromClass(bool owned)
+    bool getAttributeOwned(unsigned index) const
     {
-        // FIXME: rethink that!!!
-        unsigned numAttributes = getNumAttributes();
-        unsigned i = 0;
-        for (; i < _attributeData.size(); ++i) {
-            if (getAttributePublished(i)) {
-            } else {
-                _attributeData[i].setUpdateEnabled(false);
-                _attributeData[i].setOwned(false);
-                if (getAttributeSubscribed(i))
-                    _attributeData[i].setRequestUpdate(true);
-            }
-        }
-        _attributeData.resize(numAttributes);
-        for (; i < numAttributes; ++i) {
-            if (getAttributePublished(i)) {
-                _attributeData[i].setUpdateEnabled(true);
-                _attributeData[i].setOwned(owned);
-                if (!owned && getAttributeSubscribed(i))
-                    _attributeData[i].setRequestUpdate(true);
-            } else {
-                _attributeData[i].setUpdateEnabled(false);
-                _attributeData[i].setOwned(false);
-                if (getAttributeSubscribed(i))
-                    _attributeData[i].setRequestUpdate(true);
-            }
-        }
+        if (_attributeData.size() <= index)
+            return false;
+        return _attributeData[index]._owned;
     }
 
-    void setAttributeForceUpdate(unsigned i)
-    {
-        if (_attributeData.size() <= i)
-            return;
-        _attributeData[i].setForceUpdate(true);
-    }
     void setAttributeInScope(unsigned i, bool inScope)
     {
         if (_attributeData.size() <= i)
             return;
-        _attributeData[i].setInScope(inScope);
+        _attributeData[i]._inScope = inScope;
     }
     void setAttributeUpdateEnabled(unsigned i, bool enabled)
     {
         if (_attributeData.size() <= i)
             return;
-        _attributeData[i].setUpdateEnabled(enabled);
-    }
-    void setAttributeUpdated(unsigned i)
-    {
-        if (_attributeData.size() <= i)
-            return;
-        _attributeData[i].setForceUpdate(false);
-    }
-    bool getAttributeEffectiveUpdateEnabled(unsigned i)
-    {
-        if (_attributeData.size() <= i)
-            return false;
-        if (!getAttributePublished(i))
-            return false;
-        if (!_attributeData[i]._updateEnabled)
-            return false;
-        if (!_attributeData[i]._inScope)
-            return false;
-        if (_attributeData[i]._forceUpdate)
-            return true;
-        switch (getAttributeUpdateType(i)) {
-        case HLAPeriodicUpdate:
-            return true;
-        case HLAConditionalUpdate:
-            return true; // FIXME
-        case HLAStaticUpdate:
-            return false;
-        default:
-            return false;
-        }
-    }
-    void setRequestAttributeUpdate(bool request)
-    {
-        for (unsigned i = 0; i < getNumAttributes(); ++i) {
-            if (getAttributeUpdateType(i) == HLAPeriodicUpdate)
-                continue;
-            setRequestAttributeUpdate(i, request);
-        }
-    }
-    void setRequestAttributeUpdate(unsigned i, bool request)
-    {
-        if (_attributeData.size() <= i)
-            return;
-        _attributeData[i].setRequestUpdate(request);
-        if (request) {
-            if (!_pendingAttributeUpdateRequest) {
-                _pendingAttributeUpdateRequest = true;
-            }
-        }
-    }
-    bool getRequestAttributeUpdate(unsigned i) const
-    {
-        if (_attributeData.size() <= i)
-            return false;
-        return _attributeData[i]._requestUpdate;
-    }
-
-    void flushPendingRequests()
-    {
-        if (_pendingAttributeUpdateRequest) {
-            requestObjectAttributeValueUpdate();
-            _pendingAttributeUpdateRequest = false;
-        }
+        _attributeData[i]._updateEnabled = enabled;
     }
 
 protected:
+    // Initially set the number of attributes, do an initial query for the attribute ownership
+    void _setNumAttributes(unsigned numAttributes)
+    {
+        _attributeData.resize(numAttributes);
+        for (unsigned i = 0; i < numAttributes; ++i)
+            _attributeData[i]._owned = isAttributeOwnedByFederate(i);
+    }
+
     // The backward reference to the user visible object
-    SGWeakPtr<HLAObjectInstance> _hlaObjectInstance;
-
-    // Is true if we should emit a requestattr
-    bool _pendingAttributeUpdateRequest;
-
-    // Pool of update list entries
-    RTIIndexDataPairList _indexDataPairList;
-
-    // This adds raw storage for attribute index i to the end of the dataPairList.
-    void getDataFromPool(RTIIndexDataPairList& dataPairList)
-    {
-        // Nothing left in the pool - so allocate something
-        if (_indexDataPairList.empty()) {
-            dataPairList.push_back(RTIIndexDataPairList::value_type());
-            return;
-        }
-
-        // Take one from the pool
-        dataPairList.splice(dataPairList.end(), _indexDataPairList, _indexDataPairList.begin());
-    }
-
-    void putDataToPool(RTIIndexDataPairList& dataPairList)
-    {
-        _indexDataPairList.splice(_indexDataPairList.begin(), dataPairList);
-    }
+    HLAObjectInstance* _objectInstance;
 
     struct AttributeData {
-        AttributeData() : _owned(false), _inScope(true), _updateEnabled(true), _forceUpdate(false), _requestUpdate(false)
+        AttributeData() : _owned(false), _inScope(true), _updateEnabled(true), _dirty(false)
         { }
 
-        // The hla level data element with tha actual local program
-        // accessible data.
-        SGSharedPtr<HLADataElement> _dataElement;
-        // SGSharedPtr<HLADataElement::TimeStamp> _timeStamp;
+        bool encodeAttributeData(const HLADataElement& dataElement)
+        {
+            _dirty = true;
+            _data.resize(0);
+            HLAEncodeStream stream(_data);
+            return dataElement.encode(stream);
+        }
 
-        // Pool of already allocated raw data used for reflection of updates
-        RTIIndexDataPairList _indexDataPairList;
+        bool decodeAttributeData(HLADataElement& dataElement) const
+        {
+            HLADecodeStream stream(_data);
+            return dataElement.decode(stream);
+        }
 
-        void setOwned(bool owned)
-        { _owned = owned; }
-        void setInScope(bool inScope)
-        { _inScope = inScope; }
-        void setUpdateEnabled(bool updateEnabled)
-        { _updateEnabled = updateEnabled; }
-        void setForceUpdate(bool forceUpdate)
-        { _forceUpdate = forceUpdate; }
-        void setRequestUpdate(bool requestUpdate)
-        { _requestUpdate = requestUpdate; }
+        // The rti level raw data element
+        RTIData _data;
 
+        // The state of the attribute as tracked from the rti.
         bool _owned;
         bool _inScope;
         bool _updateEnabled;
-        bool _forceUpdate;
-        bool _requestUpdate;
+
+        // Is set to true if _data has be reencoded
+        bool _dirty;
     };
     std::vector<AttributeData> _attributeData;
-
-    friend class HLAObjectInstance;
 };
 
 }

simgear/io/HTTPClient.cxx

@@ -25,9 +25,6 @@ using std::string;
 using std::stringstream;
 using std::vector;
 
-//#include <iostream>
-//using namespace std;
-
 namespace simgear
 {
 
@@ -35,6 +32,7 @@ namespace HTTP
 {
 
 extern const int DEFAULT_HTTP_PORT = 80;
+const char* CONTENT_TYPE_URL_ENCODED = "application/x-www-form-urlencoded";
 
 class Connection : public NetChat
 {
@@ -103,15 +101,27 @@ public:
         state = STATE_SENT_REQUEST;
         bodyTransferSize = -1;
         chunkedTransfer = false;
+        noMessageBody = (r->method() == "HEAD");
         setTerminator("\r\n");
         
         stringstream headerData;
         string path = r->path();
+        string query = r->query();
+        string bodyData;
+        
         if (!client->proxyHost().empty()) {
-            path = r->url();
+            path = r->scheme() + "://" + r->host() + r->path();
         }
 
-        headerData << r->method() << " " << path << " HTTP/1.1\r\n";
+        if (r->method() == "POST") {
+            headerData << r->method() << " " << path << " HTTP/1.1\r\n";
+            bodyData = query.substr(1); // URL-encode, drop the leading '?'
+            headerData << "Content-Type:" << CONTENT_TYPE_URL_ENCODED << "\r\n";
+            headerData << "Content-Length:" << bodyData.size() << "\r\n";
+        } else {
+            headerData << r->method() << " " << path << query << " HTTP/1.1\r\n";
+        }
+        
         headerData << "Host: " << r->hostAndPort() << "\r\n";
         headerData << "User-Agent:" << client->userAgent() << "\r\n";
         if (!client->proxyAuth().empty()) {
@@ -123,9 +133,10 @@ public:
         }
 
         headerData << "\r\n"; // final CRLF to terminate the headers
-
-    // TODO - add request body support for PUT, etc operations
-
+        if (!bodyData.empty()) {
+            headerData << bodyData;
+        }
+        
         bool ok = push(headerData.str().c_str());
         if (!ok) {
             SG_LOG(SG_IO, SG_WARN, "HTTP writing to socket failed");
@@ -150,6 +161,10 @@ public:
             activeRequest->responseStart(buffer);
             state = STATE_GETTING_HEADERS;
             buffer.clear();
+            if (activeRequest->responseCode() == 204) {
+                noMessageBody = true;
+            }
+            
             break;
             
         case STATE_GETTING_HEADERS:
@@ -233,6 +248,11 @@ private:
             
             if (chunkedTransfer) {
                 state = STATE_GETTING_CHUNKED;
+            } else if (noMessageBody || (bodyTransferSize == 0)) {
+                // force the state to GETTING_BODY, to simplify logic in
+                // responseComplete and handleClose
+                state = STATE_GETTING_BODY;
+                responseComplete();
             } else {
                 setByteCount(bodyTransferSize); // may be -1, that's fine
                 state = STATE_GETTING_BODY;
@@ -327,7 +347,6 @@ private:
     {
         activeRequest->responseComplete();
         client->requestFinished(this);
-        //cout << "response complete: " << activeRequest->url() << endl;
         
         bool doClose = activeRequest->closeAfterComplete();
         activeRequest = NULL;
@@ -374,6 +393,7 @@ private:
     int bodyTransferSize;
     SGTimeStamp idleTime;
     bool chunkedTransfer;
+    bool noMessageBody;
     
     std::list<Request_ptr> queuedRequests;
 };

simgear/io/HTTPRequest.cxx

@@ -125,6 +125,20 @@ string Request::path() const
     return u.substr(hostEnd, query - hostEnd);
 }
 
+
+string Request::query() const
+{
+  string u(url());
+  int query = u.find('?');
+  if (query < 0) {
+    return "";  //no query string found
+  }
+  
+  return u.substr(query);   //includes question mark
+}
+
+
+
 string Request::host() const
 {
     string hp(hostAndPort());

simgear/io/HTTPRequest.hxx

@@ -30,6 +30,7 @@ public:
     virtual std::string host() const;
     virtual std::string hostAndPort() const;
     virtual unsigned short port() const;
+    virtual std::string query() const;
     
     virtual string_list requestHeaders() const;
     virtual std::string header(const std::string& name) const;

simgear/io/raw_socket.cxx

@@ -17,7 +17,7 @@
 
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
 #ifdef HAVE_CONFIG_H

simgear/io/raw_socket.hxx

@@ -17,7 +17,7 @@
  
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
 #ifndef SG_IO_SOCKET_HXX

simgear/io/sg_netBuffer.cxx

@@ -16,7 +16,7 @@
  
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  
      For further information visit http://plib.sourceforge.net
 

simgear/io/sg_netBuffer.hxx

@@ -16,7 +16,7 @@
  
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  
      For further information visit http://plib.sourceforge.net
 

simgear/io/sg_netChannel.cxx

@@ -16,7 +16,7 @@
  
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  
      For further information visit http://plib.sourceforge.net
 

simgear/io/sg_netChannel.hxx

@@ -16,7 +16,7 @@
  
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  
      For further information visit http://plib.sourceforge.net
 

simgear/io/sg_netChat.cxx

@@ -16,7 +16,7 @@
  
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  
      For further information visit http://plib.sourceforge.net
 

simgear/io/sg_netChat.hxx

@@ -16,7 +16,7 @@
  
      You should have received a copy of the GNU Library General Public
      License along with this library; if not, write to the Free Software
-     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  
      For further information visit http://plib.sourceforge.net
 

simgear/io/test_HTTP.cxx

@@ -46,8 +46,8 @@ public:
     bool failed;
     string bodyData;
     
-    TestRequest(const std::string& url) : 
-        HTTP::Request(url),
+    TestRequest(const std::string& url, const std::string method = "GET") : 
+        HTTP::Request(url, method),
         complete(false)
     {
     }
@@ -133,6 +133,13 @@ public:
             
             method = line[0];
             path = line[1];
+            
+            string::size_type queryPos = path.find('?');
+            if (queryPos != string::npos) {
+                parseArgs(path.substr(queryPos + 1));
+                path = path.substr(0, queryPos);
+            }
+            
             httpVersion = line[2];
             requestHeaders.clear();
             buffer.clear();
@@ -144,8 +151,8 @@ public:
                 return;
             }
             
-            int colonPos = buffer.find(':');
-            if (colonPos < 0) {
+            string::size_type colonPos = buffer.find(':');
+            if (colonPos == string::npos) {
                 cerr << "malformed HTTP response header:" << buffer << endl;
                 buffer.clear();
                 return;
@@ -156,10 +163,28 @@ public:
             requestHeaders[key] = value;
             buffer.clear();
         } else if (state == STATE_REQUEST_BODY) {
-            
+            cerr << "done getting requst body";
+            receivedBody();
+            setTerminator("\r\n");
         }
     }  
     
+    void parseArgs(const string& argData)
+    {
+        string_list argv = strutils::split(argData, "&");
+        for (unsigned int a=0; a<argv.size(); ++a) {
+            string::size_type eqPos = argv[a].find('=');
+            if (eqPos == string::npos) {
+                cerr << "malformed HTTP argument:" << argv[a] << endl;
+                continue;
+            }
+
+            string key = argv[a].substr(0, eqPos);
+            string value = argv[a].substr(eqPos + 1);
+            args[key] = value;
+        }
+    }
+    
     void receivedRequestHeaders()
     {
         state = STATE_IDLE;
@@ -172,6 +197,14 @@ public:
             d << "\r\n"; // final CRLF to terminate the headers
             d << contentStr;
             push(d.str().c_str());
+        } else if (path == "/test_zero_length_content") {
+            string contentStr;
+            stringstream d;
+            d << "HTTP/1.1 " << 200 << " " << reasonForCode(200) << "\r\n";
+            d << "Content-Length:" << contentStr.size() << "\r\n";
+            d << "\r\n"; // final CRLF to terminate the headers
+            d << contentStr;
+            push(d.str().c_str());
         } else if (path == "/test_headers") {
             COMPARE(requestHeaders["X-Foo"], string("Bar"));
             COMPARE(requestHeaders["X-AnotherHeader"], string("A longer value"));
@@ -239,8 +272,53 @@ public:
             d << contentStr;
             push(d.str().c_str());
             closeWhenDone();
+        } else if (path == "/test_args") {
+            if ((args["foo"] != "abc") || (args["bar"] != "1234") || (args["username"] != "johndoe")) {
+                sendErrorResponse(400, true, "bad arguments");
+                return;
+            }
+
+            string contentStr(BODY1);
+            stringstream d;
+            d << "HTTP/1.1 " << 200 << " " << reasonForCode(200) << "\r\n";
+            d << "Content-Length:" << contentStr.size() << "\r\n";
+            d << "\r\n"; // final CRLF to terminate the headers
+            d << contentStr;
+            push(d.str().c_str());
+        } else if (path == "/test_post") {
+            if (requestHeaders["Content-Type"] != "application/x-www-form-urlencoded") {
+                cerr << "bad content type: '" << requestHeaders["Content-Type"] << "'" << endl;
+                 sendErrorResponse(400, true, "bad content type");
+                 return;
+            }
+            
+            requestContentLength = strutils::to_int(requestHeaders["Content-Length"]);
+            setByteCount(requestContentLength);
+            state = STATE_REQUEST_BODY;
         } else {
-            sendErrorResponse(404, true, "");
+            sendErrorResponse(404, false, "");
+        }
+    }
+    
+    void receivedBody()
+    {
+        state = STATE_IDLE;
+        if (method == "POST") {
+            parseArgs(buffer);
+        }
+        
+        if (path == "/test_post") {
+            if ((args["foo"] != "abc") || (args["bar"] != "1234") || (args["username"] != "johndoe")) {
+                sendErrorResponse(400, true, "bad arguments");
+                return;
+            }
+            
+            stringstream d;
+            d << "HTTP/1.1 " << 204 << " " << reasonForCode(204) << "\r\n";
+            d << "\r\n"; // final CRLF to terminate the headers
+            push(d.str().c_str());
+            
+            cerr << "sent 204 response ok" << endl;
         }
     }
     
@@ -273,6 +351,7 @@ public:
     {
         switch (code) {
             case 200: return "OK";
+            case 204: return "no content";
             case 404: return "not found";
             default: return "unknown code";
         }
@@ -284,6 +363,8 @@ public:
     string path;
     string httpVersion;
     std::map<string, string> requestHeaders;
+    std::map<string, string> args;
+    int requestContentLength;
 };
 
 class TestServer : public NetChannel
@@ -374,7 +455,17 @@ int main(int argc, char* argv[])
         COMPARE(tr->responseBytesReceived(), strlen(BODY1));
         COMPARE(tr->bodyData, string(BODY1));
     }
-
+    
+    {
+        TestRequest* tr = new TestRequest("http://localhost:2000/test_args?foo=abc&bar=1234&username=johndoe");
+        HTTP::Request_ptr own(tr);
+        cl.makeRequest(tr);
+        waitForComplete(&cl, tr);
+        COMPARE(tr->responseCode(), 200);
+    }
+    
+    cerr << "done args" << endl;
+    
     {
         TestRequest* tr = new TestRequest("http://localhost:2000/test_headers");
         HTTP::Request_ptr own(tr);
@@ -405,6 +496,7 @@ int main(int argc, char* argv[])
         COMPARE(tr->bodyData, string(body2, body2Size));
     }
     
+    cerr << "testing chunked" << endl;
     {
         TestRequest* tr = new TestRequest("http://localhost:2000/testchunked");
         HTTP::Request_ptr own(tr);
@@ -430,6 +522,16 @@ int main(int argc, char* argv[])
         COMPARE(tr->responseLength(), 0);
     }
 
+    cout << "done 404 test" << endl;
+
+    {
+        TestRequest* tr = new TestRequest("http://localhost:2000/test_args?foo=abc&bar=1234&username=johndoe");
+        HTTP::Request_ptr own(tr);
+        cl.makeRequest(tr);
+        waitForComplete(&cl, tr);
+        COMPARE(tr->responseCode(), 200);
+    }
+
     cout << "done1" << endl;
 // test HTTP/1.0
     {
@@ -536,6 +638,29 @@ int main(int argc, char* argv[])
         COMPARE(tr3->bodyData, string(BODY1));
     }
     
+// POST
+    {
+        cout << "POST" << endl;
+        TestRequest* tr = new TestRequest("http://localhost:2000/test_post?foo=abc&bar=1234&username=johndoe", "POST");
+        HTTP::Request_ptr own(tr);
+        cl.makeRequest(tr);
+        waitForComplete(&cl, tr);
+        COMPARE(tr->responseCode(), 204);
+    }
+    
+    // test_zero_length_content
+    {
+        cout << "zero-length-content-response" << endl;
+        TestRequest* tr = new TestRequest("http://localhost:2000/test_zero_length_content");
+        HTTP::Request_ptr own(tr);
+        cl.makeRequest(tr);
+        waitForComplete(&cl, tr);
+        COMPARE(tr->responseCode(), 200);
+        COMPARE(tr->bodyData, string());
+        COMPARE(tr->responseBytesReceived(), 0);
+    }
+    
+    
     cout << "all tests passed ok" << endl;
     return EXIT_SUCCESS;
 }

simgear/io/test_binobj.cxx

@@ -9,7 +9,7 @@
 #include <cstdlib>
 #include <cstdio>
 
-#ifdef _MSC_VER
+#if defined _MSC_VER || defined _WIN32_WINNT
 #   define  random  rand
 #endif
 

simgear/math/CMakeLists.txt

@@ -2,7 +2,6 @@ include (SimGearComponent)
 
 
 set(HEADERS 
-    Math.hxx
     SGBox.hxx
     SGCMath.hxx
     SGGeoc.hxx
@@ -30,15 +29,14 @@ set(HEADERS
     leastsqs.hxx
     sg_geodesy.hxx
     sg_types.hxx
-	sg_random.h
+    sg_random.h
     )
 
 set(SOURCES 
-    SGGeod.cxx
     SGGeodesy.cxx
     interpolater.cxx
     leastsqs.cxx
-	sg_random.c
+    sg_random.c
     )
 
 simgear_component(math math "${SOURCES}" "${HEADERS}")

simgear/math/Math.hxx

@@ -1,23 +0,0 @@
-#ifndef SIMGEAR_MATH_MATH_HXX
-#define SIMGEAR_MATH_MATH_HXX 1
-namespace simgear
-{
-namespace math
-{
-/** Linear interpolation between two values.
- */
-template<typename T>
-inline T lerp(const T& x, const T& y, double alpha)
-{
-    return x * (1.0 - alpha) + y * alpha;
-}
-
-template<typename T>
-inline T lerp(const T& x, const T& y, float alpha)
-{
-    return x * (1.0f - alpha) + y * alpha;
-}
-
-}
-}
-#endif

simgear/math/SGGeod.cxx

@@ -1,59 +0,0 @@
-// Copyright (C) 2008  Tim Moore timoore@redhat.com
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Library General Public
-// License as published by the Free Software Foundation; either
-// version 2 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-// Library General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-//
-
-#ifdef HAVE_CONFIG_H
-#  include <simgear_config.h>
-#endif
-
-#include "SGMath.hxx"
-
-#ifndef NO_OPENSCENEGRAPH_INTERFACE
-
-osg::Matrix SGGeod::makeSimulationFrameRelative() const
-{
-    SGQuatd hlOr = SGQuatd::fromLonLat(*this);
-    return osg::Matrix(toOsg(hlOr));
-}
-
-osg::Matrix SGGeod::makeSimulationFrame() const
-{
-    osg::Matrix result(makeSimulationFrameRelative());
-    SGVec3d coord;
-    SGGeodesy::SGGeodToCart(*this, coord);
-    result.setTrans(toOsg(coord));
-    return result;
-}
-
-osg::Matrix SGGeod::makeZUpFrameRelative() const
-{
-    osg::Matrix result(makeSimulationFrameRelative());
-    // 180 degree rotation around Y axis
-    osg::Quat flip(0.0, 1.0, 0.0, 0.0);
-    result.preMult(osg::Matrix(flip));
-    return result;
-}
-
-osg::Matrix SGGeod::makeZUpFrame() const
-{
-    osg::Matrix result(makeZUpFrameRelative());
-    SGVec3d coord;
-    SGGeodesy::SGGeodToCart(*this, coord);
-    result.setTrans(toOsg(coord));
-    return result;
-}
-
-#endif

simgear/math/SGGeod.hxx

@@ -20,10 +20,6 @@
 
 #include <simgear/constants.h>
 
-#ifndef NO_OPENSCENEGRAPH_INTERFACE
-#include <osg/Matrix>
-#endif
-
 // #define SG_GEOD_NATIVE_DEGREE
 
 /// Class representing a geodetic location
@@ -89,19 +85,6 @@ public:
   // Compare two geodetic positions for equality
   bool operator == ( const SGGeod & other ) const;
 
-#ifndef NO_OPENSCENEGRAPH_INTERFACE
-  // Create a local coordinate frame in the earth-centered frame of
-  // reference. X points north, Z points down.
-  // makeSimulationFrameRelative() only includes rotation.
-  osg::Matrix makeSimulationFrameRelative() const;
-  osg::Matrix makeSimulationFrame() const;
-
-  // Create a Z-up local coordinate frame in the earth-centered frame
-  // of reference. This is what scenery models, etc. expect.
-  // makeZUpFrameRelative() only includes rotation.
-  osg::Matrix makeZUpFrameRelative() const;
-  osg::Matrix makeZUpFrame() const;
-#endif
 private:
   /// This one is private since construction is not unique if you do
   /// not know the units of the arguments. Use the factory methods for

simgear/math/SGGeodesy.cxx

@@ -87,7 +87,7 @@ SGGeodesy::SGCartToGeod(const SGVec3<double>& cart, SGGeod& geod)
     // coordinates 0/0/-EQURAD. It may be any other place on geoide's surface,
     // the Northpole, Hawaii or Wentorf. This one was easy to code ;-)
     geod.setLongitudeRad( 0.0 );
-    geod.setLongitudeRad( 0.0 );
+    geod.setLatitudeRad( 0.0 );
     geod.setElevationM( -EQURAD );
     return;
   }

simgear/math/SGIntersect.hxx

@@ -18,6 +18,8 @@
 #ifndef SGIntersect_HXX
 #define SGIntersect_HXX
 
+#include <algorithm>
+
 template<typename T>
 inline bool
 intersects(const SGSphere<T>& s1, const SGSphere<T>& s2)

simgear/math/SGMisc.hxx

@@ -87,6 +87,11 @@ public:
   static int roundToInt(const T& v)
   { return int(round(v)); }
 
+  // Linear interpolation between two arbitrary typed values
+  template<typename S>
+  static S lerp(const S& val0, const S& val1, const T& t)
+  { return val0*(T(1) - t) + val1*t; }
+
 #ifndef NDEBUG
   /// Returns true if v is a NaN value
   /// Use with care: allways code that you do not need to use that!

simgear/math/SGQuat.hxx

@@ -26,10 +26,6 @@
 #undef max
 #endif
 
-#ifndef NO_OPENSCENEGRAPH_INTERFACE
-#include <osg/Quat>
-#endif
-
 /// Quaternion Class
 template<typename T>
 class SGQuat {
@@ -780,16 +776,4 @@ SGQuatd
 toQuatd(const SGQuatf& v)
 { return SGQuatd(v(0), v(1), v(2), v(3)); }
 
-#ifndef NO_OPENSCENEGRAPH_INTERFACE
-inline
-SGQuatd
-toSG(const osg::Quat& q)
-{ return SGQuatd(q[0], q[1], q[2], q[3]); }
-
-inline
-osg::Quat
-toOsg(const SGQuatd& q)
-{ return osg::Quat(q[0], q[1], q[2], q[3]); }
-#endif
-
 #endif