gadget::Command Class Reference

Command is the abstract base class for devices that translate spoken commends into integer-identified commands. More...

#include <gadget/Type/Command.h>

Collaboration diagram for gadget::Command:

[legend]List of all members.

Public Types
typedef gadget::SampleBuffer< CommandData >	SampleBuffer_t
Public Member Functions
	Command ()
virtual	~Command ()
virtual bool	config (jccl::ConfigElementPtr e)
const CommandData	getCommandData (int devNum=0)
	Gets the command data for the given devNum.
void	addCommandSample (const std::vector< CommandData > &digSample)
	Helper method to add a collection of command samples to the sample buffers.
void	swapCommandBuffers ()
	Swaps the command data buffers.
const SampleBuffer_t::buffer_t &	getCommandDataBuffer ()
	Returns the current stable sample buffers for this device.
virtual std::string	getInputTypeName ()
virtual vpr::ReturnStatus	writeObject (vpr::ObjectWriter *writer)
	Serializes this object.
virtual vpr::ReturnStatus	readObject (vpr::ObjectReader *reader)
	De-serializes this object.
Protected Member Functions
	Command (const gadget::Command &)
void	operator= (const gadget::Command &)

---

Detailed Description

Command is the abstract base class for devices that translate spoken commends into integer-identified commands.

Drivers for all such devices must derive from this class (through gadget::InputMixer). This is in addition to gadget::Input. gadget::Input provides pure virtual function constraints in the following functions: startSampling(), stopSampling(), sample(), and updateData().

gadget::Command adds the function getCommandData() for retreiving the received commands. This is similar to the additions made by gadget::Position and gadget::Analog.

See also:

Input, InputMixer

Definition at line 68 of file Command.h.

---

Member Typedef Documentation

typedef gadget::SampleBuffer<CommandData> gadget::Command::SampleBuffer_t

Definition at line 71 of file Command.h.

---

Constructor & Destructor Documentation

gadget::Command::Command

(

)

[inline]

Definition at line 75 of file Command.h.

      {
         ;
      }

virtual gadget::Command::~Command

(

)

[inline, virtual]

Definition at line 80 of file Command.h.

      {
         ;
      }

gadget::Command::Command

(

const gadget::Command &

)

[inline, protected]

Definition at line 152 of file Command.h.

         : vpr::SerializableObject()
      {;}

---

Member Function Documentation

virtual bool gadget::Command::config

(

jccl::ConfigElementPtr

e

)

[inline, virtual]

Definition at line 85 of file Command.h.

      {
         boost::ignore_unused_variable_warning(e);
         return true;
      }

const CommandData gadget::Command::getCommandData

(

int

devNum = 0

)

Gets the command data for the given devNum.

Returns:

Command 0 or 1, if devNum makes sense. -1 is returned if function fails or if devNum is out of range.

Note:

If devNum is out of range, function will fail, possibly issuing an error to a log or console - but will not ASSERT.

Definition at line 43 of file Command.cpp.

References gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::stableBuffer().

{
   SampleBuffer_t::buffer_t& stable_buffer = mCommandSamples.stableBuffer();

   if ( (!stable_buffer.empty()) &&
        (stable_buffer.back().size() > (unsigned)devNum) )  // If Have entry && devNum in range
   {
      return stable_buffer.back()[devNum];
   }
   else        // No data or request out of range, return default value
   {
      if ( stable_buffer.empty() )
      {
         vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "WARNING: [gadget::Command::getCommandData()] "
            << "Stable buffer is empty.  If this is not the first "
            << "read, then this is a problem.\n" << vprDEBUG_FLUSH;
      }
      else
      {
         vprDEBUG(vprDBG_ALL, vprDBG_CONFIG_LVL)
            << "WARNING: [gadget::Command::getCommandData()] "
            << "Requested devNum (" << devNum
            << ") is not in the range available.  "
            << "This is probably a configuration error.\n" << vprDEBUG_FLUSH;
      }
      return mDefaultValue;
   }
}

void gadget::Command::addCommandSample

(

const std::vector< CommandData > &

digSample

)

[inline]

Helper method to add a collection of command samples to the sample buffers.

This MUST be called by all command devices to add new samples.

Postcondition:

The given command samples are added to the buffers.

Parameters:

digSample

A vector of CommandData objects that represent the newest samples taken.

Definition at line 111 of file Command.h.

      {
         // Locks and then swaps the indices.
         mCommandSamples.lock();
         mCommandSamples.addSample(digSample);
         mCommandSamples.unlock();
      }

void gadget::Command::swapCommandBuffers

(

)

[inline]

Swaps the command data buffers.

Postcondition:

If the ready queue has values, then those values are copied from the ready queue to the stable queue. If not, then stable queue is not changed.

Definition at line 126 of file Command.h.

      {
         mCommandSamples.swapBuffers();
      }

const SampleBuffer_t::buffer_t& gadget::Command::getCommandDataBuffer

(

)

[inline]

Returns the current stable sample buffers for this device.

Definition at line 134 of file Command.h.

      {
         return mCommandSamples.stableBuffer();
      }

virtual std::string gadget::Command::getInputTypeName

(

)

[inline, virtual]

Definition at line 139 of file Command.h.

Referenced by readObject(), and writeObject().

      {
         return std::string("Command");
      }

vpr::ReturnStatus gadget::Command::writeObject

(

vpr::ObjectWriter *

writer

)

[virtual]

Serializes this object.

Definition at line 73 of file Command.cpp.

References gadget::tokens::BufferSampleLenAttrib(), gadget::tokens::BufferSampleTag(), gadget::tokens::DataTypeAttrib(), gadget::tokens::DigitalValue(), getInputTypeName(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::lock(), gadget::MSG_DATA_COMMAND, gadget::tokens::SampleBufferLenAttrib(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::stableBuffer(), gadget::tokens::TimeStamp(), and gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::unlock().

{
   writer->beginTag(Command::getInputTypeName());
   SampleBuffer_t::buffer_t& stable_buffer = mCommandSamples.stableBuffer();
   writer->beginAttribute(gadget::tokens::DataTypeAttrib);
      // Write out the data type so that we can assert if reading in wrong
      // place.
      writer->writeUint16(MSG_DATA_COMMAND);
   writer->endAttribute();

   writer->beginAttribute(gadget::tokens::SampleBufferLenAttrib);
      // Write the # of vectors in the stable buffer.
      writer->writeUint16(stable_buffer.size());
   writer->endAttribute();

   if ( !stable_buffer.empty() )
   {
      mCommandSamples.lock();
      for ( unsigned j = 0; j < stable_buffer.size(); ++j )                               // For each vector in the stable buffer
      {
         writer->beginTag(gadget::tokens::BufferSampleTag);
         writer->beginAttribute(gadget::tokens::BufferSampleLenAttrib);
            writer->writeUint16(stable_buffer[j].size());                           // Write the # of CommandDatas in the vector
         writer->endAttribute();
         for ( unsigned i = 0; i < stable_buffer[j].size(); ++i )                         // For each CommandData in the vector
         {
            writer->beginTag(gadget::tokens::DigitalValue);
            writer->beginAttribute(gadget::tokens::TimeStamp);
               writer->writeUint64(stable_buffer[j][i].getTime().usec());           // Write Time Stamp vpr::Uint64
            writer->endAttribute();
            writer->writeUint32((vpr::Uint32)stable_buffer[j][i].getDigital());  // Write Command Data(int)
            writer->endTag();
         }
         writer->endTag();
      }
      mCommandSamples.unlock();
   }
   writer->endTag();

   return vpr::ReturnStatus::Succeed;
}

vpr::ReturnStatus gadget::Command::readObject

(

vpr::ObjectReader *

reader

)

[virtual]

De-serializes this object.

Definition at line 115 of file Command.cpp.

References gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::addSample(), gadget::tokens::BufferSampleLenAttrib(), gadget::tokens::BufferSampleTag(), gadget::tokens::DataTypeAttrib(), gadget::tokens::DigitalValue(), getInputTypeName(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::lock(), gadget::MSG_DATA_COMMAND, gadget::tokens::SampleBufferLenAttrib(), gadget::DigitalData::setDigital(), gadget::InputData::setTime(), gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::swapBuffers(), gadget::tokens::TimeStamp(), and gadget::SampleBuffer< DATA_TYPE, MAX_BUFFER_SIZE >::unlock().

{
   vprASSERT(reader->attribExists("rim.timestamp.delta"));
   vpr::Uint64 delta = reader->getAttrib<vpr::Uint64>("rim.timestamp.delta");

      // ASSERT if this data is really not Command Data
   reader->beginTag(Command::getInputTypeName());
   reader->beginAttribute(gadget::tokens::DataTypeAttrib);
      vpr::Uint16 temp = reader->readUint16();
   reader->endAttribute();

   // XXX: Should there be error checking for the case when vprASSERT()
   // is compiled out?  -PH 8/21/2003
   vprASSERT(temp==MSG_DATA_COMMAND && "[Remote Input Manager]Not Command Data");
   boost::ignore_unused_variable_warning(temp);

   std::vector<CommandData> dataSample;

   unsigned numCommandDatas;
   vpr::Uint32 value;
   vpr::Uint64 timeStamp;
   CommandData temp_command_data;

   reader->beginAttribute(gadget::tokens::SampleBufferLenAttrib);
      unsigned numVectors = reader->readUint16();
   reader->endAttribute();

   mCommandSamples.lock();
   for ( unsigned i = 0; i < numVectors; ++i )
   {
      reader->beginTag(gadget::tokens::BufferSampleTag);
      reader->beginAttribute(gadget::tokens::BufferSampleLenAttrib);
         numCommandDatas = reader->readUint16();
      reader->endAttribute();

      dataSample.clear();
      for ( unsigned j = 0; j < numCommandDatas; ++j )
      {
         reader->beginTag(gadget::tokens::DigitalValue);
         reader->beginAttribute(gadget::tokens::TimeStamp);
            timeStamp = reader->readUint64();    // read Time Stamp vpr::Uint64
         reader->endAttribute();
         value = reader->readUint32();           // read Command Data(int)
         reader->endTag();

         temp_command_data.setDigital(value);
         temp_command_data.setTime(vpr::Interval(timeStamp + delta,vpr::Interval::Usec));
         dataSample.push_back(temp_command_data);
      }
      mCommandSamples.addSample(dataSample);
      reader->endTag();
   }
   mCommandSamples.unlock();
   mCommandSamples.swapBuffers();

   reader->endTag();

   return vpr::ReturnStatus::Succeed;
}

void gadget::Command::operator=

(

const gadget::Command &

)

[inline, protected]

Definition at line 156 of file Command.h.

{;}

---

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

• Command.h
• Command.cpp

---