Mac changes for Subversion bundling.

Clang (in Xcode 4.4) is being strict about dependent lookup rules, so apply the recommended fix-it.

.gitignore

@@ -1,17 +1,14 @@
 Makefile
-Makefile.in
-.deps
-autom4te.cache
-config.guess
-config.log
-config.status
-config.sub
-configure
-depcomp
-install-sh
-missing
-aclocal.m4
-INSTALL
-SimGear.spec
 *.o
 lib*.a
+.*.swp
+cmake_install.cmake
+CMakeFiles
+CMakeCache.txt
+CPackConfig.cmake
+CPackSourceConfig.cmake
+cmake_uninstall.cmake
+CTestTestfile.cmake
+install_manifest.txt
+build*
+Build

CMakeLists.txt

@@ -1,71 +1,199 @@
-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 2.6.4)
 include (CheckFunctionExists)
 include (CheckIncludeFile)
 include (CheckCXXSourceCompiles)
-include (CPack)
+
 
 project(SimGear)
 
-set(SIMGEAR_VERSION "2.2.0")
+# read 'version' file into a variable (stripping any newlines or spaces)
+file(READ version versionFile)
+string(STRIP ${versionFile} SIMGEAR_VERSION)
+
+# use simgear version also as the SO version (if building SOs)
+SET(SIMGEAR_SOVERSION ${SIMGEAR_VERSION})
 
 #packaging
 SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
 SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
+SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
+SET(CPACK_GENERATOR "TBZ2")
+SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
+
+
+# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
+set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1}) 
+set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+
+message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
+
+set(CPACK_SOURCE_GENERATOR TBZ2)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
+set(CPACK_SOURCE_IGNORE_FILES
+  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
+
+message(STATUS "ignoring: ${CPACK_SOURCE_IGNORE_FILES}")
+
+include (CPack)
 
 # We have some custom .cmake scripts not in the official distribution.
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")
 
-option(SIMGEAR_SHARED "Set to ON to build SimGear as a shared library/framework" OFF)
+# Change the default build type to something fast
-option(SIMGEAR_HEADLESS "Set to ON to build SimGear with GUI/graphics support" OFF)
+if(NOT CMAKE_BUILD_TYPE)
-option(JPEG_FACTORY "Enable JPEG-factory support" OFF)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING
-set(MSVC_3RDPARTY_DIR NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
+      FORCE)
+endif(NOT CMAKE_BUILD_TYPE)
 
-if (MSVC_3RDPARTY_DIR)
+# Determine name of library installation directory, i.e. "lib" vs "lib64", which
-  message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_DIR}")
+# differs between all Debian-based vs all other Linux distros.
-  set (CMAKE_LIBRARY_PATH ${MSVC_3RDPARTY_DIR}/3rdParty/lib ${MSVC_3RDPARTY_DIR}/install/msvc90/OpenScenegraph/lib )
+# See cmake bug #11964, http://cmake.org/gitweb?p=cmake.git;a=commit;h=126c993d
-  set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_DIR}/3rdParty/include ${MSVC_3RDPARTY_DIR}/install/msvc90/OpenScenegraph/include)
+# GNUInstallDirs requires CMake >= 2.8.5, use own file for older cmake
-  set (BOOST_ROOT ${MSVC_3RDPARTY_DIR}/boost_1_44_0)
+if(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
-  set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_DIR}/3rdParty/include)
+  include(GNUInstallDirs)
-  set (ALUT_INCLUDE_DIR ${MSVC_3RDPARTY_DIR}/3rdParty/include)
+else(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
-  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_DIR}/3rdParty/lib) 
+  include(OldGNUInstallDirs)
-endif (MSVC_3RDPARTY_DIR)
+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_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)
+
+if (MSVC)
+  GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_SOURCE_DIR} PATH)
+  if (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty.x64")
+  else (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty")
+  endif (CMAKE_CL_64)
+  if (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT ${PARENT_DIR} CACHE PATH "Location where the third-party dependencies are extracted")
+  else (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+  endif (EXISTS ${TEST_3RDPARTY_DIR})
+else (MSVC)
+  set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+endif (MSVC)
+
+if (MSVC AND MSVC_3RDPARTY_ROOT)
+  message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
+  set( OSG_MSVC "msvc" )
+  if (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}100 )
+  else (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}90 )
+  endif (${MSVC_VERSION} EQUAL 1600)
+  if (CMAKE_CL_64)
+      set( OSG_MSVC ${OSG_MSVC}-64 )
+      set( MSVC_3RDPARTY_DIR 3rdParty.x64 )
+  else (CMAKE_CL_64)
+      set( MSVC_3RDPARTY_DIR 3rdParty )
+  endif (CMAKE_CL_64)
+
+  set (CMAKE_LIBRARY_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/lib )
+  set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/include)
+  set (BOOST_ROOT ${MSVC_3RDPARTY_ROOT}/boost_1_44_0)
+  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)
+endif (MSVC AND MSVC_3RDPARTY_ROOT)
 
 find_package(Boost REQUIRED)
 set (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")
 
-find_package(ZLIB REQUIRED)
+if(SIMGEAR_HEADLESS)
-find_package(Threads REQUIRED)
+    message(STATUS "SimGear mode: HEADLESS")
-
-if (${SIMGEAR_HEADLESS})
-    message(STATUS "headlesss mode")
-    set(NO_OPENSCENEGRAPH_INTERFACE 1)
 else()
+    message(STATUS "SimGear mode: NORMAL")
     find_package(OpenGL REQUIRED)
     find_package(OpenAL REQUIRED)
     find_package(ALUT REQUIRED)
-    find_package(OpenSceneGraph 2.8.2 REQUIRED osgText osgSim osgDB osgParticle osgUtil)
+    find_package(OpenSceneGraph 3.0.0 REQUIRED osgText osgSim osgDB osgParticle osgUtil)
-endif()
+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})
-endif()
+else()
+    message(STATUS "JPEG-factory: DISABLED")
+endif(JPEG_FACTORY)
+
+if(ENABLE_LIBSVN)
+    find_package(SvnClient)
+
+    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)
+
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
 
 check_include_file(sys/time.h HAVE_SYS_TIME_H)
 check_include_file(sys/timeb.h HAVE_SYS_TIMEB_H)
 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
+    message(STATUS "RTI: ENABLED")
+    find_package(RTI)
+else()
+    message(STATUS "RTI: DISABLED")
+endif(ENABLE_RTI)
+
 check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
 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)
 
-SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually d on windows")
+if(HAVE_UNISTD_H)
+    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
+    check_cxx_source_compiles(
+       "#include <unistd.h>
+        #if !defined(_POSIX_TIMERS) || (0 >= _POSIX_TIMERS)
+            #error clock_gettime is not supported
+        #endif
+
+        int main() { return 0; }
+        "
+        HAVE_CLOCK_GETTIME)
+endif(HAVE_UNISTD_H)
+
+set(RT_LIBRARY "")
+if(HAVE_CLOCK_GETTIME)
+    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")
 SET(CMAKE_RELEASE_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
-SET(CMAKE_RELWITHDEBINFO_POSTFIX "rd" CACHE STRING "add a postfix, usually empty on windows")
+SET(CMAKE_RELWITHDEBINFO_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
-SET(CMAKE_MINSIZEREL_POSTFIX "s" CACHE STRING "add a postfix, usually empty on windows")
+SET(CMAKE_MINSIZEREL_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
 
 # isnan might not be real symbol, so can't check using function_exists
 check_cxx_source_compiles(
@@ -74,36 +202,57 @@ 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})
+    check_cxx_source_compiles(
+       "int main() { unsigned mValue; return __sync_add_and_fetch(&mValue, 1); }"
+        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)
         #     SET(WARNING_FLAGS "${WARNING_FLAGS} /wd${warning}")
         # endforeach(warning)
         
-        set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS")
+        set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /wd4996")
     endif(MSVC)
     
     # assumed on Windows
     set(HAVE_GETLOCALTIME 1)
-endif(WIN32)    
+    
+    set( WINSOCK_LIBRARY "ws2_32.lib" )
+    set( RT_LIBRARY "winmm" )
+endif(WIN32)
 
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS} ${BOOST_CXX_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
@@ -111,7 +260,22 @@ configure_file (
   "${PROJECT_SOURCE_DIR}/simgear/simgear_config_cmake.h.in"
   "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
   )
-  
+
+configure_file (
+    "${PROJECT_SOURCE_DIR}/simgear/xml/expat_config_cmake.in"
+    "${PROJECT_BINARY_DIR}/simgear/xml/expat_config.h"
+)
+
+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/)
 add_subdirectory(simgear)
 
@@ -124,5 +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")
+include(FindPackageHandleStandardArgs)
-IF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ALUT  DEFAULT_MSG  ALUT_LIBRARY ALUT_INCLUDE_DIR)
-  SET(ALUT_FOUND "YES")
+
-ENDIF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+MARK_AS_ADVANCED(ALUT_LIBRARY ALUT_INCLUDE_DIR)
 

CMakeModules/FindSvnClient.cmake

@@ -0,0 +1,81 @@
+# Find Subversion client libraries, and dependencies
+# including APR (Apache Portable Runtime)
+
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+include (CheckLibraryExists)
+
+macro(find_static_component comp libs)
+    # account for alternative Windows svn distribution naming
+    if(MSVC)
+      set(compLib "lib${comp}")
+    else(MSVC)
+      set(compLib "${comp}")
+    endif(MSVC)
+    
+    string(TOUPPER "${comp}" compLibBase)
+    set( compLibName ${compLibBase}_LIBRARY )
+
+    # NO_DEFAULT_PATH is important on Mac - we need to ensure subversion
+    # libraires in dist/ or Macports are picked over the Apple version 
+    # in /usr, since that's what we will ship.
+    FIND_LIBRARY(${compLibName}
+      NO_DEFAULT_PATH
+      NAMES ${compLib}
+      HINTS $ENV{LIBSVN_DIR} ${CMAKE_INSTALL_PREFIX} 
+      PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
+      PATHS
+      /opt/local
+      /usr/local
+      /usr
+    )
+
+	list(APPEND ${libs} ${${compLibName}})
+endmacro()
+
+find_program(HAVE_APR_CONFIG apr-1-config)
+if(HAVE_APR_CONFIG) 
+        
+    execute_process(COMMAND apr-1-config --cppflags --includes
+        OUTPUT_VARIABLE APR_CFLAGS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+        
+    execute_process(COMMAND apr-1-config --link-ld
+        OUTPUT_VARIABLE RAW_APR_LIBS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    
+# clean up some vars, or other CMake pieces complain
+	string(STRIP "${RAW_APR_LIBS}" APR_LIBS)
+
+else(HAVE_APR_CONFIG)
+    message(STATUS "apr-1-config not found, implement manual search for APR")
+endif(HAVE_APR_CONFIG)
+
+if(HAVE_APR_CONFIG OR MSVC)
+	find_path(LIBSVN_INCLUDE_DIR svn_client.h
+      NO_DEFAULT_PATH
+	  HINTS
+	  $ENV{LIBSVN_DIR} ${CMAKE_INSTALL_PREFIX}
+	  PATH_SUFFIXES include/subversion-1
+	  PATHS
+      /opt/local
+	  /usr/local
+	  /usr
+	)
+	
+	set(LIBSVN_LIBRARIES "")
+	if (MSVC)
+		find_static_component("apr-1" LIBSVN_LIBRARIES)
+	else (MSVC)
+		list(APPEND LIBSVN_LIBRARIES ${APR_LIBS})
+	endif (MSVC)
+	find_static_component("svn_client-1" LIBSVN_LIBRARIES)
+	find_static_component("svn_subr-1" LIBSVN_LIBRARIES)
+	find_static_component("svn_ra-1" LIBSVN_LIBRARIES)
+
+	include(FindPackageHandleStandardArgs)
+	FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG LIBSVN_LIBRARIES LIBSVN_INCLUDE_DIR)
+        if(NOT LIBSVN_FOUND)
+		set(LIBSVN_LIBRARIES "")
+        endif(NOT LIBSVN_FOUND)
+endif(HAVE_APR_CONFIG OR MSVC)

CMakeModules/OldGNUInstallDirs.cmake

@@ -0,0 +1,182 @@
+# - Define GNU standard installation directories
+# Provides install directory variables as defined for GNU software:
+#  http://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+# Inclusion of this module defines the following variables:
+#  CMAKE_INSTALL_<dir>      - destination for files of a given type
+#  CMAKE_INSTALL_FULL_<dir> - corresponding absolute path
+# where <dir> is one of:
+#  BINDIR           - user executables (bin)
+#  SBINDIR          - system admin executables (sbin)
+#  LIBEXECDIR       - program executables (libexec)
+#  SYSCONFDIR       - read-only single-machine data (etc)
+#  SHAREDSTATEDIR   - modifiable architecture-independent data (com)
+#  LOCALSTATEDIR    - modifiable single-machine data (var)
+#  LIBDIR           - object code libraries (lib or lib64)
+#  INCLUDEDIR       - C header files (include)
+#  OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
+#  DATAROOTDIR      - read-only architecture-independent data root (share)
+#  DATADIR          - read-only architecture-independent data (DATAROOTDIR)
+#  INFODIR          - info documentation (DATAROOTDIR/info)
+#  LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
+#  MANDIR           - man documentation (DATAROOTDIR/man)
+#  DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)
+# Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION options of
+# install() commands for the corresponding file type.  If the includer does
+# not define a value the above-shown default will be used and the value will
+# appear in the cache for editing by the user.
+# Each CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed
+# from the corresponding destination by prepending (if necessary) the value
+# of CMAKE_INSTALL_PREFIX.
+
+#=============================================================================
+# Copyright 2011 Nikita Krupen'ko <krnekit@gmail.com>
+# Copyright 2011 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Installation directories
+#
+if(NOT DEFINED CMAKE_INSTALL_BINDIR)
+  set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "user executables (bin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SBINDIR)
+  set(CMAKE_INSTALL_SBINDIR "sbin" CACHE PATH "system admin executables (sbin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBEXECDIR)
+  set(CMAKE_INSTALL_LIBEXECDIR "libexec" CACHE PATH "program executables (libexec)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR)
+  set(CMAKE_INSTALL_SYSCONFDIR "etc" CACHE PATH "read-only single-machine data (etc)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SHAREDSTATEDIR)
+  set(CMAKE_INSTALL_SHAREDSTATEDIR "com" CACHE PATH "modifiable architecture-independent data (com)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR)
+  set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+  set(_LIBDIR_DEFAULT "lib")
+  # Override this default 'lib' with 'lib64' iff:
+  #  - we are on Linux system but NOT cross-compiling
+  #  - we are NOT on debian
+  #  - we are on a 64 bits system
+  # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf
+  # Note that the future of multi-arch handling may be even
+  # more complicated than that: http://wiki.debian.org/Multiarch
+  if(CMAKE_SYSTEM_NAME MATCHES "Linux"
+      AND NOT CMAKE_CROSSCOMPILING
+      AND NOT EXISTS "/etc/debian_version")
+    if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+      message(AUTHOR_WARNING
+        "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+        "Please enable at least one language before including GNUInstallDirs.")
+    else()
+      if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+        set(_LIBDIR_DEFAULT "lib64")
+      endif()
+    endif()
+  endif()
+  set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
+  set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_OLDINCLUDEDIR)
+  set(CMAKE_INSTALL_OLDINCLUDEDIR "/usr/include" CACHE PATH "C header files for non-gcc (/usr/include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR)
+  set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE PATH "read-only architecture-independent data root (share)")
+endif()
+
+#-----------------------------------------------------------------------------
+# Values whose defaults are relative to DATAROOTDIR.  Store empty values in
+# the cache and store the defaults in local variables if the cache values are
+# not set explicitly.  This auto-updates the defaults as DATAROOTDIR changes.
+
+if(NOT CMAKE_INSTALL_DATADIR)
+  set(CMAKE_INSTALL_DATADIR "" CACHE PATH "read-only architecture-independent data (DATAROOTDIR)")
+  set(CMAKE_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}")
+endif()
+
+if(NOT CMAKE_INSTALL_INFODIR)
+  set(CMAKE_INSTALL_INFODIR "" CACHE PATH "info documentation (DATAROOTDIR/info)")
+  set(CMAKE_INSTALL_INFODIR "${CMAKE_INSTALL_DATAROOTDIR}/info")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCALEDIR)
+  set(CMAKE_INSTALL_LOCALEDIR "" CACHE PATH "locale-dependent data (DATAROOTDIR/locale)")
+  set(CMAKE_INSTALL_LOCALEDIR "${CMAKE_INSTALL_DATAROOTDIR}/locale")
+endif()
+
+if(NOT CMAKE_INSTALL_MANDIR)
+  set(CMAKE_INSTALL_MANDIR "" CACHE PATH "man documentation (DATAROOTDIR/man)")
+  set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man")
+endif()
+
+if(NOT CMAKE_INSTALL_DOCDIR)
+  set(CMAKE_INSTALL_DOCDIR "" CACHE PATH "documentation root (DATAROOTDIR/doc/PROJECT_NAME)")
+  set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}")
+endif()
+
+#-----------------------------------------------------------------------------
+
+mark_as_advanced(
+  CMAKE_INSTALL_BINDIR
+  CMAKE_INSTALL_SBINDIR
+  CMAKE_INSTALL_LIBEXECDIR
+  CMAKE_INSTALL_SYSCONFDIR
+  CMAKE_INSTALL_SHAREDSTATEDIR
+  CMAKE_INSTALL_LOCALSTATEDIR
+  CMAKE_INSTALL_LIBDIR
+  CMAKE_INSTALL_INCLUDEDIR
+  CMAKE_INSTALL_OLDINCLUDEDIR
+  CMAKE_INSTALL_DATAROOTDIR
+  CMAKE_INSTALL_DATADIR
+  CMAKE_INSTALL_INFODIR
+  CMAKE_INSTALL_LOCALEDIR
+  CMAKE_INSTALL_MANDIR
+  CMAKE_INSTALL_DOCDIR
+  )
+
+# Result directories
+#
+foreach(dir
+    BINDIR
+    SBINDIR
+    LIBEXECDIR
+    SYSCONFDIR
+    SHAREDSTATEDIR
+    LOCALSTATEDIR
+    LIBDIR
+    INCLUDEDIR
+    OLDINCLUDEDIR
+    DATAROOTDIR
+    DATADIR
+    INFODIR
+    LOCALEDIR
+    MANDIR
+    DOCDIR
+    )
+  if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_${dir}})
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${dir}}")
+  else()
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_${dir}}")
+  endif()
+endforeach()

CMakeModules/SimGearComponent.cmake

@@ -1,10 +1,10 @@
 
-macro(simgear_component name includePath sources headers)
+macro(simgear_component_common name includePath sourcesList sources headers)
-
     if (SIMGEAR_SHARED)
+
         foreach(s ${sources})
             set_property(GLOBAL
-                APPEND PROPERTY ALL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+                APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
         endforeach()
 
 		foreach(h ${headers})
@@ -14,10 +14,18 @@ macro(simgear_component name includePath sources headers)
         
     else()
         set(libName "sg${name}")
-        add_library(${libName} STATIC ${sources} )
+        add_library(${libName} STATIC ${sources} ${headers})
 
-        install (TARGETS ${libName} ARCHIVE DESTINATION lib${LIB_SUFFIX})
+        install (TARGETS ${libName} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-        install (FILES ${headers}  DESTINATION include/simgear/${includePath})
     endif()
     
+    install (FILES ${headers}  DESTINATION include/simgear/${includePath})
 endmacro()
+
+function(simgear_component name includePath sources headers)
+    simgear_component_common(${name} ${includePath} CORE_SOURCES "${sources}" "${headers}")
+endfunction()
+
+function(simgear_scene_component name includePath sources headers)
+    simgear_component_common(${name} ${includePath} SCENE_SOURCES "${sources}" "${headers}")
+endfunction()

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
+

Makefile.am

@@ -1,18 +0,0 @@
-EXTRA_DIST = \
-	acinclude.m4 \
-	autogen.sh \
-	DoxygenMain.cxx \
-	README.zlib \
-	README.plib \
-	README.OpenAL \
-	README.OSG \
-	projects
-
-SUBDIRS	= simgear
-
-#
-# Rule to build RPM distribution package
-#
-rpm: dist
-	rpm -ta $(PACKAGE)-$(VERSION).tar.gz
-

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

@@ -1,10 +1,9 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 
-You *must* have OpenSceneGraph (OSG) installed to build this version of 
+You *must* have OpenSceneGraph (OSG) installed to build this version of
 FlightGear.
 
-Notice that FlightGear 1.9.0 requires at least version 2.7.8. Using earlier 
+Notice that this version of SimGear/FlightGear requires at least OSG 3.0.0.
-versions of OSG will yield serious rendering bugs. 
 
 You can get the latest version of OSG from:
 
@@ -22,6 +21,6 @@ ccmake .
 [ While running ccmake: press 'c' to configure, press 'c' once more, and
   then press 'g' to generate and exit ]
 
-make 
+make
 sudo make install
 

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.

acinclude.m4

@@ -1,706 +0,0 @@
-dnl
-dnl originally from ncftp 2.3.0
-dnl added wi_EXTRA_PDIR and wi_ANSI_C
-dnl $Id$
-dnl
-AC_DEFUN([wi_EXTRA_IDIR], [
-incdir="$1"
-if test -r $incdir ; then
-    already=""
-    for CPPflag in $CPPFLAGS ; do
-	if test  "_$CPPflag" = "_-I${incdir}" ; then 
-            already=yes
-            break
-        fi
-    done
-    if test -n "$already" ; then
-        echo "   + already had -I$incdir" 1>&AS_MESSAGE_LOG_FD
-    else
-        if test "$CPPFLAGS" = "" ; then
-                CPPFLAGS="-I$incdir"
-        else
-                CPPFLAGS="$CPPFLAGS -I$incdir"
-        fi
-        echo "   + added -I$incdir" 1>&AS_MESSAGE_LOG_FD
-    fi
-else 
-    echo "   + IDIR is not accessible: '$myincdir'" 1>&AS_MESSAGE_LOG_FD
-fi
-])
-dnl
-dnl
-dnl
-dnl
-AC_DEFUN([wi_EXTRA_LDIR], [
-mylibdir="$1"
-if test -r $mylibdir ; then
-    already=""
-    for LDflag in $LDFLAGS ; do
-	if test  "_$LDflag" = "_-L${mylibdir}" ; then 
-            already=yes
-            break
-        fi
-    done
-    if test -n "$already" ; then
-        echo "   + already had -L$mylibdir" 1>&AS_MESSAGE_LOG_FD
-    else
-        if test "$LDFLAGS" = "" ; then
-                LDFLAGS="-L$mylibdir"
-        else
-                LDFLAGS="$LDFLAGS -L$mylibdir"
-        fi
-        echo "   + added -L$mylibdir" 1>&AS_MESSAGE_LOG_FD
-    fi
-else 
-    echo "   + LDIR is not accessible: '$mylibdir'" 1>&AS_MESSAGE_LOG_FD
-fi
-])
-dnl
-dnl __FP__
-dnl
-dnl
-AC_DEFUN([wi_EXTRA_PDIR], [
-progdir="$1"
-if test -r $progdir ; then
-	case ":$PATH:" in
-		*:${progdir}:*)
-			echo "   + already had $progdir in \$PATH" 1>&AS_MESSAGE_LOG_FD
-			;;
-		*)
-			if test "$PATH" = "" ; then
-				PATH="$progdir"
-			else
-				PATH="$PATH:$progdir"
-			fi
-			echo "   + appended $progdir to \$PATH" 1>&AS_MESSAGE_LOG_FD
-			;;
-	esac
-else 
-       echo "   + PDIR is not accessible: '$progdir'" 1>&AS_MESSAGE_LOG_FD
-fi
-])
-dnl
-dnl
-dnl If you want to also look for include and lib subdirectories in the
-dnl $HOME tree, you supply "yes" as the first argument to this macro.
-dnl
-dnl If you want to look for subdirectories in include/lib directories,
-dnl you pass the names in argument 3, otherwise pass a dash.
-dnl
-AC_DEFUN([wi_EXTRA_DIRS], [echo "checking for extra include and lib directories..." 1>&6
-ifelse([$1], yes, [dnl
-b1=`cd .. ; pwd`
-b2=`cd ../.. ; pwd`
-exdirs="$HOME $j $b1 $b2 $prefix $2"
-],[dnl
-exdirs="$prefix $2"
-])
-subexdirs="$3"
-if test "$subexdirs" = "" ; then
-	subexdirs="-"
-fi
-for subexdir in $subexdirs ; do
-    if test "$subexdir" = "-" ; then
-            subexdir=""
-    else
-            subexdir="/$subexdir"
-    fi
-    for exdir in $exdirs ; do
-        if test "$exdir" != "/usr" || test "$subexdir" != ""; then
-            incdir="${exdir}/include${subexdir}"
-            wi_EXTRA_IDIR($incdir)
-
-dnl On 64-bit machines, if lib64/ exists and is not identical to lib/
-dnl then it should be listed here, listed ahead of lib/.
-            mylibdir64="${exdir}/lib64${subexdir}"
-            mylibdir32="${exdir}/lib${subexdir}"
-
-            if test "x86_64" = $(uname -m) \
-              -a ! ${mylibdir64} -ef ${mylibdir32} ; then
-                wi_EXTRA_LDIR($mylibdir64)
-            fi
-
-            wi_EXTRA_LDIR($mylibdir32)
-
-            progdir="${exdir}/bin${subexdir}"
-            wi_EXTRA_PDIR($progdir)
-        fi
-    done
-done
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_HPUX_CFLAGS],
-[AC_MSG_CHECKING(if HP-UX ansi C compiler flags are needed)
-AC_REQUIRE([AC_PROG_CC])
-os=`uname -s | tr '[A-Z]' '[a-z]'`
-ac_cv_hpux_flags=no
-if test "$os" = hp-ux ; then
-	if test "$ac_cv_prog_gcc" = yes ; then
-		if test "$CFLAGS" != "" ; then
-			# Shouldn't be in there.
-			CFLAGS=`echo "$CFLAGS" | sed 's/-Aa//g'`
-		fi
-	else
-		# If you're not using gcc, then you better have a cc/c89
-		# that is usable.  If you have the barebones compiler, it
-		# won't work.  The good compiler uses -Aa for the ANSI
-		# compatible stuff.
-		x=`echo $CFLAGS | grep 'Aa' 2>/dev/null`
-		if test "$x" = "" ; then
-			CFLAGS="$CFLAGS -Aa"
-		fi
-		ac_cv_hpux_flags=yes
-	fi
-	# Also add _HPUX_SOURCE to get the extended namespace.
-	x=`echo $CFLAGS | grep '_HPUX_SOURCE' 2>/dev/null`
-	if test "$x" = "" ; then
-		CFLAGS="$CFLAGS -D_HPUX_SOURCE"
-	fi
-fi
-AC_MSG_RESULT($ac_cv_hpux_flags)
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_CFLAGS], [AC_REQUIRE([AC_PROG_CC])
-wi_HPUX_CFLAGS
-	if test "$CFLAGS" = "" ; then
-		CFLAGS="-O"
-	elif test "$ac_cv_prog_gcc" = "yes" ; then
-		case "$CFLAGS" in
-			*"-g -O"*)
-				#echo "using -g as default gcc CFLAGS" 1>&6
-				CFLAGS=`echo $CFLAGS | sed 's/-g\ -O/-O/'`
-				;;
-			*"-O -g"*)
-				# Leave the -g, but remove all -O options.
-				#echo "using -g as default gcc CFLAGS" 1>&6
-				CFLAGS=`echo $CFLAGS | sed 's/-O\ -g/-O/'`
-				;;
-		esac
-	fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_PROTOTYPES], [
-AC_MSG_CHECKING(if the compiler supports function prototypes)
-AC_TRY_COMPILE(,[extern void exit(int status);],[wi_cv_prototypes=yes
-AC_DEFINE(PROTOTYPES)],wi_cv_prototypes=no)
-AC_MSG_RESULT($wi_cv_prototypes)
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_ANSI_C], [
-AC_MSG_CHECKING(ANSI-style function definitions)
-AC_TRY_COMPILE(,[int blubb(int x) { return 0; }],[wi_cv_ansi_funcs=yes
-AC_DEFINE(ANSI_FUNCS)],wi_cv_ansi_funcs=no)
-AC_MSG_RESULT($wi_cv_ansi_funcs)
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_HEADER_SYS_SELECT_H], [
-# See if <sys/select.h> is includable after <sys/time.h>
-if test "$ac_cv_header_sys_time_h" = no ; then
-AC_CHECK_HEADERS(sys/time.h sys/select.h)
-else
-AC_CHECK_HEADERS(sys/select.h)
-fi
-if test "$ac_cv_header_sys_select_h" = yes ; then
-	AC_MSG_CHECKING([if <sys/select.h> is compatible with <sys/time.h>])
-	selecth=yes
-	if test "$ac_cv_header_sys_time_h" = yes ; then
-		AC_TRY_COMPILE([#include <sys/time.h>
-		#include <sys/select.h>],[
-		fd_set a;
-		struct timeval tmval;
-
-		tmval.tv_sec = 0;],selecth=yes,selecth=no)
-
-		if test "$selecth" = yes ; then
-			AC_DEFINE(CAN_USE_SYS_SELECT_H)
-		fi
-	fi
-	AC_MSG_RESULT($selecth)
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_LIB_RESOLV], [
-# See if we could access two well-known sites without help of any special
-# libraries, like resolv.
-
-AC_TRY_RUN([
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
- 
-main()
-{
-	struct hostent *hp1, *hp2;
-	int result;
-
-	hp1 = gethostbyname("gatekeeper.dec.com");
-	hp2 = gethostbyname("ftp.ncsa.uiuc.edu");
-	result = ((hp1 != (struct hostent *) 0) && (hp2 != (struct hostent *) 0));
-	exit(! result);
-}],look_for_resolv=no,look_for_resolv=yes,look_for_resolv=yes)
-
-AC_MSG_CHECKING([if we need to look for -lresolv])
-AC_MSG_RESULT($look_for_resolv)
-if test "$look_for_resolv" = yes ; then
-AC_CHECK_LIB(resolv,main)
-else
-	ac_cv_lib_resolv=no
-fi
-])
-dnl
-dnl
-dnl
-
-AC_DEFUN([wi_LIB_NSL], [
-AC_MSG_CHECKING(if we can use -lnsl)
-ac_save_LIBS="$LIBS";
-LIBS="$LIBS -lnsl";
-AC_CACHE_VAL(r_cv_use_libnsl, [
-AC_TRY_RUN(
-main() { if (getpwuid(getuid())) exit(0); exit(-1); },
-nc_cv_use_libnsl=yes, nc_cv_use_libnsl=no, nc_cv_use_libnsl=no)
-])
-if test "$nc_cv_use_libnsl" = "no"; then LIBS="$ac_save_LIBS"; fi
-AC_MSG_RESULT($nc_cv_use_libnsl)
-])dnl
-
-dnl
-dnl
-dnl
-
-AC_DEFUN([nc_PATH_PROG_ZCAT], [
-AC_PATH_PROG(GZCAT,gzcat)
-AC_PATH_PROG(ZCAT,zcat)
-if test "x$GZCAT" = x ; then
-	if test "x$ZCAT" != x ; then
-		# See if zcat is really gzcat.  gzcat has a --version option, regular
-		# zcat does not.
-		AC_MSG_CHECKING(if zcat is really gzcat in disguise)
-		if $ZCAT --version 2> /dev/null ; then
-			AC_DEFINE_UNQUOTED(GZCAT, "$ZCAT")
-			AC_MSG_RESULT(yes)
-		else
-			AC_MSG_RESULT(no)
-		fi
-	fi
-else
-	AC_DEFINE_UNQUOTED(GZCAT, "$GZCAT")
-fi
-
-if test "x$ZCAT" != x ; then
-	AC_DEFINE_UNQUOTED(ZCAT, "$ZCAT")
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_SYSV_EXTRA_DIRS], [
-# Use System V because their curses extensions are required.  This must
-# be done early so we use the -I and -L in the library checks also.
-# This is mostly a Solaris/SunOS hack.  Note that doing this will also
-# use all of the other System V libraries and headers.
-
-AC_MSG_CHECKING(for alternative System V libraries)
-if test -f /usr/5include/curses.h ; then
-	CPPFLAGS="$CPPFLAGS -I/usr/5include"
-	LDFLAGS="$LDFLAGS -L/usr/5lib"
-	AC_MSG_RESULT(yes)
-else
-	AC_MSG_RESULT(no)
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_DEFINE_UNAME], [
-# Get first 127 chars of all uname information.  Some folks have
-# way too much stuff there, so grab only the first 127.
-unam=`uname -a 2>/dev/null | cut -c1-127`
-if test "$unam" != "" ; then
-	AC_DEFINE_UNQUOTED(UNAME, "$unam")
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN([wi_READLINE_WITH_NCURSES], [
-# Readline and Ncurses could both define "backspace".
-# Warn about this if we have both things in our definitions list.
-
-if test "$ac_cv_lib_readline" = yes && test "$ac_cv_lib_ncurses" = yes ; then
-
-AC_MSG_CHECKING(if readline and ncurses will link together)
-j="$LIBS"
-LIBS="-lreadline -lncurses"
-AC_TRY_LINK(,[
-readline("prompt");
-endwin();
-],k=yes,k=no)
-if test "$k" = no ; then
-	AC_MSG_RESULT(no)
-	# Remove '-lreadline' from LIBS.
-	LIBS=`echo $j | sed s/-lreadline//g`
-	ac_cv_lib_readline=no
-	AC_WARN([The versions of GNU readline and ncurses you have installed on this system
-can't be used together, because they use the same symbol, backspace. If
-possible, recompile one of the libraries with -Dbackspace=back_space, then
-re-run configure.])
-
-else
-	AC_MSG_RESULT(yes)
-	LIBS="$j"
-fi
-
-fi
-])
-dnl
-dnl
-dnl
-
-dnl AC_EXT_DAYLIGHT
-dnl Check for an external variable daylight. Stolen from w3c-libwww.
-AC_DEFUN([AC_EXT_DAYLIGHT],
-[ AC_MSG_CHECKING(int daylight variable)
-AC_TRY_COMPILE([#include <time.h>], [return daylight;],
-  have_daylight=yes,
-  have_daylight=no)
-AC_MSG_RESULT($have_daylight)
-])dnl
-
-dnl AC_EXT_TIMEZONE
-dnl Check for an external variable timezone. Stolen from tcl-8.0.
-AC_DEFUN([AC_EXT_TIMEZONE],
-[
-#
-# Its important to include time.h in this check, as some systems (like convex)
-# have timezone functions, etc.
-#
-have_timezone=no
-AC_MSG_CHECKING([long timezone variable])
-AC_TRY_COMPILE([#include <time.h>],
-        [extern long timezone;
-         timezone += 1;
-         exit (0);],
-        [have_timezone=yes
-         AC_MSG_RESULT(yes)],
-         AC_MSG_RESULT(no))
-
-#
-# On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
-#
-if test "$have_timezone" = no; then
-   AC_MSG_CHECKING([time_t timezone variable])
-   AC_TRY_COMPILE([#include <time.h>],
-        [extern time_t timezone;
-         timezone += 1;
-         exit (0);],
-        [have_timezone=yes
-         AC_MSG_RESULT(yes)],
-         AC_MSG_RESULT(no))
-fi
-])dnl
-
-## AC_BZ_SET_COMPILER: Addition by Theodore Papadopoulo
-## Patch by Jim McKelvey: change sed -e 's/ /@/g' to sed -e 's/ /@/'
-AC_DEFUN([AC_SG_SET_COMPILER],
-  [cxxwith=`echo $1 | sed -e 's/ /@/'`
-   case "$cxxwith" in
-     *:*@*)                 # Full initialization syntax
-       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
-       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
-     ;;
-     *:*)                   # Simple initialization syntax
-       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
-       CXXFLAGS=$3
-     ;;
-     *)                     # Default values
-       CXX=$2
-       CXXFLAGS=$3
-       CC="$2 --c"
-##       CFLAGS=
-     ;;
-   esac])
-
-pushdef([AC_PROG_INSTALL],
-[
-  dnl our own version, testing for a -p flag
-  popdef([AC_PROG_INSTALL])
-  dnl as AC_PROG_INSTALL works as it works we first have
-  dnl to save if the user didn't specify INSTALL, as the
-  dnl autoconf one overwrites INSTALL and we have no chance to find
-  dnl out afterwards
-  AC_PROG_INSTALL
-
-    # OK, user hasn't given any INSTALL, autoconf found one for us
-    # now we test, if it supports the -p flag
-    AC_MSG_CHECKING(for -p flag to install)
-    rm -f confinst.$$.* > /dev/null 2>&1
-    echo "Testtest" > confinst.$$.orig
-    ac_res=no
-    if ${INSTALL} -p confinst.$$.orig confinst.$$.new > /dev/null 2>&1 ; then
-      if test -f confinst.$$.new ; then
-        # OK, -p seems to do no harm to install
-        INSTALL="${INSTALL} -p"
-        ac_res=yes
-      fi
-    fi
-    rm -f confinst.$$.*
-    AC_MSG_RESULT($ac_res)
-  dnl the following tries to resolve some signs and wonders coming up
-  dnl with different autoconf/automake versions
-  dnl e.g.:
-  dnl  *automake 1.4 install-strip sets A_M_INSTALL_PROGRAM_FLAGS to -s
-  dnl   and has INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(A_M_INSTALL_PROGRAM_FLAGS)
-  dnl   it header-vars.am, so there the actual INSTALL_PROGRAM gets the -s
-  dnl  *automake 1.4a (and above) use INSTALL_STRIP_FLAG and only has
-  dnl   INSTALL_PROGRAM = @INSTALL_PROGRAM@ there, but changes the
-  dnl   install-@DIR@PROGRAMS targets to explicitly use that flag
-  dnl  *autoconf 2.13 is dumb, and thinks it can use INSTALL_PROGRAM as
-  dnl   INSTALL_SCRIPT, which breaks with automake <= 1.4
-  dnl  *autoconf >2.13 (since 10.Apr 1999) has not that failure
-  dnl to clean up that mess we:
-  dnl  +set INSTALL_PROGRAM to use INSTALL_STRIP_FLAG
-  dnl   which cleans KDE's program with automake > 1.4;
-  dnl  +set INSTALL_SCRIPT to only use INSTALL, to clean up autoconf's problems
-  dnl   with automake<=1.4
-  dnl  note that dues to this sometimes two '-s' flags are used
-    INSTALL_PROGRAM='${INSTALL} $(INSTALL_STRIP_FLAG)'
-    INSTALL_SCRIPT='${INSTALL}'
-])dnl
-
-# ===========================================================================
-#             http://autoconf-archive.cryp.to/ax_boost_base.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_BOOST_BASE([MINIMUM-VERSION])
-#
-# DESCRIPTION
-#
-#   Test for the Boost C++ libraries of a particular version (or newer)
-#
-#   If no path to the installed boost library is given the macro searchs
-#   under /usr, /usr/local, /opt and /opt/local and evaluates the
-#   $BOOST_ROOT environment variable. Further documentation is available at
-#   <http://randspringer.de/boost/index.html>.
-#
-#   This macro calls:
-#
-#     AC_SUBST(BOOST_CPPFLAGS) / AC_SUBST(BOOST_LDFLAGS)
-#
-#   And sets:
-#
-#     HAVE_BOOST
-#
-# LAST MODIFICATION
-#
-#   2008-04-12
-#
-# COPYLEFT
-#
-#   Copyright (c) 2008 Thomas Porschberg <thomas@randspringer.de>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved.
-
-AC_DEFUN([AX_BOOST_BASE],
-[
-AC_ARG_WITH([boost],
-	AS_HELP_STRING([--with-boost@<:@=DIR@:>@], [use boost (default is yes) - it is possible to specify the root directory for boost (optional)]),
-	[
-    if test "$withval" = "no"; then
-		want_boost="no"
-    elif test "$withval" = "yes"; then
-        want_boost="yes"
-        ac_boost_path=""
-    else
-	    want_boost="yes"
-        ac_boost_path="$withval"
-	fi
-    ],
-    [want_boost="yes"])
-
-
-AC_ARG_WITH([boost-libdir],
-        AS_HELP_STRING([--with-boost-libdir=LIB_DIR],
-        [Force given directory for boost libraries. Note that this will overwrite library path detection, so use this parameter only if default library detection fails and you know exactly where your boost libraries are located.]),
-        [
-        if test -d $withval
-        then
-                ac_boost_lib_path="$withval"
-        else
-                AC_MSG_ERROR(--with-boost-libdir expected directory name)
-        fi
-        ],
-        [ac_boost_lib_path=""]
-)
-
-if test "x$want_boost" = "xyes"; then
-	boost_lib_version_req=ifelse([$1], ,1.20.0,$1)
-	boost_lib_version_req_shorten=`expr $boost_lib_version_req : '\([[0-9]]*\.[[0-9]]*\)'`
-	boost_lib_version_req_major=`expr $boost_lib_version_req : '\([[0-9]]*\)'`
-	boost_lib_version_req_minor=`expr $boost_lib_version_req : '[[0-9]]*\.\([[0-9]]*\)'`
-	boost_lib_version_req_sub_minor=`expr $boost_lib_version_req : '[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)'`
-	if test "x$boost_lib_version_req_sub_minor" = "x" ; then
-		boost_lib_version_req_sub_minor="0"
-    	fi
-	WANT_BOOST_VERSION=`expr $boost_lib_version_req_major \* 100000 \+  $boost_lib_version_req_minor \* 100 \+ $boost_lib_version_req_sub_minor`
-	AC_MSG_CHECKING(for boostlib >= $boost_lib_version_req)
-	succeeded=no
-
-	dnl first we check the system location for boost libraries
-	dnl this location ist chosen if boost libraries are installed with the --layout=system option
-	dnl or if you install boost with RPM
-	if test "$ac_boost_path" != ""; then
-		BOOST_LDFLAGS="-L$ac_boost_path/lib"
-		BOOST_CPPFLAGS="-I$ac_boost_path/include"
-	else
-		for ac_boost_path_tmp in /usr /usr/local /opt /opt/local ; do
-			if test -d "$ac_boost_path_tmp/include/boost" && test -r "$ac_boost_path_tmp/include/boost"; then
-				BOOST_LDFLAGS="-L$ac_boost_path_tmp/lib"
-				BOOST_CPPFLAGS="-I$ac_boost_path_tmp/include"
-				break;
-			fi
-		done
-	fi
-
-    dnl overwrite ld flags if we have required special directory with
-    dnl --with-boost-libdir parameter
-    if test "$ac_boost_lib_path" != ""; then
-       BOOST_LDFLAGS="-L$ac_boost_lib_path"
-    fi
-
-	CPPFLAGS_SAVED="$CPPFLAGS"
-	CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-	export CPPFLAGS
-
-	LDFLAGS_SAVED="$LDFLAGS"
-	LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
-	export LDFLAGS
-
-	AC_LANG_PUSH(C++)
-     	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-	@%:@include <boost/version.hpp>
-	]], [[
-	#if BOOST_VERSION >= $WANT_BOOST_VERSION
-	// Everything is okay
-	#else
-	#  error Boost version is too old
-	#endif
-	]])],[
-        AC_MSG_RESULT(yes)
-	succeeded=yes
-	found_system=yes
-       	],[
-       	])
-	AC_LANG_POP([C++])
-
-
-
-	dnl if we found no boost with system layout we search for boost libraries
-	dnl built and installed without the --layout=system option or for a staged(not installed) version
-	if test "x$succeeded" != "xyes"; then
-		_version=0
-		if test "$ac_boost_path" != ""; then
-			if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
-				for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
-					_version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
-					V_CHECK=`expr $_version_tmp \> $_version`
-					if test "$V_CHECK" = "1" ; then
-						_version=$_version_tmp
-					fi
-					VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
-					BOOST_CPPFLAGS="-I$ac_boost_path/include/boost-$VERSION_UNDERSCORE"
-				done
-			fi
-		else
-			for ac_boost_path in /usr /usr/local /opt /opt/local ; do
-				if test -d "$ac_boost_path" && test -r "$ac_boost_path"; then
-					for i in `ls -d $ac_boost_path/include/boost-* 2>/dev/null`; do
-						_version_tmp=`echo $i | sed "s#$ac_boost_path##" | sed 's/\/include\/boost-//' | sed 's/_/./'`
-						V_CHECK=`expr $_version_tmp \> $_version`
-						if test "$V_CHECK" = "1" ; then
-							_version=$_version_tmp
-	               					best_path=$ac_boost_path
-						fi
-					done
-				fi
-			done
-
-			VERSION_UNDERSCORE=`echo $_version | sed 's/\./_/'`
-			BOOST_CPPFLAGS="-I$best_path/include/boost-$VERSION_UNDERSCORE"
-            if test "$ac_boost_lib_path" = ""
-            then
-               BOOST_LDFLAGS="-L$best_path/lib"
-            fi
-
-	    		if test "x$BOOST_ROOT" != "x"; then
-				if test -d "$BOOST_ROOT" && test -r "$BOOST_ROOT" && test -d "$BOOST_ROOT/stage/lib" && test -r "$BOOST_ROOT/stage/lib"; then
-					version_dir=`expr //$BOOST_ROOT : '.*/\(.*\)'`
-					stage_version=`echo $version_dir | sed 's/boost_//' | sed 's/_/./g'`
-			        	stage_version_shorten=`expr $stage_version : '\([[0-9]]*\.[[0-9]]*\)'`
-					V_CHECK=`expr $stage_version_shorten \>\= $_version`
-                    if test "$V_CHECK" = "1" -a "$ac_boost_lib_path" = "" ; then
-						AC_MSG_NOTICE(We will use a staged boost library from $BOOST_ROOT)
-						BOOST_CPPFLAGS="-I$BOOST_ROOT"
-						BOOST_LDFLAGS="-L$BOOST_ROOT/stage/lib"
-					fi
-				fi
-	    		fi
-		fi
-
-		CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-		export CPPFLAGS
-		LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
-		export LDFLAGS
-
-		AC_LANG_PUSH(C++)
-	     	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-		@%:@include <boost/version.hpp>
-		]], [[
-		#if BOOST_VERSION >= $WANT_BOOST_VERSION
-		// Everything is okay
-		#else
-		#  error Boost version is too old
-		#endif
-		]])],[
-        	AC_MSG_RESULT(yes)
-		succeeded=yes
-		found_system=yes
-       		],[
-	       	])
-		AC_LANG_POP([C++])
-	fi
-
-	if test "$succeeded" != "yes" ; then
-		if test "$_version" = "0" ; then
-			AC_MSG_ERROR([[We could not detect the boost libraries (version $boost_lib_version_req_shorten or higher). If you have a staged boost library (still not installed) please specify \$BOOST_ROOT in your environment and do not give a PATH to --with-boost option.  If you are sure you have boost installed, then check your version number looking in <boost/version.hpp>. See http://randspringer.de/boost for more documentation.]])
-		else
-			AC_MSG_ERROR([Your boost libraries seems to old (version $_version).])
-		fi
-	else
-		AC_SUBST(BOOST_CPPFLAGS)
-		AC_SUBST(BOOST_LDFLAGS)
-		AC_DEFINE(HAVE_BOOST,,[define if the Boost library is available])
-	fi
-
-        CPPFLAGS="$CPPFLAGS_SAVED"
-       	LDFLAGS="$LDFLAGS_SAVED"
-fi
-
-])

am2dsp.cfg

@@ -1,38 +0,0 @@
-type = StaticLibrary,Multithreaded,
-exclude_dir = threads
-
-include_path = .
-include_path = ..
-include_path = .\SimGear
-include_path = ..\zlib-1.2.3
-include_path = "..\OpenAL 1.0 Software Development Kit\include"
-
-define = _USE_MATH_DEFINES
-define = _CRT_SECURE_NO_DEPRECATE
-define = HAVE_CONFIG_H
-
-# Rule to create simgear_config.h
-add_source_file = SOURCE=.\simgear\simgear_config.h.vc5\
-\
-!IF  "$(CFG)" == "SimGear - Win32 Release"\
-\
-# Begin Custom Build - Creating config.h\
-InputPath=.\simgear\simgear_config.h.vc5\
-\
-".\simgear\simgear_config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\
-        copy .\simgear\simgear_config.h.vc5 .\simgear\simgear_config.h\
-\
-# End Custom Build\
-\
-!ELSEIF  "$(CFG)" == "SimGear - Win32 Debug"\
-\
-# Begin Custom Build - Creating config.h\
-InputPath=.\simgear\simgear_config.h.vc5\
-\
-".\simgear\simgear_config.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"\
-        copy .\simgear\simgear_config.h.vc5 .\simgear\simgear_config.h\
-\
-# End Custom Build\
-\
-!ENDIF\
-

autogen.sh

@@ -1,52 +0,0 @@
-#!/bin/sh
-
-OSTYPE=`uname -s`
-MACHINE=`uname -m`
-AUTO_MAKE_VERSION=`automake --version | head -1 | awk '{print $4}' | sed -e 's/\.\([0-9]*\).*/\1/'`
-if test $AUTO_MAKE_VERSION -lt 15; then
-    echo ""
-    echo "You need to upgrade to automake version 1.5 or greater."
-    echo "Most distributions have packages available to install or you can"
-    echo "find the source for the most recent version at"
-    echo "ftp://ftp.gnu.org/gnu/automake"
-    exit 1
-fi
-
-echo "Host info: $OSTYPE $MACHINE"
-echo -n " automake: `automake --version | head -1 | awk '{print $4}'`"
-echo " ($AUTO_MAKE_VERSION)"
-echo ""
-
-echo "Running aclocal"
-aclocal
-
-echo "Running autoheader"
-autoheader
-if [ ! -e simgear/simgear_config.h.in ]; then
-    echo "ERROR: autoheader didn't create simgear/simgear_config.h.in!"
-    exit 1
-fi    
-
-echo "Running automake --add-missing"
-automake --add-missing
-
-echo "Running autoconf"
-autoconf
-
-if [ ! -e configure ]; then
-    echo "ERROR: configure was not created!"
-    exit 1
-fi
-
-echo ""
-echo "======================================"
-
-if [ -f config.cache ]; then
-    echo "config.cache exists.  Removing the config.cache file will force"
-    echo "the ./configure script to rerun all it's tests rather than using"
-    echo "the previously cached values."
-    echo ""
-fi
-
-echo "Now you are ready to run './configure'"
-echo "======================================"

configure.ac

@@ -1,603 +0,0 @@
-dnl Process this file with autoget.sh to produce a working configure
-dnl script.
-
-AC_INIT
-AC_CONFIG_SRCDIR([simgear/bucket/newbucket.cxx])
-
-dnl Require at least automake 2.52
-AC_PREREQ(2.52)
-
-dnl Initialize the automake stuff
-AM_INIT_AUTOMAKE(SimGear, 2.2.0)
-
-dnl Specify KAI C++ compiler and flags.
-dnl Borrowed with slight modification from blitz distribution.
-AC_ARG_WITH(cxx,
-  [  --with-cxx=COMPILER[:name-flags] set options for COMPILER (KCC)],
-  [case "$withval" in
-    KCC*)    # KAI C++ http://www.kai.com/
-      echo "Configuring for KAI C++"
-      AC_SG_SET_COMPILER($withval,"KCC","--restrict --strict_warnings")
-      CXX_OPTIMIZE_FLAGS=="+K3 -O3"
-      CXX_DEBUG_FLAGS="-g +K0"
-    ;;
-  esac
-])
-
-AC_ARG_ENABLE(headless,
-        AS_HELP_STRING([--enable-headless],[Enable only packages for headless build]))
-
-AC_MSG_CHECKING([for headless mode])
-AC_MSG_RESULT([$enable_headless])
-
-AM_CONDITIONAL(WANT_HEADLESS,[test "x$enable_headless" = "xyes"])
-
-AC_MSG_CHECKING([CXX])
-AC_MSG_RESULT([$CXX])
-AC_MSG_CHECKING([CC])
-AC_MSG_RESULT([$CC])
-
-dnl Checks for programs.
-AC_PROG_MAKE_SET
-AC_PROG_CC
-AC_PROG_CPP
-AC_PROG_CXX
-AC_PROG_CXXCPP
-AC_PROG_RANLIB
-AC_PROG_INSTALL
-AC_PROG_LN_S
-AX_BOOST_BASE([1.37.0])
-
-if test "x$BOOST_CPPFLAGS" != "x-I/usr/include" ; then
-   CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-fi
-
-dnl set the $host variable based on local machine/os
-AC_CANONICAL_HOST
-
-dnl Used on the Irix platform
-case "${host}" in
-*-*-irix*)
-    if test "x$CXX" = "xCC" -o "x$CXX" = "xccache CC"; then
-        AR="$CXX -ar"
-        ARFLAGS="-o"
-        CXXFLAGS="$CXXFLAGS -I$(top_srcdir)/simgear/compatibility/MIPSpro740"
-        compatibility_DIR="compatibility"
-        MIPSpro_DIRS="MIPSpro740"
-        AC_MSG_CHECKING([for MIPSpro compiler version 7.4 or newer])
-        AC_TRY_RUN([
-           int main() {
-              if ( _COMPILER_VERSION < 740 ) {
-                 return -1;
-              }
-              return 0;
-           }
-
-        ], AC_MSG_RESULT(yes),
-        [  AC_MSG_RESULT(no)
-           CXXFLAGS="$CXXFLAGS -I$(top_srcdir)/simgear/compatibility/MIPSpro721"
-           MIPSpro_DIRS="$(MIPSpro_DIRS) MIPSpro721"
-           AC_MSG_WARN([Using our own subset of the STL headers])
-        ], AC_MSG_RESULT(yes))
-        AC_SUBST(MIPSpro_DIRS)
-    fi
-    ;;
-*)
-    AR="ar"
-    ARFLAGS="cru"
-    compatibility_DIR=
-    ;;
-esac
-AC_SUBST(AR)
-AC_SUBST(ARFLAGS)
-AC_SUBST(compatibility_DIR)
-
-# Show all compiler warnings by default
-CXXFLAGS="$CXXFLAGS -Wall"
-CFLAGS="$CFLAGS -Wall"
-
-if echo $includedir | egrep "simgear$" > /dev/null; then
-    echo "includedir is" $includedir "libdir is" $libdir
-else
-    includedir="${includedir}/simgear"
-    echo "includedir changed to" $includedir "libdir is" $libdir
-fi
-         
-dnl set logging; default value of with_logging=yes
-AC_ARG_WITH(logging, [  --with-logging          Include logging output (default)])
-if test "x$with_logging" = "xno" ; then
-    AC_DEFINE([FG_NDEBUG], 1, [Define for no logging output])
-fi
-
-# Specify if we want to build with Norman's jpeg image server support.
-# This requires libjpeg to be installed and available.
-# Default to with_jpeg_server=no
-JPEGLIB=''
-AC_ARG_WITH(jpeg_factory, [  --with-jpeg-factory     Include Norman's jpeg image factory support code])
-if test "x$with_jpeg_factory" = "xyes" ; then
-    echo "Building with Norman's jpeg image factory support"
-    AC_CHECK_LIB(jpeg, jpeg_start_compress)
-    if test "x$ac_cv_lib_jpeg_jpeg_start_compress" != "xyes" ; then
-        echo
-        echo "In order to build the jpeg factory code you need libjpeg installed."
-        echo "otherwise please configure with the --with-jpeg-sever=no option"
-        echo
-        echo "libjpeg is available at :"
-        echo "  ftp://ftp.uu.net in the directory graphics/jpeg"
-        exit 1
-    fi
-else
-    echo "Building without Norman's jpeg image server support"
-fi
-AM_CONDITIONAL(ENABLE_JPEG_SERVER, test "x$with_jpeg_factory" = "xyes")
-
-# specify the osg location
-AC_ARG_WITH(osg, [  --with-osg=PREFIX       Specify the prefix path to osg])
-
-if test "x$with_osg" != "x" ; then
-    echo "osg prefix is $with_osg"
-    EXTRA_DIRS="${EXTRA_DIRS} $with_osg"
-fi
-
-AC_ARG_WITH(osg_framework, [  --with-osg-framework=PREFIX     Specify the prefix path to OSG.framework ])
-
-if test "x$with_osg_framework" != "x"; then
-    echo "osg framework prefix is $with_osg_framework"
-    CPPFLAGS = "$CPPFLAGS -F$with-osg-framework"
-    export DYLD_FRAMEWORK_PATH="$DYLD_FRAMEWORK_PATH:$with_osg_framework"
-fi
-
-dnl specifying ALUT.framework (for user provided ALUT.framework)
-AC_ARG_WITH(alut_framework, [  --with-alut-framework=PREFIX    Specify the prefix path to ALUT.framework ])
-
-if test "x$with_alut_framework" != "x"; then
-    echo "ALUT framework prefix is $with_alut_framework"
-fi
-
-dnl Determine an extra directories to add to include/lib search paths
-case "${host}" in
-*-apple-darwin* | *-*-cygwin* | *-*-mingw32*)
-    echo no EXTRA_DIRS for $host
-    ;;
-
-*)
-    if test -d /usr/X11R6 ; then
-        EXTRA_DIR1="/usr/X11R6"
-    fi
-    if test -d /opt/X11R6 ; then
-        EXTRA_DIR2="/opt/X11R6"
-    fi
-    EXTRA_DIRS="${EXTRA_DIRS} $EXTRA_DIR1 $EXTRA_DIR2"
-    ;;
-
-esac
-wi_EXTRA_DIRS(no, ${EXTRA_DIRS})
-
-
-dnl Using AM_CONDITIONAL is a step out of the protected little 
-dnl automake fold so it is potentially dangerous.  But, we are
-dnl beginning to run into cases where the standard checks are not
-dnl enough.  AM_CONDITIONALS are then referenced to conditionally
-dnl build a Makefile.in from a Makefile.am which lets us define custom
-dnl includes, compile alternative source files, etc.
-
-dnl X11 might be installed on Mac OS X or cygwin/mingwin, we don't want
-dnl to use it if it is.
-case "${host}" in
-*-apple-darwin* | *-*-cygwin* | *-*-mingw32*)
-    echo no fancy X11 check
-    ;;
-
-*)
-    AC_PATH_XTRA
-    ;;
-
-esac
-
-dnl Checks for libraries.
-
-dnl Thread related checks
-AC_CHECK_HEADER(pthread.h)
-AC_SEARCH_LIBS(pthread_exit, [pthread c_r])
-if test "x$ac_cv_header_pthread_h" = "xyes"; then
-    CXXFLAGS="$CXXFLAGS -D_REENTRANT"
-    CFLAGS="$CFLAGS -D_REENTRANT"
-
-  if test "x$ac_cv_search_pthread_exit" = "x-lc_r"; then
-    CXXFLAGS="-pthread $CXXFLAGS"
-    CFLAGS="-pthread $CFLAGS"
-  fi
-fi
-
-AM_CONDITIONAL(HAVE_THREADS, test "x$ac_cv_header_pthread_h" = "xyes")
-
-thread_LIBS="$LIBS"
-LIBS=""
-
-dnl search for network related libraries
-AC_SEARCH_LIBS(inet_addr, xnet)
-AC_SEARCH_LIBS(socket, socket)
-
-network_LIBS="$LIBS"
-LIBS=""
-
-dnl check for some default libraries
-AC_SEARCH_LIBS(cos, m)
-AC_SEARCH_LIBS(clock_gettime, rt)
-
-base_LIBS="$LIBS"
-
-dnl check for OpenGL related libraries
-case "${host}" in
-*-*-cygwin* | *-*-mingw32*)
-    dnl CygWin under Windoze.
-
-    echo Win32 specific hacks...
-    AC_DEFINE([WIN32], 1, [Define for Win32 platforms])
-    AC_DEFINE([NOMINMAX], 1, [Define for Win32 platforms])
-
-    LIBS="$LIBS -lglu32 -lopengl32"
-    LIBS="$LIBS -luser32 -lgdi32 -lwinmm"
-
-    dnl add -lwsock32 for mingwin
-    case "${host}" in
-    *-*-mingw32*)
-        base_LIBS="$base_LIBS -lws2_32"
-        ;;
-    esac
-
-    echo "Will link apps with $LIBS"
-    ;;
-
-*-apple-darwin*)
-    dnl Mac OS X
-
-    LIBS="$LIBS -framework OpenGL -framework Carbon -lobjc"
-    ;;
-
-*)
-    dnl X-Windows based machines
-
-    AC_SEARCH_LIBS(XCreateWindow, X11)
-    AC_SEARCH_LIBS(XShmCreateImage, Xext)
-    AC_SEARCH_LIBS(XGetExtensionVersion, Xi)
-    AC_SEARCH_LIBS(IceOpenConnection, ICE)
-    AC_SEARCH_LIBS(SmcOpenConnection, SM)
-    AC_SEARCH_LIBS(XtMalloc, Xt)
-    AC_SEARCH_LIBS(XmuLookupStandardColormap, Xmu)
-    
-    AC_SEARCH_LIBS(glNewList, [ GL GLcore MesaGL ])
-    if test "x$ac_cv_search_glNewList" = "x-lGLcore"; then
-	dnl if GLcore found, then also check for GL
-        AC_SEARCH_LIBS(glXCreateContext, GL)
-    fi
-
-    dnl if using mesa, check for xmesa.h
-    if test "x$ac_cv_search_glNewList" = "x-lMesaGL"; then
-	AC_CHECK_HEADER(GL/fxmesa.h)
-	if test "x$ac_cv_header_GL_fxmesa_h" = "xyes"; then
-	    AC_DEFINE([XMESA], 1, [Define for fxmesa])
-            AC_DEFINE([FX], 1, [Define for fxmesa])
-        fi
-    fi
-
-    AC_SEARCH_LIBS(gluLookAt, [ GLU MesaGLU ])
-    ;;
-
-esac
-
-opengl_LIBS="$LIBS"
-LIBS="$base_LIBS"
-
-dnl check for OpenAL libraries
-OPENAL_OK="no"
-ALUT_OK="no"
-case "${host}" in
-*-*-cygwin* | *-*-mingw32*)
-    dnl CygWin under Windoze.
-    INCLUDES="$INCLUDES -I/usr/local/include/"
-    LIBS="$LIBS -L/usr/local/lib"
-    AC_SEARCH_LIBS(alGenBuffers, [ openal32 openal 'openal -ldsound -lwinmm' ] )
-    AC_SEARCH_LIBS(alutInit, [ openal32 ALut alut ] )
-    LIBS="$LIBS -lwinmm -ldsound -ldxguid -lole32"
-    openal_LIBS="$LIBS"
-    OPENAL_OK="$ac_cv_search_alGenBuffers"
-    ALUT_OK="$ac_cv_search_alutInit"
-    ;;
-
-*-apple-darwin*)
-    dnl Mac OS X
-
-    LIBS="$LIBS -framework IOKit -framework OpenAL -framework ALUT"
-    openal_LIBS="$LIBS"
-
-    if test "x$with_openal_lib" != "x"; then
-        echo "libopenal is not supported on Mac OS platform."
-        openal_LIBS=""
-    fi
-
-    AC_CHECK_HEADERS([OpenAL/al.h],[OPENAL_OK="yes"])
-    # Looking for alut.h
-    AC_CHECK_HEADERS([ALUT/alut.h],[ALUT_OK="yes"])
-
-    dnl Thank you Christian Bauer from SheepSaver
-    dnl Modified by Tatsuhiro Nishioka for accepting a given framework path
-    dnl AC_CHECK_FRAMEWORK($1=NAME, $2=INCLUDES, $3=FRAMEWORK_PATH, $4=ACTION_IF_TRUE) ; $3 is optional
-    AC_DEFUN([AC_CHECK_FRAMEWORK], [
-    AS_VAR_PUSHDEF([ac_Framework], [ac_cv_framework_$1])dnl
-    AC_CACHE_CHECK([whether compiler supports framework $1],
-        ac_Framework, [
-        saved_LIBS="$LIBS"
-        FRAMEWORKS="$FRAMEWORKS -framework $1"
-        if test "$3" = ""; then
-            FRAMEWORKS="$FRAMEWORKS $ADD2LD"
-        elif test "`echo $FRAMEWORKS | grep -- -F$3`" = ""; then
-            FRAMEWORKS="$FRAMEWORKS -F$3"
-            CXXFLAGS="$CXXFLAGS -F$3"
-            CPPFLAGS="$CPPFLAGS -F$3"
-            CCFLAGS="$CCFLAGS -F$3"
-            dnl This is needed for AC_TRY_LINK when a framework path is specified
-            export DYLD_FRAMEWORK_PATH="${DYLD_FRAMEWORK_PATH}:$3"
-        fi
-        AC_TRY_LINK(
-        [$2], [],
-        [AS_VAR_SET(ac_Framework, yes)], [AS_VAR_SET(ac_Framework, no); LIBS="$saved_LIBS"]
-        )
-    ])
-    AS_IF([test AS_VAR_GET(ac_Framework) = yes],
-        [AC_DEFINE(AS_TR_CPP(HAVE_FRAMEWORK_$1), 1, [Define if framework $1 is available.])]
-    )
-    AS_IF([test AS_VAR_GET(ac_Framework) = yes], $4)
-    
-    AS_VAR_POPDEF([ac_Framework])dnl
-    ])
-
-    dnl Check for ALUT.framework when --with-alut-framework is specified
-    if test "x$with_alut_framework" != "x"; then
-      AC_CHECK_FRAMEWORK(ALUT, [#include <ALUT/alut.h>], $with_alut_framework, [ALUT_OK="yes"])
-    fi
-
-    ;;
-
-*)
-    dnl default unix style machines
-
-    save_LIBS=$LIBS
-    LIBS="$LIBS $thread_LIBS"
-    AC_SEARCH_LIBS(alGenBuffers, openal)
-    AC_SEARCH_LIBS(alutInit, [ alut openal ] )
-    OPENAL_OK="$ac_cv_search_alGenBuffers"
-    ALUT_OK="$ac_cv_search_alutInit"
-    openal_LIBS="$LIBS"
-    LIBS=$save_LIBS
-    ;;
-
-esac
-
-if test "$OPENAL_OK" == "no" -a "x$enable_headless" != "xyes"; then
-    echo
-    echo "You *must* have the openal library installed on your system to build"
-    echo "SimGear!"
-    echo
-    echo "Please see README.OpenAL for more details."
-    echo
-    echo "configure aborted."
-    exit
-fi
-
-if test "$ALUT_OK" == "no" -a "x$enable_headless" != "xyes"; then
-    echo
-    echo "You *must* have the alut library installed on your system to build"
-    echo "SimGear!"
-    echo
-    echo "Please see README.OpenAL for more details."
-    echo
-    echo "configure aborted."
-    exit
-fi
-
-
-
-LIBS="$base_LIBS"
-
-AC_SUBST(base_LIBS)
-AC_SUBST(openal_LIBS)
-AC_SUBST(opengl_LIBS)
-AC_SUBST(thread_LIBS)
-AC_SUBST(network_LIBS)
-
-dnl Check for MS Windows environment
-AC_CHECK_HEADER(windows.h)
-AM_CONDITIONAL(EXTGL_NEEDED, test "x$ac_cv_header_windows_h" = "xyes")
-
-# The following are C++ items that need to be tested for with the c++
-# compiler
-
-CXXCPP="g++ -E"
-AC_LANG_PUSH(C++)
-
-# OpenSceneGraph
-case "${host}" in
-*-apple-darwin*)
-    if test "x$with_osg_framework" != "x"; then
-#       AC_CHECK_FRAMEWORK(osgViewer, [#include <osgViewer/Version>], $with_osg_framework)
-#       AC_CHECK_FRAMEWORK(osgGA, [#include <osgGA/Version>], $with_osg_framework)
-#       AC_CHECK_FRAMEWORK(osgText, [#include <osgText/Version>], $with_osg_framework)
-#       AC_CHECK_FRAMEWORK(osgFX, [#include <osgFX/AnisotropicLighting>], $with_osg_framework)
-#       AC_CHECK_FRAMEWORK(osgUtil, [#include <osgUtil/Version>], $with_osg_framework)
-#       AC_CHECK_FRAMEWORK(osgDB, [#include <osgDB/Version>], $with_osg_framework)
-#       AC_CHECK_FRAMEWORK(osgSim, [#include <osgSim/Version>], $with_osg_framework)
-#       AC_CHECK_FRAMEWORK(osgParticle, [#include <osgParticle/Version>], $with_osg_framework)
-        AC_CHECK_FRAMEWORK(osg, [#include <osg/Version>], $with_osg_framework)
-#       osg_FRAMEWORKS="$FRAMEWORKS"
-#       FRAMEWORKS=""
-#       AC_SUBST(osg_FRAMEWORKS)
-        AC_CHECK_FRAMEWORK(OpenThreads, [#include <OpenThreads/Version>], $with_osg_framework)
-        openthreads_FRAMEWORK="$FRAMEWORKS"
-        FRAMEWORKS=""
-        AC_SUBST(openthreads_FRAMEWORK)
-    else
-        dnl
-        dnl This is needed when osg dynamic libs are specified 
-        dnl instead of OSG frameworks on Mac OS X
-        dnl
-        AC_CHECK_LIB(OpenThreads,OpenThreadsGetVersion)
-    fi
-    ;;
-*)
-    if test "x$enable_osgdebug" = "xyes"; then
-        AC_CHECK_LIB(OpenThreadsd,OpenThreadsGetVersion)
-    else
-        AC_CHECK_LIB(OpenThreads,OpenThreadsGetVersion)
-    fi
-    ;;
-esac
-
-AM_CONDITIONAL(HAVE_FRAMEWORK_OSG, test "x$ac_cv_framework_osg" != "x")
-
-AC_CHECK_HEADER(osg/Version)
-
-if test "x$ac_cv_header_osg_Version" != "xyes" -o "x$ac_cv_lib_OpenThreads_OpenThreadsGetVersion" != "xyes"; then
-  if test "x$ac_cv_framework_osg" != "xyes"; then
-    echo
-    echo "You *must* have the OpenThreads library installed on your system"
-    echo "to build this version of SimGear!"
-    echo "   Maybe you need to specify --with-osg=DIR."
-    echo "   Maybe you need to specify some LDFLAGS to help the linker."
-    echo
-    echo "     LIBS: '$LIBS'"
-    echo "  LDFLAGS: '$LDFLAGS'"
-    echo " CPPFLAGS: '$CPPFLAGS'"
-    echo
-    echo "Please see README.OSG for more details."
-    echo
-    echo "configure aborted."
-    exit
-  fi
-fi
-
-AC_CHECK_HEADER(boost/version.hpp)
-if test "x$ac_cv_header_boost_version_hpp" != "xyes"; then
-    echo
-    echo "You *must* have the Boost library installed on your system"
-    echo "to build this version of SimGear!"
-    echo
-    echo "     LIBS: '$LIBS'"
-    echo "  LDFLAGS: '$LDFLAGS'"
-    echo " CPPFLAGS: '$CPPFLAGS'"
-    echo
-    echo "configure aborted."
-    exit
-fi
-
-AC_LANG_POP
-
-dnl Check for system installed zlib
-AC_CHECK_HEADER(zlib.h)
-if test "x$ac_cv_header_zlib_h" != "xyes"; then
-    echo
-    echo "zlib library not found."
-    echo
-    echo "If your OS does not provide an installable package for zlib"
-    echo "you will have to compile and install it first yourself.  A copy"
-    echo "of zlib-1.1.4.tar.gz is included with SimGear.  You will"
-    echo "have to untar this source code, and follow its included instructions"
-    echo "to compile and install on your system."
-    echo
-    echo "configure aborted."
-    echo
-fi
-
-dnl Checks for header files.
-AC_HEADER_STDC
-AC_CHECK_HEADERS( \
-	fcntl.h getopt.h malloc.h memory.h stdint.h stdlib.h sys/param.h \
-	sys/stat.h sys/time.h sys/timeb.h unistd.h values.h )
-
-if test "x$ac_cv_header_stdint_h" = "xyes"; then
-    AC_DEFINE([HAVE_STDINT_H], 1, [Define if stdint.h exists])
-fi
-
-dnl Checks for typedefs, structures, and compiler characteristics.
-AC_C_CONST
-AC_TYPE_SIZE_T
-AC_TYPE_MODE_T
-AC_HEADER_TIME
-AC_STRUCT_TM
-
-dnl Checks for library functions.
-old_LIBS=$LIBS
-LIBS="$base_LIBS $network_LIBS $opengl_LIBS"
-AC_TYPE_SIGNAL
-AC_FUNC_VPRINTF
-AC_CHECK_FUNCS( [ \
-        ftime gettimeofday timegm memcpy bcopy mktime strstr rand \
-	random drand48 setitimer getitimer signal GetLocalTime rint getrusage ] )
-LIBS=$old_LIBS
-
-AM_CONFIG_HEADER(simgear/simgear_config.h)
-
-AC_CONFIG_FILES([ \
-	Makefile \
-	SimGear.spec \
-	simgear/Makefile \
-	simgear/version.h \
-	simgear/compatibility/Makefile \
-	simgear/compatibility/MIPSpro721/Makefile \
-	simgear/compatibility/MIPSpro740/Makefile \
-	simgear/bucket/Makefile \
-	simgear/debug/Makefile \
-	simgear/ephemeris/Makefile \
-	simgear/io/Makefile \
-	simgear/magvar/Makefile \
-	simgear/math/Makefile \
-	simgear/environment/Makefile \
-	simgear/misc/Makefile \
-	simgear/nasal/Makefile \
-	simgear/props/Makefile \
-	simgear/route/Makefile \
-	simgear/scene/Makefile \
-	simgear/scene/bvh/Makefile \
-	simgear/scene/material/Makefile \
-	simgear/scene/model/Makefile \
-	simgear/scene/sky/Makefile \
-	simgear/scene/tgdb/Makefile \
-	simgear/scene/util/Makefile \
-	simgear/screen/Makefile \
-	simgear/serial/Makefile \
-	simgear/sound/Makefile \
-	simgear/structure/Makefile \
-	simgear/threads/Makefile \
-	simgear/timing/Makefile \
-	simgear/xml/Makefile \
-])
-AC_OUTPUT
-
-
-echo ""
-echo "Configure Summary"
-echo "================="
-
-echo "Prefix: $prefix"
-
-if test "x$with_logging" != "x"; then
-    echo "Debug messages: $with_logging"
-else
-    echo "Debug messages: yes"
-fi
-
-echo -n "Automake version: "
-automake --version | head -1
-
-if test "x$with_jpeg_factory" = "xyes"; then
-   echo "With JPEG Factory support"
-else
-   echo "Without JPEG Factory support"
-fi
-
-if test "x$ac_cv_header_pthread_h" = "xyes"; then
-   echo "Threads: pthread lib found."
-else
-   echo "Threads: no threads (pthread lib not found.)"
-fi
-

package/RedHat/README

@@ -0,0 +1,13 @@
+Building a SimGear RPM package for Red Hat
+
+Please see the "package/openSUSE" directory for an
+example how to build a SimGear RPM package with
+shared SimGear libraries.
+
+You may need to adapt the names (exact spelling) of some
+of the package dependencies in the openSUSE RPM spec,
+since these may slightly differ for Red Hat.
+
+(If you have a working and tested Red Hat RPM spec,
+you're welcome to contribute it to this project.)
+

package/openSUSE/README

@@ -0,0 +1,23 @@
+Building a SimGear RPM package for openSUSE
+
+(Last tested with openSUSE 11.4+12.1)
+
+This directory contains the files which, along with
+the source code tar files, can be used to build
+an RPM package targeted at an openSUSE Linux system.
+
+To build SimGear from source do the following:
+
+1. obtain simgear-2.8.0.tar.bz2 (adapt version if
+    necessary) and copy it into ~/rpmbuild/SOURCES
+
+2. look in the BuildRequires section of SimGear.spec
+   and check that all the packages referred to are
+   installed (note, some of these packages may be part
+   of openSUSE's "games" repository).
+
+3. run 'rpmbuild -ba simgear.spec' and find the RPM
+   build result in ~/rpmbuild/RPMS
+
+That's all!
+

package/openSUSE/SimGear.spec

@@ -0,0 +1,66 @@
+Summary:    Simulator Construction Gear
+Name:       SimGear
+Version:    2.8.0
+Release:    1
+License:    LGPL
+URL:        http://www.flightgear.org
+Group:      Amusements/Games/3D/Simulation
+Source:     http://mirrors.ibiblio.org/pub/mirrors/flightgear/ftp/Source/simgear-%{version}.tar.bz2
+BuildRoot:  %{_tmppath}/%{name}-%{version}-build
+
+BuildRequires: gcc, gcc-c++, cmake
+BuildRequires: freealut, freealut-devel
+BuildRequires: libopenal1-soft, openal-soft
+BuildRequires: plib-devel >= 1.8.5
+BuildRequires: libOpenSceneGraph-devel >= 3.0
+BuildRequires: zlib, zlib-devel
+BuildRequires: libjpeg62, libjpeg62-devel
+BuildRequires: boost-devel >= 1.37
+BuildRequires: subversion-devel, libapr1-devel
+Requires:      OpenSceneGraph-plugins >= 3.0
+
+%description
+This package contains a tools and libraries useful for constructing
+simulation and visualization applications such as FlightGear or TerraGear.
+
+%package devel
+Group:         Development/Libraries/Other
+Summary:       Development header files for SimGear
+Requires:      SimGear = %{version}
+Requires:      plib-devel
+
+%description devel
+Development headers and libraries for building applications against SimGear.
+
+%prep
+%setup -T -q -n simgear-%{version} -b 0
+
+%build
+export CFLAGS="$RPM_OPT_FLAGS"
+export CXXFLAGS="$RPM_OPT_FLAGS"
+# build SHARED simgear libraries
+cmake -DCMAKE_INSTALL_PREFIX=%{_prefix} -DSIMGEAR_SHARED:BOOL=ON -DENABLE_TESTS:BOOL=OFF -DJPEG_FACTORY:BOOL=ON
+make %{?_smp_mflags}
+
+%install
+make DESTDIR=%{buildroot} install
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%files
+%defattr (-, root, root, -)
+%doc AUTHORS COPYING ChangeLog NEWS README
+%{_libdir}/libSimGear*.so.*
+
+%files devel
+%defattr(-,root,root,-)
+%dir %{_includedir}/simgear
+%{_includedir}/simgear/*
+%{_libdir}/libSimGear*.so
+
+%changelog
+* Mon Jul 02 2012 thorstenb@flightgear.org
+- Initial version
+

projects/VC100/.gitignore

@@ -1,5 +0,0 @@
-Win32
-x64
-*.user
-*.sdf
-*.suo

projects/VC100/SimGear-alone.sln

@@ -1,37 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual Studio 2010
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimGear-install", "SimGear-install.vcxproj", "{1781C058-4D52-43AB-9028-EA0A7730057D}"
-	ProjectSection(ProjectDependencies) = postProject
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED} = {22540CD3-D3CA-4C86-A773-80AEEE3ACDED}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimGear", "SimGear.vcxproj", "{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Debug|x64 = Debug|x64
-		Release|Win32 = Release|Win32
-		Release|x64 = Release|x64
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{1781C058-4D52-43AB-9028-EA0A7730057D}.Debug|Win32.ActiveCfg = Debug|Win32
-		{1781C058-4D52-43AB-9028-EA0A7730057D}.Debug|Win32.Build.0 = Debug|Win32
-		{1781C058-4D52-43AB-9028-EA0A7730057D}.Debug|x64.ActiveCfg = Debug|Win32
-		{1781C058-4D52-43AB-9028-EA0A7730057D}.Release|Win32.ActiveCfg = Release|Win32
-		{1781C058-4D52-43AB-9028-EA0A7730057D}.Release|Win32.Build.0 = Release|Win32
-		{1781C058-4D52-43AB-9028-EA0A7730057D}.Release|x64.ActiveCfg = Release|Win32
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug|Win32.ActiveCfg = Debug|Win32
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug|Win32.Build.0 = Debug|Win32
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug|x64.ActiveCfg = Debug|x64
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug|x64.Build.0 = Debug|x64
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release|Win32.ActiveCfg = Release|Win32
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release|Win32.Build.0 = Release|Win32
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release|x64.ActiveCfg = Release|x64
-		{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release|x64.Build.0 = Release|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

projects/VC100/SimGear-install.vcxproj

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{1781C058-4D52-43AB-9028-EA0A7730057D}</ProjectGuid>
-    <RootNamespace>SimGearinstall</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup />
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

projects/VC100/SimGear-install.vcxproj.filters

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Fichiers sources">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Fichiers d%27en-tête">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Fichiers de ressources">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-</Project>

projects/VC100/SimGear.vcxproj

@@ -1,607 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}</ProjectGuid>
-    <RootNamespace>SimGear</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</IntDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Platform)\$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Platform)\$(Configuration)\</IntDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</IntDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Platform)\$(Configuration)\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Platform)\$(Configuration)\</IntDir>
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
-    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
-    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <AdditionalIncludeDirectories>..\..;..\..\simgear;..\..\..;..\..\..\install\msvc100\OpenSceneGraph\include;..\..\..\3rdparty\include;..\..\..\boost_1_44_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>HAVE_CONFIG_H;NDEBUG;WIN32;_USE_MATH_DEFINES;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <StringPooling>true</StringPooling>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <RuntimeTypeInfo>true</RuntimeTypeInfo>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <CompileAs>Default</CompileAs>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x0409</Culture>
-    </ResourceCompile>
-    <Lib>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-    </Lib>
-    <ProjectReference />
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Midl>
-      <TargetEnvironment>X64</TargetEnvironment>
-    </Midl>
-    <ClCompile>
-      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
-      <AdditionalIncludeDirectories>..\..;..\..\simgear;..\..\..;..\..\..\install\msvc100-64\OpenSceneGraph\include;..\..\..\3rdparty.x64\include;..\..\..\boost_1_44_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>HAVE_CONFIG_H;NDEBUG;WIN32;_USE_MATH_DEFINES;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <StringPooling>true</StringPooling>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <RuntimeTypeInfo>true</RuntimeTypeInfo>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <CompileAs>Default</CompileAs>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x0409</Culture>
-    </ResourceCompile>
-    <Lib>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-    </Lib>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>..\..;..\..\simgear;..\..\..;..\..\..\install\msvc100\OpenSceneGraph\include;..\..\..\3rdparty\include;..\..\..\boost_1_44_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>HAVE_CONFIG_H;_DEBUG;WIN32;_USE_MATH_DEFINES;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <RuntimeTypeInfo>true</RuntimeTypeInfo>
-      <BrowseInformation>true</BrowseInformation>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
-      <CompileAs>Default</CompileAs>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x0409</Culture>
-    </ResourceCompile>
-    <Lib>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-    </Lib>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Midl>
-      <TargetEnvironment>X64</TargetEnvironment>
-    </Midl>
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>..\..;..\..\simgear;..\..\..;..\..\..\install\msvc100-64\OpenSceneGraph\include;..\..\..\3rdparty.x64\include;..\..\..\boost_1_44_0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>HAVE_CONFIG_H;_DEBUG;WIN32;_USE_MATH_DEFINES;_CRT_SECURE_NO_WARNINGS;_CRT_NONSTDC_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <RuntimeTypeInfo>true</RuntimeTypeInfo>
-      <BrowseInformation>true</BrowseInformation>
-      <WarningLevel>Level3</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
-      <CompileAs>Default</CompileAs>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x0409</Culture>
-    </ResourceCompile>
-    <Lib>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-    </Lib>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\simgear\bucket\newbucket.cxx" />
-    <ClCompile Include="..\..\simgear\debug\logstream.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\celestialBody.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\ephemeris.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\jupiter.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\mars.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\mercury.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\moonpos.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\neptune.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\saturn.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\star.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\stardata.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\uranus.cxx" />
-    <ClCompile Include="..\..\simgear\ephemeris\venus.cxx" />
-    <ClCompile Include="..\..\simgear\io\iochannel.cxx" />
-    <ClCompile Include="..\..\simgear\io\lowlevel.cxx" />
-    <ClCompile Include="..\..\simgear\io\raw_socket.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_binobj.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_file.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_netBuffer.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_netChannel.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_netChat.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_serial.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_socket.cxx" />
-    <ClCompile Include="..\..\simgear\io\sg_socket_udp.cxx" />
-    <ClCompile Include="..\..\simgear\magvar\coremag.cxx" />
-    <ClCompile Include="..\..\simgear\magvar\magvar.cxx" />
-    <ClCompile Include="..\..\simgear\math\interpolater.cxx" />
-    <ClCompile Include="..\..\simgear\math\leastsqs.cxx" />
-    <ClCompile Include="..\..\simgear\math\project.cxx" />
-    <ClCompile Include="..\..\simgear\math\sg_random.c" />
-    <ClCompile Include="..\..\simgear\math\SGGeod.cxx" />
-    <ClCompile Include="..\..\simgear\math\SGGeodesy.cxx" />
-    <ClCompile Include="..\..\simgear\misc\interpolator.cxx" />
-    <ClCompile Include="..\..\simgear\misc\PathOptions.cxx" />
-    <ClCompile Include="..\..\simgear\misc\sg_dir.cxx" />
-    <ClCompile Include="..\..\simgear\misc\sg_path.cxx" />
-    <ClCompile Include="..\..\simgear\misc\sgstream.cxx" />
-    <ClCompile Include="..\..\simgear\misc\sg_sleep.cxx" />
-    <ClCompile Include="..\..\simgear\misc\strutils.cxx" />
-    <ClCompile Include="..\..\simgear\misc\tabbed_values.cxx" />
-    <ClCompile Include="..\..\simgear\misc\texcoord.cxx" />
-    <ClCompile Include="..\..\simgear\misc\zfstream.cxx" />
-    <ClCompile Include="..\..\simgear\misc\ResourceManager.cxx" />
-    <ClCompile Include="..\..\simgear\props\propertyObject.cxx" />
-    <ClCompile Include="..\..\simgear\route\route.cxx" />
-    <ClCompile Include="..\..\simgear\route\waypoint.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\mipmap.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\ConditionNode.cxx" />
-    <ClCompile Include="..\..\simgear\screen\extensions.cxx" />
-    <ClCompile Include="..\..\simgear\screen\jpgfactory.cxx" />
-    <ClCompile Include="..\..\simgear\screen\screen-dump.cxx" />
-    <ClCompile Include="..\..\simgear\screen\tr.cxx" />
-    <ClCompile Include="..\..\simgear\serial\serial.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\cloud.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\cloudfield.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\CloudShaderGeometry.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\dome.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\moon.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\newcloud.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\oursun.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\sky.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\sphere.cxx" />
-    <ClCompile Include="..\..\simgear\scene\sky\stars.cxx" />
-    <ClCompile Include="..\..\simgear\timing\lowleveltime.cxx" />
-    <ClCompile Include="..\..\simgear\timing\sg_time.cxx" />
-    <ClCompile Include="..\..\simgear\timing\timestamp.cxx" />
-    <ClCompile Include="..\..\simgear\timing\timezone.cxx" />
-    <ClCompile Include="..\..\simgear\xml\easyxml.cxx" />
-    <ClCompile Include="..\..\simgear\xml\hashtable.c" />
-    <ClCompile Include="..\..\simgear\xml\xmlparse.c" />
-    <ClCompile Include="..\..\simgear\xml\xmlrole.c" />
-    <ClCompile Include="..\..\simgear\xml\xmltok.c" />
-    <ClCompile Include="..\..\simgear\props\AtomicChangeListener.cxx" />
-    <ClCompile Include="..\..\simgear\props\condition.cxx" />
-    <ClCompile Include="..\..\simgear\props\props.cxx" />
-    <ClCompile Include="..\..\simgear\props\props_io.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\animation.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\CheckSceneryVisitor.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\model.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\modellib.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\ModelRegistry.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\particles.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\persparam.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\placement.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGClipGroup.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGInteractionAnimation.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGMaterialAnimation.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGOffsetTransform.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGPagedLOD.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGReaderWriterXML.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGRotateTransform.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGScaleTransform.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGText.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\SGTranslateTransform.cxx" />
-    <ClCompile Include="..\..\simgear\scene\model\shadanim.cxx" />
-    <ClCompile Include="..\..\simgear\sound\sample_group.cxx" />
-    <ClCompile Include="..\..\simgear\sound\sample_openal.cxx" />
-    <ClCompile Include="..\..\simgear\sound\soundmgr_openal.cxx" />
-    <ClCompile Include="..\..\simgear\sound\xmlsound.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\Effect.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\EffectBuilder.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\EffectCullVisitor.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\EffectGeode.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\GLPredicate.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\makeEffect.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\mat.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\matlib.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\matmodel.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\Noise.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\Pass.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\Technique.cxx" />
-    <ClCompile Include="..\..\simgear\scene\material\TextureBuilder.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\apt_signs.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\GroundLightManager.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\obj.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\pt_lights.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\ReaderWriterSTG.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\SGOceanTile.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\SGReaderWriterBTG.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\SGVasiDrawable.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\ShaderGeometry.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\TileCache.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\TileEntry.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\TreeBin.cxx" />
-    <ClCompile Include="..\..\simgear\scene\tgdb\userdata.cxx" />
-    <ClCompile Include="..\..\simgear\structure\commands.cxx" />
-    <ClCompile Include="..\..\simgear\structure\event_mgr.cxx" />
-    <ClCompile Include="..\..\simgear\structure\exception.cxx">
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-    </ClCompile>
-    <ClCompile Include="..\..\simgear\structure\SGBinding.cxx" />
-    <ClCompile Include="..\..\simgear\structure\SGExpression.cxx" />
-    <ClCompile Include="..\..\simgear\structure\SGSmplhist.cxx" />
-    <ClCompile Include="..\..\simgear\structure\SGSmplstat.cxx" />
-    <ClCompile Include="..\..\simgear\structure\subsystem_mgr.cxx" />
-    <ClCompile Include="..\..\simgear\nasal\bitslib.c" />
-    <ClCompile Include="..\..\simgear\nasal\code.c" />
-    <ClCompile Include="..\..\simgear\nasal\codegen.c" />
-    <ClCompile Include="..\..\simgear\nasal\gc.c" />
-    <ClCompile Include="..\..\simgear\nasal\hash.c" />
-    <ClCompile Include="..\..\simgear\nasal\iolib.c" />
-    <ClCompile Include="..\..\simgear\nasal\lex.c" />
-    <ClCompile Include="..\..\simgear\nasal\lib.c" />
-    <ClCompile Include="..\..\simgear\nasal\mathlib.c" />
-    <ClCompile Include="..\..\simgear\nasal\misc.c" />
-    <ClCompile Include="..\..\simgear\nasal\parse.c" />
-    <ClCompile Include="..\..\simgear\nasal\string.c">
-      <Optimization Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MinSpace</Optimization>
-      <InlineFunctionExpansion Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">OnlyExplicitInline</InlineFunctionExpansion>
-      <Optimization Condition="'$(Configuration)|$(Platform)'=='Release|x64'">MinSpace</Optimization>
-      <InlineFunctionExpansion Condition="'$(Configuration)|$(Platform)'=='Release|x64'">OnlyExplicitInline</InlineFunctionExpansion>
-    </ClCompile>
-    <ClCompile Include="..\..\simgear\nasal\thread-win32.c" />
-    <ClCompile Include="..\..\simgear\nasal\threadlib.c" />
-    <ClCompile Include="..\..\simgear\nasal\utf8lib.c" />
-    <ClCompile Include="..\..\simgear\nasal\vector.c">
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-      <ObjectFileName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(IntDir)%(Filename)1.obj</ObjectFileName>
-    </ClCompile>
-    <ClCompile Include="..\..\simgear\environment\metar.cxx" />
-    <ClCompile Include="..\..\simgear\environment\precipitation.cxx" />
-    <ClCompile Include="..\..\simgear\environment\visual_enviro.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\CopyOp.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\NodeAndDrawableVisitor.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\PrimitiveUtils.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\QuadTreeBuilder.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\SGEnlargeBoundingBox.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\SGSceneFeatures.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\SGSceneUserData.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\SGStateAttributeVisitor.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\SGTextureStateAttributeVisitor.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\SplicingVisitor.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\StateAttributeFactory.cxx" />
-    <ClCompile Include="..\..\simgear\scene\util\UpdateOnceCallback.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHGroup.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHLineGeometry.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHLineSegmentVisitor.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHMotionTransform.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHNode.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHStaticBinary.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHStaticGeometry.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHStaticLeaf.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHStaticNode.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHStaticTriangle.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHSubTreeCollector.cxx" />
-    <ClCompile Include="..\..\simgear\scene\bvh\BVHTransform.cxx" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\..\simgear\bucket\newbucket.hxx" />
-    <ClInclude Include="..\..\simgear\debug\debug_types.h" />
-    <ClInclude Include="..\..\simgear\debug\logstream.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\celestialBody.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\ephemeris.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\jupiter.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\mars.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\mercury.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\moonpos.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\neptune.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\pluto.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\saturn.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\star.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\stardata.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\uranus.hxx" />
-    <ClInclude Include="..\..\simgear\ephemeris\venus.hxx" />
-    <ClInclude Include="..\..\simgear\io\iochannel.hxx" />
-    <ClInclude Include="..\..\simgear\io\lowlevel.hxx" />
-    <ClInclude Include="..\..\simgear\io\raw_socket.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_binobj.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_file.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_netBuffer.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_netChannel.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_netChat.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_serial.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_socket.hxx" />
-    <ClInclude Include="..\..\simgear\io\sg_socket_udp.hxx" />
-    <ClInclude Include="..\..\simgear\magvar\coremag.hxx" />
-    <ClInclude Include="..\..\simgear\magvar\magvar.hxx" />
-    <ClInclude Include="..\..\simgear\math\beziercurve.hxx" />
-    <ClInclude Include="..\..\simgear\math\interpolater.hxx" />
-    <ClInclude Include="..\..\simgear\math\leastsqs.hxx" />
-    <ClInclude Include="..\..\simgear\math\linintp2.h" />
-    <ClInclude Include="..\..\simgear\math\localconsts.hxx" />
-    <ClInclude Include="..\..\simgear\math\point3d.hxx" />
-    <ClInclude Include="..\..\simgear\math\polar3d.hxx" />
-    <ClInclude Include="..\..\simgear\math\project.hxx" />
-    <ClInclude Include="..\..\simgear\math\sg_geodesy.hxx" />
-    <ClInclude Include="..\..\simgear\math\sg_random.h" />
-    <ClInclude Include="..\..\simgear\math\sg_types.hxx" />
-    <ClInclude Include="..\..\simgear\math\SGGeodesy.hxx" />
-    <ClInclude Include="..\..\simgear\math\sphrintp.h" />
-    <ClInclude Include="..\..\simgear\misc\interpolator.hxx" />
-    <ClInclude Include="..\..\simgear\misc\PathOptions.hxx" />
-    <ClInclude Include="..\..\simgear\misc\sg_dir.hxx" />
-    <ClInclude Include="..\..\simgear\misc\sg_path.hxx" />
-    <ClInclude Include="..\..\simgear\misc\sgstream.hxx" />
-    <ClInclude Include="..\..\simgear\misc\sg_sleep.hxx" />
-    <ClInclude Include="..\..\simgear\misc\stopwatch.hxx" />
-    <ClInclude Include="..\..\simgear\misc\strutils.hxx" />
-    <ClInclude Include="..\..\simgear\misc\tabbed_values.hxx" />
-    <ClInclude Include="..\..\simgear\misc\texcoord.hxx" />
-    <ClInclude Include="..\..\simgear\misc\zfstream.hxx" />
-    <ClInclude Include="..\..\simgear\misc\ResourceManager.hxx" />
-    <ClInclude Include="..\..\simgear\props\propertyObject.hxx" />
-    <ClInclude Include="..\..\simgear\route\route.hxx" />
-    <ClInclude Include="..\..\simgear\route\waypoint.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\mipmap.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\ConditionNode.hxx" />
-    <ClInclude Include="..\..\simgear\screen\colors.hxx" />
-    <ClInclude Include="..\..\simgear\screen\extensions.hxx" />
-    <ClInclude Include="..\..\simgear\screen\jpgfactory.hxx" />
-    <ClInclude Include="..\..\simgear\screen\screen-dump.hxx" />
-    <ClInclude Include="..\..\simgear\screen\tr.h" />
-    <ClInclude Include="..\..\simgear\screen\win32-printer.h" />
-    <ClInclude Include="..\..\simgear\serial\serial.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\cloud.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\cloudfield.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\CloudShaderGeometry.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\dome.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\moon.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\newcloud.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\oursun.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\sky.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\sphere.hxx" />
-    <ClInclude Include="..\..\simgear\scene\sky\stars.hxx" />
-    <ClInclude Include="..\..\simgear\timing\lowleveltime.h" />
-    <ClInclude Include="..\..\simgear\timing\sg_time.hxx" />
-    <ClInclude Include="..\..\simgear\timing\timestamp.hxx" />
-    <ClInclude Include="..\..\simgear\timing\timezone.h" />
-    <ClInclude Include="..\..\simgear\xml\asciitab.h" />
-    <ClInclude Include="..\..\simgear\xml\easyxml.hxx" />
-    <ClInclude Include="..\..\simgear\xml\hashtable.h" />
-    <ClInclude Include="..\..\simgear\xml\iasciitab.h" />
-    <ClInclude Include="..\..\simgear\xml\latin1tab.h" />
-    <ClInclude Include="..\..\simgear\xml\nametab.h" />
-    <ClInclude Include="..\..\simgear\xml\utf8tab.h" />
-    <ClInclude Include="..\..\simgear\xml\xmldef.h" />
-    <ClInclude Include="..\..\simgear\xml\xmlparse.h" />
-    <ClInclude Include="..\..\simgear\xml\xmlrole.h" />
-    <ClInclude Include="..\..\simgear\xml\xmltok.h" />
-    <ClInclude Include="..\..\simgear\xml\xmltok_impl.h" />
-    <ClInclude Include="..\..\simgear\props\AtomicChangeListener.hxx" />
-    <ClInclude Include="..\..\simgear\props\condition.hxx" />
-    <ClInclude Include="..\..\simgear\props\ExtendedPropertyAdapter.hxx" />
-    <ClInclude Include="..\..\simgear\props\props.hxx" />
-    <ClInclude Include="..\..\simgear\props\props_io.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\animation.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\CheckSceneryVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\model.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\modellib.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\ModelRegistry.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\particles.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\persparam.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\placement.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGClipGroup.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGInteractionAnimation.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGMaterialAnimation.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGOffsetTransform.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGPagedLOD.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGReaderWriterXML.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGReaderWriterXMLOptions.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGRotateTransform.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGScaleTransform.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGText.hxx" />
-    <ClInclude Include="..\..\simgear\scene\model\SGTranslateTransform.hxx" />
-    <ClInclude Include="..\..\simgear\sound\sample_group.hxx" />
-    <ClInclude Include="..\..\simgear\sound\sample_openal.hxx" />
-    <ClInclude Include="..\..\simgear\sound\soundmgr_openal.hxx" />
-    <ClInclude Include="..\..\simgear\sound\xmlsound.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\Effect.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\EffectBuilder.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\EffectCullVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\EffectGeode.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\GLPredicate.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\mat.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\matlib.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\matmodel.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\Noise.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\Pass.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\Technique.hxx" />
-    <ClInclude Include="..\..\simgear\scene\material\TextureBuilder.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\apt_signs.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\GroundLightManager.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\obj.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\pt_lights.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\SGModelBin.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\SGOceanTile.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\SGReaderWriterBTG.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\SGReaderWriterBTGOptions.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\SGVasiDrawable.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\ShaderGeometry.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\TileCache.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\TileEntry.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\TreeBin.hxx" />
-    <ClInclude Include="..\..\simgear\scene\tgdb\userdata.hxx" />
-    <ClInclude Include="..\..\simgear\threads\SGGuard.hxx" />
-    <ClInclude Include="..\..\simgear\threads\SGQueue.hxx" />
-    <ClInclude Include="..\..\simgear\structure\callback.hxx" />
-    <ClInclude Include="..\..\simgear\structure\commands.hxx" />
-    <ClInclude Include="..\..\simgear\structure\event_mgr.hxx" />
-    <ClInclude Include="..\..\simgear\structure\exception.hxx" />
-    <ClInclude Include="..\..\simgear\structure\OSGVersion.hxx" />
-    <ClInclude Include="..\..\simgear\structure\SGBinding.hxx" />
-    <ClInclude Include="..\..\simgear\structure\SGExpression.hxx" />
-    <ClInclude Include="..\..\simgear\structure\SGReferenced.hxx" />
-    <ClInclude Include="..\..\simgear\structure\SGSharedPtr.hxx" />
-    <ClInclude Include="..\..\simgear\structure\SGSmplhist.hxx" />
-    <ClInclude Include="..\..\simgear\structure\SGSmplstat.hxx" />
-    <ClInclude Include="..\..\simgear\structure\subsystem_mgr.hxx" />
-    <ClInclude Include="..\..\simgear\nasal\code.h" />
-    <ClInclude Include="..\..\simgear\nasal\data.h" />
-    <ClInclude Include="..\..\simgear\nasal\iolib.h" />
-    <ClInclude Include="..\..\simgear\nasal\nasal.h" />
-    <ClInclude Include="..\..\simgear\nasal\parse.h" />
-    <ClInclude Include="..\..\simgear\environment\metar.hxx" />
-    <ClInclude Include="..\..\simgear\environment\precipitation.hxx" />
-    <ClInclude Include="..\..\simgear\environment\visual_enviro.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\CopyOp.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\NodeAndDrawableVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\PrimitiveUtils.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\QuadTreeBuilder.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\RenderConstants.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGDebugDrawCallback.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGEnlargeBoundingBox.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGNodeMasks.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGSceneFeatures.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGSceneUserData.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGStateAttributeVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGTextureStateAttributeVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SGUpdateVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\SplicingVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\StateAttributeFactory.hxx" />
-    <ClInclude Include="..\..\simgear\scene\util\UpdateOnceCallback.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHBoundingBoxVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHDebugCollectVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHGroup.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHLineGeometry.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHLineSegmentVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHMotionTransform.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHNode.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHStaticBinary.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHStaticData.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHStaticGeometry.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHStaticGeometryBuilder.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHStaticLeaf.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHStaticNode.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHStaticTriangle.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHSubTreeCollector.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHTransform.hxx" />
-    <ClInclude Include="..\..\simgear\scene\bvh\BVHVisitor.hxx" />
-    <ClInclude Include="..\..\simgear\compiler.h" />
-    <ClInclude Include="..\..\simgear\version.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="..\..\simgear\math\linintp2.inl" />
-    <CustomBuild Include="..\..\simgear\simgear_config.h-msvc90">
-      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Generation of simgear_config.h</Message>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">copy %(FullPath) %(RootDir)%(Directory)\%(Filename).h
-</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\..\simgear\simgear_config.h;%(Outputs)</Outputs>
-      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Generation of simgear_config.h</Message>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">copy %(FullPath) %(RootDir)%(Directory)\%(Filename).h
-</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">..\..\simgear\simgear_config.h;%(Outputs)</Outputs>
-      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Generation of simgear_config.h</Message>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">copy %(FullPath) %(RootDir)%(Directory)\%(Filename).h
-</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\..\simgear\simgear_config.h;%(Outputs)</Outputs>
-      <Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Generation of simgear_config.h</Message>
-      <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">copy %(FullPath) %(RootDir)%(Directory)\%(Filename).h
-</Command>
-      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">..\..\simgear\simgear_config.h;%(Outputs)</Outputs>
-    </CustomBuild>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

projects/VC90/.gitignore

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

simgear/.gitignore

@@ -1,4 +1,2 @@
 simgear_config.h
-simgear_config.h.*
-stamp-h1
 version.h

simgear/CMakeLists.txt

@@ -11,7 +11,6 @@ foreach( mylibfolder
         misc
         nasal
         props
-        route
         serial
         structure
         threads
@@ -23,35 +22,67 @@ foreach( mylibfolder
 
 endforeach( mylibfolder )
 
-if (NOT SIMGEAR_HEADLESS)
+if(NOT SIMGEAR_HEADLESS)
     add_subdirectory(environment)
     add_subdirectory(screen)
     add_subdirectory(scene)
     add_subdirectory(sound)
-endif()
+endif(NOT SIMGEAR_HEADLESS)
 
 
+if(ENABLE_RTI)
+    add_subdirectory(hla)
+endif(ENABLE_RTI)
+
 
 set(HEADERS compiler.h constants.h sg_inlines.h ${PROJECT_BINARY_DIR}/simgear/version.h)
 install (FILES ${HEADERS}  DESTINATION include/simgear/)
 
 if(SIMGEAR_SHARED)
-    message(STATUS "building shared library")
+    message(STATUS "Library building mode: SHARED LIBRARIES")
-    get_property(allSources GLOBAL PROPERTY ALL_SOURCES)
+    get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
+    get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
     get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
 
-    add_library(SimGear SHARED ${allSources})
+    add_library(SimGearCore SHARED ${coreSources})
-    set_property(TARGET SimGear PROPERTY FRAMEWORK 1)
+
-    message(STATUS "public header: ${publicHeaders}")
+  # set_property(TARGET SimGearCore PROPERTY FRAMEWORK 1)
-    set_property(TARGET SimGear PROPERTY PUBLIC_HEADER "${publicHeaders}")
+  #  message(STATUS "public header: ${publicHeaders}")
-    set_property(TARGET SimGear PROPERTY LINKER_LANGUAGE CXX)
+  #  set_property(TARGET SimGearCore PROPERTY PUBLIC_HEADER "${publicHeaders}")
-	
+    set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
-    target_link_libraries(SimGear ${ZLIB_LIBRARY} 
+
-			${OPENSCENEGRAPH_LIBRARIES} 
+    set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
-			${OPENAL_LIBRARY} ${ALUT_LIBRARY}
+    set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
-			${OPENGL_LIBRARY})
+
-			
+    target_link_libraries(SimGearCore ${ZLIB_LIBRARY} ${RT_LIBRARY})
-    install(TARGETS SimGear LIBRARY DESTINATION lib${LIB_SUFFIX}
+    install(TARGETS SimGearCore LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
-                            PUBLIC_HEADER DESTINATION include/simgear)
+
-endif(SIMGEAR_SHARED)
+    if(LIBSVN_FOUND)
+        add_definitions(${APR_CFLAGS})
+        include_directories(${LIBSVN_INCLUDE_DIR})
+        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}
+            ${JPEG_LIBRARY})
     
+        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif()
+
+else()
+    message(STATUS "Library building mode: STATIC LIBRARIES")
+endif(SIMGEAR_SHARED)
+

simgear/Makefile.am

@@ -1,43 +0,0 @@
-EXTRA_DIST = simgear_config.h.vc5 simgear_config.h-msvc71 version.h.in
-
-include_HEADERS = \
-	compiler.h constants.h sg_inlines.h version.h
-
-if WANT_HEADLESS
-SG_EXTRA_DIRS =
-METAR_DIRS = 
-else
-SG_EXTRA_DIRS = scene sound screen
-METAR_DIRS = environment
-endif
-
-if HAVE_THREADS
-SGTHREAD_DIR = threads
-else
-SGTHREAD_DIR = 
-endif
-
-SUBDIRS_ALWAYS = \
-	xml \
-	debug \
-	misc \
-	structure \
-	bucket \
-	ephemeris \
-	io \
-	magvar \
-	math \
-	nasal \
-	props \
-	route \
-	serial \
-	timing
-
-SUBDIRS = $(SUBDIRS_ALWAYS) \
-	$(compatibility_DIR) \
-	$(METAR_DIRS) \
-	$(SG_EXTRA_DIRS) \
-	$(SGTHREAD_DIR)
-
-DIST_SUBDIRS = $(SUBDIRS_ALWAYS) compatibility scene sound screen environment threads
-

simgear/bucket/Makefile.am

@@ -1,17 +0,0 @@
-includedir = @includedir@/bucket
-
-lib_LIBRARIES = libsgbucket.a
-
-include_HEADERS = newbucket.hxx
-
-libsgbucket_a_SOURCES = newbucket.cxx
-
-# noinst_PROGRAMS = testbucket
-
-# testbucket_SOURCES = testbucket.cxx
-
-# testbucket_LDADD = \
-# 	libsgbucket.a \
-# 	$(top_builddir)/misc/libsgmisc.a
-
-INCLUDES = -I$(top_srcdir)

simgear/compatibility/MIPSpro721/Makefile.am

@@ -1,14 +0,0 @@
-includedir = @includedir@/compatibility/
-
-include_HEADERS	= \
-	iostream \
-	strstream \
-	sstream \
-	istream \
-	fstream \
-	iterator \
-	iomanip \
-	new \
-	streambuf \
-	\
-	irix_string

simgear/compatibility/MIPSpro740/Makefile.am

@@ -1,22 +0,0 @@
-includedir = @includedir@/compatibility
-
-EXTRA_DIST = README
-
-include_HEADERS	= \
-	cfloat \
-	csetjmp \
-	cstdio \
-	cwchar \
-	cassert \
-	climits \
-	csignal \
-	cstdlib \
-	cwctype \
-	cctype \
-	clocale \
-	cstdarg \
-	cstring \
-	cerrno \
-	cmath \
-	cstddef \
-	ctime

simgear/compatibility/Makefile.am

@@ -1,3 +0,0 @@
-SUBDIRS = $(MIPSpro_DIRS)
-
-DIST_SUBDIRS = MIPSpro721 MIPSpro740

simgear/debug/Makefile.am

@@ -1,11 +0,0 @@
-includedir = @includedir@/debug
-
-EXTRA_DIST = logtest.cxx
-
-lib_LIBRARIES = libsgdebug.a
-
-include_HEADERS = debug_types.h logstream.hxx
-
-libsgdebug_a_SOURCES = logstream.cxx
-
-INCLUDES = -I$(top_srcdir)

simgear/debug/debug_types.h

@@ -1,35 +1,38 @@
 /** \file debug_types.h
- *  Define the various logging classes and prioritiess
+ *  Define the various logging classes and priorities
  */
 
 /** 
  * Define the possible classes/categories of logging messages
  */
 typedef enum {
-    SG_NONE      = 0x00000000,
+    SG_NONE        = 0x00000000,
 
-    SG_TERRAIN   = 0x00000001,
+    SG_TERRAIN     = 0x00000001,
-    SG_ASTRO     = 0x00000002,
+    SG_ASTRO       = 0x00000002,
-    SG_FLIGHT    = 0x00000004,
+    SG_FLIGHT      = 0x00000004,
-    SG_INPUT     = 0x00000008,
+    SG_INPUT       = 0x00000008,
-    SG_GL        = 0x00000010,
+    SG_GL          = 0x00000010,
-    SG_VIEW      = 0x00000020,
+    SG_VIEW        = 0x00000020,
-    SG_COCKPIT   = 0x00000040,
+    SG_COCKPIT     = 0x00000040,
-    SG_GENERAL   = 0x00000080,
+    SG_GENERAL     = 0x00000080,
-    SG_MATH      = 0x00000100,
+    SG_MATH        = 0x00000100,
-    SG_EVENT     = 0x00000200,
+    SG_EVENT       = 0x00000200,
-    SG_AIRCRAFT  = 0x00000400,
+    SG_AIRCRAFT    = 0x00000400,
-    SG_AUTOPILOT = 0x00000800,
+    SG_AUTOPILOT   = 0x00000800,
-    SG_IO        = 0x00001000,
+    SG_IO          = 0x00001000,
-    SG_CLIPPER   = 0x00002000,
+    SG_CLIPPER     = 0x00002000,
-    SG_NETWORK   = 0x00004000,
+    SG_NETWORK     = 0x00004000,
-    SG_ATC       = 0x00008000,
+    SG_ATC         = 0x00008000,
-    SG_NASAL     = 0x00010000,
+    SG_NASAL       = 0x00010000,
-    SG_INSTR     = 0x00020000,
+    SG_INSTR       = 0x00020000,
-    SG_SYSTEMS   = 0x00040000,
+    SG_SYSTEMS     = 0x00040000,
-    SG_UNDEFD    = 0x00080000, // For range checking
+    SG_AI          = 0x00080000,
+    SG_ENVIRONMENT = 0x00100000,
+    SG_SOUND       = 0x00200000,
+    SG_UNDEFD      = 0x00400000, // For range checking
 
-    SG_ALL     = 0xFFFFFFFF
+    SG_ALL         = 0xFFFFFFFF
 } sgDebugClass;
 
 

simgear/environment/CMakeLists.txt

@@ -1,7 +1,23 @@
 
 include (SimGearComponent)
 
-set(HEADERS metar.hxx visual_enviro.hxx precipitation.hxx)
+set(HEADERS metar.hxx precipitation.hxx)
-set(SOURCES metar.cxx visual_enviro.cxx precipitation.cxx)
+set(SOURCES metar.cxx precipitation.cxx)
 
-simgear_component(environment environment "${SOURCES}" "${HEADERS}")
+simgear_scene_component(environment environment "${SOURCES}" "${HEADERS}")
+
+if(ENABLE_TESTS)
+add_executable(test_metar test_metar.cxx)
+
+if (SIMGEAR_SHARED)
+    target_link_libraries(test_metar SimGearScene) 
+else()
+    target_link_libraries(test_metar
+        sgenvironment sgstructure sgmisc sgdebug
+        ${CMAKE_THREAD_LIBS_INIT}
+        ${ZLIB_LIBRARY}
+        ${RT_LIBRARY})
+endif()
+
+add_test(metar ${EXECUTABLE_OUTPUT_PATH}/test_metar)
+endif(ENABLE_TESTS)

simgear/environment/Makefile.am

@@ -1,9 +0,0 @@
-includedir = @includedir@/environment
-
-lib_LIBRARIES = libsgenvironment.a
-
-include_HEADERS = metar.hxx visual_enviro.hxx precipitation.hxx
-
-libsgenvironment_a_SOURCES = metar.cxx visual_enviro.cxx precipitation.cxx
-
-INCLUDES = -I$(top_srcdir)

simgear/environment/metar.cxx

@@ -32,7 +32,6 @@
 #include <time.h>
 #include <cstring>
 
-#include <simgear/io/sg_socket.hxx>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/structure/exception.hxx>
 
@@ -40,32 +39,28 @@
 
 #define NaN SGMetarNaN
 
+using std::string;
+using std::map;
+using std::vector;
+
 /**
- * The constructor takes a Metar string, or a four-letter ICAO code. In the
+ * The constructor takes a Metar string
- * latter case the metar string is downloaded from
- * http://weather.noaa.gov/pub/data/observations/metar/stations/.
  * The constructor throws sg_io_exceptions on failure. The "METAR"
  * keyword has no effect (apart from incrementing the group counter
  * @a grpcount) and can be left away. A keyword "SPECI" is
  * likewise accepted.
  *
  * @param m     ICAO station id or metar string
- * @param proxy proxy host (optional; default: "")
- * @param port  proxy port (optional; default: "80")
- * @param auth  proxy authorization information (optional; default: "")
  *
  * @par Examples:
  * @code
  * SGMetar *m = new SGMetar("METAR KSFO 061656Z 19004KT 9SM SCT100 OVC200 08/03 A3013");
  * double t = m->getTemperature_F();
  * delete m;
- *
+
- * SGMetar n("KSFO", "proxy.provider.foo", "3128", "proxy-password");
- * double d = n.getDewpoint_C();
  * @endcode
  */
-SGMetar::SGMetar(const string& m, const string& proxy, const string& port,
+SGMetar::SGMetar(const string& m) :
-		const string& auth, const time_t time) :
 	_grpcount(0),
 	_x_proxy(false),
 	_year(-1),
@@ -87,16 +82,10 @@ SGMetar::SGMetar(const string& m, const string& proxy, const string& port,
 	_snow(false),
 	_cavok(false)
 {
-	if (m.length() == 4 && isalnum(m[0]) && isalnum(m[1]) && isalnum(m[2]) && isalnum(m[3])) {
+	_data = new char[m.length() + 2];	// make room for " \0"
-		for (int i = 0; i < 4; i++)
+	strcpy(_data, m.c_str());
-			_icao[i] = toupper(m[i]);
+	_url = _data;
-		_icao[4] = '\0';
+		
-		_data = loadData(_icao, proxy, port, auth, time);
-	} else {
-		_data = new char[m.length() + 2];	// make room for " \0"
-		strcpy(_data, m.c_str());
-		_url = _data;
-	}
 	normalizeData();
 
 	_m = _data;
@@ -169,85 +158,6 @@ void SGMetar::useCurrentDate()
 	_month = now.tm_mon + 1;
 }
 
-
-/**
-  * If called with "KSFO" loads data from
-  * @code
-  * http://weather.noaa.gov/pub/data/observations/metar/stations/KSFO.TXT.
-  * @endcode
-  * Throws sg_io_exception on failure. Gives up after waiting longer than 10 seconds.
-  *
-  * @param id four-letter ICAO Metar station code, e.g. "KSFO".
-  * @param proxy proxy host (optional; default: "")
-  * @param port  proxy port (optional; default: "80")
-  * @param auth  proxy authorization information (optional; default: "")
-  * @return pointer to Metar data string, allocated by new char[].
-  * @see rfc2068.txt for proxy spec ("Proxy-Authorization")
-  */
-char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
-		const string& auth, time_t time)
-{
-	const int buflen = 512;
-	char buf[2 * buflen];
-
-	string metar_server = "weather.noaa.gov";
-	string host = proxy.empty() ? metar_server : proxy;
-	string path = "/pub/data/observations/metar/stations/";
-
-	path += string(id) + ".TXT";
-	_url = "http://" + metar_server + path;
-
-	SGSocket *sock = new SGSocket(host, port.empty() ? "80" : port, "tcp");
-	sock->set_timeout(10000);
-	if (!sock->open(SG_IO_OUT)) {
-		delete sock;
-		throw sg_io_exception("cannot connect to ", sg_location(host));
-	}
-
-	string get = "GET ";
-	if (!proxy.empty())
-		get += "http://" + metar_server;
-
-	sprintf(buf, "%ld", time);
-	get += path + " HTTP/1.0\015\012X-Time: " + buf + "\015\012";
-	get += "Host: " + metar_server + "\015\012";
-
-	if (!auth.empty())
-		get += "Proxy-Authorization: " + auth + "\015\012";
-
-	get += "\015\012";
-	sock->writestring(get.c_str());
-
-	int i;
-
-	// skip HTTP header
-	while ((i = sock->readline(buf, buflen))) {
-		if (i <= 2 && isspace(buf[0]) && (!buf[1] || isspace(buf[1])))
-			break;
-		if (!strncmp(buf, "X-MetarProxy: ", 13))
-			_x_proxy = true;
-	}
-	if (i) {
-		i = sock->readline(buf, buflen);
-		if (i)
-			sock->readline(&buf[i], buflen);
-	}
-
-	sock->close();
-	delete sock;
-
-	char *b = buf;
-	scanBoundary(&b);
-	if (*b == '<')
-		throw sg_io_exception("no metar data available from ", 
-				sg_location(_url));
-
-	char *metar = new char[strlen(b) + 2];	// make room for " \0"
-	strcpy(metar, b);
-	return metar;
-}
-
-
 /**
   * Replace any number of subsequent spaces by just one space, and add
   * a trailing space. This makes scanning for things like "ALL RWY" easier.
@@ -596,7 +506,7 @@ bool SGMetar::scanRwyVisRange()
 	r._max_visibility._distance = to;
 
 	if (*m == '/')					// this is not in the spec!
-		*m++;
+		m++;
 	if (*m == 'D')
 		m++, r._min_visibility._tendency = SGMetarVisibility::DECREASING;
 	else if (*m == 'N')

simgear/environment/metar.hxx

@@ -29,18 +29,12 @@
 
 #include <simgear/constants.h>
 
-using std::vector;
-using std::map;
-using std::string;
-
-const double SGMetarNaN = -1E20;
-#define NaN SGMetarNaN
-
 struct Token {
 	const char *id;
 	const char *text;
 };
 
+const double SGMetarNaN = -1E20;
 
 class SGMetar;
 
@@ -48,7 +42,7 @@ class SGMetarVisibility {
 	friend class SGMetar;
 public:
 	SGMetarVisibility() :
-		_distance(NaN),
+		_distance(SGMetarNaN),
 		_direction(-1),
 		_modifier(EQUALS),
 		_tendency(NONE) {}
@@ -70,8 +64,8 @@ public:
 	void set(double dist, int dir = -1, int mod = -1, int tend = -1);
 
 	inline double	getVisibility_m()	const { return _distance; }
-	inline double	getVisibility_ft()	const { return _distance == NaN ? NaN : _distance * SG_METER_TO_FEET; }
+	inline double	getVisibility_ft()	const { return _distance == SGMetarNaN ? SGMetarNaN : _distance * SG_METER_TO_FEET; }
-	inline double	getVisibility_sm()	const { return _distance == NaN ? NaN : _distance * SG_METER_TO_SM; }
+	inline double	getVisibility_sm()	const { return _distance == SGMetarNaN ? SGMetarNaN : _distance * SG_METER_TO_SM; }
 	inline int	getDirection()		const { return _direction; }
 	inline int	getModifier()		const { return _modifier; }
 	inline int	getTendency()		const { return _tendency; }
@@ -93,8 +87,8 @@ public:
 		_deposit_string(0),
 		_extent(-1),
 		_extent_string(0),
-		_depth(NaN),
+		_depth(SGMetarNaN),
-		_friction(NaN),
+		_friction(SGMetarNaN),
 		_friction_string(0),
 		_comment(0),
 		_wind_shear(false) {}
@@ -107,7 +101,7 @@ public:
 	inline double			getFriction()		const { return _friction; }
 	inline const char		*getFrictionString()	const { return _friction_string; }
 	inline const char		*getComment()		const { return _comment; }
-	inline const bool		getWindShear()		const { return _wind_shear; }
+	inline       bool		getWindShear()		const { return _wind_shear; }
 	inline const SGMetarVisibility&	getMinVisibility()	const { return _min_visibility; }
 	inline const SGMetarVisibility&	getMaxVisibility()	const { return _max_visibility; }
 
@@ -146,14 +140,14 @@ public:
 	static const char * COVERAGE_BROKEN_STRING;
 	static const char * COVERAGE_OVERCAST_STRING;
 
-	SGMetarCloud() : _coverage(COVERAGE_NIL), _altitude(NaN), _type(0), _type_long(0) {}
+	SGMetarCloud() : _coverage(COVERAGE_NIL), _altitude(SGMetarNaN), _type(0), _type_long(0) {}
 
 	void set(double alt, Coverage cov = COVERAGE_NIL );
 
 	inline Coverage getCoverage() const { return _coverage; }
 	static Coverage getCoverage( const std::string & coverage );
 	inline double getAltitude_m() const { return _altitude; }
-	inline double getAltitude_ft() const { return _altitude == NaN ? NaN : _altitude * SG_METER_TO_FEET; }
+	inline double getAltitude_ft() const { return _altitude == SGMetarNaN ? SGMetarNaN : _altitude * SG_METER_TO_FEET; }
 	inline const char *getTypeString() const { return _type; }
 	inline const char *getTypeLongString() const { return _type_long; }
 
@@ -167,8 +161,7 @@ protected:
 
 class SGMetar {
 public:
-	SGMetar(const string& m, const string& proxy = "", const string& port = "",
+	SGMetar(const std::string& m);
-			const string &auth = "", const time_t time = 0);
 	~SGMetar();
 
 	enum ReportType {
@@ -189,13 +182,13 @@ public:
 		Weather() { intensity = NIL; vincinity = false; }
 		Intensity intensity;
 		bool      vincinity;
-		vector<string> descriptions;
+		std::vector<std::string> descriptions;
-		vector<string> phenomena;
+		std::vector<std::string> phenomena;
 	};
 
 	inline const char *getData()		const { return _data; }
 	inline const char *getUnusedData()	const { return _m; }
-	inline const bool getProxy()		const { return _x_proxy; }
+	inline       bool getProxy()		const { return _x_proxy; }
 	inline const char *getId()		const { return _icao; }
 	inline int	getYear()		const { return _year; }
 	inline int	getMonth()		const { return _month; }
@@ -206,14 +199,14 @@ public:
 
 	inline int	getWindDir()		const { return _wind_dir; }
 	inline double	getWindSpeed_mps()	const { return _wind_speed; }
-	inline double	getWindSpeed_kmh()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_KMH; }
+	inline double	getWindSpeed_kmh()	const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_KMH; }
-	inline double	getWindSpeed_kt()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_KT; }
+	inline double	getWindSpeed_kt()	const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_KT; }
-	inline double	getWindSpeed_mph()	const { return _wind_speed == NaN ? NaN : _wind_speed * SG_MPS_TO_MPH; }
+	inline double	getWindSpeed_mph()	const { return _wind_speed == SGMetarNaN ? SGMetarNaN : _wind_speed * SG_MPS_TO_MPH; }
 
 	inline double	getGustSpeed_mps()	const { return _gust_speed; }
-	inline double	getGustSpeed_kmh()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_KMH; }
+	inline double	getGustSpeed_kmh()	const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_KMH; }
-	inline double	getGustSpeed_kt()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_KT; }
+	inline double	getGustSpeed_kt()	const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_KT; }
-	inline double	getGustSpeed_mph()	const { return _gust_speed == NaN ? NaN : _gust_speed * SG_MPS_TO_MPH; }
+	inline double	getGustSpeed_mph()	const { return _gust_speed == SGMetarNaN ? SGMetarNaN : _gust_speed * SG_MPS_TO_MPH; }
 
 	inline int	getWindRangeFrom()	const { return _wind_range_from; }
 	inline int	getWindRangeTo()	const { return _wind_range_to; }
@@ -224,11 +217,11 @@ public:
 	inline const SGMetarVisibility *getDirVisibility()	const { return _dir_visibility; }
 
 	inline double	getTemperature_C()	const { return _temp; }
-	inline double	getTemperature_F()	const { return _temp == NaN ? NaN : 1.8 * _temp + 32; }
+	inline double	getTemperature_F()	const { return _temp == SGMetarNaN ? SGMetarNaN : 1.8 * _temp + 32; }
 	inline double	getDewpoint_C()		const { return _dewp; }
-	inline double	getDewpoint_F()		const { return _dewp == NaN ? NaN : 1.8 * _dewp + 32; }
+	inline double	getDewpoint_F()		const { return _dewp == SGMetarNaN ? SGMetarNaN : 1.8 * _dewp + 32; }
-	inline double	getPressure_hPa()	const { return _pressure == NaN ? NaN : _pressure / 100; }
+	inline double	getPressure_hPa()	const { return _pressure == SGMetarNaN ? SGMetarNaN : _pressure / 100; }
-	inline double	getPressure_inHg()	const { return _pressure == NaN ? NaN : _pressure * SG_PA_TO_INHG; }
+	inline double	getPressure_inHg()	const { return _pressure == SGMetarNaN ? SGMetarNaN : _pressure * SG_PA_TO_INHG; }
 
 	inline int	getRain()		const { return _rain; }
 	inline int	getHail()		const { return _hail; }
@@ -237,13 +230,13 @@ public:
 
 	double		getRelHumidity()	const;
 
-	inline const vector<SGMetarCloud>& getClouds()	const	{ return _clouds; }
+	inline const std::vector<SGMetarCloud>& getClouds()	const	{ return _clouds; }
-	inline const map<string, SGMetarRunway>& getRunways()	const	{ return _runways; }
+	inline const std::map<std::string, SGMetarRunway>& getRunways()	const	{ return _runways; }
-	inline const vector<string>& getWeather()		const	{ return _weather; }
+	inline const std::vector<std::string>& getWeather()		const	{ return _weather; }
-	inline const vector<struct Weather> getWeather2()	const   { return _weather2; }
+	inline const std::vector<struct Weather> getWeather2()	const   { return _weather2; }
 
 protected:
-	string	_url;
+	std::string	_url;
 	int	_grpcount;
 	bool	_x_proxy;
 	char	*_data;
@@ -267,15 +260,15 @@ protected:
 	int	_hail;
 	int	_snow;
 	bool	_cavok;
-	vector<struct Weather> _weather2;
+	std::vector<struct Weather> _weather2;
 
 	SGMetarVisibility		_min_visibility;
 	SGMetarVisibility		_max_visibility;
 	SGMetarVisibility		_vert_visibility;
 	SGMetarVisibility		_dir_visibility[8];
-	vector<SGMetarCloud>		_clouds;
+	std::vector<SGMetarCloud>		_clouds;
-	map<string, SGMetarRunway>	_runways;
+	std::map<std::string, SGMetarRunway>	_runways;
-	vector<string>			_weather;
+	std::vector<std::string>			_weather;
 
 	bool	scanPreambleDate();
 	bool	scanPreambleTime();
@@ -303,10 +296,7 @@ protected:
 	int	scanNumber(char **str, int *num, int min, int max = 0);
 	bool	scanBoundary(char **str);
 	const struct Token *scanToken(char **str, const struct Token *list);
-	char	*loadData(const char *id, const string& proxy, const string& port,
-			const string &auth, time_t time);
 	void	normalizeData();
 };
 
-#undef NaN
 #endif // _METAR_HXX

simgear/environment/precipitation.cxx

@@ -25,10 +25,11 @@
  */
 
 #include "precipitation.hxx"
-#include "visual_enviro.hxx"
+//#include "visual_enviro.hxx"
 
 #include <simgear/constants.h>
 #include <osg/ClipNode>
+#include <simgear/scene/util/RenderConstants.hxx>
 
 /**
  * @brief SGPrecipitation constructor
@@ -36,11 +37,20 @@
  * Build a new OSG object from osgParticle.
  */
 SGPrecipitation::SGPrecipitation() :
-    _freeze(false), _snow_intensity(0.0), _rain_intensity(0.0), _clip_distance(5.0)
+    _freeze(false), _enabled(true), _snow_intensity(0.0), _rain_intensity(0.0), _clip_distance(5.0)
 {
     _precipitationEffect = new osgParticle::PrecipitationEffect;
 }
 
+void SGPrecipitation::setEnabled( bool value )
+{
+    _enabled = value;
+}
+
+bool SGPrecipitation::getEnabled() const
+{
+    return _enabled;
+}
 
 /**
  * @brief Build and add the object "precipitationEffect"
@@ -70,6 +80,8 @@ osg::Group* SGPrecipitation::build(void)
         group->addChild(_precipitationEffect.get());
     }
 
+    group->setNodeMask( ~(simgear::CASTSHADOW_BIT | simgear::MODELLIGHT_BIT) );
+
     return group;
 }
 
@@ -161,8 +173,7 @@ bool SGPrecipitation::update(void)
             this->_snow_intensity = this->_rain_intensity;
     }
 
-    bool enabled = sgEnviro.get_precipitation_enable_state();
+    if (_enabled && this->_snow_intensity > 0) {
-    if (enabled && this->_snow_intensity > 0) {
         _precipitationEffect->setWind(_wind_vec);
         _precipitationEffect->setParticleSpeed( -0.75f - 0.25f*_snow_intensity);
 		
@@ -174,7 +185,7 @@ bool SGPrecipitation::update(void)
         _precipitationEffect->setFarTransition(100.0f - 60.0f*sqrtf(_snow_intensity));
 		
         _precipitationEffect->setParticleColor(osg::Vec4(0.85, 0.85, 0.85, 1.0) - osg::Vec4(0.1, 0.1, 0.1, 1.0) * _snow_intensity);
-    } else if (enabled && this->_rain_intensity > 0) {
+    } else if (_enabled && this->_rain_intensity > 0) {
         _precipitationEffect->setWind(_wind_vec);
         _precipitationEffect->setParticleSpeed( -2.0f + -5.0f*_rain_intensity);
 		

simgear/environment/precipitation.hxx

@@ -36,6 +36,7 @@ class SGPrecipitation : public osg::Referenced
 {
 private:
     bool _freeze;
+    bool _enabled;
 
     float _snow_intensity;
     float _rain_intensity;
@@ -56,6 +57,9 @@ public:
     void setFreezing(bool);
     void setRainIntensity(float);
     void setSnowIntensity(float);
+
+    void setEnabled( bool );
+    bool getEnabled() const;
 };
 
 #endif

simgear/environment/test_metar.cxx

@@ -0,0 +1,76 @@
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include <iostream>
+#include <cstdlib>
+#include <cstdio>
+
+#ifdef _MSC_VER
+#   define  random  rand
+#endif
+
+#include <simgear/misc/sg_dir.hxx>
+#include <simgear/structure/exception.hxx>
+
+#include "metar.hxx"
+
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::string;
+
+#define COMPARE(a, b) \
+    if ((a) != (b))  { \
+        cerr << "failed:" << #a << " != " << #b << endl; \
+        cerr << "\tgot:" << a << endl; \
+        exit(1); \
+    }
+
+#define FUZZY_COMPARE(a, b, epsilon) \
+    if (fabs(a - b) > epsilon) { \
+        cerr << "failed:" << #a << " != " << #b << endl; \
+        cerr << "\tgot:" << a << endl; \
+        cerr << "\tepsilon:" << epsilon << endl; \
+    }
+
+#define VERIFY(a) \
+    if (!(a))  { \
+        cerr << "failed:" << #a << endl; \
+        exit(1); \
+    }
+
+const double TEST_EPSILON = 1e-9;
+
+void test_basic()
+{
+    SGMetar m1("2011/10/20 11:25 EHAM 201125Z 27012KT 240V300 9999 VCSH FEW025CB SCT048 10/05 Q1025 TEMPO VRB03KT");
+    COMPARE(m1.getYear(), 2011);
+    COMPARE(m1.getMonth(), 10);
+    COMPARE(m1.getDay(), 20);
+    COMPARE(m1.getHour(), 11);
+    COMPARE(m1.getMinute(), 25);
+    COMPARE(m1.getReportType(), -1); // should default to NIL?
+    
+    COMPARE(m1.getWindDir(), 270);
+    FUZZY_COMPARE(m1.getWindSpeed_kt(), 12, TEST_EPSILON);
+    
+    FUZZY_COMPARE(m1.getTemperature_C(), 10, TEST_EPSILON);
+    FUZZY_COMPARE(m1.getDewpoint_C(), 5, TEST_EPSILON);
+    FUZZY_COMPARE(m1.getPressure_hPa(), 1025, TEST_EPSILON);
+}
+
+int main(int argc, char* argv[])
+{
+    try {
+    test_basic();
+    } catch (sg_exception& e) {
+        cerr << "got exception:" << e.getMessage() << endl;
+        return -1;
+    }
+    
+    return 0;
+}

simgear/environment/visual_enviro.cxx

@@ -187,12 +187,12 @@ SGEnviro::SGEnviro() :
 }
 
 SGEnviro::~SGEnviro(void) {
-	if (sampleGroup) delete sampleGroup;
+  // if (sampleGroup) delete sampleGroup;
 
   // OSGFIXME
   return;
 	list_of_lightning::iterator iLightning;
-	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
+	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; ++iLightning ) {
 		delete (*iLightning);
 	}
 	lightnings.clear();

simgear/ephemeris/CMakeLists.txt

@@ -32,4 +32,4 @@ set(SOURCES
     venus.cxx
     )
 
-simgear_component(ephemeris ephemeris "${SOURCES}" "${HEADERS}")
+simgear_component(ephem ephemeris "${SOURCES}" "${HEADERS}")

simgear/ephemeris/Makefile.am

@@ -1,34 +0,0 @@
-includedir = @includedir@/ephemeris
-
-lib_LIBRARIES = libsgephem.a
-
-include_HEADERS = \
-	celestialBody.hxx \
-	ephemeris.hxx \
-	jupiter.hxx \
-	mars.hxx \
-	mercury.hxx \
-	moonpos.hxx \
-	neptune.hxx \
-	saturn.hxx \
-	star.hxx \
-	stardata.hxx \
-	uranus.hxx \
-	venus.hxx
-
-libsgephem_a_SOURCES = \
-	celestialBody.cxx \
-	ephemeris.cxx \
-	jupiter.cxx \
-	mars.cxx \
-	mercury.cxx \
-	moonpos.cxx \
-	neptune.cxx \
-	pluto.hxx \
-	saturn.cxx \
-	star.cxx \
-	stardata.cxx \
-	uranus.cxx \
-	venus.cxx
-
-INCLUDES = -I$(top_srcdir)

simgear/hla/CMakeLists.txt

@@ -0,0 +1,76 @@
+include (SimGearComponent)
+
+set(HLA_HEADERS
+    RTIData.hxx
+    HLAArrayDataElement.hxx
+    HLAArrayDataType.hxx
+    HLABasicDataElement.hxx
+    HLABasicDataType.hxx
+    HLADataElement.hxx
+    HLADataElementVisitor.hxx
+    HLADataType.hxx
+    HLADataTypeVisitor.hxx
+    HLAEnumeratedDataElement.hxx
+    HLAEnumeratedDataType.hxx
+    HLAFixedRecordDataElement.hxx
+    HLAFixedRecordDataType.hxx
+    HLAFederate.hxx
+    HLAInteractionClass.hxx
+    HLALocation.hxx
+    HLAObjectClass.hxx
+    HLAObjectInstance.hxx
+    HLAOMTXmlVisitor.hxx
+    HLAPropertyDataElement.hxx
+    HLARawDataElement.hxx
+    HLATypes.hxx
+    HLAVariantDataElement.hxx
+    HLAVariantDataType.hxx
+    HLAVariantRecordDataElement.hxx
+    HLAVariantRecordDataType.hxx
+    )
+
+set(HLA_SOURCES
+    HLAArrayDataElement.cxx
+    HLAArrayDataType.cxx
+    HLABasicDataElement.cxx
+    HLABasicDataType.cxx
+    HLADataElement.cxx
+    HLADataType.cxx
+    HLADataTypeVisitor.cxx
+    HLAEnumeratedDataElement.cxx
+    HLAEnumeratedDataType.cxx
+    HLAFederate.cxx
+    HLAInteractionClass.cxx
+    HLAFixedRecordDataElement.cxx
+    HLAFixedRecordDataType.cxx
+    HLAObjectClass.cxx
+    HLAObjectInstance.cxx
+    HLAOMTXmlVisitor.cxx
+    HLAPropertyDataElement.cxx
+    HLARawDataElement.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

@@ -0,0 +1,374 @@
+// 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 "HLAArrayDataElement.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+
+namespace simgear {
+
+HLAAbstractArrayDataElement::HLAAbstractArrayDataElement(const HLAArrayDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLAAbstractArrayDataElement::~HLAAbstractArrayDataElement()
+{
+}
+
+void
+HLAAbstractArrayDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLAAbstractArrayDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAAbstractArrayDataElement::decode(HLADecodeStream& stream)
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->decode(stream, *this);
+}
+
+bool
+HLAAbstractArrayDataElement::encode(HLAEncodeStream& stream) const
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->encode(stream, *this);
+}
+
+const HLAArrayDataType*
+HLAAbstractArrayDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLAAbstractArrayDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAArrayDataType* arrayDataType = dynamic_cast<const HLAArrayDataType*>(dataType);
+    if (!arrayDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAArrayDataType: unable to set data type!");
+        return false;
+    }
+    _dataType = arrayDataType;
+    return true;
+}
+
+const HLADataType*
+HLAAbstractArrayDataElement::getElementDataType() const
+{
+    if (!_dataType.valid())
+        return 0;
+    return _dataType->getElementDataType();
+}
+
+////////////////////////////////////////////////////////////////////////
+
+HLAArrayDataElement::DataElementFactory::~DataElementFactory()
+{
+}
+
+HLAArrayDataElement::HLAArrayDataElement(const HLAArrayDataType* dataType) :
+    HLAAbstractArrayDataElement(dataType)
+{
+}
+
+HLAArrayDataElement::~HLAArrayDataElement()
+{
+    clearStamp();
+}
+
+bool
+HLAArrayDataElement::setNumElements(unsigned size)
+{
+    unsigned oldSize = _elementVector.size();
+    if (size == oldSize)
+        return true;
+    _elementVector.resize(size);
+    for (unsigned i = oldSize; i < size; ++i)
+        _elementVector[i] = newElement(i);
+    setDirty(true);
+    return true;
+}
+
+bool
+HLAArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
+{
+    HLADataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->decode(stream);
+}
+
+unsigned
+HLAArrayDataElement::getNumElements() const
+{
+    return _elementVector.size();
+}
+
+bool
+HLAArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
+{
+    const HLADataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->encode(stream);
+}
+
+const HLADataElement*
+HLAArrayDataElement::getElement(unsigned index) const
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLADataElement*
+HLAArrayDataElement::getElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLADataElement*
+HLAArrayDataElement::getOrCreateElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        if (!setNumElements(index + 1))
+            return 0;
+    return _elementVector[index].get();
+}
+
+void
+HLAArrayDataElement::setElement(unsigned index, HLADataElement* value)
+{
+    unsigned oldSize = _elementVector.size();
+    if (oldSize <= index) {
+        _elementVector.resize(index + 1);
+        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
+HLAArrayDataElement::setDataElementFactory(HLAArrayDataElement::DataElementFactory* dataElementFactory)
+{
+    _dataElementFactory = dataElementFactory;
+}
+
+HLAArrayDataElement::DataElementFactory*
+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;
+    HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
+    if (!dataElement)
+        return 0;
+    dataElement->attachStamp(*this);
+    return dataElement;
+}
+
+////////////////////////////////////////////////////////////////////////
+
+HLAVariantArrayDataElement::HLAVariantArrayDataElement() :
+    HLAAbstractArrayDataElement(0)
+{
+}
+
+HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
+{
+    clearStamp();
+}
+
+bool
+HLAVariantArrayDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAArrayDataType* arrayDataType = dataType->toArrayDataType();
+    if (!arrayDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
+        return false;
+    }
+    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;
+    }
+    _dataType = arrayDataType;
+    return true;
+}
+
+bool
+HLAVariantArrayDataElement::setNumElements(unsigned size)
+{
+    unsigned oldSize = _elementVector.size();
+    if (size == oldSize)
+        return true;
+    _elementVector.resize(size);
+    for (unsigned i = oldSize; i < size; ++i)
+        _elementVector[i] = newElement();
+    setDirty(true);
+    return true;
+}
+
+bool
+HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
+{
+    HLAVariantRecordDataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->decode(stream);
+}
+
+unsigned
+HLAVariantArrayDataElement::getNumElements() const
+{
+    return _elementVector.size();
+}
+
+bool
+HLAVariantArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
+{
+    const HLADataElement* dataElement = getElement(i);
+    if (!dataElement)
+        return false;
+    return dataElement->encode(stream);
+}
+
+const HLAVariantRecordDataElement*
+HLAVariantArrayDataElement::getElement(unsigned index) const
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLAVariantRecordDataElement*
+HLAVariantArrayDataElement::getElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        return 0;
+    return _elementVector[index].get();
+}
+
+HLAVariantRecordDataElement*
+HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
+{
+    if (_elementVector.size() <= index)
+        if (!setNumElements(index + 1))
+            return 0;
+    return _elementVector[index].get();
+}
+
+void
+HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantRecordDataElement* value)
+{
+    unsigned oldSize = _elementVector.size();
+    if (oldSize <= index) {
+        _elementVector.resize(index + 1);
+        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
+HLAVariantArrayDataElement::setAlternativeDataElementFactory(HLAVariantArrayDataElement::AlternativeDataElementFactory* alternativeDataElementFactory)
+{
+    _alternativeDataElementFactory = alternativeDataElementFactory;
+}
+
+HLAVariantArrayDataElement::AlternativeDataElementFactory*
+HLAVariantArrayDataElement::getAlternativeDataElementFactory()
+{
+    return _alternativeDataElementFactory.get();
+}
+
+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();
+    if (!arrayDataType)
+        return 0;
+    const HLADataType* elementDataType = arrayDataType->getElementDataType();
+    if (!elementDataType)
+        return 0;
+    const HLAVariantRecordDataType* variantRecordDataType = elementDataType->toVariantRecordDataType();
+    if (!variantRecordDataType)
+        return 0;
+    HLAVariantRecordDataElement* variantRecordDataElement = new HLAVariantRecordDataElement(variantRecordDataType);
+    variantRecordDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
+    variantRecordDataElement->attachStamp(*this);
+    return variantRecordDataElement;
+}
+
+}

simgear/hla/HLAArrayDataElement.hxx

@@ -0,0 +1,538 @@
+// 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 HLAArrayDataElement_hxx
+#define HLAArrayDataElement_hxx
+
+#include <string>
+#include <vector>
+#include <simgear/math/SGMath.hxx>
+#include "HLAArrayDataType.hxx"
+#include "HLADataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+class HLAAbstractArrayDataElement : public HLADataElement {
+public:
+    HLAAbstractArrayDataElement(const HLAArrayDataType* dataType);
+    virtual ~HLAAbstractArrayDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAArrayDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+
+    const HLADataType* getElementDataType() const;
+
+    virtual bool setNumElements(unsigned count) = 0;
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i) = 0;
+
+    virtual unsigned getNumElements() const = 0;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const = 0;
+
+protected:
+    SGSharedPtr<const HLAArrayDataType> _dataType;
+};
+
+class HLAArrayDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAArrayDataElement(const HLAArrayDataType* dataType = 0);
+    virtual ~HLAArrayDataElement();
+
+    virtual bool setNumElements(unsigned size);
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i);
+    virtual unsigned getNumElements() const;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
+
+    const HLADataElement* getElement(unsigned index) const;
+    HLADataElement* getElement(unsigned index);
+    HLADataElement* getOrCreateElement(unsigned index);
+    void setElement(unsigned i, HLADataElement* value);
+
+    class DataElementFactory : public SGReferenced {
+    public:
+        virtual ~DataElementFactory();
+        virtual HLADataElement* createElement(const HLAArrayDataElement&, unsigned) = 0;
+    };
+
+    void setDataElementFactory(DataElementFactory* dataElementFactory);
+    DataElementFactory* getDataElementFactory();
+
+protected:
+    virtual void _setStamp(Stamp* stamp);
+
+private:
+    HLADataElement* newElement(unsigned index);
+
+    typedef std::vector<SGSharedPtr<HLADataElement> > ElementVector;
+    ElementVector _elementVector;
+
+    SGSharedPtr<DataElementFactory> _dataElementFactory;
+};
+
+// Holds an array of variants.
+// Factors out common code for that use case.
+class HLAVariantArrayDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVariantArrayDataElement();
+    virtual ~HLAVariantArrayDataElement();
+
+    // Overwrite this from the abstract class, need some more checks here
+    virtual bool setDataType(const HLADataType* dataType);
+
+    virtual bool setNumElements(unsigned size);
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i);
+    virtual unsigned getNumElements() const;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
+
+    const HLAVariantRecordDataElement* getElement(unsigned index) const;
+    HLAVariantRecordDataElement* getElement(unsigned index);
+    HLAVariantRecordDataElement* getOrCreateElement(unsigned index);
+    void setElement(unsigned index, HLAVariantRecordDataElement* value);
+
+    typedef HLAVariantRecordDataElement::DataElementFactory AlternativeDataElementFactory;
+
+    void setAlternativeDataElementFactory(AlternativeDataElementFactory* alternativeDataElementFactory);
+    AlternativeDataElementFactory* getAlternativeDataElementFactory();
+
+protected:
+    virtual void _setStamp(Stamp* stamp);
+
+private:
+    HLAVariantRecordDataElement* newElement();
+
+    typedef std::vector<SGSharedPtr<HLAVariantRecordDataElement> > ElementVector;
+    ElementVector _elementVector;
+
+    SGSharedPtr<AlternativeDataElementFactory> _alternativeDataElementFactory;
+};
+
+class HLAStringDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAStringDataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType)
+    {}
+    HLAStringDataElement(const HLAArrayDataType* dataType, const std::string& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const std::string& getValue() const
+    { return _value; }
+    void setValue(const std::string& value)
+    { _value = value; setDirty(true); }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        _value.resize(count);
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        HLATemplateDecodeVisitor<std::string::value_type> visitor(stream);
+        getElementDataType()->accept(visitor);
+        _value[i] = visitor.getValue();
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return _value.size();
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        HLATemplateEncodeVisitor<std::string::value_type> visitor(stream, _value[i]);
+        getElementDataType()->accept(visitor);
+        return true;
+    }
+
+private:
+    std::string _value;
+};
+
+class HLAStringData {
+public:
+    HLAStringData() :
+        _value(new HLAStringDataElement(0))
+    { }
+    HLAStringData(const std::string& value) :
+        _value(new HLAStringDataElement(0))
+    { _value->setValue(value); }
+
+    operator const std::string&() const
+    { return _value->getValue(); }
+    HLAStringData& operator=(const std::string& value)
+    { _value->setValue(value); return *this; }
+
+    const std::string& getValue() const
+    { return _value->getValue(); }
+    void setValue(const std::string& value)
+    { _value->setValue(value); }
+
+    const HLAStringDataElement* getDataElement() const
+    { return _value.get(); }
+    HLAStringDataElement* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAStringDataElement> _value;
+};
+
+template<typename T>
+class HLAVec2DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec2DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec2<T>::zeros())
+    {}
+    HLAVec2DataElement(const HLAArrayDataType* dataType, const SGVec2<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec2<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec2<T>& value)
+    { _value = value; setDirty(true); }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = count; i < 2; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 2) {
+            HLATemplateDecodeVisitor<typename SGVec2<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 2;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 2) {
+            HLATemplateEncodeVisitor<typename SGVec2<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec2<T> _value;
+};
+
+template<typename T>
+class HLAVec2Data {
+public:
+    HLAVec2Data() :
+        _value(new HLAVec2DataElement<T>(0))
+    { }
+    HLAVec2Data(const SGVec2<T>& value) :
+        _value(new HLAVec2DataElement<T>(0, value))
+    { }
+
+    operator const SGVec2<T>&() const
+    { return _value->getValue(); }
+    HLAVec2Data& operator=(const SGVec2<T>& value)
+    { _value->setValue(value); return *this; }
+
+    const SGVec2<T>& getValue() const
+    { return _value->getValue(); }
+    void setValue(const SGVec2<T>& value)
+    { _value->setValue(value); }
+
+    const HLAVec2DataElement<T>* getDataElement() const
+    { return _value.get(); }
+    HLAVec2DataElement<T>* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAVec2DataElement<T> > _value;
+};
+
+typedef HLAVec2Data<float> HLAVec2fData;
+typedef HLAVec2Data<double> HLAVec2dData;
+
+template<typename T>
+class HLAVec3DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec3DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec3<T>::zeros())
+    {}
+    HLAVec3DataElement(const HLAArrayDataType* dataType, const SGVec3<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec3<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec3<T>& value)
+    { _value = value; setDirty(true); }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = count; i < 3; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 3) {
+            HLATemplateDecodeVisitor<typename SGVec3<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 3;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 3) {
+            HLATemplateEncodeVisitor<typename SGVec3<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec3<T> _value;
+};
+
+template<typename T>
+class HLAVec3Data {
+public:
+    HLAVec3Data() :
+        _value(new HLAVec3DataElement<T>(0))
+    { }
+    HLAVec3Data(const SGVec3<T>& value) :
+        _value(new HLAVec3DataElement<T>(0, value))
+    { }
+
+    operator const SGVec3<T>&() const
+    { return _value->getValue(); }
+    HLAVec3Data& operator=(const SGVec3<T>& value)
+    { _value->setValue(value); return *this; }
+
+    const SGVec3<T>& getValue() const
+    { return _value->getValue(); }
+    void setValue(const SGVec3<T>& value)
+    { _value->setValue(value); }
+
+    const HLAVec3DataElement<T>* getDataElement() const
+    { return _value.get(); }
+    HLAVec3DataElement<T>* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAVec3DataElement<T> > _value;
+};
+
+typedef HLAVec3Data<float> HLAVec3fData;
+typedef HLAVec3Data<double> HLAVec3dData;
+
+template<typename T>
+class HLAVec4DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec4DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec4<T>::zeros())
+    {}
+    HLAVec4DataElement(const HLAArrayDataType* dataType, const SGVec4<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec4<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec4<T>& value)
+    { _value = value; setDirty(true); }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = count; i < 4; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 4) {
+            HLATemplateDecodeVisitor<typename SGVec4<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 4;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 4) {
+            HLATemplateEncodeVisitor<typename SGVec4<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec4<T> _value;
+};
+
+template<typename T>
+class HLAVec4Data {
+public:
+    HLAVec4Data() :
+        _value(new HLAVec4DataElement<T>(0))
+    { }
+    HLAVec4Data(const SGVec4<T>& value) :
+        _value(new HLAVec4DataElement<T>(0, value))
+    { }
+
+    operator const SGVec4<T>&() const
+    { return _value->getValue(); }
+    HLAVec4Data& operator=(const SGVec4<T>& value)
+    { _value->setValue(value); return *this; }
+
+    const SGVec4<T>& getValue() const
+    { return _value->getValue(); }
+    void setValue(const SGVec4<T>& value)
+    { _value->setValue(value); }
+
+    const HLAVec4DataElement<T>* getDataElement() const
+    { return _value.get(); }
+    HLAVec4DataElement<T>* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAVec4DataElement<T> > _value;
+};
+
+typedef HLAVec4Data<float> HLAVec4fData;
+typedef HLAVec4Data<double> HLAVec4dData;
+
+template<typename T>
+class HLAQuatDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAQuatDataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGQuat<T>::zeros())
+    {}
+    HLAQuatDataElement(const HLAArrayDataType* dataType, const SGQuat<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGQuat<T>& getValue() const
+    { return _value; }
+    void setValue(const SGQuat<T>& value)
+    { _value = value; setDirty(true); }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = count; i < 4; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 4) {
+            HLATemplateDecodeVisitor<typename SGQuat<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 4;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 4) {
+            HLATemplateEncodeVisitor<typename SGQuat<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGQuat<T> _value;
+};
+
+}
+
+#endif

simgear/hla/HLAArrayDataType.cxx

@@ -0,0 +1,198 @@
+// 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 "HLAArrayDataType.hxx"
+
+#include "HLAArrayDataElement.hxx"
+
+namespace simgear {
+
+HLAArrayDataType::HLAArrayDataType(const std::string& name) :
+    HLADataType(name),
+    _isOpaque(false),
+    _isString(false)
+{
+}
+
+HLAArrayDataType::~HLAArrayDataType()
+{
+}
+
+void
+HLAArrayDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLAArrayDataType*
+HLAArrayDataType::toArrayDataType() const
+{
+    return this;
+}
+
+void
+HLAArrayDataType::releaseDataTypeReferences()
+{
+    _elementDataType = 0;
+    HLADataType::releaseDataTypeReferences();
+}
+
+void
+HLAArrayDataType::setElementDataType(const HLADataType* elementDataType)
+{
+    _elementDataType = elementDataType;
+}
+
+void
+HLAArrayDataType::setIsOpaque(bool isOpaque)
+{
+    _isOpaque = isOpaque;
+}
+
+void
+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) :
+    HLAArrayDataType(name)
+{
+}
+
+HLAFixedArrayDataType::~HLAFixedArrayDataType()
+{
+}
+
+void
+HLAFixedArrayDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAFixedArrayDataType::decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numElements = getNumElements();
+    if (!value.setNumElements(numElements))
+        return false;
+    for (unsigned i = 0; i < numElements; ++i)
+        if (!value.decodeElement(stream, i))
+            return false;
+    return true;
+}
+
+bool
+HLAFixedArrayDataType::encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numElementsType = getNumElements();
+    unsigned numElementsValue = value.getNumElements();
+    unsigned numElements = SGMisc<unsigned>::min(numElementsType, numElementsValue);
+    unsigned i = 0;
+    for (; i < numElements; ++i)
+        if (!value.encodeElement(stream, i))
+            return false;
+    for (; i < numElementsType; ++i) {
+        HLADataTypeEncodeVisitor visitor(stream);
+        getElementDataType()->accept(visitor);
+    }
+    return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+
+HLAVariableArrayDataType::HLAVariableArrayDataType(const std::string& name) :
+    HLAArrayDataType(name)
+{
+    setSizeDataType(new HLAUInt32BEDataType);
+}
+
+HLAVariableArrayDataType::~HLAVariableArrayDataType()
+{
+}
+
+void
+HLAVariableArrayDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAVariableArrayDataType::decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    HLATemplateDecodeVisitor<unsigned> numElementsVisitor(stream);
+    getSizeDataType()->accept(numElementsVisitor);
+    unsigned numElements = numElementsVisitor.getValue();
+    if (!value.setNumElements(numElements))
+        return false;
+    for (unsigned i = 0; i < numElements; ++i)
+        if (!value.decodeElement(stream, i))
+            return false;
+    return true;
+}
+
+bool
+HLAVariableArrayDataType::encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numElements = value.getNumElements();
+    HLATemplateEncodeVisitor<unsigned> numElementsVisitor(stream, numElements);
+    getSizeDataType()->accept(numElementsVisitor);
+    for (unsigned i = 0; i < numElements; ++i)
+        if (!value.encodeElement(stream, i))
+            return false;
+    return true;
+}
+
+void
+HLAVariableArrayDataType::setSizeDataType(const HLABasicDataType* sizeDataType)
+{
+    _sizeDataType = sizeDataType;
+}
+
+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

@@ -0,0 +1,106 @@
+// 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 HLAArrayDataType_hxx
+#define HLAArrayDataType_hxx
+
+#include <string>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractArrayDataElement;
+
+class HLAArrayDataType : public HLADataType {
+public:
+    HLAArrayDataType(const std::string& name = "HLAArrayDataType");
+    virtual ~HLAArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    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;
+
+    void setElementDataType(const HLADataType* elementDataType);
+    const HLADataType* getElementDataType() const
+    { return _elementDataType.get(); }
+
+    void setIsOpaque(bool isOpaque);
+    bool getIsOpaque() const
+    { return _isOpaque; }
+
+    void setIsString(bool isString);
+    bool getIsString() const
+    { return _isString; }
+
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
+private:
+    SGSharedPtr<const HLADataType> _elementDataType;
+    bool _isOpaque;
+    bool _isString;
+};
+
+class HLAFixedArrayDataType : public HLAArrayDataType {
+public:
+    HLAFixedArrayDataType(const std::string& name = "HLAFixedArrayDataType");
+    virtual ~HLAFixedArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
+
+    void setNumElements(unsigned numElements)
+    { _numElements = numElements; }
+    unsigned getNumElements() const
+    { return _numElements; }
+
+private:
+    unsigned _numElements;
+};
+
+class HLAVariableArrayDataType : public HLAArrayDataType {
+public:
+    HLAVariableArrayDataType(const std::string& name = "HLAVariableArrayDataType");
+    virtual ~HLAVariableArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
+
+    void setSizeDataType(const HLABasicDataType* sizeDataType);
+    const HLABasicDataType* getSizeDataType() const
+    { return _sizeDataType.get(); }
+
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
+private:
+    SGSharedPtr<const HLABasicDataType> _sizeDataType;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLABasicDataElement.cxx

@@ -0,0 +1,152 @@
+// 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.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "HLABasicDataElement.hxx"
+
+#include "HLADataElementVisitor.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+HLABasicDataElement::HLABasicDataElement(const HLABasicDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLABasicDataElement::~HLABasicDataElement()
+{
+}
+
+void
+HLABasicDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLABasicDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLABasicDataType*
+HLABasicDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLABasicDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLABasicDataType* scalarDataType = dynamic_cast<const HLABasicDataType*>(dataType);
+    if (!scalarDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLABasicDataType: unable to set data type!");
+        return false;
+    }
+    setDataType(scalarDataType);
+    return true;
+}
+
+void
+HLABasicDataElement::setDataType(const HLABasicDataType* dataType)
+{
+    _dataType = dataType;
+}
+
+#define IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(type, ctype)                                       \
+HLAAbstract##type##DataElement::HLAAbstract##type##DataElement(const HLABasicDataType* dataType) :\
+    HLABasicDataElement(dataType)                                                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+HLAAbstract##type##DataElement::~HLAAbstract##type##DataElement()                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+bool                                                                                              \
+HLAAbstract##type##DataElement::encode(HLAEncodeStream& stream) const                             \
+{                                                                                                 \
+    if (!_dataType.valid())                                                                       \
+        return false;                                                                             \
+    HLATemplateEncodeVisitor<ctype> visitor(stream, getValue());                                  \
+    _dataType->accept(visitor);                                                                   \
+    return true;                                                                                  \
+}                                                                                                 \
+                                                                                                  \
+bool                                                                                              \
+HLAAbstract##type##DataElement::decode(HLADecodeStream& stream)                                   \
+{                                                                                                 \
+    if (!_dataType.valid())                                                                       \
+        return false;                                                                             \
+    HLATemplateDecodeVisitor<ctype> visitor(stream);                                              \
+    _dataType->accept(visitor);                                                                   \
+    setValue(visitor.getValue());                                                                 \
+    return true;                                                                                  \
+}                                                                                                 \
+                                                                                                  \
+HLA##type##DataElement::HLA##type##DataElement(const HLABasicDataType* dataType) :                \
+    HLAAbstract##type##DataElement(dataType),                                                     \
+    _value(0)                                                                                     \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+HLA##type##DataElement::HLA##type##DataElement(const HLABasicDataType* dataType,                  \
+                                               const ctype& value) :                              \
+    HLAAbstract##type##DataElement(dataType),                                                     \
+    _value(value)                                                                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+HLA##type##DataElement::~HLA##type##DataElement()                                                 \
+{                                                                                                 \
+}                                                                                                 \
+                                                                                                  \
+ctype                                                                                             \
+HLA##type##DataElement::getValue() const                                                          \
+{                                                                                                 \
+    return _value;                                                                                \
+}                                                                                                 \
+                                                                                                  \
+void                                                                                              \
+HLA##type##DataElement::setValue(ctype value)                                                     \
+{                                                                                                 \
+    _value = value;                                                                               \
+    setDirty(true);                                                                               \
+}
+
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(WChar, wchar_t);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(SChar, signed char);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UChar, unsigned char);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Short, short);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UShort, unsigned short);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Int, int);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(UInt, unsigned int);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Long, long);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(ULong, unsigned long);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Float, float);
+IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Double, double);
+
+#undef IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT
+
+}

simgear/hla/HLABasicDataElement.hxx

@@ -0,0 +1,115 @@
+// 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.
+//
+
+#ifndef HLABasicDataElement_hxx
+#define HLABasicDataElement_hxx
+
+#include "HLABasicDataType.hxx"
+#include "HLADataElement.hxx"
+
+namespace simgear {
+
+class HLABasicDataElement : public HLADataElement {
+public:
+    HLABasicDataElement(const HLABasicDataType* dataType);
+    virtual ~HLABasicDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool encode(HLAEncodeStream& stream) const = 0;
+    virtual bool decode(HLADecodeStream& stream) = 0;
+
+    virtual const HLABasicDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLABasicDataType* dataType);
+
+protected:
+    SGSharedPtr<const HLABasicDataType> _dataType;
+};
+
+#define TYPED_HLA_BASIC_DATA_ELEMENT(type, ctype)                             \
+class HLAAbstract##type##DataElement : public HLABasicDataElement {           \
+public:                                                                       \
+    HLAAbstract##type##DataElement(const HLABasicDataType* dataType = 0);     \
+    virtual ~HLAAbstract##type##DataElement();                                \
+                                                                              \
+    virtual bool encode(HLAEncodeStream& stream) const;                       \
+    virtual bool decode(HLADecodeStream& stream);                             \
+                                                                              \
+    virtual ctype getValue() const = 0;                                       \
+    virtual void setValue(ctype) = 0;                                         \
+};                                                                            \
+class HLA##type##DataElement : public HLAAbstract##type##DataElement {        \
+public:                                                                       \
+    HLA##type##DataElement(const HLABasicDataType* dataType = 0);             \
+    HLA##type##DataElement(const HLABasicDataType* dataType,                  \
+                           const ctype& value);                               \
+    virtual ~HLA##type##DataElement();                                        \
+    virtual ctype getValue() const;                                           \
+    virtual void setValue(ctype value);                                       \
+private:                                                                      \
+    ctype _value;                                                             \
+};                                                                            \
+class HLA##type##Data {                                                       \
+public:                                                                       \
+    HLA##type##Data() :                                                       \
+        _value(new HLA##type##DataElement(0))                                 \
+    { }                                                                       \
+    HLA##type##Data(const ctype& value) :                                     \
+        _value(new HLA##type##DataElement(0, value))                          \
+    { }                                                                       \
+    operator ctype() const                                                    \
+    { return _value->getValue(); }                                            \
+    HLA##type##Data& operator=(const ctype& value)                            \
+    { _value->setValue(value); return *this; }                                \
+    ctype getValue() const                                                    \
+    { return _value->getValue(); }                                            \
+    void setValue(const ctype& value)                                         \
+    { _value->setValue(value); }                                              \
+    const HLA##type##DataElement* getDataElement() const                      \
+    { return _value.get(); }                                                  \
+    HLA##type##DataElement* getDataElement()                                  \
+    { return _value.get(); }                                                  \
+    const HLABasicDataType* getDataType() const                               \
+    { return _value->getDataType(); }                                         \
+    void setDataType(const HLABasicDataType* dataType)                        \
+    { _value->setDataType(dataType); }                                        \
+                                                                              \
+private:                                                                      \
+    SGSharedPtr<HLA##type##DataElement> _value;                               \
+};
+
+
+TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);
+TYPED_HLA_BASIC_DATA_ELEMENT(WChar, wchar_t);
+TYPED_HLA_BASIC_DATA_ELEMENT(SChar, signed char);
+TYPED_HLA_BASIC_DATA_ELEMENT(UChar, unsigned char);
+TYPED_HLA_BASIC_DATA_ELEMENT(Short, short);
+TYPED_HLA_BASIC_DATA_ELEMENT(UShort, unsigned short);
+TYPED_HLA_BASIC_DATA_ELEMENT(Int, int);
+TYPED_HLA_BASIC_DATA_ELEMENT(UInt, unsigned int);
+TYPED_HLA_BASIC_DATA_ELEMENT(Long, long);
+TYPED_HLA_BASIC_DATA_ELEMENT(ULong, unsigned long);
+TYPED_HLA_BASIC_DATA_ELEMENT(Float, float);
+TYPED_HLA_BASIC_DATA_ELEMENT(Double, double);
+
+#undef TYPED_HLA_BASIC_DATA_ELEMENT
+
+}
+
+#endif

simgear/hla/HLABasicDataType.cxx

@@ -0,0 +1,176 @@
+// 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 "HLABasicDataType.hxx"
+
+#include "HLADataType.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+HLABasicDataType::HLABasicDataType(const std::string& name) :
+    HLADataType(name)
+{
+}
+
+HLABasicDataType::~HLABasicDataType()
+{
+}
+
+void
+HLABasicDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLABasicDataType*
+HLABasicDataType::toBasicDataType() const
+{
+    return this;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+HLAInt8DataType::HLAInt8DataType(const std::string& name) :
+    HLABasicDataType(name)
+{
+    setAlignment(sizeof(int8_t));
+}
+
+HLAInt8DataType::~HLAInt8DataType()
+{
+}
+
+void
+HLAInt8DataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+HLAUInt8DataType::HLAUInt8DataType(const std::string& name) :
+    HLABasicDataType(name)
+{
+    setAlignment(sizeof(uint8_t));
+}
+
+HLAUInt8DataType::~HLAUInt8DataType()
+{
+}
+
+void
+HLAUInt8DataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#define BASIC_DATATYPE_IMPLEMENTATION(type, name)                       \
+HLA##name##DataType::HLA##name##DataType(const std::string& name) :     \
+    HLABasicDataType(name)                                              \
+{                                                                       \
+    setAlignment(sizeof(type));                                         \
+}                                                                       \
+                                                                        \
+HLA##name##DataType::~HLA##name##DataType()                             \
+{                                                                       \
+}                                                                       \
+                                                                        \
+void                                                                    \
+HLA##name##DataType::accept(HLADataTypeVisitor& visitor) const          \
+{                                                                       \
+    visitor.apply(*this);                                               \
+}                                                                       \
+                                                                        \
+                                                                        \
+                                                                        \
+HLA##name##LEDataType::HLA##name##LEDataType(const std::string& name) : \
+    HLA##name##DataType(name)                                           \
+{                                                                       \
+}                                                                       \
+                                                                        \
+HLA##name##LEDataType::~HLA##name##LEDataType()                         \
+{                                                                       \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##LEDataType::decode(HLADecodeStream& stream,                  \
+                              type& value) const                        \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.decode##name##LE(value);                              \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##LEDataType::encode(HLAEncodeStream& stream,                  \
+                              const type& value) const                  \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.encode##name##LE(value);                              \
+}                                                                       \
+                                                                        \
+                                                                        \
+                                                                        \
+HLA##name##BEDataType::HLA##name##BEDataType(const std::string& name) : \
+    HLA##name##DataType(name)                                           \
+{                                                                       \
+}                                                                       \
+                                                                        \
+HLA##name##BEDataType::~HLA##name##BEDataType()                         \
+{                                                                       \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##BEDataType::decode(HLADecodeStream& stream,                  \
+                              type& value) const                        \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.decode##name##BE(value);                              \
+}                                                                       \
+                                                                        \
+bool                                                                    \
+HLA##name##BEDataType::encode(HLAEncodeStream& stream,                  \
+                              const type& value) const                  \
+{                                                                       \
+    if (!stream.alignOffsetForSize(getAlignment()))                     \
+        return false;                                                   \
+    return stream.encode##name##BE(value);                              \
+}
+
+BASIC_DATATYPE_IMPLEMENTATION(int16_t, Int16)
+BASIC_DATATYPE_IMPLEMENTATION(uint16_t, UInt16)
+BASIC_DATATYPE_IMPLEMENTATION(int32_t, Int32)
+BASIC_DATATYPE_IMPLEMENTATION(uint32_t, UInt32)
+BASIC_DATATYPE_IMPLEMENTATION(int64_t, Int64)
+BASIC_DATATYPE_IMPLEMENTATION(uint64_t, UInt64)
+BASIC_DATATYPE_IMPLEMENTATION(float, Float32)
+BASIC_DATATYPE_IMPLEMENTATION(double, Float64)
+
+#undef BASIC_DATATYPE_IMPLEMENTATION
+
+} // namespace simgear

simgear/hla/HLABasicDataType.hxx

@@ -0,0 +1,155 @@
+// 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 HLABasicDataType_hxx
+#define HLABasicDataType_hxx
+
+#include <string>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLABasicDataType : public HLADataType {
+public:
+    virtual ~HLABasicDataType();
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLABasicDataType* toBasicDataType() const;
+
+protected:
+    HLABasicDataType(const std::string& name);
+};
+
+class HLAInt8DataType : public HLABasicDataType {
+public:
+    HLAInt8DataType(const std::string& name = "HLAInt8DataType");
+    virtual ~HLAInt8DataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    bool skip(HLADecodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool skip(HLAEncodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool decode(HLADecodeStream& stream, int8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.decodeInt8(value);
+    }
+    bool encode(HLAEncodeStream& stream, const int8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.encodeInt8(value);
+    }
+};
+
+class HLAUInt8DataType : public HLABasicDataType {
+public:
+    HLAUInt8DataType(const std::string& name = "HLAUInt8DataType");
+    virtual ~HLAUInt8DataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    bool skip(HLADecodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool skip(HLAEncodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool decode(HLADecodeStream& stream, uint8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.decodeUInt8(value);
+    }
+    bool encode(HLAEncodeStream& stream, const uint8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.encodeUInt8(value);
+    }
+};
+
+#define BASIC_DATATYPE_IMPLEMENTATION(type, name)                          \
+class HLA##name##DataType : public HLABasicDataType {                      \
+public:                                                                    \
+ virtual ~HLA##name##DataType();                                           \
+                                                                           \
+ virtual void accept(HLADataTypeVisitor& visitor) const;                   \
+                                                                           \
+ bool skip(HLADecodeStream& stream) const                                  \
+ {                                                                         \
+   if (!stream.alignOffsetForSize(getAlignment()))                         \
+     return false;                                                         \
+   return stream.skip(sizeof(type));                                       \
+ }                                                                         \
+ bool skip(HLAEncodeStream& stream) const                                  \
+ {                                                                         \
+   if (!stream.alignOffsetForSize(getAlignment()))                         \
+     return false;                                                         \
+   return stream.skip(sizeof(type));                                       \
+ }                                                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const = 0;      \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const = 0;\
+protected:                                                                 \
+ HLA##name##DataType(const std::string& name);                             \
+};                                                                         \
+class HLA##name##LEDataType : public HLA##name##DataType {                 \
+public:                                                                    \
+ HLA##name##LEDataType(const std::string& name = "HLA" #name "LEDataType");\
+ virtual ~HLA##name##LEDataType();                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const;          \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const;    \
+};                                                                         \
+class HLA##name##BEDataType : public HLA##name##DataType {                 \
+public:                                                                    \
+ HLA##name##BEDataType(const std::string& name = "HLA" #name "BEDataType");\
+ virtual ~HLA##name##BEDataType();                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const;          \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const;    \
+};
+
+BASIC_DATATYPE_IMPLEMENTATION(int16_t, Int16)
+BASIC_DATATYPE_IMPLEMENTATION(uint16_t, UInt16)
+BASIC_DATATYPE_IMPLEMENTATION(int32_t, Int32)
+BASIC_DATATYPE_IMPLEMENTATION(uint32_t, UInt32)
+BASIC_DATATYPE_IMPLEMENTATION(int64_t, Int64)
+BASIC_DATATYPE_IMPLEMENTATION(uint64_t, UInt64)
+BASIC_DATATYPE_IMPLEMENTATION(float, Float32)
+BASIC_DATATYPE_IMPLEMENTATION(double, Float64)
+
+#undef BASIC_DATATYPE_IMPLEMENTATION
+
+} // namespace simgear
+
+#endif

simgear/hla/HLADataElement.cxx

@@ -0,0 +1,258 @@
+// 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.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#include "HLADataElement.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+
+namespace simgear {
+
+HLADataElement::PathElement::Data::~Data()
+{
+}
+
+const HLADataElement::PathElement::FieldData*
+HLADataElement::PathElement::Data::toFieldData() const
+{
+    return 0;
+}
+
+const HLADataElement::PathElement::IndexData*
+HLADataElement::PathElement::Data::toIndexData() const
+{
+    return 0;
+}
+
+HLADataElement::PathElement::FieldData::FieldData(const std::string& name) :
+    _name(name)
+{
+}
+
+HLADataElement::PathElement::FieldData::~FieldData()
+{
+}
+
+const HLADataElement::PathElement::FieldData*
+HLADataElement::PathElement::FieldData::toFieldData() const
+{
+    return this;
+}
+
+bool
+HLADataElement::PathElement::FieldData::less(const Data* data) const
+{
+    const FieldData* fieldData = data->toFieldData();
+    // IndexData is allways smaller than FieldData
+    if (!fieldData)
+        return false;
+    return _name < fieldData->_name;
+}
+
+bool
+HLADataElement::PathElement::FieldData::equal(const Data* data) const
+{
+    const FieldData* fieldData = data->toFieldData();
+    // IndexData is allways smaller than FieldData
+    if (!fieldData)
+        return false;
+    return _name == fieldData->_name;
+}
+
+void
+HLADataElement::PathElement::FieldData::append(std::string& s) const
+{
+    s.append(1, std::string::value_type('.'));
+    s.append(_name);
+}
+
+HLADataElement::PathElement::IndexData::IndexData(unsigned index) :
+    _index(index)
+{
+}
+
+HLADataElement::PathElement::IndexData::~IndexData()
+{
+}
+
+const HLADataElement::PathElement::IndexData*
+HLADataElement::PathElement::IndexData::toIndexData() const
+{
+    return this;
+}
+
+bool
+HLADataElement::PathElement::IndexData::less(const Data* data) const
+{
+    const IndexData* indexData = data->toIndexData();
+    // IndexData is allways smaller than FieldData
+    if (!indexData)
+        return true;
+    return _index < indexData->_index;
+}
+
+bool
+HLADataElement::PathElement::IndexData::equal(const Data* data) const
+{
+    const IndexData* indexData = data->toIndexData();
+    // IndexData is allways smaller than FieldData
+    if (!indexData)
+        return false;
+    return _index == indexData->_index;
+}
+
+void
+HLADataElement::PathElement::IndexData::append(std::string& s) const
+{
+    s.append(1, std::string::value_type('['));
+    unsigned value = _index;
+    do {
+        s.append(1, std::string::value_type('0' + value % 10));
+    } while (value /= 10);
+    s.append(1, std::string::value_type(']'));
+}
+
+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)
+{
+    visitor.apply(*this);
+}
+
+void
+HLADataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+std::string
+HLADataElement::toString(const Path& path)
+{
+    std::string s;
+    for (Path::const_iterator i = path.begin(); i != path.end(); ++i)
+        i->append(s);
+    return s;
+}
+
+HLADataElement::StringPathPair
+HLADataElement::toStringPathPair(const std::string& s)
+{
+    Path path;
+    // 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()) {
+        if (s[i] == '[') {
+            ++i;
+            unsigned index = 0;
+            while (i < s.size()) {
+                if (s[i] == ']')
+                    break;
+                unsigned v = s[i] - '0';
+                // Error, no number
+                if (10 <= v) {
+                    SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid character in array subscript for \""
+                           << s << "\" at \"" << attribute << toString(path) << "\"!");
+                    return StringPathPair();
+                }
+                index *= 10;
+                index += v;
+                ++i;
+            }
+            path.push_back(index);
+            ++i;
+            continue;
+        }
+        if (s[i] == '.') {
+            // Error, . cannot be last
+            if (s.size() <= ++i) {
+                SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid terminating '.' for \""
+                       << s << "\"!");
+                return StringPathPair();
+            }
+            std::string::size_type e = s.find_first_of("[.", i);
+            path.push_back(s.substr(i, e - i));
+            i = e;
+            continue;
+        }
+    }
+
+    return StringPathPair(attribute, path);
+}
+
+void
+HLADataElement::_setStamp(HLADataElement::Stamp* stamp)
+{
+    _stamp = stamp;
+}
+
+}

simgear/hla/HLADataElement.hxx

@@ -0,0 +1,256 @@
+// Copyright (C) 2009 - 2011  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 HLADataElement_hxx
+#define HLADataElement_hxx
+
+#include <list>
+#include <map>
+#include <simgear/structure/SGReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/timing/timestamp.hxx>
+#include "RTIData.hxx"
+#include "HLADataType.hxx"
+
+class SGTimeStamp;
+
+namespace simgear {
+
+class HLADataElementVisitor;
+class HLAConstDataElementVisitor;
+
+class HLADataElement : public SGReferenced {
+public:
+    virtual ~HLADataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor) = 0;
+    virtual void accept(HLAConstDataElementVisitor& visitor) const = 0;
+
+    virtual bool encode(HLAEncodeStream& stream) const = 0;
+    virtual bool decode(HLADecodeStream& stream) = 0;
+
+    virtual const HLADataType* getDataType() const = 0;
+    virtual bool setDataType(const HLADataType* dataType) = 0;
+
+    /// 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);
+
+    bool getTimeStampValid() const
+    { if (!_stamp.valid()) return false; return _stamp->getTimeStampValid(); }
+    void setTimeStampValid(bool timeStampValid);
+
+    /// 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
+    /// order they appear while walking to the data element.
+    /// So provide here some tool functions to access these elements
+    /// Note that these functions are relatively expensive in execution time.
+    /// So only use them once at object creation time and store direct references to the values
+
+    class PathElement {
+    public:
+        PathElement(unsigned index) : _data(new IndexData(index)) {}
+        PathElement(const std::string& name) : _data(new FieldData(name)) {}
+
+        bool isFieldValue() const
+        { return _data->toFieldData(); }
+        bool isIndexValue() const
+        { return _data->toIndexData(); }
+
+        unsigned getIndexValue() const
+        {
+            const IndexData* indexData = _data->toIndexData();
+            if (!indexData)
+                return ~unsigned(0);
+            return indexData->_index;
+        }
+
+        std::string getFieldValue() const
+        {
+            const FieldData* fieldData = _data->toFieldData();
+            if (!fieldData)
+                return std::string();
+            return fieldData->_name;
+        }
+
+        // Want to be able to use that in std::map and std::set
+        bool operator<(const PathElement& pathElement) const
+        { return _data->less(pathElement._data.get()); }
+        bool operator==(const PathElement& pathElement) const
+        { return _data->equal(pathElement._data.get()); }
+
+        void append(std::string& s) const
+        { _data->append(s); }
+
+    private:
+        struct FieldData;
+        struct IndexData;
+        struct Data : public SGReferenced {
+            virtual ~Data();
+            virtual const FieldData* toFieldData() const;
+            virtual const IndexData* toIndexData() const;
+            virtual bool less(const Data*) const = 0;
+            virtual bool equal(const Data*) const = 0;
+            virtual void append(std::string&) const = 0;
+        };
+        struct FieldData : public Data {
+            FieldData(const std::string& name);
+            virtual ~FieldData();
+            virtual const FieldData* toFieldData() const;
+            virtual bool less(const Data* data) const;
+            virtual bool equal(const Data* data) const;
+            virtual void append(std::string& s) const;
+            std::string _name;
+        };
+        struct IndexData : public Data {
+            IndexData(unsigned index);
+            virtual ~IndexData();
+            virtual const IndexData* toIndexData() const;
+            virtual bool less(const Data* data) const;
+            virtual bool equal(const Data* data) const;
+            virtual void append(std::string& s) const;
+            unsigned _index;
+        };
+
+        SGSharedPtr<Data> _data;
+    };
+    typedef std::list<PathElement> Path;
+    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 StringPathPair& path)
+    { return path.first + toString(path.second); }
+    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 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<Stamp> _stamp;
+};
+
+class HLADataElementProvider {
+public:
+    class AbstractProvider : public SGReferenced {
+    public:
+        virtual ~AbstractProvider() { }
+        virtual HLADataElement* getDataElement(const HLADataElement::Path& path) = 0;
+        // virtual HLADataElement* getDataElement(const HLADataElement::Path& path, const HLADataType* dataType)
+        // {
+        //     SGSharedPtr<HLADataElement> dataElement = getDataElement(path);
+        //     if (!dataElement.valid())
+        //         return 0;
+        //     if (!dataElement->setDataType(dataType))
+        //         return 0;
+        //     return dataElement.release();
+        // }
+    };
+
+    HLADataElementProvider()
+    { }
+    HLADataElementProvider(HLADataElement* dataElement) :
+        _provider(new ConcreteProvider(dataElement))
+    { }
+    HLADataElementProvider(const SGSharedPtr<HLADataElement>& dataElement) :
+        _provider(new ConcreteProvider(dataElement))
+    { }
+    HLADataElementProvider(AbstractProvider* provider) :
+        _provider(provider)
+    { }
+
+    HLADataElement* getDataElement(const HLADataElement::Path& path) const
+    {
+        if (!_provider.valid())
+            return 0;
+        return _provider->getDataElement(path);
+    }
+
+private:
+    class ConcreteProvider : public AbstractProvider {
+    public:
+        ConcreteProvider(const SGSharedPtr<HLADataElement>& dataElement) :
+            _dataElement(dataElement)
+        { }
+        virtual HLADataElement* getDataElement(const HLADataElement::Path&)
+        { return _dataElement.get(); }
+    private:
+        SGSharedPtr<HLADataElement> _dataElement;
+    };
+
+    SGSharedPtr<AbstractProvider> _provider;
+};
+
+typedef std::map<HLADataElement::Path, HLADataElementProvider> HLAPathElementMap;
+typedef std::map<unsigned, HLAPathElementMap> HLAAttributePathElementMap;
+
+}
+
+#endif

simgear/hla/HLADataElementVisitor.hxx

@@ -0,0 +1,57 @@
+// 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 HLADataElementVisitor_hxx
+#define HLADataElementVisitor_hxx
+
+namespace simgear {
+
+class HLABasicDataElement;
+class HLAAbstractEnumeratedDataElement;
+class HLAAbstractFixedRecordDataElement;
+class HLAAbstractArrayDataElement;
+class HLAAbstractVariantRecordDataElement;
+
+class HLADataElementVisitor {
+public:
+    virtual ~HLADataElementVisitor() {}
+
+    virtual void apply(HLADataElement&);
+
+    virtual void apply(HLABasicDataElement&);
+    virtual void apply(HLAAbstractEnumeratedDataElement&);
+    virtual void apply(HLAAbstractArrayDataElement&);
+    virtual void apply(HLAAbstractFixedRecordDataElement&);
+    virtual void apply(HLAAbstractVariantRecordDataElement&);
+};
+
+class HLAConstDataElementVisitor {
+public:
+    virtual ~HLAConstDataElementVisitor() {}
+
+    virtual void apply(const HLADataElement&);
+
+    virtual void apply(const HLABasicDataElement&);
+    virtual void apply(const HLAAbstractEnumeratedDataElement&);
+    virtual void apply(const HLAAbstractArrayDataElement&);
+    virtual void apply(const HLAAbstractFixedRecordDataElement&);
+    virtual void apply(const HLAAbstractVariantRecordDataElement&);
+};
+
+}
+
+#endif

simgear/hla/HLADataType.cxx

@@ -0,0 +1,106 @@
+// 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 "HLADataType.hxx"
+
+#include "HLADataElement.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+HLADataType::HLADataType(const std::string& name, unsigned alignment) :
+    _name(name),
+    _alignment(1)
+{
+    setAlignment(alignment);
+}
+
+HLADataType::~HLADataType()
+{
+}
+
+void
+HLADataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLABasicDataType*
+HLADataType::toBasicDataType() const
+{
+    return 0;
+}
+
+const HLAArrayDataType*
+HLADataType::toArrayDataType() const
+{
+    return 0;
+}
+
+const HLAEnumeratedDataType*
+HLADataType::toEnumeratedDataType() const
+{
+    return 0;
+}
+
+const HLAFixedRecordDataType*
+HLADataType::toFixedRecordDataType() const
+{
+    return 0;
+}
+
+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)
+{
+    /// FIXME: more checks
+    if (alignment == 0)
+        _alignment = 1;
+    else
+        _alignment = alignment;
+}
+
+void
+HLADataType::_recomputeAlignmentImplementation()
+{
+}
+
+}

simgear/hla/HLADataType.hxx

@@ -0,0 +1,82 @@
+// 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 HLADataType_hxx
+#define HLADataType_hxx
+
+#include <string>
+#include <simgear/structure/SGWeakPtr.hxx>
+#include <simgear/structure/SGWeakReferenced.hxx>
+#include "RTIData.hxx"
+
+namespace simgear {
+
+class HLADataTypeVisitor;
+
+class HLABasicDataType;
+class HLAArrayDataType;
+class HLAEnumeratedDataType;
+class HLAFixedRecordDataType;
+class HLAVariantRecordDataType;
+
+class HLADataType : public SGWeakReferenced {
+public:
+    virtual ~HLADataType();
+
+    const std::string& getName() const
+    { return _name; }
+
+    const std::string& getSemantics() const
+    { return _semantics; }
+    void setSemantics(const std::string& semantics)
+    { _semantics = semantics; }
+
+    unsigned getAlignment() const
+    { return _alignment; }
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLABasicDataType* toBasicDataType() const;
+    virtual const HLAArrayDataType* toArrayDataType() const;
+    virtual const HLAEnumeratedDataType* toEnumeratedDataType() const;
+    virtual const HLAFixedRecordDataType* toFixedRecordDataType() 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;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLADataTypeVisitor.cxx

@@ -0,0 +1,194 @@
+// 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 "HLADataTypeVisitor.hxx"
+
+#include "HLAArrayDataElement.hxx"
+#include "HLABasicDataElement.hxx"
+#include "HLADataTypeVisitor.hxx"
+#include "HLAEnumeratedDataElement.hxx"
+#include "HLAFixedRecordDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
+
+namespace simgear {
+
+HLADataElementFactoryVisitor::~HLADataElementFactoryVisitor()
+{
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLADataType& dataType)
+{
+    SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Can not find a suitable data element for data type \""
+           << dataType.getName() << "\"");
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt8DataType& dataType)
+{
+    _dataElement = new HLASCharDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt8DataType& dataType)
+{
+    _dataElement = new HLAUCharDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt16DataType& dataType)
+{
+    _dataElement = new HLAShortDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt16DataType& dataType)
+{
+    _dataElement = new HLAUShortDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt32DataType& dataType)
+{
+    _dataElement = new HLAIntDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt32DataType& dataType)
+{
+    _dataElement = new HLAUIntDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAInt64DataType& dataType)
+{
+    _dataElement = new HLALongDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAUInt64DataType& dataType)
+{
+    _dataElement = new HLAULongDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFloat32DataType& dataType)
+{
+    _dataElement = new HLAFloatDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFloat64DataType& dataType)
+{
+    _dataElement = new HLADoubleDataElement(&dataType);
+}
+
+class HLADataElementFactoryVisitor::ArrayDataElementFactory : public HLAArrayDataElement::DataElementFactory {
+public:
+    virtual HLADataElement* createElement(const HLAArrayDataElement& element, unsigned index)
+    {
+        const HLADataType* dataType = element.getElementDataType();
+        if (!dataType)
+            return 0;
+        
+        HLADataElementFactoryVisitor visitor;
+        dataType->accept(visitor);
+        return visitor.getDataElement();
+    }
+};
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFixedArrayDataType& dataType)
+{
+    if (dataType.getIsString()) {
+        _dataElement = new HLAStringDataElement(&dataType);
+    } else {
+        SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+        arrayDataElement = new HLAArrayDataElement(&dataType);
+        arrayDataElement->setDataElementFactory(new ArrayDataElementFactory);
+        arrayDataElement->setNumElements(dataType.getNumElements());
+        _dataElement = arrayDataElement;
+    }
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    if (dataType.getIsString()) {
+        _dataElement = new HLAStringDataElement(&dataType);
+    } else {
+        SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+        arrayDataElement = new HLAArrayDataElement(&dataType);
+        arrayDataElement->setDataElementFactory(new ArrayDataElementFactory);
+        _dataElement = arrayDataElement;
+    }
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAEnumeratedDataType& dataType)
+{
+    _dataElement = new HLAEnumeratedDataElement(&dataType);
+}
+
+void
+HLADataElementFactoryVisitor::apply(const HLAFixedRecordDataType& dataType)
+{
+    SGSharedPtr<HLAFixedRecordDataElement> recordDataElement;
+    recordDataElement = new HLAFixedRecordDataElement(&dataType);
+
+    unsigned numFields = dataType.getNumFields();
+    for (unsigned i = 0; i < numFields; ++i) {
+        HLADataElementFactoryVisitor visitor;
+        dataType.getFieldDataType(i)->accept(visitor);
+        recordDataElement->setField(i, visitor._dataElement.get());
+    }
+
+    _dataElement = recordDataElement;
+}
+
+class HLADataElementFactoryVisitor::VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
+public:
+    virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
+    {
+        const HLAVariantRecordDataType* dataType = element.getDataType();
+        if (!dataType)
+            return 0;
+        const HLADataType* alternativeDataType = element.getAlternativeDataType();
+        if (!alternativeDataType)
+            return 0;
+        HLADataElementFactoryVisitor visitor;
+        alternativeDataType->accept(visitor);
+        return visitor.getDataElement();
+    }
+};
+
+void
+HLADataElementFactoryVisitor::apply(const HLAVariantRecordDataType& dataType)
+{
+    SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
+    variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
+    variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory);
+    _dataElement = variantRecordDataElement;
+}
+
+} // namespace simgear

simgear/hla/HLADataTypeVisitor.hxx

@@ -0,0 +1,661 @@
+// 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 HLADataTypeVisitor_hxx
+#define HLADataTypeVisitor_hxx
+
+#include <cassert>
+#include <string>
+#include <simgear/debug/logstream.hxx>
+#include <simgear/math/SGMath.hxx>
+#include "HLAArrayDataType.hxx"
+#include "HLABasicDataType.hxx"
+#include "HLADataElement.hxx"
+#include "HLAEnumeratedDataType.hxx"
+#include "HLAFixedRecordDataType.hxx"
+#include "HLAVariantRecordDataType.hxx"
+
+namespace simgear {
+
+class HLADataTypeVisitor {
+public:
+    virtual ~HLADataTypeVisitor() {}
+
+    virtual void apply(const HLADataType& dataType)
+    { }
+
+    virtual void apply(const HLABasicDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+    virtual void apply(const HLAInt8DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt16DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+
+    virtual void apply(const HLAArrayDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    { apply(static_cast<const HLAArrayDataType&>(dataType)); }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    { apply(static_cast<const HLAArrayDataType&>(dataType)); }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+};
+
+/// Walks the datatype tree and checks if it is completely defined
+class HLADataTypeCheckVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeCheckVisitor() : _valid(true) {}
+
+    bool valid() const { return _valid; }
+
+    virtual void apply(const HLAInt8DataType& dataType) { }
+    virtual void apply(const HLAUInt8DataType& dataType) { }
+    virtual void apply(const HLAInt16DataType& dataType) { }
+    virtual void apply(const HLAUInt16DataType& dataType) { }
+    virtual void apply(const HLAInt32DataType& dataType) { }
+    virtual void apply(const HLAUInt32DataType& dataType) { }
+    virtual void apply(const HLAInt64DataType& dataType) { }
+    virtual void apply(const HLAUInt64DataType& dataType) { }
+    virtual void apply(const HLAFloat32DataType& dataType) { }
+    virtual void apply(const HLAFloat64DataType& dataType) { }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        if (!dataType.getElementDataType())
+            _valid = false;
+        else
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        if (!dataType.getElementDataType())
+            _valid = false;
+        else
+            dataType.getElementDataType()->accept(*this);
+
+        if (!dataType.getSizeDataType())
+            _valid = false;
+        else
+            dataType.getSizeDataType()->accept(*this);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        if (!dataType.getRepresentation())
+            _valid = false;
+        else
+            dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i) {
+            if (!dataType.getFieldDataType(i))
+                _valid = false;
+            else
+                dataType.getFieldDataType(i)->accept(*this);
+        }
+    }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    { assert(0); }
+
+protected:
+    bool _valid;
+};
+
+class HLADataTypeDecodeVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeDecodeVisitor(HLADecodeStream& stream) : _stream(stream) {}
+    virtual ~HLADataTypeDecodeVisitor() {}
+
+    virtual void apply(const HLAInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat64DataType& dataType) { dataType.skip(_stream); }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        unsigned numElements = dataType.getNumElements();
+        for (unsigned i = 0; i < numElements; ++i)
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i)
+            dataType.getFieldDataType(i)->accept(*this);
+    }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType) { assert(0); }
+
+protected:
+    HLADecodeStream& _stream;
+};
+
+class HLADataTypeEncodeVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeEncodeVisitor(HLAEncodeStream& stream) : _stream(stream) {}
+    virtual ~HLADataTypeEncodeVisitor() {}
+
+    virtual void apply(const HLAInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat64DataType& dataType) { dataType.skip(_stream); }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        /// FIXME, might vanish in this sense ...
+        // dataType.encode(_stream, *this);
+        unsigned numElements = dataType.getNumElements();
+        for (unsigned i = 0; i < numElements; ++i)
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i)
+            dataType.getFieldDataType(i)->accept(*this);
+    }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType) { assert(0); }
+
+protected:
+    HLAEncodeStream& _stream;
+};
+
+/// Begin implementation of some get/set visitors
+
+class HLAScalarDecodeVisitor : public HLADataTypeDecodeVisitor {
+public:
+    HLAScalarDecodeVisitor(HLADecodeStream& stream) :
+        HLADataTypeDecodeVisitor(stream)
+    {}
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+};
+
+class HLAScalarEncodeVisitor : public HLADataTypeEncodeVisitor {
+public:
+    HLAScalarEncodeVisitor(HLAEncodeStream& stream) :
+        HLADataTypeEncodeVisitor(stream)
+    {}
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+};
+
+class HLAFixedRecordDecodeVisitor : public HLADataTypeDecodeVisitor {
+public:
+    HLAFixedRecordDecodeVisitor(HLADecodeStream& stream) :
+        HLADataTypeDecodeVisitor(stream)
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+};
+
+class HLAFixedRecordEncodeVisitor : public HLADataTypeEncodeVisitor {
+public:
+    HLAFixedRecordEncodeVisitor(HLAEncodeStream& stream) :
+        HLADataTypeEncodeVisitor(stream)
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+};
+
+template<typename T>
+class HLATemplateDecodeVisitor : public HLAScalarDecodeVisitor {
+public:
+    typedef T value_type;
+
+    HLATemplateDecodeVisitor(HLADecodeStream& stream, const value_type& value = value_type()) :
+        HLAScalarDecodeVisitor(stream),
+        _value(value)
+    {}
+
+    void setValue(const value_type& value)
+    { _value = value; }
+    const value_type& getValue() const
+    { return _value; }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        int8_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        uint8_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        int16_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        uint16_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        int32_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        uint32_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        int64_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        uint64_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        float value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        double value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+
+private:
+    value_type _value;
+};
+
+template<typename T>
+class HLATemplateEncodeVisitor : public HLAScalarEncodeVisitor {
+public:
+    typedef T value_type;
+
+    HLATemplateEncodeVisitor(HLAEncodeStream& stream, const value_type& value = value_type()) :
+        HLAScalarEncodeVisitor(stream),
+        _value(value)
+    {}
+
+    void setValue(const value_type& value)
+    { _value = value; }
+    const value_type& getValue() const
+    { return _value; }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+
+private:
+    value_type _value;
+};
+
+inline void HLADataTypeDecodeVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    HLATemplateDecodeVisitor<unsigned> numElementsVisitor(_stream);
+    dataType.getSizeDataType()->accept(numElementsVisitor);
+    unsigned numElements = numElementsVisitor.getValue();
+    for (unsigned i = 0; i < numElements; ++i)
+        dataType.getElementDataType()->accept(*this);
+}
+
+inline void HLADataTypeEncodeVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    HLATemplateEncodeVisitor<unsigned> numElementsVisitor(_stream, 0);
+    dataType.getSizeDataType()->accept(numElementsVisitor);
+}
+
+/// Generate standard data elements according to the traversed type
+class HLADataElementFactoryVisitor : public HLADataTypeVisitor {
+public:
+    virtual ~HLADataElementFactoryVisitor();
+
+    virtual void apply(const HLADataType& dataType);
+
+    virtual void apply(const HLAInt8DataType& dataType);
+    virtual void apply(const HLAUInt8DataType& dataType);
+    virtual void apply(const HLAInt16DataType& dataType);
+    virtual void apply(const HLAUInt16DataType& dataType);
+    virtual void apply(const HLAInt32DataType& dataType);
+    virtual void apply(const HLAUInt32DataType& dataType);
+    virtual void apply(const HLAInt64DataType& dataType);
+    virtual void apply(const HLAUInt64DataType& dataType);
+    virtual void apply(const HLAFloat32DataType& dataType);
+    virtual void apply(const HLAFloat64DataType& dataType);
+
+    virtual void apply(const HLAFixedArrayDataType& dataType);
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType);
+
+    virtual void apply(const HLAFixedRecordDataType& dataType);
+
+    virtual void apply(const HLAVariantRecordDataType& dataType);
+
+    HLADataElement* getDataElement()
+    { return _dataElement.release(); }
+
+protected:
+    class ArrayDataElementFactory;
+    class VariantRecordDataElementFactory;
+
+    SGSharedPtr<HLADataElement> _dataElement;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAEnumeratedDataElement.cxx

@@ -0,0 +1,148 @@
+// 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 "HLAEnumeratedDataElement.hxx"
+
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+
+namespace simgear {
+
+HLAAbstractEnumeratedDataElement::HLAAbstractEnumeratedDataElement(const HLAEnumeratedDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLAAbstractEnumeratedDataElement::~HLAAbstractEnumeratedDataElement()
+{
+}
+
+void
+HLAAbstractEnumeratedDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLAAbstractEnumeratedDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAAbstractEnumeratedDataElement::decode(HLADecodeStream& stream)
+{
+    if (!_dataType.valid())
+        return false;
+    unsigned index;
+    if (!_dataType->decode(stream, index))
+        return false;
+    setEnumeratorIndex(index);
+    return true;
+}
+
+bool
+HLAAbstractEnumeratedDataElement::encode(HLAEncodeStream& stream) const
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->encode(stream, getEnumeratorIndex());
+}
+
+const HLAEnumeratedDataType*
+HLAAbstractEnumeratedDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLAAbstractEnumeratedDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAEnumeratedDataType* enumeratedDataType = dataType->toEnumeratedDataType();
+    if (!enumeratedDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAEnumeratedDataType: unable to set data type!");
+        return false;
+    }
+    setDataType(enumeratedDataType);
+    return true;
+}
+
+void
+HLAAbstractEnumeratedDataElement::setDataType(const HLAEnumeratedDataType* dataType)
+{
+    _dataType = dataType;
+}
+
+const HLABasicDataType*
+HLAAbstractEnumeratedDataElement::getRepresentationDataType() const
+{
+    if (!_dataType.valid())
+        return 0;
+    return _dataType->getRepresentation();
+}
+
+std::string
+HLAAbstractEnumeratedDataElement::getStringRepresentation() const
+{
+    if (!_dataType.valid())
+        return std::string();
+    return _dataType->getString(getEnumeratorIndex());
+}
+
+bool
+HLAAbstractEnumeratedDataElement::setStringRepresentation(const std::string& name)
+{
+    if (!_dataType.valid())
+        return false;
+    unsigned index = _dataType->getIndex(name);
+    if (_dataType->getNumEnumerators() <= index)
+        return false;
+    setEnumeratorIndex(index);
+    return true;
+}
+
+
+HLAEnumeratedDataElement::HLAEnumeratedDataElement(const HLAEnumeratedDataType* dataType) :
+    HLAAbstractEnumeratedDataElement(dataType),
+    _enumeratorIndex(~unsigned(0))
+{
+}
+
+HLAEnumeratedDataElement::~HLAEnumeratedDataElement()
+{
+}
+
+unsigned
+HLAEnumeratedDataElement::getEnumeratorIndex() const
+{
+    return _enumeratorIndex;
+}
+
+void
+HLAEnumeratedDataElement::setEnumeratorIndex(unsigned index)
+{
+    _enumeratorIndex = index;
+}
+
+}

simgear/hla/HLAEnumeratedDataElement.hxx

@@ -0,0 +1,67 @@
+// 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.
+//
+
+#ifndef HLAEnumeratedDataElement_hxx
+#define HLAEnumeratedDataElement_hxx
+
+#include "HLADataElement.hxx"
+#include "HLAEnumeratedDataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractEnumeratedDataElement : public HLADataElement {
+public:
+    HLAAbstractEnumeratedDataElement(const HLAEnumeratedDataType* dataType);
+    virtual ~HLAAbstractEnumeratedDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAEnumeratedDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLAEnumeratedDataType* dataType);
+
+    const HLABasicDataType* getRepresentationDataType() const;
+
+    std::string getStringRepresentation() const;
+    bool setStringRepresentation(const std::string& name);
+
+    virtual unsigned getEnumeratorIndex() const = 0;
+    virtual void setEnumeratorIndex(unsigned index) = 0;
+
+private:
+    SGSharedPtr<const HLAEnumeratedDataType> _dataType;
+};
+
+class HLAEnumeratedDataElement : public HLAAbstractEnumeratedDataElement {
+public:
+    HLAEnumeratedDataElement(const HLAEnumeratedDataType* dataType);
+    virtual ~HLAEnumeratedDataElement();
+
+    virtual unsigned getEnumeratorIndex() const;
+    virtual void setEnumeratorIndex(unsigned index);
+
+private:
+    unsigned _enumeratorIndex;
+};
+
+}
+
+#endif

simgear/hla/HLAEnumeratedDataType.cxx

@@ -0,0 +1,195 @@
+// 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 "HLAEnumeratedDataType.hxx"
+
+#include <map>
+#include <sstream>
+#include <vector>
+#include "HLAEnumeratedDataType.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+template<typename DataType, typename T>
+class HLAEnumeratedDataType::Map : public HLAEnumeratedDataType::AbstractMap {
+public:
+    typedef typename std::pair<std::string,T> RepresentationPair;
+    typedef typename std::map<T, unsigned> RepresentationIndexMap;
+    typedef typename std::vector<RepresentationPair> IndexRepresentationMap;
+    typedef typename std::map<std::string, unsigned> StringIndexMap;
+
+    Map(const DataType* dataType) :
+        _dataType(dataType)
+    { }
+    virtual bool encode(HLAEncodeStream& stream, unsigned index) const
+    {
+        T value = _otherRepresentation;
+        if (index < _indexRepresentationMap.size())
+            value = _indexRepresentationMap[index].second;
+        if (!_dataType->encode(stream, value))
+            return false;
+        return true;
+    }
+    virtual bool decode(HLADecodeStream& stream, unsigned& index) const
+    {
+        T value;
+        if (!_dataType->decode(stream, value))
+            return false;
+        typename RepresentationIndexMap::const_iterator i;
+        i = _representationIndexMap.find(value);
+        if (i == _representationIndexMap.end())
+            index = _indexRepresentationMap.size();
+        else
+            index = i->second;
+        return true;
+    }
+    virtual const HLABasicDataType* getDataType() const
+    { return _dataType.get(); }
+
+    virtual bool add(const std::string& name, const std::string& number)
+    {
+        std::stringstream ss(number);
+        T value;
+        ss >> value;
+        if (ss.fail())
+            return false;
+        if (_representationIndexMap.find(value) != _representationIndexMap.end())
+            return false;
+        if (_stringIndexMap.find(name) != _stringIndexMap.end())
+            return false;
+        _stringIndexMap[name] = _indexRepresentationMap.size();
+        _representationIndexMap[value] = _indexRepresentationMap.size();
+        _indexRepresentationMap.push_back(RepresentationPair(name, value));
+        return true;
+    }
+    virtual std::string getString(unsigned index) const
+    {
+        if (_indexRepresentationMap.size() <= index)
+            return std::string();
+        return _indexRepresentationMap[index].first;
+    }
+    virtual unsigned getIndex(const std::string& name) const
+    {
+        typename StringIndexMap::const_iterator i = _stringIndexMap.find(name);
+        if (i == _stringIndexMap.end())
+            return ~unsigned(0);
+        return i->second;
+    }
+    virtual unsigned getNumEnumerators() const
+    { return _indexRepresentationMap.size(); }
+
+private:
+    IndexRepresentationMap _indexRepresentationMap;
+    StringIndexMap _stringIndexMap;
+    RepresentationIndexMap _representationIndexMap;
+
+    T _otherRepresentation;
+    SGSharedPtr<const DataType> _dataType;
+};
+
+class HLAEnumeratedDataType::RepresentationVisitor : public HLADataTypeVisitor {
+public:
+    virtual void apply(const HLAInt8DataType& dataType)
+    { _map = new Map<HLAInt8DataType, int8_t>(&dataType); }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    { _map = new Map<HLAUInt8DataType, uint8_t>(&dataType); }
+    virtual void apply(const HLAInt16DataType& dataType)
+    { _map = new Map<HLAInt16DataType, int16_t>(&dataType); }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    { _map = new Map<HLAUInt16DataType, uint16_t>(&dataType); }
+    virtual void apply(const HLAInt32DataType& dataType)
+    { _map = new Map<HLAInt32DataType, int32_t>(&dataType); }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    { _map = new Map<HLAUInt32DataType, uint32_t>(&dataType); }
+    virtual void apply(const HLAInt64DataType& dataType)
+    { _map = new Map<HLAInt64DataType, int64_t>(&dataType); }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    { _map = new Map<HLAUInt64DataType, uint64_t>(&dataType); }
+
+    SGSharedPtr<AbstractMap> _map;
+};
+
+HLAEnumeratedDataType::HLAEnumeratedDataType(const std::string& name) :
+    HLADataType(name)
+{
+}
+
+HLAEnumeratedDataType::~HLAEnumeratedDataType()
+{
+}
+
+void
+HLAEnumeratedDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLAEnumeratedDataType*
+HLAEnumeratedDataType::toEnumeratedDataType() const
+{
+    return this;
+}
+
+bool
+HLAEnumeratedDataType::decode(HLADecodeStream& stream, unsigned& index) const
+{
+    if (!_map.valid())
+        return false;
+
+    if (!_map->decode(stream, index))
+        return false;
+    return true;
+}
+
+bool
+HLAEnumeratedDataType::encode(HLAEncodeStream& stream, unsigned index) const
+{
+    if (!_map.valid())
+        return false;
+
+    return _map->encode(stream, index);
+}
+
+void
+HLAEnumeratedDataType::setRepresentation(HLABasicDataType* representation)
+{
+    if (!representation)
+        return;
+
+    RepresentationVisitor representationVisitor;
+    representation->accept(representationVisitor);
+    _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

@@ -0,0 +1,98 @@
+// 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 HLAEnumeratedDataType_hxx
+#define HLAEnumeratedDataType_hxx
+
+#include <string>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAEnumeratedDataType : public HLADataType {
+public:
+    HLAEnumeratedDataType(const std::string& name = "HLAEnumeratedDataType");
+    virtual ~HLAEnumeratedDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLAEnumeratedDataType* toEnumeratedDataType() const;
+
+    virtual bool decode(HLADecodeStream& stream, unsigned& index) const;
+    virtual bool encode(HLAEncodeStream& stream, unsigned index) const;
+
+    std::string getString(unsigned index) const
+    {
+        if (!_map.valid())
+            return std::string();
+        return _map->getString(index);
+    }
+    unsigned getIndex(const std::string& name) const
+    {
+        if (!_map.valid())
+            return ~unsigned(0);
+        return _map->getIndex(name);
+    }
+    unsigned getNumEnumerators() const
+    {
+        if (!_map.valid())
+            return 0;
+        return _map->getNumEnumerators();
+    }
+
+    bool addEnumerator(const std::string& name, const std::string& number)
+    {
+        if (!_map.valid())
+            return false;
+        return _map->add(name, number);
+    }
+
+    void setRepresentation(HLABasicDataType* representation);
+    const HLABasicDataType* getRepresentation() const
+    {
+        if (!_map.valid())
+            return 0;
+        return _map->getDataType();
+    }
+
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
+private:
+    class AbstractMap : public SGReferenced {
+    public:
+        virtual ~AbstractMap() {}
+        virtual bool encode(HLAEncodeStream& stream, unsigned index) const = 0;
+        virtual bool decode(HLADecodeStream& stream, unsigned& index) const = 0;
+        virtual const HLABasicDataType* getDataType() const = 0;
+        virtual bool add(const std::string& name, const std::string& number) = 0;
+        virtual std::string getString(unsigned index) const = 0;
+        virtual unsigned getIndex(const std::string& name) const = 0;
+        virtual unsigned getNumEnumerators() const = 0;
+    };
+
+    template<typename DataType, typename T>
+    class Map;
+    class RepresentationVisitor;
+
+    SGSharedPtr<AbstractMap> _map;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAFederate.hxx

@@ -0,0 +1,320 @@
+// 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 HLAFederate_hxx
+#define HLAFederate_hxx
+
+#include <map>
+
+#include "HLAObjectInstance.hxx"
+#include "HLAObjectClass.hxx"
+#include "HLAInteractionClass.hxx"
+
+class SGTimeStamp;
+
+namespace simgear {
+
+class RTIFederate;
+
+class HLAFederate : public SGWeakReferenced {
+public:
+    HLAFederate();
+    virtual ~HLAFederate();
+
+    enum Version {
+        RTI13,
+        RTI1516,
+        RTI1516E
+    };
+
+    /// 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;
+    bool setConnectArguments(const std::list<std::string>& connectArguments);
+
+    /// If true try to create on join and try to destroy on resign
+    bool getCreateFederationExecution() const;
+    bool setCreateFederationExecution(bool createFederationExecution);
+
+    /// The federation execution name to use on create, join and destroy
+    const std::string& getFederationExecutionName() const;
+    bool setFederationExecutionName(const std::string& federationExecutionName);
+
+    /// The federation object model name to use on create and possibly join
+    const std::string& getFederationObjectModel() const;
+    bool setFederationObjectModel(const std::string& federationObjectModel);
+
+    /// The federate type used on join
+    const std::string& getFederateType() const;
+    bool setFederateType(const std::string& federateType);
+
+    /// The federate name possibly used on join
+    const std::string& getFederateName() const;
+    bool setFederateName(const std::string& federateName);
+
+    /// connect to an rti
+    bool connect(Version version, const std::list<std::string>& stringList);
+    bool connect();
+    bool disconnect();
+
+    /// Create a federation execution
+    /// Semantically this methods should be static,
+    /// but the nonstatic case could reuse the connection to the server
+    bool createFederationExecution(const std::string& federation, const std::string& objectModel);
+    bool destroyFederationExecution(const std::string& federation);
+    bool createFederationExecution();
+    bool destroyFederationExecution();
+
+    /// Join with federateType the federation execution
+    bool join(const std::string& federateType, const std::string& federation);
+    bool join();
+    bool resign();
+    
+    /// Try to create and join the federation execution.
+    bool createJoinFederationExecution();
+    bool resignDestroyFederationExecution();
+
+
+    /// Time management
+
+    /// If set to true, time constrained mode is entered on init
+    bool getTimeConstrained() const;
+    bool setTimeConstrained(bool timeConstrained);
+
+    /// If set to true, time advance is constrained by the local system clock
+    bool getTimeConstrainedByLocalClock() const;
+    bool setTimeConstrainedByLocalClock(bool timeConstrainedByLocalClock);
+
+    /// If set to true, time regulation mode is entered on init
+    bool getTimeRegulating() const;
+    bool setTimeRegulating(bool timeRegulating);
+
+    /// If set to a non zero value, this federate leads the federations
+    /// locical time advance by this amount of time.
+    const SGTimeStamp& getLeadTime() const;
+    bool setLeadTime(const SGTimeStamp& leadTime);
+
+    /// The time increment for use in the default update method.
+    const SGTimeStamp& getTimeIncrement() const;
+    bool setTimeIncrement(const SGTimeStamp& timeIncrement);
+
+    /// Actually enable time constrained mode.
+    /// This method blocks until time constrained mode is enabled.
+    bool enableTimeConstrained();
+    /// Actually disable time constrained mode.
+    bool disableTimeConstrained();
+
+    /// Actually enable time constrained by local clock mode.
+    bool enableTimeConstrainedByLocalClock();
+
+    /// Actually enable time regulation mode.
+    /// This method blocks until time regulation mode is enabled.
+    bool enableTimeRegulation(const SGTimeStamp& lookahead);
+    bool enableTimeRegulation();
+    /// Actually disable time regulation mode.
+    bool disableTimeRegulation();
+    /// Actually modify the lookahead time.
+    bool modifyLookahead(const SGTimeStamp& lookahead);
+
+    /// Advance the logical time by the given time increment.
+    /// Depending on the time constrained mode, this might
+    /// block until the time advance is granted.
+    bool timeAdvanceBy(const SGTimeStamp& timeIncrement);
+    /// Advance the logical time to the given time.
+    /// Depending on the time constrained mode, this might
+    /// block until the time advance is granted.
+    bool timeAdvance(const SGTimeStamp& timeStamp);
+    /// Advance the logical time as far as time advances are available.
+    /// This call should not block and advance the logical time
+    /// as far as currently possible.
+    bool timeAdvanceAvailable();
+
+    /// Get the current federates time
+    bool queryFederateTime(SGTimeStamp& timeStamp);
+    /// Get the current federates lookahead
+    bool queryLookahead(SGTimeStamp& timeStamp);
+
+    /// Process one messsage
+    bool processMessage();
+    /// Process one message but do not wait longer than the relative timeout.
+    bool processMessage(const SGTimeStamp& timeout);
+    /// Process messages until the federate can proceed with the
+    /// next simulation step. That is flush all pending messages and
+    /// depending on the time constrained mode process messages until
+    /// a pending time advance is granted.
+    bool processMessages();
+
+    /// Legacy tick call - deprecated
+    bool tick(const double& minimum, const double& maximum);
+
+    class ObjectModelFactory {
+    public:
+        virtual ~ObjectModelFactory()
+        { }
+
+        virtual HLAObjectClass* createObjectClass(const std::string& name, HLAFederate& 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)
+        { return sharing.find("Publish") != std::string::npos; }
+        virtual bool subscribeAttribute(const std::string& objectClassName, const std::string& attributeName, const std::string& sharing)
+        { return sharing.find("Subscribe") != std::string::npos; }
+        virtual bool publishAttribute(const std::string& objectClassName, const std::string& attributeName, const std::string& sharing)
+        { return sharing.find("Publish") != std::string::npos; }
+
+    };
+
+    /// Read an omt xml file - deprecated
+    bool readObjectModelTemplate(const std::string& objectModel,
+                                 ObjectModelFactory& objectModelFactory);
+
+    /// 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();
+    virtual bool publish();
+
+    virtual bool init();
+    virtual bool update();
+    virtual bool shutdown();
+
+    virtual bool exec();
+
+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;
+
+    /// Parameters required to connect to an rti
+    Version _version;
+    std::list<std::string> _connectArguments;
+
+    /// Parameters for the federation execution
+    std::string _federationExecutionName;
+    std::string _federationObjectModel;
+    bool _createFederationExecution;
+
+    /// Parameters for the federate
+    std::string _federateType;
+    std::string _federateName;
+
+    /// Time management related parameters
+    /// If true, the federate is expected to enter time constrained mode
+    bool _timeConstrained;
+    /// If true, the federate is expected to enter time regulating mode
+    bool _timeRegulating;
+    /// The amount of time this federate leads the others.
+    SGTimeStamp _leadTime;
+    /// The regular time increment we do on calling update()
+    SGTimeStamp _timeIncrement;
+    /// The reference system time at initialization time.
+    /// Is used to implement being time constrained on the
+    /// local system time.
+    bool _timeConstrainedByLocalClock;
+    SGTimeStamp _localClockOffset;
+
+    /// If true the exec method returns.
+    bool _done;
+
+    /// 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
+
+#endif

simgear/hla/HLAFixedRecordDataElement.cxx

@@ -0,0 +1,216 @@
+// 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 "HLAFixedRecordDataElement.hxx"
+
+#include <string>
+#include <vector>
+#include <simgear/debug/logstream.hxx>
+
+#include "HLADataElementVisitor.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+HLAAbstractFixedRecordDataElement::HLAAbstractFixedRecordDataElement(const HLAFixedRecordDataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLAAbstractFixedRecordDataElement::~HLAAbstractFixedRecordDataElement()
+{
+}
+
+void
+HLAAbstractFixedRecordDataElement::accept(HLADataElementVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+HLAAbstractFixedRecordDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+bool
+HLAAbstractFixedRecordDataElement::decode(HLADecodeStream& stream)
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->decode(stream, *this);
+}
+
+bool
+HLAAbstractFixedRecordDataElement::encode(HLAEncodeStream& stream) const
+{
+    if (!_dataType.valid())
+        return false;
+    return _dataType->encode(stream, *this);
+}
+
+const HLAFixedRecordDataType*
+HLAAbstractFixedRecordDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLAAbstractFixedRecordDataElement::setDataType(const HLADataType* dataType)
+{
+    const HLAFixedRecordDataType* fixedRecordDataType = dataType->toFixedRecordDataType();
+    if (!fixedRecordDataType) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAFixedRecordDataType: unable to set data type!");
+        return false;
+    }
+    setDataType(fixedRecordDataType);
+    return true;
+}
+
+void
+HLAAbstractFixedRecordDataElement::setDataType(const HLAFixedRecordDataType* dataType)
+{
+    _dataType = dataType;
+}
+
+unsigned
+HLAAbstractFixedRecordDataElement::getNumFields() const
+{
+    return _dataType->getNumFields();
+}
+
+unsigned
+HLAAbstractFixedRecordDataElement::getFieldNumber(const std::string& name) const
+{
+    return _dataType->getFieldNumber(name);
+}
+
+const HLADataType*
+HLAAbstractFixedRecordDataElement::getFieldDataType(unsigned i) const
+{
+    return _dataType->getFieldDataType(i);
+}
+
+const HLADataType*
+HLAAbstractFixedRecordDataElement::getFieldDataType(const std::string& name) const
+{
+    return getFieldDataType(getFieldNumber(name));
+}
+
+
+HLAFixedRecordDataElement::HLAFixedRecordDataElement(const HLAFixedRecordDataType* dataType) :
+    HLAAbstractFixedRecordDataElement(dataType)
+{
+    _fieldVector.resize(getNumFields());
+}
+
+HLAFixedRecordDataElement::~HLAFixedRecordDataElement()
+{
+    clearStamp();
+}
+
+bool
+HLAFixedRecordDataElement::decodeField(HLADecodeStream& stream, unsigned i)
+{
+    HLADataElement* dataElement = getField(i);
+    if (dataElement) {
+        return dataElement->decode(stream);
+    } else {
+        HLADataTypeDecodeVisitor visitor(stream);
+        getDataType()->getFieldDataType(i)->accept(visitor);
+        return true;
+    }
+}
+
+bool
+HLAFixedRecordDataElement::encodeField(HLAEncodeStream& stream, unsigned i) const
+{
+    const HLADataElement* dataElement = getField(i);
+    if (dataElement) {
+        return dataElement->encode(stream);
+    } else {
+        HLADataTypeEncodeVisitor visitor(stream);
+        getDataType()->getFieldDataType(i)->accept(visitor);
+        return true;
+    }
+}
+
+HLADataElement*
+HLAFixedRecordDataElement::getField(const std::string& name)
+{
+    return getField(getFieldNumber(name));
+}
+
+const HLADataElement*
+HLAFixedRecordDataElement::getField(const std::string& name) const
+{
+    return getField(getFieldNumber(name));
+}
+
+HLADataElement*
+HLAFixedRecordDataElement::getField(unsigned i)
+{
+    if (_fieldVector.size() <= i)
+        return 0;
+    return _fieldVector[i].get();
+}
+
+const HLADataElement*
+HLAFixedRecordDataElement::getField(unsigned i) const
+{
+    if (_fieldVector.size() <= i)
+        return 0;
+    return _fieldVector[i].get();
+}
+
+void
+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
+HLAFixedRecordDataElement::setField(const std::string& name, HLADataElement* value)
+{
+    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

@@ -0,0 +1,83 @@
+// 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.
+//
+
+#ifndef HLAFixedRecordDataElement_hxx
+#define HLAFixedRecordDataElement_hxx
+
+#include <string>
+#include <vector>
+#include "HLADataElement.hxx"
+#include "HLAFixedRecordDataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractFixedRecordDataElement : public HLADataElement {
+public:
+    HLAAbstractFixedRecordDataElement(const HLAFixedRecordDataType* dataType);
+    virtual ~HLAAbstractFixedRecordDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAFixedRecordDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLAFixedRecordDataType* dataType);
+
+    unsigned getNumFields() const;
+    unsigned getFieldNumber(const std::string& name) const;
+
+    const HLADataType* getFieldDataType(unsigned i) const;
+    const HLADataType* getFieldDataType(const std::string& name) const;
+
+    virtual bool decodeField(HLADecodeStream& stream, unsigned i) = 0;
+    virtual bool encodeField(HLAEncodeStream& stream, unsigned i) const = 0;
+
+private:
+    SGSharedPtr<const HLAFixedRecordDataType> _dataType;
+};
+
+class HLAFixedRecordDataElement : public HLAAbstractFixedRecordDataElement {
+public:
+    HLAFixedRecordDataElement(const HLAFixedRecordDataType* dataType);
+    virtual ~HLAFixedRecordDataElement();
+
+    virtual bool decodeField(HLADecodeStream& stream, unsigned i);
+    virtual bool encodeField(HLAEncodeStream& stream, unsigned i) const;
+
+    HLADataElement* getField(const std::string& name);
+    const HLADataElement* getField(const std::string& name) const;
+
+    HLADataElement* getField(unsigned i);
+    const HLADataElement* getField(unsigned i) const;
+
+    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;
+};
+
+}
+
+#endif

simgear/hla/HLAFixedRecordDataType.cxx

@@ -0,0 +1,99 @@
+// 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 "HLAFixedRecordDataType.hxx"
+
+#include "HLADataTypeVisitor.hxx"
+#include "HLAFixedRecordDataElement.hxx"
+
+namespace simgear {
+
+HLAFixedRecordDataType::HLAFixedRecordDataType(const std::string& name) :
+    HLADataType(name)
+{
+}
+
+HLAFixedRecordDataType::~HLAFixedRecordDataType()
+{
+}
+
+void
+HLAFixedRecordDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLAFixedRecordDataType*
+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
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numFields = getNumFields();
+    for (unsigned i = 0; i < numFields; ++i)
+        if (!value.decodeField(stream, i))
+            return false;
+    return true;
+}
+
+bool
+HLAFixedRecordDataType::encode(HLAEncodeStream& stream, const HLAAbstractFixedRecordDataElement& value) const
+{
+    stream.alignOffsetForSize(getAlignment());
+    unsigned numFields = getNumFields();
+    for (unsigned i = 0; i < numFields; ++i)
+        if (!value.encodeField(stream, i))
+            return false;
+    return true;
+}
+
+void
+HLAFixedRecordDataType::addField(const std::string& name, const HLADataType* dataType)
+{
+    _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

@@ -0,0 +1,98 @@
+// 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 HLAFixedRecordDataType_hxx
+#define HLAFixedRecordDataType_hxx
+
+#include <string>
+#include <vector>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractFixedRecordDataElement;
+
+class HLAFixedRecordDataType : public HLADataType {
+public:
+    HLAFixedRecordDataType(const std::string& name = "HLAFixedRecordDataType");
+    virtual ~HLAFixedRecordDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    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;
+
+    unsigned getNumFields() const
+    { return _fieldList.size(); }
+
+    std::string getFieldName(unsigned i) const
+    {
+        if (_fieldList.size() <= i)
+            return std::string();
+        return _fieldList[i].getName();
+    }
+    const HLADataType* getFieldDataType(unsigned i) const
+    {
+        if (_fieldList.size() <= i)
+            return 0;
+        return _fieldList[i].getDataType();
+    }
+
+    unsigned getFieldNumber(const std::string& name) const
+    {
+        for (unsigned i = 0; i < _fieldList.size(); ++i) {
+            if (_fieldList[i].getName() != name)
+                continue;
+            return i;
+        }
+        return ~0u;
+    }
+
+    void addField(const std::string& name, const HLADataType* dataType);
+
+protected:
+    virtual void _recomputeAlignmentImplementation();
+
+private:
+    struct Field {
+        Field(const std::string& name, const HLADataType* dataType) :
+            _name(name), _dataType(dataType) {}
+        const std::string& getName() const
+        { return _name; }
+
+        const HLADataType* getDataType() const
+        { return _dataType.get(); }
+        void releaseDataTypeReferences()
+        { _dataType = 0; }
+
+    private:
+        std::string _name;
+        SGSharedPtr<const HLADataType> _dataType;
+    };
+
+    typedef std::vector<Field> FieldList;
+    FieldList _fieldList;
+};
+
+} // namespace simgear
+
+#endif

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

@@ -0,0 +1,111 @@
+// 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 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:
+    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
+
+#endif

simgear/hla/HLALocation.hxx

@@ -0,0 +1,549 @@
+// 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.
+//
+
+#ifndef HLALocation_hxx
+#define HLALocation_hxx
+
+#include "HLABasicDataElement.hxx"
+
+namespace simgear {
+
+class HLAAbstractLocation : public SGReferenced {
+public:
+    virtual ~HLAAbstractLocation() {}
+
+    virtual SGVec3d getCartPosition() const = 0;
+    virtual void setCartPosition(const SGVec3d&) = 0;
+
+    virtual SGQuatd getCartOrientation() const = 0;
+    virtual void setCartOrientation(const SGQuatd&) = 0;
+
+    virtual SGVec3d getAngularBodyVelocity() const = 0;
+    virtual void setAngularBodyVelocity(const SGVec3d& angular) = 0;
+
+    virtual SGVec3d getLinearBodyVelocity() const = 0;
+    virtual void setLinearBodyVelocity(const SGVec3d& linear) = 0;
+};
+
+class HLACartesianLocation : public HLAAbstractLocation {
+public:
+    HLACartesianLocation() :
+        _position(SGVec3d::zeros()),
+        _imag(SGVec3d::zeros()),
+        _angularVelocity(SGVec3d::zeros()),
+        _linearVelocity(SGVec3d::zeros())
+    { }
+
+    virtual SGVec3d getCartPosition() const
+    { return _position; }
+    virtual void setCartPosition(const SGVec3d& position)
+    { _position = position; }
+
+    virtual SGQuatd getCartOrientation() const
+    { return SGQuatd::fromPositiveRealImag(_imag); }
+    virtual void setCartOrientation(const SGQuatd& orientation)
+    { _imag = orientation.getPositiveRealImag(); }
+
+    virtual SGVec3d getAngularBodyVelocity() const
+    { return _angularVelocity; }
+    virtual void setAngularBodyVelocity(const SGVec3d& angularVelocity)
+    { _angularVelocity = angularVelocity; }
+
+    virtual SGVec3d getLinearBodyVelocity() const
+    { return _linearVelocity; }
+    virtual void setLinearBodyVelocity(const SGVec3d& linearVelocity)
+    { _linearVelocity = linearVelocity; }
+
+    HLADataElementProvider getPositionDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new PositionDataElement(this, i);
+    }
+    HLADataElementProvider getOrientationDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new OrientationDataElement(this, i);
+    }
+
+    HLADataElementProvider getAngularVelocityDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new AngularVelocityDataElement(this, i);
+    }
+    HLADataElementProvider getLinearVelocityDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new LinearVelocityDataElement(this, i);
+    }
+
+private:
+    class PositionDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        PositionDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_position[_index]; }
+        virtual void setValue(double value)
+        { _data->_position[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    class OrientationDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        OrientationDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_imag[_index]; }
+        virtual void setValue(double value)
+        { _data->_imag[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    class AngularVelocityDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        AngularVelocityDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_angularVelocity[_index]; }
+        virtual void setValue(double value)
+        { _data->_angularVelocity[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    class LinearVelocityDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        LinearVelocityDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_linearVelocity[_index]; }
+        virtual void setValue(double value)
+        { _data->_linearVelocity[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    SGVec3d _position;
+    SGVec3d _imag;
+
+    SGVec3d _angularVelocity;
+    SGVec3d _linearVelocity;
+};
+
+class HLALocationFactory : public SGReferenced {
+public:
+    virtual ~HLALocationFactory() {}
+    virtual HLAAbstractLocation* createLocation(HLAAttributePathElementMap&) const = 0;
+};
+
+class HLACartesianLocationFactory : public HLALocationFactory {
+public:
+    virtual HLAAbstractLocation* createLocation(HLAAttributePathElementMap& attributePathElementMap) const
+    {
+        HLACartesianLocation* location = new HLACartesianLocation;
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _positonIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getPositionDataElement(i);
+        }
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _orientationIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getOrientationDataElement(i);
+        }
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _angularVelocityIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getAngularVelocityDataElement(i);
+        }
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _linearVelocityIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getLinearVelocityDataElement(i);
+        }
+        return location;
+    }
+
+    void setPositionIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _positonIndexPathPair[index] = indexPathPair;
+    }
+    void setOrientationIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _orientationIndexPathPair[index] = indexPathPair;
+    }
+
+    void setAngularVelocityIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _angularVelocityIndexPathPair[index] = indexPathPair;
+    }
+    void setLinearVelocityIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _linearVelocityIndexPathPair[index] = indexPathPair;
+    }
+
+private:
+    HLADataElement::IndexPathPair _positonIndexPathPair[3];
+    HLADataElement::IndexPathPair _orientationIndexPathPair[3];
+
+    HLADataElement::IndexPathPair _angularVelocityIndexPathPair[3];
+    HLADataElement::IndexPathPair _linearVelocityIndexPathPair[3];
+};
+
+class HLAGeodeticLocation : public HLAAbstractLocation {
+public:
+    HLAGeodeticLocation() :
+        _dirty(true),
+        _cartPosition(SGVec3d::zeros()),
+        _cartOrientation(SGQuatd::unit()),
+        _cartBodyVelocity(SGVec3d::zeros()),
+        _geodPosition(),
+        _geodEulerRad(SGVec3d::zeros()),
+        _groundTrackRad(0),
+        _groundSpeedMPerSec(0),
+        _verticalSpeedMPerSec(0)
+    {
+        updateCartesianFromGeodetic();
+    }
+
+    virtual SGVec3d getCartPosition() const
+    { updateCartesianFromGeodetic(); return _cartPosition; }
+    virtual void setCartPosition(const SGVec3d& position)
+    { _cartPosition = position; _dirty = true; }
+
+    virtual SGQuatd getCartOrientation() const
+    { updateCartesianFromGeodetic(); return _cartOrientation; }
+    virtual void setCartOrientation(const SGQuatd& orientation)
+    { _cartOrientation = orientation; _dirty = true; }
+
+    virtual SGVec3d getAngularBodyVelocity() const
+    { return SGVec3d::zeros(); }
+    virtual void setAngularBodyVelocity(const SGVec3d& angular)
+    { }
+
+    virtual SGVec3d getLinearBodyVelocity() const
+    { updateCartesianFromGeodetic(); return _cartBodyVelocity; }
+    virtual void setLinearBodyVelocity(const SGVec3d& linear)
+    { _cartBodyVelocity = linear; _dirty = true; }
+
+    void setLatitudeDeg(double value)
+    { _geodPosition.setLatitudeDeg(value); _dirty = true; }
+    double getLatitudeDeg() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLatitudeDeg(); }
+    void setLatitudeRad(double value)
+    { _geodPosition.setLatitudeRad(value); _dirty = true; }
+    double getLatitudeRad() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLatitudeRad(); }
+    void setLongitudeDeg(double value)
+    { _geodPosition.setLongitudeDeg(value); _dirty = true; }
+    double getLongitudeDeg() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLongitudeDeg(); }
+    void setLongitudeRad(double value)
+    { _geodPosition.setLongitudeRad(value); _dirty = true; }
+    double getLongitudeRad() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLongitudeRad(); }
+    void setElevationFt(double value)
+    { _geodPosition.setElevationFt(value); _dirty = true; }
+    double getElevationFt() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getElevationFt(); }
+    void setElevationM(double value)
+    { _geodPosition.setElevationM(value); _dirty = true; }
+    double getElevationM() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getElevationM(); }
+
+    void setHeadingRad(double value)
+    { _geodEulerRad[2] = value; _dirty = true; }
+    double getHeadingRad() const
+    { updateGeodeticFromCartesian(); return _geodEulerRad[2]; }
+    void setHeadingDeg(double value)
+    { setHeadingRad(SGMiscd::deg2rad(value)); }
+    double getHeadingDeg() const
+    { return SGMiscd::rad2deg(getHeadingRad()); }
+    void setPitchRad(double value)
+    { _geodEulerRad[1] = value; _dirty = true; }
+    double getPitchRad() const
+    { updateGeodeticFromCartesian(); return _geodEulerRad[1]; }
+    void setPitchDeg(double value)
+    { setPitchRad(SGMiscd::deg2rad(value)); }
+    double getPitchDeg() const
+    { return SGMiscd::rad2deg(getPitchRad()); }
+    void setRollRad(double value)
+    { _geodEulerRad[0] = value; _dirty = true; }
+    double getRollRad() const
+    { updateGeodeticFromCartesian(); return _geodEulerRad[0]; }
+    void setRollDeg(double value)
+    { setRollRad(SGMiscd::deg2rad(value)); }
+    double getRollDeg() const
+    { return SGMiscd::rad2deg(getRollRad()); }
+
+    void setGroundTrackRad(double value)
+    { _groundTrackRad = value; _dirty = true; }
+    double getGroundTrackRad() const
+    { updateGeodeticFromCartesian(); return _groundTrackRad; }
+    void setGroundTrackDeg(double value)
+    { setGroundTrackRad(SGMiscd::deg2rad(value)); }
+    double getGroundTrackDeg() const
+    { return SGMiscd::rad2deg(getGroundTrackRad()); }
+
+
+    void setGroundSpeedMPerSec(double value)
+    { _groundSpeedMPerSec = value; _dirty = true; }
+    double getGroundSpeedMPerSec() const
+    { updateGeodeticFromCartesian(); return _groundSpeedMPerSec; }
+    void setGroundSpeedFtPerSec(double value)
+    { setGroundSpeedMPerSec(SG_FEET_TO_METER*value); }
+    double getGroundSpeedFtPerSec() const
+    { return SG_METER_TO_FEET*getGroundSpeedMPerSec(); }
+    void setGroundSpeedKnots(double value)
+    { setGroundSpeedMPerSec(SG_KT_TO_MPS*value); }
+    double getGroundSpeedKnots() const
+    { return SG_MPS_TO_KT*getGroundSpeedMPerSec(); }
+
+    void setVerticalSpeedMPerSec(double value)
+    { _verticalSpeedMPerSec = value; _dirty = true; }
+    double getVerticalSpeedMPerSec() const
+    { updateGeodeticFromCartesian(); return _verticalSpeedMPerSec; }
+    void setVerticalSpeedFtPerSec(double value)
+    { setVerticalSpeedMPerSec(SG_FEET_TO_METER*value); }
+    double getVerticalSpeedFtPerSec() const
+    { return SG_METER_TO_FEET*getVerticalSpeedMPerSec(); }
+    void setVerticalSpeedFtPerMin(double value)
+    { setVerticalSpeedFtPerSec(value/60); }
+    double getVerticalSpeedFtPerMin() const
+    { return 60*getVerticalSpeedFtPerSec(); }
+
+#define DATA_ELEMENT(name) \
+    HLADataElementProvider get## name ## DataElement()                  \
+    { return new DataElement<&HLAGeodeticLocation::get## name, &HLAGeodeticLocation::set ## name>(this); }
+
+    DATA_ELEMENT(LatitudeDeg)
+    DATA_ELEMENT(LatitudeRad)
+    DATA_ELEMENT(LongitudeDeg)
+    DATA_ELEMENT(LongitudeRad)
+    DATA_ELEMENT(ElevationFt)
+    DATA_ELEMENT(ElevationM)
+    DATA_ELEMENT(HeadingDeg)
+    DATA_ELEMENT(HeadingRad)
+    DATA_ELEMENT(PitchDeg)
+    DATA_ELEMENT(PitchRad)
+    DATA_ELEMENT(RollDeg)
+    DATA_ELEMENT(RollRad)
+
+    DATA_ELEMENT(GroundTrackDeg)
+    DATA_ELEMENT(GroundTrackRad)
+    DATA_ELEMENT(GroundSpeedMPerSec)
+    DATA_ELEMENT(GroundSpeedFtPerSec)
+    DATA_ELEMENT(GroundSpeedKnots)
+    DATA_ELEMENT(VerticalSpeedMPerSec)
+    DATA_ELEMENT(VerticalSpeedFtPerSec)
+    DATA_ELEMENT(VerticalSpeedFtPerMin)
+
+#undef DATA_ELEMENT
+
+private:
+    template<double (HLAGeodeticLocation::*getter)() const,
+             void (HLAGeodeticLocation::*setter)(double)>
+    class DataElement : public HLAAbstractDoubleDataElement {
+    public:
+        DataElement(HLAGeodeticLocation* data) :
+            _data(data)
+        { }
+        virtual double getValue() const
+        { return (_data->*getter)(); }
+        virtual void setValue(double value)
+        { (_data->*setter)(value); }
+
+    private:
+        SGSharedPtr<HLAGeodeticLocation> _data;
+    };
+
+    void updateGeodeticFromCartesian() const
+    {
+        if (!_dirty)
+            return;
+        _geodPosition = SGGeod::fromCart(_cartPosition);
+        SGQuatd geodOrientation = inverse(SGQuatd::fromLonLat(_geodPosition))*_cartOrientation;
+        geodOrientation.getEulerRad(_geodEulerRad[2], _geodEulerRad[1], _geodEulerRad[0]);
+        SGVec3d nedVel = geodOrientation.backTransform(_cartBodyVelocity);
+        if (SGLimitsd::min() < SGMiscd::max(fabs(nedVel[0]), fabs(nedVel[1])))
+            _groundTrackRad = atan2(nedVel[1], nedVel[0]);
+        else
+            _groundTrackRad = 0;
+        _groundSpeedMPerSec = sqrt(nedVel[0]*nedVel[0] + nedVel[1]*nedVel[1]);
+        _verticalSpeedMPerSec = -nedVel[2];
+        _dirty = false;
+    }
+    void updateCartesianFromGeodetic() const
+    {
+        if (!_dirty)
+            return;
+        _cartPosition = SGVec3d::fromGeod(_geodPosition);
+        SGQuatd geodOrientation = SGQuatd::fromEulerRad(_geodEulerRad[2], _geodEulerRad[1], _geodEulerRad[0]);
+        _cartOrientation = SGQuatd::fromLonLat(_geodPosition)*geodOrientation;
+        SGVec3d nedVel(cos(_groundTrackRad)*_groundSpeedMPerSec,
+                       sin(_groundTrackRad)*_groundSpeedMPerSec,
+                       -_verticalSpeedMPerSec);
+        _cartBodyVelocity = geodOrientation.transform(nedVel);
+        _dirty = false;
+    }
+
+    mutable bool _dirty;
+
+    // the cartesian values
+    mutable SGVec3d _cartPosition;
+    mutable SGQuatd _cartOrientation;
+    mutable SGVec3d _cartBodyVelocity;
+
+    // The geodetic values
+    mutable SGGeod _geodPosition;
+    mutable SGVec3d _geodEulerRad;
+    mutable double _groundTrackRad;
+    mutable double _groundSpeedMPerSec;
+    mutable double _verticalSpeedMPerSec;
+};
+
+class HLAGeodeticLocationFactory : public HLALocationFactory {
+public:
+    enum Semantic {
+        LatitudeDeg,
+        LatitudeRad,
+        LongitudeDeg,
+        LongitudeRad,
+        ElevationM,
+        ElevationFt,
+        HeadingDeg,
+        HeadingRad,
+        PitchDeg,
+        PitchRad,
+        RollDeg,
+        RollRad,
+        GroundTrackDeg,
+        GroundTrackRad,
+        GroundSpeedKnots,
+        GroundSpeedFtPerSec,
+        GroundSpeedMPerSec,
+        VerticalSpeedFtPerSec,
+        VerticalSpeedFtPerMin,
+        VerticalSpeedMPerSec
+    };
+
+    virtual HLAGeodeticLocation* createLocation(HLAAttributePathElementMap& attributePathElementMap) const
+    {
+        HLAGeodeticLocation* location = new HLAGeodeticLocation;
+
+        for (IndexPathPairSemanticMap::const_iterator i = _indexPathPairSemanticMap.begin();
+             i != _indexPathPairSemanticMap.end(); ++i) {
+            switch (i->second) {
+            case LatitudeDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLatitudeDegDataElement();
+                break;
+            case LatitudeRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLatitudeRadDataElement();
+                break;
+            case LongitudeDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLongitudeDegDataElement();
+                break;
+            case LongitudeRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLongitudeRadDataElement();
+                break;
+            case ElevationM:
+                attributePathElementMap[i->first.first][i->first.second] = location->getElevationMDataElement();
+                break;
+            case ElevationFt:
+                attributePathElementMap[i->first.first][i->first.second] = location->getElevationFtDataElement();
+                break;
+            case HeadingDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getHeadingDegDataElement();
+                break;
+            case HeadingRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getHeadingRadDataElement();
+                break;
+            case PitchDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getPitchDegDataElement();
+                break;
+            case PitchRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getPitchRadDataElement();
+                break;
+            case RollDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getRollDegDataElement();
+                break;
+            case RollRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getRollRadDataElement();
+                break;
+            case GroundTrackDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundTrackDegDataElement();
+                break;
+            case GroundTrackRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundTrackRadDataElement();
+                break;
+            case GroundSpeedKnots:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundSpeedKnotsDataElement();
+                break;
+            case GroundSpeedFtPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundSpeedFtPerSecDataElement();
+                break;
+            case GroundSpeedMPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundSpeedMPerSecDataElement();
+                break;
+            case VerticalSpeedFtPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getVerticalSpeedFtPerSecDataElement();
+                break;
+            case VerticalSpeedFtPerMin:
+                attributePathElementMap[i->first.first][i->first.second] = location->getVerticalSpeedFtPerMinDataElement();
+                break;
+            case VerticalSpeedMPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getVerticalSpeedMPerSecDataElement();
+                break;
+            }
+        }
+
+        return location;
+    }
+
+    void setIndexPathPair(Semantic semantic, const HLADataElement::IndexPathPair& indexPathPair)
+    { _indexPathPairSemanticMap[indexPathPair] = semantic; }
+
+private:
+    typedef std::map<HLADataElement::IndexPathPair, Semantic> IndexPathPairSemanticMap;
+    IndexPathPairSemanticMap _indexPathPairSemanticMap;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAOMTXmlVisitor.cxx

@@ -0,0 +1,864 @@
+// 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 "HLAOMTXmlVisitor.hxx"
+
+#include <map>
+#include <string>
+#include <sstream>
+
+#include <simgear/structure/exception.hxx>
+#include <simgear/xml/easyxml.hxx>
+#include "HLAArrayDataType.hxx"
+#include "HLABasicDataType.hxx"
+#include "HLADataTypeVisitor.hxx"
+#include "HLAEnumeratedDataType.hxx"
+#include "HLAFederate.hxx"
+#include "HLAFixedRecordDataType.hxx"
+#include "HLAVariantRecordDataType.hxx"
+
+namespace simgear {
+
+HLAOMTXmlVisitor::ObjectClass::ObjectClass(const std::string& name, const std::string& sharing) :
+    _name(name),
+    _sharing(sharing)
+{
+}
+
+HLAOMTXmlVisitor::ObjectClass::~ObjectClass()
+{
+}
+
+const std::string&
+HLAOMTXmlVisitor::ObjectClass::getName() const
+{
+    return _name;
+}
+
+const std::string&
+HLAOMTXmlVisitor::ObjectClass::getSharing() const
+{
+    return _sharing;
+}
+
+unsigned
+HLAOMTXmlVisitor::ObjectClass::getNumAttributes() const
+{
+    return _attributes.size();
+}
+
+const HLAOMTXmlVisitor::Attribute*
+HLAOMTXmlVisitor::ObjectClass::getAttribute(unsigned index) const
+{
+    if (_attributes.size() <= index)
+        return 0;
+    return _attributes[index];
+}
+
+const HLAOMTXmlVisitor::ObjectClass*
+HLAOMTXmlVisitor::ObjectClass::getParentObjectClass() const
+{
+    return _parentObjectClass.get();
+}
+
+HLAOMTXmlVisitor::InteractionClass::InteractionClass(const std::string& name) :
+    _name(name)
+{
+}
+
+HLAOMTXmlVisitor::InteractionClass::~InteractionClass()
+{
+}
+
+const std::string&
+HLAOMTXmlVisitor::InteractionClass::getName() const
+{
+    return _name;
+}
+
+const std::string&
+HLAOMTXmlVisitor::InteractionClass::getDimensions() const
+{
+    return _dimensions;
+}
+
+const std::string&
+HLAOMTXmlVisitor::InteractionClass::getSharing() const
+{
+    return _sharing;
+}
+
+const std::string&
+HLAOMTXmlVisitor::InteractionClass::getTransportation() const
+{
+    return _transportation;
+}
+
+const std::string&
+HLAOMTXmlVisitor::InteractionClass::getOrder() const
+{
+    return _order;
+}
+
+unsigned
+HLAOMTXmlVisitor::InteractionClass::getNumParameters() const
+{
+    return _parameters.size();
+}
+
+const HLAOMTXmlVisitor::Parameter*
+HLAOMTXmlVisitor::InteractionClass::getParameter(unsigned index) const
+{
+    if (_parameters.size() <= index)
+        return 0;
+    return _parameters[index];
+}
+
+const HLAOMTXmlVisitor::InteractionClass*
+HLAOMTXmlVisitor::InteractionClass::getParentInteractionClass() const
+{
+    return _parentInteractionClass.get();
+}
+
+HLAOMTXmlVisitor::HLAOMTXmlVisitor()
+{
+}
+
+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
+{
+    return _objectClassList.size();
+}
+
+const HLAOMTXmlVisitor::ObjectClass*
+HLAOMTXmlVisitor::getObjectClass(unsigned i) const
+{
+    if (_objectClassList.size() <= i)
+        return 0;
+    return _objectClassList[i];
+}
+
+unsigned
+HLAOMTXmlVisitor::getNumInteractionClasses() const
+{
+    return _interactionClassList.size();
+}
+
+const HLAOMTXmlVisitor::InteractionClass*
+HLAOMTXmlVisitor::getInteractionClass(unsigned i) const
+{
+    if (_interactionClassList.size() <= i)
+        return 0;
+    return _interactionClassList[i];
+}
+
+SGSharedPtr<HLADataType>
+HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName)
+{
+    StringDataTypeMap::const_iterator i = _dataTypeMap.find(dataTypeName);
+    if (i != _dataTypeMap.end())
+        return i->second;
+
+    SGSharedPtr<HLADataType> dataType;
+    dataType = getBasicDataType(dataTypeName);
+    if (dataType.valid()) {
+        _dataTypeMap[dataTypeName] = dataType;
+        return dataType;
+    }
+
+    dataType = getSimpleDataType(dataTypeName);
+    if (dataType.valid())
+        return dataType;
+
+    dataType = getEnumeratedDataType(dataTypeName);
+    if (dataType.valid())
+        return dataType;
+
+    dataType = getArrayDataType(dataTypeName);
+    if (dataType.valid())
+        return dataType;
+
+    dataType = getFixedRecordDataType(dataTypeName);
+    if (dataType.valid())
+        return dataType;
+
+    dataType = getVariantRecordDataType(dataTypeName);
+    if (dataType.valid())
+        return dataType;
+
+    SG_LOG(SG_IO, SG_WARN, "Could not resolve dataType \"" << dataTypeName << "\".");
+    return 0;
+}
+
+SGSharedPtr<HLABasicDataType>
+HLAOMTXmlVisitor::getBasicDataType(const std::string& dataTypeName)
+{
+    BasicDataMap::const_iterator i = _basicDataMap.find(dataTypeName);
+    if (i == _basicDataMap.end())
+        return 0;
+    if (i->second._size == "8") {
+        return new HLAUInt8DataType(dataTypeName);
+    } else if (i->second._size == "16") {
+        if (i->first.find("Unsigned") != std::string::npos) {
+            if (i->second._endian == "Little") {
+                return new HLAUInt16LEDataType(dataTypeName);
+            } else {
+                return new HLAUInt16BEDataType(dataTypeName);
+            }
+        } else if (i->first.find("octetPair") != std::string::npos) {
+            if (i->second._endian == "Little") {
+                return new HLAUInt16LEDataType(dataTypeName);
+            } else {
+                return new HLAUInt16BEDataType(dataTypeName);
+            }
+        } else {
+            if (i->second._endian == "Little") {
+                return new HLAInt16LEDataType(dataTypeName);
+            } else {
+                return new HLAInt16BEDataType(dataTypeName);
+            }
+        }
+    } else if (i->second._size == "32") {
+        if (i->first.find("Unsigned") != std::string::npos) {
+            if (i->second._endian == "Little") {
+                return new HLAUInt32LEDataType(dataTypeName);
+            } else {
+                return new HLAUInt32BEDataType(dataTypeName);
+            }
+        } else if (i->first.find("float") != std::string::npos) {
+            if (i->second._endian == "Little") {
+                return new HLAFloat32LEDataType(dataTypeName);
+            } else {
+                return new HLAFloat32BEDataType(dataTypeName);
+            }
+        } else {
+            if (i->second._endian == "Little") {
+                return new HLAInt32LEDataType(dataTypeName);
+            } else {
+                return new HLAInt32BEDataType(dataTypeName);
+            }
+        }
+    } else if (i->second._size == "64") {
+        if (i->first.find("Unsigned") != std::string::npos) {
+            if (i->second._endian == "Little") {
+                return new HLAUInt64LEDataType(dataTypeName);
+            } else {
+                return new HLAUInt64BEDataType(dataTypeName);
+            }
+        } else if (i->first.find("float") != std::string::npos) {
+            if (i->second._endian == "Little") {
+                return new HLAFloat64LEDataType(dataTypeName);
+            } else {
+                return new HLAFloat64BEDataType(dataTypeName);
+            }
+        } else {
+            if (i->second._endian == "Little") {
+                return new HLAInt64LEDataType(dataTypeName);
+            } else {
+                return new HLAInt64BEDataType(dataTypeName);
+            }
+        }
+    }
+
+    return 0;
+}
+
+SGSharedPtr<HLADataType>
+HLAOMTXmlVisitor::getSimpleDataType(const std::string& dataTypeName)
+{
+    SimpleDataMap::const_iterator i = _simpleDataMap.find(dataTypeName);
+    if (i == _simpleDataMap.end())
+        return 0;
+    return getDataType(i->second._representation);
+}
+
+SGSharedPtr<HLAEnumeratedDataType>
+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();
+         j != i->second._enumeratorList.end(); ++j) {
+        if (!enumeratedDataType->addEnumerator(j->_name, j->_values)) {
+            SG_LOG(SG_IO, SG_ALERT, "Could not add enumerator \"" << j->_name
+                   << "\" to find enumerated data type \"" << dataTypeName << "\".");
+            return 0;
+        }
+    }
+
+    return enumeratedDataType;
+}
+
+SGSharedPtr<HLADataType>
+HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName)
+{
+    ArrayDataMap::const_iterator i = _arrayDataMap.find(dataTypeName);
+    if (i == _arrayDataMap.end())
+        return 0;
+    SGSharedPtr<HLAArrayDataType> arrayDataType;
+    if (i->second._encoding == "HLAvariableArray") {
+        arrayDataType = new HLAVariableArrayDataType(dataTypeName);
+    } else if (i->second._encoding == "HLAfixedArray") {
+        std::stringstream ss(i->second._cardinality);
+        unsigned cardinality;
+        ss >> cardinality;
+        if (ss.fail()) {
+            SG_LOG(SG_IO, SG_ALERT, "Could not interpret cardinality \""
+                   << i->second._cardinality << "\" for dataType \""
+                   << dataTypeName << "\".");
+            return 0;
+        }
+        SGSharedPtr<HLAFixedArrayDataType> dataType = new HLAFixedArrayDataType(dataTypeName);
+        dataType->setNumElements(cardinality);
+        arrayDataType = dataType;
+    } else {
+        SG_LOG(SG_IO, SG_ALERT, "Can not interpret encoding \""
+               << i->second._encoding << "\" for dataType \""
+               << dataTypeName << "\".");
+        return 0;
+    }
+
+    _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);
+        return 0;
+    }
+    arrayDataType->setElementDataType(elementDataType.get());
+
+    // Check if this should be a string data type
+    if (elementDataType->toBasicDataType()) {
+        if (dataTypeName == "HLAopaqueData") {
+            arrayDataType->setIsOpaque(true);
+        } else if (dataTypeName.find("String") != std::string::npos || dataTypeName.find("string") != std::string::npos) {
+            arrayDataType->setIsString(true);
+        }
+    }
+
+    return arrayDataType;
+}
+
+SGSharedPtr<HLAFixedRecordDataType>
+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;
+    for (FieldList::size_type j = 0; j < i->second._fieldList.size(); ++j) {
+        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);
+            return 0;
+        }
+        dataType->addField(i->second._fieldList[j]._name, fieldDataType.get());
+    }
+    return dataType;
+}
+
+SGSharedPtr<HLAVariantRecordDataType>
+HLAOMTXmlVisitor::getVariantRecordDataType(const std::string& dataTypeName)
+{
+    VariantRecordDataMap::const_iterator i = _variantRecordDataMap.find(dataTypeName);
+    if (i == _variantRecordDataMap.end())
+        return 0;
+    SGSharedPtr<HLAVariantRecordDataType> dataType = new HLAVariantRecordDataType(dataTypeName);
+    _dataTypeMap[dataTypeName] = dataType;
+
+    SGSharedPtr<HLAEnumeratedDataType> enumeratedDataType = getEnumeratedDataType(i->second._dataType);
+    if (!enumeratedDataType.valid()) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not find enumerted data type \"" << i->second._dataType
+               << "\" for variant data type \"" << dataTypeName << "\".");
+        return 0;
+    }
+    dataType->setEnumeratedDataType(enumeratedDataType);
+
+    for (AlternativeList::const_iterator j = i->second._alternativeList.begin();
+         j != i->second._alternativeList.end(); ++j) {
+        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);
+            return 0;
+        }
+        if (!dataType->addAlternative(j->_name, j->_enumerator, alternativeDataType.get(), j->_semantics)) {
+            SG_LOG(SG_IO, SG_ALERT, "Could not add alternative \"" << j->_name << "\".");
+            return 0;
+        }
+    }
+    return dataType;
+}
+
+HLAOMTXmlVisitor::Mode
+HLAOMTXmlVisitor::getCurrentMode()
+{
+    if (_modeStack.empty())
+        return UnknownMode;
+    return _modeStack.back();
+}
+
+void
+HLAOMTXmlVisitor::pushMode(HLAOMTXmlVisitor::Mode mode)
+{
+    _modeStack.push_back(mode);
+}
+
+void
+HLAOMTXmlVisitor::popMode()
+{
+    _modeStack.pop_back();
+}
+
+void
+HLAOMTXmlVisitor::startXML()
+{
+    _modeStack.clear();
+}
+
+void
+HLAOMTXmlVisitor::endXML()
+{
+    if (!_modeStack.empty())
+        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;
+        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;
+        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);
+        }
+    }
+}
+
+void
+HLAOMTXmlVisitor::startElement(const char* name, const XMLAttributes& atts)
+{
+    if (strcmp(name, "attribute") == 0) {
+        if (getCurrentMode() != ObjectClassMode)
+            throw sg_exception("attribute tag outside objectClass!");
+        pushMode(AttributeMode);
+
+        if (_objectClassList.empty())
+            throw sg_exception("attribute tag outside of an objectClass");
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("attribute tag without name attribute");
+
+        SGSharedPtr<Attribute> attribute = new Attribute(name);
+
+        attribute->_dataType = getAttribute("dataType", atts);
+        attribute->_updateType = getAttribute("updateType", atts);
+        attribute->_updateCondition = getAttribute("updateCondition", atts);
+        attribute->_ownership = getAttribute("ownership", atts);
+        attribute->_sharing = getAttribute("sharing", atts);
+        attribute->_dimensions = getAttribute("dimensions", atts);
+        attribute->_transportation = getAttribute("transportation", atts);
+        attribute->_order = getAttribute("order", atts);
+
+        _objectClassStack.back()->_attributes.push_back(attribute);
+
+    } else if (strcmp(name, "objectClass") == 0) {
+        if (getCurrentMode() != ObjectsMode && getCurrentMode() != ObjectClassMode)
+            throw sg_exception("objectClass tag outside objectClass or objects!");
+        pushMode(ObjectClassMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("objectClass tag without name attribute");
+
+        std::string sharing = getAttribute("sharing", atts);
+
+        // The new ObjectClass
+        ObjectClass* objectClass = new ObjectClass(name, sharing);
+
+        // Inherit all previous attributes
+        if (!_objectClassStack.empty())
+            objectClass->_parentObjectClass = _objectClassStack.back();
+
+        _objectClassStack.push_back(objectClass);
+        _objectClassList.push_back(objectClass);
+
+    } else if (strcmp(name, "objects") == 0) {
+        if (getCurrentMode() != ObjectModelMode)
+            throw sg_exception("objects tag outside objectModel!");
+        pushMode(ObjectsMode);
+
+    } else if (strcmp(name, "parameter") == 0) {
+        if (getCurrentMode() != InteractionClassMode)
+            throw sg_exception("parameter tag outside interactionClass!");
+        pushMode(ParameterMode);
+
+        if (_interactionClassList.empty())
+            throw sg_exception("parameter tag outside of an interactionClass");
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("parameter tag without name parameter");
+
+        SGSharedPtr<Parameter> parameter = new Parameter(name);
+        parameter->_dataType = getAttribute("dataType", atts);
+
+        _interactionClassStack.back()->_parameters.push_back(parameter);
+
+    } else if (strcmp(name, "interactionClass") == 0) {
+        if (getCurrentMode() != InteractionsMode && getCurrentMode() != InteractionClassMode)
+            throw sg_exception("interactionClass tag outside interactions or interactionClass!");
+        pushMode(InteractionClassMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("interactionClass tag without name attribute");
+
+        // The new ObjectClass
+        InteractionClass* interactionClass = new InteractionClass(name);
+        interactionClass->_dimensions = getAttribute("dimensions", atts);
+        interactionClass->_transportation = getAttribute("transportation", atts);
+        interactionClass->_order = getAttribute("order", atts);
+
+        // Inherit all previous attributes
+        if (!_interactionClassStack.empty())
+            interactionClass->_parentInteractionClass = _interactionClassStack.back();
+
+        _interactionClassStack.push_back(interactionClass);
+        _interactionClassList.push_back(interactionClass);
+
+    } else if (strcmp(name, "interactions") == 0) {
+        if (getCurrentMode() != ObjectModelMode)
+            throw sg_exception("interactions tag outside objectModel!");
+        pushMode(InteractionsMode);
+
+    } else if (strcmp(name, "basicData") == 0) {
+        if (getCurrentMode() != BasicDataRepresentationsMode)
+            throw sg_exception("basicData tag outside basicDataRepresentations!");
+        pushMode(BasicDataMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("basicData tag without name attribute");
+
+        _basicDataMap[name]._size = getAttribute("size", atts);
+        _basicDataMap[name]._endian = getAttribute("endian", atts);
+
+    } else if (strcmp(name, "basicDataRepresentations") == 0) {
+        if (getCurrentMode() != DataTypesMode)
+            throw sg_exception("basicDataRepresentations tag outside dataTypes!");
+        pushMode(BasicDataRepresentationsMode);
+
+    } else if (strcmp(name, "simpleData") == 0) {
+        if (getCurrentMode() != SimpleDataTypesMode)
+            throw sg_exception("simpleData tag outside simpleDataTypes!");
+        pushMode(SimpleDataMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("simpleData tag without name attribute");
+
+        _simpleDataMap[name]._representation = getAttribute("representation", atts);
+        _simpleDataMap[name]._units = getAttribute("units", atts);
+        _simpleDataMap[name]._resolution = getAttribute("resolution", atts);
+        _simpleDataMap[name]._accuracy = getAttribute("accuracy", atts);
+
+    } else if (strcmp(name, "simpleDataTypes") == 0) {
+        if (getCurrentMode() != DataTypesMode)
+            throw sg_exception("simpleDataTypes tag outside dataTypes!");
+        pushMode(SimpleDataTypesMode);
+
+    } else if (strcmp(name, "enumerator") == 0) {
+        if (getCurrentMode() != EnumeratedDataMode)
+            throw sg_exception("enumerator tag outside enumeratedData!");
+        pushMode(EnumeratorMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("enumerator tag without name attribute");
+
+        Enumerator enumerator;
+        enumerator._name = name;
+        enumerator._values = getAttribute("values", atts);
+        _enumeratedDataMap[_enumeratedDataName]._enumeratorList.push_back(enumerator);
+
+    } else if (strcmp(name, "enumeratedData") == 0) {
+        if (getCurrentMode() != EnumeratedDataTypesMode)
+            throw sg_exception("enumeratedData tag outside enumeratedDataTypes!");
+        pushMode(EnumeratedDataMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("enumeratedData tag without name attribute");
+
+        _enumeratedDataName = name;
+        _enumeratedDataMap[_enumeratedDataName]._representation = getAttribute("representation", atts);
+
+    } else if (strcmp(name, "enumeratedDataTypes") == 0) {
+        if (getCurrentMode() != DataTypesMode)
+            throw sg_exception("enumeratedDataTypes tag outside dataTypes!");
+        pushMode(EnumeratedDataTypesMode);
+
+    } else if (strcmp(name, "arrayData") == 0) {
+        if (getCurrentMode() != ArrayDataTypesMode)
+            throw sg_exception("arrayData tag outside arrayDataTypes!");
+        pushMode(ArrayDataMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("arrayData tag without name attribute");
+
+        _arrayDataMap[name]._dataType = getAttribute("dataType", atts);
+        _arrayDataMap[name]._cardinality = getAttribute("cardinality", atts);
+        _arrayDataMap[name]._encoding = getAttribute("encoding", atts);
+
+    } else if (strcmp(name, "arrayDataTypes") == 0) {
+        if (getCurrentMode() != DataTypesMode)
+            throw sg_exception("arrayDataTypes tag outside dataTypes!");
+        pushMode(ArrayDataTypesMode);
+
+    } else if (strcmp(name, "field") == 0) {
+        if (getCurrentMode() != FixedRecordDataMode)
+            throw sg_exception("field tag outside fixedRecordData!");
+        pushMode(FieldMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("field tag without name attribute");
+
+        Field field;
+        field._name = name;
+        field._dataType = getAttribute("dataType", atts);
+        _fixedRecordDataMap[_fixedRecordDataName]._fieldList.push_back(field);
+
+    } else if (strcmp(name, "fixedRecordData") == 0) {
+        if (getCurrentMode() != FixedRecordDataTypesMode)
+            throw sg_exception("fixedRecordData tag outside fixedRecordDataTypes!");
+        pushMode(FixedRecordDataMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("fixedRecordData tag without name attribute");
+
+        _fixedRecordDataName = name;
+        _fixedRecordDataMap[name]._encoding = getAttribute("encoding", atts);
+
+    } else if (strcmp(name, "fixedRecordDataTypes") == 0) {
+        if (getCurrentMode() != DataTypesMode)
+            throw sg_exception("fixedRecordDataTypes tag outside dataTypes!");
+        pushMode(FixedRecordDataTypesMode);
+
+    } else if (strcmp(name, "alternative") == 0) {
+
+        if (getCurrentMode() != VariantRecordDataMode)
+            throw sg_exception("alternative tag outside variantRecordData!");
+        pushMode(AlternativeDataMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("alternative tag without name attribute");
+
+        Alternative alternative;
+        alternative._name = name;
+        alternative._dataType = getAttribute("dataType", atts);
+        alternative._semantics = getAttribute("semantics", atts);
+        alternative._enumerator = getAttribute("enumerator", atts);
+        _variantRecordDataMap[_variantRecordDataName]._alternativeList.push_back(alternative);
+
+    } else if (strcmp(name, "variantRecordData") == 0) {
+        if (getCurrentMode() != VariantRecordDataTypesMode)
+            throw sg_exception("variantRecordData tag outside variantRecordDataTypes!");
+        pushMode(VariantRecordDataMode);
+
+        std::string name = getAttribute("name", atts);
+        if (name.empty())
+            throw sg_exception("fixedRecordData tag without name attribute");
+
+        _variantRecordDataName = name;
+        _variantRecordDataMap[name]._encoding = getAttribute("encoding", atts);
+        _variantRecordDataMap[name]._dataType = getAttribute("dataType", atts);
+        _variantRecordDataMap[name]._semantics = getAttribute("semantics", atts);
+        _variantRecordDataMap[name]._discriminant = getAttribute("discriminant", atts);
+
+    } else if (strcmp(name, "variantRecordDataTypes") == 0) {
+        if (getCurrentMode() != DataTypesMode)
+            throw sg_exception("variantRecordDataTypes tag outside dataTypes!");
+        pushMode(VariantRecordDataTypesMode);
+
+    } else if (strcmp(name, "dataTypes") == 0) {
+        if (getCurrentMode() != ObjectModelMode)
+            throw sg_exception("dataTypes tag outside objectModel!");
+        pushMode(DataTypesMode);
+
+    } else if (strcmp(name, "objectModel") == 0) {
+        if (!_modeStack.empty())
+            throw sg_exception("objectModel tag not at top level!");
+        pushMode(ObjectModelMode);
+
+    } else {
+        _modeStack.push_back(UnknownMode);
+    }
+}
+
+void
+HLAOMTXmlVisitor::endElement(const char* name)
+{
+    if (strcmp(name, "objectClass") == 0) {
+        _objectClassStack.pop_back();
+    } else if (strcmp(name, "interactionClass") == 0) {
+        _interactionClassStack.pop_back();
+    } else if (strcmp(name, "enumeratedData") == 0) {
+        _enumeratedDataName.clear();
+    } else if (strcmp(name, "fixedRecordData") == 0) {
+        _fixedRecordDataName.clear();
+    } else if (strcmp(name, "variantRecordData") == 0) {
+        _variantRecordDataName.clear();
+    }
+
+    _modeStack.pop_back();
+}
+
+std::string
+HLAOMTXmlVisitor::getAttribute(const char* name, const XMLAttributes& atts)
+{
+    int index = atts.findAttribute(name);
+    if (index < 0 || atts.size() <= index)
+        return std::string();
+    return std::string(atts.getValue(index));
+}
+
+std::string
+HLAOMTXmlVisitor::getAttribute(const std::string& name, const XMLAttributes& atts)
+{
+    int index = atts.findAttribute(name.c_str());
+    if (index < 0 || atts.size() <= index)
+        return std::string();
+    return std::string(atts.getValue(index));
+}
+
+} // namespace simgear

simgear/hla/HLAOMTXmlVisitor.hxx

@@ -0,0 +1,334 @@
+// 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 HLAOMTXmlVisitor_hxx
+#define HLAOMTXmlVisitor_hxx
+
+#include <map>
+#include <string>
+
+#include <simgear/structure/exception.hxx>
+#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
+    struct Attribute : public SGReferenced {
+        Attribute(const std::string& name) :
+            _name(name)
+        { }
+        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
+        { return _transportation; }
+        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;
+        std::string _updateCondition;
+        std::string _ownership;
+        std::string _sharing;
+        std::string _dimensions;
+        std::string _transportation;
+        std::string _order;
+        friend class HLAOMTXmlVisitor;
+    };
+    typedef std::vector<SGSharedPtr<Attribute> > AttributeList;
+
+    struct ObjectClass : public SGReferenced {
+        ObjectClass(const std::string& name, const std::string& sharing);
+        ~ObjectClass();
+
+        const std::string& getName() const;
+        const std::string& getSharing() const;
+
+        unsigned getNumAttributes() const;
+        const Attribute* getAttribute(unsigned index) const;
+
+        const ObjectClass* getParentObjectClass() const;
+
+    private:
+        friend class HLAOMTXmlVisitor;
+        std::string _name;
+        std::string _sharing;
+        AttributeList _attributes;
+        SGSharedPtr<ObjectClass> _parentObjectClass;
+    };
+    typedef std::vector<SGSharedPtr<ObjectClass> > ObjectClassList;
+
+    struct Parameter : public SGReferenced {
+        Parameter(const std::string& name) :
+            _name(name)
+        { }
+        const std::string& getName() const
+        { return _name; }
+        const std::string& getDataType() const
+        { return _dataType; }
+
+    private:
+        std::string _name;
+        std::string _dataType;
+        friend class HLAOMTXmlVisitor;
+    };
+    typedef std::vector<SGSharedPtr<Parameter> > ParameterList;
+
+    struct InteractionClass : public SGReferenced {
+        InteractionClass(const std::string& name);
+        ~InteractionClass();
+
+        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 InteractionClass* getParentInteractionClass() const;
+
+    private:
+        friend class HLAOMTXmlVisitor;
+        std::string _name;
+        std::string _dimensions;
+        std::string _sharing;
+        std::string _transportation;
+        std::string _order;
+        ParameterList _parameters;
+        SGSharedPtr<InteractionClass> _parentInteractionClass;
+    };
+    typedef std::vector<SGSharedPtr<InteractionClass> > InteractionClassList;
+
+    HLAOMTXmlVisitor();
+    ~HLAOMTXmlVisitor();
+
+    void setDataTypesToFederate(HLAFederate& federate);
+    void setToFederate(HLAFederate& federate);
+
+    unsigned getNumObjectClasses() const;
+    const ObjectClass* getObjectClass(unsigned i) const;
+
+    unsigned getNumInteractionClasses() const;
+    const InteractionClass* getInteractionClass(unsigned i) const;
+
+private:
+    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,
+
+        ObjectModelMode,
+
+        ObjectsMode,
+        ObjectClassMode,
+        AttributeMode,
+
+        InteractionsMode,
+        InteractionClassMode,
+        ParameterMode,
+
+        DataTypesMode,
+        BasicDataRepresentationsMode,
+        BasicDataMode,
+        SimpleDataTypesMode,
+        SimpleDataMode,
+        EnumeratedDataTypesMode,
+        EnumeratedDataMode,
+        EnumeratorMode,
+        ArrayDataTypesMode,
+        ArrayDataMode,
+        FixedRecordDataTypesMode,
+        FixedRecordDataMode,
+        FieldMode,
+        VariantRecordDataTypesMode,
+        VariantRecordDataMode,
+        AlternativeDataMode
+    };
+
+    Mode getCurrentMode();
+    void pushMode(Mode mode);
+    void popMode();
+
+    virtual void startXML();
+    virtual void endXML ();
+    virtual void startElement(const char* name, const XMLAttributes& atts);
+    virtual void endElement(const char* name);
+
+    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;
+        std::string _size;
+        std::string _endian;
+    };
+    typedef std::map<std::string, BasicData> BasicDataMap;
+
+    struct SimpleData {
+        // std::string _name;
+        std::string _representation;
+        std::string _units;
+        std::string _resolution;
+        std::string _accuracy;
+    };
+    typedef std::map<std::string, SimpleData> SimpleDataMap;
+
+    struct Enumerator {
+        std::string _name;
+        std::string _values;
+    };
+    typedef std::vector<Enumerator> EnumeratorList;
+
+    struct EnumeratedData {
+        // std::string _name;
+        std::string _representation;
+        EnumeratorList _enumeratorList;
+    };
+    typedef std::map<std::string, EnumeratedData> EnumeratedDataMap;
+
+    struct ArrayData {
+        // std::string _name;
+        std::string _dataType;
+        std::string _cardinality;
+        std::string _encoding;
+    };
+    typedef std::map<std::string, ArrayData> ArrayDataMap;
+
+    struct Field {
+        std::string _name;
+        std::string _dataType;
+    };
+    typedef std::vector<Field> FieldList;
+
+    struct FixedRecordData {
+        // std::string _name;
+        std::string _encoding;
+        FieldList _fieldList;
+    };
+    typedef std::map<std::string, FixedRecordData> FixedRecordDataMap;
+
+    struct Alternative {
+        std::string _name;
+        std::string _dataType;
+        std::string _semantics;
+        std::string _enumerator;
+    };
+    typedef std::vector<Alternative> AlternativeList;
+
+    struct VariantRecordData {
+        // std::string _name;
+        std::string _encoding;
+        std::string _dataType;
+        std::string _discriminant;
+        std::string _semantics;
+        AlternativeList _alternativeList;
+    };
+    typedef std::map<std::string, VariantRecordData> VariantRecordDataMap;
+
+    std::vector<Mode> _modeStack;
+
+    /// The total list of object classes
+    ObjectClassList _objectClassList;
+    ObjectClassList _objectClassStack;
+
+    /// The total list of interaction classes
+    InteractionClassList _interactionClassList;
+    InteractionClassList _interactionClassStack;
+
+    typedef std::map<std::string, SGSharedPtr<HLADataType> > StringDataTypeMap;
+    StringDataTypeMap _dataTypeMap;
+
+    /// DataType definitions
+    BasicDataMap _basicDataMap;
+    SimpleDataMap _simpleDataMap;
+    std::string _enumeratedDataName;
+    EnumeratedDataMap _enumeratedDataMap;
+    ArrayDataMap _arrayDataMap;
+    std::string _fixedRecordDataName;
+    FixedRecordDataMap _fixedRecordDataMap;
+    std::string _variantRecordDataName;
+    VariantRecordDataMap _variantRecordDataMap;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAObjectClass.cxx

@@ -0,0 +1,445 @@
+// 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 "HLAObjectClass.hxx"
+
+#include "simgear/debug/logstream.hxx"
+#include "RTIFederate.hxx"
+#include "RTIObjectClass.hxx"
+#include "RTIObjectInstance.hxx"
+#include "HLADataType.hxx"
+#include "HLAFederate.hxx"
+#include "HLAObjectInstance.hxx"
+
+namespace simgear {
+
+HLAObjectClass::InstanceCallback::~InstanceCallback()
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::discoverInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance, const RTIData& tag)
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::removeInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance, const RTIData& tag)
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::registerInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance)
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::deleteInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance)
+{
+}
+
+HLAObjectClass::RegistrationCallback::~RegistrationCallback()
+{
+}
+
+HLAObjectClass::HLAObjectClass(const std::string& name, HLAFederate* federate) :
+    _federate(federate),
+    _name(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
+{
+    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
+{
+    NameIndexMap::const_iterator i = _nameIndexMap.find(name);
+    if (i == _nameIndexMap.end())
+        return ~0u;
+    return i->second;
+}
+
+std::string
+HLAObjectClass::getAttributeName(unsigned index) const
+{
+    if (_attributeVector.size() <= index)
+        return std::string();
+    return _attributeVector[index]._name;
+}
+
+const HLADataType*
+HLAObjectClass::getAttributeDataType(unsigned index) const
+{
+    if (_attributeVector.size() <= index)
+        return 0;
+    return _attributeVector[index]._dataType.get();
+}
+
+void
+HLAObjectClass::setAttributeDataType(unsigned index, const HLADataType* dataType)
+{
+    if (_attributeVector.size() <= index)
+        return;
+    _attributeVector[index]._dataType = dataType;
+}
+
+HLAUpdateType
+HLAObjectClass::getAttributeUpdateType(unsigned index) const
+{
+    if (_attributeVector.size() <= index)
+        return HLAUndefinedUpdate;
+    return _attributeVector[index]._updateType;
+}
+
+void
+HLAObjectClass::setAttributeUpdateType(unsigned index, HLAUpdateType updateType)
+{
+    if (_attributeVector.size() <= index)
+        return;
+    _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::StringPathPair& stringPathPair) const
+{
+    unsigned index = getAttributeIndex(stringPathPair.first);
+    if (getNumAttributes() <= index) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::getIndexPathPair(\""
+               << HLADataElement::toString(stringPathPair)
+               << "\"): Could not resolve attribute \"" << stringPathPair.first
+               << "\" for object class \"" << getName() << "\"!");
+    }
+    return HLADataElement::IndexPathPair(index, stringPathPair.second);
+}
+
+HLADataElement::IndexPathPair
+HLAObjectClass::getIndexPathPair(const std::string& path) const
+{
+    return getIndexPathPair(HLADataElement::toStringPathPair(path));
+}
+
+bool
+HLAObjectClass::subscribe()
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): "
+               "No RTIObject class for object class \"" << getName() << "\"!");
+        return false;
+    }
+
+    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() << "\"!");
+        return false;
+    }
+    return _rtiObjectClass->unsubscribe();
+}
+
+bool
+HLAObjectClass::publish()
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): "
+               "No RTIObject class for object class \"" << getName() << "\"!");
+        return false;
+    }
+
+    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() << "\"!");
+        return false;
+    }
+    return _rtiObjectClass->unpublish();
+}
+
+void
+HLAObjectClass::startRegistration() const
+{
+}
+
+void
+HLAObjectClass::stopRegistration() const
+{
+}
+
+HLAObjectInstance*
+HLAObjectClass::createObjectInstance(const std::string& name)
+{
+    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::_setRTIObjectClass(RTIObjectClass* objectClass)
+{
+    if (_rtiObjectClass) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Setting RTIObjectClass twice for object class \"" << getName() << "\"!");
+        return;
+    }
+    _rtiObjectClass = objectClass;
+    if (_rtiObjectClass->_objectClass != this) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: backward reference does not match!");
+        return;
+    }
+    for (unsigned i = 0; i < _attributeVector.size(); ++i)
+        _resolveAttributeIndex(_attributeVector[i]._name, i);
+}
+
+void
+HLAObjectClass::_resolveAttributeIndex(const std::string& name, unsigned index)
+{
+    if (!_rtiObjectClass)
+        return;
+    if (!_rtiObjectClass->resolveAttributeIndex(name, index))
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Could not resolve attribute \""
+               << name << "\" for object class \"" << getName() << "\"!");
+}
+
+void
+HLAObjectClass::_clearRTIObjectClass()
+{
+    if (!_rtiObjectClass.valid())
+        return;
+    _rtiObjectClass->_objectClass = 0;
+    _rtiObjectClass = 0;
+}
+
+void
+HLAObjectClass::_discoverInstance(RTIObjectInstance* rtiObjectInstance, const RTIData& tag)
+{
+    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;
+    }
+
+    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::_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);
+    else
+        startRegistration();
+}
+
+void
+HLAObjectClass::_stopRegistration()
+{
+    if (_registrationCallback.valid())
+        _registrationCallback->stopRegistration(*this);
+    else
+        stopRegistration();
+}
+
+} // namespace simgear

simgear/hla/HLAObjectClass.hxx

@@ -0,0 +1,180 @@
+// 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 HLAObjectClass_hxx
+#define HLAObjectClass_hxx
+
+#include <string>
+#include <vector>
+
+#include "HLADataType.hxx"
+#include "HLAObjectInstance.hxx"
+#include "HLATypes.hxx"
+
+namespace simgear {
+
+class RTIObjectClass;
+class HLAFederate;
+
+class HLAObjectClass : public SGWeakReferenced {
+public:
+    HLAObjectClass(const std::string& name, HLAFederate* federate);
+    virtual ~HLAObjectClass();
+
+    /// 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;
+    /// 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);
+
+    /// 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;
+
+    virtual bool subscribe();
+    virtual bool unsubscribe();
+
+    virtual bool publish();
+    virtual bool unpublish();
+
+    // Object instance creation and destruction
+    class InstanceCallback : public SGReferenced {
+    public:
+        virtual ~InstanceCallback();
+
+        virtual void discoverInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance, const RTIData& tag);
+        virtual void removeInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance, const RTIData& tag);
+
+        virtual void registerInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance);
+        virtual void deleteInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance);
+    };
+
+    void setInstanceCallback(const SGSharedPtr<InstanceCallback>& instanceCallback)
+    { _instanceCallback = instanceCallback; }
+    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:
+        virtual ~RegistrationCallback();
+        virtual void startRegistration(HLAObjectClass& objectClass) = 0;
+        virtual void stopRegistration(HLAObjectClass& objectClass) = 0;
+    };
+
+    void setRegistrationCallback(const SGSharedPtr<RegistrationCallback>& registrationCallback)
+    { _registrationCallback = registrationCallback; }
+    const SGSharedPtr<RegistrationCallback>& getRegistrationCallback() const
+    { return _registrationCallback; }
+
+    /// 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 _startRegistration();
+    void _stopRegistration();
+
+    friend class HLAObjectInstance;
+    friend class RTIObjectClass;
+
+    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
+    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;
+
+    friend class HLAFederate;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAObjectInstance.cxx

@@ -0,0 +1,706 @@
+// 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 "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 "HLAVariantRecordDataElement.hxx"
+#include "RTIObjectClass.hxx"
+#include "RTIObjectInstance.hxx"
+
+namespace simgear {
+
+HLAObjectInstance::UpdateCallback::~UpdateCallback()
+{
+}
+
+HLAObjectInstance::ReflectCallback::~ReflectCallback()
+{
+}
+
+HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass) :
+    _objectClass(objectClass)
+{
+    if (objectClass)
+        _federate = objectClass->_federate;
+}
+
+HLAObjectInstance::~HLAObjectInstance()
+{
+    _clearRTIObjectInstance();
+}
+
+const std::string&
+HLAObjectInstance::getName() const
+{
+    return _name;
+}
+
+const SGWeakPtr<HLAFederate>&
+HLAObjectInstance::getFederate() const
+{
+    return _federate;
+}
+
+const SGSharedPtr<HLAObjectClass>&
+HLAObjectInstance::getObjectClass() const
+{
+    return _objectClass;
+}
+
+unsigned
+HLAObjectInstance::getNumAttributes() const
+{
+    if (!_objectClass.valid())
+        return 0;
+    return _objectClass->getNumAttributes();
+}
+
+unsigned
+HLAObjectInstance::getAttributeIndex(const std::string& name) const
+{
+    if (!_objectClass.valid())
+        return ~0u;
+    return _objectClass->getAttributeIndex(name);
+}
+
+std::string
+HLAObjectInstance::getAttributeName(unsigned index) const
+{
+    if (!_objectClass.valid())
+        return std::string();
+    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 (!_objectClass.valid())
+        return 0;
+    return _objectClass->getAttributeDataType(index);
+}
+
+HLADataElement*
+HLAObjectInstance::getAttributeDataElement(unsigned index)
+{
+    if (_attributeVector.size() <= index)
+        return 0;
+    return _attributeVector[index]._dataElement.get();
+}
+
+const HLADataElement*
+HLAObjectInstance::getAttributeDataElement(unsigned index) const
+{
+    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->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 {
+public:
+    DataElementFactoryVisitor(const HLAPathElementMap& pathElementMap) :
+        _pathElementMap(pathElementMap)
+    { }
+    DataElementFactoryVisitor(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
+        _pathElementMap(pathElementMap),
+        _path(path)
+    { }
+    virtual ~DataElementFactoryVisitor() {}
+
+    virtual void apply(const HLADataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Can not find a suitable data element for data type \""
+               << dataType.getName() << "\"");
+    }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+
+    class ArrayDataElementFactory : public HLAArrayDataElement::DataElementFactory {
+    public:
+        ArrayDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
+            _path(path)
+        {
+            for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
+                 i != pathElementMap.end(); ++i) {
+                if (i->first.begin() != std::search(i->first.begin(), i->first.end(),
+                                                    path.begin(), path.end()))
+                    break;
+                _pathElementMap.insert(*i);
+            }
+        }
+        virtual HLADataElement* createElement(const HLAArrayDataElement& element, unsigned index)
+        {
+            const HLADataType* dataType = element.getElementDataType();
+            if (!dataType)
+                return 0;
+            HLADataElement::Path path = _path;
+            path.push_back(HLADataElement::PathElement(index));
+            DataElementFactoryVisitor visitor(path, _pathElementMap);
+            dataType->accept(visitor);
+            return visitor._dataElement.release();
+        }
+    private:
+        HLADataElement::Path _path;
+        HLAPathElementMap _pathElementMap;
+    };
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+        arrayDataElement = new HLAArrayDataElement(&dataType);
+        arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_path, _pathElementMap));
+        arrayDataElement->setNumElements(dataType.getNumElements());
+
+        _dataElement = arrayDataElement;
+    }
+
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+        arrayDataElement = new HLAArrayDataElement(&dataType);
+        arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_path, _pathElementMap));
+
+        _dataElement = arrayDataElement;
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        HLADataElementFactoryVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        SGSharedPtr<HLAFixedRecordDataElement> recordDataElement;
+        recordDataElement = new HLAFixedRecordDataElement(&dataType);
+
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i) {
+
+            _path.push_back(HLADataElement::PathElement(dataType.getFieldName(i)));
+
+            dataType.getFieldDataType(i)->accept(*this);
+            recordDataElement->setField(i, _dataElement.release());
+
+            _path.pop_back();
+        }
+        _dataElement = recordDataElement;
+    }
+
+    class VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
+    public:
+        VariantRecordDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
+            _path(path)
+        {
+            for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
+                 i != pathElementMap.end(); ++i) {
+                if (i->first.begin() != std::search(i->first.begin(), i->first.end(),
+                                                    path.begin(), path.end()))
+                    break;
+                _pathElementMap.insert(*i);
+            }
+        }
+        virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
+        {
+            const HLAVariantRecordDataType* dataType = element.getDataType();
+            if (!dataType)
+                return 0;
+            const HLADataType* alternativeDataType = element.getAlternativeDataType();
+            if (!alternativeDataType)
+                return 0;
+            HLADataElement::Path path = _path;
+            path.push_back(HLADataElement::PathElement(dataType->getAlternativeName(index)));
+            DataElementFactoryVisitor visitor(path, _pathElementMap);
+            alternativeDataType->accept(visitor);
+            return visitor._dataElement.release();
+        }
+    private:
+        HLADataElement::Path _path;
+        HLAPathElementMap _pathElementMap;
+    };
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    {
+        _dataElement = createDataElement(_path, dataType);
+        if (_dataElement.valid())
+            return;
+
+        SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
+        variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
+        variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory(_path, _pathElementMap));
+
+        _dataElement = variantRecordDataElement;
+    }
+
+private:
+    SGSharedPtr<HLADataElement> createDataElement(const HLADataElement::Path& path, const HLADataType& dataType)
+    {
+        HLAPathElementMap::const_iterator i = _pathElementMap.find(path);
+        if (i == _pathElementMap.end()) {
+            SG_LOG(SG_IO, SG_WARN, "No dataElement provided for \""
+                   << HLADataElement::toString(path) << "\".");
+
+            return 0;
+        }
+        SGSharedPtr<HLADataElement> dataElement = i->second.getDataElement(path);
+        if (!dataElement->setDataType(&dataType)) {
+            SG_LOG(SG_IO, SG_ALERT, "Cannot set data type for data element at \""
+                   << HLADataElement::toString(path) <<  "\"!");
+            return 0;
+        }
+        SG_LOG(SG_IO, SG_DEBUG, "Using provided dataElement for \""
+               << HLADataElement::toString(path) << "\".");
+        return dataElement;
+    }
+
+    const HLAPathElementMap& _pathElementMap;
+    HLADataElement::Path _path;
+};
+
+void
+HLAObjectInstance::setAttribute(unsigned index, const HLAPathElementMap& pathElementMap)
+{
+    const HLADataType* dataType = getAttributeDataType(index);
+    if (!dataType) {
+        SG_LOG(SG_IO, SG_ALERT, "Cannot get attribute data type for setting attribute \""
+               << getAttributeName(index) << "\" at index " << index << "!");
+        return;
+    }
+
+    SG_LOG(SG_IO, SG_DEBUG, "Setting DataElement for attribute \""
+           << getAttributeName(index) << "\".");
+
+    DataElementFactoryVisitor visitor(pathElementMap);
+    dataType->accept(visitor);
+    setAttributeDataElement(index, visitor.getDataElement());
+}
+
+void
+HLAObjectInstance::setAttributes(const HLAAttributePathElementMap& attributePathElementMap)
+{
+    for (HLAAttributePathElementMap::const_iterator i = attributePathElementMap.begin();
+         i != attributePathElementMap.end(); ++i) {
+        setAttribute(i->first, i->second);
+    }
+}
+
+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;
+    }
+    if (!objectClass) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not register object with unknown object class!");
+        return;
+    }
+    if (_objectClass.valid() && objectClass != _objectClass.get()) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not change object class while registering!");
+        return;
+    }
+    _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;
+    }
+    _objectClass->_registerInstance(this);
+}
+
+void
+HLAObjectInstance::deleteInstance(const RTIData& tag)
+{
+    if (!_rtiObjectInstance.valid()) {
+        SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
+        return;
+    }
+    if (!_objectClass.valid())
+        return;
+    _objectClass->_deleteInstance(*this);
+    _rtiObjectInstance->deleteObjectInstance(tag);
+}
+
+void
+HLAObjectInstance::updateAttributeValues(const RTIData& tag)
+{
+    if (_attributeCallback.valid())
+        _attributeCallback->updateAttributeValues(*this, 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;
+    }
+    _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
+}
+
+void
+HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
+{
+    for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
+        reflectAttributeValue(*i, tag);
+}
+
+void
+HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
+                                          const SGTimeStamp& timeStamp, const RTIData& tag)
+{
+    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;
+    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

@@ -0,0 +1,204 @@
+// 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 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 = 0);
+    virtual ~HLAObjectInstance();
+
+    /// Return the name of this object instance
+    const std::string& getName() 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;
+
+    /// 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() {}
+        virtual void updateAttributeValues(HLAObjectInstance& objectInstance, const RTIData& tag)
+        { }
+        virtual void reflectAttributeValues(HLAObjectInstance& objectInstance,
+                                            const RTIIndexDataPairList& dataPairList, const RTIData& tag)
+        { }
+        virtual void reflectAttributeValues(HLAObjectInstance& objectInstance, const RTIIndexDataPairList& dataPairList,
+                                            const SGTimeStamp& timeStamp, const RTIData& tag)
+        { reflectAttributeValues(objectInstance, dataPairList, tag); }
+    };
+
+    void setAttributeCallback(const SGSharedPtr<AttributeCallback>& attributeCallback)
+    { _attributeCallback = attributeCallback; }
+    const SGSharedPtr<AttributeCallback>& getAttributeCallback() const
+    { return _attributeCallback; }
+
+private:
+    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;
+
+    // /// 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
+
+#endif

simgear/hla/HLAPropertyDataElement.cxx

@@ -0,0 +1,568 @@
+// 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 "HLAPropertyDataElement.hxx"
+
+#include "HLAArrayDataElement.hxx"
+#include "HLABasicDataElement.hxx"
+#include "HLADataElementVisitor.hxx"
+#include "HLADataTypeVisitor.hxx"
+#include "HLAFixedRecordDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
+
+namespace simgear {
+
+class HLAPropertyDataElement::ScalarDecodeVisitor : public HLADataTypeDecodeVisitor {
+public:
+    ScalarDecodeVisitor(HLADecodeStream& stream, SGPropertyNode& propertyNode) :
+        HLADataTypeDecodeVisitor(stream),
+        _propertyNode(propertyNode)
+    { }
+    virtual ~ScalarDecodeVisitor()
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        int8_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setIntValue(value);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        uint8_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setIntValue(value);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        int16_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setIntValue(value);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        uint16_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setIntValue(value);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        int32_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setIntValue(value);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        uint32_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setIntValue(value);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        int64_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setLongValue(value);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        uint64_t value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setLongValue(value);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        float value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setFloatValue(value);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        double value = 0;
+        dataType.decode(_stream, value);
+        _propertyNode.setDoubleValue(value);
+    }
+
+protected:
+    SGPropertyNode& _propertyNode;
+};
+
+class HLAPropertyDataElement::ScalarEncodeVisitor : public HLADataTypeEncodeVisitor {
+public:
+    ScalarEncodeVisitor(HLAEncodeStream& stream, const SGPropertyNode& propertyNode) :
+        HLADataTypeEncodeVisitor(stream),
+        _propertyNode(propertyNode)
+    { }
+    virtual ~ScalarEncodeVisitor()
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getIntValue());
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getIntValue());
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getIntValue());
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getIntValue());
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getIntValue());
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getIntValue());
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getLongValue());
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getLongValue());
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getFloatValue());
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        dataType.encode(_stream, _propertyNode.getDoubleValue());
+    }
+
+protected:
+    const SGPropertyNode& _propertyNode;
+};
+
+class HLAPropertyDataElement::ScalarDataElement : public HLABasicDataElement {
+public:
+    ScalarDataElement(const HLABasicDataType* dataType, SGPropertyNode* propertyNode);
+    virtual ~ScalarDataElement();
+
+    virtual bool encode(HLAEncodeStream& stream) const;
+    virtual bool decode(HLADecodeStream& stream);
+
+private:
+    SGSharedPtr<SGPropertyNode> _propertyNode;
+};
+
+HLAPropertyDataElement::ScalarDataElement::ScalarDataElement(const HLABasicDataType* dataType, SGPropertyNode* propertyNode) :
+    HLABasicDataElement(dataType),
+    _propertyNode(propertyNode)
+{
+}
+
+HLAPropertyDataElement::ScalarDataElement::~ScalarDataElement()
+{
+}
+
+bool
+HLAPropertyDataElement::ScalarDataElement::encode(HLAEncodeStream& stream) const
+{
+    ScalarEncodeVisitor visitor(stream, *_propertyNode);
+    _dataType->accept(visitor);
+    return true;
+}
+
+bool
+HLAPropertyDataElement::ScalarDataElement::decode(HLADecodeStream& stream)
+{
+    ScalarDecodeVisitor visitor(stream, *_propertyNode);
+    _dataType->accept(visitor);
+    return true;
+}
+
+class HLAPropertyDataElement::StringDataElement : public HLAStringDataElement {
+public:
+    StringDataElement(const HLAArrayDataType* dataType, SGPropertyNode* propertyNode);
+    virtual ~StringDataElement();
+
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i);
+
+    class Listener : public SGPropertyChangeListener {
+    public:
+        Listener(StringDataElement* stringDataElement);
+        virtual ~Listener();
+        virtual void valueChanged (SGPropertyNode * node);
+    private:
+        StringDataElement* _stringDataElement;
+    };
+
+private:
+    SGSharedPtr<SGPropertyNode> _propertyNode;
+    Listener* _listener;
+};
+
+HLAPropertyDataElement::StringDataElement::Listener::Listener(StringDataElement* stringDataElement) :
+            _stringDataElement(stringDataElement)
+{
+}
+
+HLAPropertyDataElement::StringDataElement::Listener::~Listener()
+{
+}
+
+void
+HLAPropertyDataElement::StringDataElement::Listener::valueChanged (SGPropertyNode * node)
+{
+    _stringDataElement->setValue(node->getStringValue());
+}
+
+HLAPropertyDataElement::StringDataElement::StringDataElement(const HLAArrayDataType* dataType, SGPropertyNode* propertyNode) :
+    HLAStringDataElement(dataType),
+    _propertyNode(propertyNode),
+    _listener(new Listener(this))
+{
+    _propertyNode->addChangeListener(_listener, true);
+}
+
+HLAPropertyDataElement::StringDataElement::~StringDataElement()
+{
+    _propertyNode->removeChangeListener(_listener);
+    delete _listener;
+    _listener = 0;
+}
+
+bool
+HLAPropertyDataElement::StringDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
+{
+    if (!HLAStringDataElement::decodeElement(stream, i))
+        return false;
+    if (i + 1 == getValue().size())
+        _propertyNode->setStringValue(getValue());
+    return true;
+}
+
+class HLAPropertyDataElement::DataElementFactoryVisitor : public HLADataTypeVisitor {
+public:
+    DataElementFactoryVisitor(SGPropertyNode* propertyNode) :
+        _propertyNode(propertyNode)
+    { }
+    virtual ~DataElementFactoryVisitor()
+    { }
+
+    virtual void apply(const HLADataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLA: Can not find a suitable data element for data type \""
+               << dataType.getName() << "\"");
+    }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(&dataType, _propertyNode.get());
+    }
+
+    class ArrayDataElementFactory : public HLAArrayDataElement::DataElementFactory {
+    public:
+        ArrayDataElementFactory(SGPropertyNode* propertyNode) :
+            _propertyNode(propertyNode)
+        { }
+        virtual HLADataElement* createElement(const HLAArrayDataElement& element, unsigned index)
+        {
+            const HLADataType* dataType = element.getElementDataType();
+            if (!dataType)
+                return 0;
+
+            SGPropertyNode* parent = _propertyNode->getParent();
+            DataElementFactoryVisitor visitor(parent->getChild(_propertyNode->getNameString(), index, true));
+            dataType->accept(visitor);
+            return visitor.getDataElement();
+        }
+    private:
+        SGSharedPtr<SGPropertyNode> _propertyNode;
+    };
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        if (dataType.getIsString()) {
+            _dataElement = new StringDataElement(&dataType, _propertyNode.get());
+        } else {
+            SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+            arrayDataElement = new HLAArrayDataElement(&dataType);
+            arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_propertyNode.get()));
+            arrayDataElement->setNumElements(dataType.getNumElements());
+            _dataElement = arrayDataElement;
+        }
+    }
+
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        if (dataType.getIsString()) {
+            _dataElement = new StringDataElement(&dataType, _propertyNode.get());
+        } else {
+            SGSharedPtr<HLAArrayDataElement> arrayDataElement;
+            arrayDataElement = new HLAArrayDataElement(&dataType);
+            arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_propertyNode.get()));
+            _dataElement = arrayDataElement;
+        }
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        _dataElement = new ScalarDataElement(dataType.getRepresentation(), _propertyNode.get());
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        SGSharedPtr<HLAFixedRecordDataElement> recordDataElement;
+        recordDataElement = new HLAFixedRecordDataElement(&dataType);
+
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i) {
+            DataElementFactoryVisitor visitor(_propertyNode->getChild(dataType.getFieldName(i), 0, true));
+            dataType.getFieldDataType(i)->accept(visitor);
+            recordDataElement->setField(i, visitor._dataElement.get());
+        }
+
+        _dataElement = recordDataElement;
+    }
+
+    class VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
+    public:
+        VariantRecordDataElementFactory(SGPropertyNode* propertyNode) :
+            _propertyNode(propertyNode)
+        { }
+        virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
+        {
+            const HLAVariantRecordDataType* dataType = element.getDataType();
+            if (!dataType)
+                return 0;
+            const HLADataType* alternativeDataType = element.getAlternativeDataType();
+            if (!alternativeDataType)
+                return 0;
+            DataElementFactoryVisitor visitor(_propertyNode->getChild(dataType->getAlternativeName(index), 0, true));
+            alternativeDataType->accept(visitor);
+            return visitor.getDataElement();
+        }
+    private:
+        SGSharedPtr<SGPropertyNode> _propertyNode;
+    };
+
+    virtual void apply(const HLAVariantRecordDataType& dataType)
+    {
+        SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
+        variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
+        variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory(_propertyNode.get()));
+        _dataElement = variantRecordDataElement;
+    }
+
+    HLADataElement* getDataElement()
+    { return _dataElement.release(); }
+
+private:
+    SGSharedPtr<SGPropertyNode> _propertyNode;
+    SGSharedPtr<HLADataElement> _dataElement;
+};
+
+HLAPropertyDataElement::HLAPropertyDataElement()
+{
+}
+
+HLAPropertyDataElement::HLAPropertyDataElement(SGPropertyNode* propertyNode)
+{
+    setPropertyNode(propertyNode);
+}
+
+HLAPropertyDataElement::HLAPropertyDataElement(const HLADataType* dataType, SGPropertyNode* propertyNode) :
+    _dataType(dataType)
+{
+    setPropertyNode(propertyNode);
+}
+
+HLAPropertyDataElement::HLAPropertyDataElement(const HLADataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLAPropertyDataElement::~HLAPropertyDataElement()
+{
+}
+
+void
+HLAPropertyDataElement::accept(HLADataElementVisitor& visitor)
+{
+    if (_dataElement.valid()) {
+        visitor.apply(*_dataElement);
+    } else {
+        // We cant do anything if the data type is not valid
+        if (_dataType.valid()) {
+            HLADataElementFactoryVisitor factoryVisitor;
+            _dataType->accept(factoryVisitor);
+            _dataElement = factoryVisitor.getDataElement();
+            if (_dataElement.valid()) {
+                visitor.apply(*_dataElement);
+            } else {
+                HLADataElement::accept(visitor);
+            }
+        } else {
+            HLADataElement::accept(visitor);
+        }
+    }
+}
+
+void
+HLAPropertyDataElement::accept(HLAConstDataElementVisitor& visitor) const
+{
+    if (_dataElement.valid()) {
+        visitor.apply(*_dataElement);
+    } else {
+        HLADataElement::accept(visitor);
+    }
+}
+
+bool
+HLAPropertyDataElement::encode(HLAEncodeStream& stream) const
+{
+    if (_dataElement.valid()) {
+        return _dataElement->encode(stream);
+    } else {
+        if (!_dataType.valid())
+            return false;
+        HLADataTypeEncodeVisitor visitor(stream);
+        _dataType->accept(visitor);
+        return true;
+    }
+}
+
+bool
+HLAPropertyDataElement::decode(HLADecodeStream& stream)
+{
+    if (_dataElement.valid()) {
+        return _dataElement->decode(stream);
+    } else if (!_dataType.valid()) {
+        // We cant do anything if the data type is not valid
+        return false;
+    } else {
+        HLADataElementFactoryVisitor visitor;
+        _dataType->accept(visitor);
+        _dataElement = visitor.getDataElement();
+        if (_dataElement.valid()) {
+            return _dataElement->decode(stream);
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            _dataType->accept(visitor);
+            return true;
+        }
+    }
+}
+
+const HLADataType*
+HLAPropertyDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLAPropertyDataElement::setDataType(const HLADataType* dataType)
+{
+    _dataType = dataType;
+    if (_dataType.valid() && _propertyNode.valid())
+        _dataElement = createDataElement(_dataType, _propertyNode);
+    return true;
+}
+
+void
+HLAPropertyDataElement::setPropertyNode(SGPropertyNode* propertyNode)
+{
+    _propertyNode = propertyNode;
+    if (_dataType.valid() && _propertyNode.valid())
+        _dataElement = createDataElement(_dataType, _propertyNode);
+}
+
+SGPropertyNode*
+HLAPropertyDataElement::getPropertyNode()
+{
+    return _propertyNode.get();
+}
+
+const SGPropertyNode*
+HLAPropertyDataElement::getPropertyNode() const
+{
+    return _propertyNode.get();
+}
+
+HLADataElement*
+HLAPropertyDataElement::createDataElement(const SGSharedPtr<const HLADataType>& dataType,
+                                          const SGSharedPtr<SGPropertyNode>& propertyNode)
+{
+    DataElementFactoryVisitor visitor(propertyNode);
+    dataType->accept(visitor);
+    SGSharedPtr<HLADataElement> dataElement = visitor.getDataElement();
+
+    // Copy over the content of the previous data element if there is any.
+    if (_dataElement.valid()) {
+        // FIXME is encode/decode the right tool here??
+        RTIData data;
+        HLAEncodeStream encodeStream(data);
+        if (_dataElement->encode(encodeStream)) {
+            HLADecodeStream decodeStream(data);
+            dataElement->decode(decodeStream);
+        }
+    }
+
+    return dataElement.release();
+}
+
+} // namespace simgear

simgear/hla/HLAPropertyDataElement.hxx

@@ -0,0 +1,66 @@
+// Copyright (C) 2009 - 2011  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 HLAPropertyDataElement_hxx
+#define HLAPropertyDataElement_hxx
+
+#include <simgear/props/props.hxx>
+#include "HLADataElement.hxx"
+
+namespace simgear {
+
+class HLAPropertyDataElement : public HLADataElement {
+public:
+    HLAPropertyDataElement();
+    HLAPropertyDataElement(SGPropertyNode* propertyNode);
+    HLAPropertyDataElement(const HLADataType* dataType, SGPropertyNode* propertyNode);
+    HLAPropertyDataElement(const HLADataType* dataType);
+    virtual ~HLAPropertyDataElement();
+
+    virtual void accept(HLADataElementVisitor& visitor);
+    virtual void accept(HLAConstDataElementVisitor& visitor) const;
+
+    virtual bool encode(HLAEncodeStream& stream) const;
+    virtual bool decode(HLADecodeStream& stream);
+
+    virtual const HLADataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+
+    void setPropertyNode(SGPropertyNode* propertyNode);
+    SGPropertyNode* getPropertyNode();
+    const SGPropertyNode* getPropertyNode() const;
+    
+private:
+    HLADataElement*
+    createDataElement(const SGSharedPtr<const HLADataType>& dataType, const SGSharedPtr<SGPropertyNode>& propertyNode);
+    
+    class ScalarDecodeVisitor;
+    class ScalarEncodeVisitor;
+    class ScalarDataElement;
+    class StringDecodeVisitor;
+    class StringEncodeVisitor;
+    class StringDataElement;
+    class DataElementFactoryVisitor;
+
+    SGSharedPtr<const HLADataType> _dataType;
+    SGSharedPtr<HLADataElement> _dataElement;
+    SGSharedPtr<SGPropertyNode> _propertyNode;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLARawDataElement.cxx

@@ -0,0 +1,66 @@
+// 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 "HLARawDataElement.hxx"
+
+namespace simgear {
+
+HLARawDataElement::HLARawDataElement(const HLADataType* dataType) :
+    _dataType(dataType)
+{
+}
+
+HLARawDataElement::~HLARawDataElement()
+{
+}
+
+bool
+HLARawDataElement::encode(HLAEncodeStream& stream) const
+{
+    stream.setData(_rtiData);
+    stream.skip(_rtiData.size());
+    return true;
+}
+
+bool
+HLARawDataElement::decode(HLADecodeStream& stream)
+{
+    _rtiData = stream.getData();
+    stream.skip(_rtiData.size());
+    return true;
+}
+
+const HLADataType*
+HLARawDataElement::getDataType() const
+{
+    return _dataType.get();
+}
+
+bool
+HLARawDataElement::setDataType(const HLADataType* dataType)
+{
+    _dataType = dataType;
+    return true;
+}
+
+}

simgear/hla/HLARawDataElement.hxx

@@ -0,0 +1,52 @@
+// 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.
+//
+
+#ifndef HLARawDataElement_hxx
+#define HLARawDataElement_hxx
+
+#include "RTIData.hxx"
+#include "HLADataElement.hxx"
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLARawDataElement : public HLADataElement {
+public:
+    HLARawDataElement(const HLADataType* dataType);
+    virtual ~HLARawDataElement();
+
+    virtual bool encode(HLAEncodeStream& stream) const;
+    virtual bool decode(HLADecodeStream& stream);
+
+    virtual const HLADataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+
+    const RTIData& getData() const
+    { return _rtiData; }
+    RTIData& getData()
+    { return _rtiData; }
+    void setData(const RTIData& rtiData)
+    { _rtiData = rtiData; }
+
+protected:
+    SGSharedPtr<const HLADataType> _dataType;
+    RTIData _rtiData;
+};
+
+}
+
+#endif

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.hxx

@@ -0,0 +1,31 @@
+// 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 HLAVariantDataElement_hxx
+#define HLAVariantDataElement_hxx
+
+#include "HLAVariantDataType.hxx"
+#include "HLAVariantRecordDataElement.hxx"
+
+namespace simgear {
+
+typedef HLAAbstractVariantRecordDataElement HLAAbstractVariantDataElement;
+typedef HLAVariantRecordDataElement HLAVariantDataElement;
+
+}
+
+#endif

simgear/hla/HLAVariantDataType.hxx

@@ -1,5 +1,4 @@
-// PathOptions.hxx -- make an osgDB Options object from a path
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
-// Copyright (C) 2007  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
@@ -15,16 +14,16 @@
 // 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
+#ifndef HLAVariantDataType_hxx
-#define PATHOPTIONSHXX 1
+#define HLAVariantDataType_hxx
 
-#include <osgDB/ReaderWriter>
+#include "HLAVariantRecordDataType.hxx"
-#include <simgear/misc/sg_path.hxx>
+
+namespace simgear {
+
+typedef HLAVariantRecordDataType HLAVariantDataType;
+
+} // namespace simgear
 
-namespace simgear
-{
-osgDB::ReaderWriter::Options* makeOptionsFromPath(const SGPath&);
-}
 #endif

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

@@ -0,0 +1,126 @@
+// 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 "HLAVariantRecordDataType.hxx"
+
+#include "HLADataTypeVisitor.hxx"
+#include "HLAVariantRecordDataElement.hxx"
+
+namespace simgear {
+
+HLAVariantRecordDataType::HLAVariantRecordDataType(const std::string& name) :
+    HLADataType(name)
+{
+}
+
+HLAVariantRecordDataType::~HLAVariantRecordDataType()
+{
+}
+
+void
+HLAVariantRecordDataType::accept(HLADataTypeVisitor& visitor) const
+{
+    visitor.apply(*this);
+}
+
+const HLAVariantRecordDataType*
+HLAVariantRecordDataType::toVariantRecordDataType() const
+{
+    return this;
+}
+
+void
+HLAVariantRecordDataType::releaseDataTypeReferences()
+{
+    for (AlternativeList::iterator i = _alternativeList.begin(); i != _alternativeList.end(); ++i)
+        i->_dataType = 0;
+}
+
+bool
+HLAVariantRecordDataType::decode(HLADecodeStream& stream, HLAAbstractVariantRecordDataElement& value) const
+{
+    if (!stream.alignOffsetForSize(getAlignment()))
+        return false;
+    if (!_enumeratedDataType.valid())
+        return false;
+    unsigned index = ~0u;
+    if (!_enumeratedDataType->decode(stream, index))
+        return false;
+    if (!value.setAlternativeIndex(index))
+        return false;
+    if (!value.decodeAlternative(stream))
+        return false;
+    return true;
+}
+
+bool
+HLAVariantRecordDataType::encode(HLAEncodeStream& stream, const HLAAbstractVariantRecordDataElement& value) const
+{
+    if (!stream.alignOffsetForSize(getAlignment()))
+        return false;
+    if (!_enumeratedDataType.valid())
+        return false;
+    unsigned index = value.getAlternativeIndex();
+    if (!_enumeratedDataType->encode(stream, index))
+        return false;
+    if (!value.encodeAlternative(stream))
+        return false;
+    return true;
+}
+
+void
+HLAVariantRecordDataType::setEnumeratedDataType(HLAEnumeratedDataType* dataType)
+{
+    _enumeratedDataType = dataType;
+}
+
+bool
+HLAVariantRecordDataType::addAlternative(const std::string& name, const std::string& enumerator,
+                                         const HLADataType* dataType, const std::string& semantics)
+{
+    if (!_enumeratedDataType.valid())
+        return false;
+    unsigned index = _enumeratedDataType->getIndex(enumerator);
+    if (_enumeratedDataType->getNumEnumerators() <= index)
+        return false;
+    _alternativeList.resize(_enumeratedDataType->getNumEnumerators());
+    _alternativeList[index]._name = name;
+    _alternativeList[index]._dataType = dataType;
+    _alternativeList[index]._semantics = semantics;
+    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

@@ -0,0 +1,446 @@
+// 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.
+//
+
+#ifndef RTI13Ambassador_hxx
+#define RTI13Ambassador_hxx
+
+#include <cstdlib>
+#include <list>
+#include <memory>
+#include <vector>
+#include <map>
+#include <set>
+
+#ifndef RTI_USES_STD_FSTREAM
+#define RTI_USES_STD_FSTREAM
+#endif
+
+#include <RTI.hh>
+#include <fedtime.hh>
+
+#include <simgear/debug/logstream.hxx>
+#include <simgear/structure/SGWeakReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/structure/SGWeakPtr.hxx>
+#include <simgear/timing/timestamp.hxx>
+
+#include "RTIObjectClass.hxx"
+#include "RTIData.hxx"
+#include "RTI13Federate.hxx"
+#include "RTI13ObjectInstance.hxx"
+
+namespace simgear {
+
+class RTI13Federate;
+
+class RTI13Ambassador : public SGReferenced {
+public:
+    ~RTI13Ambassador()
+    { }
+
+    void createFederationExecution(const std::string& name, const std::string& objectModel)
+    { _rtiAmbassador.createFederationExecution(name.c_str(), objectModel.c_str()); }
+    void destroyFederationExecution(const std::string& name)
+    { _rtiAmbassador.destroyFederationExecution(name.c_str()); }
+
+    RTI::FederateHandle joinFederationExecution(const std::string& federate, const std::string& federation, RTI::FederateAmbassador* federateAmbassador)
+    { return _rtiAmbassador.joinFederationExecution(federate.c_str(), federation.c_str(), federateAmbassador); }
+    void resignFederationExecution()
+    { _rtiAmbassador.resignFederationExecution(RTI::DELETE_OBJECTS_AND_RELEASE_ATTRIBUTES); }
+
+    void registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag)
+    { _rtiAmbassador.registerFederationSynchronizationPoint(label.c_str(), tag.data()); }
+    void synchronizationPointAchieved(const std::string& label)
+    { _rtiAmbassador.synchronizationPointAchieved(label.c_str()); }
+
+    void publishObjectClass(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet)
+    { _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,
+                               const SGTimeStamp& timeStamp, const RTIData& tag)
+    { _rtiAmbassador.updateAttributeValues(objectHandle, attributeValues, toFedTime(timeStamp), tag.data()); }
+    void updateAttributeValues(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandleValuePairSet& attributeValues, const RTIData& tag)
+    { _rtiAmbassador.updateAttributeValues(objectHandle, attributeValues, tag.data()); }
+
+    // RTI::EventRetractionHandle sendInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters, const RTI::FedTime& fedTime, const RTIData& tag)
+    // { return _rtiAmbassador.sendInteraction(interactionClassHandle, parameters, fedTime, tag.data()); }
+    // void sendInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters, const RTIData& tag)
+    // { _rtiAmbassador.sendInteraction(interactionClassHandle, parameters, tag.data()); }
+
+    void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const SGTimeStamp& timeStamp, const RTIData& tag)
+    { /* RTI::EventRetractionHandle h = */ _rtiAmbassador.deleteObjectInstance(objectHandle, toFedTime(timeStamp), tag.data()); }
+    void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const RTIData& tag)
+    { _rtiAmbassador.deleteObjectInstance(objectHandle, tag.data()); }
+    void localDeleteObjectInstance(const RTI::ObjectHandle& objectHandle)
+    { _rtiAmbassador.localDeleteObjectInstance(objectHandle); }
+
+    void requestObjectAttributeValueUpdate(const RTI::ObjectHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet)
+    { _rtiAmbassador.requestObjectAttributeValueUpdate(handle, attributeHandleSet); }
+    void requestClassAttributeValueUpdate(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet)
+    { _rtiAmbassador.requestClassAttributeValueUpdate(handle, attributeHandleSet); }
+
+    // Ownership Management -------------------
+
+    // bool unconditionalAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
+    // {
+    //     try {
+    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
+    //             attributeHandleSet->add(*i);
+    //         _rtiAmbassador.unconditionalAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet);
+    //         return true;
+    //     } catch (RTI::ObjectNotKnown& e) {
+    //     } catch (RTI::AttributeNotDefined& e) {
+    //     } catch (RTI::AttributeNotOwned& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::SaveInProgress& e) {
+    //     } catch (RTI::RestoreInProgress& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return false;
+    // }
+    // bool negotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
+    // {
+    //     try {
+    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
+    //             attributeHandleSet->add(*i);
+    //         _rtiAmbassador.negotiatedAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet, tag.data());
+    //         return true;
+    //     } catch (RTI::ObjectNotKnown& e) {
+    //     } catch (RTI::AttributeNotDefined& e) {
+    //     } catch (RTI::AttributeNotOwned& e) {
+    //     } catch (RTI::AttributeAlreadyBeingDivested& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::SaveInProgress& e) {
+    //     } catch (RTI::RestoreInProgress& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return false;
+    // }
+    // bool attributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles, const RTIData& tag)
+    // {
+    //     try {
+    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
+    //             attributeHandleSet->add(*i);
+    //         _rtiAmbassador.attributeOwnershipAcquisition(objectHandle, *attributeHandleSet, tag.data());
+    //         return true;
+    //     } catch (RTI::ObjectNotKnown& e) {
+    //     } catch (RTI::ObjectClassNotPublished& e) {
+    //     } catch (RTI::AttributeNotDefined& e) {
+    //     } catch (RTI::AttributeNotPublished& e) {
+    //     } catch (RTI::FederateOwnsAttributes& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::SaveInProgress& e) {
+    //     } catch (RTI::RestoreInProgress& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return false;
+    // }
+    // bool attributeOwnershipAcquisitionIfAvailable(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
+    // {
+    //     try {
+    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
+    //             attributeHandleSet->add(*i);
+    //         _rtiAmbassador.attributeOwnershipAcquisitionIfAvailable(objectHandle, *attributeHandleSet);
+    //         return true;
+    //     } catch (RTI::ObjectNotKnown& e) {
+    //     } catch (RTI::ObjectClassNotPublished& e) {
+    //     } catch (RTI::AttributeNotDefined& e) {
+    //     } catch (RTI::AttributeNotPublished& e) {
+    //     } catch (RTI::FederateOwnsAttributes& e) {
+    //     } catch (RTI::AttributeAlreadyBeingAcquired& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::SaveInProgress& e) {
+    //     } catch (RTI::RestoreInProgress& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return false;
+    // }
+    // RTIHandleSet attributeOwnershipReleaseResponse(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
+    // {
+    //     try {
+    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
+    //             attributeHandleSet->add(*i);
+    //         attributeHandleSet.reset(_rtiAmbassador.attributeOwnershipReleaseResponse(objectHandle, *attributeHandleSet));
+    //         RTIHandleSet handleSet;
+    //         RTI::ULong numAttribs = attributeHandleSet->size();
+    //         for (RTI::ULong i = 0; i < numAttribs; ++i)
+    //             handleSet.insert(attributeHandleSet->getHandle(i));
+    //         return handleSet;
+    //     } catch (RTI::ObjectNotKnown& e) {
+    //     } catch (RTI::AttributeNotDefined& e) {
+    //     } catch (RTI::AttributeNotOwned& e) {
+    //     } catch (RTI::FederateWasNotAskedToReleaseAttribute& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::SaveInProgress& e) {
+    //     } catch (RTI::RestoreInProgress& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return RTIHandleSet();
+    // }
+    // bool cancelNegotiatedAttributeOwnershipDivestiture(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
+    // {
+    //     try {
+    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
+    //             attributeHandleSet->add(*i);
+    //         _rtiAmbassador.cancelNegotiatedAttributeOwnershipDivestiture(objectHandle, *attributeHandleSet);
+    //         return true;
+    //     } catch (RTI::ObjectNotKnown& e) {
+    //     } catch (RTI::AttributeNotDefined& e) {
+    //     } catch (RTI::AttributeNotOwned& e) {
+    //     } catch (RTI::AttributeDivestitureWasNotRequested& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::SaveInProgress& e) {
+    //     } catch (RTI::RestoreInProgress& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return false;
+    // }
+    // bool cancelAttributeOwnershipAcquisition(const RTIHandle& objectHandle, const RTIHandleSet& attributeHandles)
+    // {
+    //     try {
+    //         std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(attributeHandles.size()));
+    //         for (RTIHandleSet::const_iterator i = attributeHandles.begin(); i != attributeHandles.end(); ++i)
+    //             attributeHandleSet->add(*i);
+    //         _rtiAmbassador.cancelAttributeOwnershipAcquisition(objectHandle, *attributeHandleSet);
+    //         return true;
+    //     } catch (RTI::ObjectNotKnown& e) {
+    //     } catch (RTI::AttributeNotDefined& e) {
+    //     } catch (RTI::AttributeAlreadyOwned& e) {
+    //     } catch (RTI::AttributeAcquisitionWasNotRequested& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::SaveInProgress& e) {
+    //     } catch (RTI::RestoreInProgress& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return false;
+    // }
+    // bool queryAttributeOwnership(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
+    // {
+    //     try {
+    //         _rtiAmbassador.queryAttributeOwnership(objectHandle, attributeHandle);
+    //         return true;
+    //     } 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
+
+    void enableTimeRegulation(const SGTimeStamp& lookahead)
+    {
+        RTIfedTime federateTime;
+        federateTime.setZero();
+        _rtiAmbassador.enableTimeRegulation(federateTime, toFedTime(lookahead));
+    }
+    void disableTimeRegulation()
+    { _rtiAmbassador.disableTimeRegulation();}
+
+    void enableTimeConstrained()
+    { _rtiAmbassador.enableTimeConstrained(); }
+    void disableTimeConstrained()
+    { _rtiAmbassador.disableTimeConstrained(); }
+
+    void timeAdvanceRequest(const SGTimeStamp& time)
+    { _rtiAmbassador.timeAdvanceRequest(toFedTime(time)); }
+    void timeAdvanceRequestAvailable(const SGTimeStamp& time)
+    { _rtiAmbassador.timeAdvanceRequestAvailable(toFedTime(time)); }
+    void flushQueueRequest(const SGTimeStamp& time)
+    { _rtiAmbassador.flushQueueRequest(toFedTime(time)); }
+
+    bool queryGALT(SGTimeStamp& timeStamp)
+    {
+        RTIfedTime fedTime;
+        fedTime.setPositiveInfinity();
+        _rtiAmbassador.queryLBTS(fedTime);
+        if (fedTime.isPositiveInfinity())
+            return false;
+        timeStamp = toTimeStamp(fedTime);
+        return true;
+    }
+    bool queryLITS(SGTimeStamp& timeStamp)
+    {
+        RTIfedTime fedTime;
+        fedTime.setPositiveInfinity();
+        _rtiAmbassador.queryMinNextEventTime(fedTime);
+        if (fedTime.isPositiveInfinity())
+            return false;
+        timeStamp = toTimeStamp(fedTime);
+        return true;
+    }
+    void queryFederateTime(SGTimeStamp& timeStamp)
+    {
+        RTIfedTime fedTime;
+        _rtiAmbassador.queryFederateTime(fedTime);
+        timeStamp = toTimeStamp(fedTime);
+    }
+    void modifyLookahead(const SGTimeStamp& timeStamp)
+    { _rtiAmbassador.modifyLookahead(toFedTime(timeStamp)); }
+    void queryLookahead(SGTimeStamp& timeStamp)
+    {
+        RTIfedTime fedTime;
+        _rtiAmbassador.queryLookahead(fedTime);
+        timeStamp = toTimeStamp(fedTime);
+    }
+
+    RTI::ObjectClassHandle getObjectClassHandle(const std::string& name)
+    { return _rtiAmbassador.getObjectClassHandle(name.c_str()); }
+    std::string getObjectClassName(const RTI::ObjectClassHandle& handle)
+    { return rtiToStdString(_rtiAmbassador.getObjectClassName(handle)); }
+
+    RTI::AttributeHandle getAttributeHandle(const std::string& attributeName, const RTI::ObjectClassHandle& objectClassHandle)
+    { return _rtiAmbassador.getAttributeHandle(attributeName.c_str(), objectClassHandle); }
+    std::string getAttributeName(const RTI::AttributeHandle& attributeHandle, const RTI::ObjectClassHandle& objectClassHandle)
+    { return rtiToStdString(_rtiAmbassador.getAttributeName(attributeHandle, objectClassHandle)); }
+
+    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)); }
+
+    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()); }
+    std::string getObjectInstanceName(const RTI::ObjectHandle& objectHandle)
+    { return rtiToStdString(_rtiAmbassador.getObjectInstanceName(objectHandle)); }
+
+    // RTIHandle getRoutingSpaceHandle(const std::string& routingSpaceName)
+    // {
+    //     try {
+    //         return _rtiAmbassador.getRoutingSpaceHandle(routingSpaceName.c_str());
+    //     } catch (RTI::NameNotFound& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return RTIHandle(-1);
+    // }
+    // std::string getRoutingSpaceName(const RTIHandle& routingSpaceHandle)
+    // {
+    //     std::string routingSpaceName;
+    //     try {
+    //         rtiToStdString(routingSpaceName, _rtiAmbassador.wgetRoutingSpaceName(routingSpaceHandle));
+    //     } catch (RTI::SpaceNotDefined& e) {
+    //     } catch (RTI::FederateNotExecutionMember& e) {
+    //     } catch (RTI::ConcurrentAccessAttempted& e) {
+    //     } catch (RTI::RTIinternalError& e) {
+    //     }
+    //     return routingSpaceName;
+    // }
+
+    void enableClassRelevanceAdvisorySwitch()
+    { _rtiAmbassador.enableClassRelevanceAdvisorySwitch(); }
+    void disableClassRelevanceAdvisorySwitch()
+    { _rtiAmbassador.disableClassRelevanceAdvisorySwitch(); }
+
+    void enableAttributeRelevanceAdvisorySwitch()
+    { _rtiAmbassador.enableAttributeRelevanceAdvisorySwitch(); }
+    void disableAttributeRelevanceAdvisorySwitch()
+    { _rtiAmbassador.disableAttributeRelevanceAdvisorySwitch(); }
+
+    void enableAttributeScopeAdvisorySwitch()
+    { _rtiAmbassador.enableAttributeScopeAdvisorySwitch(); }
+    void disableAttributeScopeAdvisorySwitch()
+    { _rtiAmbassador.disableAttributeScopeAdvisorySwitch(); }
+
+    void enableInteractionRelevanceAdvisorySwitch()
+    { _rtiAmbassador.enableInteractionRelevanceAdvisorySwitch(); }
+    void disableInteractionRelevanceAdvisorySwitch()
+    { _rtiAmbassador.disableInteractionRelevanceAdvisorySwitch(); }
+
+
+    bool tick()
+    { return _rtiAmbassador.tick(); }
+    bool tick(double minimum, double maximum)
+    { return _rtiAmbassador.tick(minimum, maximum); }
+
+
+    static SGTimeStamp toTimeStamp(const RTI::FedTime& fedTime)
+    {
+        RTIfedTime referenceTime(fedTime);
+        return SGTimeStamp::fromSec(referenceTime.getTime() + 0.5e-9);
+    }
+
+    static RTIfedTime toFedTime(const SGTimeStamp& timeStamp)
+    {
+        RTIfedTime referenceTime;
+        referenceTime.setZero();
+        referenceTime += timeStamp.toSecs();
+        return referenceTime;
+    }
+
+    static std::string rtiToStdString(char* n)
+    {
+        if (!n)
+            return std::string();
+        std::string s;
+        s.assign(n);
+        delete[] n;
+        return s;
+    }
+
+    // The connection class
+    RTI::RTIambassador _rtiAmbassador;
+    SGWeakPtr<RTI13Federate> _federate;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/RTI13Federate.hxx

@@ -0,0 +1,105 @@
+// Copyright (C) 2009 - 2011  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 RTI13Federate_hxx
+#define RTI13Federate_hxx
+
+#ifndef RTI_USES_STD_FSTREAM
+#define RTI_USES_STD_FSTREAM
+#endif
+
+#include <RTI.hh>
+
+#include "RTIFederate.hxx"
+#include "RTI13InteractionClass.hxx"
+#include "RTI13ObjectClass.hxx"
+#include "RTI13ObjectInstance.hxx"
+
+namespace simgear {
+
+class RTI13Ambassador;
+
+class RTI13Federate : public RTIFederate {
+public:
+    RTI13Federate(const std::list<std::string>& stringList);
+    virtual ~RTI13Federate();
+
+    /// Create a federation execution
+    /// Semantically this methods should be static,
+    virtual FederationManagementResult createFederationExecution(const std::string& federation, const std::string& objectModel);
+    virtual FederationManagementResult destroyFederationExecution(const std::string& federation);
+
+    /// Join with federateName the federation execution federation
+    virtual FederationManagementResult join(const std::string& federateType, const std::string& federation);
+    virtual bool resign();
+    virtual bool getJoined() const;
+
+    /// Synchronization Point handling
+    virtual bool registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag);
+    virtual bool getFederationSynchronizationPointAnnounced(const std::string& label);
+    virtual bool synchronizationPointAchieved(const std::string& label);
+    virtual bool getFederationSynchronized(const std::string& label);
+
+    /// Time management
+    virtual bool enableTimeConstrained();
+    virtual bool disableTimeConstrained();
+    virtual bool getTimeConstrainedEnabled();
+
+    virtual bool enableTimeRegulation(const SGTimeStamp& lookahead);
+    virtual bool disableTimeRegulation();
+    virtual bool modifyLookahead(const SGTimeStamp& timeStamp);
+    virtual bool getTimeRegulationEnabled();
+
+    virtual bool timeAdvanceRequest(const SGTimeStamp& timeStamp);
+    virtual bool timeAdvanceRequestAvailable(const SGTimeStamp& timeStamp);
+    virtual bool flushQueueRequest(const SGTimeStamp& timeStamp);
+    virtual bool getTimeAdvancePending();
+
+    virtual bool queryFederateTime(SGTimeStamp& timeStamp);
+    virtual bool queryLookahead(SGTimeStamp& timeStamp);
+    virtual bool queryGALT(SGTimeStamp& timeStamp);
+    virtual bool queryLITS(SGTimeStamp& timeStamp);
+
+    /// Process messages
+    virtual bool processMessage();
+    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);
+
+private:
+    RTI13Federate(const RTI13Federate&);
+    RTI13Federate& operator=(const RTI13Federate&);
+
+    /// The federate handle
+    RTI::FederateHandle _federateHandle;
+    bool _joined;
+
+    /// RTI connection
+    SGSharedPtr<RTI13Ambassador> _ambassador;
+
+    /// Callbacks from the rti are handled here.
+    struct FederateAmbassador;
+    FederateAmbassador* _federateAmbassador;
+};
+
+}
+
+#endif

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