Mac changes for Subversion bundling.

Make dependent template lookups explicit.
Clang (in Xcode 4.4) is being strict about dependent lookup rules, so apply the recommended fix-it.
2012-08-12 16:59:31 +01:00 · 2012-07-31 09:01:42 +01:00 · 2012-07-16 20:06:53 +02:00 · 2012-07-14 13:00:30 +02:00 · 2012-07-13 20:00:06 +01:00 · 2012-07-13 17:53:00 +02:00
411 changed files with 28230 additions and 17429 deletions
@@ -1,25 +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
@@ -1,8 +1,8 @@
-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 2.6.4)
 include (CheckFunctionExists)
 include (CheckIncludeFile)
 include (CheckCXXSourceCompiles)
-include (CPack)
+
 project(SimGear)
@@ -10,19 +10,78 @@ project(SimGear)
 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
-option(ENABLE_LIBSVN "Set to ON to build SimGear with libsvnclient support" OFF)
+      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
      FORCE)
 endif(NOT CMAKE_BUILD_TYPE)
-set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+# Determine name of library installation directory, i.e. "lib" vs "lib64", which
 # differs between all Debian-based vs all other Linux distros.
 # See cmake bug #11964, http://cmake.org/gitweb?p=cmake.git;a=commit;h=126c993d
 # GNUInstallDirs requires CMake >= 2.8.5, use own file for older cmake
 if(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
  include(GNUInstallDirs)
 else(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
  include(OldGNUInstallDirs)
 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}")
@@ -42,6 +101,7 @@ if (MSVC AND MSVC_3RDPARTY_ROOT)
  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)
@@ -50,52 +110,90 @@ 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.1 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 "libsvn found, enabling in SimGear")
+        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)
-# See if we have any rti library variant installed
+if(ENABLE_RTI)
-find_package(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(
@@ -104,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)
    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
@@ -142,6 +261,21 @@ configure_file (
  "${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)
@@ -154,5 +288,3 @@ CONFIGURE_FILE(
  IMMEDIATE @ONLY)
 ADD_CUSTOM_TARGET(uninstall
  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.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)
@@ -3,6 +3,35 @@
 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) 
@@ -16,33 +45,37 @@ if(HAVE_APR_CONFIG)
        OUTPUT_STRIP_TRAILING_WHITESPACE)
 # clean up some vars, or other CMake pieces complain
-	string(STRIP ${RAW_APR_LIBS} APR_LIBS)
+	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)
-find_path(LIBSVN_INCLUDE_DIR svn_client.h
+if(HAVE_APR_CONFIG OR MSVC)
 	find_path(LIBSVN_INCLUDE_DIR svn_client.h
      NO_DEFAULT_PATH
 	  HINTS
-  $ENV{LIBSVN_DIR}
+	  $ENV{LIBSVN_DIR} ${CMAKE_INSTALL_PREFIX}
 	  PATH_SUFFIXES include/subversion-1
 	  PATHS
      /opt/local
 	  /usr/local
 	  /usr
-  /opt
+	)
 )
-check_library_exists(svn_client-1 svn_client_checkout "" HAVE_LIB_SVNCLIENT)
+	set(LIBSVN_LIBRARIES "")
-check_library_exists(svn_subr-1 svn_cmdline_init "" HAVE_LIB_SVNSUBR)
+	if (MSVC)
-check_library_exists(svn_ra-1 svn_ra_initialize "" HAVE_LIB_SVNRA)
+		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)
+	include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG 
+	FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG LIBSVN_LIBRARIES LIBSVN_INCLUDE_DIR)
-    HAVE_LIB_SVNSUBR 
+        if(NOT LIBSVN_FOUND)
-    HAVE_LIB_SVNCLIENT
+		set(LIBSVN_LIBRARIES "")
-    HAVE_LIB_SVNRA 
+        endif(NOT LIBSVN_FOUND)
-    LIBSVN_INCLUDE_DIR)
+endif(HAVE_APR_CONFIG OR MSVC)
 if(LIBSVN_FOUND)
    set(LIBSVN_LIBRARIES "svn_client-1" "svn_subr-1" "svn_ra-1" ${APR_LIBS})
 endif(LIBSVN_FOUND)
@@ -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()
@@ -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()
@@ -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.
@@ -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
@@ -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
@@ -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.
@@ -3,8 +3,7 @@
 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:
@@ -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.
@@ -1 +0,0 @@
 03/25/2001 - Resolve location of Sky dome implimentation documentation.
@@ -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
 ])
@@ -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\
@@ -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 "======================================"
@@ -1,670 +0,0 @@
 dnl Process this file with autogen.sh to produce a working configure
 dnl script.
 AC_INIT(SimGear, m4_esyscmd([cat ./version | tr -d '\n']), [http://www.flightgear.org])
 dnl Ensure touching the version causes autoconf to re-run
 AC_SUBST([CONFIGURE_DEPENDENCIES], ['$(top_srcdir)/version'])
 AC_CONFIG_SRCDIR([simgear/bucket/newbucket.cxx])
 dnl Require at least automake 2.52
 AC_PREREQ(2.52)
 dnl Initialize the automake stuff
 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
 ])
 dnl set the $host variable based on local machine/os
 AC_CANONICAL_TARGET
 AM_INIT_AUTOMAKE([dist-bzip2])
 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
 # specify the rti13 location
 AC_ARG_WITH(rti13, [  --with-rti13=PREFIX       Specify the prefix path to a HLA13 rti])
 if test "x$with_rti13" != "x" ; then
    echo "rti13 prefix is $with_rti13"
    EXTRA_DIRS="${EXTRA_DIRS} $with_rti13"
 fi
 # specify the rti13 location
 AC_ARG_WITH(rti1516, [  --with-rti1516=PREFIX     Specify the prefix path to a HLA1516 rti])
 if test "x$with_rti1516" != "x" ; then
    echo "rti1516 prefix is $with_rti1516"
    EXTRA_DIRS="${EXTRA_DIRS} $with_rti1516"
 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
 dnl Check for a HLA13 rti.
 dnl This is really tricky because of the ancient iostream stuff in RTI13
 saved_CPPFLAGS="$CPPFLAGS"
 CPPFLAGS="$CPPFLAGS -DRTI_USES_STD_FSTREAM"
 AC_CHECK_HEADER(RTI.hh)
 CPPFLAGS="${saved_CPPFLAGS}"
 dnl Up to now only RTI13
 AM_CONDITIONAL(ENABLE_HLA, test "x$ac_cv_header_RTI_hh" = "xyes")
 AM_CONDITIONAL(ENABLE_HLA13, test "x$ac_cv_header_RTI_hh" = "xyes")
 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 Check for Subversion library support
 # libsvn support defaults to yes
 save_LIBS=$LIBS
 save_CPPFLAGS=$CPPFLAGS
 AC_ARG_WITH(libsvn, [  --without-libsvn        Do not use built-in subversion (libsvn) for simgear [default=no]], [], [with_libsvn=yes])
 if test "x$with_libsvn" = "xyes"; then
    LIBS="`apr-1-config --link-ld`"
    CPPFLAGS="-I/usr/include/subversion-1 `apr-1-config --includes --cppflags`"
    AC_CHECK_HEADERS([svn_client.h])
       if test "x$ac_cv_header_svn_client_h" = "xyes"; then
 	echo "Using built-in subversion (libsvn) for scenery downloads."
 	AC_SEARCH_LIBS(svn_client_checkout, svn_client-1,
 	               [AC_DEFINE([HAVE_LIBSVN_CLIENT_1], [1], [Define to 1 if you have libsvn_client-1])],
 	               [AC_MSG_ERROR(svn_client-1 library not found.)],)
 	AC_SEARCH_LIBS(svn_cmdline_init, svn_subr-1, , [AC_MSG_ERROR(svn_subr-1 library not found.)],)
 	AC_SEARCH_LIBS(svn_ra_initialize, svn_ra-1, , [AC_MSG_ERROR(svn_ra-1 library not found.)],)
 	svn_LIBS=$LIBS
 	svn_CPPFLAGS=$CPPFLAGS
 	AC_SUBST(svn_LIBS)
 	AC_SUBST(svn_CPPFLAGS)
       else
 	echo "Libsvn not found. Will use command line subversion for scenery downloads."
 	svn_LIBS=""
 	svn_CPPFLAGS=""
       fi
 else
 echo "Libsvn explicitly disabled. Will use command line subversion for scenery downloads."
  svn_LIBS=""
  svn_CPPFLAGS=""
 fi
 LIBS=$save_LIBS
 CPPFLAGS=$save_CPPFLAGS
 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/hla/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/scene/tsync/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
@@ -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.)
@@ -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!
@@ -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
@@ -1,2 +0,0 @@
 The handmade VS2010 project files have been replaced by the Cmake build system.
 Please use Cmake to build FlightGear with Visual Studio 2010.
@@ -1,3 +0,0 @@
 *.user
 Win32
 x64
@@ -1,4 +1,2 @@
 simgear_config.h
 simgear_config.h.*
 stamp-h1
 version.h
@@ -5,14 +5,12 @@ foreach( mylibfolder
        bucket
        debug
        ephemeris
        hla
        io
        magvar
        math
        misc
        nasal
        props
        route
        serial
        structure
        threads
@@ -24,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 SimGear PROPERTY PUBLIC_HEADER "${publicHeaders}")
    set_property(TARGET SimGear PROPERTY LINKER_LANGUAGE CXX)
-    target_link_libraries(SimGear ${ZLIB_LIBRARY} 
+  # set_property(TARGET SimGearCore PROPERTY FRAMEWORK 1)
  #  message(STATUS "public header: ${publicHeaders}")
  #  set_property(TARGET SimGearCore PROPERTY PUBLIC_HEADER "${publicHeaders}")
    set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
    set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
    set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
    target_link_libraries(SimGearCore ${ZLIB_LIBRARY} ${RT_LIBRARY})
    install(TARGETS SimGearCore LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
    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})
+            ${OPENGL_LIBRARY}
            ${JPEG_LIBRARY})
-    install(TARGETS SimGear LIBRARY DESTINATION lib${LIB_SUFFIX}
+        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
-                            PUBLIC_HEADER DESTINATION include/simgear)
+    endif()
 else()
    message(STATUS "Library building mode: STATIC LIBRARIES")
 endif(SIMGEAR_SHARED)
@@ -1,50 +0,0 @@
 if ENABLE_HLA
 HLA_DIR = hla
 else
 HLA_DIR =
 endif
 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 \
 	$(HLA_DIR) \
 	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
@@ -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)
@@ -1,14 +0,0 @@
 includedir = @includedir@/compatibility/
 include_HEADERS	= \
 	iostream \
 	strstream \
 	sstream \
 	istream \
 	fstream \
 	iterator \
 	iomanip \
 	new \
 	streambuf \
 	\
 	irix_string
@@ -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
@@ -1,3 +0,0 @@
 SUBDIRS = $(MIPSpro_DIRS)
 DIST_SUBDIRS = MIPSpro721 MIPSpro740
@@ -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)
@@ -1,5 +1,5 @@
 /** \file debug_types.h
- *  Define the various logging classes and prioritiess
+ *  Define the various logging classes and priorities
 */
 /** 
@@ -27,7 +27,10 @@ typedef enum {
    SG_NASAL       = 0x00010000,
    SG_INSTR       = 0x00020000,
    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
 } sgDebugClass;
@@ -4,4 +4,20 @@ include (SimGearComponent)
 set(HEADERS metar.hxx precipitation.hxx)
 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)
@@ -1,9 +0,0 @@
 includedir = @includedir@/environment
 lib_LIBRARIES = libsgenvironment.a
 include_HEADERS = metar.hxx precipitation.hxx
 libsgenvironment_a_SOURCES = metar.cxx precipitation.cxx
 INCLUDES = -I$(top_srcdir)
@@ -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])) {
 		for (int i = 0; i < 4; i++)
 			_icao[i] = toupper(m[i]);
 		_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.
@@ -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
@@ -29,6 +29,7 @@
 #include <simgear/constants.h>
 #include <osg/ClipNode>
 #include <simgear/scene/util/RenderConstants.hxx>
 /**
 * @brief SGPrecipitation constructor
@@ -79,6 +80,8 @@ osg::Group* SGPrecipitation::build(void)
        group->addChild(_precipitationEffect.get());
    }
    group->setNodeMask( ~(simgear::CASTSHADOW_BIT | simgear::MODELLIGHT_BIT) );
    return group;
 }
@@ -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;
 }
@@ -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)
@@ -7,6 +7,7 @@ set(HLA_HEADERS
    HLABasicDataElement.hxx
    HLABasicDataType.hxx
    HLADataElement.hxx
    HLADataElementVisitor.hxx
    HLADataType.hxx
    HLADataTypeVisitor.hxx
    HLAEnumeratedDataElement.hxx
@@ -21,23 +22,25 @@ set(HLA_HEADERS
    HLAOMTXmlVisitor.hxx
    HLAPropertyDataElement.hxx
    HLARawDataElement.hxx
    HLATypes.hxx
    HLAVariantDataElement.hxx
    HLAVariantDataType.hxx
    HLAVariantRecordDataElement.hxx
    HLAVariantRecordDataType.hxx
    )
 set(HLA_SOURCES
    RTIObjectClass.cxx
    RTIObjectInstance.cxx
    RTIFederate.cxx
    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
@@ -45,21 +48,29 @@ set(HLA_SOURCES
    HLAOMTXmlVisitor.cxx
    HLAPropertyDataElement.cxx
    HLARawDataElement.cxx
-    HLAVariantDataElement.cxx
+    HLAVariantRecordDataElement.cxx
-    HLAVariantDataType.cxx
+    HLAVariantRecordDataType.cxx
    )
 simgear_component(hla hla "${HLA_SOURCES}" "${HLA_HEADERS}")
 if(RTI_FOUND)
-  set(HLA13_HEADERS
+  set(RTI13_SOURCES
-    HLA13Federate.hxx
+    RTI13InteractionClass.cxx
    )
  set(HLA13_SOURCES
    RTI13ObjectClass.cxx
    RTI13ObjectInstance.cxx
    RTI13Federate.cxx
-    HLA13Federate.cxx
+    RTI13FederateFactory.cxx
    )
-  simgear_component(hla13 hla "${HLA13_SOURCES}" "${HLA13_HEADERS}")
+  simgear_component(rti13 hla "${RTI13_SOURCES}" "")
-  set_property(TARGET sghla13 APPEND PROPERTY COMPILE_FLAGS "-I${RTI_INCLUDE_DIR}")
+  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}" "")
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,10 +15,18 @@
 // 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) :
@@ -30,6 +38,18 @@ HLAAbstractArrayDataElement::~HLAAbstractArrayDataElement()
 {
 }
 void
 HLAAbstractArrayDataElement::accept(HLADataElementVisitor& visitor)
 {
    visitor.apply(*this);
 }
 void
 HLAAbstractArrayDataElement::accept(HLAConstDataElementVisitor& visitor) const
 {
    visitor.apply(*this);
 }
 bool
 HLAAbstractArrayDataElement::decode(HLADecodeStream& stream)
 {
@@ -85,6 +105,7 @@ HLAArrayDataElement::HLAArrayDataElement(const HLAArrayDataType* dataType) :
 HLAArrayDataElement::~HLAArrayDataElement()
 {
    clearStamp();
 }
 bool
@@ -96,6 +117,7 @@ HLAArrayDataElement::setNumElements(unsigned size)
    _elementVector.resize(size);
    for (unsigned i = oldSize; i < size; ++i)
        _elementVector[i] = newElement(i);
    setDirty(true);
    return true;
 }
@@ -157,7 +179,12 @@ HLAArrayDataElement::setElement(unsigned index, HLADataElement* value)
        for (unsigned j = oldSize; j < index; ++j)
            _elementVector[j] = newElement(j);
    }
    if (_elementVector[index].valid())
        _elementVector[index]->clearStamp();
    _elementVector[index] = value;
    if (value)
        value->attachStamp(*this);
    setDirty(true);
 }
 void
@@ -172,12 +199,27 @@ HLAArrayDataElement::getDataElementFactory()
    return _dataElementFactory.get();
 }
 void
 HLAArrayDataElement::_setStamp(Stamp* stamp)
 {
    HLAAbstractArrayDataElement::_setStamp(stamp);
    for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
        if (!i->valid())
            continue;
        (*i)->attachStamp(*this);
    }
 }
 HLADataElement*
 HLAArrayDataElement::newElement(unsigned index)
 {
    if (!_dataElementFactory.valid())
        return 0;
-    return _dataElementFactory->createElement(*this, index);
+    HLADataElement* dataElement = _dataElementFactory->createElement(*this, index);
    if (!dataElement)
        return 0;
    dataElement->attachStamp(*this);
    return dataElement;
 }
 ////////////////////////////////////////////////////////////////////////
@@ -189,6 +231,7 @@ HLAVariantArrayDataElement::HLAVariantArrayDataElement() :
 HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
 {
    clearStamp();
 }
 bool
@@ -199,8 +242,8 @@ HLAVariantArrayDataElement::setDataType(const HLADataType* dataType)
        SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
        return false;
    }
-    const HLAVariantDataType* variantDataType = arrayDataType->getElementDataType()->toVariantDataType();
+    const HLAVariantRecordDataType* variantRecordDataType = arrayDataType->getElementDataType()->toVariantRecordDataType();
-    if (!variantDataType) {
+    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;
    }
@@ -217,13 +260,14 @@ HLAVariantArrayDataElement::setNumElements(unsigned size)
    _elementVector.resize(size);
    for (unsigned i = oldSize; i < size; ++i)
        _elementVector[i] = newElement();
    setDirty(true);
    return true;
 }
 bool
 HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
 {
-    HLAVariantDataElement* dataElement = getElement(i);
+    HLAVariantRecordDataElement* dataElement = getElement(i);
    if (!dataElement)
        return false;
    return dataElement->decode(stream);
@@ -244,7 +288,7 @@ HLAVariantArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) c
    return dataElement->encode(stream);
 }
-const HLAVariantDataElement*
+const HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::getElement(unsigned index) const
 {
    if (_elementVector.size() <= index)
@@ -252,7 +296,7 @@ HLAVariantArrayDataElement::getElement(unsigned index) const
    return _elementVector[index].get();
 }
-HLAVariantDataElement*
+HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::getElement(unsigned index)
 {
    if (_elementVector.size() <= index)
@@ -260,7 +304,7 @@ HLAVariantArrayDataElement::getElement(unsigned index)
    return _elementVector[index].get();
 }
-HLAVariantDataElement*
+HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
 {
    if (_elementVector.size() <= index)
@@ -270,7 +314,7 @@ HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
 }
 void
-HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantDataElement* value)
+HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantRecordDataElement* value)
 {
    unsigned oldSize = _elementVector.size();
    if (oldSize <= index) {
@@ -278,7 +322,12 @@ HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantDataElement* va
        for (unsigned j = oldSize; j < index; ++j)
            _elementVector[j] = newElement();
    }
    if (_elementVector[index].valid())
        _elementVector[index]->clearStamp();
    _elementVector[index] = value;
    if (value)
        value->attachStamp(*this);
    setDirty(true);
 }
 void
@@ -293,7 +342,18 @@ HLAVariantArrayDataElement::getAlternativeDataElementFactory()
    return _alternativeDataElementFactory.get();
 }
-HLAVariantDataElement*
+void
 HLAVariantArrayDataElement::_setStamp(Stamp* stamp)
 {
    HLAAbstractArrayDataElement::_setStamp(stamp);
    for (ElementVector::iterator i = _elementVector.begin(); i != _elementVector.end(); ++i) {
        if (!i->valid())
            continue;
        (*i)->attachStamp(*this);
    }
 }
 HLAVariantRecordDataElement*
 HLAVariantArrayDataElement::newElement()
 {
    const HLAArrayDataType* arrayDataType = getDataType();
@@ -302,12 +362,13 @@ HLAVariantArrayDataElement::newElement()
    const HLADataType* elementDataType = arrayDataType->getElementDataType();
    if (!elementDataType)
        return 0;
-    const HLAVariantDataType* variantDataType = elementDataType->toVariantDataType();
+    const HLAVariantRecordDataType* variantRecordDataType = elementDataType->toVariantRecordDataType();
-    if (!variantDataType)
+    if (!variantRecordDataType)
        return 0;
-    HLAVariantDataElement* variantDataElement = new HLAVariantDataElement(variantDataType);
+    HLAVariantRecordDataElement* variantRecordDataElement = new HLAVariantRecordDataElement(variantRecordDataType);
-    variantDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
+    variantRecordDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
-    return variantDataElement;
+    variantRecordDataElement->attachStamp(*this);
    return variantRecordDataElement;
 }
 }
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -23,7 +23,7 @@
 #include <simgear/math/SGMath.hxx>
 #include "HLAArrayDataType.hxx"
 #include "HLADataElement.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 #include "HLADataTypeVisitor.hxx"
 namespace simgear {
@@ -33,6 +33,9 @@ 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;
@@ -75,6 +78,9 @@ public:
    void setDataElementFactory(DataElementFactory* dataElementFactory);
    DataElementFactory* getDataElementFactory();
 protected:
    virtual void _setStamp(Stamp* stamp);
 private:
    HLADataElement* newElement(unsigned index);
@@ -99,20 +105,23 @@ public:
    virtual unsigned getNumElements() const;
    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
-    const HLAVariantDataElement* getElement(unsigned index) const;
+    const HLAVariantRecordDataElement* getElement(unsigned index) const;
-    HLAVariantDataElement* getElement(unsigned index);
+    HLAVariantRecordDataElement* getElement(unsigned index);
-    HLAVariantDataElement* getOrCreateElement(unsigned index);
+    HLAVariantRecordDataElement* getOrCreateElement(unsigned index);
-    void setElement(unsigned index, HLAVariantDataElement* value);
+    void setElement(unsigned index, HLAVariantRecordDataElement* value);
-    typedef HLAVariantDataElement::DataElementFactory AlternativeDataElementFactory;
+    typedef HLAVariantRecordDataElement::DataElementFactory AlternativeDataElementFactory;
    void setAlternativeDataElementFactory(AlternativeDataElementFactory* alternativeDataElementFactory);
    AlternativeDataElementFactory* getAlternativeDataElementFactory();
-private:
+protected:
-    HLAVariantDataElement* newElement();
+    virtual void _setStamp(Stamp* stamp);
-    typedef std::vector<SGSharedPtr<HLAVariantDataElement> > ElementVector;
+private:
    HLAVariantRecordDataElement* newElement();
    typedef std::vector<SGSharedPtr<HLAVariantRecordDataElement> > ElementVector;
    ElementVector _elementVector;
    SGSharedPtr<AlternativeDataElementFactory> _alternativeDataElementFactory;
@@ -130,7 +139,7 @@ public:
    const std::string& getValue() const
    { return _value; }
    void setValue(const std::string& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
    virtual bool setNumElements(unsigned count)
    {
@@ -207,11 +216,11 @@ public:
    const SGVec2<T>& getValue() const
    { return _value; }
    void setValue(const SGVec2<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
    virtual bool setNumElements(unsigned count)
    {
-        for (unsigned i = 2; i < count; ++i)
+        for (unsigned i = count; i < 2; ++i)
            _value[i] = 0;
        return true;
    }
@@ -248,6 +257,43 @@ 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:
@@ -262,11 +308,11 @@ public:
    const SGVec3<T>& getValue() const
    { return _value; }
    void setValue(const SGVec3<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
    virtual bool setNumElements(unsigned count)
    {
-        for (unsigned i = 3; i < count; ++i)
+        for (unsigned i = count; i < 3; ++i)
            _value[i] = 0;
        return true;
    }
@@ -303,6 +349,43 @@ 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:
@@ -317,11 +400,11 @@ public:
    const SGVec4<T>& getValue() const
    { return _value; }
    void setValue(const SGVec4<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
    virtual bool setNumElements(unsigned count)
    {
-        for (unsigned i = 4; i < count; ++i)
+        for (unsigned i = count; i < 4; ++i)
            _value[i] = 0;
        return true;
    }
@@ -358,6 +441,43 @@ 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:
@@ -372,11 +492,11 @@ public:
    const SGQuat<T>& getValue() const
    { return _value; }
    void setValue(const SGQuat<T>& value)
-    { _value = value; }
+    { _value = value; setDirty(true); }
    virtual bool setNumElements(unsigned count)
    {
-        for (unsigned i = 4; i < count; ++i)
+        for (unsigned i = count; i < 4; ++i)
            _value[i] = 0;
        return true;
    }
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLAArrayDataType.hxx"
 #include "HLAArrayDataElement.hxx"
@@ -22,7 +28,9 @@
 namespace simgear {
 HLAArrayDataType::HLAArrayDataType(const std::string& name) :
-    HLADataType(name)
+    HLADataType(name),
    _isOpaque(false),
    _isString(false)
 {
 }
@@ -42,15 +50,40 @@ HLAArrayDataType::toArrayDataType() const
    return this;
 }
 void
 HLAArrayDataType::releaseDataTypeReferences()
 {
    _elementDataType = 0;
    HLADataType::releaseDataTypeReferences();
 }
 void
 HLAArrayDataType::setElementDataType(const HLADataType* elementDataType)
 {
    // FIXME this only works if we do not reset the alignment to something smaller
    if (getAlignment() < elementDataType->getAlignment())
        setAlignment(elementDataType->getAlignment());
    _elementDataType = elementDataType;
 }
 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) :
@@ -146,13 +179,20 @@ HLAVariableArrayDataType::encode(HLAEncodeStream& stream, const HLAAbstractArray
 }
 void
-HLAVariableArrayDataType::setSizeDataType(const HLADataType* sizeDataType)
+HLAVariableArrayDataType::setSizeDataType(const HLABasicDataType* sizeDataType)
 {
    // FIXME this only works if we do not reset the alignment to something smaller
    if (getAlignment() < sizeDataType->getAlignment())
        setAlignment(sizeDataType->getAlignment());
    _sizeDataType = sizeDataType;
-    // setAlignment(SGMisc<unsigned>::max(_sizeDataType->getAlignment(), _elementDataType->getAlignment());
+}
 void
 HLAVariableArrayDataType::_recomputeAlignmentImplementation()
 {
    unsigned alignment = 1;
    if (const HLADataType* dataType = getElementDataType())
        alignment = std::max(alignment, dataType->getAlignment());
    if (const HLADataType* dataType = getSizeDataType())
        alignment = std::max(alignment, dataType->getAlignment());
    setAlignment(alignment);
 }
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -35,6 +35,8 @@ public:
    virtual const HLAArrayDataType* toArrayDataType() const;
    virtual void releaseDataTypeReferences();
    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const = 0;
    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const = 0;
@@ -42,8 +44,21 @@ public:
    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 {
@@ -75,12 +90,15 @@ public:
    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
-    void setSizeDataType(const HLADataType* sizeDataType);
+    void setSizeDataType(const HLABasicDataType* sizeDataType);
-    const HLADataType* getSizeDataType() const
+    const HLABasicDataType* getSizeDataType() const
    { return _sizeDataType.get(); }
 protected:
    virtual void _recomputeAlignmentImplementation();
 private:
-    SGSharedPtr<const HLADataType> _sizeDataType;
+    SGSharedPtr<const HLABasicDataType> _sizeDataType;
 };
 } // namespace simgear
@@ -15,8 +15,15 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLABasicDataElement.hxx"
 #include "HLADataElementVisitor.hxx"
 #include "HLADataTypeVisitor.hxx"
 namespace simgear {
@@ -30,6 +37,18 @@ HLABasicDataElement::~HLABasicDataElement()
 {
 }
 void
 HLABasicDataElement::accept(HLADataElementVisitor& visitor)
 {
    visitor.apply(*this);
 }
 void
 HLABasicDataElement::accept(HLAConstDataElementVisitor& visitor) const
 {
    visitor.apply(*this);
 }
 const HLABasicDataType*
 HLABasicDataElement::getDataType() const
 {
@@ -112,6 +131,7 @@ void
 HLA##type##DataElement::setValue(ctype value)                                                     \
 {                                                                                                 \
    _value = value;                                                                               \
    setDirty(true);                                                                               \
 }
 IMPLEMENT_TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);
@@ -28,6 +28,12 @@ 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);
@@ -41,6 +47,7 @@ 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);                             \
                                                                              \
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLABasicDataType.hxx"
 #include "HLADataType.hxx"
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,10 +15,18 @@
 // 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()
@@ -129,6 +137,63 @@ 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)
 {
@@ -138,11 +203,11 @@ HLADataElement::toString(const Path& path)
    return s;
 }
-HLADataElement::AttributePathPair
+HLADataElement::StringPathPair
-HLADataElement::toAttributePathPair(const std::string& s)
+HLADataElement::toStringPathPair(const std::string& s)
 {
    Path path;
-    // Skip the initial attribute name if given
+    // Skip the initial attribute/parameter name if given
    std::string::size_type i = s.find_first_of("[.");
    std::string attribute = s.substr(0, i);
    while (i < s.size()) {
@@ -157,7 +222,7 @@ HLADataElement::toAttributePathPair(const std::string& s)
                if (10 <= v) {
                    SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid character in array subscript for \""
                           << s << "\" at \"" << attribute << toString(path) << "\"!");
-                    return AttributePathPair();
+                    return StringPathPair();
                }
                index *= 10;
                index += v;
@@ -172,7 +237,7 @@ HLADataElement::toAttributePathPair(const std::string& s)
            if (s.size() <= ++i) {
                SG_LOG(SG_NETWORK, SG_WARN, "HLADataElement: invalid terminating '.' for \""
                       << s << "\"!");
-                return AttributePathPair();
+                return StringPathPair();
            }
            std::string::size_type e = s.find_first_of("[.", i);
            path.push_back(s.substr(i, e - i));
@@ -181,7 +246,13 @@ HLADataElement::toAttributePathPair(const std::string& s)
        }
    }
-    return AttributePathPair(attribute, path);
+    return StringPathPair(attribute, path);
 }
 void
 HLADataElement::_setStamp(HLADataElement::Stamp* stamp)
 {
    _stamp = stamp;
 }
 }
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// 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
@@ -30,44 +30,46 @@ 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;
-    // Container for the timestamp the originating attribute was last updated for
+    /// Returns the time stamp if this data element.
-    // class TimeStamp : public SGReferenced {
+    /// Do not access this getter if the getTimeStampValid() method returns false.
-    // public:
+    const SGTimeStamp& getTimeStamp() const
-    //     const SGTimeStamp& getTimeStamp() const
+    { return _stamp->getTimeStamp(); }
-    //     { return _timeStamp; }
+    void setTimeStamp(const SGTimeStamp& timeStamp);
    //     void setTimeStamp(const SGTimeStamp& timeStamp)
    //     { _timeStamp = timeStamp; }
    // private:
    //     SGTimeStamp _timeStamp;
    // };
-    // const TimeStamp* getTimeStamp() const
+    bool getTimeStampValid() const
-    // { return _timeStamp.get(); }
+    { if (!_stamp.valid()) return false; return _stamp->getTimeStampValid(); }
-    // void setTimeStamp(const TimeStamp* timeStamp)
+    void setTimeStampValid(bool timeStampValid);
    // { _timeStamp = timeStamp; }
-    // struct ChangeCount : public SGReferenced {
+    /// Convenience function that gives the time difference in seconds to a given timestamp
-    //     ChangeCount() : _value(0) {}
+    /// This function returns 0 if the timestamp is not valid.
-    //     unsigned _value;
+    double getTimeDifference(const SGTimeStamp& timeStamp) const;
-    // };
+
-    // SGSharedPtr<ChangeCount> _changeCount;
+    /// Dirty tracking of the attribute/parameter that this data element belongs to
-    // unsigned getChangeCount() const
+    bool getDirty() const
-    // {
+    { if (!_stamp.valid()) return true; return _stamp->getDirty(); }
-    //     // If we don't have return allways the same
+    void setDirty(bool dirty)
-    //     if (!_changeCount.valid())
+    { if (!_stamp.valid()) return; _stamp->setDirty(dirty); }
-    //         return 0;
+
-    //     return _changeCount->_value;
+    /// 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
@@ -144,18 +146,55 @@ public:
        SGSharedPtr<Data> _data;
    };
    typedef std::list<PathElement> Path;
-    typedef std::pair<std::string, Path> AttributePathPair;
+    typedef std::pair<std::string, Path> StringPathPair;
    typedef StringPathPair AttributePathPair; // deprecated
    typedef std::pair<unsigned, Path> IndexPathPair;
    static std::string toString(const Path& path);
-    static std::string toString(const AttributePathPair& path)
+    static std::string toString(const StringPathPair& path)
    { return path.first + toString(path.second); }
-    static AttributePathPair toAttributePathPair(const std::string& s);
+    static StringPathPair toStringPathPair(const std::string& s);
    static AttributePathPair toAttributePathPair(const std::string& s) // deprecated
    { return toStringPathPair(s); }
    static Path toPath(const std::string& s)
-    { return toAttributePathPair(s).second; }
+    { return toStringPathPair(s).second; }
 protected:
    // Container for the timestamp the originating attribute was last updated for
    class Stamp : public SGReferenced {
    public:
        Stamp() : _timeStampValid(false), _dirty(true)
        { }
        const SGTimeStamp& getTimeStamp() const
        { return _timeStamp; }
        void setTimeStamp(const SGTimeStamp& timeStamp)
        { _timeStamp = timeStamp; }
        bool getTimeStampValid() const
        { return _timeStampValid; }
        void setTimeStampValid(bool timeStampValid)
        { _timeStampValid = timeStampValid; }
        bool getDirty() const
        { return _dirty; }
        void setDirty(bool dirty)
        { _dirty = dirty; }
    private:
        SGTimeStamp _timeStamp;
        bool _timeStampValid;
        bool _dirty;
    };
    /// get the stamp
    Stamp* _getStamp() const
    { return _stamp.get(); }
    /// Set the stamp
    virtual void _setStamp(Stamp* stamp);
 private:
-    // SGSharedPtr<const TimeStamp> _timeStamp;
+    SGSharedPtr<Stamp> _stamp;
 };
 class HLADataElementProvider {
@@ -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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLADataType.hxx"
 #include "HLADataElement.hxx"
@@ -39,12 +45,6 @@ HLADataType::accept(HLADataTypeVisitor& visitor) const
    visitor.apply(*this);
 }
 const HLADataTypeReference*
 HLADataType::toDataTypeReference() const
 {
    return 0;
 }
 const HLABasicDataType*
 HLADataType::toBasicDataType() const
 {
@@ -69,12 +69,25 @@ HLADataType::toFixedRecordDataType() const
    return 0;
 }
-const HLAVariantDataType*
+const HLAVariantRecordDataType*
-HLADataType::toVariantDataType() const
+HLADataType::toVariantRecordDataType() const
 {
    return 0;
 }
 bool
 HLADataType::recomputeAlignment()
 {
    unsigned alignment = getAlignment();
    _recomputeAlignmentImplementation();
    return alignment != getAlignment();
 }
 void
 HLADataType::releaseDataTypeReferences()
 {
 }
 void
 HLADataType::setAlignment(unsigned alignment)
 {
@@ -85,20 +98,9 @@ HLADataType::setAlignment(unsigned alignment)
        _alignment = alignment;
 }
 HLADataTypeReference::~HLADataTypeReference()
 {
 }
 void
-HLADataTypeReference::accept(HLADataTypeVisitor& visitor) const
+HLADataType::_recomputeAlignmentImplementation()
 {
    visitor.apply(*this);
 }
 const HLADataTypeReference*
 HLADataTypeReference::toDataTypeReference() const
 {
    return this;
 }
 }
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -27,19 +27,11 @@ namespace simgear {
 class HLADataTypeVisitor;
 class HLADataTypeReference;
 class HLABasicDataType;
 class HLAArrayDataType;
 class HLAEnumeratedDataType;
 class HLAFixedRecordDataType;
-class HLAVariantDataType;
+class HLAVariantRecordDataType;
 enum HLAUpdateType {
    HLAStaticUpdate,
    HLAPeriodicUpdate,
    HLAConditionalUpdate,
    HLAUndefinedUpdate
 };
 class HLADataType : public SGWeakReferenced {
 public:
@@ -58,42 +50,33 @@ public:
    virtual void accept(HLADataTypeVisitor& visitor) const;
    virtual const HLADataTypeReference* toDataTypeReference() const;
    virtual const HLABasicDataType* toBasicDataType() const;
    virtual const HLAArrayDataType* toArrayDataType() const;
    virtual const HLAEnumeratedDataType* toEnumeratedDataType() const;
    virtual const HLAFixedRecordDataType* toFixedRecordDataType() const;
-    virtual const HLAVariantDataType* toVariantDataType() const;
+    /// deprecated
    const HLAVariantRecordDataType* toVariantDataType() const { return toVariantRecordDataType(); }
    virtual const HLAVariantRecordDataType* toVariantRecordDataType() const;
    /// Recompute the alignment value of this data type.
    /// Return true if the alignment changed, false otherwise.
    bool recomputeAlignment();
    /// Release references to other data types. Since we can have cycles this is
    /// required for propper feeing of memory.
    virtual void releaseDataTypeReferences();
 protected:
    HLADataType(const std::string& name, unsigned alignment = 1);
    void setAlignment(unsigned alignment);
    virtual void _recomputeAlignmentImplementation();
 private:
    std::string _name;
    std::string _semantics;
    unsigned _alignment;
 };
 // Weak reference to a data type. Used to implement self referencing data types
 class HLADataTypeReference : public HLADataType {
 public:
    HLADataTypeReference(const SGSharedPtr<HLADataType>& dataType) :
        HLADataType(dataType->getName(), dataType->getAlignment()),
        _dataType(dataType)
    { }
    virtual ~HLADataTypeReference();
    SGSharedPtr<const HLADataType> getDataType() const
    { return _dataType.lock(); }
    virtual void accept(HLADataTypeVisitor& visitor) const;
    virtual const HLADataTypeReference* toDataTypeReference() const;
 private:
    SGWeakPtr<const HLADataType> _dataType;
 };
 } // namespace simgear
 #endif
@@ -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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -24,10 +24,10 @@
 #include <simgear/math/SGMath.hxx>
 #include "HLAArrayDataType.hxx"
 #include "HLABasicDataType.hxx"
-#include "HLADataTypeVisitor.hxx"
+#include "HLADataElement.hxx"
 #include "HLAEnumeratedDataType.hxx"
 #include "HLAFixedRecordDataType.hxx"
-#include "HLAVariantDataType.hxx"
+#include "HLAVariantRecordDataType.hxx"
 namespace simgear {
@@ -38,16 +38,6 @@ public:
    virtual void apply(const HLADataType& dataType)
    { }
    virtual void apply(const HLADataTypeReference& dataType)
    {
        SGSharedPtr<const HLADataType> dataTypeReference = dataType.getDataType();
        if (!dataTypeReference.valid()) {
            SG_LOG(SG_NETWORK, SG_WARN, "HLADataTypeReference weak reference vanished!");
            return;
        }
        dataTypeReference->accept(*this);
    }
    virtual void apply(const HLABasicDataType& dataType)
    { apply(static_cast<const HLADataType&>(dataType)); }
    virtual void apply(const HLAInt8DataType& dataType)
@@ -84,7 +74,7 @@ public:
    virtual void apply(const HLAFixedRecordDataType& dataType)
    { apply(static_cast<const HLADataType&>(dataType)); }
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
    { apply(static_cast<const HLADataType&>(dataType)); }
 };
@@ -145,7 +135,7 @@ public:
        }
    }
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
    { assert(0); }
 protected:
@@ -188,7 +178,7 @@ public:
            dataType.getFieldDataType(i)->accept(*this);
    }
-    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+    virtual void apply(const HLAVariantRecordDataType& dataType) { assert(0); }
 protected:
    HLADecodeStream& _stream;
@@ -232,7 +222,7 @@ public:
            dataType.getFieldDataType(i)->accept(*this);
    }
-    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+    virtual void apply(const HLAVariantRecordDataType& dataType) { assert(0); }
 protected:
    HLAEncodeStream& _stream;
@@ -269,7 +259,7 @@ public:
        HLADataTypeDecodeVisitor::apply(dataType);
    }
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
    {
        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
        HLADataTypeDecodeVisitor::apply(dataType);
@@ -305,7 +295,7 @@ public:
        HLADataTypeEncodeVisitor::apply(dataType);
    }
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
    {
        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
        HLADataTypeEncodeVisitor::apply(dataType);
@@ -386,7 +376,7 @@ public:
        HLADataTypeDecodeVisitor::apply(dataType);
    }
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
    {
        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
        HLADataTypeDecodeVisitor::apply(dataType);
@@ -467,7 +457,7 @@ public:
        HLADataTypeEncodeVisitor::apply(dataType);
    }
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
    {
        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
        HLADataTypeEncodeVisitor::apply(dataType);
@@ -629,6 +619,43 @@ inline void HLADataTypeEncodeVisitor::apply(const HLAVariableArrayDataType& data
    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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,10 +15,18 @@
 // 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) :
@@ -30,6 +38,18 @@ HLAAbstractEnumeratedDataElement::~HLAAbstractEnumeratedDataElement()
 {
 }
 void
 HLAAbstractEnumeratedDataElement::accept(HLADataElementVisitor& visitor)
 {
    visitor.apply(*this);
 }
 void
 HLAAbstractEnumeratedDataElement::accept(HLAConstDataElementVisitor& visitor) const
 {
    visitor.apply(*this);
 }
 bool
 HLAAbstractEnumeratedDataElement::decode(HLADecodeStream& stream)
 {
@@ -28,6 +28,9 @@ 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;
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLAEnumeratedDataType.hxx"
 #include <map>
@@ -176,5 +182,14 @@ HLAEnumeratedDataType::setRepresentation(HLABasicDataType* representation)
    _map.swap(representationVisitor._map);
 }
 void
 HLAEnumeratedDataType::_recomputeAlignmentImplementation()
 {
    unsigned alignment = 1;
    if (const HLADataType* dataType = getRepresentation())
        alignment = std::max(alignment, dataType->getAlignment());
    setAlignment(alignment);
 }
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -70,6 +70,9 @@ public:
        return _map->getDataType();
    }
 protected:
    virtual void _recomputeAlignmentImplementation();
 private:
    class AbstractMap : public SGReferenced {
    public:
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -32,34 +32,137 @@ class RTIFederate;
 class HLAFederate : public SGWeakReferenced {
 public:
    HLAFederate();
    virtual ~HLAFederate();
-    /// Get the name of the joined federate/federation
+    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;
-    const std::string& getFederationName() 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
    /// FIXME: cannot determine from the return value if we created the execution
    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);
-    bool timeAdvanceRequestBy(const SGTimeStamp& dt);
+    /// Advance the logical time by the given time increment.
-    bool timeAdvanceRequest(const SGTimeStamp& dt);
+    /// 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();
-    /// Process messages
+    /// Get the current federates time
-    bool tick();
+    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 {
@@ -68,7 +171,7 @@ public:
        { }
        virtual HLAObjectClass* createObjectClass(const std::string& name, HLAFederate& federate)
-        { return new HLAObjectClass(name, federate); }
+        { return federate.createObjectClass(name); }
        virtual bool subscribeObjectClass(const std::string& objectClassName, const std::string& sharing)
        { return sharing.find("Subscribe") != std::string::npos; }
        virtual bool publishObjectClass(const std::string& objectClassName, const std::string& sharing)
@@ -80,30 +183,136 @@ public:
    };
-    /// Read an omt xml file
+    /// Read an omt xml file - deprecated
    bool readObjectModelTemplate(const std::string& objectModel,
                                 ObjectModelFactory& objectModelFactory);
-    HLAObjectClass* getObjectClass(const std::string& name);
+    /// Read an rti1.3 omt xml file
-    const HLAObjectClass* getObjectClass(const std::string& name) const;
+    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);
-protected:
+    /// Get the object class of a given name
-    HLAFederate(const SGSharedPtr<RTIFederate>& rtiFederate);
+    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;
-    typedef std::map<std::string, SGSharedPtr<HLAObjectClass> > ObjectClassMap;
+    /// Parameters required to connect to an rti
-    ObjectClassMap _objectClassMap;
+    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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,11 +15,19 @@
 // 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 {
@@ -33,6 +41,18 @@ HLAAbstractFixedRecordDataElement::~HLAAbstractFixedRecordDataElement()
 {
 }
 void
 HLAAbstractFixedRecordDataElement::accept(HLADataElementVisitor& visitor)
 {
    visitor.apply(*this);
 }
 void
 HLAAbstractFixedRecordDataElement::accept(HLAConstDataElementVisitor& visitor) const
 {
    visitor.apply(*this);
 }
 bool
 HLAAbstractFixedRecordDataElement::decode(HLADecodeStream& stream)
 {
@@ -106,6 +126,7 @@ HLAFixedRecordDataElement::HLAFixedRecordDataElement(const HLAFixedRecordDataTyp
 HLAFixedRecordDataElement::~HLAFixedRecordDataElement()
 {
    clearStamp();
 }
 bool
@@ -167,7 +188,12 @@ HLAFixedRecordDataElement::setField(unsigned index, HLADataElement* value)
 {
    if (getNumFields() <= index)
        return;
    if (_fieldVector[index].valid())
        _fieldVector[index]->clearStamp();
    _fieldVector[index] = value;
    if (value)
        value->attachStamp(*this);
    setDirty(true);
 }
 void
@@ -176,4 +202,15 @@ HLAFixedRecordDataElement::setField(const std::string& name, HLADataElement* val
    setField(getFieldNumber(name), value);
 }
 void
 HLAFixedRecordDataElement::_setStamp(Stamp* stamp)
 {
    HLAAbstractFixedRecordDataElement::_setStamp(stamp);
    for (FieldVector::iterator i = _fieldVector.begin(); i != _fieldVector.end(); ++i) {
        if (!i->valid())
            continue;
        (*i)->attachStamp(*this);
    }
 }
 }
@@ -30,6 +30,9 @@ 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;
@@ -67,6 +70,9 @@ public:
    void setField(unsigned index, HLADataElement* value);
    void setField(const std::string& name, HLADataElement* value);
 protected:
    virtual void _setStamp(Stamp* stamp);
 private:
    typedef std::vector<SGSharedPtr<HLADataElement> > FieldVector;
    FieldVector _fieldVector;
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLAFixedRecordDataType.hxx"
 #include "HLADataTypeVisitor.hxx"
@@ -43,6 +49,14 @@ HLAFixedRecordDataType::toFixedRecordDataType() const
    return this;
 }
 void
 HLAFixedRecordDataType::releaseDataTypeReferences()
 {
    unsigned numFields = getNumFields();
    for (unsigned i = 0; i < numFields; ++i)
        _fieldList[i].releaseDataTypeReferences();
 }
 bool
 HLAFixedRecordDataType::decode(HLADecodeStream& stream, HLAAbstractFixedRecordDataElement& value) const
 {
@@ -68,10 +82,18 @@ HLAFixedRecordDataType::encode(HLAEncodeStream& stream, const HLAAbstractFixedRe
 void
 HLAFixedRecordDataType::addField(const std::string& name, const HLADataType* dataType)
 {
    // FIXME this only works if we do not reset the alignment to something smaller
    if (getAlignment() < dataType->getAlignment())
        setAlignment(dataType->getAlignment());
    _fieldList.push_back(Field(name, dataType));
 }
 void
 HLAFixedRecordDataType::_recomputeAlignmentImplementation()
 {
    unsigned alignment = 1;
    for (unsigned i = 0; i < getNumFields(); ++i) {
        if (const HLADataType* dataType = getFieldDataType(i))
            alignment = std::max(alignment, dataType->getAlignment());
    }
    setAlignment(alignment);
 }
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -36,6 +36,8 @@ public:
    virtual const HLAFixedRecordDataType* toFixedRecordDataType() const;
    virtual void releaseDataTypeReferences();
    virtual bool decode(HLADecodeStream& stream, HLAAbstractFixedRecordDataElement& value) const;
    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractFixedRecordDataElement& value) const;
@@ -67,6 +69,9 @@ public:
    void addField(const std::string& name, const HLADataType* dataType);
 protected:
    virtual void _recomputeAlignmentImplementation();
 private:
    struct Field {
        Field(const std::string& name, const HLADataType* dataType) :
@@ -76,6 +81,8 @@ private:
        const HLADataType* getDataType() const
        { return _dataType.get(); }
        void releaseDataTypeReferences()
        { _dataType = 0; }
    private:
        std::string _name;
@@ -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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,13 +18,92 @@
 #ifndef HLAInteractionClass_hxx
 #define HLAInteractionClass_hxx
 #include <map>
 #include <string>
 #include <vector>
 #include <simgear/structure/SGWeakReferenced.hxx>
 #include "HLADataElement.hxx"
 #include "HLADataType.hxx"
 #include "HLATypes.hxx"
 namespace simgear {
 class RTIInteractionClass;
 class HLADataType;
 class HLAFederate;
 class HLAInteractionClass : public SGWeakReferenced {
 public:
-    virtual ~HLAInteractionClass() {}
+    HLAInteractionClass(const std::string& name, HLAFederate* federate);
    virtual ~HLAInteractionClass();
    const std::string& getName() const;
    /// return the federate this interaction class belongs to
    const SGWeakPtr<HLAFederate>& getFederate() const;
    HLASubscriptionType getSubscriptionType() const;
    void setSubscriptionType(HLASubscriptionType subscriptionType);
    HLAPublicationType getPublicationType() const;
    void setPublicationType(HLAPublicationType publicationType);
    unsigned getNumParameters() const;
    unsigned addParameter(const std::string& name);
    unsigned getParameterIndex(const std::string& name) const;
    std::string getParameterName(unsigned index) const;
    const HLADataType* getParameterDataType(unsigned index) const;
    void setParameterDataType(unsigned index, const SGSharedPtr<const HLADataType>& dataType);
    HLADataElement::IndexPathPair getIndexPathPair(const HLADataElement::StringPathPair& stringPathPair) const;
    HLADataElement::IndexPathPair getIndexPathPair(const std::string& path) const;
    virtual bool subscribe();
    virtual bool unsubscribe();
    virtual bool publish();
    virtual bool unpublish();
 private:
    HLAInteractionClass(const HLAInteractionClass&);
    HLAInteractionClass& operator=(const HLAInteractionClass&);
    void _setRTIInteractionClass(RTIInteractionClass* interactionClass);
    void _resolveParameterIndex(const std::string& name, unsigned index);
    void _clearRTIInteractionClass();
    struct Parameter {
        Parameter() {}
        Parameter(const std::string& name) : _name(name) {}
        std::string _name;
        SGSharedPtr<const HLADataType> _dataType;
    };
    typedef std::vector<Parameter> ParameterVector;
    typedef std::map<std::string,unsigned> NameIndexMap;
    /// The parent federate.
    SGWeakPtr<HLAFederate> _federate;
    /// The rti class if already instantiated.
    RTIInteractionClass* _rtiInteractionClass;
    /// The interaction class name
    std::string _name;
    /// The configured subscription and publication type
    HLASubscriptionType _subscriptionType;
    HLAPublicationType _publicationType;
    /// The parameter data
    ParameterVector _parameterVector;
    /// The mapping from parameter names to parameter indices
    NameIndexMap _nameIndexMap;
    friend class HLAFederate;
 };
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLAOMTXmlVisitor.hxx"
 #include <map>
@@ -27,8 +33,9 @@
 #include "HLABasicDataType.hxx"
 #include "HLADataTypeVisitor.hxx"
 #include "HLAEnumeratedDataType.hxx"
 #include "HLAFederate.hxx"
 #include "HLAFixedRecordDataType.hxx"
-#include "HLAVariantDataType.hxx"
+#include "HLAVariantRecordDataType.hxx"
 namespace simgear {
@@ -68,18 +75,6 @@ HLAOMTXmlVisitor::ObjectClass::getAttribute(unsigned index) const
    return _attributes[index];
 }
 const HLAOMTXmlVisitor::Attribute*
 HLAOMTXmlVisitor::ObjectClass::getAttribute(const std::string& name) const
 {
    for (AttributeList::const_iterator i = _attributes.begin(); i != _attributes.end(); ++i) {
        if ((*i)->_name != name)
            continue;
        return i->get();
    }
    SG_LOG(SG_IO, SG_ALERT, "Could not find class attribute \"" << name << "\".");
    return 0;
 }
 const HLAOMTXmlVisitor::ObjectClass*
 HLAOMTXmlVisitor::ObjectClass::getParentObjectClass() const
 {
@@ -107,6 +102,12 @@ HLAOMTXmlVisitor::InteractionClass::getDimensions() const
    return _dimensions;
 }
 const std::string&
 HLAOMTXmlVisitor::InteractionClass::getSharing() const
 {
    return _sharing;
 }
 const std::string&
 HLAOMTXmlVisitor::InteractionClass::getTransportation() const
 {
@@ -133,18 +134,6 @@ HLAOMTXmlVisitor::InteractionClass::getParameter(unsigned index) const
    return _parameters[index];
 }
 const HLAOMTXmlVisitor::Parameter*
 HLAOMTXmlVisitor::InteractionClass::getParameter(const std::string& name) const
 {
    for (ParameterList::const_iterator i = _parameters.begin(); i != _parameters.end(); ++i) {
        if ((*i)->_name != name)
            continue;
        return i->get();
    }
    SG_LOG(SG_IO, SG_ALERT, "Could not find parameter \"" << name << "\".");
    return 0;
 }
 const HLAOMTXmlVisitor::InteractionClass*
 HLAOMTXmlVisitor::InteractionClass::getParentInteractionClass() const
 {
@@ -159,6 +148,81 @@ HLAOMTXmlVisitor::~HLAOMTXmlVisitor()
 {
 }
 void
 HLAOMTXmlVisitor::setDataTypesToFederate(HLAFederate& federate)
 {
    // Provide all the data types
    for (BasicDataMap::iterator i = _basicDataMap.begin(); i != _basicDataMap.end(); ++i)
        federate.insertDataType(i->first, getDataType(i->first));
    for (SimpleDataMap::iterator i = _simpleDataMap.begin(); i != _simpleDataMap.end(); ++i)
        federate.insertDataType(i->first, getDataType(i->first));
    for (EnumeratedDataMap::iterator i = _enumeratedDataMap.begin(); i != _enumeratedDataMap.end(); ++i)
        federate.insertDataType(i->first, getDataType(i->first));
    for (ArrayDataMap::iterator i = _arrayDataMap.begin(); i != _arrayDataMap.end(); ++i)
        federate.insertDataType(i->first, getDataType(i->first));
    for (FixedRecordDataMap::iterator i = _fixedRecordDataMap.begin(); i != _fixedRecordDataMap.end(); ++i)
        federate.insertDataType(i->first, getDataType(i->first));
    for (VariantRecordDataMap::iterator i = _variantRecordDataMap.begin(); i != _variantRecordDataMap.end(); ++i)
        federate.insertDataType(i->first, getDataType(i->first));
    // Finish alignment computations
    federate.recomputeDataTypeAlignment();
 }
 void
 HLAOMTXmlVisitor::setToFederate(HLAFederate& federate)
 {
    setDataTypesToFederate(federate);
    // Provide all interaction classes
    unsigned numInteractionClasses = getNumInteractionClasses();
    for (unsigned i = 0; i < numInteractionClasses; ++i) {
        const InteractionClass* interactionClass = getInteractionClass(i);
        SGSharedPtr<HLAInteractionClass> hlaInteractionClass;
        hlaInteractionClass = federate.createInteractionClass(interactionClass->getName());
        if (!hlaInteractionClass.valid()) {
            SG_LOG(SG_IO, SG_INFO, "Ignoring Interaction class \"" << interactionClass->getName() << "\".");
            continue;
        }
        hlaInteractionClass->setSubscriptionType(interactionClass->getSubscriptionType());
        hlaInteractionClass->setPublicationType(interactionClass->getPublicationType());
        // process the parameters
        for (unsigned j = 0; j < interactionClass->getNumParameters(); ++j) {
            const Parameter* parameter = interactionClass->getParameter(j);
            unsigned index = hlaInteractionClass->addParameter(parameter->getName());
            hlaInteractionClass->setParameterDataType(index, federate.getDataType(parameter->getDataType()));
        }
    }
    // Provide all object classes
    unsigned numObjectClasses = getNumObjectClasses();
    for (unsigned i = 0; i < numObjectClasses; ++i) {
        const ObjectClass* objectClass = getObjectClass(i);
        SGSharedPtr<HLAObjectClass> hlaObjectClass;
        hlaObjectClass = federate.createObjectClass(objectClass->getName());
        if (!hlaObjectClass.valid()) {
            SG_LOG(SG_IO, SG_INFO, "Ignoring Object class \"" << objectClass->getName() << "\".");
            continue;
        }
        // process the attributes
        for (unsigned j = 0; j < objectClass->getNumAttributes(); ++j) {
            const Attribute* attribute = objectClass->getAttribute(j);
            unsigned index = hlaObjectClass->addAttribute(attribute->getName());
            hlaObjectClass->setAttributeDataType(index, federate.getDataType(attribute->getDataType()));
            hlaObjectClass->setAttributeSubscriptionType(index, attribute->getSubscriptionType());
            hlaObjectClass->setAttributePublicationType(index, attribute->getPublicationType());
            hlaObjectClass->setAttributeUpdateType(index, attribute->getUpdateType());
        }
    }
 }
 unsigned
 HLAOMTXmlVisitor::getNumObjectClasses() const
 {
@@ -173,36 +237,6 @@ HLAOMTXmlVisitor::getObjectClass(unsigned i) const
    return _objectClassList[i];
 }
 const HLAOMTXmlVisitor::ObjectClass*
 HLAOMTXmlVisitor::getObjectClass(const std::string& name) const
 {
    for (ObjectClassList::const_iterator i = _objectClassList.begin(); i != _objectClassList.end(); ++i) {
        if ((*i)->_name != name)
            continue;
        return i->get();
    }
    SG_LOG(SG_IO, SG_ALERT, "Could not resolve ObjectClass \"" << name << "\".");
    return 0;
 }
 const HLAOMTXmlVisitor::Attribute*
 HLAOMTXmlVisitor::getAttribute(const std::string& objectClassName, const std::string& attributeName) const
 {
    const ObjectClass* objectClass = getObjectClass(objectClassName);
    if (!objectClass)
        return 0;
    return objectClass->getAttribute(attributeName);
 }
 HLADataType*
 HLAOMTXmlVisitor::getAttributeDataType(const std::string& objectClassName, const std::string& attributeName) const
 {
    const Attribute* attribute = getAttribute(objectClassName, attributeName);
    if (!attribute)
        return 0;
    return getDataType(attribute->_dataType);
 }
 unsigned
 HLAOMTXmlVisitor::getNumInteractionClasses() const
 {
@@ -217,59 +251,19 @@ HLAOMTXmlVisitor::getInteractionClass(unsigned i) const
    return _interactionClassList[i];
 }
 const HLAOMTXmlVisitor::InteractionClass*
 HLAOMTXmlVisitor::getInteractionClass(const std::string& name) const
 {
    for (InteractionClassList::const_iterator i = _interactionClassList.begin(); i != _interactionClassList.end(); ++i) {
        if ((*i)->_name != name)
            continue;
        return i->get();
    }
    SG_LOG(SG_IO, SG_ALERT, "Could not resolve InteractionClass \"" << name << "\".");
    return 0;
 }
 const HLAOMTXmlVisitor::Parameter*
 HLAOMTXmlVisitor::getParameter(const std::string& interactionClassName, const std::string& parameterName) const
 {
    const InteractionClass* interactionClass = getInteractionClass(interactionClassName);
    if (!interactionClass)
        return 0;
    return interactionClass->getParameter(parameterName);
 }
 HLADataType*
 HLAOMTXmlVisitor::getParameterDataType(const std::string& interactionClassName, const std::string& parameterName) const
 {
    const Parameter* parameter = getParameter(interactionClassName, parameterName);
    if (!parameter)
        return 0;
    return getDataType(parameter->_dataType);
 }
 HLADataType*
 HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName) const
 {
    SGSharedPtr<HLADataType> dataType;
    {
        // Playing dirty things with reference counts
        StringDataTypeMap dataTypeMap;
        dataType = getDataType(dataTypeName, dataTypeMap);
    }
    return dataType.release();
 }
 SGSharedPtr<HLADataType>
-HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName)
 {
-    StringDataTypeMap::const_iterator i = dataTypeMap.find(dataTypeName);
+    StringDataTypeMap::const_iterator i = _dataTypeMap.find(dataTypeName);
-    if (i != dataTypeMap.end())
+    if (i != _dataTypeMap.end())
-        return new HLADataTypeReference(i->second);
+        return i->second;
    SGSharedPtr<HLADataType> dataType;
    dataType = getBasicDataType(dataTypeName);
-    if (dataType.valid())
+    if (dataType.valid()) {
        _dataTypeMap[dataTypeName] = dataType;
        return dataType;
    }
    dataType = getSimpleDataType(dataTypeName);
    if (dataType.valid())
@@ -279,15 +273,15 @@ HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName, HLAOMTXmlVisitor:
    if (dataType.valid())
        return dataType;
-    dataType = getArrayDataType(dataTypeName, dataTypeMap);
+    dataType = getArrayDataType(dataTypeName);
    if (dataType.valid())
        return dataType;
-    dataType = getFixedRecordDataType(dataTypeName, dataTypeMap);
+    dataType = getFixedRecordDataType(dataTypeName);
    if (dataType.valid())
        return dataType;
-    dataType = getVariantDataType(dataTypeName, dataTypeMap);
+    dataType = getVariantRecordDataType(dataTypeName);
    if (dataType.valid())
        return dataType;
@@ -296,7 +290,7 @@ HLAOMTXmlVisitor::getDataType(const std::string& dataTypeName, HLAOMTXmlVisitor:
 }
 SGSharedPtr<HLABasicDataType>
-HLAOMTXmlVisitor::getBasicDataType(const std::string& dataTypeName) const
+HLAOMTXmlVisitor::getBasicDataType(const std::string& dataTypeName)
 {
    BasicDataMap::const_iterator i = _basicDataMap.find(dataTypeName);
    if (i == _basicDataMap.end())
@@ -369,7 +363,7 @@ HLAOMTXmlVisitor::getBasicDataType(const std::string& dataTypeName) const
 }
 SGSharedPtr<HLADataType>
-HLAOMTXmlVisitor::getSimpleDataType(const std::string& dataTypeName) const
+HLAOMTXmlVisitor::getSimpleDataType(const std::string& dataTypeName)
 {
    SimpleDataMap::const_iterator i = _simpleDataMap.find(dataTypeName);
    if (i == _simpleDataMap.end())
@@ -378,13 +372,14 @@ HLAOMTXmlVisitor::getSimpleDataType(const std::string& dataTypeName) const
 }
 SGSharedPtr<HLAEnumeratedDataType>
-HLAOMTXmlVisitor::getEnumeratedDataType(const std::string& dataTypeName) const
+HLAOMTXmlVisitor::getEnumeratedDataType(const std::string& dataTypeName)
 {
    EnumeratedDataMap::const_iterator i = _enumeratedDataMap.find(dataTypeName);
    if (i == _enumeratedDataMap.end())
        return 0;
    SGSharedPtr<HLAEnumeratedDataType> enumeratedDataType = new HLAEnumeratedDataType(dataTypeName);
    _dataTypeMap[dataTypeName] = enumeratedDataType;
    enumeratedDataType->setRepresentation(getBasicDataType(i->second._representation));
    for (EnumeratorList::const_iterator j = i->second._enumeratorList.begin();
@@ -400,7 +395,7 @@ HLAOMTXmlVisitor::getEnumeratedDataType(const std::string& dataTypeName) const
 }
 SGSharedPtr<HLADataType>
-HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName)
 {
    ArrayDataMap::const_iterator i = _arrayDataMap.find(dataTypeName);
    if (i == _arrayDataMap.end())
@@ -428,35 +423,44 @@ HLAOMTXmlVisitor::getArrayDataType(const std::string& dataTypeName, HLAOMTXmlVis
        return 0;
    }
-    dataTypeMap[dataTypeName] = arrayDataType;
+    _dataTypeMap[dataTypeName] = arrayDataType;
-    SGSharedPtr<HLADataType> elementDataType = getDataType(i->second._dataType, dataTypeMap);
+    SGSharedPtr<HLADataType> elementDataType = getDataType(i->second._dataType);
    if (!elementDataType.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Could not interpret dataType \""
               << i->second._dataType << "\" for array data type \""
               << dataTypeName << "\".");
-        dataTypeMap.erase(dataTypeName);
+        _dataTypeMap.erase(dataTypeName);
        return 0;
    }
    arrayDataType->setElementDataType(elementDataType.get());
    // 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, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+HLAOMTXmlVisitor::getFixedRecordDataType(const std::string& dataTypeName)
 {
    FixedRecordDataMap::const_iterator i = _fixedRecordDataMap.find(dataTypeName);
    if (i == _fixedRecordDataMap.end())
        return 0;
    SGSharedPtr<HLAFixedRecordDataType> dataType = new HLAFixedRecordDataType(dataTypeName);
-    dataTypeMap[dataTypeName] = dataType;
+    _dataTypeMap[dataTypeName] = dataType;
    for (FieldList::size_type j = 0; j < i->second._fieldList.size(); ++j) {
-        SGSharedPtr<HLADataType> fieldDataType = getDataType(i->second._fieldList[j]._dataType, dataTypeMap);
+        SGSharedPtr<HLADataType> fieldDataType = getDataType(i->second._fieldList[j]._dataType);
        if (!fieldDataType.valid()) {
            SG_LOG(SG_IO, SG_ALERT, "Could not get data type \"" << i->second._fieldList[j]._dataType
                   << "\" for field " << j << "of fixed record data type \"" << dataTypeName << "\".");
-            dataTypeMap.erase(dataTypeName);
+            _dataTypeMap.erase(dataTypeName);
            return 0;
        }
        dataType->addField(i->second._fieldList[j]._name, fieldDataType.get());
@@ -464,14 +468,14 @@ HLAOMTXmlVisitor::getFixedRecordDataType(const std::string& dataTypeName, HLAOMT
    return dataType;
 }
-SGSharedPtr<HLAVariantDataType>
+SGSharedPtr<HLAVariantRecordDataType>
-HLAOMTXmlVisitor::getVariantDataType(const std::string& dataTypeName, HLAOMTXmlVisitor::StringDataTypeMap& dataTypeMap) const
+HLAOMTXmlVisitor::getVariantRecordDataType(const std::string& dataTypeName)
 {
    VariantRecordDataMap::const_iterator i = _variantRecordDataMap.find(dataTypeName);
    if (i == _variantRecordDataMap.end())
        return 0;
-    SGSharedPtr<HLAVariantDataType> dataType = new HLAVariantDataType(dataTypeName);
+    SGSharedPtr<HLAVariantRecordDataType> dataType = new HLAVariantRecordDataType(dataTypeName);
-    dataTypeMap[dataTypeName] = dataType;
+    _dataTypeMap[dataTypeName] = dataType;
    SGSharedPtr<HLAEnumeratedDataType> enumeratedDataType = getEnumeratedDataType(i->second._dataType);
    if (!enumeratedDataType.valid()) {
@@ -483,11 +487,11 @@ HLAOMTXmlVisitor::getVariantDataType(const std::string& dataTypeName, HLAOMTXmlV
    for (AlternativeList::const_iterator j = i->second._alternativeList.begin();
         j != i->second._alternativeList.end(); ++j) {
-        SGSharedPtr<HLADataType> alternativeDataType = getDataType(j->_dataType, dataTypeMap);
+        SGSharedPtr<HLADataType> alternativeDataType = getDataType(j->_dataType);
        if (!alternativeDataType.valid()) {
            SG_LOG(SG_IO, SG_ALERT, "Could not resolve alternative dataType \"" << j->_dataType
                   << "\" for alternative \"" << j->_name << "\".");
-            dataTypeMap.erase(dataTypeName);
+            _dataTypeMap.erase(dataTypeName);
            return 0;
        }
        if (!dataType->addAlternative(j->_name, j->_enumerator, alternativeDataType.get(), j->_semantics)) {
@@ -531,27 +535,27 @@ HLAOMTXmlVisitor::endXML()
        throw sg_exception("Internal parse error!");
    // propagate parent attributes to the derived classes
    // Note that this preserves the order of the attributes starting from the root object
    for (ObjectClassList::const_iterator i = _objectClassList.begin(); i != _objectClassList.end(); ++i) {
        SGSharedPtr<const ObjectClass> objectClass = (*i)->_parentObjectClass;
-        while (objectClass) {
+        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);
        }
            objectClass = objectClass->_parentObjectClass;
        }
    }
    // propagate parent parameter to the derived interactions
    // Note that this preserves the order of the parameters starting from the root object
    for (InteractionClassList::const_iterator i = _interactionClassList.begin(); i != _interactionClassList.end(); ++i) {
        SGSharedPtr<const InteractionClass> interactionClass = (*i)->_parentInteractionClass;
-        while (interactionClass) {
+        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);
        }
            interactionClass = interactionClass->_parentInteractionClass;
        }
    }
 }
@@ -720,11 +724,6 @@ HLAOMTXmlVisitor::startElement(const char* name, const XMLAttributes& atts)
            throw sg_exception("enumeratedDataTypes tag outside dataTypes!");
        pushMode(EnumeratedDataTypesMode);
        Enumerator enumerator;
        enumerator._name = getAttribute("name", atts);
        enumerator._values = getAttribute("values", atts);
        _enumeratedDataMap[_enumeratedDataName]._enumeratorList.push_back(enumerator);
    } else if (strcmp(name, "arrayData") == 0) {
        if (getCurrentMode() != ArrayDataTypesMode)
            throw sg_exception("arrayData tag outside arrayDataTypes!");
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -25,9 +25,12 @@
 #include <simgear/structure/SGSharedPtr.hxx>
 #include <simgear/xml/easyxml.hxx>
 #include "HLADataType.hxx"
 #include "HLATypes.hxx"
 namespace simgear {
 class HLAFederate;
 class HLAOMTXmlVisitor : public XMLVisitor {
 public:
    /// structures representing the federate object model data
@@ -37,6 +40,10 @@ public:
        { }
        const std::string& getName() const
        { return _name; }
        const std::string& getDataType() const
        { return _dataType; }
        const std::string& getSharing() const
        { return _sharing; }
        const std::string& getDimensions() const
        { return _dimensions; }
        const std::string& getTransportation() const
@@ -44,6 +51,34 @@ public:
        const std::string& getOrder() const
        { return _order; }
        HLASubscriptionType getSubscriptionType() const
        {
            if (_sharing.find("Subscribe") != std::string::npos)
                return HLASubscribedActive;
            else
                return HLAUnsubscribed;
        }
        HLAPublicationType getPublicationType() const
        {
            if (_sharing.find("Publish") != std::string::npos)
                return HLAPublished;
            else
                return HLAUnpublished;
        }
        HLAUpdateType getUpdateType() const
        {
            if (_updateType == "Periodic")
                return HLAPeriodicUpdate;
            else if (_updateType == "Static")
                return HLAStaticUpdate;
            else if (_updateType == "Conditional")
                return HLAConditionalUpdate;
            else
                return HLAUndefinedUpdate;
        }
        std::string _name;
        std::string _dataType;
        std::string _updateType;
@@ -66,7 +101,6 @@ public:
        unsigned getNumAttributes() const;
        const Attribute* getAttribute(unsigned index) const;
        const Attribute* getAttribute(const std::string& name) const;
        const ObjectClass* getParentObjectClass() const;
@@ -101,12 +135,28 @@ public:
        const std::string& getName() const;
        const std::string& getDimensions() const;
        const std::string& getSharing() const;
        const std::string& getTransportation() const;
        const std::string& getOrder() const;
        HLASubscriptionType getSubscriptionType() const
        {
            if (_sharing.find("Subscribe") != std::string::npos)
                return HLASubscribedActive;
            else
                return HLAUnsubscribed;
        }
        HLAPublicationType getPublicationType() const
        {
            if (_sharing.find("Publish") != std::string::npos)
                return HLAPublished;
            else
                return HLAUnpublished;
        }
        unsigned getNumParameters() const;
        const Parameter* getParameter(unsigned index) const;
        const Parameter* getParameter(const std::string& name) const;
        const InteractionClass* getParentInteractionClass() const;
@@ -114,6 +164,7 @@ public:
        friend class HLAOMTXmlVisitor;
        std::string _name;
        std::string _dimensions;
        std::string _sharing;
        std::string _transportation;
        std::string _order;
        ParameterList _parameters;
@@ -124,36 +175,23 @@ public:
    HLAOMTXmlVisitor();
    ~HLAOMTXmlVisitor();
    void setDataTypesToFederate(HLAFederate& federate);
    void setToFederate(HLAFederate& federate);
    unsigned getNumObjectClasses() const;
    const ObjectClass* getObjectClass(unsigned i) const;
    const ObjectClass* getObjectClass(const std::string& name) const;
    /// Return the data type from the fom data
    const Attribute* getAttribute(const std::string& objectClassName, const std::string& attributeName) const;
    /// Return the data type from the fom data
    HLADataType* getAttributeDataType(const std::string& objectClassName, const std::string& attributeName) const;
    unsigned getNumInteractionClasses() const;
    const InteractionClass* getInteractionClass(unsigned i) const;
    const InteractionClass* getInteractionClass(const std::string& name) const;
    /// Return the data type from the fom data
    const Parameter* getParameter(const std::string& interactionClassName, const std::string& parameterName) const;
    /// Return the data type from the fom data
    HLADataType* getParameterDataType(const std::string& interactionClassName, const std::string& parameterName) const;
    HLADataType* getDataType(const std::string& dataTypeName) const;
 private:
-    typedef std::map<std::string, SGSharedPtr<HLADataType> > StringDataTypeMap;
+    SGSharedPtr<HLADataType> getDataType(const std::string& dataTypeName);
-    SGSharedPtr<HLADataType> getDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+    SGSharedPtr<HLABasicDataType> getBasicDataType(const std::string& dataTypeName);
-    SGSharedPtr<HLABasicDataType> getBasicDataType(const std::string& dataTypeName) const;
+    SGSharedPtr<HLADataType> getSimpleDataType(const std::string& dataTypeName);
-    SGSharedPtr<HLADataType> getSimpleDataType(const std::string& dataTypeName) const;
+    SGSharedPtr<HLAEnumeratedDataType> getEnumeratedDataType(const std::string& dataTypeName);
-    SGSharedPtr<HLAEnumeratedDataType> getEnumeratedDataType(const std::string& dataTypeName) const;
+    SGSharedPtr<HLADataType> getArrayDataType(const std::string& dataTypeName);
-    SGSharedPtr<HLADataType> getArrayDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+    SGSharedPtr<HLAFixedRecordDataType> getFixedRecordDataType(const std::string& dataTypeName);
-    SGSharedPtr<HLAFixedRecordDataType> getFixedRecordDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+    SGSharedPtr<HLAVariantRecordDataType> getVariantRecordDataType(const std::string& dataTypeName);
    SGSharedPtr<HLAVariantDataType> getVariantDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
    enum Mode {
        UnknownMode,
@@ -195,8 +233,8 @@ private:
    virtual void startElement(const char* name, const XMLAttributes& atts);
    virtual void endElement(const char* name);
-    std::string getAttribute(const char* name, const XMLAttributes& atts);
+    static std::string getAttribute(const char* name, const XMLAttributes& atts);
-    std::string getAttribute(const std::string& name, const XMLAttributes& atts);
+    static std::string getAttribute(const std::string& name, const XMLAttributes& atts);
    struct BasicData {
        // std::string _name;
@@ -276,6 +314,9 @@ private:
    InteractionClassList _interactionClassList;
    InteractionClassList _interactionClassStack;
    typedef std::map<std::string, SGSharedPtr<HLADataType> > StringDataTypeMap;
    StringDataTypeMap _dataTypeMap;
    /// DataType definitions
    BasicDataMap _basicDataMap;
    SimpleDataMap _simpleDataMap;
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,8 +15,15 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLAObjectClass.hxx"
 #include "simgear/debug/logstream.hxx"
 #include "RTIFederate.hxx"
 #include "RTIObjectClass.hxx"
 #include "RTIObjectInstance.hxx"
@@ -54,143 +61,226 @@ HLAObjectClass::RegistrationCallback::~RegistrationCallback()
 {
 }
-HLAObjectClass::HLAObjectClass(const std::string& name, HLAFederate& federate) :
+HLAObjectClass::HLAObjectClass(const std::string& name, HLAFederate* federate) :
    _federate(federate),
    _name(name)
 {
-    _rtiObjectClass = federate._rtiFederate->createObjectClass(name, this);
+    if (!federate) {
-    if (!_rtiObjectClass.valid())
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::HLAObjectClass(): "
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::HLAObjectClass(): No RTIObjectClass found for \"" << name << "\"!");
+               "No parent federate given for object class \"" << getName() << "\"!");
        return;
    }
    federate->_insertObjectClass(this);
 }
 HLAObjectClass::~HLAObjectClass()
 {
    // HLAObjectClass objects only get deleted when the parent federate
    // dies. So we do not need to deregister there.
    _clearRTIObjectClass();
 }
 const std::string&
 HLAObjectClass::getName() const
 {
    return _name;
 }
 const SGWeakPtr<HLAFederate>&
 HLAObjectClass::getFederate() const
 {
    return _federate;
 }
 unsigned
 HLAObjectClass::getNumAttributes() const
 {
-    if (!_rtiObjectClass.valid()) {
+    return _attributeVector.size();
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
+}
-        return 0;
+
-    }
+unsigned
-    return _rtiObjectClass->getNumAttributes();
+HLAObjectClass::addAttribute(const std::string& name)
 {
    unsigned index = _attributeVector.size();
    _nameIndexMap[name] = index;
    _attributeVector.push_back(Attribute(name));
    _resolveAttributeIndex(name, index);
    return index;
 }
 unsigned
 HLAObjectClass::getAttributeIndex(const std::string& name) const
 {
-    if (!_rtiObjectClass.valid()) {
+    NameIndexMap::const_iterator i = _nameIndexMap.find(name);
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
+    if (i == _nameIndexMap.end())
        return ~0u;
-    }
+    return i->second;
    return _rtiObjectClass->getOrCreateAttributeIndex(name);
 }
 std::string
 HLAObjectClass::getAttributeName(unsigned index) const
 {
-    if (!_rtiObjectClass.valid()) {
+    if (_attributeVector.size() <= index)
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
+        return std::string();
-        return 0;
+    return _attributeVector[index]._name;
    }
    return _rtiObjectClass->getAttributeName(index);
 }
 const HLADataType*
 HLAObjectClass::getAttributeDataType(unsigned index) const
 {
-    if (!_rtiObjectClass.valid()) {
+    if (_attributeVector.size() <= index)
        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeDataType(): No RTIObject class for object class \"" << getName() << "\"!");
        return 0;
-    }
+    return _attributeVector[index]._dataType.get();
    return _rtiObjectClass->getAttributeDataType(index);
 }
 void
 HLAObjectClass::setAttributeDataType(unsigned index, const HLADataType* dataType)
 {
-    if (!_rtiObjectClass.valid()) {
+    if (_attributeVector.size() <= index)
        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::setAttributeDataType(): No RTIObject class for object class \"" << getName() << "\"!");
        return;
-    }
+    _attributeVector[index]._dataType = dataType;
    _rtiObjectClass->setAttributeDataType(index, dataType);
 }
 HLAUpdateType
 HLAObjectClass::getAttributeUpdateType(unsigned index) const
 {
-    if (!_rtiObjectClass.valid()) {
+    if (_attributeVector.size() <= index)
        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeUpdateType(): No RTIObject class for object class \"" << getName() << "\"!");
        return HLAUndefinedUpdate;
-    }
+    return _attributeVector[index]._updateType;
    return _rtiObjectClass->getAttributeUpdateType(index);
 }
 void
 HLAObjectClass::setAttributeUpdateType(unsigned index, HLAUpdateType updateType)
 {
-    if (!_rtiObjectClass.valid()) {
+    if (_attributeVector.size() <= index)
        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::setAttributeUpdateType(): "
               "No RTIObject class for object class \"" << getName() << "\"!");
        return;
-    }
+    _attributeVector[index]._updateType = updateType;
-    _rtiObjectClass->setAttributeUpdateType(index, updateType);
+}
 HLASubscriptionType
 HLAObjectClass::getAttributeSubscriptionType(unsigned index) const
 {
    if (_attributeVector.size() <= index)
        return HLAUnsubscribed;
    return _attributeVector[index]._subscriptionType;
 }
 void
 HLAObjectClass::setAttributeSubscriptionType(unsigned index, HLASubscriptionType subscriptionType)
 {
    if (_attributeVector.size() <= index)
        return;
    _attributeVector[index]._subscriptionType = subscriptionType;
 }
 HLAPublicationType
 HLAObjectClass::getAttributePublicationType(unsigned index) const
 {
    if (_attributeVector.size() <= index)
        return HLAUnpublished;
    return _attributeVector[index]._publicationType;
 }
 void
 HLAObjectClass::setAttributePublicationType(unsigned index, HLAPublicationType publicationType)
 {
    if (_attributeVector.size() <= index)
        return;
    _attributeVector[index]._publicationType = publicationType;
 }
 HLADataElement::IndexPathPair
-HLAObjectClass::getIndexPathPair(const HLADataElement::AttributePathPair& attributePathPair) const
+HLAObjectClass::getIndexPathPair(const HLADataElement::StringPathPair& stringPathPair) const
 {
-    unsigned index = getAttributeIndex(attributePathPair.first);
+    unsigned index = getAttributeIndex(stringPathPair.first);
    if (getNumAttributes() <= index) {
        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::getIndexPathPair(\""
-               << HLADataElement::toString(attributePathPair)
+               << HLADataElement::toString(stringPathPair)
-               << "\"): Could not resolve attribute \"" << attributePathPair.first
+               << "\"): Could not resolve attribute \"" << stringPathPair.first
               << "\" for object class \"" << getName() << "\"!");
    }
-    return HLADataElement::IndexPathPair(index, attributePathPair.second);
+    return HLADataElement::IndexPathPair(index, stringPathPair.second);
 }
 HLADataElement::IndexPathPair
 HLAObjectClass::getIndexPathPair(const std::string& path) const
 {
-    return getIndexPathPair(HLADataElement::toAttributePathPair(path));
+    return getIndexPathPair(HLADataElement::toStringPathPair(path));
 }
 bool
-HLAObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
+HLAObjectClass::subscribe()
 {
    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): "
               "No RTIObject class for object class \"" << getName() << "\"!");
        return false;
    }
-    return _rtiObjectClass->subscribe(indexSet, active);
+
    HLAIndexList indexList;
    for (unsigned i = 1; i < getNumAttributes(); ++i) {
        if (_attributeVector[i]._subscriptionType != HLASubscribedActive)
            continue;
        indexList.push_back(i);
    }
    if (!indexList.empty()) {
        if (!_rtiObjectClass->subscribe(indexList, true))
            return false;
    }
    indexList.clear();
    for (unsigned i = 1; i < getNumAttributes(); ++i) {
        if (_attributeVector[i]._subscriptionType != HLASubscribedPassive)
            continue;
        indexList.push_back(i);
    }
    if (!indexList.empty()) {
        if (!_rtiObjectClass->subscribe(indexList, false))
            return false;
    }
    return true;
 }
 bool
 HLAObjectClass::unsubscribe()
 {
    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unsubscribe(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unsubscribe(): "
               "No RTIObject class for object class \"" << getName() << "\"!");
        return false;
    }
    return _rtiObjectClass->unsubscribe();
 }
 bool
-HLAObjectClass::publish(const std::set<unsigned>& indexSet)
+HLAObjectClass::publish()
 {
    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): "
               "No RTIObject class for object class \"" << getName() << "\"!");
        return false;
    }
-    return _rtiObjectClass->publish(indexSet);
+
    HLAIndexList indexList;
    for (unsigned i = 1; i < getNumAttributes(); ++i) {
        if (_attributeVector[i]._publicationType == HLAUnpublished)
            continue;
        indexList.push_back(i);
    }
    if (indexList.empty())
        return true;
    if (!_rtiObjectClass->publish(indexList))
        return false;
    return true;
 }
 bool
 HLAObjectClass::unpublish()
 {
    if (!_rtiObjectClass.valid()) {
-        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unpublish(): No RTIObject class for object class \"" << getName() << "\"!");
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unpublish(): "
               "No RTIObject class for object class \"" << getName() << "\"!");
        return false;
    }
    return _rtiObjectClass->unpublish();
@@ -207,82 +297,135 @@ HLAObjectClass::stopRegistration() const
 }
 HLAObjectInstance*
-HLAObjectClass::createObjectInstance(RTIObjectInstance* rtiObjectInstance)
+HLAObjectClass::createObjectInstance(const std::string& name)
 {
-    return new HLAObjectInstance(this, rtiObjectInstance);
+    HLAObjectInstance* objectInstance = createObjectInstance();
    if (objectInstance)
        return objectInstance;
    SGSharedPtr<HLAFederate> federate = _federate.lock();
    if (!federate.valid())
        return 0;
    return federate->createObjectInstance(this, name);
 }
 HLAObjectInstance*
 HLAObjectClass::createObjectInstance()
 {
    return 0;
 }
 void
-HLAObjectClass::discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag)
+HLAObjectClass::_setRTIObjectClass(RTIObjectClass* objectClass)
 {
-    SGSharedPtr<HLAObjectInstance> hlaObjectInstance = createObjectInstance(objectInstance);
+    if (_rtiObjectClass) {
-    if (hlaObjectInstance.valid()) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: Setting RTIObjectClass twice for object class \"" << getName() << "\"!");
-        SG_LOG(SG_NETWORK, SG_INFO, "RTI: create new object instance for discovered \""
+        return;
               << hlaObjectInstance->getName() << "\" object");
        _objectInstanceSet.insert(hlaObjectInstance);
        discoverInstanceCallback(*hlaObjectInstance, tag);
    } else {
        SG_LOG(SG_NETWORK, SG_INFO, "RTI: local delete of \"" << objectInstance->getName() << "\"");
        objectInstance->localDeleteObjectInstance();
    }
-}
+    _rtiObjectClass = objectClass;
-
+    if (_rtiObjectClass->_objectClass != this) {
-void
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass: backward reference does not match!");
 HLAObjectClass::removeInstance(HLAObjectInstance& hlaObjectInstance, const RTIData& tag)
 {
    SG_LOG(SG_NETWORK, SG_INFO, "RTI: remove object instance \"" << hlaObjectInstance.getName() << "\"");
    removeInstanceCallback(hlaObjectInstance, tag);
    _objectInstanceSet.erase(&hlaObjectInstance);
 }
 void
 HLAObjectClass::registerInstance(HLAObjectInstance& objectInstance)
 {
    _objectInstanceSet.insert(&objectInstance);
    registerInstanceCallback(objectInstance);
 }
 void
 HLAObjectClass::deleteInstance(HLAObjectInstance& objectInstance)
 {
    deleteInstanceCallback(objectInstance);
    _objectInstanceSet.erase(&objectInstance);
 }
 void
 HLAObjectClass::discoverInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const
 {
    if (!_instanceCallback.valid())
        return;
-    _instanceCallback->discoverInstance(*this, objectInstance, tag);
+    }
    for (unsigned i = 0; i < _attributeVector.size(); ++i)
        _resolveAttributeIndex(_attributeVector[i]._name, i);
 }
 void
-HLAObjectClass::removeInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const
+HLAObjectClass::_resolveAttributeIndex(const std::string& name, unsigned index)
 {
-    if (!_instanceCallback.valid())
+    if (!_rtiObjectClass)
        return;
    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::registerInstanceCallback(HLAObjectInstance& objectInstance) const
+HLAObjectClass::_registerInstance(HLAObjectInstance* objectInstance)
 {
-    if (!_instanceCallback.valid())
+    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;
-    _instanceCallback->registerInstance(*this, objectInstance);
+    }
    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::deleteInstanceCallback(HLAObjectInstance& objectInstance) const
+HLAObjectClass::_deleteInstance(HLAObjectInstance& objectInstance)
 {
-    if (!_instanceCallback.valid())
+    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::startRegistrationCallback()
+HLAObjectClass::_startRegistration()
 {
    if (_registrationCallback.valid())
        _registrationCallback->startRegistration(*this);
@@ -291,7 +434,7 @@ HLAObjectClass::startRegistrationCallback()
 }
 void
-HLAObjectClass::stopRegistrationCallback()
+HLAObjectClass::_stopRegistration()
 {
    if (_registrationCallback.valid())
        _registrationCallback->stopRegistration(*this);
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,12 +18,12 @@
 #ifndef HLAObjectClass_hxx
 #define HLAObjectClass_hxx
 #include <set>
 #include <string>
 #include <vector>
 #include "HLADataType.hxx"
 #include "HLAObjectInstance.hxx"
 #include "HLATypes.hxx"
 namespace simgear {
@@ -32,30 +32,56 @@ class HLAFederate;
 class HLAObjectClass : public SGWeakReferenced {
 public:
-    HLAObjectClass(const std::string& name, HLAFederate& federate);
+    HLAObjectClass(const std::string& name, HLAFederate* federate);
    virtual ~HLAObjectClass();
-    const std::string& getName() const
+    /// Return the name of this object class
-    { return _name; }
+    const std::string& getName() const;
    /// return the federate this class belongs to
    const SGWeakPtr<HLAFederate>& getFederate() const;
    /// Return the number of attributes in this object class
    unsigned getNumAttributes() const;
    /// Adds a new attribute to this object class, return the index
    unsigned addAttribute(const std::string& name);
    /// Return the attribute index for the attribute with the given name
    unsigned getAttributeIndex(const std::string& name) const;
    /// Return the attribute name for the attribute with the given index
    std::string getAttributeName(unsigned index) const;
    /// Return the data type of the attribute with the given index
    const HLADataType* getAttributeDataType(unsigned index) const;
-    void setAttributeDataType(unsigned index, const HLADataType*);
+    /// Sets the data type of the attribute with the given index to dataType
    void setAttributeDataType(unsigned index, const HLADataType* dataType);
    /// Return the update type of the attribute with the given index
    HLAUpdateType getAttributeUpdateType(unsigned index) const;
    /// Sets the update type of the attribute with the given index to updateType
    void setAttributeUpdateType(unsigned index, HLAUpdateType updateType);
-    HLADataElement::IndexPathPair getIndexPathPair(const HLADataElement::AttributePathPair&) const;
+    /// Return the subscription type of the attribute with the given index
    HLASubscriptionType getAttributeSubscriptionType(unsigned index) const;
    /// Sets the subscription type of the attribute with the given index to subscriptionType
    void setAttributeSubscriptionType(unsigned index, HLASubscriptionType subscriptionType);
    /// Return the publication type of the attribute with the given index
    HLAPublicationType getAttributePublicationType(unsigned index) const;
    /// Sets the publication type of the attribute with the given index to publicationType
    void setAttributePublicationType(unsigned index, HLAPublicationType publicationType);
    /// Return the index, path pair for the given string path pair
    HLADataElement::IndexPathPair getIndexPathPair(const HLADataElement::StringPathPair&) const;
    /// Return the index, path pair for the given string path
    HLADataElement::IndexPathPair getIndexPathPair(const std::string& path) const;
-    bool subscribe(const std::set<unsigned>& indexSet, bool active);
+    virtual bool subscribe();
-    bool unsubscribe();
+    virtual bool unsubscribe();
-    bool publish(const std::set<unsigned>& indexSet);
+    virtual bool publish();
-    bool unpublish();
+    virtual bool unpublish();
    // Object instance creation and destruction
    class InstanceCallback : public SGReferenced {
@@ -74,6 +100,11 @@ public:
    const SGSharedPtr<InstanceCallback>& getInstanceCallback() const
    { return _instanceCallback; }
    // Is called by the default registration callback if installed
    // Should register the already known object instances of this class.
    virtual void startRegistration() const;
    virtual void stopRegistration() const;
    // Handles startRegistrationForObjectClass and stopRegistrationForObjectClass events
    class RegistrationCallback : public SGReferenced {
    public:
@@ -87,43 +118,61 @@ public:
    const SGSharedPtr<RegistrationCallback>& getRegistrationCallback() const
    { return _registrationCallback; }
-    // Is called by the default registration callback if installed
+    /// Create a new instance of this class.
-    void startRegistration() const;
+    virtual HLAObjectInstance* createObjectInstance(const std::string& name);
-    void stopRegistration() const;
+    virtual HLAObjectInstance* createObjectInstance(); // deprecated
 protected:
    virtual HLAObjectInstance* createObjectInstance(RTIObjectInstance* rtiObjectInstance);
 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 _discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag);
-    void removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag);
+    void _removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag);
-    void registerInstance(HLAObjectInstance& objectInstance);
+    void _registerInstance(HLAObjectInstance* objectInstance);
-    void deleteInstance(HLAObjectInstance& objectInstance);
+    void _deleteInstance(HLAObjectInstance& objectInstance);
-    void discoverInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const;
+    void _startRegistration();
-    void removeInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const;
+    void _stopRegistration();
    void registerInstanceCallback(HLAObjectInstance& objectInstance) const;
    void deleteInstanceCallback(HLAObjectInstance& objectInstance) const;
    void startRegistrationCallback();
    void stopRegistrationCallback();
    friend class HLAObjectInstance;
    friend class RTIObjectClass;
-    // The object class name
+    struct Attribute {
        Attribute() : _subscriptionType(HLAUnsubscribed), _publicationType(HLAUnpublished), _updateType(HLAUndefinedUpdate) {}
        Attribute(const std::string& name) : _name(name), _subscriptionType(HLAUnsubscribed), _publicationType(HLAUnpublished), _updateType(HLAUndefinedUpdate) {}
        std::string _name;
        SGSharedPtr<const HLADataType> _dataType;
        HLASubscriptionType _subscriptionType;
        HLAPublicationType _publicationType;
        HLAUpdateType _updateType;
    };
    typedef std::vector<Attribute> AttributeVector;
    typedef std::map<std::string,unsigned> NameIndexMap;
    /// The parent federate.
    SGWeakPtr<HLAFederate> _federate;
    /// The object class name
    std::string _name;
-    // The underlying rti dispatcher class
+    /// The underlying rti dispatcher class
    SGSharedPtr<RTIObjectClass> _rtiObjectClass;
    /// The attribute data
    AttributeVector _attributeVector;
    /// The mapping from attribute names to attribute indices
    NameIndexMap _nameIndexMap;
    // Callback classes
    SGSharedPtr<InstanceCallback> _instanceCallback;
    SGSharedPtr<RegistrationCallback> _registrationCallback;
-    // The set of active objects
+    friend class HLAFederate;
    typedef std::set<SGSharedPtr<HLAObjectInstance> > ObjectInstanceSet;
    ObjectInstanceSet _objectInstanceSet;
 };
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,115 +15,148 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLAObjectInstance.hxx"
 #include <algorithm>
 #include "simgear/debug/logstream.hxx"
 #include "HLAArrayDataElement.hxx"
 #include "HLABasicDataElement.hxx"
 #include "HLADataElement.hxx"
 #include "HLAEnumeratedDataElement.hxx"
 #include "HLAFederate.hxx"
 #include "HLAFixedRecordDataElement.hxx"
 #include "HLAObjectClass.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 #include "RTIObjectClass.hxx"
 #include "RTIObjectInstance.hxx"
 namespace simgear {
-HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass) :
+HLAObjectInstance::UpdateCallback::~UpdateCallback()
    _objectClass(objectClass)
 {
 }
-HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass, RTIObjectInstance* rtiObjectInstance) :
+HLAObjectInstance::ReflectCallback::~ReflectCallback()
    _objectClass(objectClass),
    _rtiObjectInstance(rtiObjectInstance)
 {
-    _rtiObjectInstance->_hlaObjectInstance = this;
+}
-    _name = _rtiObjectInstance->getName();
+
 HLAObjectInstance::HLAObjectInstance(HLAObjectClass* objectClass) :
    _objectClass(objectClass)
 {
    if (objectClass)
        _federate = objectClass->_federate;
 }
 HLAObjectInstance::~HLAObjectInstance()
 {
    _clearRTIObjectInstance();
 }
-SGSharedPtr<HLAObjectClass>
+const std::string&
 HLAObjectInstance::getName() const
 {
    return _name;
 }
 const SGWeakPtr<HLAFederate>&
 HLAObjectInstance::getFederate() const
 {
    return _federate;
 }
 const SGSharedPtr<HLAObjectClass>&
 HLAObjectInstance::getObjectClass() const
 {
-    return _objectClass.lock();
+    return _objectClass;
 }
 unsigned
 HLAObjectInstance::getNumAttributes() const
 {
-    if (!_rtiObjectInstance.valid()) {
+    if (!_objectClass.valid())
        SG_LOG(SG_IO, SG_ALERT, "Trying to get number of attributes for inactive object!");
        return 0;
-    }
+    return _objectClass->getNumAttributes();
    return _rtiObjectInstance->getNumAttributes();
 }
 unsigned
 HLAObjectInstance::getAttributeIndex(const std::string& name) const
 {
-    if (!_rtiObjectInstance.valid()) {
+    if (!_objectClass.valid())
-        SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute index for inactive object!");
+        return ~0u;
-        return 0;
+    return _objectClass->getAttributeIndex(name);
    }
    return _rtiObjectInstance->getAttributeIndex(name);
 }
 std::string
 HLAObjectInstance::getAttributeName(unsigned index) const
 {
-    if (!_rtiObjectInstance.valid()) {
+    if (!_objectClass.valid())
        SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute name for inactive object!");
        return std::string();
-    }
+    return _objectClass->getAttributeName(index);
-    return _rtiObjectInstance->getAttributeName(index);
+}
 bool
 HLAObjectInstance::getAttributeOwned(unsigned index) const
 {
    if (!_rtiObjectInstance.valid())
        return false;
    return _rtiObjectInstance->getAttributeOwned(index);
 }
 const HLADataType*
 HLAObjectInstance::getAttributeDataType(unsigned index) const
 {
-    if (!_rtiObjectInstance.valid()) {
+    if (!_objectClass.valid())
        SG_LOG(SG_IO, SG_ALERT, "Trying to get attribute index for inactive object!");
        return 0;
-    }
+    return _objectClass->getAttributeDataType(index);
    return _rtiObjectInstance->getAttributeDataType(index);
 }
 void
 HLAObjectInstance::setAttributeDataElement(unsigned index, SGSharedPtr<HLADataElement> dataElement)
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
        return;
    }
    _rtiObjectInstance->setDataElement(index, dataElement);
 }
 HLADataElement*
 HLAObjectInstance::getAttributeDataElement(unsigned index)
 {
-    if (!_rtiObjectInstance.valid()) {
+    if (_attributeVector.size() <= index)
        SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
        return 0;
-    }
+    return _attributeVector[index]._dataElement.get();
    return _rtiObjectInstance->getDataElement(index);
 }
 const HLADataElement*
 HLAObjectInstance::getAttributeDataElement(unsigned index) const
 {
-    if (!_rtiObjectInstance.valid()) {
+    if (_attributeVector.size() <= index)
        SG_LOG(SG_IO, SG_ALERT, "Trying to set data element for inactive object!");
        return 0;
-    }
+    return _attributeVector[index]._dataElement.get();
    return _rtiObjectInstance->getDataElement(index);
 }
-class HLAObjectInstance::DataElementFactoryVisitor : public HLADataTypeVisitor {
+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)
@@ -150,7 +183,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLASCharDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAUInt8DataType& dataType)
    {
@@ -158,7 +191,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAUCharDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAInt16DataType& dataType)
    {
@@ -166,7 +199,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAShortDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAUInt16DataType& dataType)
    {
@@ -174,7 +207,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAUShortDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAInt32DataType& dataType)
    {
@@ -182,7 +215,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAIntDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAUInt32DataType& dataType)
    {
@@ -190,7 +223,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAUIntDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAInt64DataType& dataType)
    {
@@ -198,7 +231,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLALongDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAUInt64DataType& dataType)
    {
@@ -206,7 +239,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAULongDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAFloat32DataType& dataType)
    {
@@ -214,7 +247,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAFloatDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAFloat64DataType& dataType)
    {
@@ -222,7 +255,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLADoubleDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    class ArrayDataElementFactory : public HLAArrayDataElement::DataElementFactory {
@@ -287,7 +320,7 @@ public:
        if (_dataElement.valid())
            return;
-        _dataElement = new HLAEnumeratedDataElement(&dataType);
+        HLADataElementFactoryVisitor::apply(dataType);
    }
    virtual void apply(const HLAFixedRecordDataType& dataType)
@@ -312,9 +345,9 @@ public:
        _dataElement = recordDataElement;
    }
-    class VariantDataElementFactory : public HLAVariantDataElement::DataElementFactory {
+    class VariantRecordDataElementFactory : public HLAVariantRecordDataElement::DataElementFactory {
    public:
-        VariantDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
+        VariantRecordDataElementFactory(const HLADataElement::Path& path, const HLAPathElementMap& pathElementMap) :
            _path(path)
        {
            for (HLAPathElementMap::const_iterator i = pathElementMap.lower_bound(path);
@@ -325,9 +358,9 @@ public:
                _pathElementMap.insert(*i);
            }
        }
-        virtual HLADataElement* createElement(const HLAVariantDataElement& element, unsigned index)
+        virtual HLADataElement* createElement(const HLAVariantRecordDataElement& element, unsigned index)
        {
-            const HLAVariantDataType* dataType = element.getDataType();
+            const HLAVariantRecordDataType* dataType = element.getDataType();
            if (!dataType)
                return 0;
            const HLADataType* alternativeDataType = element.getAlternativeDataType();
@@ -344,22 +377,19 @@ public:
        HLAPathElementMap _pathElementMap;
    };
-    virtual void apply(const HLAVariantDataType& dataType)
+    virtual void apply(const HLAVariantRecordDataType& dataType)
    {
        _dataElement = createDataElement(_path, dataType);
        if (_dataElement.valid())
            return;
-        SGSharedPtr<HLAVariantDataElement> variantDataElement;
+        SGSharedPtr<HLAVariantRecordDataElement> variantRecordDataElement;
-        variantDataElement = new HLAVariantDataElement(&dataType);
+        variantRecordDataElement = new HLAVariantRecordDataElement(&dataType);
-        variantDataElement->setDataElementFactory(new VariantDataElementFactory(_path, _pathElementMap));
+        variantRecordDataElement->setDataElementFactory(new VariantRecordDataElementFactory(_path, _pathElementMap));
-        _dataElement = variantDataElement;
+        _dataElement = variantRecordDataElement;
    }
    const SGSharedPtr<HLADataElement>& getDataElement() const
    { return _dataElement; }
 private:
    SGSharedPtr<HLADataElement> createDataElement(const HLADataElement::Path& path, const HLADataType& dataType)
    {
@@ -381,7 +411,6 @@ private:
        return dataElement;
    }
    SGSharedPtr<HLADataElement> _dataElement;
    const HLAPathElementMap& _pathElementMap;
    HLADataElement::Path _path;
 };
@@ -391,8 +420,8 @@ HLAObjectInstance::setAttribute(unsigned index, const HLAPathElementMap& pathEle
 {
    const HLADataType* dataType = getAttributeDataType(index);
    if (!dataType) {
-        SG_LOG(SG_IO, SG_ALERT, "Cannot get attribute data type for setting attribute at index "
+        SG_LOG(SG_IO, SG_ALERT, "Cannot get attribute data type for setting attribute \""
-               << index << "!");
+               << getAttributeName(index) << "\" at index " << index << "!");
        return;
    }
@@ -413,48 +442,38 @@ HLAObjectInstance::setAttributes(const HLAAttributePathElementMap& attributePath
    }
 }
 void
 HLAObjectInstance::requestAttributeUpdate(unsigned index)
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Trying to request attribute update for inactive object!");
        return;
    }
    _rtiObjectInstance->setRequestAttributeUpdate(index, true);
 }
 void
 HLAObjectInstance::requestAttributeUpdate()
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Trying to request attribute update for inactive object!");
        return;
    }
    _rtiObjectInstance->setRequestAttributeUpdate(true);
 }
 void
 HLAObjectInstance::registerInstance()
 {
    registerInstance(_objectClass.get());
 }
 void
 HLAObjectInstance::registerInstance(HLAObjectClass* objectClass)
 {
    if (_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Trying to register object " << getName() << " already known to the RTI!");
        return;
    }
-    SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
+    if (!objectClass) {
    if (!objectClass.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Could not register object with unknown object class!");
        return;
    }
-    // This error must have been flagged before
+    if (_objectClass.valid() && objectClass != _objectClass.get()) {
-    if (!objectClass->_rtiObjectClass.valid())
+        SG_LOG(SG_IO, SG_ALERT, "Could not change object class while registering!");
        return;
-    _rtiObjectInstance = objectClass->_rtiObjectClass->registerObjectInstance(this);
+    }
    _objectClass = objectClass;
    _federate = _objectClass->_federate;
    // This error must have been flagged before
    if (!_objectClass->_rtiObjectClass.valid())
        return;
    _setRTIObjectInstance(_objectClass->_rtiObjectClass->registerObjectInstance(this));
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Could not register object at the RTI!");
        return;
    }
-    _name = _rtiObjectInstance->getName();
+    _objectClass->_registerInstance(this);
    objectClass->registerInstance(*this);
 }
 void
@@ -464,81 +483,224 @@ HLAObjectInstance::deleteInstance(const RTIData& tag)
        SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
        return;
    }
-    SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
+    if (!_objectClass.valid())
    if (!objectClass.valid())
        return;
-    objectClass->deleteInstance(*this);
+    _objectClass->_deleteInstance(*this);
    _rtiObjectInstance->deleteObjectInstance(tag);
 }
 void
 HLAObjectInstance::localDeleteInstance()
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_ALERT, "Trying to delete inactive object!");
        return;
    }
   _rtiObjectInstance->localDeleteObjectInstance();
 }
 void
 HLAObjectInstance::updateAttributeValues(const RTIData& tag)
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
        return;
    }
    if (_attributeCallback.valid())
        _attributeCallback->updateAttributeValues(*this, tag);
-    _rtiObjectInstance->updateAttributeValues(tag);
+    if (_updateCallback.valid()) {
        _updateCallback->updateAttributeValues(*this, tag);
    } else {
        encodeAttributeValues();
        sendAttributeValues(tag);
    }
 }
 void
 HLAObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 {
    if (_attributeCallback.valid())
        _attributeCallback->updateAttributeValues(*this, tag);
    if (_updateCallback.valid()) {
        _updateCallback->updateAttributeValues(*this, timeStamp, tag);
    } else {
        encodeAttributeValues();
        sendAttributeValues(timeStamp, tag);
    }
 }
 void
 HLAObjectInstance::encodeAttributeValues()
 {
    unsigned numAttributes = _attributeVector.size();
    for (unsigned i = 0; i < numAttributes;++i) {
        if (_attributeVector[i]._unconditionalUpdate) {
            encodeAttributeValue(i);
        } else if (_attributeVector[i]._enabledUpdate) {
            const HLADataElement* dataElement = getAttributeDataElement(i);
            if (dataElement && dataElement->getDirty())
                encodeAttributeValue(i);
        }
    }
 }
 void
 HLAObjectInstance::encodeAttributeValue(unsigned index)
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
        return;
    }
    HLADataElement* dataElement = getAttributeDataElement(index);
    if (!dataElement)
        return;
    _rtiObjectInstance->encodeAttributeData(index, *dataElement);
    dataElement->setDirty(false);
 }
 void
 HLAObjectInstance::sendAttributeValues(const RTIData& tag)
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
        return;
    }
    _rtiObjectInstance->updateAttributeValues(tag);
 }
 void
 HLAObjectInstance::sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 {
    if (!_rtiObjectInstance.valid()) {
        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
        return;
    }
    if (_attributeCallback.valid())
        _attributeCallback->updateAttributeValues(*this, tag);
    _rtiObjectInstance->updateAttributeValues(timeStamp, tag);
 }
 void
-HLAObjectInstance::reflectQueuedAttributeValues(const SGTimeStamp& timeStamp)
+HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag)
 {
-    if (!_rtiObjectInstance.valid()) {
+    for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
-        SG_LOG(SG_IO, SG_INFO, "Not updating inactive object!");
+        reflectAttributeValue(*i, tag);
        return;
    }
    _rtiObjectInstance->reflectQueuedAttributeValues(timeStamp);
 }
 void
-HLAObjectInstance::removeInstance(const RTIData& tag)
+HLAObjectInstance::reflectAttributeValues(const HLAIndexList& indexList,
 {
    SGSharedPtr<HLAObjectClass> objectClass = _objectClass.lock();
    if (!objectClass.valid())
        return;
    objectClass->removeInstanceCallback(*this, tag);
 }
 void
 HLAObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const RTIData& tag)
 {
    if (!_attributeCallback.valid())
        return;
    _attributeCallback->reflectAttributeValues(*this, dataPairList, tag);
 }
 void
 HLAObjectInstance::reflectAttributeValues(const RTIIndexDataPairList& dataPairList,
                                          const SGTimeStamp& timeStamp, const RTIData& tag)
 {
-    if (!_attributeCallback.valid())
+    for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i)
        reflectAttributeValue(*i, timeStamp, tag);
 }
 void
 HLAObjectInstance::reflectAttributeValue(unsigned index, const RTIData& tag)
 {
    HLADataElement* dataElement = getAttributeDataElement(index);
    if (!dataElement)
        return;
    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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,56 +18,121 @@
 #ifndef HLAObjectInstance_hxx
 #define HLAObjectInstance_hxx
 #include <vector>
 #include <simgear/structure/SGWeakPtr.hxx>
 #include "HLADataElement.hxx"
 #include "HLATypes.hxx"
 class SGTimeStamp;
 namespace simgear {
 class RTIObjectInstance;
 class HLAFederate;
 class HLAObjectClass;
 class HLAObjectInstance : public SGWeakReferenced {
 public:
-    HLAObjectInstance(HLAObjectClass* objectClass);
+    HLAObjectInstance(HLAObjectClass* objectClass = 0);
    HLAObjectInstance(HLAObjectClass* objectClass, RTIObjectInstance* rtiObjectInstance);
    virtual ~HLAObjectInstance();
-    const std::string& getName() const
+    /// Return the name of this object instance
-    { return _name; }
+    const std::string& getName() const;
-    SGSharedPtr<HLAObjectClass> getObjectClass() const;
+    /// return the federate this instance belongs to
    const SGWeakPtr<HLAFederate>& getFederate() const;
    /// Return the object class of this instance.
    /// Should always return a valid object class.
    const SGSharedPtr<HLAObjectClass>& getObjectClass() const;
    /// Return the number of attributes
    unsigned getNumAttributes() const;
    /// Return the attribute index for the attribute with the given name
    unsigned getAttributeIndex(const std::string& name) const;
    /// Return the attribute name for the attribute with the given index
    std::string getAttributeName(unsigned index) const;
    /// Return true if the attribute with the given index is owned by
    /// this federate
    bool getAttributeOwned(unsigned index) const;
    /// Return the data type of the attribute with the given index
    const HLADataType* getAttributeDataType(unsigned index) const;
-    void setAttributeDataElement(unsigned index, SGSharedPtr<HLADataElement> dataElement);
+    /// Return the data element of the attribute with the given index
    HLADataElement* getAttributeDataElement(unsigned index);
    const HLADataElement* getAttributeDataElement(unsigned index) const;
    /// Write the raw attribute data value into data, works only of the object
    /// is backed up with an rti object instance
    bool getAttributeData(unsigned index, RTIData& data) const;
    /// Sets the data element of the attribute with the given index to dataElement
    void setAttributeDataElement(unsigned index, const SGSharedPtr<HLADataElement>& dataElement);
    /// Sets the data element of the attribute with the given index to the content of pathElementMap
    void setAttribute(unsigned index, const HLAPathElementMap& pathElementMap);
    void setAttributes(const HLAAttributePathElementMap& attributePathElementMap);
    // Ask the rti to provide the attribute at index
    void requestAttributeUpdate(unsigned index);
    void requestAttributeUpdate();
    void registerInstance();
    void registerInstance(HLAObjectClass* objectClass);
    void deleteInstance(const RTIData& tag);
    void localDeleteInstance();
    // Push the current values into the RTI
    virtual void updateAttributeValues(const RTIData& tag);
    virtual void updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
    // encode periodic and dirty attribute values for the next sendAttributeValues
    void encodeAttributeValues();
    // encode the attribute value at index i for the next sendAttributeValues
    void encodeAttributeValue(unsigned index);
    // Really sends the prepared attribute update values into the RTI
    void sendAttributeValues(const RTIData& tag);
    void sendAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
    class UpdateCallback : public SGReferenced {
    public:
        virtual ~UpdateCallback();
        virtual void updateAttributeValues(HLAObjectInstance&, const RTIData&) = 0;
        virtual void updateAttributeValues(HLAObjectInstance&, const SGTimeStamp&, const RTIData&) = 0;
    };
    void setUpdateCallback(const SGSharedPtr<UpdateCallback>& updateCallback)
    { _updateCallback = updateCallback; }
    const SGSharedPtr<UpdateCallback>& getUpdateCallback() const
    { return _updateCallback; }
    // Reflects the indices given in the index vector into the attributes HLADataElements.
    virtual void reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag);
    virtual void reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag);
    // Reflect a single attribute value at the given index into the attributes HLADataELement.
    virtual void reflectAttributeValue(unsigned index, const RTIData& tag);
    virtual void reflectAttributeValue(unsigned index, const SGTimeStamp& timeStamp, const RTIData& tag);
    class ReflectCallback : public SGReferenced {
    public:
        virtual ~ReflectCallback();
        virtual void reflectAttributeValues(HLAObjectInstance&, const HLAIndexList&, const RTIData&) = 0;
        virtual void reflectAttributeValues(HLAObjectInstance&, const HLAIndexList&, const SGTimeStamp&, const RTIData&) = 0;
    };
    void setReflectCallback(const SGSharedPtr<ReflectCallback>& reflectCallback)
    { _reflectCallback = reflectCallback; }
    const SGSharedPtr<ReflectCallback>& getReflectCallback() const
    { return _reflectCallback; }
    // deprecated.
    class AttributeCallback : public SGReferenced {
    public:
        virtual ~AttributeCallback() {}
        // Notification about reflect and whatever TBD
        // Hmm, don't know yet how this should look like
        virtual void updateAttributeValues(HLAObjectInstance& objectInstance, const RTIData& tag)
        { }
        virtual void reflectAttributeValues(HLAObjectInstance& objectInstance,
                                            const RTIIndexDataPairList& dataPairList, const RTIData& tag)
        { }
@@ -81,29 +146,57 @@ public:
    const SGSharedPtr<AttributeCallback>& getAttributeCallback() const
    { return _attributeCallback; }
    // Push the current values into the RTI
    void updateAttributeValues(const RTIData& tag);
    void updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
    // Retrieve queued up updates up to and including timestamp,
    // Note that this only applies to timestamped updates.
    // The unordered updates are reflected as they arrive
    void reflectQueuedAttributeValues(const SGTimeStamp& timeStamp);
 private:
-    void removeInstance(const RTIData& tag);
+    void _setRTIObjectInstance(RTIObjectInstance* rtiObjectInstance);
-    void reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const RTIData& tag);
+    void _clearRTIObjectInstance();
-    void reflectAttributeValues(const RTIIndexDataPairList& dataPairList, const SGTimeStamp& timeStamp, const RTIData& tag);
+
-    friend class RTIObjectInstance;
+    // The callback entry points from the RTI interface classes.
-    friend class HLAObjectClass;
+    void _removeInstance(const RTIData& tag);
    void _reflectAttributeValues(const HLAIndexList& indexList, const RTIData& tag);
    void _reflectAttributeValues(const HLAIndexList& indexList, const SGTimeStamp& timeStamp, const RTIData& tag);
    class DataElementFactoryVisitor;
    struct Attribute {
        Attribute() : _enabledUpdate(false), _unconditionalUpdate(false) {}
        SGSharedPtr<HLADataElement> _dataElement;
        bool _enabledUpdate;
        bool _unconditionalUpdate;
        // HLAIndexList::iterator _unconditionalUpdateAttributeIndexListIterator;
        // HLAIndexList::iterator _conditionalUpdateAttributeIndexListIterator;
    };
    typedef std::vector<Attribute> AttributeVector;
    // At some time we want these: Until then, use the _enabledUpdate and _unconditionalUpdate flags in the Attribute struct.
    // HLAIndexList _unconditionalUpdateAttributeIndexList;
    // HLAIndexList _conditionalUpdateAttributeIndexList;
    /// The parent Federate
    SGWeakPtr<HLAFederate> _federate;
    /// The ObjectClass
    SGSharedPtr<HLAObjectClass> _objectClass;
    /// The name as known in the RTI
    std::string _name;
-    SGWeakPtr<HLAObjectClass> _objectClass;
+    // /// The name as given by the local created instance
    // std::string _givenName;
    /// The underlying rti dispatcher class
    SGSharedPtr<RTIObjectInstance> _rtiObjectInstance;
    /// The attribute data
    AttributeVector _attributeVector;
    // Callback classes
    SGSharedPtr<UpdateCallback> _updateCallback;
    SGSharedPtr<ReflectCallback> _reflectCallback;
    SGSharedPtr<AttributeCallback> _attributeCallback;
    friend class HLAFederate;
    friend class HLAObjectClass;
    friend class RTIObjectInstance;
 };
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,197 +15,424 @@
 // 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::DecodeVisitor : public HLADataTypeDecodeVisitor {
+class HLAPropertyDataElement::ScalarDecodeVisitor : public HLADataTypeDecodeVisitor {
 public:
-    DecodeVisitor(HLADecodeStream& stream, HLAPropertyReference& propertyReference) :
+    ScalarDecodeVisitor(HLADecodeStream& stream, SGPropertyNode& propertyNode) :
        HLADataTypeDecodeVisitor(stream),
-        _propertyReference(propertyReference)
+        _propertyNode(propertyNode)
    { }
    virtual ~ScalarDecodeVisitor()
    { }
    virtual void apply(const HLAInt8DataType& dataType)
    {
        int8_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setIntValue(value);
+        _propertyNode.setIntValue(value);
    }
    virtual void apply(const HLAUInt8DataType& dataType)
    {
        uint8_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setIntValue(value);
+        _propertyNode.setIntValue(value);
    }
    virtual void apply(const HLAInt16DataType& dataType)
    {
        int16_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setIntValue(value);
+        _propertyNode.setIntValue(value);
    }
    virtual void apply(const HLAUInt16DataType& dataType)
    {
        uint16_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setIntValue(value);
+        _propertyNode.setIntValue(value);
    }
    virtual void apply(const HLAInt32DataType& dataType)
    {
        int32_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setIntValue(value);
+        _propertyNode.setIntValue(value);
    }
    virtual void apply(const HLAUInt32DataType& dataType)
    {
        uint32_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setIntValue(value);
+        _propertyNode.setIntValue(value);
    }
    virtual void apply(const HLAInt64DataType& dataType)
    {
        int64_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setLongValue(value);
+        _propertyNode.setLongValue(value);
    }
    virtual void apply(const HLAUInt64DataType& dataType)
    {
        uint64_t value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setLongValue(value);
+        _propertyNode.setLongValue(value);
    }
    virtual void apply(const HLAFloat32DataType& dataType)
    {
        float value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setFloatValue(value);
+        _propertyNode.setFloatValue(value);
    }
    virtual void apply(const HLAFloat64DataType& dataType)
    {
        double value = 0;
        dataType.decode(_stream, value);
-        _propertyReference.setDoubleValue(value);
+        _propertyNode.setDoubleValue(value);
    }
    virtual void apply(const HLAFixedArrayDataType& dataType)
    {
        unsigned numElements = dataType.getNumElements();
        std::string value;
        value.reserve(numElements);
        for (unsigned i = 0; i < numElements; ++i) {
            HLATemplateDecodeVisitor<char> visitor(_stream);
            dataType.getElementDataType()->accept(visitor);
            value.push_back(visitor.getValue());
        }
        _propertyReference.setStringValue(value);
    }
    virtual void apply(const HLAVariableArrayDataType& dataType)
    {
        HLATemplateDecodeVisitor<unsigned> numElementsVisitor(_stream);
        dataType.getSizeDataType()->accept(numElementsVisitor);
        unsigned numElements = numElementsVisitor.getValue();
        std::string value;
        value.reserve(numElements);
        for (unsigned i = 0; i < numElements; ++i) {
            HLATemplateDecodeVisitor<char> visitor(_stream);
            dataType.getElementDataType()->accept(visitor);
            value.push_back(visitor.getValue());
        }
        _propertyReference.setStringValue(value);
    }
 protected:
-    HLAPropertyReference& _propertyReference;
+    SGPropertyNode& _propertyNode;
 };
-class HLAPropertyDataElement::EncodeVisitor : public HLADataTypeEncodeVisitor {
+class HLAPropertyDataElement::ScalarEncodeVisitor : public HLADataTypeEncodeVisitor {
 public:
-    EncodeVisitor(HLAEncodeStream& stream, const HLAPropertyReference& propertyReference) :
+    ScalarEncodeVisitor(HLAEncodeStream& stream, const SGPropertyNode& propertyNode) :
        HLADataTypeEncodeVisitor(stream),
-        _propertyReference(propertyReference)
+        _propertyNode(propertyNode)
    { }
    virtual ~ScalarEncodeVisitor()
    { }
    virtual void apply(const HLAInt8DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getIntValue());
+        dataType.encode(_stream, _propertyNode.getIntValue());
    }
    virtual void apply(const HLAUInt8DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getIntValue());
+        dataType.encode(_stream, _propertyNode.getIntValue());
    }
    virtual void apply(const HLAInt16DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getIntValue());
+        dataType.encode(_stream, _propertyNode.getIntValue());
    }
    virtual void apply(const HLAUInt16DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getIntValue());
+        dataType.encode(_stream, _propertyNode.getIntValue());
    }
    virtual void apply(const HLAInt32DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getIntValue());
+        dataType.encode(_stream, _propertyNode.getIntValue());
    }
    virtual void apply(const HLAUInt32DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getIntValue());
+        dataType.encode(_stream, _propertyNode.getIntValue());
    }
    virtual void apply(const HLAInt64DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getLongValue());
+        dataType.encode(_stream, _propertyNode.getLongValue());
    }
    virtual void apply(const HLAUInt64DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getLongValue());
+        dataType.encode(_stream, _propertyNode.getLongValue());
    }
    virtual void apply(const HLAFloat32DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getFloatValue());
+        dataType.encode(_stream, _propertyNode.getFloatValue());
    }
    virtual void apply(const HLAFloat64DataType& dataType)
    {
-        dataType.encode(_stream, _propertyReference.getDoubleValue());
+        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)
    {
-        unsigned numElements = dataType.getNumElements();
+        if (dataType.getIsString()) {
-        std::string value = _propertyReference.getStringValue();
+            _dataElement = new StringDataElement(&dataType, _propertyNode.get());
        for (unsigned i = 0; i < numElements; ++i) {
            if (i < value.size()) {
                HLATemplateEncodeVisitor<char> visitor(_stream, value[i]);
                dataType.getElementDataType()->accept(visitor);
        } else {
-                HLADataTypeEncodeVisitor visitor(_stream);
+            SGSharedPtr<HLAArrayDataElement> arrayDataElement;
-                dataType.getElementDataType()->accept(visitor);
+            arrayDataElement = new HLAArrayDataElement(&dataType);
-            }
+            arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_propertyNode.get()));
            arrayDataElement->setNumElements(dataType.getNumElements());
            _dataElement = arrayDataElement;
        }
    }
    virtual void apply(const HLAVariableArrayDataType& dataType)
    {
-        std::string value = _propertyReference.getStringValue();
+        if (dataType.getIsString()) {
-        HLATemplateEncodeVisitor<std::string::size_type> numElementsVisitor(_stream, value.size());
+            _dataElement = new StringDataElement(&dataType, _propertyNode.get());
-        dataType.getSizeDataType()->accept(numElementsVisitor);
+        } else {
-        for (unsigned i = 0; i < value.size(); ++i) {
+            SGSharedPtr<HLAArrayDataElement> arrayDataElement;
-            HLATemplateEncodeVisitor<char> visitor(_stream, value[i]);
+            arrayDataElement = new HLAArrayDataElement(&dataType);
-            dataType.getElementDataType()->accept(visitor);
+            arrayDataElement->setDataElementFactory(new ArrayDataElementFactory(_propertyNode.get()));
            _dataElement = arrayDataElement;
        }
    }
-protected:
+    virtual void apply(const HLAEnumeratedDataType& dataType)
-    const HLAPropertyReference& _propertyReference;
+    {
        _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(HLAPropertyReference* propertyReference) :
+HLAPropertyDataElement::HLAPropertyDataElement()
    _propertyReference(propertyReference)
 {
 }
-HLAPropertyDataElement::HLAPropertyDataElement(const simgear::HLADataType* dataType, HLAPropertyReference* propertyReference) :
+HLAPropertyDataElement::HLAPropertyDataElement(SGPropertyNode* propertyNode)
-    _dataType(dataType),
+{
-    _propertyReference(propertyReference)
+    setPropertyNode(propertyNode);
 }
 HLAPropertyDataElement::HLAPropertyDataElement(const HLADataType* dataType, SGPropertyNode* propertyNode) :
    _dataType(dataType)
 {
    setPropertyNode(propertyNode);
 }
 HLAPropertyDataElement::HLAPropertyDataElement(const HLADataType* dataType) :
    _dataType(dataType)
 {
 }
@@ -213,34 +440,72 @@ 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;
    if (_propertyReference.valid()) {
        EncodeVisitor visitor(stream, *_propertyReference);
        _dataType->accept(visitor);
    } else {
        HLADataTypeEncodeVisitor visitor(stream);
        _dataType->accept(visitor);
    }
        return true;
    }
 }
 bool
 HLAPropertyDataElement::decode(HLADecodeStream& stream)
 {
-    if (!_dataType.valid())
+    if (_dataElement.valid()) {
        return _dataElement->decode(stream);
    } else if (!_dataType.valid()) {
        // We cant do anything if the data type is not valid
        return false;
-    if (_propertyReference.valid()) {
+    } else {
-        DecodeVisitor visitor(stream, *_propertyReference);
+        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*
@@ -252,18 +517,52 @@ HLAPropertyDataElement::getDataType() const
 bool
 HLAPropertyDataElement::setDataType(const HLADataType* dataType)
 {
    if (dataType->toBasicDataType()) {
        _dataType = dataType;
        return true;
    } else {
        const HLAArrayDataType* arrayDataType = dataType->toArrayDataType();
        if (arrayDataType && arrayDataType->getElementDataType() &&
            arrayDataType->getElementDataType()->toBasicDataType()) {
    _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 false;
+
    return dataElement.release();
 }
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// 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
@@ -18,140 +18,21 @@
 #ifndef HLAPropertyDataElement_hxx
 #define HLAPropertyDataElement_hxx
 #include <set>
 #include <simgear/props/props.hxx>
 #include "HLADataElement.hxx"
 namespace simgear {
 class HLAPropertyReference : public SGReferenced {
 public:
    HLAPropertyReference()
    { }
    HLAPropertyReference(const std::string& relativePath) :
        _relativePath(relativePath)
    { }
    void setIntValue(int value)
    {
        if (!_propertyNode.valid())
            return;
        _propertyNode->setIntValue(value);
    }
    int getIntValue() const
    {
        if (!_propertyNode.valid())
            return 0;
        return _propertyNode->getIntValue();
    }
    void setLongValue(long value)
    {
        if (!_propertyNode.valid())
            return;
        _propertyNode->setLongValue(value);
    }
    long getLongValue() const
    {
        if (!_propertyNode.valid())
            return 0;
        return _propertyNode->getLongValue();
    }
    void setFloatValue(float value)
    {
        if (!_propertyNode.valid())
            return;
        _propertyNode->setFloatValue(value);
    }
    float getFloatValue() const
    {
        if (!_propertyNode.valid())
            return 0;
        return _propertyNode->getFloatValue();
    }
    void setDoubleValue(double value)
    {
        if (!_propertyNode.valid())
            return;
        _propertyNode->setDoubleValue(value);
    }
    double getDoubleValue() const
    {
        if (!_propertyNode.valid())
            return 0;
        return _propertyNode->getDoubleValue();
    }
    void setStringValue(const std::string& value)
    {
        if (!_propertyNode.valid())
            return;
        _propertyNode->setStringValue(value);
    }
    std::string getStringValue() const
    {
        if (!_propertyNode.valid())
            return std::string();
        return _propertyNode->getStringValue();
    }
    SGPropertyNode* getPropertyNode()
    { return _propertyNode.get(); }
    void setRootNode(SGPropertyNode* rootNode)
    {
        if (!rootNode)
            _propertyNode.clear();
        else
            _propertyNode = rootNode->getNode(_relativePath, true);
    }
 private:
    std::string _relativePath;
    SGSharedPtr<SGPropertyNode> _propertyNode;
 };
 class HLAPropertyReferenceSet : public SGReferenced {
 public:
    void insert(const SGSharedPtr<HLAPropertyReference>& propertyReference)
    {
        _propertyReferenceSet.insert(propertyReference);
        propertyReference->setRootNode(_rootNode.get());
    }
    void remove(const SGSharedPtr<HLAPropertyReference>& propertyReference)
    {
        PropertyReferenceSet::iterator i = _propertyReferenceSet.find(propertyReference);
        if (i == _propertyReferenceSet.end())
            return;
        _propertyReferenceSet.erase(i);
        propertyReference->setRootNode(0);
    }
    void setRootNode(SGPropertyNode* rootNode)
    {
        _rootNode = rootNode;
        for (PropertyReferenceSet::iterator i = _propertyReferenceSet.begin();
             i != _propertyReferenceSet.end(); ++i) {
            (*i)->setRootNode(_rootNode.get());
        }
    }
    SGPropertyNode* getRootNode()
    { return _rootNode.get(); }
 private:
    SGSharedPtr<SGPropertyNode> _rootNode;
    typedef std::set<SGSharedPtr<HLAPropertyReference> > PropertyReferenceSet;
    PropertyReferenceSet _propertyReferenceSet;
 };
 class HLAPropertyDataElement : public HLADataElement {
 public:
-    HLAPropertyDataElement(HLAPropertyReference* propertyReference);
+    HLAPropertyDataElement();
-    HLAPropertyDataElement(const simgear::HLADataType* dataType, HLAPropertyReference* propertyReference);
+    HLAPropertyDataElement(SGPropertyNode* propertyNode);
-    ~HLAPropertyDataElement();
+    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);
@@ -159,12 +40,25 @@ public:
    virtual const HLADataType* getDataType() const;
    virtual bool setDataType(const HLADataType* dataType);
    void setPropertyNode(SGPropertyNode* propertyNode);
    SGPropertyNode* getPropertyNode();
    const SGPropertyNode* getPropertyNode() const;
 private:
-    class DecodeVisitor;
+    HLADataElement*
-    class EncodeVisitor;
+    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<HLAPropertyReference> _propertyReference;
+    SGSharedPtr<HLADataElement> _dataElement;
    SGSharedPtr<SGPropertyNode> _propertyNode;
 };
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLARawDataElement.hxx"
 namespace simgear {
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,19 +15,33 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
-#ifndef HLA13Federate_hxx
+#ifndef HLATypes_hxx
-#define HLA13Federate_hxx
+#define HLATypes_hxx
-#include "HLAFederate.hxx"
+#include <list>
 namespace simgear {
-class HLA13Federate : public HLAFederate {
+enum HLASubscriptionType {
-public:
+    HLAUnsubscribed,
-    HLA13Federate();
+    HLASubscribedActive,
-    virtual ~HLA13Federate();
+    HLASubscribedPassive
 };
 enum HLAPublicationType {
    HLAUnpublished,
    HLAPublished
 };
 enum HLAUpdateType {
    HLAStaticUpdate,
    HLAPeriodicUpdate,
    HLAConditionalUpdate,
    HLAUndefinedUpdate
 };
 typedef std::list<unsigned> HLAIndexList;
 } // namespace simgear
 #endif
@@ -1,155 +0,0 @@
 // Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
 // License as published by the Free Software Foundation; either
 // version 2 of the License, or (at your option) any later version.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // Library General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #include "HLAVariantDataElement.hxx"
 #include <simgear/debug/logstream.hxx>
 namespace simgear {
 HLAAbstractVariantDataElement::HLAAbstractVariantDataElement(const HLAVariantDataType* dataType) :
    _dataType(dataType)
 {
 }
 HLAAbstractVariantDataElement::~HLAAbstractVariantDataElement()
 {
 }
 bool
 HLAAbstractVariantDataElement::decode(HLADecodeStream& stream)
 {
    if (!_dataType.valid())
        return false;
    return _dataType->decode(stream, *this);
 }
 bool
 HLAAbstractVariantDataElement::encode(HLAEncodeStream& stream) const
 {
    if (!_dataType.valid())
        return false;
    return _dataType->encode(stream, *this);
 }
 const HLAVariantDataType*
 HLAAbstractVariantDataElement::getDataType() const
 {
    return _dataType.get();
 }
 bool
 HLAAbstractVariantDataElement::setDataType(const HLADataType* dataType)
 {
    const HLAVariantDataType* variantDataType = dataType->toVariantDataType();
    if (!variantDataType) {
        SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantDataType: unable to set data type!");
        return false;
    }
    setDataType(variantDataType);
    return true;
 }
 void
 HLAAbstractVariantDataElement::setDataType(const HLAVariantDataType* dataType)
 {
    _dataType = dataType;
 }
 std::string
 HLAAbstractVariantDataElement::getAlternativeName() const
 {
    if (!_dataType.valid())
        return std::string();
    return _dataType->getAlternativeName(getAlternativeIndex());
 }
 const HLADataType*
 HLAAbstractVariantDataElement::getAlternativeDataType() const
 {
    if (!_dataType.valid())
        return 0;
    return _dataType->getAlternativeDataType(getAlternativeIndex());
 }
 HLAVariantDataElement::DataElementFactory::~DataElementFactory()
 {
 }
 HLAVariantDataElement::HLAVariantDataElement(const HLAVariantDataType* dataType) :
    HLAAbstractVariantDataElement(dataType),
    _alternativeIndex(~0u)
 {
 }
 HLAVariantDataElement::~HLAVariantDataElement()
 {
 }
 bool
 HLAVariantDataElement::setAlternativeIndex(unsigned index)
 {
    if (_alternativeIndex == index)
        return true;
    SGSharedPtr<HLADataElement> dataElement = newElement(index);
    if (!dataElement.valid())
        return false;
    _dataElement.swap(dataElement);
    _alternativeIndex = index;
    return true;
 }
 bool
 HLAVariantDataElement::decodeAlternative(HLADecodeStream& stream)
 {
    return _dataElement->decode(stream);
 }
 unsigned
 HLAVariantDataElement::getAlternativeIndex() const
 {
    return _alternativeIndex;
 }
 bool
 HLAVariantDataElement::encodeAlternative(HLAEncodeStream& stream) const
 {
    return _dataElement->encode(stream);
 }
 void
 HLAVariantDataElement::setDataElementFactory(HLAVariantDataElement::DataElementFactory* dataElementFactory)
 {
    _dataElementFactory = dataElementFactory;
 }
 HLAVariantDataElement::DataElementFactory*
 HLAVariantDataElement::getDataElementFactory()
 {
    return _dataElementFactory;
 }
 HLADataElement*
 HLAVariantDataElement::newElement(unsigned index)
 {
    if (!_dataElementFactory.valid())
        return 0;
    return _dataElementFactory->createElement(*this, index);
 }
 }
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,64 +18,13 @@
 #ifndef HLAVariantDataElement_hxx
 #define HLAVariantDataElement_hxx
 #include <string>
 #include <simgear/structure/SGSharedPtr.hxx>
 #include "HLADataElement.hxx"
 #include "HLAVariantDataType.hxx"
 #include "HLAVariantRecordDataElement.hxx"
 namespace simgear {
-class HLAAbstractVariantDataElement : public HLADataElement {
+typedef HLAAbstractVariantRecordDataElement HLAAbstractVariantDataElement;
-public:
+typedef HLAVariantRecordDataElement HLAVariantDataElement;
    HLAAbstractVariantDataElement(const HLAVariantDataType* dataType);
    virtual ~HLAAbstractVariantDataElement();
    virtual bool decode(HLADecodeStream& stream);
    virtual bool encode(HLAEncodeStream& stream) const;
    virtual const HLAVariantDataType* getDataType() const;
    virtual bool setDataType(const HLADataType* dataType);
    void setDataType(const HLAVariantDataType* dataType);
    std::string getAlternativeName() const;
    const HLADataType* getAlternativeDataType() const;
    virtual bool setAlternativeIndex(unsigned index) = 0;
    virtual bool decodeAlternative(HLADecodeStream& stream) = 0;
    virtual unsigned getAlternativeIndex() const = 0;
    virtual bool encodeAlternative(HLAEncodeStream& stream) const = 0;
 private:
    SGSharedPtr<const HLAVariantDataType> _dataType;
 };
 class HLAVariantDataElement : public HLAAbstractVariantDataElement {
 public:
    HLAVariantDataElement(const HLAVariantDataType* dataType);
    virtual ~HLAVariantDataElement();
    virtual bool setAlternativeIndex(unsigned index);
    virtual bool decodeAlternative(HLADecodeStream& stream);
    virtual unsigned getAlternativeIndex() const;
    virtual bool encodeAlternative(HLAEncodeStream& stream) const;
    class DataElementFactory : public SGReferenced {
    public:
        virtual ~DataElementFactory();
        virtual HLADataElement* createElement(const HLAVariantDataElement&, unsigned) = 0;
    };
    void setDataElementFactory(DataElementFactory* dataElementFactory);
    DataElementFactory* getDataElementFactory();
 private:
    HLADataElement* newElement(unsigned index);
    SGSharedPtr<HLADataElement> _dataElement;
    unsigned _alternativeIndex;
    SGSharedPtr<DataElementFactory> _dataElementFactory;
 };
 }
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -18,84 +18,11 @@
 #ifndef HLAVariantDataType_hxx
 #define HLAVariantDataType_hxx
-#include <string>
+#include "HLAVariantRecordDataType.hxx"
 #include <vector>
 #include "simgear/structure/SGSharedPtr.hxx"
 #include "HLADataType.hxx"
 #include "HLAEnumeratedDataType.hxx"
 namespace simgear {
-class HLAAbstractVariantDataElement;
+typedef HLAVariantRecordDataType HLAVariantDataType;
 class HLAVariantDataType : public HLADataType {
 public:
    HLAVariantDataType(const std::string& name = "HLAVariantDataType");
    virtual ~HLAVariantDataType();
    virtual void accept(HLADataTypeVisitor& visitor) const;
    virtual const HLAVariantDataType* toVariantDataType() const;
    virtual bool decode(HLADecodeStream& stream, HLAAbstractVariantDataElement& value) const;
    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractVariantDataElement& value) const;
    const HLAEnumeratedDataType* getEnumeratedDataType() const
    { return _enumeratedDataType.get(); }
    void setEnumeratedDataType(HLAEnumeratedDataType* dataType);
    bool addAlternative(const std::string& name, const std::string& enumerator,
                        const HLADataType* dataType, const std::string& semantics);
    unsigned getNumAlternatives() const
    { return _alternativeList.size(); }
    unsigned getAlternativeIndex(const std::string& enumerator) const
    {
        if (!_enumeratedDataType.valid())
            return ~unsigned(0);
        return _enumeratedDataType->getIndex(enumerator);
    }
    const HLADataType* getAlternativeDataType(unsigned index) const
    {
        if (_alternativeList.size() <= index)
            return 0;
        return _alternativeList[index]._dataType.get();
    }
    const HLADataType* getAlternativeDataType(const std::string& enumerator) const
    { return getAlternativeDataType(getAlternativeIndex(enumerator)); }
    std::string getAlternativeName(unsigned index) const
    {
        if (_alternativeList.size() <= index)
            return std::string();
        return _alternativeList[index]._name;
    }
    std::string getAlternativeName(const std::string& enumerator) const
    { return getAlternativeName(getAlternativeIndex(enumerator)); }
    std::string getAlternativeSemantics(unsigned index) const
    {
        if (_alternativeList.size() <= index)
            return std::string();
        return _alternativeList[index]._semantics;
    }
    std::string getAlternativeSemantics(const std::string& enumerator) const
    { return getAlternativeSemantics(getAlternativeIndex(enumerator)); }
 private:
    SGSharedPtr<HLAEnumeratedDataType> _enumeratedDataType;
    struct Alternative {
        std::string _name;
        SGSharedPtr<const HLADataType> _dataType;
        std::string _semantics;
    };
    typedef std::vector<Alternative> AlternativeList;
    AlternativeList _alternativeList;
 };
 } // namespace simgear
@@ -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;
 }
 }
@@ -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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,36 +15,49 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
-#include "HLAVariantDataType.hxx"
+#ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "HLAVariantRecordDataType.hxx"
 #include "HLADataTypeVisitor.hxx"
-#include "HLAVariantDataElement.hxx"
+#include "HLAVariantRecordDataElement.hxx"
 namespace simgear {
-HLAVariantDataType::HLAVariantDataType(const std::string& name) :
+HLAVariantRecordDataType::HLAVariantRecordDataType(const std::string& name) :
    HLADataType(name)
 {
 }
-HLAVariantDataType::~HLAVariantDataType()
+HLAVariantRecordDataType::~HLAVariantRecordDataType()
 {
 }
 void
-HLAVariantDataType::accept(HLADataTypeVisitor& visitor) const
+HLAVariantRecordDataType::accept(HLADataTypeVisitor& visitor) const
 {
    visitor.apply(*this);
 }
-const HLAVariantDataType*
+const HLAVariantRecordDataType*
-HLAVariantDataType::toVariantDataType() const
+HLAVariantRecordDataType::toVariantRecordDataType() const
 {
    return this;
 }
 void
 HLAVariantRecordDataType::releaseDataTypeReferences()
 {
    for (AlternativeList::iterator i = _alternativeList.begin(); i != _alternativeList.end(); ++i)
        i->_dataType = 0;
 }
 bool
-HLAVariantDataType::decode(HLADecodeStream& stream, HLAAbstractVariantDataElement& value) const
+HLAVariantRecordDataType::decode(HLADecodeStream& stream, HLAAbstractVariantRecordDataElement& value) const
 {
    if (!stream.alignOffsetForSize(getAlignment()))
        return false;
@@ -61,7 +74,7 @@ HLAVariantDataType::decode(HLADecodeStream& stream, HLAAbstractVariantDataElemen
 }
 bool
-HLAVariantDataType::encode(HLAEncodeStream& stream, const HLAAbstractVariantDataElement& value) const
+HLAVariantRecordDataType::encode(HLAEncodeStream& stream, const HLAAbstractVariantRecordDataElement& value) const
 {
    if (!stream.alignOffsetForSize(getAlignment()))
        return false;
@@ -76,13 +89,13 @@ HLAVariantDataType::encode(HLAEncodeStream& stream, const HLAAbstractVariantData
 }
 void
-HLAVariantDataType::setEnumeratedDataType(HLAEnumeratedDataType* dataType)
+HLAVariantRecordDataType::setEnumeratedDataType(HLAEnumeratedDataType* dataType)
 {
    _enumeratedDataType = dataType;
 }
 bool
-HLAVariantDataType::addAlternative(const std::string& name, const std::string& enumerator,
+HLAVariantRecordDataType::addAlternative(const std::string& name, const std::string& enumerator,
                                         const HLADataType* dataType, const std::string& semantics)
 {
    if (!_enumeratedDataType.valid())
@@ -94,8 +107,20 @@ HLAVariantDataType::addAlternative(const std::string& name, const std::string& e
    _alternativeList[index]._name = name;
    _alternativeList[index]._dataType = dataType;
    _alternativeList[index]._semantics = semantics;
    setAlignment(SGMisc<unsigned>::max(getAlignment(), dataType->getAlignment()));
    return true;
 }
 void
 HLAVariantRecordDataType::_recomputeAlignmentImplementation()
 {
    unsigned alignment = 1;
    if (const HLADataType* dataType = getEnumeratedDataType())
        alignment = std::max(alignment, dataType->getAlignment());
    for (unsigned i = 0; i < getNumAlternatives(); ++i) {
        if (const HLADataType* dataType = getAlternativeDataType(i))
            alignment = std::max(alignment, dataType->getAlignment());
    }
    setAlignment(alignment);
 }
 } // namespace simgear
@@ -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
@@ -1,69 +0,0 @@
 INCLUDES = -I$(top_srcdir)
 lib_LIBRARIES = libsghla.a
 libsghla_adir = @includedir@/hla
 libsghla_a_HEADERS = \
 	RTIData.hxx \
 	HLAArrayDataElement.hxx \
 	HLAArrayDataType.hxx \
 	HLABasicDataElement.hxx \
 	HLABasicDataType.hxx \
 	HLADataElement.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 \
 	HLAVariantDataElement.hxx \
 	HLAVariantDataType.hxx
 libsghla_a_SOURCES = \
 	RTIObjectClass.cxx \
 	RTIObjectInstance.cxx \
 	RTIFederate.cxx \
 	HLAArrayDataElement.cxx \
 	HLAArrayDataType.cxx \
 	HLABasicDataElement.cxx \
 	HLABasicDataType.cxx \
 	HLADataElement.cxx \
 	HLADataType.cxx \
 	HLAEnumeratedDataElement.cxx \
 	HLAEnumeratedDataType.cxx \
 	HLAFederate.cxx \
 	HLAFixedRecordDataElement.cxx \
 	HLAFixedRecordDataType.cxx \
 	HLAObjectClass.cxx \
 	HLAObjectInstance.cxx \
 	HLAOMTXmlVisitor.cxx \
 	HLAPropertyDataElement.cxx \
 	HLARawDataElement.cxx \
 	HLAVariantDataElement.cxx \
 	HLAVariantDataType.cxx
 if ENABLE_HLA13
 lib_LIBRARIES += libsghla13.a
 libsghla13_adir = @includedir@/hla
 libsghla13_a_HEADERS = \
 	HLA13Federate.hxx
 libsghla13_a_SOURCES = \
 	RTI13ObjectClass.cxx \
 	RTI13ObjectInstance.cxx \
 	RTI13Federate.cxx \
 	HLA13Federate.cxx
 endif
@@ -15,8 +15,8 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
-#ifndef RTIAmbassador_hxx
+#ifndef RTI13Ambassador_hxx
-#define RTIAmbassador_hxx
+#define RTI13Ambassador_hxx
 #include <cstdlib>
 #include <list>
@@ -45,58 +45,20 @@
 namespace simgear {
-class RTI13Ambassador : public SGWeakReferenced {
+class RTI13Federate;
 class RTI13Ambassador : public SGReferenced {
 public:
-    RTI13Ambassador() :
+    ~RTI13Ambassador()
        _federateAmbassador(*this),
        _timeRegulationEnabled(false),
        _timeConstrainedEnabled(false),
        _timeAdvancePending(false)
    { }
    virtual ~RTI13Ambassador()
    { }
    // processes the queues that filled up during the past
    void processQueues()
    {
        while (!_queueCallbackList.empty()) {
            (*_queueCallbackList.front())();
            _queueCallbackList.pop_front();
        }
        while (!_objectInstancePendingCallbackList.empty()) {
            (*_objectInstancePendingCallbackList.begin())->flushPendingRequests();
            _objectInstancePendingCallbackList.erase(_objectInstancePendingCallbackList.begin());
        }
    }
    bool getTimeRegulationEnabled() const
    { return _timeRegulationEnabled; }
    bool getTimeConstrainedEnabled() const
    { return _timeConstrainedEnabled; }
    bool getTimeAdvancePending() const
    { return _timeAdvancePending; }
    const SGTimeStamp& getCurrentLogicalTime() const
    { return _federateTime; }
    bool getFederationSynchronizationPointAnnounced(const std::string& label)
    { return _pendingSyncLabels.find(label) != _pendingSyncLabels.end(); }
    bool getFederationSynchronized(const std::string& label)
    {
        std::set<std::string>::iterator i = _syncronizedSyncLabels.find(label);
        if (i == _syncronizedSyncLabels.end())
            return false;
        _syncronizedSyncLabels.erase(i);
        return true;
    }
    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::FederateHandle joinFederationExecution(const std::string& federate, const std::string& federation, RTI::FederateAmbassador* federateAmbassador)
-    { return _rtiAmbassador.joinFederationExecution(federate.c_str(), federation.c_str(), &_federateAmbassador); }
+    { return _rtiAmbassador.joinFederationExecution(federate.c_str(), federation.c_str(), federateAmbassador); }
    void resignFederationExecution()
    { _rtiAmbassador.resignFederationExecution(RTI::DELETE_OBJECTS_AND_RELEASE_ATTRIBUTES); }
@@ -109,18 +71,24 @@ public:
    { _rtiAmbassador.publishObjectClass(handle, attributeHandleSet); }
    void unpublishObjectClass(const RTI::ObjectClassHandle& handle)
    { _rtiAmbassador.unpublishObjectClass(handle); }
    void publishInteractionClass(const RTI::InteractionClassHandle& handle)
    { _rtiAmbassador.publishInteractionClass(handle); }
    void unpublishInteractionClass(const RTI::InteractionClassHandle& handle)
    { _rtiAmbassador.unpublishInteractionClass(handle); }
    void subscribeObjectClassAttributes(const RTI::ObjectClassHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet, bool active)
    { _rtiAmbassador.subscribeObjectClassAttributes(handle, attributeHandleSet, active ? RTI::RTI_TRUE : RTI::RTI_FALSE); }
    void unsubscribeObjectClass(const RTI::ObjectClassHandle& handle)
    { _rtiAmbassador.unsubscribeObjectClass(handle); }
-    RTI13ObjectInstance* registerObjectInstance(const RTI13ObjectClass* objectClass, HLAObjectInstance* hlaObjectInstance)
+    void subscribeInteractionClass(const RTI::InteractionClassHandle& handle, bool active)
-    {
+    { _rtiAmbassador.subscribeInteractionClass(handle, active ? RTI::RTI_TRUE : RTI::RTI_FALSE); }
-        RTI::ObjectHandle objectHandle = _rtiAmbassador.registerObjectInstance(objectClass->getHandle());
+    void unsubscribeInteractionClass(const RTI::InteractionClassHandle& handle)
-        RTI13ObjectInstance* objectInstance = new RTI13ObjectInstance(objectHandle, hlaObjectInstance, objectClass, this, true);
+    { _rtiAmbassador.unsubscribeInteractionClass(handle); }
-        _objectInstanceMap[objectHandle] = objectInstance;
+
-        return objectInstance;
+    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()); }
@@ -133,38 +101,11 @@ public:
    // { _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()); }
        RTI::EventRetractionHandle h = _rtiAmbassador.deleteObjectInstance(objectHandle, toFedTime(timeStamp), tag.data());
        ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
        if (i == _objectInstanceMap.end()) {
            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
            return;
        }
        _objectInstancePendingCallbackList.erase(i->second);
        _objectInstanceMap.erase(i);
    }
    void deleteObjectInstance(const RTI::ObjectHandle& objectHandle, const RTIData& tag)
-    {
+    { _rtiAmbassador.deleteObjectInstance(objectHandle, tag.data()); }
        _rtiAmbassador.deleteObjectInstance(objectHandle, tag.data());
        ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
        if (i == _objectInstanceMap.end()) {
            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
            return;
        }
        _objectInstancePendingCallbackList.erase(i->second);
        _objectInstanceMap.erase(i);
    }
    void localDeleteObjectInstance(const RTI::ObjectHandle& objectHandle)
-    {
+    { _rtiAmbassador.localDeleteObjectInstance(objectHandle); }
        _rtiAmbassador.localDeleteObjectInstance(objectHandle);
        ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
        if (i == _objectInstanceMap.end()) {
            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
            return;
        }
        _objectInstancePendingCallbackList.erase(i->second);
        _objectInstanceMap.erase(i);
    }
    void requestObjectAttributeValueUpdate(const RTI::ObjectHandle& handle, const RTI::AttributeHandleSet& attributeHandleSet)
    { _rtiAmbassador.requestObjectAttributeValueUpdate(handle, attributeHandleSet); }
@@ -334,98 +275,67 @@ public:
    //     }
    //     return false;
    // }
-    // bool isAttributeOwnedByFederate(const RTIHandle& objectHandle, const RTIHandle& attributeHandle)
+    bool isAttributeOwnedByFederate(const RTI::ObjectHandle& objectHandle, const RTI::AttributeHandle& attributeHandle)
-    // {
+    { return _rtiAmbassador.isAttributeOwnedByFederate(objectHandle, attributeHandle); }
    //     try {
    //         return _rtiAmbassador.isAttributeOwnedByFederate(objectHandle, attributeHandle);
    //     } catch (RTI::ObjectNotKnown& e) {
    //     } catch (RTI::AttributeNotDefined& e) {
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::SaveInProgress& e) {
    //     } catch (RTI::RestoreInProgress& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return false;
    // }
    /// Time Management
-    void enableTimeRegulation(const SGTimeStamp& federateTime, const SGTimeStamp& lookahead)
+    void enableTimeRegulation(const SGTimeStamp& lookahead)
-    { _rtiAmbassador.enableTimeRegulation(toFedTime(federateTime), toFedTime(lookahead)); }
+    {
        RTIfedTime federateTime;
        federateTime.setZero();
        _rtiAmbassador.enableTimeRegulation(federateTime, toFedTime(lookahead));
    }
    void disableTimeRegulation()
-    { _rtiAmbassador.disableTimeRegulation(); _timeRegulationEnabled = false; }
+    { _rtiAmbassador.disableTimeRegulation();}
    void enableTimeConstrained()
    { _rtiAmbassador.enableTimeConstrained(); }
    void disableTimeConstrained()
-    { _rtiAmbassador.disableTimeConstrained(); _timeConstrainedEnabled = false; }
+    { _rtiAmbassador.disableTimeConstrained(); }
    void timeAdvanceRequest(const SGTimeStamp& time)
-    { _rtiAmbassador.timeAdvanceRequest(toFedTime(time)); _timeAdvancePending = true; }
+    { _rtiAmbassador.timeAdvanceRequest(toFedTime(time)); }
    void timeAdvanceRequestAvailable(const SGTimeStamp& time)
-    { _rtiAmbassador.timeAdvanceRequestAvailable(toFedTime(time)); _timeAdvancePending = true; }
+    { _rtiAmbassador.timeAdvanceRequestAvailable(toFedTime(time)); }
    void flushQueueRequest(const SGTimeStamp& time)
    { _rtiAmbassador.flushQueueRequest(toFedTime(time)); }
-    // bool queryLBTS(double& time)
+    bool queryGALT(SGTimeStamp& timeStamp)
    // {
    //     try {
    //         RTIfedTime fedTime;
    //         _rtiAmbassador.queryLBTS(fedTime);
    //         time = fedTime.getTime();
    //         return true;
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::SaveInProgress& e) {
    //     } catch (RTI::RestoreInProgress& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return false;
    // }
    // bool queryFederateTime(double& time)
    // {
    //     try {
    //         RTIfedTime fedTime;
    //         _rtiAmbassador.queryFederateTime(fedTime);
    //         time = fedTime.getTime();
    //         return true;
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::SaveInProgress& e) {
    //     } catch (RTI::RestoreInProgress& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return false;
    // }
    // bool queryLookahead(double& time)
    // {
    //     try {
    //         RTIfedTime fedTime;
    //         _rtiAmbassador.queryLookahead(fedTime);
    //         time = fedTime.getTime();
    //         return true;
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::SaveInProgress& e) {
    //     } catch (RTI::RestoreInProgress& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return false;
    // }
    RTI13ObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass)
    {
-        RTI::ObjectClassHandle objectClassHandle;
+        RTIfedTime fedTime;
-        objectClassHandle = getObjectClassHandle(name);
+        fedTime.setPositiveInfinity();
-        if (_objectClassMap.find(objectClassHandle) != _objectClassMap.end()) {
+        _rtiAmbassador.queryLBTS(fedTime);
-            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not create object class, object class already exists!");
+        if (fedTime.isPositiveInfinity())
-            return 0;
+            return false;
        timeStamp = toTimeStamp(fedTime);
        return true;
    }
-        RTI13ObjectClass* rtiObjectClass;
+    bool queryLITS(SGTimeStamp& timeStamp)
-        rtiObjectClass = new RTI13ObjectClass(hlaObjectClass, objectClassHandle, this);
+    {
-        _objectClassMap[objectClassHandle] = rtiObjectClass;
+        RTIfedTime fedTime;
-        return rtiObjectClass;
+        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)
@@ -436,67 +346,16 @@ public:
    std::string getAttributeName(const RTI::AttributeHandle& attributeHandle, const RTI::ObjectClassHandle& objectClassHandle)
    { return rtiToStdString(_rtiAmbassador.getAttributeName(attributeHandle, objectClassHandle)); }
-    // RTIHandle getInteractionClassHandle(const std::string& name)
+    RTI::InteractionClassHandle getInteractionClassHandle(const std::string& name)
-    // {
+    { return _rtiAmbassador.getInteractionClassHandle(name.c_str()); }
-    //     try {
+    std::string getInteractionClassName(const RTI::InteractionClassHandle& handle)
-    //         return _rtiAmbassador.getInteractionClassHandle(name.c_str());
+    { return rtiToStdString(_rtiAmbassador.getInteractionClassName(handle)); }
    //     } catch (RTI::NameNotFound& e) {
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return RTIHandle(-1);
    // }
    // std::string getInteractionClassName(const RTIHandle& handle)
    // {
    //     std::string name;
    //     try {
    //         rtiToStdString(name, _rtiAmbassador.getInteractionClassName(handle));
    //     } catch (RTI::InteractionClassNotDefined& e) {
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return name;
    // }
-    // RTIHandle getParameterHandle(const std::string& parameterName, const RTIHandle& interactionClassHandle)
+    RTI::ParameterHandle getParameterHandle(const std::string& parameterName, const RTI::InteractionClassHandle& interactionClassHandle)
-    // {
+    { return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle); }
-    //     try {
+    std::string getParameterName(const RTI::ParameterHandle& parameterHandle, const RTI::InteractionClassHandle& interactionClassHandle)
-    //         return _rtiAmbassador.getParameterHandle(parameterName.c_str(), interactionClassHandle);
+    { return rtiToStdString(_rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle)); }
    //     } catch (RTI::InteractionClassNotDefined& e) {
    //     } catch (RTI::NameNotFound& e) {
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return RTIHandle(-1);
    // }
    // std::string getParameterName(const RTIHandle& parameterHandle, const RTIHandle& interactionClassHandle)
    // {
    //     std::string parameterName;
    //     try {
    //         rtiToStdString(parameterName, _rtiAmbassador.getParameterName(parameterHandle, interactionClassHandle));
    //     } catch (RTI::InteractionClassNotDefined& e) {
    //     } catch (RTI::InteractionParameterNotDefined& e) {
    //     } catch (RTI::FederateNotExecutionMember& e) {
    //     } catch (RTI::ConcurrentAccessAttempted& e) {
    //     } catch (RTI::RTIinternalError& e) {
    //     }
    //     return parameterName;
    // }
    RTI13ObjectInstance* getObjectInstance(const std::string& name)
    {
        RTI::ObjectHandle objectHandle;
        objectHandle = getObjectInstanceHandle(name);
        ObjectInstanceMap::iterator i = _objectInstanceMap.find(objectHandle);
        if (i == _objectInstanceMap.end()) {
            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class: ObjectInstance not found.");
            return 0;
        }
        return i->second;
    }
    RTI::ObjectHandle getObjectInstanceHandle(const std::string& name)
    { return _rtiAmbassador.getObjectInstanceHandle(name.c_str()); }
    std::string getObjectInstanceName(const RTI::ObjectHandle& objectHandle)
@@ -552,498 +411,6 @@ public:
    bool tick(double minimum, double maximum)
    { return _rtiAmbassador.tick(minimum, maximum); }
    void addObjectInstanceForCallback(RTIObjectInstance* objectIntance)
    { _objectInstancePendingCallbackList.insert(objectIntance); }
 private:
    /// Generic callback to execute some notification on objects in a way that they are not prone to
    /// ConcurrentAccess exceptions.
    class QueueCallback : public SGReferenced {
    public:
        virtual ~QueueCallback() {}
        virtual void operator()() = 0;
    };
    class RemoveObjectCallback : public QueueCallback {
    public:
        RemoveObjectCallback(SGSharedPtr<RTIObjectInstance> objectInstance, const RTIData& tag) :
            _objectInstance(objectInstance),
            _tag(tag)
        { }
        virtual void operator()()
        {
            _objectInstance->removeInstance(_tag);
        }
    private:
        SGSharedPtr<RTIObjectInstance> _objectInstance;
        RTIData _tag;
    };
    /// Just the interface class doing the callbacks into the parent class
    struct FederateAmbassador : public RTI::FederateAmbassador {
        FederateAmbassador(RTI13Ambassador& rtiAmbassador) :
            _rtiAmbassador(rtiAmbassador)
        {
        }
        virtual ~FederateAmbassador()
        throw (RTI::FederateInternalError)
        {
        }
        /// RTI federate ambassador callback functions.
        virtual void synchronizationPointRegistrationSucceeded(const char* label)
            throw (RTI::FederateInternalError)
        {
        }
        virtual void synchronizationPointRegistrationFailed(const char* label)
            throw (RTI::FederateInternalError)
        {
        }
        virtual void announceSynchronizationPoint(const char* label, const char* tag)
            throw (RTI::FederateInternalError)
        {
            _rtiAmbassador._pendingSyncLabels.insert(toStdString(label));
        }
        virtual void federationSynchronized(const char* label)
            throw (RTI::FederateInternalError)
        {
            std::string s = toStdString(label);
            _rtiAmbassador._pendingSyncLabels.erase(s);
            _rtiAmbassador._syncronizedSyncLabels.insert(s);
        }
        virtual void initiateFederateSave(const char* label)
            throw (RTI::UnableToPerformSave,
                   RTI::FederateInternalError)
        {
        }
        virtual void federationSaved()
            throw (RTI::FederateInternalError)
        {
        }
        virtual void federationNotSaved()
            throw (RTI::FederateInternalError)
        {
        }
        virtual void requestFederationRestoreSucceeded(const char* label)
            throw (RTI::FederateInternalError)
        {
        }
        virtual void requestFederationRestoreFailed(const char* label, const char* reason)
            throw (RTI::FederateInternalError)
        {
        }
        virtual void federationRestoreBegun()
            throw (RTI::FederateInternalError)
        {
        }
        virtual void initiateFederateRestore(const char* label, RTI::FederateHandle federateHandle)
            throw (RTI::SpecifiedSaveLabelDoesNotExist,
                   RTI::CouldNotRestore,
                   RTI::FederateInternalError)
        {
        }
        virtual void federationRestored()
            throw (RTI::FederateInternalError)
        {
        }
        virtual void federationNotRestored()
            throw (RTI::FederateInternalError)
        {
        }
        // Declaration Management
        virtual void startRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
            throw (RTI::ObjectClassNotPublished,
                   RTI::FederateInternalError)
        {
            ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
            if (i == _rtiAmbassador._objectClassMap.end())
                return;
            if (!i->second.valid())
                return;
            i->second->startRegistration();
        }
        virtual void stopRegistrationForObjectClass(RTI::ObjectClassHandle objectClassHandle)
            throw (RTI::ObjectClassNotPublished,
                   RTI::FederateInternalError)
        {
            ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
            if (i == _rtiAmbassador._objectClassMap.end())
                return;
            if (!i->second.valid())
                return;
            i->second->stopRegistration();
        }
        virtual void turnInteractionsOn(RTI::InteractionClassHandle interactionClassHandle)
            throw (RTI::InteractionClassNotPublished,
                   RTI::FederateInternalError)
        {
        }
        virtual void turnInteractionsOff(RTI::InteractionClassHandle interactionClassHandle)
            throw (RTI::InteractionClassNotPublished,
                   RTI::FederateInternalError)
        {
        }
        // Object Management
        virtual void discoverObjectInstance(RTI::ObjectHandle objectHandle, RTI::ObjectClassHandle objectClassHandle, const char* tag)
            throw (RTI::CouldNotDiscover,
                   RTI::ObjectClassNotKnown,
                   RTI::FederateInternalError)
        {
            ObjectClassMap::iterator i = _rtiAmbassador._objectClassMap.find(objectClassHandle);
            if (i == _rtiAmbassador._objectClassMap.end())
                throw RTI::ObjectClassNotKnown("Federate: discoverObjectInstance()!");
            if (!i->second.valid())
                return;
            SGSharedPtr<RTI13ObjectInstance> objectInstance = new RTI13ObjectInstance(objectHandle, 0, i->second, &_rtiAmbassador, false);
            _rtiAmbassador._objectInstanceMap[objectHandle] = objectInstance;
            _rtiAmbassador._objectInstancePendingCallbackList.insert(objectInstance);
            i->second->discoverInstance(objectInstance.get(), tagToData(tag));
        }
        virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
                                            const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::FederateOwnsAttributes,
                   RTI::InvalidFederationTime,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
            if (!i->second.valid())
                return;
            i->second->reflectAttributeValues(attributeValuePairSet, toTimeStamp(fedTime), tagToData(tag));
        }
        virtual void reflectAttributeValues(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleValuePairSet& attributeValuePairSet,
                                            const char* tag)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::FederateOwnsAttributes,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
            if (!i->second.valid())
                return;
            i->second->reflectAttributeValues(attributeValuePairSet, tagToData(tag));
        }
        virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle, const RTI::ParameterHandleValuePairSet& parameters,
                                        const RTI::FedTime& fedTime, const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
            throw (RTI::InteractionClassNotKnown,
                   RTI::InteractionParameterNotKnown,
                   RTI::InvalidFederationTime,
                   RTI::FederateInternalError)
        {
        }
        virtual void receiveInteraction(RTI::InteractionClassHandle interactionClassHandle,
                                        const RTI::ParameterHandleValuePairSet& parameters, const char* tag)
            throw (RTI::InteractionClassNotKnown,
                   RTI::InteractionParameterNotKnown,
                   RTI::FederateInternalError)
        {
        }
        virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const RTI::FedTime& fedTime,
                                          const char* tag, RTI::EventRetractionHandle eventRetractionHandle)
            throw (RTI::ObjectNotKnown,
                   RTI::InvalidFederationTime,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
            if (i->second.valid())
                _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
            _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second);
            _rtiAmbassador._objectInstanceMap.erase(i);
        }
        virtual void removeObjectInstance(RTI::ObjectHandle objectHandle, const char* tag)
            throw (RTI::ObjectNotKnown,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Federate: removeObjectInstance()!");
            if (i->second.valid())
                _rtiAmbassador._queueCallbackList.push_back(new RemoveObjectCallback(i->second, tagToData(tag)));
            _rtiAmbassador._objectInstancePendingCallbackList.erase(i->second);
            _rtiAmbassador._objectInstanceMap.erase(i);
        }
        virtual void attributesInScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
            if (!i->second.valid())
                return;
            i->second->attributesInScope(attributes);
        }
        virtual void attributesOutOfScope(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Attributes in scope for unknown object!");
            if (!i->second.valid())
                return;
            i->second->attributesOutOfScope(attributes);
        }
        virtual void provideAttributeValueUpdate(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::AttributeNotOwned,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Reflect attributes for unknown object!");
            if (!i->second.valid())
                return;
            i->second->provideAttributeValueUpdate(attributes);
        }
        virtual void turnUpdatesOnForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotOwned,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Turn on attributes for unknown object!");
            if (!i->second.valid())
                return;
            i->second->turnUpdatesOnForObjectInstance(attributes);
        }
        virtual void turnUpdatesOffForObjectInstance(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotOwned,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("Turn off attributes for unknown object!");
            if (!i->second.valid())
                return;
            i->second->turnUpdatesOffForObjectInstance(attributes);
        }
        // Ownership Management
        virtual void requestAttributeOwnershipAssumption(RTI::ObjectHandle objectHandle,
                                                         const RTI::AttributeHandleSet& attributes, const char* tag)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::AttributeAlreadyOwned,
                   RTI::AttributeNotPublished,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("requestAttributeOwnershipAssumption for unknown object!");
            if (!i->second.valid())
                return;
            i->second->requestAttributeOwnershipAssumption(attributes, tagToData(tag));
        }
        virtual void attributeOwnershipDivestitureNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::AttributeNotOwned,
                   RTI::AttributeDivestitureWasNotRequested,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("attributeOwnershipDivestitureNotification for unknown object!");
            if (!i->second.valid())
                return;
            i->second->attributeOwnershipDivestitureNotification(attributes);
        }
        virtual void attributeOwnershipAcquisitionNotification(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::AttributeAcquisitionWasNotRequested,
                   RTI::AttributeAlreadyOwned,
                   RTI::AttributeNotPublished,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("attributeOwnershipAcquisitionNotification for unknown object!");
            if (!i->second.valid())
                return;
            i->second->attributeOwnershipAcquisitionNotification(attributes);
        }
        virtual void attributeOwnershipUnavailable(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::AttributeAlreadyOwned,
                   RTI::AttributeAcquisitionWasNotRequested,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("attributeOwnershipUnavailable for unknown object!");
            if (!i->second.valid())
                return;
            i->second->attributeOwnershipUnavailable(attributes);
        }
        virtual void requestAttributeOwnershipRelease(RTI::ObjectHandle objectHandle,
                                                      const RTI::AttributeHandleSet& attributes, const char* tag)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::AttributeNotOwned,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("requestAttributeOwnershipRelease for unknown object!");
            if (!i->second.valid())
                return;
            i->second->requestAttributeOwnershipRelease(attributes, tagToData(tag));
        }
        virtual void confirmAttributeOwnershipAcquisitionCancellation(RTI::ObjectHandle objectHandle, const RTI::AttributeHandleSet& attributes)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::AttributeAlreadyOwned,
                   RTI::AttributeAcquisitionWasNotCanceled,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("confirmAttributeOwnershipAcquisitionCancellation for unknown object!");
            if (!i->second.valid())
                return;
            i->second->confirmAttributeOwnershipAcquisitionCancellation(attributes);
        }
        virtual void informAttributeOwnership(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle,
                                              RTI::FederateHandle federateHandle)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("informAttributeOwnership for unknown object!");
            if (!i->second.valid())
                return;
            i->second->informAttributeOwnership(attributeHandle, federateHandle);
        }
        virtual void attributeIsNotOwned(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("attributeIsNotOwned for unknown object!");
            if (!i->second.valid())
                return;
            i->second->attributeIsNotOwned(attributeHandle);
        }
        virtual void attributeOwnedByRTI(RTI::ObjectHandle objectHandle, RTI::AttributeHandle attributeHandle)
            throw (RTI::ObjectNotKnown,
                   RTI::AttributeNotKnown,
                   RTI::FederateInternalError)
        {
            ObjectInstanceMap::iterator i = _rtiAmbassador._objectInstanceMap.find(objectHandle);
            if (i == _rtiAmbassador._objectInstanceMap.end())
                throw RTI::ObjectNotKnown("attributeOwnedByRTI for unknown object!");
            if (!i->second.valid())
                return;
            i->second->attributeOwnedByRTI(attributeHandle);
        }
        // Time Management
        virtual void timeRegulationEnabled(const RTI::FedTime& fedTime)
            throw (RTI::InvalidFederationTime,
                   RTI::EnableTimeRegulationWasNotPending,
                   RTI::FederateInternalError)
        {
            _rtiAmbassador._timeRegulationEnabled = true;
            _rtiAmbassador._federateTime = toTimeStamp(fedTime);
            SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeRegulationEnabled: " << _rtiAmbassador._federateTime);
        }
        virtual void timeConstrainedEnabled(const RTI::FedTime& fedTime)
            throw (RTI::InvalidFederationTime,
                   RTI::EnableTimeConstrainedWasNotPending,
                   RTI::FederateInternalError)
        {
            _rtiAmbassador._timeConstrainedEnabled = true;
            _rtiAmbassador._federateTime = toTimeStamp(fedTime);
            SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeConstrainedEnabled: " << _rtiAmbassador._federateTime);
        }
        virtual void timeAdvanceGrant(const RTI::FedTime& fedTime)
            throw (RTI::InvalidFederationTime,
                   RTI::TimeAdvanceWasNotInProgress,
                   RTI::FederateInternalError)
        {
            _rtiAmbassador._federateTime = toTimeStamp(fedTime);
            _rtiAmbassador._timeAdvancePending = false;
            SG_LOG(SG_NETWORK, SG_INFO, "RTI: timeAdvanceGrant: " << _rtiAmbassador._federateTime);
        }
        virtual void requestRetraction(RTI::EventRetractionHandle eventRetractionHandle)
            throw (RTI::EventNotKnown,
                   RTI::FederateInternalError)
        {
            // No retraction concept yet
        }
    private:
        const RTIData& tagToData(const char* tag)
        {
            if (tag)
                _cachedTag.setData(tag, std::strlen(tag) + 1);
            else
                _cachedTag.setData("", 1);
            return _cachedTag;
        }
        RTIData _cachedTag;
        RTI13Ambassador& _rtiAmbassador;
    };
    static SGTimeStamp toTimeStamp(const RTI::FedTime& fedTime)
    {
@@ -1069,45 +436,9 @@ private:
        return s;
    }
    static std::string toStdString(const char* n)
    {
        if (!n)
            return std::string();
        return std::string(n);
    }
    // The connection class
    RTI::RTIambassador _rtiAmbassador;
-
+    SGWeakPtr<RTI13Federate> _federate;
    // The class with all the callbacks.
    FederateAmbassador _federateAmbassador;
    // All the sync labels we got an announcement for
    std::set<std::string> _pendingSyncLabels;
    std::set<std::string> _syncronizedSyncLabels;
    // All that calls back into user code is just queued.
    // That is to make sure we do not call recursively into the RTI
    typedef std::list<SGSharedPtr<QueueCallback> > QueueCallbackList;
    QueueCallbackList _queueCallbackList;
    // All object instances that need to be called due to some event are noted here
    // That is to make sure we do not call recursively into the RTI
    typedef std::set<SGSharedPtr<RTIObjectInstance> > ObjectInstanceSet;
    ObjectInstanceSet _objectInstancePendingCallbackList;
    // Top level information for dispatching federate object attribute updates
    typedef std::map<RTI::ObjectHandle, SGSharedPtr<RTI13ObjectInstance> > ObjectInstanceMap;
    // Map of all available objects
    ObjectInstanceMap _objectInstanceMap;
    // Top level information for dispatching creation of federate objects
    typedef std::map<RTI::ObjectClassHandle, SGSharedPtr<RTI13ObjectClass> > ObjectClassMap;
    ObjectClassMap _objectClassMap;
    bool _timeRegulationEnabled;
    bool _timeConstrainedEnabled;
    bool _timeAdvancePending;
    SGTimeStamp _federateTime;
 };
 } // namespace simgear
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// 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
@@ -25,6 +25,7 @@
 #include <RTI.hh>
 #include "RTIFederate.hxx"
 #include "RTI13InteractionClass.hxx"
 #include "RTI13ObjectClass.hxx"
 #include "RTI13ObjectInstance.hxx"
@@ -34,39 +35,54 @@ class RTI13Ambassador;
 class RTI13Federate : public RTIFederate {
 public:
-    RTI13Federate();
+    RTI13Federate(const std::list<std::string>& stringList);
    virtual ~RTI13Federate();
-    virtual bool createFederationExecution(const std::string& federation, const std::string& objectModel);
+    /// Create a federation execution
-    virtual bool destroyFederationExecution(const std::string& federation);
+    /// 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 bool join(const std::string& federateType, const std::string& 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 waitForFederationSynchronizationPointAnnounced(const std::string& label);
+    virtual bool getFederationSynchronizationPointAnnounced(const std::string& label);
    virtual bool synchronizationPointAchieved(const std::string& label);
-    virtual bool waitForFederationSynchronized(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 timeAdvanceRequestBy(const SGTimeStamp& dt);
+    virtual bool timeAdvanceRequest(const SGTimeStamp& timeStamp);
-    virtual bool timeAdvanceRequest(const SGTimeStamp& fedTime);
+    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 tick();
+    virtual bool processMessage();
-    virtual bool tick(const double& minimum, const double& maximum);
+    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&);
@@ -74,13 +90,14 @@ private:
    /// The federate handle
    RTI::FederateHandle _federateHandle;
-
+    bool _joined;
    /// The timeout for the single callback tick function in
    /// syncronous operations that need to wait for a callback
    double _tickTimeout;
    /// RTI connection
    SGSharedPtr<RTI13Ambassador> _ambassador;
    /// Callbacks from the rti are handled here.
    struct FederateAmbassador;
    FederateAmbassador* _federateAmbassador;
 };
 }
@@ -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;
 }
 }
@@ -1,7 +1,4 @@
-
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 // Written by James Turner, started July 2010.
 //
 // Copyright (C) 2010  Curtis L. Olson - http://www.flightgear.org/~curt
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -17,44 +14,26 @@
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
-#include <simgear/misc/sg_sleep.hxx>
+#ifndef RTI13FederateFactory_hxx
 #define RTI13FederateFactory_hxx
-#ifdef SG_WINDOWS
+#include "RTIFederateFactory.hxx"
 # include <windows.h>
 #else
 # include <unistd.h>
 #endif
-namespace simgear
+#include "simgear/structure/SGSharedPtr.hxx"
 {
-#ifdef SG_WINDOWS
+namespace simgear {
-void sleepForSeconds(int seconds)
+class RTI13FederateFactory : public RTIFederateFactory {
-{
+public:
-  Sleep(1000 * seconds);
+    RTI13FederateFactory();
-}
+    virtual ~RTI13FederateFactory();
-void sleepForMSec(int msec)
+    virtual RTIFederate* create(const std::string& name, const std::list<std::string>& stringList) const;
 {
  Sleep(msec);
 }
-#else
+    static const SGSharedPtr<RTI13FederateFactory>& instance();
 };
 void sleepForSeconds(int seconds)
 {
  ::sleep(seconds);
 }
 void sleepForMSec(int msec)
 {
  ::usleep(msec * 1000);
 }
 #endif
 } // of namespace simhear
@@ -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;
 }
 }
@@ -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
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,34 +15,74 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "RTI13ObjectClass.hxx"
 #include "RTI13Ambassador.hxx"
 namespace simgear {
-RTI13ObjectClass::RTI13ObjectClass(HLAObjectClass* hlaObjectClass, RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador) :
+RTI13ObjectClass::RTI13ObjectClass(HLAObjectClass* hlaObjectClass, const RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador) :
    RTIObjectClass(hlaObjectClass),
    _handle(handle),
    _ambassador(ambassador)
 {
    if (0 != getOrCreateAttributeIndex("privilegeToDelete") &&
        0 != getOrCreateAttributeIndex("HLAprivilegeToDeleteObject"))
        SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass: Cannot find object root attribute.");
 }
 RTI13ObjectClass::~RTI13ObjectClass()
 {
 }
-std::string
+bool
-RTI13ObjectClass::getName() const
+RTI13ObjectClass::resolveAttributeIndex(const std::string& name, unsigned index)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
-        return std::string();
+        return false;
    }
    if (index != _attributeHandleVector.size()) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Resolving needs to happen in growing index order!");
        return false;
    }
    try {
        RTI::AttributeHandle attributeHandle = _ambassador->getAttributeHandle(name, _handle);
        AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle);
        if (i != _attributeHandleIndexMap.end()) {
            SG_LOG(SG_NETWORK, SG_WARN, "RTI: Resolving attributeIndex for attribute \"" << name << "\" twice!");
            return false;
        }
        _attributeHandleIndexMap[attributeHandle] = index;
        _attributeHandleVector.push_back(attributeHandle);
        return true;
    } catch (RTI::ObjectClassNotDefined& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return false;
    } catch (RTI::NameNotFound& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return false;
    } catch (RTI::FederateNotExecutionMember& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return false;
    } catch (RTI::ConcurrentAccessAttempted& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return false;
    } catch (RTI::RTIinternalError& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return false;
    } catch (...) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute.");
        return false;
    }
    return ambassador->getObjectClassName(_handle);
 }
 unsigned
@@ -51,133 +91,18 @@ RTI13ObjectClass::getNumAttributes() const
    return _attributeHandleVector.size();
 }
 unsigned
 RTI13ObjectClass::getAttributeIndex(const std::string& name) const
 {
    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return ~0u;
    }
    try {
        RTI::AttributeHandle attributeHandle = ambassador->getAttributeHandle(name, _handle);
        AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle);
        if (i !=  _attributeHandleIndexMap.end())
            return i->second;
        return ~0u;
    } catch (RTI::ObjectClassNotDefined& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::NameNotFound& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::FederateNotExecutionMember& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::ConcurrentAccessAttempted& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::RTIinternalError& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (...) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute.");
        return ~0u;
    }
 }
 unsigned
 RTI13ObjectClass::getOrCreateAttributeIndex(const std::string& name)
 {
    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return ~0u;
    }
    try {
        RTI::AttributeHandle attributeHandle = ambassador->getAttributeHandle(name, _handle);
        AttributeHandleIndexMap::const_iterator i = _attributeHandleIndexMap.find(attributeHandle);
        if (i !=  _attributeHandleIndexMap.end())
            return i->second;
        unsigned index = _attributeHandleVector.size();
        _attributeHandleIndexMap[attributeHandle] = index;
        _attributeHandleVector.push_back(attributeHandle);
        _attributeDataVector.push_back(name);
        return index;
    } catch (RTI::ObjectClassNotDefined& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::NameNotFound& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::FederateNotExecutionMember& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::ConcurrentAccessAttempted& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (RTI::RTIinternalError& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute: " << e._name << " " << e._reason);
        return ~0u;
    } catch (...) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute.");
        return ~0u;
    }
 }
 // std::string
 // RTI13ObjectClass::getAttributeName(unsigned index) const
 // {
 //     SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
 //     if (!ambassador.valid()) {
 //         SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
 //         return std::string();
 //     }
 //     try {
 //         return ambassador->getAttributeName(getAttributeHandle(index), _handle);
 //     } catch (RTI::ObjectClassNotDefined& e) {
 //         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
 //         return std::string();
 //     } catch (RTI::AttributeNotDefined& e) {
 //         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
 //         return std::string();
 //     } catch (RTI::FederateNotExecutionMember& e) {
 //         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
 //         return std::string();
 //     } catch (RTI::ConcurrentAccessAttempted& e) {
 //         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
 //         return std::string();
 //     } catch (RTI::RTIinternalError& e) {
 //         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name: " << e._name << " " << e._reason);
 //         return std::string();
 //     } catch (...) {
 //         SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object class attribute name.");
 //         return std::string();
 //     }
 // }
 bool
-RTI13ObjectClass::publish(const std::set<unsigned>& indexSet)
+RTI13ObjectClass::publish(const HLAIndexList& indexList)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return false;
    }
    try {
-        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(indexSet.size()));
+        unsigned numAttributes = getNumAttributes();
-        for (std::set<unsigned>::const_iterator i = indexSet.begin(); i != indexSet.end(); ++i) {
+        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
            if (_attributeHandleVector.size() <= *i) {
                SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass::publish(): Invalid attribute index!");
                continue;
@@ -185,11 +110,7 @@ RTI13ObjectClass::publish(const std::set<unsigned>& indexSet)
            attributeHandleSet->add(_attributeHandleVector[*i]);
        }
-        ambassador->publishObjectClass(_handle, *attributeHandleSet);
+        _ambassador->publishObjectClass(_handle, *attributeHandleSet);
        for (unsigned i = 0; i < getNumAttributes(); ++i) {
            _attributeDataVector[i]._published = true;
        }
        return true;
    } catch (RTI::ObjectClassNotDefined& e) {
@@ -225,18 +146,13 @@ RTI13ObjectClass::publish(const std::set<unsigned>& indexSet)
 bool
 RTI13ObjectClass::unpublish()
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return false;
    }
    try {
-        ambassador->unpublishObjectClass(_handle);
+        _ambassador->unpublishObjectClass(_handle);
        for (unsigned i = 0; i < getNumAttributes(); ++i) {
            _attributeDataVector[i]._published = false;
        }
        return true;
    } catch (RTI::ObjectClassNotDefined& e) {
@@ -270,18 +186,17 @@ RTI13ObjectClass::unpublish()
 }
 bool
-RTI13ObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
+RTI13ObjectClass::subscribe(const HLAIndexList& indexList, bool active)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return false;
    }
    try {
-        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(indexSet.size()));
+        unsigned numAttributes = getNumAttributes();
-        for (std::set<unsigned>::const_iterator i = indexSet.begin();
+        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
-             i != indexSet.end(); ++i) {
+        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
            if (_attributeHandleVector.size() <= *i) {
                SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectClass::subscribe(): Invalid attribute index!");
                continue;
@@ -289,11 +204,7 @@ RTI13ObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
            attributeHandleSet->add(_attributeHandleVector[*i]);
        }
-        ambassador->subscribeObjectClassAttributes(_handle, *attributeHandleSet, active);
+        _ambassador->subscribeObjectClassAttributes(_handle, *attributeHandleSet, active);
        for (unsigned i = 0; i < getNumAttributes(); ++i) {
            _attributeDataVector[i]._subscribed = true;
        }
        return true;
    } catch (RTI::ObjectClassNotDefined& e) {
@@ -326,18 +237,13 @@ RTI13ObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
 bool
 RTI13ObjectClass::unsubscribe()
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return 0;
    }
    try {
-        ambassador->unsubscribeObjectClass(_handle);
+        _ambassador->unsubscribeObjectClass(_handle);
        for (unsigned i = 0; i < getNumAttributes(); ++i) {
            _attributeDataVector[i]._subscribed = false;
        }
        return true;
    } catch (RTI::ObjectClassNotDefined& e) {
@@ -370,14 +276,22 @@ RTI13ObjectClass::unsubscribe()
 RTIObjectInstance*
 RTI13ObjectClass::registerObjectInstance(HLAObjectInstance* hlaObjectInstance)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return 0;
    }
    SGSharedPtr<RTI13Federate> federate = _ambassador->_federate.lock();
    if (!federate.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero.");
        return 0;
    }
    try {
-        return ambassador->registerObjectInstance(this, hlaObjectInstance);
+        RTI::ObjectHandle objectHandle = _ambassador->registerObjectInstance(getHandle());
        RTI13ObjectInstance* objectInstance = new RTI13ObjectInstance(objectHandle, hlaObjectInstance, this, _ambassador.get());
        federate->insertObjectInstance(objectInstance);
        return objectInstance;
    } catch (RTI::ObjectClassNotDefined& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not register object instance: " << e._name << " " << e._reason);
        return 0;
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -37,17 +37,15 @@ class RTIObjectInstance;
 class RTI13ObjectClass : public RTIObjectClass {
 public:
-    RTI13ObjectClass(HLAObjectClass* hlaObjectClass, RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador);
+    RTI13ObjectClass(HLAObjectClass* hlaObjectClass, const RTI::ObjectClassHandle& handle, RTI13Ambassador* ambassador);
    virtual ~RTI13ObjectClass();
    const RTI::ObjectClassHandle& getHandle() const
    { return _handle; }
-    virtual std::string getName() const;
+    virtual bool resolveAttributeIndex(const std::string& name, unsigned index);
    virtual unsigned getNumAttributes() const;
    virtual unsigned getAttributeIndex(const std::string& name) const;
    virtual unsigned getOrCreateAttributeIndex(const std::string& name);
    unsigned getAttributeIndex(const RTI::AttributeHandle& handle) const
    {
@@ -63,17 +61,17 @@ public:
        return _attributeHandleVector[index];
    }
-    virtual bool publish(const std::set<unsigned>& indexSet);
+    virtual bool publish(const HLAIndexList& indexList);
    virtual bool unpublish();
-    virtual bool subscribe(const std::set<unsigned>& indexSet, bool);
+    virtual bool subscribe(const HLAIndexList& indexList, bool);
    virtual bool unsubscribe();
    virtual RTIObjectInstance* registerObjectInstance(HLAObjectInstance* hlaObjectInstance);
 private:
    RTI::ObjectClassHandle _handle;
-    SGWeakPtr<RTI13Ambassador> _ambassador;
+    SGSharedPtr<RTI13Ambassador> _ambassador;
    typedef std::map<RTI::AttributeHandle, unsigned> AttributeHandleIndexMap;
    AttributeHandleIndexMap _attributeHandleIndexMap;
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,20 +15,26 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "RTIObjectInstance.hxx"
 #include "RTI13Ambassador.hxx"
 namespace simgear {
-RTI13ObjectInstance::RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* hlaObjectInstance,
+RTI13ObjectInstance::RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* objectInstance,
-                                         const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador, bool owned) :
+                                         const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador) :
-    RTIObjectInstance(hlaObjectInstance),
+    RTIObjectInstance(objectInstance),
    _handle(handle),
    _objectClass(objectClass),
    _ambassador(ambassador),
    _attributeValuePairSet(RTI::AttributeSetFactory::create(objectClass->getNumAttributes()))
 {
-    updateAttributesFromClass(owned);
+    _setNumAttributes(getNumAttributes());
 }
 RTI13ObjectInstance::~RTI13ObjectInstance()
@@ -50,14 +56,13 @@ RTI13ObjectInstance::get13ObjectClass() const
 std::string
 RTI13ObjectInstance::getName() const
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return std::string();
    }
    try {
-        return ambassador->getObjectInstanceName(_handle);
+        return _ambassador->getObjectInstanceName(_handle);
    } catch (RTI::ObjectNotKnown& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not get object name: " << e._name << " " << e._reason);
        return std::string();
@@ -77,28 +82,21 @@ RTI13ObjectInstance::getName() const
 }
 void
-RTI13ObjectInstance::addToRequestQueue()
+RTI13ObjectInstance::deleteObjectInstance(const RTIData& tag)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return;
    }
-    ambassador->addObjectInstanceForCallback(this);
+    SGSharedPtr<RTI13Federate> federate = _ambassador->_federate.lock();
-}
+    if (!federate.valid()) {
-
+        SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero.");
 void
 RTI13ObjectInstance::deleteObjectInstance(const RTIData& tag)
 {
    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return;
    }
    try {
-        ambassador->deleteObjectInstance(_handle, tag);
+        _ambassador->deleteObjectInstance(_handle, tag);
    } catch (RTI::ObjectNotKnown& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
    } catch (RTI::DeletePrivilegeNotHeld& e) {
@@ -119,14 +117,19 @@ RTI13ObjectInstance::deleteObjectInstance(const RTIData& tag)
 void
 RTI13ObjectInstance::deleteObjectInstance(const SGTimeStamp& timeStamp, const RTIData& tag)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return;
    }
    SGSharedPtr<RTI13Federate> federate = _ambassador->_federate.lock();
    if (!federate.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero.");
        return;
    }
    try {
-        ambassador->deleteObjectInstance(_handle, timeStamp, tag);
+        _ambassador->deleteObjectInstance(_handle, timeStamp, tag);
    } catch (RTI::ObjectNotKnown& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
    } catch (RTI::DeletePrivilegeNotHeld& e) {
@@ -149,14 +152,19 @@ RTI13ObjectInstance::deleteObjectInstance(const SGTimeStamp& timeStamp, const RT
 void
 RTI13ObjectInstance::localDeleteObjectInstance()
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return;
    }
    SGSharedPtr<RTI13Federate> federate = _ambassador->_federate.lock();
    if (!federate.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Federate is zero.");
        return;
    }
    try {
-        ambassador->localDeleteObjectInstance(_handle);
+        _ambassador->localDeleteObjectInstance(_handle);
    } catch (RTI::ObjectNotKnown& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
    } catch (RTI::FederateOwnsAttributes& e) {
@@ -175,73 +183,79 @@ RTI13ObjectInstance::localDeleteObjectInstance()
 }
 void
-RTI13ObjectInstance::reflectAttributeValues(const RTI::AttributeHandleValuePairSet& attributeValuePairSet, const RTIData& tag)
+RTI13ObjectInstance::reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
                                            const RTIData& tag, HLAIndexList& indexPool)
 {
-    // Retrieve an empty update struct from the memory pool
+    HLAIndexList reflectedIndices;
-    UpdateList updateList;
+    for (RTI13AttributeHandleDataPairList::iterator i = attributeHandleDataPairList.begin();
-    getUpdateFromPool(updateList);
+         i != attributeHandleDataPairList.end(); ++i) {
        unsigned index = getAttributeIndex(i->first);
        _attributeData[index]._data.swap(i->second);
-    RTI::ULong numAttribs = attributeValuePairSet.size();
+        if (indexPool.empty())
-    for (RTI::ULong i = 0; i < numAttribs; ++i) {
+            reflectedIndices.push_back(index);
-        unsigned index = getAttributeIndex(attributeValuePairSet.getHandle(i));
+        else {
-        // Get a RTIData from the data pool
+            reflectedIndices.splice(reflectedIndices.end(), indexPool, indexPool.begin());
-        getDataFromPool(index, updateList.back()._indexDataPairList);
+            reflectedIndices.back() = index;
-        RTI::ULong length = attributeValuePairSet.getValueLength(i);
+        }
        updateList.back()._indexDataPairList.back().second.resize(length);
        attributeValuePairSet.getValue(i, updateList.back()._indexDataPairList.back().second.data(), length);
        updateList.back()._tag = tag;
    }
-    RTIObjectInstance::reflectAttributeValues(updateList.front()._indexDataPairList, tag);
+    RTIObjectInstance::reflectAttributeValues(reflectedIndices, tag);
-    // Return the update data back to the pool
+
-    putUpdateToPool(updateList);
+    // Return the index list to the pool
    indexPool.splice(indexPool.end(), reflectedIndices);
 }
 void
-RTI13ObjectInstance::reflectAttributeValues(const RTI::AttributeHandleValuePairSet& attributeValuePairSet, const SGTimeStamp& timeStamp, const RTIData& tag)
+RTI13ObjectInstance::reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
                                            const SGTimeStamp& timeStamp, const RTIData& tag, HLAIndexList& indexPool)
 {
-    // Retrieve an empty update struct from the memory pool
+    HLAIndexList reflectedIndices;
-    UpdateList updateList;
+    for (RTI13AttributeHandleDataPairList::iterator i = attributeHandleDataPairList.begin();
-    getUpdateFromPool(updateList);
+         i != attributeHandleDataPairList.end(); ++i) {
        unsigned index = getAttributeIndex(i->first);
        _attributeData[index]._data.swap(i->second);
-    RTI::ULong numAttribs = attributeValuePairSet.size();
+        if (indexPool.empty())
-    for (RTI::ULong i = 0; i < numAttribs; ++i) {
+            reflectedIndices.push_back(index);
-        unsigned index = getAttributeIndex(attributeValuePairSet.getHandle(i));
+        else {
-        // Get a RTIData from the data pool
+            reflectedIndices.splice(reflectedIndices.end(), indexPool, indexPool.begin());
-        getDataFromPool(index, updateList.back()._indexDataPairList);
+            reflectedIndices.back() = index;
-        RTI::ULong length = attributeValuePairSet.getValueLength(i);
+        }
        updateList.back()._indexDataPairList.back().second.resize(length);
        attributeValuePairSet.getValue(i, updateList.back()._indexDataPairList.back().second.data(), length);
        updateList.back()._tag = tag;
    }
-    scheduleUpdates(timeStamp, updateList);
+    RTIObjectInstance::reflectAttributeValues(reflectedIndices, timeStamp, tag);
    // Return the index list to the pool
    indexPool.splice(indexPool.end(), reflectedIndices);
 }
 void
-RTI13ObjectInstance::requestObjectAttributeValueUpdate()
+RTI13ObjectInstance::requestObjectAttributeValueUpdate(const HLAIndexList& indexList)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return;
    }
    if (indexList.empty())
        return;
    try {
        unsigned numAttributes = getNumAttributes();
        std::auto_ptr<RTI::AttributeHandleSet> attributeHandleSet(RTI::AttributeHandleSetFactory::create(numAttributes));
-        for (unsigned i = 0; i < numAttributes; ++i) {
+        for (HLAIndexList::const_iterator i = indexList.begin(); i != indexList.end(); ++i) {
-            if (!getRequestAttributeUpdate(i))
+            if (getAttributeOwned(*i)) {
                SG_LOG(SG_NETWORK, SG_WARN, "RTI13ObjectInstance::requestObjectAttributeValueUpdate(): "
                       "Invalid attribute index!");
                continue;
-            attributeHandleSet->add(getAttributeHandle(i));
+            }
            attributeHandleSet->add(getAttributeHandle(*i));
        }
        if (!attributeHandleSet->size())
            return;
-        ambassador->requestObjectAttributeValueUpdate(_handle, *attributeHandleSet);
+        _ambassador->requestObjectAttributeValueUpdate(_handle, *attributeHandleSet);
        for (unsigned i = 0; i < numAttributes; ++i)
            setRequestAttributeUpdate(i, false);
        return;
    } catch (RTI::ObjectNotKnown& e) {
@@ -272,21 +286,20 @@ RTI13ObjectInstance::requestObjectAttributeValueUpdate()
 }
 void
-RTI13ObjectInstance::provideAttributeValueUpdate(const RTI::AttributeHandleSet& attributes)
+RTI13ObjectInstance::provideAttributeValueUpdate(const std::vector<RTI::AttributeHandle>& attributeHandleSet)
 {
    // Called from the ambassador. Just marks some instance attributes dirty so that they are sent with the next update
-    RTI::ULong numAttribs = attributes.size();
+    size_t numAttribs = attributeHandleSet.size();
    for (RTI::ULong i = 0; i < numAttribs; ++i) {
-        unsigned index = getAttributeIndex(attributes.getHandle(i));
+        unsigned index = getAttributeIndex(attributeHandleSet[i]);
-        setAttributeForceUpdate(index);
+        _attributeData[index]._dirty = true;
    }
 }
 void
 RTI13ObjectInstance::updateAttributeValues(const RTIData& tag)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return;
    }
@@ -297,43 +310,37 @@ RTI13ObjectInstance::updateAttributeValues(const RTIData& tag)
        unsigned numAttributes = getNumAttributes();
        for (unsigned i = 0; i < numAttributes; ++i) {
-            if (!getAttributeEffectiveUpdateEnabled(i))
+            if (!_attributeData[i]._dirty)
                continue;
-            const HLADataElement* dataElement = getDataElement(i);
+            const RTIData& data = _attributeData[i]._data;
            if (!dataElement)
                continue;
            // FIXME cache somewhere
            RTIData data;
            HLAEncodeStream stream(data);
            dataElement->encode(stream);
            _attributeValuePairSet->add(getAttributeHandle(i), data.data(), data.size());
        }
        if (!_attributeValuePairSet->size())
            return;
-        ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, tag);
+        _ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, tag);
        for (unsigned i = 0; i < numAttributes; ++i) {
-            setAttributeUpdated(i);
+            _attributeData[i]._dirty = false;
        }
    } catch (RTI::ObjectNotKnown& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::AttributeNotDefined& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::AttributeNotOwned& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::FederateNotExecutionMember& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::ConcurrentAccessAttempted& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::SaveInProgress& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::RestoreInProgress& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::RTIinternalError& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    }
    // That means clear()
@@ -343,8 +350,7 @@ RTI13ObjectInstance::updateAttributeValues(const RTIData& tag)
 void
 RTI13ObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag)
 {
-    SGSharedPtr<RTI13Ambassador> ambassador = _ambassador.lock();
+    if (!_ambassador.valid()) {
    if (!ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return;
    }
@@ -355,45 +361,39 @@ RTI13ObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const R
        unsigned numAttributes = getNumAttributes();
        for (unsigned i = 0; i < numAttributes; ++i) {
-            if (!getAttributeEffectiveUpdateEnabled(i))
+            if (!_attributeData[i]._dirty)
                continue;
-            const HLADataElement* dataElement = getDataElement(i);
+            const RTIData& data = _attributeData[i]._data;
            if (!dataElement)
                continue;
            // FIXME cache somewhere
            RTIData data;
            HLAEncodeStream stream(data);
            dataElement->encode(stream);
            _attributeValuePairSet->add(getAttributeHandle(i), data.data(), data.size());
        }
        if (!_attributeValuePairSet->size())
            return;
-        ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, timeStamp, tag);
+        _ambassador->updateAttributeValues(_handle, *_attributeValuePairSet, timeStamp, tag);
        for (unsigned i = 0; i < numAttributes; ++i) {
-            setAttributeUpdated(i);
+            _attributeData[i]._dirty = false;
        }
    } catch (RTI::ObjectNotKnown& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::AttributeNotDefined& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::AttributeNotOwned& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::InvalidFederationTime& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::FederateNotExecutionMember& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::ConcurrentAccessAttempted& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::SaveInProgress& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::RestoreInProgress& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    } catch (RTI::RTIinternalError& e) {
-        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not delete object instance: " << e._name << " " << e._reason);
+        SG_LOG(SG_NETWORK, SG_WARN, "RTI: could not update attribute values object instance: " << e._name << " " << e._reason);
    }
    // That means clear()
@@ -401,72 +401,114 @@ RTI13ObjectInstance::updateAttributeValues(const SGTimeStamp& timeStamp, const R
 }
 void
-RTI13ObjectInstance::attributesInScope(const RTI::AttributeHandleSet& attributeHandleSet)
+RTI13ObjectInstance::attributesInScope(const std::vector<RTI::AttributeHandle>& attributeHandleSet)
 {
-    RTI::ULong numAttribs = attributeHandleSet.size();
+    size_t numAttribs = attributeHandleSet.size();
    for (RTI::ULong i = 0; i < numAttribs; ++i) {
-        RTI::AttributeHandle attributeHandle = attributeHandleSet.getHandle(i);
+        RTI::AttributeHandle attributeHandle = attributeHandleSet[i];
        setAttributeInScope(getAttributeIndex(attributeHandle), true);
    }
 }
 void
-RTI13ObjectInstance::attributesOutOfScope(const RTI::AttributeHandleSet& attributeHandleSet)
+RTI13ObjectInstance::attributesOutOfScope(const std::vector<RTI::AttributeHandle>& attributeHandleSet)
 {
-    RTI::ULong numAttribs = attributeHandleSet.size();
+    size_t numAttribs = attributeHandleSet.size();
    for (RTI::ULong i = 0; i < numAttribs; ++i) {
-        RTI::AttributeHandle attributeHandle = attributeHandleSet.getHandle(i);
+        RTI::AttributeHandle attributeHandle = attributeHandleSet[i];
        setAttributeInScope(getAttributeIndex(attributeHandle), false);
    }
 }
 void
-RTI13ObjectInstance::turnUpdatesOnForObjectInstance(const RTI::AttributeHandleSet& attributeHandleSet)
+RTI13ObjectInstance::turnUpdatesOnForObjectInstance(const std::vector<RTI::AttributeHandle>& attributeHandleSet)
 {
-    RTI::ULong numAttribs = attributeHandleSet.size();
+    size_t numAttribs = attributeHandleSet.size();
    for (RTI::ULong i = 0; i < numAttribs; ++i) {
-        RTI::AttributeHandle attributeHandle = attributeHandleSet.getHandle(i);
+        RTI::AttributeHandle attributeHandle = attributeHandleSet[i];
        setAttributeUpdateEnabled(getAttributeIndex(attributeHandle), true);
    }
 }
 void
-RTI13ObjectInstance::turnUpdatesOffForObjectInstance(const RTI::AttributeHandleSet& attributeHandleSet)
+RTI13ObjectInstance::turnUpdatesOffForObjectInstance(const std::vector<RTI::AttributeHandle>& attributeHandleSet)
 {
-    RTI::ULong numAttribs = attributeHandleSet.size();
+    size_t numAttribs = attributeHandleSet.size();
    for (RTI::ULong i = 0; i < numAttribs; ++i) {
-        RTI::AttributeHandle attributeHandle = attributeHandleSet.getHandle(i);
+        RTI::AttributeHandle attributeHandle = attributeHandleSet[i];
        setAttributeUpdateEnabled(getAttributeIndex(attributeHandle), false);
    }
 }
 bool
 RTI13ObjectInstance::isAttributeOwnedByFederate(unsigned index) const
 {
    if (!_ambassador.valid()) {
        SG_LOG(SG_NETWORK, SG_WARN, "Error: Ambassador is zero.");
        return false;
    }
    try {
        RTI::AttributeHandle attributeHandle = getAttributeHandle(index);
        return _ambassador->isAttributeOwnedByFederate(_handle, attributeHandle);
    } catch (RTI::ObjectNotKnown& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
               << e._name << " " << e._reason);
        return false;
    } catch (RTI::AttributeNotDefined& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
               << e._name << " " << e._reason);
        return false;
    } catch (RTI::FederateNotExecutionMember& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
               << e._name << " " << e._reason);
        return false;
    } catch (RTI::ConcurrentAccessAttempted& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
               << e._name << " " << e._reason);
        return false;
    } catch (RTI::SaveInProgress& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
               << e._name << " " << e._reason);
        return false;
    } catch (RTI::RestoreInProgress& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
               << e._name << " " << e._reason);
        return false;
    } catch (RTI::RTIinternalError& e) {
        SG_LOG(SG_NETWORK, SG_WARN, "RTI: Could not query attribute ownership for index " << index << ": "
               << e._name << " " << e._reason);
        return false;
    }
    return false;
 }
 void
-RTI13ObjectInstance::requestAttributeOwnershipAssumption(const RTI::AttributeHandleSet& attributes, const RTIData& tag)
+RTI13ObjectInstance::requestAttributeOwnershipAssumption(const std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag)
 {
 }
 void
-RTI13ObjectInstance::attributeOwnershipDivestitureNotification(const RTI::AttributeHandleSet& attributes)
+RTI13ObjectInstance::attributeOwnershipDivestitureNotification(const std::vector<RTI::AttributeHandle>& attributes)
 {
 }
 void
-RTI13ObjectInstance::attributeOwnershipAcquisitionNotification(const RTI::AttributeHandleSet& attributes)
+RTI13ObjectInstance::attributeOwnershipAcquisitionNotification(const std::vector<RTI::AttributeHandle>& attributes)
 {
 }
 void
-RTI13ObjectInstance::attributeOwnershipUnavailable(const RTI::AttributeHandleSet& attributes)
+RTI13ObjectInstance::attributeOwnershipUnavailable(const std::vector<RTI::AttributeHandle>& attributes)
 {
 }
 void
-RTI13ObjectInstance::requestAttributeOwnershipRelease(const RTI::AttributeHandleSet& attributes, const RTIData& tag)
+RTI13ObjectInstance::requestAttributeOwnershipRelease(const std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag)
 {
 }
 void
-RTI13ObjectInstance::confirmAttributeOwnershipAcquisitionCancellation(const RTI::AttributeHandleSet& attributes)
+RTI13ObjectInstance::confirmAttributeOwnershipAcquisitionCancellation(const std::vector<RTI::AttributeHandle>& attributes)
 {
 }
@@ -37,9 +37,12 @@ namespace simgear {
 class RTI13Ambassador;
 class RTI13ObjectClass;
 typedef std::pair<RTI::AttributeHandle, RTIData> RTI13AttributeHandleDataPair;
 typedef std::list<RTI13AttributeHandleDataPair> RTI13AttributeHandleDataPairList;
 class RTI13ObjectInstance : public RTIObjectInstance {
 public:
-    RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* hlaObjectInstance, const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador, bool owned);
+    RTI13ObjectInstance(const RTI::ObjectHandle& handle, HLAObjectInstance* hlaObjectInstance, const RTI13ObjectClass* objectClass, RTI13Ambassador* ambassador);
    virtual ~RTI13ObjectInstance();
    const RTI::ObjectHandle& getHandle() const
@@ -52,8 +55,6 @@ public:
    unsigned getNumAttributes() const
    { return get13ObjectClass()->getNumAttributes(); }
    unsigned getAttributeIndex(const std::string& name) const
    { return get13ObjectClass()->getAttributeIndex(name); }
    unsigned getAttributeIndex(const RTI::AttributeHandle& handle) const
    { return get13ObjectClass()->getAttributeIndex(handle); }
    RTI::AttributeHandle getAttributeHandle(unsigned index) const
@@ -61,33 +62,35 @@ public:
    virtual std::string getName() const;
    virtual void addToRequestQueue();
    virtual void deleteObjectInstance(const RTIData& tag);
    virtual void deleteObjectInstance(const SGTimeStamp& timeStamp, const RTIData& tag);
    virtual void localDeleteObjectInstance();
-    void reflectAttributeValues(const RTI::AttributeHandleValuePairSet& attributeValuePairSet, const RTIData& tag);
+    void reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
-    void reflectAttributeValues(const RTI::AttributeHandleValuePairSet& attributeValuePairSet, const SGTimeStamp& timeStamp, const RTIData& tag);
+                                const RTIData& tag, HLAIndexList& indexPool);
-    virtual void requestObjectAttributeValueUpdate();
+    void reflectAttributeValues(RTI13AttributeHandleDataPairList& attributeHandleDataPairList,
-    void provideAttributeValueUpdate(const RTI::AttributeHandleSet& attributes);
+                                const SGTimeStamp& timeStamp, const RTIData& tag, HLAIndexList& indexPool);
    virtual void requestObjectAttributeValueUpdate(const HLAIndexList& indexList);
    void provideAttributeValueUpdate(const std::vector<RTI::AttributeHandle>& attributes);
    virtual void updateAttributeValues(const RTIData& tag);
    virtual void updateAttributeValues(const SGTimeStamp& timeStamp, const RTIData& tag);
-    void attributesInScope(const RTI::AttributeHandleSet& attributes);
+    virtual bool isAttributeOwnedByFederate(unsigned index) const;
    void attributesOutOfScope(const RTI::AttributeHandleSet& attributes);
-    void turnUpdatesOnForObjectInstance(const RTI::AttributeHandleSet& attributes);
+    void attributesInScope(const std::vector<RTI::AttributeHandle>& attributes);
-    void turnUpdatesOffForObjectInstance(const RTI::AttributeHandleSet& attributes);
+    void attributesOutOfScope(const std::vector<RTI::AttributeHandle>& attributes);
    void turnUpdatesOnForObjectInstance(const std::vector<RTI::AttributeHandle>& attributes);
    void turnUpdatesOffForObjectInstance(const std::vector<RTI::AttributeHandle>& attributes);
    // Not yet sure what to do here. But the dispatch functions are already there
-    void requestAttributeOwnershipAssumption(const RTI::AttributeHandleSet& attributes, const RTIData& tag);
+    void requestAttributeOwnershipAssumption(const std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag);
-    void attributeOwnershipDivestitureNotification(const RTI::AttributeHandleSet& attributes);
+    void attributeOwnershipDivestitureNotification(const std::vector<RTI::AttributeHandle>& attributes);
-    void attributeOwnershipAcquisitionNotification(const RTI::AttributeHandleSet& attributes);
+    void attributeOwnershipAcquisitionNotification(const std::vector<RTI::AttributeHandle>& attributes);
-    void attributeOwnershipUnavailable(const RTI::AttributeHandleSet& attributes);
+    void attributeOwnershipUnavailable(const std::vector<RTI::AttributeHandle>& attributes);
-    void requestAttributeOwnershipRelease(const RTI::AttributeHandleSet& attributes, const RTIData& tag);
+    void requestAttributeOwnershipRelease(const std::vector<RTI::AttributeHandle>& attributes, const RTIData& tag);
-    void confirmAttributeOwnershipAcquisitionCancellation(const RTI::AttributeHandleSet& attributes);
+    void confirmAttributeOwnershipAcquisitionCancellation(const std::vector<RTI::AttributeHandle>& attributes);
    void informAttributeOwnership(RTI::AttributeHandle attributeHandle, RTI::FederateHandle federateHandle);
    void attributeIsNotOwned(RTI::AttributeHandle attributeHandle);
    void attributeOwnedByRTI(RTI::AttributeHandle attributeHandle);
@@ -95,7 +98,7 @@ public:
 private:
    RTI::ObjectHandle _handle;
    SGSharedPtr<const RTI13ObjectClass> _objectClass;
-    SGWeakPtr<RTI13Ambassador> _ambassador;
+    SGSharedPtr<RTI13Ambassador> _ambassador;
    // cached storage for updates
    std::auto_ptr<RTI::AttributeHandleValuePairSet> _attributeValuePairSet;
@@ -115,6 +115,13 @@ public:
        ensureCapacity(capacity);
    }
    void swap(RTIData& data)
    {
        std::swap(_data, data._data);
        std::swap(_size, data._size);
        std::swap(_capacity, data._capacity);
    }
    void setData(char* data, unsigned size)
    {
        if (_capacity)
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -15,6 +15,12 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "RTIFederate.hxx"
 namespace simgear {
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+// Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -20,6 +20,7 @@
 #include <string>
 #include "simgear/structure/SGWeakReferenced.hxx"
 #include "RTIInteractionClass.hxx"
 #include "RTIObjectClass.hxx"
 #include "RTIObjectInstance.hxx"
@@ -32,63 +33,60 @@ public:
    RTIFederate();
    virtual ~RTIFederate();
    /// Get the name of the joined federate/federation
    const std::string& getFederateType() const
    { return _federateType; }
    const std::string& getFederationName() const
    { return _federationName; }
    /// Create a federation execution
    /// Semantically this methods should be static,
-    /// but the nonstatic case could reuse the connection to the server
+    enum FederationManagementResult {
-    /// FIXME: cannot determine from the return value if we created the execution
+        FederationManagementSuccess,
-    virtual bool createFederationExecution(const std::string& federation, const std::string& objectModel) = 0;
+        FederationManagementFail,
-    virtual bool destroyFederationExecution(const std::string& federation) = 0;
+        FederationManagementFatal
    };
    virtual FederationManagementResult createFederationExecution(const std::string& federation, const std::string& objectModel) = 0;
    virtual FederationManagementResult destroyFederationExecution(const std::string& federation) = 0;
    /// Join with federateName the federation execution federation
-    virtual bool join(const std::string& federateType, const std::string& federation) = 0;
+    virtual FederationManagementResult join(const std::string& federateType, const std::string& federation) = 0;
    virtual bool resign() = 0;
    virtual bool getJoined() const = 0;
    /// Synchronization Point handling
    virtual bool registerFederationSynchronizationPoint(const std::string& label, const RTIData& tag) = 0;
-    virtual bool waitForFederationSynchronizationPointAnnounced(const std::string& label) = 0;
+    virtual bool getFederationSynchronizationPointAnnounced(const std::string& label) = 0;
    virtual bool synchronizationPointAchieved(const std::string& label) = 0;
-    virtual bool waitForFederationSynchronized(const std::string& label) = 0;
+    virtual bool getFederationSynchronized(const std::string& label) = 0;
    /// Time management
    virtual bool enableTimeConstrained() = 0;
    virtual bool disableTimeConstrained() = 0;
    virtual bool getTimeConstrainedEnabled() = 0;
    virtual bool enableTimeRegulation(const SGTimeStamp& lookahead) = 0;
    virtual bool disableTimeRegulation() = 0;
    virtual bool modifyLookahead(const SGTimeStamp& timeStamp) = 0;
    virtual bool getTimeRegulationEnabled() = 0;
    virtual bool timeAdvanceRequestBy(const SGTimeStamp& dt) = 0;
    virtual bool timeAdvanceRequest(const SGTimeStamp& fedTime) = 0;
    virtual bool timeAdvanceRequestAvailable(const SGTimeStamp& timeStamp) = 0;
    virtual bool flushQueueRequest(const SGTimeStamp& timeStamp) = 0;
    virtual bool getTimeAdvancePending() = 0;
    virtual bool queryFederateTime(SGTimeStamp& timeStamp) = 0;
    virtual bool queryLookahead(SGTimeStamp& timeStamp) = 0;
    virtual bool queryGALT(SGTimeStamp& timeStamp) = 0;
    virtual bool queryLITS(SGTimeStamp& timeStamp) = 0;
    /// Process messages
-    virtual bool tick() = 0;
+    virtual bool processMessage() = 0;
-    virtual bool tick(const double& minimum, const double& maximum) = 0;
+    virtual bool processMessages(const double& minimum, const double& maximum) = 0;
    virtual RTIObjectClass* createObjectClass(const std::string& name, HLAObjectClass* hlaObjectClass) = 0;
-    // virtual RTIInteractionClass* createInteractionClass(const std::string& name) = 0;
+    virtual RTIInteractionClass* createInteractionClass(const std::string& name, HLAInteractionClass* interactionClass) = 0;
    virtual RTIObjectInstance* getObjectInstance(const std::string& name) = 0;
 protected:
    void setFederateType(const std::string& federateType)
    { _federateType = federateType; }
    void setFederationName(const std::string& federationName)
    { _federationName = federationName; }
 private:
    RTIFederate(const RTIFederate&);
    RTIFederate& operator=(const RTIFederate&);
    /// The federates name
    std::string _federateType;
    /// The federation execution name
    std::string _federationName;
 };
 }
@@ -1,7 +1,4 @@
-
+// Copyright (C) 2011 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
 // Written by James Turner, started July 2010.
 //
 // Copyright (C) 2010  Curtis L. Olson - http://www.flightgear.org/~curt
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Library General Public
@@ -17,25 +14,30 @@
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
 #ifndef _SG_SLEEP_HXX
 #define _SG_SLEEP_HXX
 #ifdef HAVE_CONFIG_H
 #  include <simgear_config.h>
 #endif
 #include <simgear/compiler.h>
 #include "RTIFederateFactory.hxx"
-namespace simgear
+#include "RTIFederateFactoryRegistry.hxx"
 namespace simgear {
 RTIFederateFactory::~RTIFederateFactory()
 {
 }
-void sleepForSeconds(int seconds);
+void
-
+RTIFederateFactory::_registerAtFactory()
-void sleepForMSec(int msec);
+{
-
+    SGSharedPtr<RTIFederateFactoryRegistry> registry = RTIFederateFactoryRegistry::instance();
-} // of namespace simgear
+    if (!registry.valid())
-
+        return;
-#endif // _SG_SLEEP_HXX
+    registry->registerFactory(this);
-
+}
 }
--- a/Show More
+++ b/Show More
		`@@ -1 +0,0 @@`
			`03/25/2001 - Resolve location of Sky dome implimentation documentation.`
		`@@ -1,2 +0,0 @@`
			`The handmade VS2010 project files have been replaced by the Cmake build system.`
			`Please use Cmake to build FlightGear with Visual Studio 2010.`
		`@@ -1,3 +0,0 @@`
			`SUBDIRS = $(MIPSpro_DIRS)`

			`DIST_SUBDIRS = MIPSpro721 MIPSpro740`