PEventLoop Class Reference

#include <PEventLoop-es.h>

Public Member Functions
	PEventLoop ()
	This is the standard PEventLoop constructor.
	~PEventLoop ()
	This is the standard pNode destructor.
void	RegisterState (DeviceState *state, const std::string &function, Variant parameters)
void	RegisterEvent (DeviceState *state, const std::string &function, Variant parameters)
void	RemoveState (DeviceState state)
void	RegisterEventTest (DeviceState *state, const std::string function, PList *parameters)
void	RemoveEventTest (DeviceState state)
void	Clear ()
PEvent	Loop ()
	Initiates the looping tests.
PEvent	Loop1 ()
	Initiates the looping tests.
bool	IsLooping ()
	PEventLoop ()
	~PEventLoop ()
void	RegisterState (DeviceState *state, const std::string &function, Variant parameters)
void	RegisterEvent (DeviceState *state, const std::string &function, Variant parameters)
void	RemoveState (DeviceState state)
void	RegisterEventTest (DeviceState *state, const std::string function, PList *parameters)
void	RemoveEventTest (DeviceState state)
void	Clear ()
PEvent	Loop ()
	Initiates the looping tests.
void	Print (std::ostream &out) const

Public Attributes
std::string	mTmp

Protected Attributes
std::vector< DeviceState * >	mStates
std::vector< PNode * >	mNodes
std::vector< Variant >	mFunctionNames
int	mNumStates
std::vector< Variant >	mParameters
std::vector< bool >	mIsEvent

Friends
std::ostream &	operator<< (std::ostream &out, const PEventLoop &loop)
std::ostream &	operator<< (std::ostream &out, const PEventLoop &loop)

Detailed Description

A EventLoop repetitively scans a number of devices for certain pre-specified states, and executes a PEBL function whenever one is true.

Definition at line 46 of file PEventLoop-es.h.

Constructor & Destructor Documentation

PEventLoop() [1/2]

PEventLoop::PEventLoop

(

)

This is the standard PEventLoop constructor.

Definition at line 68 of file PEventLoop-es.cpp.

{
 
    char s[25];
    char* mTmp;
    sprintf(s,"%d",PEBLUtility::Round(PEBLUtility::RandomUniform()*100));
    mTmp = s;
    //cout << "CREATING AN EVENT LOOP " << mTmp << endl;
    //  eloop = this;
    mNumStates = 0;
    mIsLooping = false;
    mCallbackScheduled = false;
    mCallbackNodeStackSize = 0;
}

References mNumStates, mTmp, PEBLUtility::RandomUniform(), and PEBLUtility::Round().

~PEventLoop() [1/2]

PEventLoop::~PEventLoop

(

)

This is the standard pNode destructor.

Definition at line 84 of file PEventLoop-es.cpp.

{
    //cout << "Dstructing veentloop " << mTmp << endl;
    // Standard Destructor
 
}

PEventLoop() [2/2]

PEventLoop::PEventLoop

(

)

~PEventLoop() [2/2]

PEventLoop::~PEventLoop

(

)

Member Function Documentation

Clear() [1/2]

void PEventLoop::Clear

(

)

Definition at line 176 of file PEventLoop-es.cpp.

{
 
    //When the eventloop is Clear()ed, the states should be deleted one-by-one,
    //to avoid a memory leak.
    std::vector<DeviceState*>::iterator i = mStates.begin();
    while(i != mStates.end())
        {
            if(*i) delete *i;
            i++;
        }
 
    mStates.clear();
    mNodes.clear();
    mFunctionNames.clear();
    mParameters.clear();
    mIsEvent.clear();
    mNumStates=0;
    mIsLooping = false;
    //    cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Clearning:\n";
    //    cout << *this << endl;
}

References mFunctionNames, mIsEvent, mNodes, mNumStates, mParameters, and mStates.

Referenced by PEBLEnvironment::ClearEventLoop(), PEBLEnvironment::GetInput0(), Loop(), PEBLEnvironment::PlayMovie(), PEBLEnvironment::Wait(), PEBLEnvironment::WaitForAllKeysUp(), PEBLEnvironment::WaitForAnyKeyDown(), PEBLEnvironment::WaitForAnyKeyDownWithTimeout(), PEBLEnvironment::WaitForAnyKeyPress(), PEBLEnvironment::WaitForAnyKeyPressWithTimeout(), PEBLEnvironment::WaitForKeyDown(), PEBLEnvironment::WaitForKeyListDown(), PEBLEnvironment::WaitForKeyPress(), PEBLEnvironment::WaitForKeyRelease(), PEBLEnvironment::WaitForKeyUp(), PEBLEnvironment::WaitForListKeyPress(), PEBLEnvironment::WaitForListKeyPressWithTimeout(), PEBLEnvironment::WaitForMouseButton(), and PEBLEnvironment::WaitForMouseButtonWithTimeout().

Clear() [2/2]

void PEventLoop::Clear

(

)

IsLooping()

bool PEventLoop::IsLooping ( )

inline

Definition at line 88 of file PEventLoop-es.h.

{return mIsLooping;}

Loop() [1/2]

PEvent PEventLoop::Loop

(

)

Initiates the looping tests.

The following method will initiate an event loop. It will repetitively cycle through each of the devices-events registered and determine if any are satisfied. Whenever one is satisfied, it will follow the directive of that event. It will continue until a STOPEVENTLOOP event is processed.

(myEval->gGlobalVariableMap.RetrieveValue("gKeepLooping"));

Definition at line 207 of file PEventLoop-es.cpp.

{
 
    mIsLooping = true;
 
    unsigned int i, result =0;
    PEvent returnval(PDT_UNKNOWN,0,0);
 
    //Enter a variable into the global variable map.  The loop will exit
    //when this is set false.
    myEval->gGlobalVariableMap.AddVariable("gKeepLooping", 1);
 
    //    cout <<"*****" <<myEval->gGlobalVariableMap.RetrieveValue("gKeepLooping") << "--"<< mStates.size() << std::endl;
 
 
    //Loop until gKeepLooping becomes false
    //In Emscripten, emscripten_sleep() yields to browser between iterations
    while(mNumStates > 0 &&
          (pInt)(myEval->gGlobalVariableMap.RetrieveValue("gKeepLooping")))
    {
        //Process one iteration of event checking
        returnval = Loop1();
 
#ifdef PEBL_ITERATIVE_EVAL
        //If Loop1() scheduled a callback, execute it now
        //The callback schedules 4 nodes initially, but lambdaNode pushes the entire function body
        //Execute until the callback completes (all scheduled nodes consumed)
        if(mCallbackScheduled)
        {
            //Save the node stack size before we scheduled the callback
            //We want to execute until we're back to this size (all callback nodes consumed)
            size_t targetNodeStackSize = mCallbackNodeStackSize;
 
            //Execute nodes until the callback completes
            //Continue until node stack is back to the size it was before we scheduled the callback
            while(!myEval->mNodeStack.empty() &&
                  myEval->mNodeStack.size() > targetNodeStackSize)
            {
                myEval->Evaluate1();  //Process one node from the stack
            }
        }
#endif
 
#ifdef PEBL_EMSCRIPTEN
        // Emscripten: 10ms sleep tied to browser screen refresh
        PEBLEnvironment::myTimer.Sleep(10);
#else
        // Unix/Windows: 1ms sleep via platform-specific implementation
        PEBLEnvironment::myTimer.Sleep(1);
#endif
    }
 
    //Clear the event loop when we're done
    Clear();
 
    return returnval;
}

References VariableMap::AddVariable(), Clear(), Evaluator::Evaluate1(), Evaluator::gGlobalVariableMap, Loop1(), mNumStates, myEval, PEBLEnvironment::myTimer, PDT_UNKNOWN, pInt, VariableMap::RetrieveValue(), and PlatformTimer::Sleep().

Referenced by PEBLEnvironment::GetInput0(), PEBLEnvironment::PlayMovie(), PEBLEnvironment::StartEventLoop(), PEBLEnvironment::Wait(), PEBLEnvironment::WaitForAllKeysUp(), PEBLEnvironment::WaitForAnyKeyDown(), PEBLEnvironment::WaitForAnyKeyDownWithTimeout(), PEBLEnvironment::WaitForAnyKeyPress(), PEBLEnvironment::WaitForAnyKeyPressWithTimeout(), PEBLEnvironment::WaitForKeyDown(), PEBLEnvironment::WaitForKeyListDown(), PEBLEnvironment::WaitForKeyPress(), PEBLEnvironment::WaitForKeyRelease(), PEBLEnvironment::WaitForKeyUp(), PEBLEnvironment::WaitForListKeyPress(), PEBLEnvironment::WaitForListKeyPressWithTimeout(), PEBLEnvironment::WaitForMouseButton(), and PEBLEnvironment::WaitForMouseButtonWithTimeout().

Loop() [2/2]

PEvent PEventLoop::Loop

(

)

Initiates the looping tests.

Loop1()

PEvent PEventLoop::Loop1

(

)

Initiates the looping tests.

Definition at line 282 of file PEventLoop-es.cpp.

{
    PEvent returnval(PDT_UNKNOWN,0,0);
    unsigned int result =0;
    bool matched = false;
 
    //Reset callback flag
    mCallbackScheduled = false;
 
    // Prime the event queue (process pending SDL events)
    gEventQueue->Prime();
 
            //Check event queue events FIRST (keyboard, mouse) so they have priority over timers
            for(int i = 0; i < mNumStates; i++)
                {
                    if(!mIsEvent[i])   //Skip non-event states (timers) in this first pass
                        continue;
 
                    //The test is for an event queue-type event.
                            // Note: 'events' contrast with 'states', handled later.
                            // These are devices which send events through the PEBL Event queue.
                            // So, if the current test is an 'event' state, we need to check the event queue.
 
                            //Only test the event if the queue is not empty.
                            if(!gEventQueue->IsEmpty())
                                {
                                    //Now, we only should test an event if it is the proper device type.
 
                                    if(gEventQueue->GetFirstEventType() == mStates[i]->GetDeviceType())
                                        {
                                            //Now, just test the device.
                                            //I don't think any devices support TestDevice currently.
                                            result = mStates[i]->TestDevice();
                                             
                                            if(result)
                                                {
                                                    returnval = gEventQueue->GetFirstEvent();
 
 
                                                    if(mFunctionNames[i].GetString() != "")  //Execute callback if function name exists
                                                        {
                                                            //Save node stack size before scheduling callback
                                                            mCallbackNodeStackSize = myEval->mNodeStack.size();
 
                                                            //Add the parameters, as a list, to the stack.
                                                            //Need to add the returnval (event) to the parameter list
                                                            //just like the recursive evaluator does in PEventLoop.cpp
 
                                                            Variant parlist = mParameters[i];
 
                                                            const PList *tmp = parlist.GetComplexData()->GetList();
 
                                                            PList * list = new PList(*tmp);
                                                            list->PushBack(Variant(returnval));
 
                                                            counted_ptr<PEBLObjectBase> list2 = counted_ptr<PEBLObjectBase>(list);
                                                            PComplexData * pcd = new PComplexData(list2);  // Heap allocation - will be managed by Variant
 
                                                            
                                                            //Create a DataNode containing the parameter list
                                                            //This will be evaluated by PEBL_FUNCTION and push the list onto the stack
                                                            DataNode * paramsNode = new DataNode(Variant(pcd), "", -1);
 
                                                            //Create a DataNode for the function name
                                                            DataNode * funcNameNode = new DataNode(mFunctionNames[i], "", -1);
 
                                                            //Create PEBL_FUNCTION node with parameter DataNode as right child
                                                            //When PEBL_FUNCTION executes, it will evaluate paramsNode which pushes the parameter list
                                                            OpNode * functionCallNode = new OpNode(PEBL_FUNCTION, (PNode*)funcNameNode, (PNode*)paramsNode, "event-callback", -1);
 
                                                            //Mark that we scheduled a callback (for Loop() to execute)
                                                            mCallbackScheduled = true;
 
                                                            //Schedule nodes to execute the function and pop its return value
 
                                                            //Pop the callback's return value (we don't need it)
                                                            const OpNode * popResult = new OpNode(PEBL_STATEMENTS_TAIL1,NULL,NULL,"event-callback",-1);
                                                            myEval->NodeStackPush(popResult);
 
                                                            //Execute the function call (this will handle all stack management)
                                                            myEval->NodeStackPush(functionCallNode);
 
                                                        }
                                                    else  //If mNodes[i] is null, terminate
                                                        {
 
                                                            //cout << "Stopping the loop.  Donk.\n";
                                                            //We are aborting here.  no need to reprogram anything.
                                                            myEval->gGlobalVariableMap.AddVariable("gKeepLooping", 0);
 
                                                        }
                                                    matched = true;
                                                    break;
                                                }
                                        }
                                }
 
                            //cout << "END Event code\n";
                }
 
            //If no event queue match and queue not empty, pop the non-matching event
            if(!matched && !gEventQueue->IsEmpty())
            {
                gEventQueue->PopEvent();
            }
 
            //If no event queue match, check timer/state events (second pass)
            if(!matched)
            {
                for(int i = 0; i < mNumStates; i++)
                {
                    if(mIsEvent[i])   //Skip event states in this second pass
                        continue;
 
                    //this is where time events (wait) land.
                    //cout << "STATE type\n";
                    //mStates[i] isn't a device-type state.
 
                    //The test examines the device's state directly.
 
                    result = mStates[i]->TestDevice();
                                  if(result)
 
                                {
                                    //We need to create a 'dummy' event to use here.
                                    PEBL_DummyEvent pde;
                                    pde.value = mStates[i]->GetState(mStates[i]->GetInterface());
 
 
                                    if(mStates[i]->GetDevice()->GetDeviceType() == PDT_TIMER)
                                        {
 
                                            returnval = PEvent(PDT_TIMER,0,0);
                                            returnval.SetDummyEvent(pde);
 
                                        }
                                    else if(mStates[i]->GetDevice()->GetDeviceType() == PDT_KEYBOARD)
                                        {
                                            //This is a keyboard state; different from a keypress event!
 
                                            pde.value = (PEBL_Keycode)(mStates[i]->GetInterface());
 
                                            returnval = PEvent(PDT_DUMMY,0,0);
                                            returnval.SetDummyEvent(pde);
 
                                        }
                                    else
                                        {
 
                                            //If this was a time-check event, make a PDT_timer
                                            //time needs to go in  the 0 below.
                                            //returnval = PEvent(PDT_DUMMY,0,0);
 
                                            returnval = PEvent((PEBL_DEVICE_TYPE)pde.value,0,0);
                                            returnval.SetDummyEvent(pde);
                                        }
                                    //If mNodes[i] is null, terminate
 
                                    if(mFunctionNames[i].GetString() != "")  //Execute callback if function name exists
                                        {
                                            //Save node stack size before scheduling callback
                                            mCallbackNodeStackSize = myEval->mNodeStack.size();
 
                                            //Add the parameters, as a list, to the stack.
                                            //Need to add the returnval (event) to the parameter list
                                            //just like the recursive evaluator does in PEventLoop.cpp
 
                                            Variant parlist = mParameters[i];
 
                                            const PList *tmp = parlist.GetComplexData()->GetList();
 
                                            PList * list = new PList(*tmp);
                                            list->PushBack(Variant(returnval));
 
                                            counted_ptr<PEBLObjectBase> list2 = counted_ptr<PEBLObjectBase>(list);
                                            PComplexData * pcd = new PComplexData(list2);  // Heap allocation - will be managed by Variant
 
                                            //Create a DataNode containing the parameter list
                                            //This will be evaluated by PEBL_FUNCTION and push the list onto the stack
                                            DataNode * paramsNode = new DataNode(Variant(pcd), "", -1);
 
                                            //Create a DataNode for the function name
                                            DataNode * funcNameNode = new DataNode(mFunctionNames[i], "", -1);
 
                                            //Create PEBL_FUNCTION node with parameter DataNode as right child
                                            //When PEBL_FUNCTION executes, it will evaluate paramsNode which pushes the parameter list
                                            OpNode * functionCallNode = new OpNode(PEBL_FUNCTION, (PNode*)funcNameNode, (PNode*)paramsNode, "event-callback", -1);
 
                                            //Mark that we scheduled a callback (for Loop() to execute)
                                            mCallbackScheduled = true;
 
                                            //Schedule nodes to execute the function and pop its return value
 
                                            //Pop the callback's return value (we don't need it)
                                            const OpNode * popResult = new OpNode(PEBL_STATEMENTS_TAIL1,NULL,NULL,"event-callback",-1);
                                            myEval->NodeStackPush(popResult);
 
                                            //Execute the function call (this will handle all stack management)
                                            myEval->NodeStackPush(functionCallNode);
 
                                        }
                                    else
                                        {
 
 
                                            myEval->gGlobalVariableMap.AddVariable("gKeepLooping", 0);
 
                                        }
                                    matched = true;
                                    //Don't break - allow other timer states to fire in same iteration
                                    //break;
 
                                } else
                                {
 
                                    //cout << "state test is 0; \n";
                                }
                }  //End second for loop (timer/state events)
            }  //End if(!matched)
 
    // After checking all events, pop matched event queue events
    if(matched && returnval.GetType() != PDT_TIMER)
    {
        //Pop the matched event from queue
        gEventQueue->PopEvent();
    }
 
    // Return the event (or UNKNOWN if no match)
    // The caller (Loop) will call this again to continue checking events
    return returnval;
}

References VariableMap::AddVariable(), Variant::GetComplexData(), PEventQueue::GetFirstEvent(), PEventQueue::GetFirstEventType(), PComplexData::GetList(), PEvent::GetType(), gEventQueue, Evaluator::gGlobalVariableMap, PEventQueue::IsEmpty(), mFunctionNames, mIsEvent, mNumStates, mParameters, mStates, myEval, Evaluator::NodeStackPush(), NULL, PDT_DUMMY, PDT_KEYBOARD, PDT_TIMER, PDT_UNKNOWN, PEventQueue::PopEvent(), PlatformEventQueue::Prime(), PList::PushBack(), PEvent::SetDummyEvent(), and PEBL_DummyEvent::value.

Referenced by Loop().

Print()

void PEventLoop::Print

(

std::ostream &

out

)

const

Definition at line 490 of file PEventLoop.cpp.

{
    out << " ---------------\n";
    out << "Number of states:" <<mStates.size() << endl;
 
}

References mStates.

Referenced by operator<<().

RegisterEvent() [1/2]

void PEventLoop::RegisterEvent	(	DeviceState *	state,
		const std::string &	function,
		Variant	parameters
	)

This function will 'register' a specific event that will be tested for in an event-loop. This allows multiple tests to be registered (time limit, key press, etc.) and tested within a fairly tight compiled loop, without the user having to write his/her own interpreted event loop. This method takes over ownership of the DeviceState, and is responsible for cleaning it up when finished.

Definition at line 141 of file PEventLoop-es.cpp.

{
 
    //    cout << "Regestering...mNumStates:" << mNumStates << endl;
    //    cout << mStates.size() << endl;
    //Add the state to the states list.
    mStates.push_back(state);
    mNumStates++;
    //Make a PNode representing the function. If the function-name is null, push a
    //null PNode onto the vector; this is a short-cut for an end-of-loop event.
    if(function != "")
        {
 
            //Store the function name for later use
            Variant fname = Variant(function.c_str(),P_DATA_FUNCTION);
            mFunctionNames.push_back(fname);
 
            //We don't store any node - we'll handle the function call manually
            mNodes.push_back(NULL);
        }
    else
        {
            mNodes.push_back(NULL);
            mFunctionNames.push_back(Variant(""));
        }
    //Add parameters, for use later.
 
    mParameters.push_back(parameters);
    mIsEvent.push_back(true);
}

References mFunctionNames, mIsEvent, mNodes, mNumStates, mParameters, mStates, NULL, and P_DATA_FUNCTION.

Referenced by PEBLEnvironment::GetInput0(), PEBLEnvironment::PlayMovie(), PEBLEnvironment::RegisterEvent(), PEBLEnvironment::WaitForAnyKeyPress(), PEBLEnvironment::WaitForAnyKeyPressWithTimeout(), PEBLEnvironment::WaitForKeyPress(), PEBLEnvironment::WaitForKeyRelease(), PEBLEnvironment::WaitForListKeyPress(), PEBLEnvironment::WaitForListKeyPressWithTimeout(), PEBLEnvironment::WaitForMouseButton(), and PEBLEnvironment::WaitForMouseButtonWithTimeout().

RegisterEvent() [2/2]

void PEventLoop::RegisterEvent	(	DeviceState *	state,
		const std::string &	function,
		Variant	parameters
	)

RegisterEventTest() [1/2]

void PEventLoop::RegisterEventTest	(	DeviceState *	state,
		const std::string	function,
		PList *	parameters
	)

RegisterEventTest() [2/2]

void PEventLoop::RegisterEventTest	(	DeviceState *	state,
		const std::string	function,
		PList *	parameters
	)

RegisterState() [1/2]

void PEventLoop::RegisterState	(	DeviceState *	state,
		const std::string &	function,
		Variant	parameters
	)

This function will 'register' a specific event that will be tested for in an event-loop. This allows multiple tests to be registered (time limit, key press, etc.) and tested within a fairly tight compiled loop, without the user having to write his/her own interpreted event loop.

Definition at line 97 of file PEventLoop-es.cpp.

{
 
 
    //Add the state to the states list.
    mStates.push_back(state);
    mNumStates++;
    //Make a PNode representing the function. If the function-name is null, push a
    //null PNode onto the vector; this is a short-cut for an end-of-loop event.
    if(function != "")
        {
 
            //Store the function name for later use
            Variant fname = Variant(function.c_str(),P_DATA_FUNCTION);
            mFunctionNames.push_back(fname);
 
            //We don't store any node - we'll handle the function call manually
            mNodes.push_back(NULL);
 
        }
    else
        {
 
            mNodes.push_back(NULL);
            mFunctionNames.push_back(Variant(""));
        }
    //Add parameters, for use later.
    //parameters is passed in as a pointer, and must be attached to a counted pointer
    //if we are to maintain it once the original function is gone.
 
 
    mParameters.push_back(parameters);
    mIsEvent.push_back(false);
}

References mFunctionNames, mIsEvent, mNodes, mNumStates, mParameters, mStates, NULL, and P_DATA_FUNCTION.

Referenced by PEBLEnvironment::PlayMovie(), PEBLEnvironment::RegisterEvent(), PEBLEnvironment::Wait(), PEBLEnvironment::WaitForAllKeysUp(), PEBLEnvironment::WaitForAnyKeyDown(), PEBLEnvironment::WaitForAnyKeyDownWithTimeout(), PEBLEnvironment::WaitForAnyKeyPressWithTimeout(), PEBLEnvironment::WaitForKeyDown(), PEBLEnvironment::WaitForKeyListDown(), PEBLEnvironment::WaitForKeyUp(), PEBLEnvironment::WaitForListKeyPressWithTimeout(), and PEBLEnvironment::WaitForMouseButtonWithTimeout().

RegisterState() [2/2]

void PEventLoop::RegisterState	(	DeviceState *	state,
		const std::string &	function,
		Variant	parameters
	)

RemoveEventTest() [1/2]

void PEventLoop::RemoveEventTest

(

DeviceState

state

)

RemoveEventTest() [2/2]

void PEventLoop::RemoveEventTest

(

DeviceState

state

)

RemoveState() [1/2]

void PEventLoop::RemoveState

(

DeviceState

state

)

RemoveState() [2/2]

void PEventLoop::RemoveState

(

DeviceState

state

)

Friends And Related Symbol Documentation

operator<< [1/2]

std::ostream & operator<< ( std::ostream &  out, const PEventLoop &  loop  )

friend

Definition at line 516 of file PEventLoop-es.cpp.

{
 
    out << "PEBL Event Loop:" << flush;
 
    return out;
}

operator<< [2/2]

std::ostream & operator<< ( std::ostream &  out, const PEventLoop &  loop  )

friend

Definition at line 516 of file PEventLoop-es.cpp.

{
 
    out << "PEBL Event Loop:" << flush;
 
    return out;
}

Member Data Documentation

mFunctionNames

std::vector<Variant> PEventLoop::mFunctionNames

protected

Definition at line 97 of file PEventLoop-es.h.

Referenced by Clear(), Loop1(), RegisterEvent(), and RegisterState().

mIsEvent

std::vector< bool > PEventLoop::mIsEvent

protected

Definition at line 106 of file PEventLoop-es.h.

Referenced by Clear(), Loop1(), RegisterEvent(), and RegisterState().

mNodes

std::vector< PNode * > PEventLoop::mNodes

protected

Definition at line 96 of file PEventLoop-es.h.

Referenced by Clear(), RegisterEvent(), and RegisterState().

mNumStates

int PEventLoop::mNumStates

protected

Definition at line 98 of file PEventLoop-es.h.

Referenced by Clear(), Loop(), Loop1(), PEventLoop(), RegisterEvent(), and RegisterState().

mParameters

std::vector< Variant > PEventLoop::mParameters

protected

Definition at line 100 of file PEventLoop-es.h.

Referenced by Clear(), Loop1(), RegisterEvent(), and RegisterState().

mStates

std::vector< DeviceState * > PEventLoop::mStates

protected

Definition at line 95 of file PEventLoop-es.h.

Referenced by Clear(), Loop1(), Print(), RegisterEvent(), and RegisterState().

mTmp

std::string PEventLoop::mTmp

Definition at line 87 of file PEventLoop-es.h.

Referenced by PEventLoop().

---

The documentation for this class was generated from the following files:

• PEventLoop-es.h
• PEventLoop.h
• PEventLoop-es.cpp
• PEventLoop.cpp