Bump version to 2.4.0

Avoid log output cluttering due to "missing animation objects".

.gitignore

@@ -1,19 +1,25 @@
 Makefile
 Makefile.in
-SimGear.spec
-aclocal.m4
+.deps
 autom4te.cache
-config.cache
+config.guess
 config.log
 config.status
-configure
-do-config.sh
-.cdtproject
-.project
-config.guess
 config.sub
+configure
 depcomp
-INSTALL
 install-sh
 missing
-mkinstalldirs
+aclocal.m4
+INSTALL
+SimGear.spec
+*.o
+lib*.a
+cmake_install.cmake
+CMakeFiles
+CMakeCache.txt
+CPackConfig.cmake
+CPackSourceConfig.cmake
+cmake_uninstall.cmake
+install_manifest.txt
+

CMakeLists.txt

@@ -0,0 +1,158 @@
+cmake_minimum_required (VERSION 2.6)
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+include (CheckCXXSourceCompiles)
+include (CPack)
+
+project(SimGear)
+
+# read 'version' file into a variable (stripping any newlines or spaces)
+file(READ version versionFile)
+string(STRIP ${versionFile} SIMGEAR_VERSION)
+
+#packaging
+SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
+SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
+
+# 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)
+option(SIMGEAR_HEADLESS "Set to ON to build SimGear with GUI/graphics support" OFF)
+option(JPEG_FACTORY "Enable JPEG-factory support" OFF)
+option(ENABLE_LIBSVN "Set to ON to build SimGear with libsvnclient support" OFF)
+
+set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+
+if (MSVC AND MSVC_3RDPARTY_ROOT)
+  message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
+  set( OSG_MSVC "msvc" )
+  if (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}100 )
+  else (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}90 )
+  endif (${MSVC_VERSION} EQUAL 1600)
+  if (CMAKE_CL_64)
+      set( OSG_MSVC ${OSG_MSVC}-64 )
+      set( MSVC_3RDPARTY_DIR 3rdParty.x64 )
+  else (CMAKE_CL_64)
+      set( MSVC_3RDPARTY_DIR 3rdParty )
+  endif (CMAKE_CL_64)
+
+  set (CMAKE_LIBRARY_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/lib )
+  set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/include)
+  set (BOOST_ROOT ${MSVC_3RDPARTY_ROOT}/boost_1_44_0)
+  set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+  set (ALUT_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib) 
+endif (MSVC AND MSVC_3RDPARTY_ROOT)
+
+find_package(Boost REQUIRED)
+set (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")
+
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
+
+if (${SIMGEAR_HEADLESS})
+    message(STATUS "headlesss mode")
+    set(NO_OPENSCENEGRAPH_INTERFACE 1)
+else()
+    find_package(OpenGL REQUIRED)
+    find_package(OpenAL REQUIRED)
+    find_package(ALUT REQUIRED)
+    find_package(OpenSceneGraph 2.8.1 REQUIRED osgText osgSim osgDB osgParticle osgUtil)
+endif()
+
+if(JPEG_FACTORY)
+    message(STATUS "JPEG-factory enabled")
+    find_package(JPEG REQUIRED)
+    include_directories(${JPEG_INCLUDE_DIR})
+endif()
+
+if(ENABLE_LIBSVN)
+	find_package(SvnClient)
+	
+	if(LIBSVN_FOUND)
+		message(STATUS "libsvn found, enabling in SimGear")
+		set(HAVE_SVN_CLIENT_H 1)
+		set(HAVE_LIBSVN_CLIENT_1 1)
+	endif(LIBSVN_FOUND)
+endif(ENABLE_LIBSVN)
+
+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
+find_package(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)
+
+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_MINSIZEREL_POSTFIX "s" 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(
+    "#include <cmath> 
+    void f() { isnan(0.0);} "
+    HAVE_ISNAN)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+    set(WARNING_FLAGS -Wall)
+endif(CMAKE_COMPILER_IS_GNUCXX)
+
+if(WIN32)
+
+    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")
+    endif(MSVC)
+    
+    # assumed on Windows
+    set(HAVE_GETLOCALTIME 1)
+endif(WIN32)    
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
+
+include_directories(${PROJECT_SOURCE_DIR})
+include_directories(${PROJECT_BINARY_DIR}/simgear)
+
+include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
+    ${Boost_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIR} 
+    ${ALUT_INCLUDE_DIR} ${OPENAL_INCLUDE_DIR} )
+
+
+add_definitions(-DHAVE_CONFIG_H)
+
+# configure a header file to pass some of the CMake settings
+# to the source code
+configure_file (
+  "${PROJECT_SOURCE_DIR}/simgear/simgear_config_cmake.h.in"
+  "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
+  )
+  
+install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
+add_subdirectory(simgear)
+
+#-----------------------------------------------------------------------------
+### uninstall target
+#-----------------------------------------------------------------------------
+CONFIGURE_FILE(
+  "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/cmake_uninstall.cmake.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+  IMMEDIATE @ONLY)
+ADD_CUSTOM_TARGET(uninstall
+  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+
+

CMakeModules/FindALUT.cmake

@@ -0,0 +1,67 @@
+# Locate ALUT
+# This module defines
+# ALUT_LIBRARY
+# ALUT_FOUND, if false, do not try to link to ALUT 
+# ALUT_INCLUDE_DIR, where to find the headers
+#
+# $ALUTDIR is an environment variable that would
+# correspond to the ./configure --prefix=$ALUTDIR
+# used in building ALUT.
+#
+# Created by James Turner. This was influenced by the FindOpenAL.cmake module.
+
+#=============================================================================
+# Copyright 2005-2009 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 distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Per my request, CMake should search for frameworks first in
+# the following order:
+# ~/Library/Frameworks/OpenAL.framework/Headers
+# /Library/Frameworks/OpenAL.framework/Headers
+# /System/Library/Frameworks/OpenAL.framework/Headers
+#
+# On OS X, this will prefer the Framework version (if found) over others.
+# People will have to manually change the cache values of 
+# 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
+  $ENV{ALUTDIR}
+  PATH_SUFFIXES lib64 lib libs64 libs libs/Win32 libs/Win64
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt
+)
+
+
+SET(ALUT_FOUND "NO")
+IF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+  SET(ALUT_FOUND "YES")
+ENDIF(ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+

CMakeModules/FindSvnClient.cmake

@@ -0,0 +1,48 @@
+# Find Subversion client libraries, and dependencies
+# including APR (Apache Portable Runtime)
+
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+
+find_program(HAVE_APR_CONFIG apr-1-config)
+if(HAVE_APR_CONFIG) 
+        
+    execute_process(COMMAND apr-1-config --cppflags --includes
+        OUTPUT_VARIABLE APR_CFLAGS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+        
+    execute_process(COMMAND apr-1-config --link-ld
+        OUTPUT_VARIABLE RAW_APR_LIBS
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    
+# clean up some vars, or other CMake pieces complain
+	string(STRIP ${RAW_APR_LIBS} APR_LIBS)
+
+else(HAVE_APR_CONFIG)
+    message(STATUS "apr-1-config not found, implement manual search for APR")
+endif(HAVE_APR_CONFIG)
+
+find_path(LIBSVN_INCLUDE_DIR svn_client.h
+  HINTS
+  $ENV{LIBSVN_DIR}
+  PATH_SUFFIXES include/subversion-1
+  PATHS
+  /usr/local
+  /usr
+  /opt
+)
+
+check_library_exists(svn_client-1 svn_client_checkout "" HAVE_LIB_SVNCLIENT)
+check_library_exists(svn_subr-1 svn_cmdline_init "" HAVE_LIB_SVNSUBR)
+check_library_exists(svn_ra-1 svn_ra_initialize "" HAVE_LIB_SVNRA)
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBSVN DEFAULT_MSG 
+    HAVE_LIB_SVNSUBR 
+    HAVE_LIB_SVNCLIENT
+    HAVE_LIB_SVNRA 
+    LIBSVN_INCLUDE_DIR)
+
+if(LIBSVN_FOUND)
+    set(LIBSVN_LIBRARIES "svn_client-1" "svn_subr-1" "svn_ra-1" ${APR_LIBS})
+endif(LIBSVN_FOUND)

CMakeModules/SimGearComponent.cmake

@@ -0,0 +1,23 @@
+
+macro(simgear_component name includePath sources headers)
+
+    if (SIMGEAR_SHARED)
+        foreach(s ${sources})
+            set_property(GLOBAL
+                APPEND PROPERTY ALL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+        endforeach()
+
+		foreach(h ${headers})
+			set_property(GLOBAL
+				APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+		endforeach()
+        
+    else()
+        set(libName "sg${name}")
+        add_library(${libName} STATIC ${sources} )
+
+        install (TARGETS ${libName} ARCHIVE DESTINATION lib${LIB_SUFFIX})
+        install (FILES ${headers}  DESTINATION include/simgear/${includePath})
+    endif()
+    
+endmacro()

CMakeModules/cmake_uninstall.cmake.in

@@ -0,0 +1,22 @@
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+    MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+ENDIF()
+
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+
+FOREACH(file ${files})
+    MESSAGE(STATUS "Uninstalling \"${file}\"")
+    IF(EXISTS "${file}")
+        EXEC_PROGRAM(
+            "@CMAKE_COMMAND@" ARGS "-E remove \"${file}\""
+            OUTPUT_VARIABLE rm_out
+            RETURN_VALUE rm_retval
+            )
+        IF(NOT "${rm_retval}" STREQUAL 0)
+            MESSAGE(FATAL_ERROR "Problem when removing \"${file}\"")
+        ENDIF()
+    ELSE()
+        MESSAGE(STATUS "File \"${file}\" does not exist.")
+    ENDIF()
+ENDFOREACH()

Doxyfile

@@ -22,7 +22,7 @@ PROJECT_NAME           = SimGear
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 0.3.10
+PROJECT_NUMBER         = 2.2.0
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 

Makefile.am

@@ -2,19 +2,14 @@ EXTRA_DIST = \
 	acinclude.m4 \
 	autogen.sh \
 	DoxygenMain.cxx \
-	project/VC8 \
-	README.MSVC \
 	README.zlib \
-        projects \
-	SimGear.dsp \
-	SimGear.dsw
+	README.plib \
+	README.OpenAL \
+	README.OSG \
+	projects
 
 SUBDIRS	= simgear
 
-dist-hook:
-	(cd $(top_srcdir); $(HOME)/Projects/FlightGear/admin/am2dsp.pl)
-	rm -rf `find $(distdir)/projects -name CVS`
-
 #
 # Rule to build RPM distribution package
 #

NEWS

@@ -1,3 +1,15 @@
+Version 1.9.0
+* Thu Dec 18 15:12:15 CST 2008
+
+
+Version 1.8.6
+* Mon Dec  1 14:02:47 CST 2008
+
+
+Version 1.8.5
+* October 30, 2008 (source code snapshot release)
+
+
 New in 0.3.10
 * April 5, 2006
 

README.MSVC

@@ -1,24 +0,0 @@
-This document describes how to build SimGear using the supplied workspace and
-project files.  
-
-Unpack the SimGear source file into your work directory.  This creates a new
-subdirectory called SimGear-X.Y.Z.  Rename this to SimGear.  Before we can
-build SimGear you must unpack and build the third party libraries metakit and
-zlib.  Sources for these are included in the SimGear/src-libs directory.
-Unpack these into the top level SimGear directory.  At this point your
-directory structure should look something like this:
-
-<work_dir>/
-  SimGear/
-    metakit-x.y.z/
-    simgear/
-    src-libs/
-    zlib-x.y.z/
-
-Now open the SimGear workspace.  This workspace file contains projects for
-building metakit(mklib), SimGear and zlib.  Select each project as the active
-project and build all.  Order is unimportant since there are no dependencies
-between the projects.
-
-The workspace and project files are generated by a perl script with extra
-input from the am2dsp.cfg file.

README.OSG

@@ -0,0 +1,27 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+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 
+versions of OSG will yield serious rendering bugs. 
+
+You can get the latest version of OSG from:
+
+http://www.openscenegraph.org/
+
+Build notes:
+
+Unzip the file OpenSceneGraph-x.x.zip and install using the following
+commands:
+
+unzip OpenSceneGraph-x.x
+cd OpenSceneGraph
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+make 
+sudo make install
+

README.OpenAL

@@ -3,10 +3,27 @@
 You *must* have the development components of OpenAL installed on your system
 to build FlightGear!"  You can get a copy here:
 
-    http://www.openal.org
+      http://connect.creativelabs.com/openal/default.aspx
 
 Build notes:
 
-The OpenAL developers do not make "versioned" releases so we recommend that
-you pull the latest version via anonymous CVS (follow the instructions at
-the OpenAL web site) and build/install that.
+You can download a versioned release of the openal library from 
+http://www.openal.org/downloads.html. Download the openal source,
+release 0.0.8 (dated February 11, 2006) and run:  
+tar xjvf openal-soft-1.5.304.tar.bz2
+cd openal-soft-1.5.304/
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+
+The alut library is also required, but comes separately in the package
+freelut-1.1.0.tar.gz. This package can be downloaded from the same page
+(http://connect.creativelabs.com/openal/default.aspx). Download and run:
+tar xzvf freelut-1.1.0.tar.gz
+cd freealut-1.1.0
+./configure
+make
+sudo make install
+

README.plib

@@ -1,6 +1,6 @@
 [This file is mirrored in both the FlightGear and SimGear packages.]
 
-You *must* have plib version 1.6.0 or later installed on your system
+You *must* have plib version 1.8.5 or later installed on your system
 to build FlightGear!"  Flight Gear is no longer compatible with the
 earlier versions of the library.
 
@@ -14,3 +14,19 @@ You should be able to just run "./configure" to configure the package
 and use all of plib's defaults.  Then run "make" followed by "make
 install".  By default, plib installs itself into /usr so if you don't
 like this, be sure to specify an alternate prefix such as --prefix=/usr/local
+
+As of this writing (2007-11-18), many linux distributions are shipped with a 
+working version of plib, so chances are that this library is already 
+installed. It should be noted, that currently plib version no longer compiles
+using recent versions of gcc (confirmed on version gcc 4.1.2, as shipped with 
+SuSe 10.2). As a workaround, it is possible to either use plib SVN. Run the 
+following commands: 
+
+
+svn co https://plib.svn.sourceforge.net/svnroot/plib/trunk plib
+cd plib
+./autogen.sh
+./configure
+make
+make install
+

SimGear.dsw

@@ -1,29 +0,0 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "SimGear"=".\SimGear.dsp" - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-

Thanks

@@ -47,6 +47,18 @@ Jean-Francois Doue
   http://www.animats.com/simpleppp/ftp/public_html/topics/developers.html
 
 
+Melchior Franz
+  METAR parser and fetcher. "material" animation (based on Jim Wilsons's
+  "emission" animation). Debugging and extension of property listener
+  features. Addition of removeChildren.
+
+
+Mathias Froehlich
+  Reworked and cleaned up large parts of the infrastructure, of math
+  files, animations and rendering in preparation of a transition to
+  the OSG library. Added new handlers for shared and referenced objects.
+
+
 Bruce Finney <bfinney@gte.net>
   MSVC5 compatibility.
 
@@ -71,6 +83,10 @@ Bruce Jackson of NASA <e.b.jackson@larc.nasa.gov>
   http://dcb.larc.nasa.gov/www/DCBStaff/ebj/ebj.html
 
 
+Maik Justus
+  Fixed an old bug in the SGPropertyNode class.
+
+
 Richard Kaszeta <bofh@me.umn.edu>
   Contributed screen buffer to ppm screen shot routine.
   Rich has also helped in the early development of the Flight Gear "altitude 
@@ -90,6 +106,11 @@ David Megginson <david@megginson.com>
   SimGear property manager/registry
 
 
+Tim Moore
+  Ported the (chrome) "shader" animation to OSG, and helped with porting
+  the "material" animation.
+
+
 Curt Olson http://www.flightgear.org/~curt/
   Curt is responsible for overall project and source code management.
   He has his hands in many of the areas.
@@ -99,7 +120,7 @@ Petter Reinholdtsen <pere@games.no>
   Incorporated the Gnu automake/autoconf system (with libtool).
   This should streamline and standardize the build process for all
   Unix-like platforms.  It should have little effect on IDE type 
-  environments since the don't use the Unix make system.
+  environments since these don't use the Unix make system.
 
 
 Paul Schlyter <pausch@saaf.se>  

acinclude.m4

@@ -6,19 +6,25 @@ dnl
 AC_DEFUN([wi_EXTRA_IDIR], [
 incdir="$1"
 if test -r $incdir ; then
-	case "$CPPFLAGS" in
-		*-I${incdir}*)
-			# echo "   + already had $incdir" 1>&6
-			;;
-		*)
-			if test "$CPPFLAGS" = "" ; then
-				CPPFLAGS="-I$incdir"
-			else
-				CPPFLAGS="$CPPFLAGS -I$incdir"
-			fi
-			echo "   + found $incdir" 1>&6
-			;;
-	esac
+    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
@@ -28,19 +34,25 @@ dnl
 AC_DEFUN([wi_EXTRA_LDIR], [
 mylibdir="$1"
 if test -r $mylibdir ; then
-	case "$LDFLAGS" in
-		*-L${mylibdir}*)
-			# echo "   + already had $mylibdir" 1>&6
-			;;
-		*)
-			if test "$LDFLAGS" = "" ; then
-				LDFLAGS="-L$mylibdir"
-			else
-				LDFLAGS="$LDFLAGS -L$mylibdir"
-			fi
-			echo "   + found $mylibdir" 1>&6
-			;;
-	esac
+    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
@@ -50,12 +62,9 @@ dnl
 AC_DEFUN([wi_EXTRA_PDIR], [
 progdir="$1"
 if test -r $progdir ; then
-	case "$PATH" in
-		*:${progdir}*)
-			# echo "   + already had $progdir" 1>&6
-			;;
-		*${progdir}:*)
-			# echo "   + already had $progdir" 1>&6
+	case ":$PATH:" in
+		*:${progdir}:*)
+			echo "   + already had $progdir in \$PATH" 1>&AS_MESSAGE_LOG_FD
 			;;
 		*)
 			if test "$PATH" = "" ; then
@@ -63,9 +72,11 @@ if test -r $progdir ; then
 			else
 				PATH="$PATH:$progdir"
 			fi
-			echo "   + found $progdir" 1>&6
+			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
@@ -89,23 +100,32 @@ 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)
+    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)
 
-		mylibdir="${exdir}/lib${subexdir}"
-		wi_EXTRA_LDIR($mylibdir)
+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}"
 
-		progdir="${exdir}/bin${subexdir}"
-		wi_EXTRA_PDIR($progdir)
-	fi
-done
+            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
@@ -413,3 +433,274 @@ AC_DEFUN([AC_SG_SET_COMPILER],
 ##       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
+
+])

configure.ac

@@ -1,15 +1,17 @@
-dnl Process this file with autoget.sh to produce a working configure
+dnl Process this file with autogen.sh to produce a working configure
 dnl script.
 
-AC_INIT
+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
-AM_INIT_AUTOMAKE(SimGear, 0.3.10)
-
 dnl Specify KAI C++ compiler and flags.
 dnl Borrowed with slight modification from blitz distribution.
 AC_ARG_WITH(cxx,
@@ -23,18 +25,37 @@ AC_ARG_WITH(cxx,
     ;;
   esac
 ])
+dnl set the $host variable based on local machine/os
+AC_CANONICAL_TARGET
+AM_INIT_AUTOMAKE([dist-bzip2])
 
-echo CXX = $CXX
-echo CC = $CC
+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
@@ -76,13 +97,17 @@ 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
@@ -111,12 +136,43 @@ else
 fi
 AM_CONDITIONAL(ENABLE_JPEG_SERVER, test "x$with_jpeg_factory" = "xyes")
 
-# specify the plib location
-AC_ARG_WITH(plib, [  --with-plib=PREFIX      Specify the prefix path to plib])
+# specify the osg location
+AC_ARG_WITH(osg, [  --with-osg=PREFIX       Specify the prefix path to osg])
 
-if test "x$with_plib" != "x" ; then
-    echo "plib prefix is $with_plib"
-    EXTRA_DIRS="${EXTRA_DIRS} $with_plib"
+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
@@ -139,7 +195,7 @@ esac
 wi_EXTRA_DIRS(no, ${EXTRA_DIRS})
 
 
-dnl Using AM_CONDITIONAL is a step out of the protected little 
+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
@@ -188,6 +244,7 @@ LIBS=""
 
 dnl check for some default libraries
 AC_SEARCH_LIBS(cos, m)
+AC_SEARCH_LIBS(clock_gettime, rt)
 
 base_LIBS="$LIBS"
 
@@ -229,7 +286,7 @@ case "${host}" in
     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
@@ -250,33 +307,77 @@ case "${host}" in
 
 esac
 
-AC_SEARCH_LIBS(glutGetModifiers, [ glut glut32 freeglut ], have_glut=yes, have_glut=no)
-AM_CONDITIONAL(HAVE_GLUT, test "x$have_glut" = "xyes")
-
 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 ] )
+    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"
+    LIBS="$LIBS -framework IOKit -framework OpenAL -framework ALUT"
     openal_LIBS="$LIBS"
-    # not sure how to test if OpenAL exists on MacOS (does it come by default?)
-    OPENAL_OK="yes"
+
+    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
+
     ;;
 
 *)
@@ -287,13 +388,14 @@ case "${host}" in
     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"; then
+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!"
@@ -304,6 +406,19 @@ if test "$OPENAL_OK" == "no"; then
     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)
@@ -319,45 +434,93 @@ 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++)
 
-dnl Check for "plib" without which we cannot go on
-AC_CHECK_HEADER(plib/ul.h)
-if test "x$ac_cv_header_plib_ul_h" != "xyes"; then
+# 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 plib library installed on your system to build"
-    echo "SimGear!"
+    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 "Please see README.plib for more details."
+    echo "     LIBS: '$LIBS'"
+    echo "  LDFLAGS: '$LDFLAGS'"
+    echo " CPPFLAGS: '$CPPFLAGS'"
+    echo
+    echo "Please see README.OSG for more details."
+    echo
+    echo "configure aborted."
+    exit
+  fi
+fi
+
+AC_CHECK_HEADER(boost/version.hpp)
+if test "x$ac_cv_header_boost_version_hpp" != "xyes"; then
+    echo
+    echo "You *must* have the Boost library installed on your system"
+    echo "to build this version of SimGear!"
+    echo
+    echo "     LIBS: '$LIBS'"
+    echo "  LDFLAGS: '$LDFLAGS'"
+    echo " CPPFLAGS: '$CPPFLAGS'"
     echo
     echo "configure aborted."
     exit
 fi
 
-AC_MSG_CHECKING([for plib 1.8.4 or newer])
-AC_TRY_RUN([
-#include <plib/ul.h>
+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}"
 
-#define MIN_PLIB_VERSION 184
-
-int main() {
-    int major, minor, micro;
-
-    if ( PLIB_VERSION < MIN_PLIB_VERSION ) {
-	 return -1;
-    }
-
-    return 0;
-}
-
-],
-  AC_MSG_RESULT(yes),
-  [AC_MSG_RESULT(wrong version);
-   AC_MSG_ERROR([Install plib 1.8.4 or later first...])],
-  AC_MSG_RESULT(yes)
-)
-
-LIBS="$saved_LIBS"
+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
 
@@ -377,6 +540,39 @@ if test "x$ac_cv_header_zlib_h" != "xyes"; then
     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( \
@@ -417,6 +613,7 @@ AC_CONFIG_FILES([ \
 	simgear/bucket/Makefile \
 	simgear/debug/Makefile \
 	simgear/ephemeris/Makefile \
+	simgear/hla/Makefile \
 	simgear/io/Makefile \
 	simgear/magvar/Makefile \
 	simgear/math/Makefile \
@@ -426,10 +623,13 @@ AC_CONFIG_FILES([ \
 	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 \

projects/VC100/README

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

projects/VC8/SimGear.sln

@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 9.00
-# Visual C++ Express 2005
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimGear", "SimGear.vcproj", "{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Debug|Win32.ActiveCfg = Debug|Win32
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Debug|Win32.Build.0 = Debug|Win32
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Release|Win32.ActiveCfg = Release|Win32
-		{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

projects/VC90/.gitignore

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

simgear/.cvsignore

@@ -1,8 +0,0 @@
-Makefile
-Makefile.in
-simgear_config.h
-simgear_config.h.in
-stamp-h
-stamp-h.in
-stamp-h1
-version.h

simgear/.gitignore

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

simgear/CMakeLists.txt

@@ -0,0 +1,58 @@
+
+file(WRITE ${PROJECT_BINARY_DIR}/simgear/version.h "#define SIMGEAR_VERSION ${SIMGEAR_VERSION}")
+
+foreach( mylibfolder 
+        bucket
+        debug
+        ephemeris
+        hla
+        io
+        magvar
+        math
+        misc
+        nasal
+        props
+        route
+        serial
+        structure
+        threads
+        timing
+        xml
+    )
+
+    add_subdirectory(${mylibfolder})
+
+endforeach( mylibfolder )
+
+if (NOT SIMGEAR_HEADLESS)
+    add_subdirectory(environment)
+    add_subdirectory(screen)
+    add_subdirectory(scene)
+    add_subdirectory(sound)
+endif()
+
+
+
+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")
+    get_property(allSources GLOBAL PROPERTY ALL_SOURCES)
+    get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
+
+    add_library(SimGear SHARED ${allSources})
+    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} 
+			${OPENSCENEGRAPH_LIBRARIES} 
+			${OPENAL_LIBRARY} ${ALUT_LIBRARY}
+			${OPENGL_LIBRARY})
+			
+    install(TARGETS SimGear LIBRARY DESTINATION lib${LIB_SUFFIX}
+                            PUBLIC_HEADER DESTINATION include/simgear)
+endif(SIMGEAR_SHARED)
+    

simgear/Makefile.am

@@ -1,37 +1,50 @@
+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
 
-# METAR_DIRS =
-METAR_DIRS = environment
-
-EXTRA_DIST = simgear_config.h.vc5 version.h.in
-
-include_HEADERS = \
-	compiler.h constants.h sg_inlines.h sg_traits.hxx version.h
-
-SUBDIRS = \
-	$(compatibility_DIR) \
+SUBDIRS_ALWAYS = \
 	xml \
 	debug \
 	misc \
 	structure \
 	bucket \
 	ephemeris \
+	$(HLA_DIR) \
 	io \
 	magvar \
 	math \
-	$(METAR_DIRS) \
 	nasal \
 	props \
 	route \
-	scene \
-	screen \
 	serial \
-	sound \
-	$(SGTHREAD_DIR) \
 	timing
 
-DIST_SUBDIRS = $(SUBDIRS) compatibility threads
+SUBDIRS = $(SUBDIRS_ALWAYS) \
+	$(compatibility_DIR) \
+	$(METAR_DIRS) \
+	$(SG_EXTRA_DIRS) \
+	$(SGTHREAD_DIR)
+
+DIST_SUBDIRS = $(SUBDIRS_ALWAYS) compatibility scene sound screen environment threads
+

simgear/bucket/.cvsignore

@@ -1,3 +0,0 @@
-.deps
-Makefile
-Makefile.in

simgear/bucket/CMakeLists.txt

@@ -0,0 +1,7 @@
+
+include (SimGearComponent)
+
+set(HEADERS newbucket.hxx)
+set(SOURCES newbucket.cxx)
+
+simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")

simgear/bucket/Makefile.am

@@ -11,7 +11,7 @@ libsgbucket_a_SOURCES = newbucket.cxx
 # testbucket_SOURCES = testbucket.cxx
 
 # testbucket_LDADD = \
-# 	$(top_builddir)/bucket/libsgbucket.a \
+# 	libsgbucket.a \
 # 	$(top_builddir)/misc/libsgmisc.a
 
 INCLUDES = -I$(top_srcdir)

simgear/bucket/newbucket.cxx

@@ -44,6 +44,9 @@ SGBucket::SGBucket(const double dlon, const double dlat) {
     set_bucket(dlon, dlat);
 }
 
+SGBucket::SGBucket(const SGGeod& geod) {
+    set_bucket(geod);
+}
 
 // create an impossible bucket if false
 SGBucket::SGBucket(const bool is_good) {
@@ -73,11 +76,6 @@ SGBucket::SGBucket(const long int bindex) {
 }
 
 
-// default destructor
-SGBucket::~SGBucket() {
-}
-
-
 // Set the bucket params for the specified lat and lon
 void SGBucket::set_bucket( double *lonlat ) {
     set_bucket( lonlat[0], lonlat[1] );
@@ -94,6 +92,11 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
 
     // cout << "diff = " << diff << "  span = " << span << endl;
 
+    /* Calculate the greatest integral longitude less than
+     * or equal to the given longitude (floor(dlon)),
+     * but attribute coordinates near the east border
+     * to the next tile.
+     */
     if ( (dlon >= 0) || (fabs(diff) < SG_EPSILON) ) {
 	lon = (int)dlon;
     } else {
@@ -102,22 +105,48 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
 
     // find subdivision or super lon if needed
     if ( span < SG_EPSILON ) {
+        /* sg_bucket_span() never returns 0.0
+         * or anything near it, so this really
+         * should not occur at any time.
+         */
 	// polar cap
 	lon = 0;
 	x = 0;
     } else if ( span <= 1.0 ) {
+        /* We have more than one tile per degree of
+         * longitude, so we need an x offset.
+         */
 	x = (int)((dlon - lon) / span);
     } else {
-	if ( (dlon >= 0) || (fabs(diff) < SG_EPSILON) ) {
-	    lon = (int)( (int)(lon / span) * span);
-	} else {
-	    // cout << " lon = " << lon 
-	    //  << "  tmp = " << (int)((lon-1) / span) << endl;
-	    lon = (int)( (int)((lon + 1) / span) * span - span);
-	    if ( lon < -180 ) {
-		lon = -180;
-	    }
-	}
+        /* We have one or more degrees per tile,
+         * so we need to find the base longitude
+         * of that tile.
+         *
+         * First we calculate the integral base longitude
+         * (e.g. -85.5 => -86) and then find the greatest
+         * multiple of span that is less than or equal to
+         * that longitude.
+         *
+         * That way, the Greenwich Meridian is always
+         * a tile border.
+         *
+         * This gets us into trouble with the polar caps,
+         * which have width 360 and thus either span
+         * the range from 0 to 360 or from -360 to 0
+         * degrees, depending on whether lon is positive
+         * or negative!
+         *
+         * We also get into trouble with the 8 degree tiles
+         * north of 88N and south of 88S, because the west-
+         * and east-most tiles in that range will cover 184W
+         * to 176W and 176E to 184E respectively, with their
+         * center at 180E/W!
+         */
+        lon=(int)floor(floor((lon+SG_EPSILON)/span)*span);
+        /* Correct the polar cap issue */
+        if ( lon < -180 ) {
+            lon = -180;
+        }
 	x = 0;
     }
 
@@ -126,17 +155,26 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
     //
     diff = dlat - (double)(int)dlat;
 
+    /* Again, a modified floor() function (see longitude) */
     if ( (dlat >= 0) || (fabs(diff) < SG_EPSILON) ) {
 	lat = (int)dlat;
     } else {
 	lat = (int)dlat - 1;
     }
+    /* Latitude base and offset are easier, as
+     * tiles always are 1/8 degree of latitude wide.
+     */
     y = (int)((dlat - lat) * 8);
 }
 
 
+void SGBucket::set_bucket(const SGGeod& geod)
+{
+    set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
+}
+
 // Build the path name for this bucket
-string SGBucket::gen_base_path() const {
+std::string SGBucket::gen_base_path() const {
     // long int index;
     int top_lon, top_lat, main_lon, main_lat;
     char hem, pole;
@@ -186,6 +224,17 @@ string SGBucket::gen_base_path() const {
 
 // return width of the tile in degrees
 double SGBucket::get_width() const {
+    if (lon==-180 && (lat==-89 || lat==88) ) {
+        /* Normally the tile at 180W in 88N and 89S
+         * would cover 184W to 176W and the next
+         * on the east side starts at 176W.
+         * To correct, make this a special tile
+         * from 180W to 176W with 4 degrees width
+         * instead of the normal 8 degrees at
+         * that latitude.
+         */
+         return 4.0;
+    }
     return sg_bucket_span( get_center_lat() );
 }
 
@@ -210,7 +259,7 @@ double SGBucket::get_width_m() const {
     double local_perimeter = local_radius * SGD_2PI;
     double degree_width = local_perimeter / 360.0;
 
-    return sg_bucket_span( get_center_lat() ) * degree_width;
+    return get_width() * degree_width;
 }
 
 

simgear/bucket/newbucket.hxx

@@ -24,6 +24,11 @@
 
 /** \file newbucket.hxx
  * A class and associated utiltity functions to manage world scenery tiling.
+ *
+ * Tile borders are aligned along circles of latitude and longitude.
+ * All tiles are 1/8 degree of latitude high and their width in degrees
+ * longitude depends on their latitude, adjusted in such a way that
+ * all tiles cover about the same amount of area of the earth surface.
  */
 
 #ifndef _NEWBUCKET_HXX
@@ -31,30 +36,12 @@
 
 #include <simgear/compiler.h>
 #include <simgear/constants.h>
+#include <simgear/math/SGMath.hxx>
 
-#ifdef SG_HAVE_STD_INCLUDES
-#  include <cmath>
-#  include <cstdio> // sprintf()
-#else
-#  include <math.h>
-#  include <stdio.h> // sprintf()
-#endif
-
-#include STL_IOSTREAM
-
-// I don't understand ... <math.h> or <cmath> should be included
-// already depending on how you defined SG_HAVE_STD_INCLUDES, but I
-// can go ahead and add this -- CLO
-#ifdef __MWERKS__
-SG_USING_STD(sprintf);
-SG_USING_STD(fabs);
-#endif
-
-#include STL_STRING
-
-SG_USING_STD(string);
-SG_USING_STD(ostream);
-
+#include <cmath>
+#include <cstdio> // sprintf()
+#include <ostream>
+#include <string>
 
 /**
  * standard size of a bucket in degrees (1/8 of a degree)
@@ -113,7 +100,6 @@ static double sg_bucket_span( double l ) {
 class SGBucket {
 
 private:
-    double cx, cy;  // centerpoint (lon, lat) in degrees of bucket
     short lon;        // longitude index (-180 to 179)
     short lat;        // latitude index (-90 to 89)
     char x;          // x subdivision (0 to 7)
@@ -133,6 +119,13 @@ public:
      */
     SGBucket(const double dlon, const double dlat);
 
+    /**
+     * Construct a bucket given a specific location.
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    SGBucket(const SGGeod& geod);
+
     /** Construct a bucket.
      *  @param is_good if false, create an invalid bucket.  This is
      *  useful * if you are comparing cur_bucket to last_bucket and
@@ -146,11 +139,6 @@ public:
      */
     SGBucket(const long int bindex);
 
-    /**
-     * Default destructor.
-     */
-    ~SGBucket();
-
     /**
      * Reset a bucket to represent a new lat and lon
      * @param dlon longitude specified in degrees
@@ -165,6 +153,13 @@ public:
      */
     void set_bucket( double *lonlat );
 
+    /**
+     * Reset a bucket to represent a new lat and lon
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    void set_bucket(const SGGeod& geod);
+
     /**
      * Create an impossible bucket.
      * This is useful if you are comparing cur_bucket to last_bucket
@@ -200,18 +195,19 @@ public:
      * string form.
      * @return tile index in string form
      */
-    inline string gen_index_str() const {
+    inline std::string gen_index_str() const {
 	char tmp[20];
-	sprintf(tmp, "%ld", 
-                (((long)lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x);
-	return (string)tmp;
+	std::sprintf(tmp, "%ld", 
+                     (((long)lon + 180) << 14) + ((lat + 90) << 6)
+                     + (y << 3) + x);
+	return (std::string)tmp;
     }
 
     /**
      * Build the base path name for this bucket.
      * @return base path in string form
      */
-    string gen_base_path() const;
+    std::string gen_base_path() const;
 
     /**
      * @return the center lon of a tile.
@@ -220,9 +216,9 @@ public:
 	double span = sg_bucket_span( lat + y / 8.0 + SG_HALF_BUCKET_SPAN );
 
 	if ( span >= 1.0 ) {
-	    return lon + span / 2.0;
+	    return lon + get_width() / 2.0;
 	} else {
-	    return lon + x * span + span / 2.0;
+	    return lon + x * span + get_width() / 2.0;
 	}
     }
 
@@ -252,7 +248,24 @@ public:
      * @return the height of the tile in meters.
      */
     double get_height_m() const;
- 
+
+    /**
+     * @return the center of the bucket in geodetic coordinates.
+     */
+    SGGeod get_center() const
+    { return SGGeod::fromDeg(get_center_lon(), get_center_lat()); }
+
+    /**
+     * @return the center of the bucket in geodetic coordinates.
+     */
+    SGGeod get_corner(unsigned num) const
+    {
+        double lonFac = ((num + 1) & 2) ? 0.5 : -0.5;
+        double latFac = ((num    ) & 2) ? 0.5 : -0.5;
+        return SGGeod::fromDeg(get_center_lon() + lonFac*get_width(),
+                               get_center_lat() + latFac*get_height());
+    }
+
     // Informational methods.
 
     /**
@@ -279,10 +292,15 @@ public:
 
     // friends
 
-    friend ostream& operator<< ( ostream&, const SGBucket& );
+    friend std::ostream& operator<< ( std::ostream&, const SGBucket& );
     friend bool operator== ( const SGBucket&, const SGBucket& );
 };
 
+inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
 
 /**
  * \relates SGBucket
@@ -313,10 +331,10 @@ void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy );
  * @param out output stream
  * @param b bucket
  */
-inline ostream&
-operator<< ( ostream& out, const SGBucket& b )
+inline std::ostream&
+operator<< ( std::ostream& out, const SGBucket& b )
 {
-    return out << b.lon << ":" << b.x << ", " << b.lat << ":" << b.y;
+    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
 }
 
 

simgear/compatibility/.cvsignore

@@ -1,2 +0,0 @@
-Makefile
-Makefile.in

simgear/compatibility/MIPSpro721/.cvsignore

@@ -1,2 +0,0 @@
-Makefile
-Makefile.in

simgear/compatibility/MIPSpro740/.cvsignore

@@ -1,2 +0,0 @@
-Makefile
-Makefile.in

simgear/compiler.h

@@ -23,48 +23,9 @@
  * A set of defines to encapsulate compiler and platform differences.
  * Please refer to the source code for full documentation on this file.
  *
- * Here is a summary of what this file does.
+ * This file is useful to set compiler-specific options in every file - for
+ * example, disabling warnings.
  *
- *  (1)  Defines macros for some STL includes which may be affected
- *       by file name length limitations.
- *
- *  (2)  Defines macros for some features not supported by all C++ compilers.
- *
- *  (3)  Defines 'explicit' as a null macro if the compiler doesn't support
- *       the explicit keyword.
- *
- *  (4)  Defines 'typename' as a null macro if the compiler doesn't support
- *       the typename keyword.
- *
- *  (5)  Defines bool, true and false if the compiler doesn't do so.
- *
- *  (6)  Defines SG_EXPLICIT_FUNCTION_TMPL_ARGS if the compiler
- *       supports calling a function template by providing its template
- *       arguments explicitly.
- *
- *  (7)  Defines SG_NEED_AUTO_PTR if STL doesn't provide auto_ptr<>.
- *
- *  (8)  Defines SG_NO_ARROW_OPERATOR if the compiler is unable
- *       to support operator->() for iterators.
- *
- *  (9)  Defines SG_USE_EXCEPTIONS if the compiler supports exceptions.
- *       Note: no FlightGear code uses exceptions.
- *
- *  (10) Define SG_NAMESPACES if the compiler supports namespaces.
- *
- *  (11) SG_MATH_FN_IN_NAMESPACE_STD -- not used??
- *
- *  (12) Define SG_HAVE_STD if std namespace is supported.
- *
- *  (13) Defines SG_CLASS_PARTIAL_SPECIALIZATION if the compiler 
- *       supports partial specialization of class templates.
- *
- *  (14) Defines SG_HAVE_STD_INCLUDES to use ISO C++ Standard headers.
- *
- *  (15) Defines SG_HAVE_STREAMBUF if <streambuf> of <streambuf.h> are present.
- *
- *  (16) Define SG_MATH_EXCEPTION_CLASH if math.h defines an exception class
- *       that clashes with the one defined in <stdexcept>.
  */
 
 #ifndef _SG_COMPILER_H
@@ -79,157 +40,37 @@
 #define SG_DO_STRINGIZE(X) #X
 
 #ifdef __GNUC__
-#  if __GNUC__ == 2 
-#    if __GNUC_MINOR__ < 8
-
-       // g++-2.7.x
-#      define STL_ALGORITHM  <algorithm>
-#      define STL_FUNCTIONAL <functional>
-#      define STL_IOMANIP    <iomanip.h>
-#      define STL_IOSTREAM   <iostream.h>
-#      define STL_ITERATOR   <iterator.h>
-#      define STL_FSTREAM    <fstream.h>
-#      define STL_STDEXCEPT  <stdexcept>
-#      define STL_STRING     <string>
-#      define STL_STRSTREAM  <strstream.h>
-
-#      define SG_NEED_AUTO_PTR
-#      define SG_NO_DEFAULT_TEMPLATE_ARGS
-#      define SG_INCOMPLETE_FUNCTIONAL
-#      define SG_NO_ARROW_OPERATOR
-
-#    elif __GNUC_MINOR__ >= 8
-
-       // g++-2.8.x and egcs-1.x
-#      define SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#      define SG_NEED_AUTO_PTR
-#      define SG_MEMBER_TEMPLATES
-#      define SG_NAMESPACES
-#      define SG_HAVE_STD
-#      define SG_HAVE_STREAMBUF
-#      define SG_CLASS_PARTIAL_SPECIALIZATION
-
-#      define STL_ALGORITHM  <algorithm>
-#      define STL_FUNCTIONAL <functional>
-#      define STL_IOMANIP    <iomanip>
-#      define STL_IOSTREAM   <iostream>
-#      define STL_ITERATOR   <iterator>
-#      define STL_FSTREAM    <fstream>
-#      define STL_STDEXCEPT  <stdexcept>
-#      define STL_STRING     <string>
-#      define STL_STRSTREAM  <strstream>
-
-#    endif
-#  elif __GNUC__ >= 3
-       // g++-3.0.x
-#      define SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#      define SG_NEED_AUTO_PTR
-#      define SG_MEMBER_TEMPLATES
-#      define SG_NAMESPACES
-#      define SG_HAVE_STD
-#      define SG_HAVE_STREAMBUF
-#      define SG_CLASS_PARTIAL_SPECIALIZATION
-#      define SG_HAVE_STD_INCLUDES
-
-#      define STL_ALGORITHM  <algorithm>
-#      define STL_FUNCTIONAL <functional>
-#      define STL_IOMANIP    <iomanip>
-#      define STL_IOSTREAM   <iostream>
-#      define STL_ITERATOR   <iterator>
-#      define STL_FSTREAM    <fstream>
-#      define STL_STDEXCEPT  <stdexcept>
-#      define STL_STRING     <string>
-#      define STL_STRSTREAM  <strstream>
-#  else
-#    error Time to upgrade. GNU compilers < 2.7 not supported
+#  if __GNUC__ < 3
+#    error Time to upgrade. GNU compilers < 3.0 not supported
+#  elif (__GNUC__ == 3) && (__GNUC_MINOR__ < 4)
+#    warning GCC compilers prior to 3.4 are suspect  
 #  endif
 
 #  define SG_COMPILER_STR "GNU C++ version " SG_STRINGIZE(__GNUC__) "." SG_STRINGIZE(__GNUC_MINOR__)
-
 #endif // __GNUC__
 
 /* KAI C++ */
 #if defined(__KCC)
-
-#  define SG_NAMESPACES
-#  define SG_HAVE_STD
-#  define SG_HAVE_STREAMBUF
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRING     <string>
-#  define STL_STRSTREAM  <strstream>
-
 #  define SG_COMPILER_STR "Kai C++ version " SG_STRINGIZE(__KCC_VERSION)
-
 #endif // __KCC
 
-//
-// Metrowerks 
-//
-#if defined(__MWERKS__)
-/*
-  CodeWarrior compiler from Metrowerks, Inc.
-*/
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-#  define SG_HAVE_STD
-#  define SG_NAMESPACES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRING     <string>
-
-// Temp:
-#  define bcopy(from, to, n) memcpy(to, from, n)
-
-// -rp- please use FG_MEM_COPY everywhere !
-// #define FG_MEM_COPY(to,from,n) memcpy(to, from, n)
-
-// -dw- currently used glut has no game mode stuff
-#  define GLUT_WRONG_VERSION
-
-#  define SG_COMPILER_STR "Metrowerks CodeWarrior C++ version " SG_STRINGIZE(__MWERKS__)
-
-#endif // __MWERKS__
-
 //
 // Microsoft compilers.
 //
 #ifdef _MSC_VER
 #  define bcopy(from, to, n) memcpy(to, from, n)
-#  define FG_MEM_COPY(to,from,n) memcpy(to, from, n)
 
 #  if _MSC_VER >= 1200  // msvc++ 6.0 or greater
-#    define SG_NAMESPACES
-#    define SG_HAVE_STD
-#    define SG_HAVE_STD_INCLUDES
-#    define SG_HAVE_STREAMBUF
-
-#    define STL_ALGORITHM  <algorithm>
-#    define STL_FUNCTIONAL <functional>
-#    define STL_IOMANIP    <iomanip>
-#    define STL_IOSTREAM   <iostream>
-#    define STL_ITERATOR   <iterator>
-#    define STL_FSTREAM    <fstream>
-#    define STL_STDEXCEPT  <stdexcept>
-#    define STL_STRING     <string>
-#    define STL_STRSTREAM  <strstream>
-
 #    define isnan _isnan
 #    define snprintf _snprintf
+#    if _MSC_VER < 1500
+#      define vsnprintf _vsnprintf
+#    endif
+#    define copysign _copysign
+#    define strcasecmp stricmp
+
+#    undef min
+#    undef max
 
 #    pragma warning(disable: 4786) // identifier was truncated to '255' characters
 #    pragma warning(disable: 4244) // conversion from double to float
@@ -243,79 +84,23 @@
 
 #endif // _MSC_VER
 
-#ifdef __BORLANDC__
-# if defined(HAVE_SGI_STL_PORT)
-
-// Use quotes around long file names to get around Borland's include hackery
-
-#  define STL_ALGORITHM  "algorithm"
-#  define STL_FUNCTIONAL "functional"
-
-#  define SG_MATH_EXCEPTION_CLASH
-
-# else
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRSTREAM  <strstream>
-
-#  define SG_INCOMPLETE_FUNCTIONAL
-
-# endif // HAVE_SGI_STL_PORT
-
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STRING     <string>
-#  define SG_NO_DEFAULT_TEMPLATE_ARGS
-#  define SG_NAMESPACES
-// #  define SG_HAVE_STD
-
-#  define SG_COMPILER_STR "Borland C++ version " SG_STRINGIZE(__BORLANDC__)
-
-#endif // __BORLANDC__
-
 //
 // Native SGI compilers
 //
 
 #if defined ( sgi ) && !defined( __GNUC__ )
-#  define SG_HAVE_NATIVE_SGI_COMPILERS
+# if (_COMPILER_VERSION < 740)
+#  error Need MipsPro 7.4.0 or higher now
+# endif
 
-#  define SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#  define SG_CLASS_PARTIAL_SPECIALIZATION
-#  define SG_NEED_AUTO_PTR
-#  define SG_MEMBER_TEMPLATES
-#  define SG_NAMESPACES
-#  define SG_HAVE_STD
-#  define SG_HAVE_STREAMBUF
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#if (_COMPILER_VERSION < 740)
-#  define STL_STRING     <irix_string>
-#else
-#  define STL_STRING     <string>
-#endif
-#  define STL_STRSTREAM  <strstream>
+#define SG_HAVE_NATIVE_SGI_COMPILERS
 
 #pragma set woff 1001,1012,1014,1116,1155,1172,1174
 #pragma set woff 1401,1460,1551,1552,1681
 
 #ifdef __cplusplus
-#pragma set woff 1682,3303
-#if (_COMPILER_VERSION >= 740)
-#  pragma set woff 3624
-#endif
+# pragma set woff 1682,3303
+# pragma set woff 3624
 #endif
 
 #  define SG_COMPILER_STR "SGI MipsPro compiler version " SG_STRINGIZE(_COMPILER_VERSION)
@@ -324,6 +109,7 @@
 
 
 #if defined (__sun)
+#  define SG_UNIX
 #  include <strings.h>
 #  include <memory.h>
 #  if defined ( __cplusplus )
@@ -345,24 +131,7 @@
 // Intel C++ Compiler
 //
 #if defined(__ICC) || defined (__ECC)
-#  define SG_NAMESPACES
-#  define SG_HAVE_STD
-#  define SG_HAVE_STREAMBUF
-#  define SG_HAVE_TRAITS
-#  define SG_HAVE_STD_INCLUDES
-
-#  define STL_ALGORITHM  <algorithm>
-#  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip>
-#  define STL_IOSTREAM   <iostream>
-#  define STL_ITERATOR   <iterator>
-#  define STL_FSTREAM    <fstream>
-#  define STL_STDEXCEPT  <stdexcept>
-#  define STL_STRING     <string>
-#  define STL_STRSTREAM  <strstream>
-
 #  define SG_COMPILER_STR "Intel C++ version " SG_STRINGIZE(__ICC)
-
 #endif // __ICC
 
 //
@@ -370,101 +139,51 @@
 //
 
 #ifdef __APPLE__
-#  define SG_GL_H <OpenGL/gl.h>
-#  define SG_GLX_H <AGL/agl.h>
-#  define SG_GLU_H <OpenGL/glu.h>
-#  define SG_GLEXT_H <OpenGL/glext.h>
-#  define SG_GLUT_H <GLUT/glut.h>
-
+#  define SG_MAC
+#  define SG_UNIX
+#  ifdef __GNUC__
+#    if ( __GNUC__ > 3 ) || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 3 )
 inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
-#else
-#  define SG_GL_H <GL/gl.h>
-#  define SG_GLX_H <GL/glx.h>
-#  define SG_GLU_H <GL/glu.h>
-#  define SG_GLEXT_H <GL/glext.h>
-#  define SG_GLUT_H <GL/glut.h>
+#    else
+    // any C++ header file undefines isinf and isnan
+    // so this should be included before <iostream>
+    // the functions are STILL in libm (libSystem on mac os x)
+extern "C" int (isnan)(double);
+extern "C" int (isinf)(double);
+#    endif
+#  else
+inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
+#  endif
 #endif
 
+#if defined (__FreeBSD__)
+#  define SG_UNIX
+#include <sys/param.h>
+#  if __FreeBSD_version < 500000
+     extern "C" {
+       inline int isnan(double r) { return !(r <= 0 || r >= 0); }
+     }
+#  endif
+#endif
+
+#if defined (__CYGWIN__)
+#  define SG_WINDOWS
+#  define SG_UNIX
+#  include <ieeefp.h>		// isnan
+#endif
+
+// includes both MSVC and mingw compilers
+#if defined(_WIN32) || defined(__WIN32__)
+#  define SG_WINDOWS
+#endif
+
+#if defined(__linux__) || defined(_AIX) || defined ( sgi )
+#  define SG_UNIX
+#endif
 
 //
 // No user modifiable definitions beyond here.
 //
 
-#ifdef SG_NEED_EXPLICIT
-#  define explicit
-#endif
-
-#ifdef SG_NEED_TYPENAME
-#  define typename
-#endif
-
-#ifdef SG_NEED_MUTABLE
-#  define mutable
-#endif
-
-#ifdef SG_NEED_BOOL
-   typedef int bool;
-#  define true 1
-#  define false 0
-#endif
-
-#ifdef SG_EXPLICIT_FUNCTION_TMPL_ARGS
-#  define SG_NULL_TMPL_ARGS <>
-#else
-#  define SG_NULL_TMPL_ARGS
-#endif
-
-#ifdef SG_CLASS_PARTIAL_SPECIALIZATION
-# define SG_TEMPLATE_NULL template<>
-#else
-# define SG_TEMPLATE_NULL
-#endif
-
-// SG_NO_NAMESPACES is a hook so that users can disable namespaces
-// without having to edit library headers.
-#if defined(SG_NAMESPACES) && !defined(SG_NO_NAMESPACES)
-#   define SG_NAMESPACE(X) namespace X {
-#   define SG_NAMESPACE_END }
-#   define SG_USING_NAMESPACE(X) using namespace X
-# else
-#   define SG_NAMESPACE(X)
-#   define SG_NAMESPACE_END
-#   define SG_USING_NAMESPACE(X)
-#endif
-
-/** \def SG_USING_STD(x)
- *  Expands to using std::x if SG_HAVE_STD is defined 
- */
-# ifdef SG_HAVE_STD
-#  define SG_USING_STD(X) using std::X
-#  define STD std
-# else
-#  define SG_USING_STD(X) 
-#  define STD
-# endif
-
-// Additional <functional> implementation from SGI STL 3.11
-// Adapter function objects: pointers to member functions
-#ifdef SG_INCOMPLETE_FUNCTIONAL
-
-template <class _Ret, class _Tp>
-class const_mem_fun_ref_t
-#ifndef __BORLANDC__
-    : public unary_function<_Tp,_Ret>
-#endif // __BORLANDC__
-{
-public:
-  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
-  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
-private:
-  _Ret (_Tp::*_M_f)() const;
-};
-
-template <class _Ret, class _Tp>
-inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
-  { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
-
-#endif // SG_INCOMPLETE_FUNCTIONAL
-
 #endif // _SG_COMPILER_H
 

simgear/constants.h

@@ -31,24 +31,25 @@
 
 #include <simgear/compiler.h>
 
-#ifdef SG_HAVE_STD_INCLUDES
-#  include <cmath>
-#else
-#  ifdef SG_MATH_EXCEPTION_CLASH
-#    define exception C_exception
-#  endif
-#  include <math.h>
-#endif
-
-#include <plib/sg.h>
+#include <cmath>
 
 
 // Make sure PI is defined in its various forms
 
-// SG_PI and SGD_PI (float and double) come from plib/sg.h
+#ifndef SGD_PI // remove me once FlightGear no longer uses PLIB
+
+#ifdef M_PI
+const double SGD_PI = M_PI;
+const float SG_PI = M_PI;
+#else
+const float SG_PI = 3.1415926535f;
+const double SGD_PI = 3.1415926535;
+#endif
+
+#endif // of PLIB-SG guard
 
 /** 2 * PI */
-#define SGD_2PI      6.28318530717958647692
+const double SGD_2PI = SGD_PI * 2.0;
 
 /** PI / 2 */
 #ifdef M_PI_2
@@ -58,7 +59,17 @@
 #endif
 
 /** PI / 4 */
-#define SGD_PI_4     0.78539816339744830961
+const double SGD_PI_4 = 0.78539816339744830961;
+
+#ifndef SGD_DEGREES_TO_RADIANS // // remove me once FlightGear no longer uses PLIB
+
+const double SGD_DEGREES_TO_RADIANS = SGD_PI / 180.0;
+const double SGD_RADIANS_TO_DEGREES = 180.0 / SGD_PI;
+
+const float SG_DEGREES_TO_RADIANS = SG_PI / 180.0f;
+const float SG_RADIANS_TO_DEGREES = 180.0f / SG_PI;
+
+#endif // of PLIB-SG guard
 
 /** \def SG_E "e" */
 #ifdef M_E
@@ -75,6 +86,8 @@
  *  6378.165 but this is probably close enough */
 #define SG_EARTH_RAD 6378.155
 
+// Maximum terrain elevation from sea level
+#define SG_MAX_ELEVATION_M 9000.0
 
 // Earth parameters for WGS 84, taken from LaRCsim/ls_constants.h
 
@@ -122,10 +135,10 @@
 /** Nautical Miles to Radians */
 #define SG_RAD_TO_NM        3437.7467707849392526
 
-/** Miles per second to Knots */
+/** meters per second to Knots */
 #define SG_MPS_TO_KT        1.9438444924406046432
 
-/** Knots to Miles per second */
+/** Knots to meters per second */
 #define SG_KT_TO_MPS        0.5144444444444444444
 
 /** Feet per second to Knots */
@@ -134,16 +147,16 @@
 /** Knots to Feet per second */
 #define SG_KT_TO_FPS        1.6878098571011956874
 
-/** Miles per second to Miles per hour */
+/** meters per second to Miles per hour */
 #define SG_MPS_TO_MPH       2.2369362920544020312
 
-/** Miles per hour to Miles per second */
+/** meetrs per hour to Miles per second */
 #define SG_MPH_TO_MPS       0.44704
 
 /** Meters per second to Kilometers per hour */
 #define SG_MPS_TO_KMH       3.6
 
-/** Kilometers per hour to Miles per second */
+/** Kilometers per hour to meters per second */
 #define SG_KMH_TO_MPS       0.2777777777777777778
 
 /** Pascal to Inch Mercury */

simgear/debug/.cvsignore

@@ -1,3 +0,0 @@
-.deps
-Makefile
-Makefile.in

simgear/debug/CMakeLists.txt

@@ -0,0 +1,7 @@
+
+include (SimGearComponent)
+
+set(HEADERS debug_types.h logstream.hxx)
+set(SOURCES logstream.cxx)
+
+simgear_component(debug debug "${SOURCES}" "${HEADERS}")

simgear/debug/logstream.cxx

@@ -20,18 +20,31 @@
 //
 // $Id$
 
+#include <iostream>
+
 #include "logstream.hxx"
 
-logstream *global_logstream = NULL;
+logstream *logstream::global_logstream = 0;
 
 bool            logbuf::logging_enabled = true;
-#ifdef _MSC_VER
+#ifdef _WIN32
    bool         logbuf::has_console = true;
 #endif
 sgDebugClass    logbuf::logClass        = SG_NONE;
 sgDebugPriority logbuf::logPriority     = SG_INFO;
 streambuf*      logbuf::sbuf            = NULL;
 
+namespace {
+struct ignore_me
+{
+    ignore_me()
+    {
+        logstream::initGlobalLogstream();
+    }
+};
+static ignore_me im;
+}
+
 logbuf::logbuf()
 {
 //     if ( sbuf == NULL )
@@ -90,3 +103,12 @@ logstream::setLogLevels( sgDebugClass c, sgDebugPriority p )
     logbuf::set_log_level( c, p );
 }
 
+logstream *
+logstream::initGlobalLogstream()
+{
+    // Force initialization of cerr.
+    static std::ios_base::Init initializer;
+    if( !global_logstream )
+        global_logstream = new logstream(std::cerr);
+    return global_logstream;
+}

simgear/debug/logstream.hxx

@@ -27,29 +27,18 @@
 
 #include <simgear/compiler.h>
 
-#ifdef _MSC_VER
+#ifdef _WIN32
 #  include <windows.h>
 #endif
 
-#ifdef SG_HAVE_STD_INCLUDES
-# include <streambuf>
-# include <iostream>
-#else
-# include <iostream.h>
-# include <simgear/sg_traits.hxx>
-#endif
+#include <streambuf>
+#include <ostream>
+#include <cstdio>
 
 #include <simgear/debug/debug_types.h>
 
-SG_USING_STD(streambuf);
-SG_USING_STD(ostream);
-SG_USING_STD(cout);
-SG_USING_STD(cerr);
-SG_USING_STD(endl);
-
-#ifdef __MWERKS__
-SG_USING_STD(iostream);
-#endif
+using std::streambuf;
+using std::ostream;
 
 //
 // TODO:
@@ -67,17 +56,10 @@ SG_USING_STD(iostream);
 #ifdef SG_NEED_STREAMBUF_HACK
 class logbuf : public __streambuf
 #else
-class logbuf : public streambuf
+class logbuf : public std::streambuf
 #endif
 {
 public:
-
-#ifndef SG_HAVE_STD_INCLUDES
-    typedef char_traits<char>           traits_type;
-    typedef char_traits<char>::int_type int_type;
-    // typedef char_traits<char>::pos_type pos_type;
-    // typedef char_traits<char>::off_type off_type;
-#endif
     // logbuf( streambuf* sb ) : sbuf(sb) {}
     /** Constructor */
     logbuf();
@@ -97,6 +79,8 @@ public:
      */
     void set_log_state( sgDebugClass c, sgDebugPriority p );
 
+    bool would_log( sgDebugClass c, sgDebugPriority p ) const;
+
     /**
      * Set the global logging level.
      * @param c debug class
@@ -137,9 +121,9 @@ public:
      * Set the stream buffer
      * @param sb stream buffer
      */
-    void set_sb( streambuf* sb );
+    void set_sb( std::streambuf* sb );
 
-#ifdef _MSC_VER
+#ifdef _WIN32
     static void has_no_console() { has_console = false; }
 #endif
 
@@ -155,10 +139,10 @@ protected:
 private:
 
     // The streambuf used for actual output. Defaults to cerr.rdbuf().
-    static streambuf* sbuf;
+    static std::streambuf* sbuf;
 
     static bool logging_enabled;
-#ifdef _MSC_VER
+#ifdef _WIN32
     static bool has_console;
 #endif
     static sgDebugClass logClass;
@@ -174,11 +158,7 @@ private:
 inline int
 logbuf::sync()
 {
-#ifdef SG_HAVE_STD_INCLUDES
 	return sbuf->pubsync();
-#else
-	return sbuf->sync();
-#endif
 }
 
 inline void
@@ -187,10 +167,16 @@ logbuf::set_log_state( sgDebugClass c, sgDebugPriority p )
     logging_enabled = ((c & logClass) != 0 && p >= logPriority);
 }
 
+inline bool
+logbuf::would_log( sgDebugClass c, sgDebugPriority p ) const
+{
+    return ((c & logClass) != 0 && p >= logPriority);
+}
+
 inline logbuf::int_type
 logbuf::overflow( int c )
 {
-#ifdef _MSC_VER
+#ifdef _WIN32
     if ( logging_enabled ) {
         if ( !has_console ) {
             AllocConsole();
@@ -238,23 +224,23 @@ struct logstream_base
 /**
  * Class to manage the debug logging stream.
  */
-class logstream : private logstream_base, public ostream
+class logstream : private logstream_base, public std::ostream
 {
 public:
     /**
      * The default is to send messages to cerr.
      * @param out output stream
      */
-    logstream( ostream& out )
+    logstream( std::ostream& out )
 	// : logstream_base(out.rdbuf()),
 	: logstream_base(),
-	  ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
+	  std::ostream(&lbuf) { lbuf.set_sb(out.rdbuf());}
 
     /**
      * Set the output stream
      * @param out output stream
      */
-    void set_output( ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
+    void set_output( std::ostream& out ) { lbuf.set_sb( out.rdbuf() ); }
 
     /**
      * Set the global log class and priority level.
@@ -263,22 +249,29 @@ public:
      */
     void setLogLevels( sgDebugClass c, sgDebugPriority p );
 
+    bool would_log(  sgDebugClass c, sgDebugPriority p ) const
+    {
+        return lbuf.would_log( c, p );
+    };
+
     /**
      * Output operator to capture the debug level and priority of a message.
      * @param l log level
      */
-    inline ostream& operator<< ( const loglevel& l );
+    inline std::ostream& operator<< ( const loglevel& l );
+    friend logstream& sglog();
+    static logstream *initGlobalLogstream();
+protected:
+    static logstream *global_logstream;
 };
 
-inline ostream&
+inline std::ostream&
 logstream::operator<< ( const loglevel& l )
 {
     lbuf.set_log_state( l.logClass, l.logPriority );
     return *this;
 }
 
-extern logstream *global_logstream;
-
 /**
  * \relates logstream
  * Return the one and only logstream instance.
@@ -289,22 +282,7 @@ extern logstream *global_logstream;
 inline logstream&
 sglog()
 {
-  if (global_logstream == NULL) {
-
-#ifdef __APPLE__
-    /**
-     * There appears to be a bug in the C++ runtime in Mac OS X that
-     * will crash if certain funtions are called (in this case
-     * cerr.rdbuf()) during static initialization of a class. This
-     * print statement is hack to kick the library in the pants so it
-     * won't crash when cerr.rdbuf() is first called -DW 
-     **/
-    cout << "Using Mac OS X hack for initializing C++ stdio..." << endl;
-#endif    
-    global_logstream = new logstream (cerr);
-  }
-    
-  return *global_logstream;
+    return *logstream::initGlobalLogstream();
 }
 
 
@@ -316,12 +294,15 @@ sglog()
  */
 #ifdef FG_NDEBUG
 # define SG_LOG(C,P,M)
-#elif defined( __MWERKS__ )
-# define SG_LOG(C,P,M) ::sglog() << ::loglevel(C,P) << M << std::endl
 #else
-# define SG_LOG(C,P,M) sglog() << loglevel(C,P) << M << endl
+# define SG_LOG(C,P,M) do {                     \
+	logstream& __tmplogstreamref(sglog());                      \
+	if(__tmplogstreamref.would_log(C,P)) {                      \
+        __tmplogstreamref << loglevel(C,P) << M << std::endl; } \
+	} while(0)
 #endif
 
+#define SG_ORIGIN __FILE__ ":" SG_STRINGIZE(__LINE__)
 
 #endif // _LOGSTREAM_H
 

simgear/debug/logtest.cxx

@@ -1,5 +1,5 @@
 #include <string>
-#include "Debug/logstream.hxx"
+#include <simgear/debug/logstream.hxx>
 
 class Test {
 

simgear/environment/.cvsignore

@@ -1,4 +0,0 @@
-.deps
-Makefile
-Makefile.in
-metar

simgear/environment/CMakeLists.txt

@@ -0,0 +1,7 @@
+
+include (SimGearComponent)
+
+set(HEADERS metar.hxx precipitation.hxx)
+set(SOURCES metar.cxx precipitation.cxx)
+
+simgear_component(environment environment "${SOURCES}" "${HEADERS}")

simgear/environment/Makefile.am

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

simgear/environment/metar.cxx

@@ -30,6 +30,7 @@
 
 #include <string>
 #include <time.h>
+#include <cstring>
 
 #include <simgear/io/sg_socket.hxx>
 #include <simgear/debug/logstream.hxx>
@@ -159,7 +160,7 @@ void SGMetar::useCurrentDate()
 {
 	struct tm now;
 	time_t now_sec = time(0);
-#if defined( _MSC_VER ) || defined ( __MINGW32__ )
+#ifdef _WIN32
 	now = *gmtime(&now_sec);
 #else
 	gmtime_r(&now_sec, &now);
@@ -189,11 +190,12 @@ char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
 	const int buflen = 512;
 	char buf[2 * buflen];
 
-	string host = proxy.empty() ? "weather.noaa.gov" : proxy;
+	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://weather.noaa.gov" + path;
+	_url = "http://" + metar_server + path;
 
 	SGSocket *sock = new SGSocket(host, port.empty() ? "80" : port, "tcp");
 	sock->set_timeout(10000);
@@ -204,10 +206,11 @@ char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
 
 	string get = "GET ";
 	if (!proxy.empty())
-		get += "http://weather.noaa.gov";
+		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";
@@ -465,11 +468,13 @@ bool SGMetar::scanVisibility()
 	int modifier = SGMetarVisibility::EQUALS;
 // \d{4}(N|NE|E|SE|S|SW|W|NW)?
 	if (scanNumber(&m, &i, 4)) {
-		if (*m == 'E')
+		if( strncmp( m, "NDV",3 ) == 0 ) {
+			m+=3; // tolerate NDV (no directional validation)
+		} else if (*m == 'E') {
 			m++, dir = 90;
-		else if (*m == 'W')
+		} else if (*m == 'W') {
 			m++, dir = 270;
-		else if (*m == 'N') {
+		} else if (*m == 'N') {
 			m++;
 			if (*m == 'E')
 				m++, dir = 45;
@@ -485,7 +490,7 @@ bool SGMetar::scanVisibility()
 				m++, dir = 225;
 			else
 				dir = 180;
-		}
+                }
 		if (i == 0)
 			i = 50, modifier = SGMetarVisibility::LESS_THAN;
 		else if (i == 9999)
@@ -493,7 +498,6 @@ bool SGMetar::scanVisibility()
 		distance = i;
 	} else {
 // M?(\d{1,2}|\d{1,2}/\d{1,2}|\d{1,2} \d{1,2}/\d{1,2})(SM|KM)
-		modifier = 0;
 		if (*m == 'M')
 			m++, modifier = SGMetarVisibility::LESS_THAN;
 
@@ -592,7 +596,7 @@ bool SGMetar::scanRwyVisRange()
 	r._max_visibility._distance = to;
 
 	if (*m == '/')					// this is not in the spec!
-		*m++;
+		m++;
 	if (*m == 'D')
 		m++, r._min_visibility._tendency = SGMetarVisibility::DECREASING;
 	else if (*m == 'N')
@@ -613,8 +617,8 @@ bool SGMetar::scanRwyVisRange()
 
 static const struct Token special[] = {
 	{ "NSW",  "no significant weather" },
-	{ "VCSH", "showers in the vicinity" },
-	{ "VCTS", "thunderstorm in the vicinity" },
+/*	{ "VCSH", "showers in the vicinity" },
+	{ "VCTS", "thunderstorm in the vicinity" }, */
 	{ 0, 0 }
 };
 
@@ -667,6 +671,7 @@ bool SGMetar::scanWeather()
 	char *m = _m;
 	string weather;
 	const struct Token *a;
+
 	if ((a = scanToken(&m, special))) {
 		if (!scanBoundary(&m))
 			return false;
@@ -676,32 +681,35 @@ bool SGMetar::scanWeather()
 	}
 
 	string pre, post;
-	int intensity = 0;
+    struct Weather w;
 	if (*m == '-')
-		m++, pre = "light ", intensity = 1;
+		m++, pre = "light ", w.intensity = LIGHT;
 	else if (*m == '+')
-		m++, pre = "heavy ", intensity = 3;
+		m++, pre = "heavy ", w.intensity = HEAVY;
 	else if (!strncmp(m, "VC", 2))
-		m += 2, post = "in the vicinity ";
+        m += 2, post = "in the vicinity ", w.vincinity=true;
 	else
-		pre = "moderate ", intensity = 2;
+		pre = "moderate ", w.intensity = MODERATE;
 
 	int i;
 	for (i = 0; i < 3; i++) {
 		if (!(a = scanToken(&m, description)))
 			break;
+		w.descriptions.push_back(a->id);
 		weather += string(a->text) + " ";
 	}
+
 	for (i = 0; i < 3; i++) {
 		if (!(a = scanToken(&m, phenomenon)))
 			break;
+        w.phenomena.push_back(a->id);
 		weather += string(a->text) + " ";
 		if (!strcmp(a->id, "RA"))
-			_rain = intensity;
+			_rain = w.intensity;
 		else if (!strcmp(a->id, "HA"))
-			_hail = intensity;
+			_hail = w.intensity;
 		else if (!strcmp(a->id, "SN"))
-			_snow = intensity;
+			_snow = w.intensity;
 	}
 	if (!weather.length())
 		return false;
@@ -711,6 +719,8 @@ bool SGMetar::scanWeather()
 	weather = pre + weather + post;
 	weather.erase(weather.length() - 1);
 	_weather.push_back(weather);
+    if( w.phenomena.size() > 0 )
+        _weather2.push_back( w );
 	_grpcount++;
 	return true;
 }
@@ -739,7 +749,7 @@ static const struct Token cloud_types[] = {
 	{ 0, 0 }
 };
 
-
+#include <iostream>
 // (FEW|SCT|BKN|OVC|SKC|CLR|CAVOK|VV)([0-9]{3}|///)?[:cloud_type:]?
 bool SGMetar::scanSkyCondition()
 {
@@ -747,8 +757,17 @@ bool SGMetar::scanSkyCondition()
 	int i;
 	SGMetarCloud cl;
 
+	if (!strncmp(m, "//////", 6)) {
+		m += 6;
+		if (!scanBoundary(&m))
+			return false;
+		_m = m;
+		return true;
+	}
+
 	if (!strncmp(m, "CLR", i = 3)				// clear
 			|| !strncmp(m, "SKC", i = 3)		// sky clear
+			|| !strncmp(m, "NCD", i = 3)		// nil cloud detected
 			|| !strncmp(m, "NSC", i = 3)		// no significant clouds
 			|| !strncmp(m, "CAVOK", i = 5))	{	// ceiling and visibility OK (implies 9999)
 		m += i;
@@ -756,7 +775,7 @@ bool SGMetar::scanSkyCondition()
 			return false;
 
 		if (i == 3) {
-			cl._coverage = 0;
+            cl._coverage = SGMetarCloud::COVERAGE_CLEAR;
 			_clouds.push_back(cl);
 		} else {
 			_cavok = true;
@@ -768,13 +787,13 @@ bool SGMetar::scanSkyCondition()
 	if (!strncmp(m, "VV", i = 2))				// vertical visibility
 		;
 	else if (!strncmp(m, "FEW", i = 3))
-		cl._coverage = 1;
+        cl._coverage = SGMetarCloud::COVERAGE_FEW;
 	else if (!strncmp(m, "SCT", i = 3))
-		cl._coverage = 2;
+        cl._coverage = SGMetarCloud::COVERAGE_SCATTERED;
 	else if (!strncmp(m, "BKN", i = 3))
-		cl._coverage = 3;
+        cl._coverage = SGMetarCloud::COVERAGE_BROKEN;
 	else if (!strncmp(m, "OVC", i = 3))
-		cl._coverage = 4;
+        cl._coverage = SGMetarCloud::COVERAGE_OVERCAST;
 	else
 		return false;
 	m += i;
@@ -787,7 +806,7 @@ bool SGMetar::scanSkyCondition()
 	} else if (!scanNumber(&m, &i, 3))
 		i = -1;
 
-	if (cl._coverage == -1) {
+    if (cl._coverage == SGMetarCloud::COVERAGE_NIL) {
 		if (!scanBoundary(&m))
 			return false;
 		if (i == -1)			// 'VV///'
@@ -836,7 +855,7 @@ bool SGMetar::scanTemperature()
 		return false;
 	if (!scanBoundary(&m)) {
 		if (!strncmp(m, "XX", 2))	// not spec compliant!
-			m += 2, sign = 0;
+			m += 2, sign = 0, dew = temp;
 		else {
 			sign = 1;
 			if (*m == 'M')
@@ -1174,7 +1193,7 @@ const struct Token *SGMetar::scanToken(char **str, const struct Token *list)
 {
 	const struct Token *longest = 0;
 	int maxlen = 0, len;
-	char *s;
+	const char *s;
 	for (int i = 0; (s = list[i].id); i++) {
 		len = strlen(s);
 		if (!strncmp(s, *str, len) && len > maxlen) {
@@ -1187,13 +1206,29 @@ const struct Token *SGMetar::scanToken(char **str, const struct Token *list)
 }
 
 
-void SGMetarCloud::set(double alt, int cov)
+void SGMetarCloud::set(double alt, Coverage cov)
 {
 	_altitude = alt;
 	if (cov != -1)
 		_coverage = cov;
 }
 
+SGMetarCloud::Coverage SGMetarCloud::getCoverage( const std::string & coverage ) 
+{
+	if( coverage == "clear" ) return COVERAGE_CLEAR;
+	if( coverage == "few" ) return COVERAGE_FEW;
+	if( coverage == "scattered" ) return COVERAGE_SCATTERED;
+	if( coverage == "broken" ) return COVERAGE_BROKEN;
+	if( coverage == "overcast" ) return COVERAGE_OVERCAST;
+	return COVERAGE_NIL;
+}
+
+const char * SGMetarCloud::COVERAGE_NIL_STRING = "nil";
+const char * SGMetarCloud::COVERAGE_CLEAR_STRING = "clear";
+const char * SGMetarCloud::COVERAGE_FEW_STRING = "few";
+const char * SGMetarCloud::COVERAGE_SCATTERED_STRING = "scattered";
+const char * SGMetarCloud::COVERAGE_BROKEN_STRING = "broken";
+const char * SGMetarCloud::COVERAGE_OVERCAST_STRING = "overcast";
 
 void SGMetarVisibility::set(double dist, int dir, int mod, int tend)
 {

simgear/environment/metar.hxx

@@ -29,16 +29,16 @@
 
 #include <simgear/constants.h>
 
-SG_USING_STD(vector);
-SG_USING_STD(map);
-SG_USING_STD(string);
+using std::vector;
+using std::map;
+using std::string;
 
 const double SGMetarNaN = -1E20;
 #define NaN SGMetarNaN
 
 struct Token {
-	char	*id;
-	char	*text;
+	const char *id;
+	const char *text;
 };
 
 
@@ -130,25 +130,38 @@ protected:
 class SGMetarCloud {
 	friend class SGMetar;
 public:
-	SGMetarCloud() :
-		_coverage(-1),
-		_altitude(NaN),
-		_type(0),
-		_type_long(0) {}
+	enum Coverage {
+		COVERAGE_NIL = -1,
+		COVERAGE_CLEAR = 0,
+		COVERAGE_FEW = 1,
+		COVERAGE_SCATTERED = 2,
+		COVERAGE_BROKEN = 3,
+		COVERAGE_OVERCAST = 4
+	};
 
-	void set(double alt, int cov = -1);
+	static const char * COVERAGE_NIL_STRING;
+	static const char * COVERAGE_CLEAR_STRING;
+	static const char * COVERAGE_FEW_STRING;
+	static const char * COVERAGE_SCATTERED_STRING;
+	static const char * COVERAGE_BROKEN_STRING;
+	static const char * COVERAGE_OVERCAST_STRING;
 
-	inline int	getCoverage()		const { return _coverage; }
-	inline double	getAltitude_m()		const { return _altitude; }
-	inline double	getAltitude_ft()	const { return _altitude == NaN ? NaN : _altitude * SG_METER_TO_FEET; }
-	inline char	*getTypeString()	const { return _type; }
-	inline char	*getTypeLongString()	const { return _type_long; }
+	SGMetarCloud() : _coverage(COVERAGE_NIL), _altitude(NaN), _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 const char *getTypeString() const { return _type; }
+	inline const char *getTypeLongString() const { return _type_long; }
 
 protected:
-	int	_coverage;		// quarters: 0 -> clear ... 4 -> overcast
-	double	_altitude;		// 1000 m
-	char	*_type;			// CU
-	char	*_type_long;		// cumulus
+	Coverage _coverage;     // quarters: 0 -> clear ... 4 -> overcast
+	double _altitude;       // 1000 m
+	const char *_type;      // CU
+	const char *_type_long; // cumulus
 };
 
 
@@ -165,6 +178,21 @@ public:
 		RTD
 	};
 
+	enum Intensity {
+		NIL = 0,
+		LIGHT = 1,
+		MODERATE = 2,
+		HEAVY = 3
+	};
+
+	struct Weather {
+		Weather() { intensity = NIL; vincinity = false; }
+		Intensity intensity;
+		bool      vincinity;
+		vector<string> descriptions;
+		vector<string> phenomena;
+	};
+
 	inline const char *getData()		const { return _data; }
 	inline const char *getUnusedData()	const { return _m; }
 	inline const bool getProxy()		const { return _x_proxy; }
@@ -212,6 +240,7 @@ public:
 	inline const vector<SGMetarCloud>& getClouds()	const	{ return _clouds; }
 	inline const map<string, SGMetarRunway>& getRunways()	const	{ return _runways; }
 	inline const vector<string>& getWeather()		const	{ return _weather; }
+	inline const vector<struct Weather> getWeather2()	const   { return _weather2; }
 
 protected:
 	string	_url;
@@ -238,6 +267,7 @@ protected:
 	int	_hail;
 	int	_snow;
 	bool	_cavok;
+	vector<struct Weather> _weather2;
 
 	SGMetarVisibility		_min_visibility;
 	SGMetarVisibility		_max_visibility;

simgear/environment/precipitation.cxx

@@ -0,0 +1,203 @@
+/**
+ * @file precipitation.cxx
+ * @author Nicolas VIVIEN
+ * @date 2008-02-10
+ *
+ * @note Copyright (C) 2008 Nicolas VIVIEN
+ *
+ * @brief Precipitation effects to draw rain and snow.
+ *
+ * @par Licences
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License as
+ *   published by the Free Software Foundation; either version 2 of the
+ *   License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *   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 "precipitation.hxx"
+//#include "visual_enviro.hxx"
+
+#include <simgear/constants.h>
+#include <osg/ClipNode>
+
+/**
+ * @brief SGPrecipitation constructor
+ *
+ * Build a new OSG object from osgParticle.
+ */
+SGPrecipitation::SGPrecipitation() :
+    _freeze(false), _enabled(true), _snow_intensity(0.0), _rain_intensity(0.0), _clip_distance(5.0)
+{
+    _precipitationEffect = new osgParticle::PrecipitationEffect;
+}
+
+void SGPrecipitation::setEnabled( bool value )
+{
+    _enabled = value;
+}
+
+bool SGPrecipitation::getEnabled() const
+{
+    return _enabled;
+}
+
+/**
+ * @brief Build and add the object "precipitationEffect"
+ *
+ * This function permits you to create an object precipitationEffect and initialize it.
+ * I define by default the color of water (for raining)
+ */
+osg::Group* SGPrecipitation::build(void)
+{
+    osg::Group* group = new osg::Group;
+
+    _precipitationEffect->snow(0);	
+    _precipitationEffect->rain(0);	
+
+    if (_clip_distance!=0.0)
+    {    
+        osg::ref_ptr<osg::ClipNode> clipNode = new osg::ClipNode;
+        clipNode->addClipPlane( new osg::ClipPlane( 0 ) );
+        clipNode->getClipPlane(0)->setClipPlane( 0.0, 0.0, -1.0, -_clip_distance );
+        clipNode->setReferenceFrame(osg::ClipNode::ABSOLUTE_RF);
+        clipNode->addChild(_precipitationEffect.get());
+
+        group->addChild(clipNode.get());
+    }
+    else
+    {
+        group->addChild(_precipitationEffect.get());
+    }
+
+    return group;
+}
+
+
+/**
+ * @brief Define the snow intensity
+ *
+ * This function permits you to define and change the snow intensity
+ * The param 'intensity' is normed (0 to 1).
+ */
+void SGPrecipitation::setSnowIntensity(float intensity)
+{
+    if (this->_snow_intensity < intensity-0.001)
+        this->_snow_intensity += 0.001;
+    else if (this->_snow_intensity > intensity+0.001)
+        this->_snow_intensity -= 0.001;
+    else
+        this->_snow_intensity = intensity;
+}
+
+
+/**
+ * @brief Define the rain intensity
+ *
+ * This function permits you to define and change the rain intensity
+ * The param 'intensity' is normed (0 to 1).
+ */
+void SGPrecipitation::setRainIntensity(float intensity)
+{
+    if (this->_rain_intensity < intensity-0.001)
+        this->_rain_intensity += 0.001;
+    else if (this->_rain_intensity > intensity+0.001)
+        this->_rain_intensity -= 0.001;
+    else
+        this->_rain_intensity = intensity;
+}
+
+
+/** 
+ * @brief Freeze the rain to snow
+ * 
+ * @param freeze Boolean 
+ * 
+ * This function permits you to turn off the rain to snow.
+ */
+void SGPrecipitation::setFreezing(bool freeze)
+{
+    this->_freeze = freeze;
+}
+
+
+/**
+ * @brief Define the wind direction and speed
+ *
+ * This function permits you to define and change the wind direction
+ * 
+ * After apply the MatrixTransform to the osg::Precipitation object,
+ * x points full south... From wind heading and speed, we can calculate
+ * the wind vector.
+ */
+void SGPrecipitation::setWindProperty(double heading, double speed)
+{
+    double x, y, z;
+
+    heading = (heading + 180) * SGD_DEGREES_TO_RADIANS;
+    speed = speed * SG_FEET_TO_METER;
+
+    x = -cos(heading) * speed;
+    y = sin(heading) * speed;
+    z = 0;
+
+    this->_wind_vec = osg::Vec3(x, y, z);
+}
+
+
+/**
+ * @brief Update the precipitation effects
+ *
+ * This function permits you to update the precipitation effects.
+ * Be careful, if snow and rain intensity are greater than '0', snow effect
+ * will be first.
+ *
+ * The settings come from the osgParticule/PrecipitationEffect.cpp exemple.
+ */
+bool SGPrecipitation::update(void)
+{
+    if (this->_freeze) {
+        if (this->_rain_intensity > 0) 
+            this->_snow_intensity = this->_rain_intensity;
+    }
+
+    if (_enabled && this->_snow_intensity > 0) {
+        _precipitationEffect->setWind(_wind_vec);
+        _precipitationEffect->setParticleSpeed( -0.75f - 0.25f*_snow_intensity);
+		
+        _precipitationEffect->setParticleSize(0.02f + 0.03f*_snow_intensity);
+        _precipitationEffect->setMaximumParticleDensity(_snow_intensity * 7.2f);
+        _precipitationEffect->setCellSize(osg::Vec3(5.0f / (0.25f+_snow_intensity), 5.0f / (0.25f+_snow_intensity), 5.0f));
+		
+        _precipitationEffect->setNearTransition(25.f);
+        _precipitationEffect->setFarTransition(100.0f - 60.0f*sqrtf(_snow_intensity));
+		
+        _precipitationEffect->setParticleColor(osg::Vec4(0.85, 0.85, 0.85, 1.0) - osg::Vec4(0.1, 0.1, 0.1, 1.0) * _snow_intensity);
+    } else if (_enabled && this->_rain_intensity > 0) {
+        _precipitationEffect->setWind(_wind_vec);
+        _precipitationEffect->setParticleSpeed( -2.0f + -5.0f*_rain_intensity);
+		
+        _precipitationEffect->setParticleSize(0.01 + 0.02*_rain_intensity);
+        _precipitationEffect->setMaximumParticleDensity(_rain_intensity * 7.5f);
+        _precipitationEffect->setCellSize(osg::Vec3(5.0f / (0.25f+_rain_intensity), 5.0f / (0.25f+_rain_intensity), 5.0f));
+		
+        _precipitationEffect->setNearTransition(25.f);
+        _precipitationEffect->setFarTransition(100.0f - 60.0f*sqrtf(_rain_intensity));
+		
+        _precipitationEffect->setParticleColor( osg::Vec4(0x7A, 0xCE, 0xFF, 0x80));
+    } else {
+        _precipitationEffect->snow(0);	
+        _precipitationEffect->rain(0);	
+    }
+
+    return true;
+}

simgear/environment/precipitation.hxx

@@ -0,0 +1,65 @@
+/**
+ * @file precipitation.hxx
+ * @author Nicolas VIVIEN
+ * @date 2008-02-10
+ *
+ * @note Copyright (C) 2008 Nicolas VIVIEN
+ *
+ * @brief Precipitation effects to draw rain and snow.
+ *
+ * @par Licences
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License as
+ *   published by the Free Software Foundation; either version 2 of the
+ *   License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *   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 _PRECIPITATION_HXX
+#define _PRECIPITATION_HXX
+
+#include <osg/Group>
+#include <osg/Referenced>
+#include <osgParticle/PrecipitationEffect>
+
+
+class SGPrecipitation : public osg::Referenced
+{
+private:
+    bool _freeze;
+    bool _enabled;
+
+    float _snow_intensity;
+    float _rain_intensity;
+    float _clip_distance;
+	
+    int _wind_dir;
+    osg::Vec3 _wind_vec;
+	
+    osg::ref_ptr<osgParticle::PrecipitationEffect> _precipitationEffect;
+
+public:
+    SGPrecipitation();
+    virtual ~SGPrecipitation() {}
+    osg::Group* build(void);
+    bool update(void);
+	
+    void setWindProperty(double, double);
+    void setFreezing(bool);
+    void setRainIntensity(float);
+    void setSnowIntensity(float);
+
+    void setEnabled( bool );
+    bool getEnabled() const;
+};
+
+#endif

simgear/environment/visual_enviro.cxx

@@ -28,9 +28,7 @@
 #include <simgear/structure/SGSharedPtr.hxx>
 #include <simgear/math/sg_random.h>
 #include <simgear/math/sg_geodesy.hxx>
-#include <simgear/math/point3d.hxx>
-#include <simgear/math/polar3d.hxx>
-#include <simgear/sound/soundmgr_openal.hxx>
+#include <simgear/sound/sample_group.hxx>
 #include <simgear/scene/sky/cloudfield.hxx>
 #include <simgear/scene/sky/newcloud.hxx>
 #include <simgear/props/props.hxx>
@@ -38,11 +36,11 @@
 
 #include <vector>
 
-SG_USING_STD(vector);
+using std::vector;
 
 
 typedef struct {
-	Point3D		pt;
+	SGVec3d		pt;
 	int			depth;
 	int			prev;
 } lt_tree_seg;
@@ -52,23 +50,23 @@ static float rainpos[MAX_RAIN_SLICE];
 #define MAX_LT_TREE_SEG	400
 
 #define DFL_MIN_LIGHT 0.35
-sgVec3 SGEnviro::min_light = {DFL_MIN_LIGHT, DFL_MIN_LIGHT, DFL_MIN_LIGHT};
+SGVec3f SGEnviro::min_light(DFL_MIN_LIGHT, DFL_MIN_LIGHT, DFL_MIN_LIGHT);
 #define DFL_STREAK_BRIGHT_NEARMOST_LAYER 0.9
-SGfloat SGEnviro::streak_bright_nearmost_layer = DFL_STREAK_BRIGHT_NEARMOST_LAYER;
+float SGEnviro::streak_bright_nearmost_layer = DFL_STREAK_BRIGHT_NEARMOST_LAYER;
 #define DFL_STREAK_BRIGHT_FARMOST_LAYER 0.5
-SGfloat SGEnviro::streak_bright_farmost_layer = DFL_STREAK_BRIGHT_FARMOST_LAYER;
+float SGEnviro::streak_bright_farmost_layer = DFL_STREAK_BRIGHT_FARMOST_LAYER;
 #define DFL_STREAK_PERIOD_MAX 2.5
-SGfloat SGEnviro::streak_period_max = DFL_STREAK_PERIOD_MAX;
+float SGEnviro::streak_period_max = DFL_STREAK_PERIOD_MAX;
 #define DFL_STREAK_PERIOD_CHANGE_PER_KT 0.005
-SGfloat SGEnviro::streak_period_change_per_kt = DFL_STREAK_PERIOD_CHANGE_PER_KT;
+float SGEnviro::streak_period_change_per_kt = DFL_STREAK_PERIOD_CHANGE_PER_KT;
 #define DFL_STREAK_PERIOD_MIN 1.0
-SGfloat SGEnviro::streak_period_min = DFL_STREAK_PERIOD_MIN;
+float SGEnviro::streak_period_min = DFL_STREAK_PERIOD_MIN;
 #define DFL_STREAK_LENGTH_MIN 0.03
-SGfloat SGEnviro::streak_length_min = DFL_STREAK_LENGTH_MIN;
+float SGEnviro::streak_length_min = DFL_STREAK_LENGTH_MIN;
 #define DFL_STREAK_LENGTH_CHANGE_PER_KT 0.0005
-SGfloat SGEnviro::streak_length_change_per_kt = DFL_STREAK_LENGTH_CHANGE_PER_KT;
+float SGEnviro::streak_length_change_per_kt = DFL_STREAK_LENGTH_CHANGE_PER_KT;
 #define DFL_STREAK_LENGTH_MAX 0.1
-SGfloat SGEnviro::streak_length_max = DFL_STREAK_LENGTH_MAX;
+float SGEnviro::streak_length_max = DFL_STREAK_LENGTH_MAX;
 #define DFL_STREAK_COUNT_MIN 40
 int SGEnviro::streak_count_min = DFL_STREAK_COUNT_MIN;
 #define DFL_STREAK_COUNT_MAX 190
@@ -77,9 +75,9 @@ int SGEnviro::streak_count_min = DFL_STREAK_COUNT_MIN;
 #endif
 int SGEnviro::streak_count_max = DFL_STREAK_COUNT_MAX;
 #define DFL_CONE_BASE_RADIUS 15.0
-SGfloat SGEnviro::cone_base_radius = DFL_CONE_BASE_RADIUS;
+float SGEnviro::cone_base_radius = DFL_CONE_BASE_RADIUS;
 #define DFL_CONE_HEIGHT 30.0
-SGfloat SGEnviro::cone_height = DFL_CONE_HEIGHT;
+float SGEnviro::cone_height = DFL_CONE_HEIGHT;
 
 
 void SGEnviro::config(const SGPropertyNode* n)
@@ -88,7 +86,7 @@ void SGEnviro::config(const SGPropertyNode* n)
 		return;
 
 	const float ml = n->getFloatValue("min-light", DFL_MIN_LIGHT);
-	sgSetVec3(min_light, ml, ml, ml);
+  min_light = SGVec3f(ml, ml, ml);
 
 	streak_bright_nearmost_layer = n->getFloatValue(
 			"streak-brightness-nearmost-layer",
@@ -146,7 +144,7 @@ public:
 	~SGLightning();
 	void lt_Render(void);
 	void lt_build(void);
-	void lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize);
+	void lt_build_tree_branch(int tree_nr, SGVec3d &start, float energy, int nbseg, float segsize);
 
 	// contains all the segments of the lightning
 	lt_tree_seg lt_tree[MAX_LT_TREE_SEG];
@@ -175,7 +173,7 @@ SGEnviro::SGEnviro() :
 	lightning_enable_state(false),
 	elapsed_time(0.0),
 	dt(0.0),
-	soundMgr(NULL),
+	sampleGroup(NULL),
 	snd_active(false),
 	snd_dist(0.0),
 	min_time_before_lt(0.0),
@@ -189,24 +187,28 @@ SGEnviro::SGEnviro() :
 }
 
 SGEnviro::~SGEnviro(void) {
+  // if (sampleGroup) delete sampleGroup;
+
+  // OSGFIXME
+  return;
 	list_of_lightning::iterator iLightning;
-	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
+	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; ++iLightning ) {
 		delete (*iLightning);
 	}
 	lightnings.clear();
 }
 
-void SGEnviro::startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time) {
+void SGEnviro::startOfFrame( SGVec3f p, SGVec3f up, double lon, double lat, double alt, double delta_time) {
+  // OSGFIXME
+  return;
 	view_in_cloud = false;
 	// ask the impostor cache to do some cleanup
-	if(SGNewCloud::cldCache)
-		SGNewCloud::cldCache->startNewFrame();
 	last_cloud_turbulence = cloud_turbulence;
 	cloud_turbulence = 0.0;
 	elapsed_time += delta_time;
 	min_time_before_lt -= delta_time;
 	dt = delta_time;
-
+#if 0
 	sgMat4 T1, LON, LAT;
     sgVec3 axis;
 
@@ -228,6 +230,7 @@ void SGEnviro::startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double
     sgSetCoord( &pos, TRANSFORM );
 
 	sgMakeCoordMat4( transform, &pos );
+  #endif
     last_lon = lon;
     last_lat = lat;
 	last_alt = alt;
@@ -251,43 +254,10 @@ void SGEnviro::set_view_in_cloud(bool incloud) {
 	view_in_cloud = incloud;
 }
 
-int SGEnviro::get_CacheResolution(void) const {
-	return SGCloudField::get_CacheResolution();
-}
-
-int SGEnviro::get_clouds_CacheSize(void) const {
-	return SGCloudField::get_CacheSize();
-}
-float SGEnviro::get_clouds_visibility(void) const {
-	return SGCloudField::get_CloudVis();
-}
-float SGEnviro::get_clouds_density(void) const {
-	return SGCloudField::get_density();
-}
-bool SGEnviro::get_clouds_enable_state(void) const {
-	return SGCloudField::get_enable3dClouds();
-}
-
 bool SGEnviro::get_turbulence_enable_state(void) const {
 	return turbulence_enable_state;
 }
 
-void SGEnviro::set_CacheResolution(int resolutionPixels) {
-	SGCloudField::set_CacheResolution(resolutionPixels);
-}
-
-void SGEnviro::set_clouds_CacheSize(int sizeKb) {
-	SGCloudField::set_CacheSize(sizeKb);
-}
-void SGEnviro::set_clouds_visibility(float distance) {
-	SGCloudField::set_CloudVis(distance);
-}
-void SGEnviro::set_clouds_density(float density) {
-	SGCloudField::set_density(density);
-}
-void SGEnviro::set_clouds_enable_state(bool enable) {
-	SGCloudField::set_enable3dClouds(enable);
-}
 void SGEnviro::set_turbulence_enable_state(bool enable) {
 	turbulence_enable_state = enable;
 }
@@ -318,13 +288,15 @@ void SGEnviro::set_lightning_enable_state(bool enable) {
 	}
 }
 
-void SGEnviro::setLight(sgVec4 adj_fog_color) {
-	sgCopyVec4( fog_color, adj_fog_color );
+void SGEnviro::setLight(SGVec4f adj_fog_color) {
+  // OSGFIXME
+  return;
+	 fog_color = adj_fog_color;
 	if( false ) {
 	//    ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
 	}
 }
-
+#if 0
 void SGEnviro::callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId) {
 	// send data to wx radar
 	// compute turbulence
@@ -397,6 +369,7 @@ void SGEnviro::callback_cloud(float heading, float alt, float radius, int family
 			LWC = 0.29*2.0;
 			break;
 	}
+
 	// add to the list for the wxRadar instrument
 	if( LWC > 0.0 )
 		radarEcho.push_back( SGWxRadarEcho ( heading, alt, radius, dist, LWC, false, cloudId ) );
@@ -407,7 +380,7 @@ void SGEnviro::callback_cloud(float heading, float alt, float radius, int family
 	if(lightning_enable_state && min_time_before_lt <= 0.0 && (family == SGNewCloud::CLFamilly_cb) &&
 		dist < 15000.0 * 15000.0 && sg_random() > 0.9f) {
 		double lat, lon;
-		Point3D orig, dest;
+		SGVec3d orig, dest;
 		orig.setlat(last_lat * SG_DEGREES_TO_RADIANS );
 		orig.setlon(last_lon * SG_DEGREES_TO_RADIANS );
 		orig.setelev(0.0);
@@ -434,129 +407,30 @@ void SGEnviro::callback_cloud(float heading, float alt, float radius, int family
 		}
 }
 
+#endif
+
 list_of_SGWxRadarEcho *SGEnviro::get_radar_echo(void) {
 	return &radarEcho;
 }
 
 // precipitation rendering code
 void SGEnviro::DrawCone2(float baseRadius, float height, int slices, bool down, double rain_norm, double speed) {
-	sgVec3 light;
-	sgAddVec3( light, fog_color, min_light );
-	float da = SG_PI * 2.0f / (float) slices;
-	// low number = faster
-	float speedf = streak_period_max - speed * streak_period_change_per_kt;
-	if( speedf < streak_period_min )
-		speedf = streak_period_min;
-	float lenf = streak_length_min + speed * streak_length_change_per_kt;
-	if( lenf > streak_length_max )
-		lenf = streak_length_max;
-    float t = fmod((float) elapsed_time, speedf) / speedf;
-//	t = 0.1f;
-	if( !down )
-		t = 1.0f - t;
-	float angle = 0.0f;
-	//glColor4f(1.0f, 0.7f, 0.7f, 0.9f); // XXX unneeded? overriden below
-	glBegin(GL_LINES);
-	if (slices >  MAX_RAIN_SLICE)
-		slices = MAX_RAIN_SLICE; // should never happen
-	for( int i = 0 ; i < slices ; i++ ) {
-		float x = cos(angle) * baseRadius;
-		float y = sin(angle) * baseRadius;
-		angle += da;
-		sgVec3 dir = {x, -height, y};
-
-		// rain drops at 2 different speed to simulate depth
-		float t1 = (i & 1 ? t : t + t) + rainpos[i];
-		if(t1 > 1.0f)	t1 -= 1.0f;
-		if(t1 > 1.0f)	t1 -= 1.0f;
-
-		// distant raindrops are more transparent
-		float c = t1 * (i & 1 ?
-				streak_bright_farmost_layer
-				: streak_bright_nearmost_layer);
-		glColor4f(c * light[0], c * light[1], c * light[2], c);
-		sgVec3 p1, p2;
-		sgScaleVec3(p1, dir, t1);
-		// distant raindrops are shorter
-		float t2 = t1 + (i & 1 ? lenf : lenf+lenf);
-		sgScaleVec3(p2, dir, t2);
-
-		glVertex3f(p1[0], p1[1] + height, p1[2]);
-		glVertex3f(p2[0], p2[1] + height, p2[2]);
-	}
-	glEnd();
+  // OSGFIXME
+  return;
 }
 
 void SGEnviro::drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm) {
-
-#if 0
-	static int debug_period = 0;
-	if (debug_period++ == 50) {
-		debug_period = 0;
-		cout << "drawRain("
-			<< pitch << ", "
-			<< roll  << ", "
-			<< heading << ", "
-			<< hspeed << ", "
-			<< rain_norm << ");"
-			//" angle = " << angle
-			//<< " raindrop(KTS) = " << raindrop_speed_kts
-			<< endl;
-	}
-#endif
-
-
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glDisable(GL_DEPTH_TEST);
-	glShadeModel(GL_SMOOTH);
-	glEnable(GL_BLEND);
-	glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
-	glDisable( GL_FOG );
-	glDisable(GL_LIGHTING);
-
-	int slice_count = static_cast<int>(
-			(streak_count_min + rain_norm*(streak_count_max-streak_count_min))
-				* precipitation_density / 100.0);
-
-	// www.wonderquest.com/falling-raindrops.htm says that
-	// Raindrop terminal velocity is 5 to 20mph
-	// Rather than model it accurately (temp, pressure, diameter), and make it
-	// smaller than terminal when closer to the precipitation cloud base,
-	// we interpolate in the 5-20mph range according to rain_norm.
-	double raindrop_speed_kts
-		= (5.0 + rain_norm*15.0) * SG_MPH_TO_MPS * SG_MPS_TO_KT;
-
-	float angle = atanf(hspeed / raindrop_speed_kts) * SG_RADIANS_TO_DEGREES;
-	glPushMatrix();
-		// the cone rotate with hspeed
-		angle = -pitch - angle;
-		glRotatef(roll, 0.0, 0.0, 1.0);
-		glRotatef(heading, 0.0, 1.0, 0.0);
-		glRotatef(angle, 1.0, 0.0, 0.0);
-
-		// up cone
-		DrawCone2(cone_base_radius, cone_height, 
-				slice_count, true, rain_norm, hspeed);
-		// down cone (usually not visible)
-		if(angle > 0.0 || heading != 0.0)
-			DrawCone2(cone_base_radius, -cone_height, 
-					slice_count, false, rain_norm, hspeed);
-
-	glPopMatrix();
-
-	glEnable(GL_LIGHTING);
-	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
-	glEnable( GL_FOG );
-	glEnable(GL_DEPTH_TEST);
-
+  // OSGFIXME
+  return;
 }
 
-void SGEnviro::set_soundMgr(SGSoundMgr *mgr) {
-	soundMgr = mgr;
+void SGEnviro::set_sampleGroup(SGSampleGroup *sgr) {
+	sampleGroup = sgr;
 }
 
 void SGEnviro::drawPrecipitation(double rain_norm, double snow_norm, double hail_norm, double pitch, double roll, double heading, double hspeed) {
+  // OSGFIXME
+  return;
 	if( precipitation_enable_state && rain_norm > 0.0)
 	  if( precipitation_max_alt >= last_alt )
 		drawRain(pitch, roll, heading, hspeed, rain_norm);
@@ -578,164 +452,25 @@ SGLightning::~SGLightning() {
 }
 
 // lightning rendering code
-void SGLightning::lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize) {
-
-	sgVec3 dir, newdir;
-	int nseg = 0;
-	Point3D pt = start;
-	if( nbseg == 50 )
-		sgSetVec3( dir, 0.0, -1.0, 0.0 );
-	else {
-		sgSetVec3( dir, sg_random() - 0.5f, sg_random() - 0.5f, sg_random() - 0.5f);
-		sgNormaliseVec3(dir);
-	}
-	if( nb_tree >= MAX_LT_TREE_SEG )
-		return;
-
-	lt_tree[nb_tree].depth = tree_nr;
-	nseg = 0;
-	lt_tree[nb_tree].pt = pt;
-	lt_tree[nb_tree].prev = -1;
-	nb_tree ++;
-
-	// TODO:check agl
-	while(nseg < nbseg && pt.y() > 0.0) {
-        int prev = nb_tree - 1;
-        nseg++;
-		// add a branch
-        if( energy * sg_random() > 0.8f )
-			lt_build_tree_branch(tree_nr + 1, pt, energy * 0.9f, nbseg == 50 ? 10 : static_cast<int>(nbseg * 0.4f), segsize * 0.7f);
-
-		if( nb_tree >= MAX_LT_TREE_SEG )
-			return;
-		sgSetVec3(newdir, (sg_random() - 0.5f), (sg_random() - 0.5f) - (nbseg == 50 ? 0.5f : 0.0), (sg_random() - 0.5f));
-		sgNormaliseVec3(newdir);
-		sgAddVec3( dir, newdir);
-		sgNormaliseVec3(dir);
-		sgVec3 scaleDir;
-		sgScaleVec3( scaleDir, dir, segsize * energy * 0.5f );
-		pt[PX] += scaleDir[0];
-		pt[PY] += scaleDir[1];
-		pt[PZ] += scaleDir[2];
-
-		lt_tree[nb_tree].depth = tree_nr;
-		lt_tree[nb_tree].pt = pt;
-		lt_tree[nb_tree].prev = prev;
-		nb_tree ++;
-	}
+void SGLightning::lt_build_tree_branch(int tree_nr, SGVec3d &start, float energy, int nbseg, float segsize) {
+  // OSGFIXME
+  return;
 }
 
 void SGLightning::lt_build(void) {
-    Point3D top;
-    nb_tree = 0;
-    top[PX] = 0 ;
-    top[PY] = alt;
-    top[PZ] = 0;
-    lt_build_tree_branch(0, top, 1.0, 50, top[PY] / 8.0);
-	if( ! sgEnviro.soundMgr )
-		return;
-	Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-	Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
-	double course = 0.0, dist = 0.0;
-	calc_gc_course_dist( dest, start, &course, &dist );
-	if( dist < 10000.0 && ! sgEnviro.snd_playing && (dist < sgEnviro.snd_dist || ! sgEnviro.snd_active) ) {
-		sgEnviro.snd_timer = 0.0;
-		sgEnviro.snd_wait  = dist / 340;
-		sgEnviro.snd_dist  = dist;
-		sgEnviro.snd_pos_lat = lat;
-		sgEnviro.snd_pos_lon = lon;
-		sgEnviro.snd_active = true;
-		sgEnviro.snd_playing = false;
-	}
+  // OSGFIXME
+  return;
 }
 
 
 void SGLightning::lt_Render(void) {
-	float flash = 0.5;
-	if( fmod(sgEnviro.elapsed_time*100.0, 100.0) > 50.0 )
-		flash = sg_random() * 0.75f + 0.25f;
-    float h = lt_tree[0].pt[PY];
-	sgVec4 col={0.62f, 0.83f, 1.0f, 1.0f};
-	sgVec4 c;
-
-#define DRAW_SEG() \
-			{glColorMaterial(GL_FRONT, GL_EMISSION);  \
-			glDisable(GL_LINE_SMOOTH); glBegin(GL_LINES); \
-				glColor4fv(c); \
-                glVertex3f(lt_tree[n].pt[PX], lt_tree[n].pt[PZ], lt_tree[n].pt[PY]); \
-                glVertex3f(lt_tree[lt_tree[n].prev].pt[PX], lt_tree[lt_tree[n].prev].pt[PZ], lt_tree[lt_tree[n].prev].pt[PY]); \
-			glEnd(); glEnable(GL_LINE_SMOOTH);}
-
-	glDepthMask( GL_FALSE );
-	glEnable(GL_BLEND);
-	glBlendFunc( GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glDisable(GL_LIGHTING);
-	glDisable( GL_FOG );
-	glPushMatrix();
-	sgMat4 modelview, tmp;
-    ssgGetModelviewMatrix( modelview );
-	sgCopyMat4( tmp, sgEnviro.transform );
-    sgPostMultMat4( tmp, modelview );
-    ssgLoadModelviewMatrix( tmp );
-
-    Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-    Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
-    double course = 0.0, dist = 0.0;
-    calc_gc_course_dist( dest, start, &course, &dist );
-    double ax = 0.0, ay = 0.0;
-    ax = cos(course) * dist;
-    ay = sin(course) * dist;
-
-	glTranslatef( ax, ay, -sgEnviro.last_alt );
-
-	sgEnviro.radarEcho.push_back( SGWxRadarEcho ( course, 0.0, 0.0, dist, age, true, 0 ) );
-
-	for( int n = 0 ; n < nb_tree ; n++ ) {
-        if( lt_tree[n].prev < 0 )
-			continue;
-
-        float t1 = sgLerp(0.5, 1.0, lt_tree[n].pt[PY] / h);
-		t1 *= flash;
-		if( lt_tree[n].depth >= 2 ) {
-            glLineWidth(3);
-			sgScaleVec4(c, col, t1 * 0.6f);
-			DRAW_SEG();
-		} else {
-			if( lt_tree[n].depth == 0 ) {
-                glLineWidth(12);
-				sgScaleVec4(c, col, t1 * 0.5f);
-				DRAW_SEG();
-
-                glLineWidth(6);
-				sgScaleVec4(c, col, t1);
-				DRAW_SEG();
-			} else {
-                glLineWidth(6);
-				sgScaleVec4(c, col, t1 * 0.7f);
-				DRAW_SEG();
-			}
-
-            if( lt_tree[n].depth == 0 ) 
-                glLineWidth(3);
-			else
-                glLineWidth(2);
-
-            sgSetVec4(c, t1, t1, t1, t1);
-			DRAW_SEG();
-		}
-
-	}
-    glLineWidth(1);
-	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
-	glPopMatrix();
-	glDepthMask( GL_TRUE );	
-	glEnable( GL_FOG );
-	glEnable(GL_LIGHTING);
+  // OSGFIXME
+  return;
 }
 
 void SGEnviro::addLightning(double lon, double lat, double alt) {
+  // OSGFIXME
+  return;
 	if( lightnings.size() > 10)
 		return;
 	SGLightning *lt= new SGLightning(lon, lat, alt);
@@ -743,52 +478,8 @@ void SGEnviro::addLightning(double lon, double lat, double alt) {
 }
 
 void SGEnviro::drawLightning(void) {
-	list_of_lightning::iterator iLightning;
-	// play 'thunder' for lightning
-	if( snd_active )
-		if( !snd_playing ) {
-			// wait until sound has reached us
-			snd_timer += dt;
-			if( snd_timer >= snd_wait ) {
-				snd_playing = true;
-				// compute relative position of lightning
-				Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-				Point3D dest( snd_pos_lon*SG_DEGREES_TO_RADIANS, snd_pos_lat*SG_DEGREES_TO_RADIANS, 0.0 );
-				double course = 0.0, dist = 0.0;
-				calc_gc_course_dist( dest, start, &course, &dist );
-				double ax = 0.0, ay = 0.0;
-				ax = cos(course) * dist;
-				ay = sin(course) * dist;
-				SGSharedPtr<SGSoundSample> snd = soundMgr->find("thunder");
-				if( snd ) {
-					ALfloat pos[3]={ax, ay, -sgEnviro.last_alt };
-					snd->set_source_pos(pos);
-					snd->play_once();
-				}
-			}
-		} else {
-			if( !soundMgr->is_playing("thunder") ) {
-				snd_active = false;
-				snd_playing = false;
-			}
-		}
-
-	if( ! lightning_enable_state )
-		return;
-
-	for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
-		if( dt )
-			if( sg_random() > 0.95f )
-				(*iLightning)->lt_build();
-		(*iLightning)->lt_Render();
-		(*iLightning)->age -= dt;
-		if( (*iLightning)->age < 0.0 ) {
-			delete (*iLightning);
-			lightnings.erase( iLightning );
-			break;
-		}
-	}
-
+  // OSGFIXME
+  return;
 }
 
 

simgear/environment/visual_enviro.hxx

@@ -22,17 +22,14 @@
 #ifndef _VISUAL_ENVIRO_HXX
 #define _VISUAL_ENVIRO_HXX
 
-#include <plib/sg.h>
-
 #include <simgear/compiler.h>
-#include STL_STRING
+#include <string>
 #include <vector>
 
-SG_USING_STD(vector);
-SG_USING_STD(string);
+#include <simgear/math/SGMath.hxx>
 
 class SGLightning;
-class SGSoundMgr;
+class SGSampleGroup;
 
 /**
  * Simulate some echo on a weather radar.
@@ -40,7 +37,8 @@ class SGSoundMgr;
  */
 class SGWxRadarEcho {
 public:
-	SGWxRadarEcho(float _heading, float _alt, float _radius, float _dist, double _LWC, bool _lightning, int _cloudId) :
+	SGWxRadarEcho(float _heading, float _alt, float _radius, float _dist,
+			double _LWC, bool _lightning, int _cloudId ) :
 	  heading( _heading ),
 	  alt ( _alt ),
 	  radius ( _radius ),
@@ -56,12 +54,12 @@ public:
 	/** reflectivity converted to liquid water content. */
 	double LWC;
 	/** if true then this data is for a lightning else it is for water echo. */
-	bool   lightning;
+	bool lightning;
 	/** Unique identifier of cloud */
 	int cloudId;
 };
 
-typedef vector<SGWxRadarEcho> list_of_SGWxRadarEcho;
+typedef std::vector<SGWxRadarEcho> list_of_SGWxRadarEcho;
 
 /**
  * Visual environment helper class.
@@ -80,10 +78,10 @@ private:
 	double last_cloud_turbulence, cloud_turbulence;
 	bool lightning_enable_state;
 	double elapsed_time, dt;
-	sgVec4	fog_color;
-	sgMat4 transform;
+	SGVec4f	fog_color;
+	SGMatrixf transform;
 	double last_lon, last_lat, last_alt;
-	SGSoundMgr	*soundMgr;
+	SGSampleGroup	*sampleGroup;
 	bool		snd_active, snd_playing;
 	double		snd_timer, snd_wait, snd_pos_lat, snd_pos_lon, snd_dist;
 	double		min_time_before_lt;
@@ -92,8 +90,8 @@ private:
 
 	/** a list of all the radar echo. */
 	list_of_SGWxRadarEcho radarEcho;
-	static sgVec3 min_light;
-	static SGfloat streak_bright_nearmost_layer,
+	static SGVec3f min_light;
+	static float streak_bright_nearmost_layer,
 				   streak_bright_farmost_layer,
 				   streak_period_max,
 				   streak_period_change_per_kt,
@@ -102,7 +100,7 @@ private:
 				   streak_length_change_per_kt,
 				   streak_length_max;
 	static int streak_count_min, streak_count_max;
-	static SGfloat cone_base_radius,
+	static float cone_base_radius,
 				   cone_height;
 
 public:
@@ -120,10 +118,11 @@ public:
     /**
      * Forward a few states used for renderings.
      */
-	void startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time);
+	void startOfFrame( SGVec3f p, SGVec3f up, double lon, double lat, double alt, double delta_time);
 
 	void endOfFrame(void);
 
+#if 0
     /**
      * Whenever a cloud is drawn we check his 'impact' on the environment.
      * @param heading direction of cloud in radians
@@ -133,7 +132,7 @@ public:
      * @param dist  squared dist to cloud in meters
      */
 	void callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId);
-
+#endif
 	void drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm);
     /**
      * Draw rain or snow precipitation around the viewer.
@@ -156,7 +155,7 @@ public:
      * Forward the fog color used by the rain rendering.
      * @param adj_fog_color color of the fog
      */
-	void setLight(sgVec4 adj_fog_color);
+	void setLight(SGVec4f adj_fog_color);
 
 	// this can be queried to add some turbulence for example
 	bool is_view_in_cloud(void) const;
@@ -241,14 +240,14 @@ public:
      * Forward the sound manager instance to be able to play samples.
      * @param mgr a running sound manager
      */
-	void set_soundMgr(SGSoundMgr *mgr);
+	void set_sampleGroup(SGSampleGroup *sgr);
 
 	void setFOV( float w, float h );
 	void getFOV( float &w, float &h );
 
 	list_of_SGWxRadarEcho *get_radar_echo(void);
 
-	sgMat4 *get_transform(void) { return &transform; }
+	SGMatrixf *get_transform(void) { return &transform; }
 };
 
 extern SGEnviro sgEnviro;

simgear/ephemeris/.cvsignore

@@ -1,3 +0,0 @@
-.deps
-Makefile
-Makefile.in

simgear/ephemeris/CMakeLists.txt

@@ -0,0 +1,35 @@
+
+include (SimGearComponent)
+
+set(HEADERS 
+    celestialBody.hxx
+    ephemeris.hxx
+    jupiter.hxx
+    mars.hxx
+    mercury.hxx
+    moonpos.hxx
+    neptune.hxx
+    pluto.hxx
+    saturn.hxx
+    star.hxx
+    stardata.hxx
+    uranus.hxx
+    venus.hxx
+    )
+    
+set(SOURCES 
+    celestialBody.cxx
+    ephemeris.cxx
+    jupiter.cxx
+    mars.cxx
+    mercury.cxx
+    moonpos.cxx
+    neptune.cxx
+    saturn.cxx
+    star.cxx
+    stardata.cxx
+    uranus.cxx
+    venus.cxx
+    )
+
+simgear_component(ephem ephemeris "${SOURCES}" "${HEADERS}")

simgear/ephemeris/celestialBody.cxx

@@ -24,9 +24,6 @@
 
 #include <simgear/debug/logstream.hxx>
 
-#ifdef SG_MATH_EXCEPTION_CLASH
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "celestialBody.hxx"

simgear/ephemeris/celestialBody.hxx

@@ -81,8 +81,8 @@ public:
   double getRightAscension();
   double getDeclination();
   double getMagnitude();
-  double getLon();
-  double getLat(); 
+  double getLon() const;
+  double getLat() const; 
   void updatePosition(double mjd, Star *ourSun);
 };
 
@@ -90,12 +90,12 @@ inline double CelestialBody::getRightAscension() { return rightAscension; }
 inline double CelestialBody::getDeclination() { return declination; }
 inline double CelestialBody::getMagnitude() { return magnitude; }
 
-inline double CelestialBody::getLon()
+inline double CelestialBody::getLon() const
 {
   return lonEcl;
 }
 
-inline double CelestialBody::getLat()
+inline double CelestialBody::getLat() const
 {
   return latEcl;
 }

simgear/ephemeris/ephemeris.cxx

@@ -31,7 +31,7 @@
 
 
 // Constructor
-SGEphemeris::SGEphemeris( const string &path ) {
+SGEphemeris::SGEphemeris( const std::string &path ) {
     our_sun = new Star;
     moon = new MoonPos;
     mercury = new Mercury;
@@ -42,9 +42,8 @@ SGEphemeris::SGEphemeris( const string &path ) {
     uranus = new Uranus;
     neptune = new Neptune;
     nplanets = 7;
-    for ( int i = 0; i < nplanets; ++i ) {
-        sgdSetVec3( planets[i], 0.0, 0.0, 0.0 );
-    }
+    for ( int i = 0; i < nplanets; ++i )
+      planets[i] = SGVec3d::zeros();
     stars = new SGStarData( SGPath(path) );
 }
 

simgear/ephemeris/ephemeris.hxx

@@ -29,8 +29,7 @@
 #ifndef _EPHEMERIS_HXX
 #define _EPHEMERIS_HXX
 
-
-#include <plib/sg.h>
+#include <string>
 
 #include <simgear/ephemeris/star.hxx>
 #include <simgear/ephemeris/moonpos.hxx>
@@ -43,6 +42,9 @@
 #include <simgear/ephemeris/neptune.hxx>
 #include <simgear/ephemeris/stardata.hxx>
 
+#include <simgear/math/SGMath.hxx>
+#include <simgear/misc/sg_path.hxx>
+
 
 /** Ephemeris class
  *
@@ -83,7 +85,7 @@ class SGEphemeris {
     // planets[i][1] = Declination
     // planets[i][2] = Magnitude
     int nplanets;
-    sgdVec3 planets[7];
+    SGVec3d planets[7];
 
     SGStarData *stars;
 
@@ -95,7 +97,7 @@ public:
      * calling the constructor you need to provide a path pointing to
      * your star database file.
      * @param path path to your star database */
-    SGEphemeris( const string &path );
+    SGEphemeris( const std::string &path );
 
     /** Destructor */
     ~SGEphemeris( void );
@@ -155,7 +157,8 @@ public:
      * the second is the declination, and the third is the magnitude.
      * @return planets array
      */
-    inline sgdVec3 *getPlanets() { return planets; }
+    inline SGVec3d *getPlanets() { return planets; }
+    inline const SGVec3d *getPlanets() const { return planets; }
 
     /** @return the numbers of defined stars. */
     inline int getNumStars() const { return stars->getNumStars(); }
@@ -167,7 +170,8 @@ public:
      * third is the magnitude.
      * @returns star array
      */
-    inline sgdVec3 *getStars() { return stars->getStars(); }
+    inline SGVec3d *getStars() { return stars->getStars(); }
+    inline const SGVec3d *getStars() const { return stars->getStars(); }
 };
 
 

simgear/ephemeris/jupiter.cxx

@@ -22,10 +22,6 @@
  * $Id$
  **************************************************************************/
 
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "jupiter.hxx"

simgear/ephemeris/mars.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "mars.hxx"

simgear/ephemeris/mercury.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "mercury.hxx"

simgear/ephemeris/moonpos.cxx

@@ -27,9 +27,6 @@
 
 #include <simgear/debug/logstream.hxx>
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 // #include <FDM/flight.hxx>

simgear/ephemeris/saturn.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "saturn.hxx"

simgear/ephemeris/star.cxx

@@ -22,10 +22,6 @@
  * $Id$
  **************************************************************************/
 
-
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include <simgear/debug/logstream.hxx>

simgear/ephemeris/star.hxx

@@ -43,47 +43,47 @@ public:
     Star ();
     ~Star();
     void updatePosition(double mjd);
-    double getM();
-    double getw();
-    double getxs();
-    double getys();
-    double getye();
-    double getze();
-    double getDistance();
+    double getM() const;
+    double getw() const;
+    double getxs() const;
+    double getys() const;
+    double getye() const;
+    double getze() const;
+    double getDistance() const;
 };
 
 
-inline double Star::getM()
+inline double Star::getM() const
 {
   return M;
 }
 
-inline double Star::getw()
+inline double Star::getw() const
 {
   return w;
 }
 
-inline double Star::getxs()
+inline double Star::getxs() const
 {
   return xs;
 }
 
-inline double Star::getys()
+inline double Star::getys() const
 {
   return ys;
 }
 
-inline double Star::getye()
+inline double Star::getye() const
 {
    return ye;
 }
 
-inline double Star::getze()
+inline double Star::getze() const
 {
    return ze;
 }
 
-inline double Star::getDistance()
+inline double Star::getDistance() const
 {
   return distance;
 }

simgear/ephemeris/stardata.cxx

@@ -25,25 +25,21 @@
 #endif
 
 #include <simgear/debug/logstream.hxx>
+#include <simgear/misc/sg_path.hxx>
 #include <simgear/misc/sgstream.hxx>
 
 #include "stardata.hxx"
 
 #if defined (_MSC_VER)
-  SG_USING_STD(getline);
+  using std::getline;
 #endif
 
-// Constructor
-SGStarData::SGStarData() :
-    nstars(0)
-{
-}
+using std::string;
 
-SGStarData::SGStarData( SGPath path ) :
-    nstars(0)
+// Constructor
+SGStarData::SGStarData( const SGPath& path )
 {
-    data_path = SGPath( path );
-    load();
+    load(path);
 }
 
 
@@ -52,31 +48,28 @@ SGStarData::~SGStarData() {
 }
 
 
-bool SGStarData::load() {
+bool SGStarData::load( const SGPath& path ) {
 
-    // -dw- avoid local data > 32k error by dynamic allocation of the
-    // array, problem for some compilers
-    stars = new sgdVec3[SG_MAX_STARS];
+    _stars.clear();
 
-     // build the full path name to the stars data base file
-    data_path.append( "stars" );
-    SG_LOG( SG_ASTRO, SG_INFO, "  Loading stars from " << data_path.str() );
+    // build the full path name to the stars data base file
+    SGPath tmp = path;
+    tmp.append( "stars" );
+    SG_LOG( SG_ASTRO, SG_INFO, "  Loading stars from " << tmp.str() );
 
-    sg_gzifstream in( data_path.str() );
+    sg_gzifstream in( tmp.str() );
     if ( ! in.is_open() ) {
 	SG_LOG( SG_ASTRO, SG_ALERT, "Cannot open star file: "
-		<< data_path.str() );
-	exit(-1);
+		<< tmp.str() );
+        return false;
     }
 
     double ra, dec, mag;
     char c;
     string name;
 
-    nstars = 0;
-
     // read in each line of the file
-    while ( ! in.eof() && nstars < SG_MAX_STARS ) {
+    while ( ! in.eof() ) {
 	in >> skipcomment;
 
         getline( in, name, ',' );
@@ -116,13 +109,10 @@ bool SGStarData::load() {
 	in >> mag;
 
 	// cout << " star data = " << ra << " " << dec << " " << mag << endl;
-
-	sgdSetVec3( stars[nstars], ra, dec, mag );
-
-	++nstars;
+        _stars.push_back(SGVec3d(ra, dec, mag));
     }
 
-    SG_LOG( SG_ASTRO, SG_INFO, "  Loaded " << nstars << " stars" );
+    SG_LOG( SG_ASTRO, SG_INFO, "  Loaded " << _stars.size() << " stars" );
 
     return true;
 }

simgear/ephemeris/stardata.hxx

@@ -24,37 +24,28 @@
 #ifndef _SG_STARDATA_HXX
 #define _SG_STARDATA_HXX
 
+#include <vector>
+#include <simgear/math/SGMath.hxx>
 
-#include <plib/sg.h>
-
-#include <simgear/misc/sg_path.hxx>
-
-
-#define SG_MAX_STARS 850
-
+class SGPath;
 
 class SGStarData {
-
-    int nstars;
-    sgdVec3 *stars;
-    
-    SGPath data_path;
-
 public:
-
     // Constructor
-    SGStarData();
-    SGStarData( SGPath path );
+    SGStarData( const SGPath& path );
 
     // Destructor
     ~SGStarData();
 
     // load the stars database
-    bool load();
+    bool load( const SGPath& path );
 
     // stars
-    inline int getNumStars() const { return nstars; }
-    inline sgdVec3 *getStars() { return stars; }
+    inline int getNumStars() const { return _stars.size(); }
+    inline SGVec3d *getStars() { return &(_stars[0]); }
+
+private:
+    std::vector<SGVec3d> _stars;
 };
 
 

simgear/ephemeris/uranus.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "uranus.hxx"

simgear/ephemeris/venus.cxx

@@ -22,9 +22,6 @@
  * $Id$
  **************************************************************************/
 
-#ifdef __BORLANDC__
-#  define exception c_exception
-#endif
 #include <math.h>
 
 #include "venus.hxx"

simgear/hla/CMakeLists.txt

@@ -0,0 +1,65 @@
+include (SimGearComponent)
+
+set(HLA_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
+    )
+
+set(HLA_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
+    )
+simgear_component(hla hla "${HLA_SOURCES}" "${HLA_HEADERS}")
+
+if(RTI_FOUND)
+  set(HLA13_HEADERS
+    HLA13Federate.hxx
+    )
+  set(HLA13_SOURCES
+    RTI13ObjectClass.cxx
+    RTI13ObjectInstance.cxx
+    RTI13Federate.cxx
+    HLA13Federate.cxx
+    )
+  simgear_component(hla13 hla "${HLA13_SOURCES}" "${HLA13_HEADERS}")
+  set_property(TARGET sghla13 APPEND PROPERTY COMPILE_FLAGS "-I${RTI_INCLUDE_DIR}")
+endif()

simgear/hla/HLA13Federate.cxx

@@ -0,0 +1,33 @@
+// 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 "HLA13Federate.hxx"
+
+#include "RTI13Federate.hxx"
+
+namespace simgear {
+
+HLA13Federate::HLA13Federate() :
+    HLAFederate(new RTI13Federate)
+{
+}
+
+HLA13Federate::~HLA13Federate()
+{
+}
+
+} // namespace simgear

simgear/hla/HLA13Federate.hxx

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

simgear/hla/HLAArrayDataElement.cxx

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

simgear/hla/HLAArrayDataElement.hxx

@@ -0,0 +1,418 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAArrayDataElement_hxx
+#define HLAArrayDataElement_hxx
+
+#include <string>
+#include <vector>
+#include <simgear/math/SGMath.hxx>
+#include "HLAArrayDataType.hxx"
+#include "HLADataElement.hxx"
+#include "HLAVariantDataElement.hxx"
+#include "HLADataTypeVisitor.hxx"
+
+namespace simgear {
+
+class HLAAbstractArrayDataElement : public HLADataElement {
+public:
+    HLAAbstractArrayDataElement(const HLAArrayDataType* dataType);
+    virtual ~HLAAbstractArrayDataElement();
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAArrayDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+
+    const HLADataType* getElementDataType() const;
+
+    virtual bool setNumElements(unsigned count) = 0;
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i) = 0;
+
+    virtual unsigned getNumElements() const = 0;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const = 0;
+
+protected:
+    SGSharedPtr<const HLAArrayDataType> _dataType;
+};
+
+class HLAArrayDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAArrayDataElement(const HLAArrayDataType* dataType = 0);
+    virtual ~HLAArrayDataElement();
+
+    virtual bool setNumElements(unsigned size);
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i);
+    virtual unsigned getNumElements() const;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
+
+    const HLADataElement* getElement(unsigned index) const;
+    HLADataElement* getElement(unsigned index);
+    HLADataElement* getOrCreateElement(unsigned index);
+    void setElement(unsigned i, HLADataElement* value);
+
+    class DataElementFactory : public SGReferenced {
+    public:
+        virtual ~DataElementFactory();
+        virtual HLADataElement* createElement(const HLAArrayDataElement&, unsigned) = 0;
+    };
+
+    void setDataElementFactory(DataElementFactory* dataElementFactory);
+    DataElementFactory* getDataElementFactory();
+
+private:
+    HLADataElement* newElement(unsigned index);
+
+    typedef std::vector<SGSharedPtr<HLADataElement> > ElementVector;
+    ElementVector _elementVector;
+
+    SGSharedPtr<DataElementFactory> _dataElementFactory;
+};
+
+// Holds an array of variants.
+// Factors out common code for that use case.
+class HLAVariantArrayDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVariantArrayDataElement();
+    virtual ~HLAVariantArrayDataElement();
+
+    // Overwrite this from the abstract class, need some more checks here
+    virtual bool setDataType(const HLADataType* dataType);
+
+    virtual bool setNumElements(unsigned size);
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i);
+    virtual unsigned getNumElements() const;
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const;
+
+    const HLAVariantDataElement* getElement(unsigned index) const;
+    HLAVariantDataElement* getElement(unsigned index);
+    HLAVariantDataElement* getOrCreateElement(unsigned index);
+    void setElement(unsigned index, HLAVariantDataElement* value);
+
+    typedef HLAVariantDataElement::DataElementFactory AlternativeDataElementFactory;
+
+    void setAlternativeDataElementFactory(AlternativeDataElementFactory* alternativeDataElementFactory);
+    AlternativeDataElementFactory* getAlternativeDataElementFactory();
+
+private:
+    HLAVariantDataElement* newElement();
+
+    typedef std::vector<SGSharedPtr<HLAVariantDataElement> > ElementVector;
+    ElementVector _elementVector;
+
+    SGSharedPtr<AlternativeDataElementFactory> _alternativeDataElementFactory;
+};
+
+class HLAStringDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAStringDataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType)
+    {}
+    HLAStringDataElement(const HLAArrayDataType* dataType, const std::string& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const std::string& getValue() const
+    { return _value; }
+    void setValue(const std::string& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        _value.resize(count);
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        HLATemplateDecodeVisitor<std::string::value_type> visitor(stream);
+        getElementDataType()->accept(visitor);
+        _value[i] = visitor.getValue();
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return _value.size();
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        HLATemplateEncodeVisitor<std::string::value_type> visitor(stream, _value[i]);
+        getElementDataType()->accept(visitor);
+        return true;
+    }
+
+private:
+    std::string _value;
+};
+
+class HLAStringData {
+public:
+    HLAStringData() :
+        _value(new HLAStringDataElement(0))
+    { }
+    HLAStringData(const std::string& value) :
+        _value(new HLAStringDataElement(0))
+    { _value->setValue(value); }
+
+    operator const std::string&() const
+    { return _value->getValue(); }
+    HLAStringData& operator=(const std::string& value)
+    { _value->setValue(value); return *this; }
+
+    const std::string& getValue() const
+    { return _value->getValue(); }
+    void setValue(const std::string& value)
+    { _value->setValue(value); }
+
+    const HLAStringDataElement* getDataElement() const
+    { return _value.get(); }
+    HLAStringDataElement* getDataElement()
+    { return _value.get(); }
+
+    const HLAArrayDataType* getDataType() const
+    { return _value->getDataType(); }
+    void setDataType(const HLAArrayDataType* dataType)
+    { _value->setDataType(dataType); }
+
+private:
+    SGSharedPtr<HLAStringDataElement> _value;
+};
+
+template<typename T>
+class HLAVec2DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec2DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec2<T>::zeros())
+    {}
+    HLAVec2DataElement(const HLAArrayDataType* dataType, const SGVec2<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec2<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec2<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 2; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 2) {
+            HLATemplateDecodeVisitor<typename SGVec2<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 2;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 2) {
+            HLATemplateEncodeVisitor<typename SGVec2<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec2<T> _value;
+};
+
+template<typename T>
+class HLAVec3DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec3DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec3<T>::zeros())
+    {}
+    HLAVec3DataElement(const HLAArrayDataType* dataType, const SGVec3<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec3<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec3<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 3; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 3) {
+            HLATemplateDecodeVisitor<typename SGVec3<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 3;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 3) {
+            HLATemplateEncodeVisitor<typename SGVec3<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec3<T> _value;
+};
+
+template<typename T>
+class HLAVec4DataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAVec4DataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGVec4<T>::zeros())
+    {}
+    HLAVec4DataElement(const HLAArrayDataType* dataType, const SGVec4<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGVec4<T>& getValue() const
+    { return _value; }
+    void setValue(const SGVec4<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 4; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 4) {
+            HLATemplateDecodeVisitor<typename SGVec4<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 4;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 4) {
+            HLATemplateEncodeVisitor<typename SGVec4<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGVec4<T> _value;
+};
+
+template<typename T>
+class HLAQuatDataElement : public HLAAbstractArrayDataElement {
+public:
+    HLAQuatDataElement(const HLAArrayDataType* dataType = 0) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(SGQuat<T>::zeros())
+    {}
+    HLAQuatDataElement(const HLAArrayDataType* dataType, const SGQuat<T>& value) :
+        HLAAbstractArrayDataElement(dataType),
+        _value(value)
+    {}
+    const SGQuat<T>& getValue() const
+    { return _value; }
+    void setValue(const SGQuat<T>& value)
+    { _value = value; }
+
+    virtual bool setNumElements(unsigned count)
+    {
+        for (unsigned i = 4; i < count; ++i)
+            _value[i] = 0;
+        return true;
+    }
+    virtual bool decodeElement(HLADecodeStream& stream, unsigned i)
+    {
+        if (i < 4) {
+            HLATemplateDecodeVisitor<typename SGQuat<T>::value_type> visitor(stream);
+            getElementDataType()->accept(visitor);
+            _value[i] = visitor.getValue();
+        } else {
+            HLADataTypeDecodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+    virtual unsigned getNumElements() const
+    {
+        return 4;
+    }
+    virtual bool encodeElement(HLAEncodeStream& stream, unsigned i) const
+    {
+        if (i < 4) {
+            HLATemplateEncodeVisitor<typename SGQuat<T>::value_type> visitor(stream, _value[i]);
+            getElementDataType()->accept(visitor);
+        } else {
+            HLADataTypeEncodeVisitor visitor(stream);
+            getElementDataType()->accept(visitor);
+        }
+        return true;
+    }
+
+private:
+    SGQuat<T> _value;
+};
+
+}
+
+#endif

simgear/hla/HLAArrayDataType.cxx

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

simgear/hla/HLAArrayDataType.hxx

@@ -0,0 +1,88 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAArrayDataType_hxx
+#define HLAArrayDataType_hxx
+
+#include <string>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractArrayDataElement;
+
+class HLAArrayDataType : public HLADataType {
+public:
+    HLAArrayDataType(const std::string& name = "HLAArrayDataType");
+    virtual ~HLAArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLAArrayDataType* toArrayDataType() const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const = 0;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const = 0;
+
+    void setElementDataType(const HLADataType* elementDataType);
+    const HLADataType* getElementDataType() const
+    { return _elementDataType.get(); }
+
+private:
+    SGSharedPtr<const HLADataType> _elementDataType;
+};
+
+class HLAFixedArrayDataType : public HLAArrayDataType {
+public:
+    HLAFixedArrayDataType(const std::string& name = "HLAFixedArrayDataType");
+    virtual ~HLAFixedArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
+
+    void setNumElements(unsigned numElements)
+    { _numElements = numElements; }
+    unsigned getNumElements() const
+    { return _numElements; }
+
+private:
+    unsigned _numElements;
+};
+
+class HLAVariableArrayDataType : public HLAArrayDataType {
+public:
+    HLAVariableArrayDataType(const std::string& name = "HLAVariableArrayDataType");
+    virtual ~HLAVariableArrayDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractArrayDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractArrayDataElement& value) const;
+
+    void setSizeDataType(const HLADataType* sizeDataType);
+    const HLADataType* getSizeDataType() const
+    { return _sizeDataType.get(); }
+
+private:
+    SGSharedPtr<const HLADataType> _sizeDataType;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLABasicDataElement.cxx

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

simgear/hla/HLABasicDataElement.hxx

@@ -0,0 +1,108 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLABasicDataElement_hxx
+#define HLABasicDataElement_hxx
+
+#include "HLABasicDataType.hxx"
+#include "HLADataElement.hxx"
+
+namespace simgear {
+
+class HLABasicDataElement : public HLADataElement {
+public:
+    HLABasicDataElement(const HLABasicDataType* dataType);
+    virtual ~HLABasicDataElement();
+
+    virtual const HLABasicDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLABasicDataType* dataType);
+
+protected:
+    SGSharedPtr<const HLABasicDataType> _dataType;
+};
+
+#define TYPED_HLA_BASIC_DATA_ELEMENT(type, ctype)                             \
+class HLAAbstract##type##DataElement : public HLABasicDataElement {           \
+public:                                                                       \
+    HLAAbstract##type##DataElement(const HLABasicDataType* dataType = 0);     \
+    virtual ~HLAAbstract##type##DataElement();                                \
+    virtual bool encode(HLAEncodeStream& stream) const;                       \
+    virtual bool decode(HLADecodeStream& stream);                             \
+                                                                              \
+    virtual ctype getValue() const = 0;                                       \
+    virtual void setValue(ctype) = 0;                                         \
+};                                                                            \
+class HLA##type##DataElement : public HLAAbstract##type##DataElement {        \
+public:                                                                       \
+    HLA##type##DataElement(const HLABasicDataType* dataType = 0);             \
+    HLA##type##DataElement(const HLABasicDataType* dataType,                  \
+                           const ctype& value);                               \
+    virtual ~HLA##type##DataElement();                                        \
+    virtual ctype getValue() const;                                           \
+    virtual void setValue(ctype value);                                       \
+private:                                                                      \
+    ctype _value;                                                             \
+};                                                                            \
+class HLA##type##Data {                                                       \
+public:                                                                       \
+    HLA##type##Data() :                                                       \
+        _value(new HLA##type##DataElement(0))                                 \
+    { }                                                                       \
+    HLA##type##Data(const ctype& value) :                                     \
+        _value(new HLA##type##DataElement(0, value))                          \
+    { }                                                                       \
+    operator ctype() const                                                    \
+    { return _value->getValue(); }                                            \
+    HLA##type##Data& operator=(const ctype& value)                            \
+    { _value->setValue(value); return *this; }                                \
+    ctype getValue() const                                                    \
+    { return _value->getValue(); }                                            \
+    void setValue(const ctype& value)                                         \
+    { _value->setValue(value); }                                              \
+    const HLA##type##DataElement* getDataElement() const                      \
+    { return _value.get(); }                                                  \
+    HLA##type##DataElement* getDataElement()                                  \
+    { return _value.get(); }                                                  \
+    const HLABasicDataType* getDataType() const                               \
+    { return _value->getDataType(); }                                         \
+    void setDataType(const HLABasicDataType* dataType)                        \
+    { _value->setDataType(dataType); }                                        \
+                                                                              \
+private:                                                                      \
+    SGSharedPtr<HLA##type##DataElement> _value;                               \
+};
+
+
+TYPED_HLA_BASIC_DATA_ELEMENT(Char, char);
+TYPED_HLA_BASIC_DATA_ELEMENT(WChar, wchar_t);
+TYPED_HLA_BASIC_DATA_ELEMENT(SChar, signed char);
+TYPED_HLA_BASIC_DATA_ELEMENT(UChar, unsigned char);
+TYPED_HLA_BASIC_DATA_ELEMENT(Short, short);
+TYPED_HLA_BASIC_DATA_ELEMENT(UShort, unsigned short);
+TYPED_HLA_BASIC_DATA_ELEMENT(Int, int);
+TYPED_HLA_BASIC_DATA_ELEMENT(UInt, unsigned int);
+TYPED_HLA_BASIC_DATA_ELEMENT(Long, long);
+TYPED_HLA_BASIC_DATA_ELEMENT(ULong, unsigned long);
+TYPED_HLA_BASIC_DATA_ELEMENT(Float, float);
+TYPED_HLA_BASIC_DATA_ELEMENT(Double, double);
+
+#undef TYPED_HLA_BASIC_DATA_ELEMENT
+
+}
+
+#endif

simgear/hla/HLABasicDataType.cxx

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

simgear/hla/HLABasicDataType.hxx

@@ -0,0 +1,155 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLABasicDataType_hxx
+#define HLABasicDataType_hxx
+
+#include <string>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLABasicDataType : public HLADataType {
+public:
+    virtual ~HLABasicDataType();
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLABasicDataType* toBasicDataType() const;
+
+protected:
+    HLABasicDataType(const std::string& name);
+};
+
+class HLAInt8DataType : public HLABasicDataType {
+public:
+    HLAInt8DataType(const std::string& name = "HLAInt8DataType");
+    virtual ~HLAInt8DataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    bool skip(HLADecodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool skip(HLAEncodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool decode(HLADecodeStream& stream, int8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.decodeInt8(value);
+    }
+    bool encode(HLAEncodeStream& stream, const int8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.encodeInt8(value);
+    }
+};
+
+class HLAUInt8DataType : public HLABasicDataType {
+public:
+    HLAUInt8DataType(const std::string& name = "HLAUInt8DataType");
+    virtual ~HLAUInt8DataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    bool skip(HLADecodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool skip(HLAEncodeStream& stream) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.skip(1);
+    }
+    bool decode(HLADecodeStream& stream, uint8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.decodeUInt8(value);
+    }
+    bool encode(HLAEncodeStream& stream, const uint8_t& value) const
+    {
+        if (!stream.alignOffsetForSize(getAlignment()))
+            return false;
+        return stream.encodeUInt8(value);
+    }
+};
+
+#define BASIC_DATATYPE_IMPLEMENTATION(type, name)                          \
+class HLA##name##DataType : public HLABasicDataType {                      \
+public:                                                                    \
+ virtual ~HLA##name##DataType();                                           \
+                                                                           \
+ virtual void accept(HLADataTypeVisitor& visitor) const;                   \
+                                                                           \
+ bool skip(HLADecodeStream& stream) const                                  \
+ {                                                                         \
+   if (!stream.alignOffsetForSize(getAlignment()))                         \
+     return false;                                                         \
+   return stream.skip(sizeof(type));                                       \
+ }                                                                         \
+ bool skip(HLAEncodeStream& stream) const                                  \
+ {                                                                         \
+   if (!stream.alignOffsetForSize(getAlignment()))                         \
+     return false;                                                         \
+   return stream.skip(sizeof(type));                                       \
+ }                                                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const = 0;      \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const = 0;\
+protected:                                                                 \
+ HLA##name##DataType(const std::string& name);                             \
+};                                                                         \
+class HLA##name##LEDataType : public HLA##name##DataType {                 \
+public:                                                                    \
+ HLA##name##LEDataType(const std::string& name = "HLA" #name "LEDataType");\
+ virtual ~HLA##name##LEDataType();                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const;          \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const;    \
+};                                                                         \
+class HLA##name##BEDataType : public HLA##name##DataType {                 \
+public:                                                                    \
+ HLA##name##BEDataType(const std::string& name = "HLA" #name "BEDataType");\
+ virtual ~HLA##name##BEDataType();                                         \
+ virtual bool decode(HLADecodeStream& stream, type& value) const;          \
+ virtual bool encode(HLAEncodeStream& stream, const type& value) const;    \
+};
+
+BASIC_DATATYPE_IMPLEMENTATION(int16_t, Int16)
+BASIC_DATATYPE_IMPLEMENTATION(uint16_t, UInt16)
+BASIC_DATATYPE_IMPLEMENTATION(int32_t, Int32)
+BASIC_DATATYPE_IMPLEMENTATION(uint32_t, UInt32)
+BASIC_DATATYPE_IMPLEMENTATION(int64_t, Int64)
+BASIC_DATATYPE_IMPLEMENTATION(uint64_t, UInt64)
+BASIC_DATATYPE_IMPLEMENTATION(float, Float32)
+BASIC_DATATYPE_IMPLEMENTATION(double, Float64)
+
+#undef BASIC_DATATYPE_IMPLEMENTATION
+
+} // namespace simgear
+
+#endif

simgear/hla/HLADataElement.cxx

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

simgear/hla/HLADataElement.hxx

@@ -0,0 +1,217 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLADataElement_hxx
+#define HLADataElement_hxx
+
+#include <list>
+#include <map>
+#include <simgear/structure/SGReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/timing/timestamp.hxx>
+#include "RTIData.hxx"
+#include "HLADataType.hxx"
+
+class SGTimeStamp;
+
+namespace simgear {
+
+class HLADataElement : public SGReferenced {
+public:
+    virtual ~HLADataElement();
+
+    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
+    // class TimeStamp : public SGReferenced {
+    // public:
+    //     const SGTimeStamp& getTimeStamp() const
+    //     { return _timeStamp; }
+    //     void setTimeStamp(const SGTimeStamp& timeStamp)
+    //     { _timeStamp = timeStamp; }
+    // private:
+    //     SGTimeStamp _timeStamp;
+    // };
+
+    // const TimeStamp* getTimeStamp() const
+    // { return _timeStamp.get(); }
+    // void setTimeStamp(const TimeStamp* timeStamp)
+    // { _timeStamp = timeStamp; }
+
+    // struct ChangeCount : public SGReferenced {
+    //     ChangeCount() : _value(0) {}
+    //     unsigned _value;
+    // };
+    // SGSharedPtr<ChangeCount> _changeCount;
+    // unsigned getChangeCount() const
+    // {
+    //     // If we don't have return allways the same
+    //     if (!_changeCount.valid())
+    //         return 0;
+    //     return _changeCount->_value;
+    // }
+
+    /// HLADataElements could be identified by path
+    /// These paths are composed of structure field names and array indices in the
+    /// order they appear while walking to the data element.
+    /// So provide here some tool functions to access these elements
+    /// Note that these functions are relatively expensive in execution time.
+    /// So only use them once at object creation time and store direct references to the values
+
+    class PathElement {
+    public:
+        PathElement(unsigned index) : _data(new IndexData(index)) {}
+        PathElement(const std::string& name) : _data(new FieldData(name)) {}
+
+        bool isFieldValue() const
+        { return _data->toFieldData(); }
+        bool isIndexValue() const
+        { return _data->toIndexData(); }
+
+        unsigned getIndexValue() const
+        {
+            const IndexData* indexData = _data->toIndexData();
+            if (!indexData)
+                return ~unsigned(0);
+            return indexData->_index;
+        }
+
+        std::string getFieldValue() const
+        {
+            const FieldData* fieldData = _data->toFieldData();
+            if (!fieldData)
+                return std::string();
+            return fieldData->_name;
+        }
+
+        // Want to be able to use that in std::map and std::set
+        bool operator<(const PathElement& pathElement) const
+        { return _data->less(pathElement._data.get()); }
+        bool operator==(const PathElement& pathElement) const
+        { return _data->equal(pathElement._data.get()); }
+
+        void append(std::string& s) const
+        { _data->append(s); }
+
+    private:
+        struct FieldData;
+        struct IndexData;
+        struct Data : public SGReferenced {
+            virtual ~Data();
+            virtual const FieldData* toFieldData() const;
+            virtual const IndexData* toIndexData() const;
+            virtual bool less(const Data*) const = 0;
+            virtual bool equal(const Data*) const = 0;
+            virtual void append(std::string&) const = 0;
+        };
+        struct FieldData : public Data {
+            FieldData(const std::string& name);
+            virtual ~FieldData();
+            virtual const FieldData* toFieldData() const;
+            virtual bool less(const Data* data) const;
+            virtual bool equal(const Data* data) const;
+            virtual void append(std::string& s) const;
+            std::string _name;
+        };
+        struct IndexData : public Data {
+            IndexData(unsigned index);
+            virtual ~IndexData();
+            virtual const IndexData* toIndexData() const;
+            virtual bool less(const Data* data) const;
+            virtual bool equal(const Data* data) const;
+            virtual void append(std::string& s) const;
+            unsigned _index;
+        };
+
+        SGSharedPtr<Data> _data;
+    };
+    typedef std::list<PathElement> Path;
+    typedef std::pair<std::string, Path> AttributePathPair;
+    typedef std::pair<unsigned, Path> IndexPathPair;
+
+    static std::string toString(const Path& path);
+    static std::string toString(const AttributePathPair& path)
+    { return path.first + toString(path.second); }
+    static AttributePathPair toAttributePathPair(const std::string& s);
+    static Path toPath(const std::string& s)
+    { return toAttributePathPair(s).second; }
+
+private:
+    // SGSharedPtr<const TimeStamp> _timeStamp;
+};
+
+class HLADataElementProvider {
+public:
+    class AbstractProvider : public SGReferenced {
+    public:
+        virtual ~AbstractProvider() { }
+        virtual HLADataElement* getDataElement(const HLADataElement::Path& path) = 0;
+        // virtual HLADataElement* getDataElement(const HLADataElement::Path& path, const HLADataType* dataType)
+        // {
+        //     SGSharedPtr<HLADataElement> dataElement = getDataElement(path);
+        //     if (!dataElement.valid())
+        //         return 0;
+        //     if (!dataElement->setDataType(dataType))
+        //         return 0;
+        //     return dataElement.release();
+        // }
+    };
+
+    HLADataElementProvider()
+    { }
+    HLADataElementProvider(HLADataElement* dataElement) :
+        _provider(new ConcreteProvider(dataElement))
+    { }
+    HLADataElementProvider(const SGSharedPtr<HLADataElement>& dataElement) :
+        _provider(new ConcreteProvider(dataElement))
+    { }
+    HLADataElementProvider(AbstractProvider* provider) :
+        _provider(provider)
+    { }
+
+    HLADataElement* getDataElement(const HLADataElement::Path& path) const
+    {
+        if (!_provider.valid())
+            return 0;
+        return _provider->getDataElement(path);
+    }
+
+private:
+    class ConcreteProvider : public AbstractProvider {
+    public:
+        ConcreteProvider(const SGSharedPtr<HLADataElement>& dataElement) :
+            _dataElement(dataElement)
+        { }
+        virtual HLADataElement* getDataElement(const HLADataElement::Path&)
+        { return _dataElement.get(); }
+    private:
+        SGSharedPtr<HLADataElement> _dataElement;
+    };
+
+    SGSharedPtr<AbstractProvider> _provider;
+};
+
+typedef std::map<HLADataElement::Path, HLADataElementProvider> HLAPathElementMap;
+typedef std::map<unsigned, HLAPathElementMap> HLAAttributePathElementMap;
+
+}
+
+#endif

simgear/hla/HLADataType.cxx

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

simgear/hla/HLADataType.hxx

@@ -0,0 +1,99 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLADataType_hxx
+#define HLADataType_hxx
+
+#include <string>
+#include <simgear/structure/SGWeakPtr.hxx>
+#include <simgear/structure/SGWeakReferenced.hxx>
+#include "RTIData.hxx"
+
+namespace simgear {
+
+class HLADataTypeVisitor;
+
+class HLADataTypeReference;
+class HLABasicDataType;
+class HLAArrayDataType;
+class HLAEnumeratedDataType;
+class HLAFixedRecordDataType;
+class HLAVariantDataType;
+
+enum HLAUpdateType {
+    HLAStaticUpdate,
+    HLAPeriodicUpdate,
+    HLAConditionalUpdate,
+    HLAUndefinedUpdate
+};
+
+class HLADataType : public SGWeakReferenced {
+public:
+    virtual ~HLADataType();
+
+    const std::string& getName() const
+    { return _name; }
+
+    const std::string& getSemantics() const
+    { return _semantics; }
+    void setSemantics(const std::string& semantics)
+    { _semantics = semantics; }
+
+    unsigned getAlignment() const
+    { return _alignment; }
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const 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;
+
+protected:
+    HLADataType(const std::string& name, unsigned alignment = 1);
+    void setAlignment(unsigned alignment);
+
+private:
+    std::string _name;
+    std::string _semantics;
+    unsigned _alignment;
+};
+
+// Weak reference to a data type. Used to implement self referencing data types
+class HLADataTypeReference : public HLADataType {
+public:
+    HLADataTypeReference(const SGSharedPtr<HLADataType>& dataType) :
+        HLADataType(dataType->getName(), dataType->getAlignment()),
+        _dataType(dataType)
+    { }
+    virtual ~HLADataTypeReference();
+
+    SGSharedPtr<const HLADataType> getDataType() const
+    { return _dataType.lock(); }
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+    virtual const HLADataTypeReference* toDataTypeReference() const;
+
+private:
+    SGWeakPtr<const HLADataType> _dataType;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLADataTypeVisitor.hxx

@@ -0,0 +1,634 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLADataTypeVisitor_hxx
+#define HLADataTypeVisitor_hxx
+
+#include <cassert>
+#include <string>
+#include <simgear/debug/logstream.hxx>
+#include <simgear/math/SGMath.hxx>
+#include "HLAArrayDataType.hxx"
+#include "HLABasicDataType.hxx"
+#include "HLADataTypeVisitor.hxx"
+#include "HLAEnumeratedDataType.hxx"
+#include "HLAFixedRecordDataType.hxx"
+#include "HLAVariantDataType.hxx"
+
+namespace simgear {
+
+class HLADataTypeVisitor {
+public:
+    virtual ~HLADataTypeVisitor() {}
+
+    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)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt16DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAInt64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    { apply(static_cast<const HLABasicDataType&>(dataType)); }
+
+    virtual void apply(const HLAArrayDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    { apply(static_cast<const HLAArrayDataType&>(dataType)); }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    { apply(static_cast<const HLAArrayDataType&>(dataType)); }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    { apply(static_cast<const HLADataType&>(dataType)); }
+};
+
+/// Walks the datatype tree and checks if it is completely defined
+class HLADataTypeCheckVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeCheckVisitor() : _valid(true) {}
+
+    bool valid() const { return _valid; }
+
+    virtual void apply(const HLAInt8DataType& dataType) { }
+    virtual void apply(const HLAUInt8DataType& dataType) { }
+    virtual void apply(const HLAInt16DataType& dataType) { }
+    virtual void apply(const HLAUInt16DataType& dataType) { }
+    virtual void apply(const HLAInt32DataType& dataType) { }
+    virtual void apply(const HLAUInt32DataType& dataType) { }
+    virtual void apply(const HLAInt64DataType& dataType) { }
+    virtual void apply(const HLAUInt64DataType& dataType) { }
+    virtual void apply(const HLAFloat32DataType& dataType) { }
+    virtual void apply(const HLAFloat64DataType& dataType) { }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        if (!dataType.getElementDataType())
+            _valid = false;
+        else
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        if (!dataType.getElementDataType())
+            _valid = false;
+        else
+            dataType.getElementDataType()->accept(*this);
+
+        if (!dataType.getSizeDataType())
+            _valid = false;
+        else
+            dataType.getSizeDataType()->accept(*this);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        if (!dataType.getRepresentation())
+            _valid = false;
+        else
+            dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i) {
+            if (!dataType.getFieldDataType(i))
+                _valid = false;
+            else
+                dataType.getFieldDataType(i)->accept(*this);
+        }
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    { assert(0); }
+
+protected:
+    bool _valid;
+};
+
+class HLADataTypeDecodeVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeDecodeVisitor(HLADecodeStream& stream) : _stream(stream) {}
+    virtual ~HLADataTypeDecodeVisitor() {}
+
+    virtual void apply(const HLAInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat64DataType& dataType) { dataType.skip(_stream); }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        unsigned numElements = dataType.getNumElements();
+        for (unsigned i = 0; i < numElements; ++i)
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i)
+            dataType.getFieldDataType(i)->accept(*this);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+
+protected:
+    HLADecodeStream& _stream;
+};
+
+class HLADataTypeEncodeVisitor : public HLADataTypeVisitor {
+public:
+    HLADataTypeEncodeVisitor(HLAEncodeStream& stream) : _stream(stream) {}
+    virtual ~HLADataTypeEncodeVisitor() {}
+
+    virtual void apply(const HLAInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt8DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt16DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAUInt64DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat32DataType& dataType) { dataType.skip(_stream); }
+    virtual void apply(const HLAFloat64DataType& dataType) { dataType.skip(_stream); }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        /// FIXME, might vanish in this sense ...
+        // dataType.encode(_stream, *this);
+        unsigned numElements = dataType.getNumElements();
+        for (unsigned i = 0; i < numElements; ++i)
+            dataType.getElementDataType()->accept(*this);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType);
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        dataType.getRepresentation()->accept(*this);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        unsigned numFields = dataType.getNumFields();
+        for (unsigned i = 0; i < numFields; ++i)
+            dataType.getFieldDataType(i)->accept(*this);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType) { assert(0); }
+
+protected:
+    HLAEncodeStream& _stream;
+};
+
+/// Begin implementation of some get/set visitors
+
+class HLAScalarDecodeVisitor : public HLADataTypeDecodeVisitor {
+public:
+    HLAScalarDecodeVisitor(HLADecodeStream& stream) :
+        HLADataTypeDecodeVisitor(stream)
+    {}
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing scalar value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+};
+
+class HLAScalarEncodeVisitor : public HLADataTypeEncodeVisitor {
+public:
+    HLAScalarEncodeVisitor(HLAEncodeStream& stream) :
+        HLADataTypeEncodeVisitor(stream)
+    {}
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedRecordDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing scalar value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+};
+
+class HLAFixedRecordDecodeVisitor : public HLADataTypeDecodeVisitor {
+public:
+    HLAFixedRecordDecodeVisitor(HLADecodeStream& stream) :
+        HLADataTypeDecodeVisitor(stream)
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while decodeing a fixed record value");
+        HLADataTypeDecodeVisitor::apply(dataType);
+    }
+};
+
+class HLAFixedRecordEncodeVisitor : public HLADataTypeEncodeVisitor {
+public:
+    HLAFixedRecordEncodeVisitor(HLAEncodeStream& stream) :
+        HLADataTypeEncodeVisitor(stream)
+    { }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAFixedArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+    virtual void apply(const HLAVariableArrayDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAEnumeratedDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+
+    virtual void apply(const HLAVariantDataType& dataType)
+    {
+        SG_LOG(SG_NETWORK, SG_WARN, "Unexpected HLADataType while writing a fixed record value");
+        HLADataTypeEncodeVisitor::apply(dataType);
+    }
+};
+
+template<typename T>
+class HLATemplateDecodeVisitor : public HLAScalarDecodeVisitor {
+public:
+    typedef T value_type;
+
+    HLATemplateDecodeVisitor(HLADecodeStream& stream, const value_type& value = value_type()) :
+        HLAScalarDecodeVisitor(stream),
+        _value(value)
+    {}
+
+    void setValue(const value_type& value)
+    { _value = value; }
+    const value_type& getValue() const
+    { return _value; }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        int8_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        uint8_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        int16_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        uint16_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        int32_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        uint32_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        int64_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        uint64_t value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        float value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        double value = 0;
+        dataType.decode(_stream, value);
+        _value = value_type(value);
+    }
+
+private:
+    value_type _value;
+};
+
+template<typename T>
+class HLATemplateEncodeVisitor : public HLAScalarEncodeVisitor {
+public:
+    typedef T value_type;
+
+    HLATemplateEncodeVisitor(HLAEncodeStream& stream, const value_type& value = value_type()) :
+        HLAScalarEncodeVisitor(stream),
+        _value(value)
+    {}
+
+    void setValue(const value_type& value)
+    { _value = value; }
+    const value_type& getValue() const
+    { return _value; }
+
+    virtual void apply(const HLAInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt8DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt16DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAUInt64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAFloat32DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+    virtual void apply(const HLAFloat64DataType& dataType)
+    {
+        dataType.encode(_stream, _value);
+    }
+
+private:
+    value_type _value;
+};
+
+inline void HLADataTypeDecodeVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    HLATemplateDecodeVisitor<unsigned> numElementsVisitor(_stream);
+    dataType.getSizeDataType()->accept(numElementsVisitor);
+    unsigned numElements = numElementsVisitor.getValue();
+    for (unsigned i = 0; i < numElements; ++i)
+        dataType.getElementDataType()->accept(*this);
+}
+
+inline void HLADataTypeEncodeVisitor::apply(const HLAVariableArrayDataType& dataType)
+{
+    HLATemplateEncodeVisitor<unsigned> numElementsVisitor(_stream, 0);
+    dataType.getSizeDataType()->accept(numElementsVisitor);
+}
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAEnumeratedDataElement.cxx

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

simgear/hla/HLAEnumeratedDataElement.hxx

@@ -0,0 +1,64 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAEnumeratedDataElement_hxx
+#define HLAEnumeratedDataElement_hxx
+
+#include "HLADataElement.hxx"
+#include "HLAEnumeratedDataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractEnumeratedDataElement : public HLADataElement {
+public:
+    HLAAbstractEnumeratedDataElement(const HLAEnumeratedDataType* dataType);
+    virtual ~HLAAbstractEnumeratedDataElement();
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAEnumeratedDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLAEnumeratedDataType* dataType);
+
+    const HLABasicDataType* getRepresentationDataType() const;
+
+    std::string getStringRepresentation() const;
+    bool setStringRepresentation(const std::string& name);
+
+    virtual unsigned getEnumeratorIndex() const = 0;
+    virtual void setEnumeratorIndex(unsigned index) = 0;
+
+private:
+    SGSharedPtr<const HLAEnumeratedDataType> _dataType;
+};
+
+class HLAEnumeratedDataElement : public HLAAbstractEnumeratedDataElement {
+public:
+    HLAEnumeratedDataElement(const HLAEnumeratedDataType* dataType);
+    virtual ~HLAEnumeratedDataElement();
+
+    virtual unsigned getEnumeratorIndex() const;
+    virtual void setEnumeratorIndex(unsigned index);
+
+private:
+    unsigned _enumeratorIndex;
+};
+
+}
+
+#endif

simgear/hla/HLAEnumeratedDataType.cxx

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

simgear/hla/HLAEnumeratedDataType.hxx

@@ -0,0 +1,95 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAEnumeratedDataType_hxx
+#define HLAEnumeratedDataType_hxx
+
+#include <string>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAEnumeratedDataType : public HLADataType {
+public:
+    HLAEnumeratedDataType(const std::string& name = "HLAEnumeratedDataType");
+    virtual ~HLAEnumeratedDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLAEnumeratedDataType* toEnumeratedDataType() const;
+
+    virtual bool decode(HLADecodeStream& stream, unsigned& index) const;
+    virtual bool encode(HLAEncodeStream& stream, unsigned index) const;
+
+    std::string getString(unsigned index) const
+    {
+        if (!_map.valid())
+            return std::string();
+        return _map->getString(index);
+    }
+    unsigned getIndex(const std::string& name) const
+    {
+        if (!_map.valid())
+            return ~unsigned(0);
+        return _map->getIndex(name);
+    }
+    unsigned getNumEnumerators() const
+    {
+        if (!_map.valid())
+            return 0;
+        return _map->getNumEnumerators();
+    }
+
+    bool addEnumerator(const std::string& name, const std::string& number)
+    {
+        if (!_map.valid())
+            return false;
+        return _map->add(name, number);
+    }
+
+    void setRepresentation(HLABasicDataType* representation);
+    const HLABasicDataType* getRepresentation() const
+    {
+        if (!_map.valid())
+            return 0;
+        return _map->getDataType();
+    }
+
+private:
+    class AbstractMap : public SGReferenced {
+    public:
+        virtual ~AbstractMap() {}
+        virtual bool encode(HLAEncodeStream& stream, unsigned index) const = 0;
+        virtual bool decode(HLADecodeStream& stream, unsigned& index) const = 0;
+        virtual const HLABasicDataType* getDataType() const = 0;
+        virtual bool add(const std::string& name, const std::string& number) = 0;
+        virtual std::string getString(unsigned index) const = 0;
+        virtual unsigned getIndex(const std::string& name) const = 0;
+        virtual unsigned getNumEnumerators() const = 0;
+    };
+
+    template<typename DataType, typename T>
+    class Map;
+    class RepresentationVisitor;
+
+    SGSharedPtr<AbstractMap> _map;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAFederate.cxx

@@ -0,0 +1,246 @@
+// 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 "HLAFederate.hxx"
+
+#include "RTIFederate.hxx"
+#include "RTIInteractionClass.hxx"
+#include "RTIObjectClass.hxx"
+#include "HLADataElement.hxx"
+#include "HLADataType.hxx"
+#include "HLAOMTXmlVisitor.hxx"
+
+namespace simgear {
+
+HLAFederate::HLAFederate(const SGSharedPtr<RTIFederate>& rtiFederate) :
+    _rtiFederate(rtiFederate)
+{
+}
+
+HLAFederate::~HLAFederate()
+{
+}
+
+const std::string&
+HLAFederate::getFederateType() const
+{
+    return _rtiFederate->getFederateType();
+}
+
+const std::string&
+HLAFederate::getFederationName() const
+{
+    return _rtiFederate->getFederationName();
+}
+
+bool
+HLAFederate::createFederationExecution(const std::string& federation, const std::string& objectModel)
+{
+    return _rtiFederate->createFederationExecution(federation, objectModel);
+}
+
+bool
+HLAFederate::destroyFederationExecution(const std::string& federation)
+{
+    return _rtiFederate->destroyFederationExecution(federation);
+}
+
+bool
+HLAFederate::join(const std::string& federateType, const std::string& federation)
+{
+    return _rtiFederate->join(federateType, federation);
+}
+
+bool
+HLAFederate::resign()
+{
+    return _rtiFederate->resign();
+}
+
+bool
+HLAFederate::enableTimeConstrained()
+{
+    return _rtiFederate->enableTimeConstrained();
+}
+
+bool
+HLAFederate::disableTimeConstrained()
+{
+    return _rtiFederate->disableTimeConstrained();
+}
+
+bool
+HLAFederate::enableTimeRegulation(const SGTimeStamp& lookahead)
+{
+    return _rtiFederate->enableTimeRegulation(lookahead);
+}
+
+bool
+HLAFederate::disableTimeRegulation()
+{
+    return _rtiFederate->disableTimeRegulation();
+}
+
+bool
+HLAFederate::timeAdvanceRequestBy(const SGTimeStamp& dt)
+{
+    return _rtiFederate->timeAdvanceRequestBy(dt);
+}
+
+bool
+HLAFederate::timeAdvanceRequest(const SGTimeStamp& dt)
+{
+    return _rtiFederate->timeAdvanceRequest(dt);
+}
+
+bool
+HLAFederate::tick()
+{
+    return _rtiFederate->tick();
+}
+
+bool
+HLAFederate::tick(const double& minimum, const double& maximum)
+{
+    return _rtiFederate->tick(minimum, maximum);
+}
+
+bool
+HLAFederate::readObjectModelTemplate(const std::string& objectModel,
+                                     HLAFederate::ObjectModelFactory& objectModelFactory)
+{
+    if (!_rtiFederate.valid()) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not process HLA XML object model file: "
+               "No rti federate available!");
+        return false;
+    }
+
+    // The XML version of the federate object model.
+    // This one covers the generic attributes, parameters and data types.
+    HLAOMTXmlVisitor omtXmlVisitor;
+    try {
+        readXML(objectModel, omtXmlVisitor);
+    } catch (const sg_throwable& e) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file: "
+               << e.getMessage());
+        return false;
+    } catch (...) {
+        SG_LOG(SG_IO, SG_ALERT, "Could not open HLA XML object model file");
+        return false;
+    }
+
+    unsigned numObjectClasses = omtXmlVisitor.getNumObjectClasses();
+    for (unsigned i = 0; i < numObjectClasses; ++i) {
+        const HLAOMTXmlVisitor::ObjectClass* objectClass = omtXmlVisitor.getObjectClass(i);
+        std::string objectClassName = objectClass->getName();
+
+        SGSharedPtr<HLAObjectClass> hlaObjectClass = objectModelFactory.createObjectClass(objectClassName, *this);
+        if (!hlaObjectClass.valid()) {
+            SG_LOG(SG_IO, SG_INFO, "Ignoring object class \"" << objectClassName << "\".");
+            continue;
+        }
+
+        bool publish = objectModelFactory.publishObjectClass(objectClassName, objectClass->getSharing());
+        bool subscribe = objectModelFactory.subscribeObjectClass(objectClassName, objectClass->getSharing());
+
+        std::set<unsigned> subscriptions;
+        std::set<unsigned> publications;
+
+        // process the attributes
+        for (unsigned j = 0; j < objectClass->getNumAttributes(); ++j) {
+            const simgear::HLAOMTXmlVisitor::Attribute* attribute;
+            attribute = objectClass->getAttribute(j);
+
+            std::string attributeName = attribute->getName();
+            unsigned index = hlaObjectClass->getAttributeIndex(attributeName);
+
+            if (index == ~0u) {
+                SG_LOG(SG_IO, SG_WARN, "RTI does not know the \"" << attributeName << "\" attribute!");
+                continue;
+            }
+
+            SGSharedPtr<HLADataType> dataType;
+            dataType = omtXmlVisitor.getAttributeDataType(objectClassName, attributeName);
+            if (!dataType.valid()) {
+                SG_LOG(SG_IO, SG_WARN, "Could not find data type for attribute \""
+                       << attributeName << "\" in object class \"" << objectClassName << "\"!");
+            }
+            hlaObjectClass->setAttributeDataType(index, dataType);
+
+            HLAUpdateType updateType = HLAUndefinedUpdate;
+            if (attribute->_updateType == "Periodic")
+                updateType = HLAPeriodicUpdate;
+            else if (attribute->_updateType == "Static")
+                updateType = HLAStaticUpdate;
+            else if (attribute->_updateType == "Conditional")
+                updateType = HLAConditionalUpdate;
+            hlaObjectClass->setAttributeUpdateType(index, updateType);
+
+            if (subscribe && objectModelFactory.subscribeAttribute(objectClassName, attributeName, attribute->_sharing))
+                subscriptions.insert(index);
+            if (publish && objectModelFactory.publishAttribute(objectClassName, attributeName, attribute->_sharing))
+                publications.insert(index);
+        }
+
+        if (publish)
+            hlaObjectClass->publish(publications);
+        if (subscribe)
+            hlaObjectClass->subscribe(subscriptions, true);
+
+        _objectClassMap[objectClassName] = hlaObjectClass;
+    }
+
+    return true;
+}
+
+HLAObjectClass*
+HLAFederate::getObjectClass(const std::string& name)
+{
+    ObjectClassMap::const_iterator i = _objectClassMap.find(name);
+    if (i == _objectClassMap.end())
+        return 0;
+    return i->second.get();
+}
+
+const HLAObjectClass*
+HLAFederate::getObjectClass(const std::string& name) const
+{
+    ObjectClassMap::const_iterator i = _objectClassMap.find(name);
+    if (i == _objectClassMap.end())
+        return 0;
+    return i->second.get();
+}
+
+HLAInteractionClass*
+HLAFederate::getInteractionClass(const std::string& name)
+{
+    InteractionClassMap::const_iterator i = _interactionClassMap.find(name);
+    if (i == _interactionClassMap.end())
+        return 0;
+    return i->second.get();
+}
+
+const HLAInteractionClass*
+HLAFederate::getInteractionClass(const std::string& name) const
+{
+    InteractionClassMap::const_iterator i = _interactionClassMap.find(name);
+    if (i == _interactionClassMap.end())
+        return 0;
+    return i->second.get();
+}
+
+} // namespace simgear

simgear/hla/HLAFederate.hxx

@@ -0,0 +1,111 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAFederate_hxx
+#define HLAFederate_hxx
+
+#include <map>
+
+#include "HLAObjectInstance.hxx"
+#include "HLAObjectClass.hxx"
+#include "HLAInteractionClass.hxx"
+
+class SGTimeStamp;
+
+namespace simgear {
+
+class RTIFederate;
+
+class HLAFederate : public SGWeakReferenced {
+public:
+    virtual ~HLAFederate();
+
+    /// Get the name of the joined federate/federation
+    const std::string& getFederateType() const;
+    const std::string& getFederationName() const;
+
+    /// 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);
+
+    /// Join with federateType the federation execution
+    bool join(const std::string& federateType, const std::string& federation);
+    bool resign();
+
+    bool enableTimeConstrained();
+    bool disableTimeConstrained();
+
+    bool enableTimeRegulation(const SGTimeStamp& lookahead);
+    bool disableTimeRegulation();
+
+    bool timeAdvanceRequestBy(const SGTimeStamp& dt);
+    bool timeAdvanceRequest(const SGTimeStamp& dt);
+
+    /// Process messages
+    bool tick();
+    bool tick(const double& minimum, const double& maximum);
+
+    class ObjectModelFactory {
+    public:
+        virtual ~ObjectModelFactory()
+        { }
+
+        virtual HLAObjectClass* createObjectClass(const std::string& name, HLAFederate& federate)
+        { return new HLAObjectClass(name, federate); }
+        virtual bool subscribeObjectClass(const std::string& objectClassName, const std::string& sharing)
+        { return sharing.find("Subscribe") != std::string::npos; }
+        virtual bool publishObjectClass(const std::string& objectClassName, const std::string& sharing)
+        { return sharing.find("Publish") != std::string::npos; }
+        virtual bool subscribeAttribute(const std::string& objectClassName, const std::string& attributeName, const std::string& sharing)
+        { return sharing.find("Subscribe") != std::string::npos; }
+        virtual bool publishAttribute(const std::string& objectClassName, const std::string& attributeName, const std::string& sharing)
+        { return sharing.find("Publish") != std::string::npos; }
+
+    };
+
+    /// Read an omt xml file
+    bool readObjectModelTemplate(const std::string& objectModel,
+                                 ObjectModelFactory& objectModelFactory);
+
+    HLAObjectClass* getObjectClass(const std::string& name);
+    const HLAObjectClass* getObjectClass(const std::string& name) const;
+
+    HLAInteractionClass* getInteractionClass(const std::string& name);
+    const HLAInteractionClass* getInteractionClass(const std::string& name) const;
+
+protected:
+    HLAFederate(const SGSharedPtr<RTIFederate>& rtiFederate);
+
+private:
+    SGSharedPtr<RTIFederate> _rtiFederate;
+
+    typedef std::map<std::string, SGSharedPtr<HLAObjectClass> > ObjectClassMap;
+    ObjectClassMap _objectClassMap;
+
+    typedef std::map<std::string, SGSharedPtr<HLAInteractionClass> > InteractionClassMap;
+    InteractionClassMap _interactionClassMap;
+
+    friend class HLAInteractionClass;
+    friend class HLAObjectClass;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAFixedRecordDataElement.cxx

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

simgear/hla/HLAFixedRecordDataElement.hxx

@@ -0,0 +1,77 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAFixedRecordDataElement_hxx
+#define HLAFixedRecordDataElement_hxx
+
+#include <string>
+#include <vector>
+#include "HLADataElement.hxx"
+#include "HLAFixedRecordDataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractFixedRecordDataElement : public HLADataElement {
+public:
+    HLAAbstractFixedRecordDataElement(const HLAFixedRecordDataType* dataType);
+    virtual ~HLAAbstractFixedRecordDataElement();
+
+    virtual bool decode(HLADecodeStream& stream);
+    virtual bool encode(HLAEncodeStream& stream) const;
+
+    virtual const HLAFixedRecordDataType* getDataType() const;
+    virtual bool setDataType(const HLADataType* dataType);
+    void setDataType(const HLAFixedRecordDataType* dataType);
+
+    unsigned getNumFields() const;
+    unsigned getFieldNumber(const std::string& name) const;
+
+    const HLADataType* getFieldDataType(unsigned i) const;
+    const HLADataType* getFieldDataType(const std::string& name) const;
+
+    virtual bool decodeField(HLADecodeStream& stream, unsigned i) = 0;
+    virtual bool encodeField(HLAEncodeStream& stream, unsigned i) const = 0;
+
+private:
+    SGSharedPtr<const HLAFixedRecordDataType> _dataType;
+};
+
+class HLAFixedRecordDataElement : public HLAAbstractFixedRecordDataElement {
+public:
+    HLAFixedRecordDataElement(const HLAFixedRecordDataType* dataType);
+    virtual ~HLAFixedRecordDataElement();
+
+    virtual bool decodeField(HLADecodeStream& stream, unsigned i);
+    virtual bool encodeField(HLAEncodeStream& stream, unsigned i) const;
+
+    HLADataElement* getField(const std::string& name);
+    const HLADataElement* getField(const std::string& name) const;
+
+    HLADataElement* getField(unsigned i);
+    const HLADataElement* getField(unsigned i) const;
+
+    void setField(unsigned index, HLADataElement* value);
+    void setField(const std::string& name, HLADataElement* value);
+
+private:
+    typedef std::vector<SGSharedPtr<HLADataElement> > FieldVector;
+    FieldVector _fieldVector;
+};
+
+}
+
+#endif

simgear/hla/HLAFixedRecordDataType.cxx

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

simgear/hla/HLAFixedRecordDataType.hxx

@@ -0,0 +1,91 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAFixedRecordDataType_hxx
+#define HLAFixedRecordDataType_hxx
+
+#include <string>
+#include <vector>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAAbstractFixedRecordDataElement;
+
+class HLAFixedRecordDataType : public HLADataType {
+public:
+    HLAFixedRecordDataType(const std::string& name = "HLAFixedRecordDataType");
+    virtual ~HLAFixedRecordDataType();
+
+    virtual void accept(HLADataTypeVisitor& visitor) const;
+
+    virtual const HLAFixedRecordDataType* toFixedRecordDataType() const;
+
+    virtual bool decode(HLADecodeStream& stream, HLAAbstractFixedRecordDataElement& value) const;
+    virtual bool encode(HLAEncodeStream& stream, const HLAAbstractFixedRecordDataElement& value) const;
+
+    unsigned getNumFields() const
+    { return _fieldList.size(); }
+
+    std::string getFieldName(unsigned i) const
+    {
+        if (_fieldList.size() <= i)
+            return std::string();
+        return _fieldList[i].getName();
+    }
+    const HLADataType* getFieldDataType(unsigned i) const
+    {
+        if (_fieldList.size() <= i)
+            return 0;
+        return _fieldList[i].getDataType();
+    }
+
+    unsigned getFieldNumber(const std::string& name) const
+    {
+        for (unsigned i = 0; i < _fieldList.size(); ++i) {
+            if (_fieldList[i].getName() != name)
+                continue;
+            return i;
+        }
+        return ~0u;
+    }
+
+    void addField(const std::string& name, const HLADataType* dataType);
+
+private:
+    struct Field {
+        Field(const std::string& name, const HLADataType* dataType) :
+            _name(name), _dataType(dataType) {}
+        const std::string& getName() const
+        { return _name; }
+
+        const HLADataType* getDataType() const
+        { return _dataType.get(); }
+
+    private:
+        std::string _name;
+        SGSharedPtr<const HLADataType> _dataType;
+    };
+
+    typedef std::vector<Field> FieldList;
+    FieldList _fieldList;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAInteractionClass.hxx

@@ -0,0 +1,32 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAInteractionClass_hxx
+#define HLAInteractionClass_hxx
+
+namespace simgear {
+
+class RTIInteractionClass;
+
+class HLAInteractionClass : public SGWeakReferenced {
+public:
+    virtual ~HLAInteractionClass() {}
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLALocation.hxx

@@ -0,0 +1,549 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLALocation_hxx
+#define HLALocation_hxx
+
+#include "HLABasicDataElement.hxx"
+
+namespace simgear {
+
+class HLAAbstractLocation : public SGReferenced {
+public:
+    virtual ~HLAAbstractLocation() {}
+
+    virtual SGVec3d getCartPosition() const = 0;
+    virtual void setCartPosition(const SGVec3d&) = 0;
+
+    virtual SGQuatd getCartOrientation() const = 0;
+    virtual void setCartOrientation(const SGQuatd&) = 0;
+
+    virtual SGVec3d getAngularBodyVelocity() const = 0;
+    virtual void setAngularBodyVelocity(const SGVec3d& angular) = 0;
+
+    virtual SGVec3d getLinearBodyVelocity() const = 0;
+    virtual void setLinearBodyVelocity(const SGVec3d& linear) = 0;
+};
+
+class HLACartesianLocation : public HLAAbstractLocation {
+public:
+    HLACartesianLocation() :
+        _position(SGVec3d::zeros()),
+        _imag(SGVec3d::zeros()),
+        _angularVelocity(SGVec3d::zeros()),
+        _linearVelocity(SGVec3d::zeros())
+    { }
+
+    virtual SGVec3d getCartPosition() const
+    { return _position; }
+    virtual void setCartPosition(const SGVec3d& position)
+    { _position = position; }
+
+    virtual SGQuatd getCartOrientation() const
+    { return SGQuatd::fromPositiveRealImag(_imag); }
+    virtual void setCartOrientation(const SGQuatd& orientation)
+    { _imag = orientation.getPositiveRealImag(); }
+
+    virtual SGVec3d getAngularBodyVelocity() const
+    { return _angularVelocity; }
+    virtual void setAngularBodyVelocity(const SGVec3d& angularVelocity)
+    { _angularVelocity = angularVelocity; }
+
+    virtual SGVec3d getLinearBodyVelocity() const
+    { return _linearVelocity; }
+    virtual void setLinearBodyVelocity(const SGVec3d& linearVelocity)
+    { _linearVelocity = linearVelocity; }
+
+    HLADataElementProvider getPositionDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new PositionDataElement(this, i);
+    }
+    HLADataElementProvider getOrientationDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new OrientationDataElement(this, i);
+    }
+
+    HLADataElementProvider getAngularVelocityDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new AngularVelocityDataElement(this, i);
+    }
+    HLADataElementProvider getLinearVelocityDataElement(unsigned i)
+    {
+        if (3 <= i)
+            return HLADataElementProvider();
+        return new LinearVelocityDataElement(this, i);
+    }
+
+private:
+    class PositionDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        PositionDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_position[_index]; }
+        virtual void setValue(double value)
+        { _data->_position[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    class OrientationDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        OrientationDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_imag[_index]; }
+        virtual void setValue(double value)
+        { _data->_imag[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    class AngularVelocityDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        AngularVelocityDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_angularVelocity[_index]; }
+        virtual void setValue(double value)
+        { _data->_angularVelocity[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    class LinearVelocityDataElement : public HLAAbstractDoubleDataElement {
+    public:
+        LinearVelocityDataElement(HLACartesianLocation* data, unsigned index) :
+            _data(data), _index(index)
+        { }
+        virtual double getValue() const
+        { return _data->_linearVelocity[_index]; }
+        virtual void setValue(double value)
+        { _data->_linearVelocity[_index] = value; }
+
+    private:
+        SGSharedPtr<HLACartesianLocation> _data;
+        unsigned _index;
+    };
+
+    SGVec3d _position;
+    SGVec3d _imag;
+
+    SGVec3d _angularVelocity;
+    SGVec3d _linearVelocity;
+};
+
+class HLALocationFactory : public SGReferenced {
+public:
+    virtual ~HLALocationFactory() {}
+    virtual HLAAbstractLocation* createLocation(HLAAttributePathElementMap&) const = 0;
+};
+
+class HLACartesianLocationFactory : public HLALocationFactory {
+public:
+    virtual HLAAbstractLocation* createLocation(HLAAttributePathElementMap& attributePathElementMap) const
+    {
+        HLACartesianLocation* location = new HLACartesianLocation;
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _positonIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getPositionDataElement(i);
+        }
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _orientationIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getOrientationDataElement(i);
+        }
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _angularVelocityIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getAngularVelocityDataElement(i);
+        }
+        for (unsigned i = 0; i < 3; ++i) {
+            const HLADataElement::IndexPathPair& indexPathPair = _linearVelocityIndexPathPair[i];
+            attributePathElementMap[indexPathPair.first][indexPathPair.second] = location->getLinearVelocityDataElement(i);
+        }
+        return location;
+    }
+
+    void setPositionIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _positonIndexPathPair[index] = indexPathPair;
+    }
+    void setOrientationIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _orientationIndexPathPair[index] = indexPathPair;
+    }
+
+    void setAngularVelocityIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _angularVelocityIndexPathPair[index] = indexPathPair;
+    }
+    void setLinearVelocityIndexPathPair(unsigned index, const HLADataElement::IndexPathPair& indexPathPair)
+    {
+        if (3 <= index)
+            return;
+        _linearVelocityIndexPathPair[index] = indexPathPair;
+    }
+
+private:
+    HLADataElement::IndexPathPair _positonIndexPathPair[3];
+    HLADataElement::IndexPathPair _orientationIndexPathPair[3];
+
+    HLADataElement::IndexPathPair _angularVelocityIndexPathPair[3];
+    HLADataElement::IndexPathPair _linearVelocityIndexPathPair[3];
+};
+
+class HLAGeodeticLocation : public HLAAbstractLocation {
+public:
+    HLAGeodeticLocation() :
+        _dirty(true),
+        _cartPosition(SGVec3d::zeros()),
+        _cartOrientation(SGQuatd::unit()),
+        _cartBodyVelocity(SGVec3d::zeros()),
+        _geodPosition(),
+        _geodEulerRad(SGVec3d::zeros()),
+        _groundTrackRad(0),
+        _groundSpeedMPerSec(0),
+        _verticalSpeedMPerSec(0)
+    {
+        updateCartesianFromGeodetic();
+    }
+
+    virtual SGVec3d getCartPosition() const
+    { updateCartesianFromGeodetic(); return _cartPosition; }
+    virtual void setCartPosition(const SGVec3d& position)
+    { _cartPosition = position; _dirty = true; }
+
+    virtual SGQuatd getCartOrientation() const
+    { updateCartesianFromGeodetic(); return _cartOrientation; }
+    virtual void setCartOrientation(const SGQuatd& orientation)
+    { _cartOrientation = orientation; _dirty = true; }
+
+    virtual SGVec3d getAngularBodyVelocity() const
+    { return SGVec3d::zeros(); }
+    virtual void setAngularBodyVelocity(const SGVec3d& angular)
+    { }
+
+    virtual SGVec3d getLinearBodyVelocity() const
+    { updateCartesianFromGeodetic(); return _cartBodyVelocity; }
+    virtual void setLinearBodyVelocity(const SGVec3d& linear)
+    { _cartBodyVelocity = linear; _dirty = true; }
+
+    void setLatitudeDeg(double value)
+    { _geodPosition.setLatitudeDeg(value); _dirty = true; }
+    double getLatitudeDeg() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLatitudeDeg(); }
+    void setLatitudeRad(double value)
+    { _geodPosition.setLatitudeRad(value); _dirty = true; }
+    double getLatitudeRad() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLatitudeRad(); }
+    void setLongitudeDeg(double value)
+    { _geodPosition.setLongitudeDeg(value); _dirty = true; }
+    double getLongitudeDeg() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLongitudeDeg(); }
+    void setLongitudeRad(double value)
+    { _geodPosition.setLongitudeRad(value); _dirty = true; }
+    double getLongitudeRad() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getLongitudeRad(); }
+    void setElevationFt(double value)
+    { _geodPosition.setElevationFt(value); _dirty = true; }
+    double getElevationFt() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getElevationFt(); }
+    void setElevationM(double value)
+    { _geodPosition.setElevationM(value); _dirty = true; }
+    double getElevationM() const
+    { updateGeodeticFromCartesian(); return _geodPosition.getElevationM(); }
+
+    void setHeadingRad(double value)
+    { _geodEulerRad[2] = value; _dirty = true; }
+    double getHeadingRad() const
+    { updateGeodeticFromCartesian(); return _geodEulerRad[2]; }
+    void setHeadingDeg(double value)
+    { setHeadingRad(SGMiscd::deg2rad(value)); }
+    double getHeadingDeg() const
+    { return SGMiscd::rad2deg(getHeadingRad()); }
+    void setPitchRad(double value)
+    { _geodEulerRad[1] = value; _dirty = true; }
+    double getPitchRad() const
+    { updateGeodeticFromCartesian(); return _geodEulerRad[1]; }
+    void setPitchDeg(double value)
+    { setPitchRad(SGMiscd::deg2rad(value)); }
+    double getPitchDeg() const
+    { return SGMiscd::rad2deg(getPitchRad()); }
+    void setRollRad(double value)
+    { _geodEulerRad[0] = value; _dirty = true; }
+    double getRollRad() const
+    { updateGeodeticFromCartesian(); return _geodEulerRad[0]; }
+    void setRollDeg(double value)
+    { setRollRad(SGMiscd::deg2rad(value)); }
+    double getRollDeg() const
+    { return SGMiscd::rad2deg(getRollRad()); }
+
+    void setGroundTrackRad(double value)
+    { _groundTrackRad = value; _dirty = true; }
+    double getGroundTrackRad() const
+    { updateGeodeticFromCartesian(); return _groundTrackRad; }
+    void setGroundTrackDeg(double value)
+    { setGroundTrackRad(SGMiscd::deg2rad(value)); }
+    double getGroundTrackDeg() const
+    { return SGMiscd::rad2deg(getGroundTrackRad()); }
+
+
+    void setGroundSpeedMPerSec(double value)
+    { _groundSpeedMPerSec = value; _dirty = true; }
+    double getGroundSpeedMPerSec() const
+    { updateGeodeticFromCartesian(); return _groundSpeedMPerSec; }
+    void setGroundSpeedFtPerSec(double value)
+    { setGroundSpeedMPerSec(SG_FEET_TO_METER*value); }
+    double getGroundSpeedFtPerSec() const
+    { return SG_METER_TO_FEET*getGroundSpeedMPerSec(); }
+    void setGroundSpeedKnots(double value)
+    { setGroundSpeedMPerSec(SG_KT_TO_MPS*value); }
+    double getGroundSpeedKnots() const
+    { return SG_MPS_TO_KT*getGroundSpeedMPerSec(); }
+
+    void setVerticalSpeedMPerSec(double value)
+    { _verticalSpeedMPerSec = value; _dirty = true; }
+    double getVerticalSpeedMPerSec() const
+    { updateGeodeticFromCartesian(); return _verticalSpeedMPerSec; }
+    void setVerticalSpeedFtPerSec(double value)
+    { setVerticalSpeedMPerSec(SG_FEET_TO_METER*value); }
+    double getVerticalSpeedFtPerSec() const
+    { return SG_METER_TO_FEET*getVerticalSpeedMPerSec(); }
+    void setVerticalSpeedFtPerMin(double value)
+    { setVerticalSpeedFtPerSec(value/60); }
+    double getVerticalSpeedFtPerMin() const
+    { return 60*getVerticalSpeedFtPerSec(); }
+
+#define DATA_ELEMENT(name) \
+    HLADataElementProvider get## name ## DataElement()                  \
+    { return new DataElement<&HLAGeodeticLocation::get## name, &HLAGeodeticLocation::set ## name>(this); }
+
+    DATA_ELEMENT(LatitudeDeg)
+    DATA_ELEMENT(LatitudeRad)
+    DATA_ELEMENT(LongitudeDeg)
+    DATA_ELEMENT(LongitudeRad)
+    DATA_ELEMENT(ElevationFt)
+    DATA_ELEMENT(ElevationM)
+    DATA_ELEMENT(HeadingDeg)
+    DATA_ELEMENT(HeadingRad)
+    DATA_ELEMENT(PitchDeg)
+    DATA_ELEMENT(PitchRad)
+    DATA_ELEMENT(RollDeg)
+    DATA_ELEMENT(RollRad)
+
+    DATA_ELEMENT(GroundTrackDeg)
+    DATA_ELEMENT(GroundTrackRad)
+    DATA_ELEMENT(GroundSpeedMPerSec)
+    DATA_ELEMENT(GroundSpeedFtPerSec)
+    DATA_ELEMENT(GroundSpeedKnots)
+    DATA_ELEMENT(VerticalSpeedMPerSec)
+    DATA_ELEMENT(VerticalSpeedFtPerSec)
+    DATA_ELEMENT(VerticalSpeedFtPerMin)
+
+#undef DATA_ELEMENT
+
+private:
+    template<double (HLAGeodeticLocation::*getter)() const,
+             void (HLAGeodeticLocation::*setter)(double)>
+    class DataElement : public HLAAbstractDoubleDataElement {
+    public:
+        DataElement(HLAGeodeticLocation* data) :
+            _data(data)
+        { }
+        virtual double getValue() const
+        { return (_data->*getter)(); }
+        virtual void setValue(double value)
+        { (_data->*setter)(value); }
+
+    private:
+        SGSharedPtr<HLAGeodeticLocation> _data;
+    };
+
+    void updateGeodeticFromCartesian() const
+    {
+        if (!_dirty)
+            return;
+        _geodPosition = SGGeod::fromCart(_cartPosition);
+        SGQuatd geodOrientation = inverse(SGQuatd::fromLonLat(_geodPosition))*_cartOrientation;
+        geodOrientation.getEulerRad(_geodEulerRad[2], _geodEulerRad[1], _geodEulerRad[0]);
+        SGVec3d nedVel = geodOrientation.backTransform(_cartBodyVelocity);
+        if (SGLimitsd::min() < SGMiscd::max(fabs(nedVel[0]), fabs(nedVel[1])))
+            _groundTrackRad = atan2(nedVel[1], nedVel[0]);
+        else
+            _groundTrackRad = 0;
+        _groundSpeedMPerSec = sqrt(nedVel[0]*nedVel[0] + nedVel[1]*nedVel[1]);
+        _verticalSpeedMPerSec = -nedVel[2];
+        _dirty = false;
+    }
+    void updateCartesianFromGeodetic() const
+    {
+        if (!_dirty)
+            return;
+        _cartPosition = SGVec3d::fromGeod(_geodPosition);
+        SGQuatd geodOrientation = SGQuatd::fromEulerRad(_geodEulerRad[2], _geodEulerRad[1], _geodEulerRad[0]);
+        _cartOrientation = SGQuatd::fromLonLat(_geodPosition)*geodOrientation;
+        SGVec3d nedVel(cos(_groundTrackRad)*_groundSpeedMPerSec,
+                       sin(_groundTrackRad)*_groundSpeedMPerSec,
+                       -_verticalSpeedMPerSec);
+        _cartBodyVelocity = geodOrientation.transform(nedVel);
+        _dirty = false;
+    }
+
+    mutable bool _dirty;
+
+    // the cartesian values
+    mutable SGVec3d _cartPosition;
+    mutable SGQuatd _cartOrientation;
+    mutable SGVec3d _cartBodyVelocity;
+
+    // The geodetic values
+    mutable SGGeod _geodPosition;
+    mutable SGVec3d _geodEulerRad;
+    mutable double _groundTrackRad;
+    mutable double _groundSpeedMPerSec;
+    mutable double _verticalSpeedMPerSec;
+};
+
+class HLAGeodeticLocationFactory : public HLALocationFactory {
+public:
+    enum Semantic {
+        LatitudeDeg,
+        LatitudeRad,
+        LongitudeDeg,
+        LongitudeRad,
+        ElevationM,
+        ElevationFt,
+        HeadingDeg,
+        HeadingRad,
+        PitchDeg,
+        PitchRad,
+        RollDeg,
+        RollRad,
+        GroundTrackDeg,
+        GroundTrackRad,
+        GroundSpeedKnots,
+        GroundSpeedFtPerSec,
+        GroundSpeedMPerSec,
+        VerticalSpeedFtPerSec,
+        VerticalSpeedFtPerMin,
+        VerticalSpeedMPerSec
+    };
+
+    virtual HLAGeodeticLocation* createLocation(HLAAttributePathElementMap& attributePathElementMap) const
+    {
+        HLAGeodeticLocation* location = new HLAGeodeticLocation;
+
+        for (IndexPathPairSemanticMap::const_iterator i = _indexPathPairSemanticMap.begin();
+             i != _indexPathPairSemanticMap.end(); ++i) {
+            switch (i->second) {
+            case LatitudeDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLatitudeDegDataElement();
+                break;
+            case LatitudeRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLatitudeRadDataElement();
+                break;
+            case LongitudeDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLongitudeDegDataElement();
+                break;
+            case LongitudeRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getLongitudeRadDataElement();
+                break;
+            case ElevationM:
+                attributePathElementMap[i->first.first][i->first.second] = location->getElevationMDataElement();
+                break;
+            case ElevationFt:
+                attributePathElementMap[i->first.first][i->first.second] = location->getElevationFtDataElement();
+                break;
+            case HeadingDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getHeadingDegDataElement();
+                break;
+            case HeadingRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getHeadingRadDataElement();
+                break;
+            case PitchDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getPitchDegDataElement();
+                break;
+            case PitchRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getPitchRadDataElement();
+                break;
+            case RollDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getRollDegDataElement();
+                break;
+            case RollRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getRollRadDataElement();
+                break;
+            case GroundTrackDeg:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundTrackDegDataElement();
+                break;
+            case GroundTrackRad:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundTrackRadDataElement();
+                break;
+            case GroundSpeedKnots:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundSpeedKnotsDataElement();
+                break;
+            case GroundSpeedFtPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundSpeedFtPerSecDataElement();
+                break;
+            case GroundSpeedMPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getGroundSpeedMPerSecDataElement();
+                break;
+            case VerticalSpeedFtPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getVerticalSpeedFtPerSecDataElement();
+                break;
+            case VerticalSpeedFtPerMin:
+                attributePathElementMap[i->first.first][i->first.second] = location->getVerticalSpeedFtPerMinDataElement();
+                break;
+            case VerticalSpeedMPerSec:
+                attributePathElementMap[i->first.first][i->first.second] = location->getVerticalSpeedMPerSecDataElement();
+                break;
+            }
+        }
+
+        return location;
+    }
+
+    void setIndexPathPair(Semantic semantic, const HLADataElement::IndexPathPair& indexPathPair)
+    { _indexPathPairSemanticMap[indexPathPair] = semantic; }
+
+private:
+    typedef std::map<HLADataElement::IndexPathPair, Semantic> IndexPathPairSemanticMap;
+    IndexPathPairSemanticMap _indexPathPairSemanticMap;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAOMTXmlVisitor.cxx

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

simgear/hla/HLAOMTXmlVisitor.hxx

@@ -0,0 +1,293 @@
+// Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef HLAOMTXmlVisitor_hxx
+#define HLAOMTXmlVisitor_hxx
+
+#include <map>
+#include <string>
+
+#include <simgear/structure/exception.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/xml/easyxml.hxx>
+#include "HLADataType.hxx"
+
+namespace simgear {
+
+class HLAOMTXmlVisitor : public XMLVisitor {
+public:
+    /// structures representing the federate object model data
+    struct Attribute : public SGReferenced {
+        Attribute(const std::string& name) :
+            _name(name)
+        { }
+        const std::string& getName() const
+        { return _name; }
+        const std::string& getDimensions() const
+        { return _dimensions; }
+        const std::string& getTransportation() const
+        { return _transportation; }
+        const std::string& getOrder() const
+        { return _order; }
+
+        std::string _name;
+        std::string _dataType;
+        std::string _updateType;
+        std::string _updateCondition;
+        std::string _ownership;
+        std::string _sharing;
+        std::string _dimensions;
+        std::string _transportation;
+        std::string _order;
+        friend class HLAOMTXmlVisitor;
+    };
+    typedef std::vector<SGSharedPtr<Attribute> > AttributeList;
+
+    struct ObjectClass : public SGReferenced {
+        ObjectClass(const std::string& name, const std::string& sharing);
+        ~ObjectClass();
+
+        const std::string& getName() const;
+        const std::string& getSharing() const;
+
+        unsigned getNumAttributes() const;
+        const Attribute* getAttribute(unsigned index) const;
+        const Attribute* getAttribute(const std::string& name) const;
+
+        const ObjectClass* getParentObjectClass() const;
+
+    private:
+        friend class HLAOMTXmlVisitor;
+        std::string _name;
+        std::string _sharing;
+        AttributeList _attributes;
+        SGSharedPtr<ObjectClass> _parentObjectClass;
+    };
+    typedef std::vector<SGSharedPtr<ObjectClass> > ObjectClassList;
+
+    struct Parameter : public SGReferenced {
+        Parameter(const std::string& name) :
+            _name(name)
+        { }
+        const std::string& getName() const
+        { return _name; }
+        const std::string& getDataType() const
+        { return _dataType; }
+
+    private:
+        std::string _name;
+        std::string _dataType;
+        friend class HLAOMTXmlVisitor;
+    };
+    typedef std::vector<SGSharedPtr<Parameter> > ParameterList;
+
+    struct InteractionClass : public SGReferenced {
+        InteractionClass(const std::string& name);
+        ~InteractionClass();
+
+        const std::string& getName() const;
+        const std::string& getDimensions() const;
+        const std::string& getTransportation() const;
+        const std::string& getOrder() const;
+
+        unsigned getNumParameters() const;
+        const Parameter* getParameter(unsigned index) const;
+        const Parameter* getParameter(const std::string& name) const;
+
+        const InteractionClass* getParentInteractionClass() const;
+
+    private:
+        friend class HLAOMTXmlVisitor;
+        std::string _name;
+        std::string _dimensions;
+        std::string _transportation;
+        std::string _order;
+        ParameterList _parameters;
+        SGSharedPtr<InteractionClass> _parentInteractionClass;
+    };
+    typedef std::vector<SGSharedPtr<InteractionClass> > InteractionClassList;
+
+    HLAOMTXmlVisitor();
+    ~HLAOMTXmlVisitor();
+
+    unsigned getNumObjectClasses() const;
+    const ObjectClass* getObjectClass(unsigned i) const;
+    const ObjectClass* getObjectClass(const std::string& name) const;
+
+    /// Return the data type from the fom data
+    const Attribute* getAttribute(const std::string& objectClassName, const std::string& attributeName) const;
+    /// Return the data type from the fom data
+    HLADataType* getAttributeDataType(const std::string& objectClassName, const std::string& attributeName) const;
+
+    unsigned getNumInteractionClasses() const;
+    const InteractionClass* getInteractionClass(unsigned i) const;
+    const InteractionClass* getInteractionClass(const std::string& name) const;
+
+    /// Return the data type from the fom data
+    const Parameter* getParameter(const std::string& interactionClassName, const std::string& parameterName) const;
+
+    /// Return the data type from the fom data
+    HLADataType* getParameterDataType(const std::string& interactionClassName, const std::string& parameterName) const;
+
+    HLADataType* getDataType(const std::string& dataTypeName) const;
+
+private:
+    typedef std::map<std::string, SGSharedPtr<HLADataType> > StringDataTypeMap;
+    SGSharedPtr<HLADataType> getDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+    SGSharedPtr<HLABasicDataType> getBasicDataType(const std::string& dataTypeName) const;
+    SGSharedPtr<HLADataType> getSimpleDataType(const std::string& dataTypeName) const;
+    SGSharedPtr<HLAEnumeratedDataType> getEnumeratedDataType(const std::string& dataTypeName) const;
+    SGSharedPtr<HLADataType> getArrayDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+    SGSharedPtr<HLAFixedRecordDataType> getFixedRecordDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+    SGSharedPtr<HLAVariantDataType> getVariantDataType(const std::string& dataTypeName, StringDataTypeMap& dataTypeMap) const;
+
+    enum Mode {
+        UnknownMode,
+
+        ObjectModelMode,
+
+        ObjectsMode,
+        ObjectClassMode,
+        AttributeMode,
+
+        InteractionsMode,
+        InteractionClassMode,
+        ParameterMode,
+
+        DataTypesMode,
+        BasicDataRepresentationsMode,
+        BasicDataMode,
+        SimpleDataTypesMode,
+        SimpleDataMode,
+        EnumeratedDataTypesMode,
+        EnumeratedDataMode,
+        EnumeratorMode,
+        ArrayDataTypesMode,
+        ArrayDataMode,
+        FixedRecordDataTypesMode,
+        FixedRecordDataMode,
+        FieldMode,
+        VariantRecordDataTypesMode,
+        VariantRecordDataMode,
+        AlternativeDataMode
+    };
+
+    Mode getCurrentMode();
+    void pushMode(Mode mode);
+    void popMode();
+
+    virtual void startXML();
+    virtual void endXML ();
+    virtual void startElement(const char* name, const XMLAttributes& atts);
+    virtual void endElement(const char* name);
+
+    std::string getAttribute(const char* name, const XMLAttributes& atts);
+    std::string getAttribute(const std::string& name, const XMLAttributes& atts);
+
+    struct BasicData {
+        // std::string _name;
+        std::string _size;
+        std::string _endian;
+    };
+    typedef std::map<std::string, BasicData> BasicDataMap;
+
+    struct SimpleData {
+        // std::string _name;
+        std::string _representation;
+        std::string _units;
+        std::string _resolution;
+        std::string _accuracy;
+    };
+    typedef std::map<std::string, SimpleData> SimpleDataMap;
+
+    struct Enumerator {
+        std::string _name;
+        std::string _values;
+    };
+    typedef std::vector<Enumerator> EnumeratorList;
+
+    struct EnumeratedData {
+        // std::string _name;
+        std::string _representation;
+        EnumeratorList _enumeratorList;
+    };
+    typedef std::map<std::string, EnumeratedData> EnumeratedDataMap;
+
+    struct ArrayData {
+        // std::string _name;
+        std::string _dataType;
+        std::string _cardinality;
+        std::string _encoding;
+    };
+    typedef std::map<std::string, ArrayData> ArrayDataMap;
+
+    struct Field {
+        std::string _name;
+        std::string _dataType;
+    };
+    typedef std::vector<Field> FieldList;
+
+    struct FixedRecordData {
+        // std::string _name;
+        std::string _encoding;
+        FieldList _fieldList;
+    };
+    typedef std::map<std::string, FixedRecordData> FixedRecordDataMap;
+
+    struct Alternative {
+        std::string _name;
+        std::string _dataType;
+        std::string _semantics;
+        std::string _enumerator;
+    };
+    typedef std::vector<Alternative> AlternativeList;
+
+    struct VariantRecordData {
+        // std::string _name;
+        std::string _encoding;
+        std::string _dataType;
+        std::string _discriminant;
+        std::string _semantics;
+        AlternativeList _alternativeList;
+    };
+    typedef std::map<std::string, VariantRecordData> VariantRecordDataMap;
+
+    std::vector<Mode> _modeStack;
+
+    /// The total list of object classes
+    ObjectClassList _objectClassList;
+    ObjectClassList _objectClassStack;
+
+    /// The total list of interaction classes
+    InteractionClassList _interactionClassList;
+    InteractionClassList _interactionClassStack;
+
+    /// DataType definitions
+    BasicDataMap _basicDataMap;
+    SimpleDataMap _simpleDataMap;
+    std::string _enumeratedDataName;
+    EnumeratedDataMap _enumeratedDataMap;
+    ArrayDataMap _arrayDataMap;
+    std::string _fixedRecordDataName;
+    FixedRecordDataMap _fixedRecordDataMap;
+    std::string _variantRecordDataName;
+    VariantRecordDataMap _variantRecordDataMap;
+};
+
+} // namespace simgear
+
+#endif

simgear/hla/HLAObjectClass.cxx

@@ -0,0 +1,302 @@
+// 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 "HLAObjectClass.hxx"
+
+#include "RTIFederate.hxx"
+#include "RTIObjectClass.hxx"
+#include "RTIObjectInstance.hxx"
+#include "HLADataType.hxx"
+#include "HLAFederate.hxx"
+#include "HLAObjectInstance.hxx"
+
+namespace simgear {
+
+HLAObjectClass::InstanceCallback::~InstanceCallback()
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::discoverInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance, const RTIData& tag)
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::removeInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance, const RTIData& tag)
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::registerInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance)
+{
+}
+
+void
+HLAObjectClass::InstanceCallback::deleteInstance(const HLAObjectClass&, HLAObjectInstance& objectInstance)
+{
+}
+
+HLAObjectClass::RegistrationCallback::~RegistrationCallback()
+{
+}
+
+HLAObjectClass::HLAObjectClass(const std::string& name, HLAFederate& federate) :
+    _name(name)
+{
+    _rtiObjectClass = federate._rtiFederate->createObjectClass(name, this);
+    if (!_rtiObjectClass.valid())
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::HLAObjectClass(): No RTIObjectClass found for \"" << name << "\"!");
+}
+
+HLAObjectClass::~HLAObjectClass()
+{
+}
+
+unsigned
+HLAObjectClass::getNumAttributes() const
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
+        return 0;
+    }
+    return _rtiObjectClass->getNumAttributes();
+}
+
+unsigned
+HLAObjectClass::getAttributeIndex(const std::string& name) const
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
+        return ~0u;
+    }
+    return _rtiObjectClass->getOrCreateAttributeIndex(name);
+}
+
+std::string
+HLAObjectClass::getAttributeName(unsigned index) const
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeIndex(): No RTIObject class for object class \"" << getName() << "\"!");
+        return 0;
+    }
+    return _rtiObjectClass->getAttributeName(index);
+}
+
+const HLADataType*
+HLAObjectClass::getAttributeDataType(unsigned index) const
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeDataType(): No RTIObject class for object class \"" << getName() << "\"!");
+        return 0;
+    }
+    return _rtiObjectClass->getAttributeDataType(index);
+}
+
+void
+HLAObjectClass::setAttributeDataType(unsigned index, const HLADataType* dataType)
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::setAttributeDataType(): No RTIObject class for object class \"" << getName() << "\"!");
+        return;
+    }
+    _rtiObjectClass->setAttributeDataType(index, dataType);
+}
+
+HLAUpdateType
+HLAObjectClass::getAttributeUpdateType(unsigned index) const
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::getAttributeUpdateType(): No RTIObject class for object class \"" << getName() << "\"!");
+        return HLAUndefinedUpdate;
+    }
+    return _rtiObjectClass->getAttributeUpdateType(index);
+}
+
+void
+HLAObjectClass::setAttributeUpdateType(unsigned index, HLAUpdateType updateType)
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::setAttributeUpdateType(): "
+               "No RTIObject class for object class \"" << getName() << "\"!");
+        return;
+    }
+    _rtiObjectClass->setAttributeUpdateType(index, updateType);
+}
+
+HLADataElement::IndexPathPair
+HLAObjectClass::getIndexPathPair(const HLADataElement::AttributePathPair& attributePathPair) const
+{
+    unsigned index = getAttributeIndex(attributePathPair.first);
+    if (getNumAttributes() <= index) {
+        SG_LOG(SG_NETWORK, SG_ALERT, "HLAObjectClass::getIndexPathPair(\""
+               << HLADataElement::toString(attributePathPair)
+               << "\"): Could not resolve attribute \"" << attributePathPair.first
+               << "\" for object class \"" << getName() << "\"!");
+    }
+    return HLADataElement::IndexPathPair(index, attributePathPair.second);
+}
+
+HLADataElement::IndexPathPair
+HLAObjectClass::getIndexPathPair(const std::string& path) const
+{
+    return getIndexPathPair(HLADataElement::toAttributePathPair(path));
+}
+
+bool
+HLAObjectClass::subscribe(const std::set<unsigned>& indexSet, bool active)
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::subscribe(): No RTIObject class for object class \"" << getName() << "\"!");
+        return false;
+    }
+    return _rtiObjectClass->subscribe(indexSet, active);
+}
+
+bool
+HLAObjectClass::unsubscribe()
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unsubscribe(): No RTIObject class for object class \"" << getName() << "\"!");
+        return false;
+    }
+    return _rtiObjectClass->unsubscribe();
+}
+
+bool
+HLAObjectClass::publish(const std::set<unsigned>& indexSet)
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::publish(): No RTIObject class for object class \"" << getName() << "\"!");
+        return false;
+    }
+    return _rtiObjectClass->publish(indexSet);
+}
+
+bool
+HLAObjectClass::unpublish()
+{
+    if (!_rtiObjectClass.valid()) {
+        SG_LOG(SG_NETWORK, SG_WARN, "HLAObjectClass::unpublish(): No RTIObject class for object class \"" << getName() << "\"!");
+        return false;
+    }
+    return _rtiObjectClass->unpublish();
+}
+
+void
+HLAObjectClass::startRegistration() const
+{
+}
+
+void
+HLAObjectClass::stopRegistration() const
+{
+}
+
+HLAObjectInstance*
+HLAObjectClass::createObjectInstance(RTIObjectInstance* rtiObjectInstance)
+{
+    return new HLAObjectInstance(this, rtiObjectInstance);
+}
+
+void
+HLAObjectClass::discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag)
+{
+    SGSharedPtr<HLAObjectInstance> hlaObjectInstance = createObjectInstance(objectInstance);
+    if (hlaObjectInstance.valid()) {
+        SG_LOG(SG_NETWORK, SG_INFO, "RTI: create new object instance for discovered \""
+               << hlaObjectInstance->getName() << "\" object");
+        _objectInstanceSet.insert(hlaObjectInstance);
+        discoverInstanceCallback(*hlaObjectInstance, tag);
+    } else {
+        SG_LOG(SG_NETWORK, SG_INFO, "RTI: local delete of \"" << objectInstance->getName() << "\"");
+        objectInstance->localDeleteObjectInstance();
+    }
+}
+
+void
+HLAObjectClass::removeInstance(HLAObjectInstance& hlaObjectInstance, const RTIData& tag)
+{
+    SG_LOG(SG_NETWORK, SG_INFO, "RTI: remove object instance \"" << hlaObjectInstance.getName() << "\"");
+    removeInstanceCallback(hlaObjectInstance, tag);
+    _objectInstanceSet.erase(&hlaObjectInstance);
+}
+
+void
+HLAObjectClass::registerInstance(HLAObjectInstance& objectInstance)
+{
+    _objectInstanceSet.insert(&objectInstance);
+    registerInstanceCallback(objectInstance);
+}
+
+void
+HLAObjectClass::deleteInstance(HLAObjectInstance& objectInstance)
+{
+    deleteInstanceCallback(objectInstance);
+    _objectInstanceSet.erase(&objectInstance);
+}
+
+void
+HLAObjectClass::discoverInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const
+{
+    if (!_instanceCallback.valid())
+        return;
+    _instanceCallback->discoverInstance(*this, objectInstance, tag);
+}
+
+void
+HLAObjectClass::removeInstanceCallback(HLAObjectInstance& objectInstance, const RTIData& tag) const
+{
+    if (!_instanceCallback.valid())
+        return;
+    _instanceCallback->removeInstance(*this, objectInstance, tag);
+}
+
+void
+HLAObjectClass::registerInstanceCallback(HLAObjectInstance& objectInstance) const
+{
+    if (!_instanceCallback.valid())
+        return;
+    _instanceCallback->registerInstance(*this, objectInstance);
+}
+
+void
+HLAObjectClass::deleteInstanceCallback(HLAObjectInstance& objectInstance) const
+{
+    if (!_instanceCallback.valid())
+        return;
+    _instanceCallback->deleteInstance(*this, objectInstance);
+}
+
+void
+HLAObjectClass::startRegistrationCallback()
+{
+    if (_registrationCallback.valid())
+        _registrationCallback->startRegistration(*this);
+    else
+        startRegistration();
+}
+
+void
+HLAObjectClass::stopRegistrationCallback()
+{
+    if (_registrationCallback.valid())
+        _registrationCallback->stopRegistration(*this);
+    else
+        stopRegistration();
+}
+
+} // namespace simgear