FGFS-4.1/simgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Grrrr.

Browse Source
This commit is contained in:
James Turner 2013-02-09 15:45:36 +00:00
parent a60d293759
commit eac169b6da
2 changed files with 0 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
simgear/structure/commands.cxx~
View File

@ -1,100 +0,0 @@
// commands.cxx - encapsulated commands.
// Started Spring 2001 by David Megginson, david@megginson.com
// This code is released into the Public Domain.
//
// $Id$
#ifdef HAVE_CONFIG_H
# include <simgear_config.h>
#endif
#include <memory>
#include <simgear/props/props_io.hxx>
#include "commands.hxx"
#include <simgear/structure/exception.hxx>
#include <simgear/threads/SGThread.hxx>
#include <simgear/threads/SGGuard.hxx>
#include <simgear/debug/logstream.hxx>
////////////////////////////////////////////////////////////////////////
// Implementation of SGCommandMgr class.
////////////////////////////////////////////////////////////////////////
SGCommandMgr::SGCommandMgr ()
{
// no-op
}
SGCommandMgr::~SGCommandMgr ()
{
// no-op
}
SGMutex SGCommandMgr::_instanceMutex;
SGCommandMgr*
SGCommandMgr::instance()
{
static std::auto_ptr<SGCommandMgr> mgr;
if (mgr.get())
return mgr.get();
SGGuard<SGMutex> lock(_instanceMutex);
if (mgr.get())
return mgr.get();
mgr = std::auto_ptr<SGCommandMgr>(new SGCommandMgr);
return mgr.get();
}
void
SGCommandMgr::addCommand (const std::string &name, Command* command)
{
if (_commands.find(name) != _commands.end())
throw sg_exception("duplicate command name:" + name);
_commands[name] = command;
}
SGCommandMgr::Command*
SGCommandMgr::getCommand (const std::string &name) const
{
const command_map::const_iterator it = _commands.find(name);
return (it != _commands.end() ? it->second : 0);
}
string_list
SGCommandMgr::getCommandNames () const
{
string_list names;
command_map::const_iterator it = _commands.begin();
command_map::const_iterator last = _commands.end();
while (it != last) {
names.push_back(it->first);
++it;
}
return names;
}
bool
SGCommandMgr::execute (const std::string &name, const SGPropertyNode * arg) const
{
Command* command = getCommand(name);
if (command == 0)
return false;
try {
return (*command)(arg);
} catch (sg_exception& e) {
SG_LOG(SG_GENERAL, SG_ALERT, "command '" << name << "' failed with exception\n"
<< "\tmessage:" << e.getMessage() << " (from " << e.getOrigin() << ")");
return false;
}
}
// end of commands.cxx

171
simgear/structure/commands.hxx~
View File

@ -1,171 +0,0 @@
/**
* \file commands.hxx
* Interface definition for encapsulated commands.
* Started Spring 2001 by David Megginson, david@megginson.com
* This code is released into the Public Domain.
*
* $Id$
*/
#ifndef __COMMANDS_HXX
#define __COMMANDS_HXX
#include <simgear/compiler.h>
#include <string>
#include <map>
#include <simgear/threads/SGThread.hxx>
#include <simgear/math/sg_types.hxx>
// forward decls
class SGPropertyNode;
/**
* Manage commands.
*
* <p>This class allows the application to register and unregister
* commands, and provides shortcuts for executing them. Commands are
* simple functions that take a const pointer to an SGPropertyNode:
* the function may use the nodes children as parameters.</p>
*
* @author David Megginson, david@megginson.com
*/
class SGCommandMgr
{
public:
/**
* Command functor object
*/
class Command
{
public:
virtual ~Command() { }
virtual bool operator()(const SGPropertyNode * arg) = 0;
};
typedef bool (*command_t) (const SGPropertyNode * arg);
private:
class FunctionCommand : public Command
{
public:
FunctionCommand( command_t fun )
: f_(fun) {}
virtual bool operator()(const SGPropertyNode * arg) { return (*f_)(arg); }
private:
command_t f_;
};
template< class ObjPtr, typename MemFn >
class MethodCommand : public Command
{
public:
MethodCommand( const ObjPtr& pObj, MemFn pMemFn ) :
pObj_(pObj), pMemFn_(pMemFn) {}
virtual bool operator()(const SGPropertyNode * arg)
{
return ((*pObj_).*pMemFn_)(arg);
}
private:
ObjPtr pObj_;
MemFn pMemFn_;
};
/**
* Helper template functions.
*/
template< class ObjPtr, typename MemFn >
Command* make_functor( const ObjPtr& pObj, MemFn pMemFn )
{
return new MethodCommand<ObjPtr,MemFn>(pObj, pMemFn );
}
public:
/**
* Destructor.
*/
virtual ~SGCommandMgr ();
/**
* Implement the classical singleton.
*/
static SGCommandMgr* instance();
/**
* Register a new command with the manager.
*
* @param name The command name. Any existing command with
* the same name will silently be overwritten.
* @param command A pointer to a one-arg function returning
* a bool result. The argument is always a const pointer to
* an SGPropertyNode (which may contain multiple values).
*/
void addCommand(const std::string& name, command_t f)
{ addCommandObject(name, new FunctionCommand(f); }
void addCommandObject (const std::string &name, Command* command);
template<class OBJ, typename METHOD>
void addCommand(const std::string& name, const OBJ& o, METHOD m)
{
addCommandObject(name, make_functor(o,m));
}
/**
* Look up an existing command.
*
* @param name The command name.
* @return A pointer to the command, or 0 if there is no registered
* command with the name specified.
*/
virtual Command* getCommand (const std::string &name) const;
/**
* Get a list of all existing command names.
*
* @return A (possibly empty) vector of the names of all registered
* commands.
*/
virtual string_list getCommandNames () const;
/**
* Execute a command.
*
* @param name The name of the command.
* @param arg A const pointer to an SGPropertyNode. The node
* may have a value and/or children, etc., so that it is possible
* to pass an arbitrarily complex data structure to a command.
* @return true if the command is present and executes successfully,
* false otherwise.
*/
virtual bool execute (const std::string &name, const SGPropertyNode * arg) const;
protected:
/**
* Default constructor.
*/
SGCommandMgr ();
private:
typedef std::map<std::string,Command*> command_map;
command_map _commands;
static SGMutex _instanceMutex;
};
#endif // __COMMANDS_HXX
// end of commands.hxx