Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/core4/src/core/input/InputManager.cc @ 3288

Last change on this file since 3288 was 3288, checked in by rgrieder, 15 years ago
Finally found a satisfying way to deal with interfaces that deliver information, but only upon virtual call. The solution involves a static variable but any other (and uglier/hackier) solution will do so too. I applied the method the the JoyStickQuantityListener so that the KeyBinder is now independent on the InputManager.
Property svn:eol-style set to `native`
File size: 25.5 KB

Line
1	/*
2	* ORXONOX - the hottest 3D action shooter ever to exist
3	* > www.orxonox.net <
4	*
5	*
6	* License notice:
7	*
8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License
10	* as published by the Free Software Foundation; either version 2
11	* of the License, or (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21	*
22	* Author:
23	* Reto Grieder
24	* Co-authors:
25	* ...
26	*
27	*/
28
29	/**
30	@file
31	@brief
32	Implementation of the InputManager and a static variable from the InputHandler.
33	*/
34
35	#include "InputManager.h"
36
37	#include <cassert>
38	#include <climits>
39	#include <ois/OISException.h>
40	#include <ois/OISInputManager.h>
41	#include <boost/foreach.hpp>
42
43	#include "util/Exception.h"
44	#include "util/ScopeGuard.h"
45	#include "core/Clock.h"
46	#include "core/CoreIncludes.h"
47	#include "core/ConfigValueIncludes.h"
48	#include "core/ConsoleCommand.h"
49	#include "core/CommandLine.h"
50	#include "core/Functor.h"
51
52	#include "InputBuffer.h"
53	#include "KeyDetector.h"
54	#include "JoyStick.h"
55	#include "JoyStickQuantityListener.h"
56	#include "Mouse.h"
57	#include "Keyboard.h"
58
59	namespace orxonox
60	{
61	SetCommandLineSwitch(keyboard_no_grab).information("Whether not to exclusively grab the keyboard");
62
63	// Abuse of this source file for the InputHandler
64	InputHandler InputHandler::EMPTY;
65
66	InputManager* InputManager::singletonRef_s = 0;
67
68	//! Defines the \|= operator for easier use.
69	inline InputManager::State operator\|=(InputManager::State& lval, InputManager::State rval)
70	{
71	return (lval = (InputManager::State)(lval \| rval));
72	}
73
74	//! Defines the &= operator for easier use.
75	inline InputManager::State operator&=(InputManager::State& lval, int rval)
76	{
77	return (lval = (InputManager::State)(lval & rval));
78	}
79
80	// ############################################################
81	// ##### Initialisation #####
82	// ########## ##########
83	// ############################################################
84	InputManager::InputManager(size_t windowHnd, unsigned int windowWidth, unsigned int windowHeight)
85	: internalState_(Bad)
86	, oisInputManager_(0)
87	, devices_(2)
88	, windowHnd_(0)
89	, emptyState_(0)
90	, keyDetector_(0)
91	, calibratorCallbackHandler_(0)
92	{
93	RegisterRootObject(InputManager);
94
95	assert(singletonRef_s == 0);
96	singletonRef_s = this;
97
98	CCOUT(4) << "Constructing..." << std::endl;
99
100	this->setConfigValues();
101
102	this->loadDevices(windowHnd, windowWidth, windowHeight);
103
104	// Lowest priority empty InputState
105	emptyState_ = createInputState("empty", false, false, InputStatePriority::Empty);
106	emptyState_->setHandler(&InputHandler::EMPTY);
107	activeStates_[emptyState_->getPriority()] = emptyState_;
108
109	// KeyDetector to evaluate a pressed key's name
110	InputState* detector = createInputState("detector", false, false, InputStatePriority::Detector);
111	// Create a callback to avoid buttonHeld events after the key has been detected
112	FunctorMember<InputManager>* bufferFunctor = createFunctor(&InputManager::clearBuffers);
113	bufferFunctor->setObject(this);
114	detector->setLeaveFunctor(bufferFunctor);
115	keyDetector_ = new KeyDetector();
116	detector->setHandler(keyDetector_);
117
118	// Joy stick calibration helper callback
119	InputState* calibrator = createInputState("calibrator", false, false, InputStatePriority::Calibrator);
120	calibrator->setHandler(&InputHandler::EMPTY);
121	calibratorCallbackHandler_ = new InputBuffer();
122	calibratorCallbackHandler_->registerListener(this, &InputManager::stopCalibration, '\r', true);
123	calibrator->setKeyHandler(calibratorCallbackHandler_);
124
125	this->updateActiveStates();
126
127	{
128	// calibrate console command
129	FunctorMember<InputManager>* functor = createFunctor(&InputManager::calibrate);
130	functor->setObject(this);
131	this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "calibrate"), true);
132	}
133	{
134	// reload console command
135	FunctorMember<InputManager>* functor = createFunctor(&InputManager::reload);
136	functor->setObject(this);
137	this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "reload"), false);
138	}
139
140	internalState_ = Nothing;
141	CCOUT(4) << "Construction complete." << std::endl;
142	}
143
144	void InputManager::setConfigValues()
145	{
146	}
147
148	/**
149	@brief
150	Creates the OIS::InputMananger, the keyboard, the mouse and
151	the joys ticks. If either of the first two fail, this method throws an exception.
152	@param windowHnd
153	The window handle of the render window
154	@param windowWidth
155	The width of the render window
156	@param windowHeight
157	The height of the render window
158	*/
159	void InputManager::loadDevices(size_t windowHnd, unsigned int windowWidth, unsigned int windowHeight)
160	{
161	CCOUT(3) << "Loading input devices..." << std::endl;
162
163	// When loading the devices they should not already be loaded
164	assert(internalState_ & Bad);
165	assert(devices_[InputDeviceEnumerator::Mouse] == 0);
166	assert(devices_[InputDeviceEnumerator::Keyboard] == 0);
167	assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
168
169	// store handle internally so we can reload OIS
170	windowHnd_ = windowHnd;
171
172	OIS::ParamList paramList;
173	std::ostringstream windowHndStr;
174
175	// Fill parameter list
176	windowHndStr << (unsigned int)windowHnd_;
177	paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
178	#if defined(ORXONOX_PLATFORM_WINDOWS)
179	//paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
180	//paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
181	//paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
182	//paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
183	#elif defined(ORXONOX_PLATFORM_LINUX)
184	paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
185	paramList.insert(std::make_pair(std::string("x11_mouse_grab"), "true"));
186	paramList.insert(std::make_pair(std::string("x11_mouse_hide"), "true"));
187	bool kbNoGrab;
188	CommandLine::getValue("keyboard_no_grab", &kbNoGrab);
189	if (kbNoGrab)
190	paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
191	else
192	paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("true")));
193	#endif
194
195	try
196	{
197	oisInputManager_ = OIS::InputManager::createInputSystem(paramList);
198	// Exception-safety
199	Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, oisInputManager_);
200	CCOUT(ORX_DEBUG) << "Created OIS input manager." << std::endl;
201
202	if (oisInputManager_->getNumberOfDevices(OIS::OISKeyboard) > 0)
203	devices_[InputDeviceEnumerator::Keyboard] = new Keyboard(InputDeviceEnumerator::Keyboard, oisInputManager_);
204	else
205	ThrowException(InitialisationFailed, "InputManager: No keyboard found, cannot proceed!");
206
207	// Successful initialisation
208	guard.Dismiss();
209	}
210	catch (std::exception& ex)
211	{
212	oisInputManager_ = NULL;
213	internalState_ \|= Bad;
214	ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
215	}
216
217	// TODO: Remove the two parameters
218	this->loadMouse(windowWidth, windowHeight);
219	this->loadJoySticks();
220
221	// Reorder states in case some joy sticks were added/removed
222	this->updateActiveStates();
223
224	CCOUT(3) << "Input devices loaded." << std::endl;
225	}
226
227	//! Creates a new orxonox::Mouse
228	void InputManager::loadMouse(unsigned int windowWidth, unsigned int windowHeight)
229	{
230	if (oisInputManager_->getNumberOfDevices(OIS::OISMouse) > 0)
231	{
232	try
233	{
234	devices_[InputDeviceEnumerator::Mouse] = new Mouse(InputDeviceEnumerator::Mouse, oisInputManager_, windowWidth, windowHeight);
235	}
236	catch (const OIS::Exception& ex)
237	{
238	CCOUT(2) << "Warning: Failed to create Mouse:" << ex.eText << std::endl
239	<< "Proceeding without mouse support." << std::endl;
240	}
241	}
242	else
243	CCOUT(ORX_WARNING) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
244	}
245
246	//! Creates as many joy sticks as are available.
247	void InputManager::loadJoySticks()
248	{
249	for (int i = 0; i < oisInputManager_->getNumberOfDevices(OIS::OISJoyStick); i++)
250	{
251	try
252	{
253	devices_.push_back(new JoyStick(InputDeviceEnumerator::FirstJoyStick + i, oisInputManager_));
254	}
255	catch (std::exception ex)
256	{
257	CCOUT(2) << "Warning: Failed to create joy stick: " << ex.what() << std::endl;
258	}
259	}
260
261	// inform all JoyStick Device Number Listeners
262	std::vector<JoyStick*> joyStickList;
263	for (unsigned int i = InputDeviceEnumerator::FirstJoyStick; i < devices_.size(); ++i)
264	joyStickList.push_back(static_cast<JoyStick*>(devices_[i]));
265	JoyStickQuantityListener::changeJoyStickQuantity(joyStickList);
266	}
267
268	void InputManager::setKeyDetectorCallback(const std::string& command)
269	{
270	this->keyDetector_->setCallbackCommand(command);
271	}
272
273	// ############################################################
274	// ##### Destruction #####
275	// ########## ##########
276	// ############################################################
277
278	InputManager::~InputManager()
279	{
280	CCOUT(4) << "Destroying..." << std::endl;
281
282	// Destroy calibrator helper handler and state
283	delete keyDetector_;
284	this->destroyState("calibrator");
285	// Destroy KeyDetector and state
286	delete calibratorCallbackHandler_;
287	this->destroyState("detector");
288	// destroy the empty InputState
289	this->destroyStateInternal(this->emptyState_);
290
291	// destroy all user InputStates
292	while (statesByName_.size() > 0)
293	this->destroyStateInternal((*statesByName_.rbegin()).second);
294
295	if (!(internalState_ & Bad))
296	this->destroyDevices();
297
298	CCOUT(4) << "Destruction complete." << std::endl;
299	singletonRef_s = 0;
300	}
301
302	/**
303	@brief
304	Destoys all input devices (joy sticks, mouse, keyboard and OIS::InputManager)
305	@throw
306	Method does not throw
307	*/
308	void InputManager::destroyDevices()
309	{
310	CCOUT(3) << "Destroying devices..." << std::endl;
311
312	BOOST_FOREACH(InputDevice*& device, devices_)
313	{
314	if (device == NULL)
315	continue;
316	std::string className = device->getClassName();
317	try
318	{
319	delete device;
320	device = 0;
321	CCOUT(4) << className << " destroyed." << std::endl;
322	}
323	catch (...)
324	{
325	CCOUT(1) << className << " destruction failed! Potential resource leak!" << std::endl;
326	}
327	}
328	devices_.resize(InputDeviceEnumerator::FirstJoyStick);
329
330	assert(oisInputManager_ != NULL);
331	try
332	{
333	OIS::InputManager::destroyInputSystem(oisInputManager_);
334	}
335	catch (...)
336	{
337	CCOUT(1) << "OIS::InputManager destruction failed! Potential resource leak!" << std::endl;
338	}
339	oisInputManager_ = NULL;
340
341	internalState_ \|= Bad;
342	CCOUT(3) << "Destroyed devices." << std::endl;
343	}
344
345	// ############################################################
346	// ##### Reloading #####
347	// ########## ##########
348	// ############################################################
349
350	void InputManager::reload()
351	{
352	if (internalState_ & Ticking)
353	{
354	// We cannot destroy OIS right now, because reload was probably
355	// caused by a user clicking on a GUI item. The stack trace would then
356	// include an OIS method. So it would be a very bad thing to destroy it..
357	internalState_ \|= ReloadRequest;
358	}
359	else if (internalState_ & Calibrating)
360	CCOUT(2) << "Warning: Cannot reload input system. Joy sticks are currently being calibrated." << std::endl;
361	else
362	reloadInternal();
363	}
364
365	//! Internal reload method. Destroys the OIS devices and loads them again.
366	void InputManager::reloadInternal()
367	{
368	CCOUT(3) << "Reloading ..." << std::endl;
369
370	// Save mouse clipping size
371	int clippingWidth = 800;
372	int clippingHeight = 600;
373	if (devices_[InputDeviceEnumerator::Mouse])
374	{
375	int clippingWidth = static_cast<Mouse*>(devices_[InputDeviceEnumerator::Mouse])->getClippingWidth();
376	int clippingHeight = static_cast<Mouse*>(devices_[InputDeviceEnumerator::Mouse])->getClippingHeight();
377	}
378
379	this->destroyDevices();
380	this->loadDevices(windowHnd_, clippingWidth, clippingHeight);
381
382	internalState_ &= ~Bad;
383	internalState_ &= ~ReloadRequest;
384	CCOUT(3) << "Reloading complete." << std::endl;
385	}
386
387	// ############################################################
388	// ##### Runtime Methods #####
389	// ########## ##########
390	// ############################################################
391
392	void InputManager::update(const Clock& time)
393	{
394	if (internalState_ & Bad)
395	ThrowException(General, "InputManager was not correctly reloaded.");
396
397	else if (internalState_ & ReloadRequest)
398	reloadInternal();
399
400	// check for states to leave
401	if (!stateLeaveRequests_.empty())
402	{
403	for (std::set<InputState*>::iterator it = stateLeaveRequests_.begin();
404	it != stateLeaveRequests_.end(); ++it)
405	{
406	(*it)->left();
407	// just to be sure that the state actually is registered
408	assert(statesByName_.find((*it)->getName()) != statesByName_.end());
409
410	activeStates_.erase((*it)->getPriority());
411	if ((*it)->getPriority() < InputStatePriority::HighPriority)
412	(*it)->setPriority(0);
413	updateActiveStates();
414	}
415	stateLeaveRequests_.clear();
416	}
417
418	// check for states to enter
419	if (!stateEnterRequests_.empty())
420	{
421	for (std::set<InputState*>::const_iterator it = stateEnterRequests_.begin();
422	it != stateEnterRequests_.end(); ++it)
423	{
424	// just to be sure that the state actually is registered
425	assert(statesByName_.find((*it)->getName()) != statesByName_.end());
426
427	if ((*it)->getPriority() == 0)
428	{
429	// Get smallest possible priority between 1 and maxStateStackSize_s
430	for(std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
431	rit != activeStates_.rend(); ++rit)
432	{
433	if (rit->first < InputStatePriority::HighPriority)
434	{
435	(*it)->setPriority(rit->first + 1);
436	break;
437	}
438	}
439	// In case no normal handler was on the stack
440	if ((*it)->getPriority() == 0)
441	(*it)->setPriority(1);
442	}
443	activeStates_[(it)->getPriority()] = (it);
444	updateActiveStates();
445	(*it)->entered();
446	}
447	stateEnterRequests_.clear();
448	}
449
450	// check for states to destroy
451	if (!stateDestroyRequests_.empty())
452	{
453	for (std::set<InputState*>::iterator it = stateDestroyRequests_.begin();
454	it != stateDestroyRequests_.end(); ++it)
455	{
456	destroyStateInternal((*it));
457	}
458	stateDestroyRequests_.clear();
459	}
460
461	// check whether a state has changed its EMPTY situation
462	bool bUpdateRequired = false;
463	for (std::map<int, InputState*>::iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
464	{
465	if (it->second->hasExpired())
466	{
467	it->second->resetExpiration();
468	bUpdateRequired = true;
469	}
470	}
471	if (bUpdateRequired)
472	updateActiveStates();
473
474	// mark that we now start capturing and distributing input
475	internalState_ \|= Ticking;
476
477	// Capture all the input and handle it
478	BOOST_FOREACH(InputDevice* device, devices_)
479	if (device != NULL)
480	device->update(time);
481
482	// Update the states
483	for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
484	activeStatesTicked_[i]->update(time.getDeltaTime());
485
486	internalState_ &= ~Ticking;
487	}
488
489	/**
490	@brief
491	Updates the currently active states (according to activeStates_) for each device.
492	Also, a list of all active states (no duplicates!) is compiled for the general update().
493	*/
494	void InputManager::updateActiveStates()
495	{
496	// temporary resize
497	for (unsigned int i = 0; i < devices_.size(); ++i)
498	{
499	if (devices_[i] == NULL)
500	continue;
501	std::vector<InputState*>& states = devices_[i]->getStateListRef();
502	bool occupied = false;
503	states.clear();
504	for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin(); rit != activeStates_.rend(); ++rit)
505	{
506	if (rit->second->isInputDeviceEnabled(i) && (!occupied \|\| rit->second->bAlwaysGetsInput_))
507	{
508	states.push_back(rit->second);
509	if (!rit->second->bTransparent_)
510	occupied = true;
511	}
512	}
513	}
514
515	// update tickables (every state will only appear once)
516	// Using a std::set to avoid duplicates
517	std::set<InputState*> tempSet;
518	for (unsigned int i = 0; i < devices_.size(); ++i)
519	if (devices_[i] != NULL)
520	for (unsigned int iState = 0; iState < devices_[i]->getStateListRef().size(); ++iState)
521	tempSet.insert(devices_[i]->getStateListRef()[iState]);
522
523	// copy the content of the std::set back to the actual vector
524	activeStatesTicked_.clear();
525	for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
526	activeStatesTicked_.push_back(*it);
527	}
528
529	void InputManager::clearBuffers()
530	{
531	BOOST_FOREACH(InputDevice* device, devices_)
532	if (device != NULL)
533	device->clearBuffers();
534	}
535
536	void InputManager::calibrate()
537	{
538	COUT(0) << "Move all joy stick axes fully in all directions." << std::endl
539	<< "When done, put the axex in the middle position and press enter." << std::endl;
540
541	BOOST_FOREACH(InputDevice* device, devices_)
542	if (device != NULL)
543	device->startCalibration();
544
545	internalState_ \|= Calibrating;
546	enterState("calibrator");
547	}
548
549	//! Tells all devices to stop the calibration and evaluate it. Buffers are being cleared as well!
550	void InputManager::stopCalibration()
551	{
552	BOOST_FOREACH(InputDevice* device, devices_)
553	if (device != NULL)
554	device->stopCalibration();
555
556	// restore old input state
557	leaveState("calibrator");
558	internalState_ &= ~Calibrating;
559	// Clear buffers to prevent button hold events
560	this->clearBuffers();
561
562	COUT(0) << "Calibration has been stored." << std::endl;
563	}
564
565	// ############################################################
566	// ##### Iput States #####
567	// ########## ##########
568	// ############################################################
569
570	InputState* InputManager::createInputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
571	{
572	if (name == "")
573	return 0;
574	if (statesByName_.find(name) == statesByName_.end())
575	{
576	if (priority >= InputStatePriority::HighPriority \|\| priority == InputStatePriority::Empty)
577	{
578	// Make sure we don't add two high priority states with the same priority
579	for (std::map<std::string, InputState*>::const_iterator it = this->statesByName_.begin();
580	it != this->statesByName_.end(); ++it)
581	{
582	if (it->second->getPriority() == priority)
583	{
584	COUT(2) << "Warning: Could not add an InputState with the same priority '"
585	<< static_cast<int>(priority) << "' != 0." << std::endl;
586	return 0;
587	}
588	}
589	}
590	InputState* state = new InputState(name, bAlwaysGetsInput, bTransparent, priority);
591	statesByName_[name] = state;
592
593	return state;
594	}
595	else
596	{
597	COUT(2) << "Warning: Could not add an InputState with the same name '" << name << "'." << std::endl;
598	return 0;
599	}
600	}
601
602	InputState* InputManager::getState(const std::string& name)
603	{
604	std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
605	if (it != statesByName_.end())
606	return it->second;
607	else
608	return 0;
609	}
610
611	bool InputManager::enterState(const std::string& name)
612	{
613	// get pointer from the map with all stored handlers
614	std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
615	if (it != statesByName_.end())
616	{
617	// exists
618	if (activeStates_.find(it->second->getPriority()) == activeStates_.end())
619	{
620	// not active
621	if (stateDestroyRequests_.find(it->second) == stateDestroyRequests_.end())
622	{
623	// not scheduled for destruction
624	// prevents a state being added multiple times
625	stateEnterRequests_.insert(it->second);
626	return true;
627	}
628	}
629	}
630	return false;
631	}
632
633	bool InputManager::leaveState(const std::string& name)
634	{
635	if (name == "empty")
636	{
637	COUT(2) << "InputManager: Leaving the empty state is not allowed!" << std::endl;
638	return false;
639	}
640	// get pointer from the map with all stored handlers
641	std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
642	if (it != statesByName_.end())
643	{
644	// exists
645	if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
646	{
647	// active
648	stateLeaveRequests_.insert(it->second);
649	return true;
650	}
651	}
652	return false;
653	}
654
655	bool InputManager::destroyState(const std::string& name)
656	{
657	if (name == "empty")
658	{
659	COUT(2) << "InputManager: Removing the empty state is not allowed!" << std::endl;
660	return false;
661	}
662	std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
663	if (it != statesByName_.end())
664	{
665	if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
666	{
667	// The state is still active. We have to postpone
668	stateLeaveRequests_.insert(it->second);
669	stateDestroyRequests_.insert(it->second);
670	}
671	else if (this->internalState_ & Ticking)
672	{
673	// cannot remove state while ticking
674	stateDestroyRequests_.insert(it->second);
675	}
676	else
677	destroyStateInternal(it->second);
678
679	return true;
680	}
681	return false;
682	}
683
684	//! Destroys an InputState internally.
685	void InputManager::destroyStateInternal(InputState* state)
686	{
687	assert(state && !(this->internalState_ & Ticking));
688	std::map<int, InputState*>::iterator it = this->activeStates_.find(state->getPriority());
689	if (it != this->activeStates_.end())
690	{
691	this->activeStates_.erase(it);
692	updateActiveStates();
693	}
694	statesByName_.erase(state->getName());
695	delete state;
696	}
697	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: