fly/flightgear
1
0
Fork 0
Code Activity

Initial revision. Contributed by Bernie Bright.

Browse source
This commit is contained in:
curt 1998-08-30 14:12:45 +00:00
parent e1cb71ee9b
commit aaeb1222e5
3 changed files with 358 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
auto_ptr.hxx Normal file
View file

@ -0,0 +1,90 @@
/**************************************************************************
* auto_ptr.hxx -- A simple auto_ptr definition.
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Id$
* (Log is kept at end of this file)
**************************************************************************/
#ifndef _AUTO_PTR_HXX
#define _AUTO_PTR_HXX
#include "fg_stl_config.h"
//-----------------------------------------------------------------------------
//
// auto_ptr is initialised with a pointer obtained via new and deletes that
// object when it itself is destroyed (such as when leaving block scope).
// auto_ptr can be used in any way that a normal pointer can be.
//
// This class is only required when the STL doesn't supply one.
//
template <class X> class auto_ptr {
private:
X* ptr;
mutable bool owns;
public:
typedef X element_type;
explicit auto_ptr(X* p = 0) : ptr(p), owns(p) {}
auto_ptr(const auto_ptr& a) : ptr(a.ptr), owns(a.owns) {
a.owns = 0;
}
template <class T> auto_ptr(const auto_ptr<T>& a)
: ptr(a.ptr), owns(a.owns) {
a.owns = 0;
}
auto_ptr& operator = (const auto_ptr& a) {
if (&a != this) {
if (owns)
delete ptr;
owns = a.owns;
ptr = a.ptr;
a.owns = 0;
}
}
template <class T> auto_ptr& operator = (const auto_ptr<T>& a) {
if (&a != this) {
if (owns)
delete ptr;
owns = a.owns;
ptr = a.ptr;
a.owns = 0;
}
}
~auto_ptr() {
if (owns)
delete ptr;
}
X& operator*() const { return *ptr; }
X* operator->() const { return ptr; }
X* get() const { return ptr; }
X* release() const { owns = false; return ptr; }
};
#endif /* _AUTO_PTR_HXX */
// $Log$
// Revision 1.1 1998/08/30 14:12:45 curt
// Initial revision. Contributed by Bernie Bright.
//

178
fg_callback.hxx Normal file
View file

@ -0,0 +1,178 @@
/**************************************************************************
* fg_callback.hxx -- Wrapper classes to treat function and method pointers
* as objects.
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Id$
* (Log is kept at end of this file)
**************************************************************************/
#ifndef _FG_CALLBACK_HXX
#define _FG_CALLBACK_HXX
//-----------------------------------------------------------------------------
//
// Abstract base class for all FlightGear callbacks.
//
class fgCallback
{
public:
virtual ~fgCallback() {}
virtual fgCallback* clone() const = 0;
virtual void* call( void** ) = 0;
size_t params() const { return n_params; }
protected:
fgCallback( size_t params )
: n_params(params) {}
protected:
// The number of parameters to pass to the callback routine.
size_t n_params;
private:
};
//-----------------------------------------------------------------------------
//
// Callback for invoking a file scope function.
//
class fgFunctionCallback : public fgCallback
{
public:
// Pointer to function taking no arguments and returning void.
typedef void (*Proc0v)();
fgFunctionCallback( Proc0v p );
virtual fgCallback* clone() const;
private:
void* call( void** in );
void* call0v( void** );
private:
// Not defined.
fgFunctionCallback();
private:
typedef void* (fgFunctionCallback::*DoPtr)( void** );
DoPtr doPtr;
Proc0v proc0v;
};
inline
fgFunctionCallback::fgFunctionCallback( Proc0v p )
: fgCallback(0),
doPtr(&fgFunctionCallback::call0v),
proc0v(p)
{
// empty
}
inline fgCallback*
fgFunctionCallback::clone() const
{
return new fgFunctionCallback( *this );
}
inline void*
fgFunctionCallback::call( void** in )
{
return (this->*doPtr)( in );
}
inline void*
fgFunctionCallback::call0v( void** )
{
(*proc0v)();
return (void*) NULL;
}
//-----------------------------------------------------------------------------
//
// Callback for invoking an instance method.
//
template< class T >
class fgMethodCallback : public fgCallback
{
public:
// Pointer to method taking no arguments and returning void.
typedef void (T::*Method0v)();
//
fgMethodCallback( T* o, Method0v m );
//
fgCallback* clone() const;
private:
//
void* call( void** in );
//
void* call0v( void** );
private:
// Not defined.
fgMethodCallback();
private:
T* object;
Method0v method0v;
typedef void * (fgMethodCallback::*DoPtr)( void ** );
DoPtr doPtr;
};
template< class T > inline
fgMethodCallback<T>::fgMethodCallback( T* o, Method0v m )
: fgCallback(0),
object(o),
method0v(m),
doPtr(&fgMethodCallback<T>::call0v)
{
}
template< class T > inline fgCallback*
fgMethodCallback<T>::clone() const
{
return new fgMethodCallback( *this );
}
template< class T > inline void*
fgMethodCallback<T>::call( void** in )
{
return (this->*doPtr)( in );
}
template< class T > inline void*
fgMethodCallback<T>::call0v( void** )
{
(object->*method0v)();
return (void*) NULL;
}
#endif // _FG_CALLBACK_HXX
// $Log$
// Revision 1.1 1998/08/30 14:13:48 curt
// Initial revision. Contributed by Bernie Bright.
//

90
fg_stl_config.h Normal file
View file

@ -0,0 +1,90 @@
/**************************************************************************
* fg_stl_config.hxx -- STL Portability Macros
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Id$
* (Log is kept at end of this file)
**************************************************************************/
#ifndef _FG_STL_CONFIG_H
#define _FG_STL_CONFIG_H
// What this file does.
// (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 _FG_EXPLICIT_FUNCTION_TMPL_ARGS if the compiler
// supports calling a function template by providing its template
// arguments explicitly.
// (7) Defines _FG_NEED_AUTO_PTR if STL doesn't provide auto_ptr<>.
#ifdef __GNUC__
# if __GNUC__ == 2 && __GNUC_MINOR__ >= 8
// g++-2.8.x and egcs-1.0.x
# define STL_ALGORITHM <algorithm>
# define STL_FUNCTIONAL <functional>
# define STL_IOMANIP <iomanip>
# define STL_IOSTREAM <iostream>
# define STL_STDEXCEPT <stdexcept>
# define STL_STRING <string>
# define STL_STRSTREAM <strstream>
# define _FG_EXPLICIT_FUNCTION_TMPL_ARGS
# define _FG_NEED_AUTO_PTR
# else
# error Old GNU compilers not yet supported
# endif
#endif
// Microsoft compilers.
#ifdef _MSC_VER
# if _MSC_VER < 1100
# define _FG_NEED_EXPLICIT
# endif
#endif
#ifdef _FG_NEED_EXPLICIT
# define explicit
#endif
#ifdef _FG_NEED_TYPENAME
# define typename
#endif
#ifdef _FG_NEED_BOOL
typedef int bool;
# define true 1
# define false 0
#endif
#ifdef _FG_EXPLICIT_FUNCTION_TMPL_ARGS
# define _FG_NULL_TMPL_ARGS <>
#else
# define _FG_NULL_TMPL_ARGS
#endif
#endif // _FG_STL_CONFIG_H
// $Log$
// Revision 1.1 1998/08/30 14:13:49 curt
// Initial revision. Contributed by Bernie Bright.
//