自学教程：C++ vprDEBUG函数代码示例

vpr::Uint8 SerialPortImplWin32::getStopBits() const{   vpr::Uint8 num_bits;   DCB dcb;   if ( GetCommState(mHandle, &dcb) )   {      switch ( dcb.StopBits )      {         case ONESTOPBIT:            num_bits = 1;            break;         case TWOSTOPBITS:            num_bits = 2;            break;      }   }   else   {      std::stringstream msg_stream;      msg_stream << "Number of stop bits is unavailable: "                 << getErrorMessageWithCode(GetLastError());      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)         << clrOutBOLD(clrYELLOW, "WARNING") << ": " << msg_stream.str()         << std::endl << vprDEBUG_FLUSH;      throw IOException(msg_stream.str(), VPR_LOCATION);   }   return num_bits;}

// Set the number of stop bits to use.  The value must be either 1 or 2.void SerialPortImplWin32::setStopBits(const vpr::Uint8 numBits){   DCB dcb;   GetCommState(mHandle, &dcb);   switch ( numBits )   {      case 1:         dcb.StopBits = ONESTOPBIT;         break;      case 2:         dcb.StopBits = TWOSTOPBITS;         break;   }   if ( ! SetCommState(mHandle, &dcb) )   {      std::stringstream msg_stream;      msg_stream << "Failed to set stop bits: "                 << getErrorMessageWithCode(GetLastError());      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)         << clrOutBOLD(clrYELLOW, "WARNING") << ": " << msg_stream.str()         << std::endl << vprDEBUG_FLUSH;      throw IOException(msg_stream.str(), VPR_LOCATION);   }}

// Reconfigure the file handle so that writes are synchronous.void FileHandleImplUNIX::setSynchronousWrite(bool sync){#if ! defined(_POSIX_SOURCE) && defined(O_SYNC) && defined(O_ASYNC)   int cur_flags, new_flags, retval;   // Get the current flags.   cur_flags = getFlags();   // Synchronous writes.   if ( sync )   {      new_flags = cur_flags | O_SYNC;   }   // Asynchronous writes.   else   {      new_flags = cur_flags | O_ASYNC;   }   // Set the file descriptor to be blocking with the new flags.   retval = setFlags(new_flags);   if ( retval == -1 )   {      vprDEBUG(vprDBG_ERROR, vprDBG_CRITICAL_LVL)         << "[vpr::FileHandleImplUNIX::setSynchronousWrite()] Failed to enable "         << (sync ? "synchronous" : "asynchronous") << " writes on "         << mName << ": " << strerror(errno) << std::endl << vprDEBUG_FLUSH;      std::ostringstream msg_stream;      msg_stream << "Failed to enable "                 << (sync ? "synchronous" : "asynchronous") << " writes on "                 << mName << ": " << strerror(errno);      throw IOException(msg_stream.str(), VPR_LOCATION);   }#else   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)      << "[vpr::FileHandleImplUNIX::setSynchronousWrite()] Cannot enable "      << (sync ? "synchronous" : "asynchronous")      << " writes on this platform!/n" << vprDEBUG_FLUSH;   std::ostringstream msg_stream;   msg_stream << "Cannot enable " << (sync ? "synchronous" : "asynchronous")              << " writes on this platform!";   throw IOException(msg_stream.str(), VPR_LOCATION);#endif}

void Header::readData(vpr::SocketStream* stream, bool dumpHeader){   vprASSERT( NULL != stream && "Can not create a Header using a NULL SocketStream" );   // - Is stream is a valid SocketStream?   //   - Read in the packet from the socket   //   - Set the BufferObjectReader and BufferObjectWriter to use mData  <====We only need BufferObjectReader   if (NULL == stream)   {      vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )         << clrOutBOLD( clrRED, "ERROR:" )         << " SocketSteam is NULL"         << std::endl << vprDEBUG_FLUSH;      throw cluster::ClusterException("Header::Header() - SocketStream is NULL");   }   vpr::Uint32 bytes_read;      std::vector<vpr::Uint8> header_data;    try   {      bytes_read = stream->readn(header_data, Header::RIM_PACKET_HEAD_SIZE);   }   catch (vpr::IOException& ex)   {      vprDEBUG( gadgetDBG_RIM, vprDBG_CRITICAL_LVL )         << "Header::readData() - Could not read the header!/n"         << ex.what()         << std::endl << vprDEBUG_FLUSH;      throw ex;   }   vprASSERT( RIM_PACKET_HEAD_SIZE == bytes_read && "Header::Header() - Bytes read != RIM_PACKET_HEAD_SIZE" );   parseHeader(header_data);   if(dumpHeader)   {      std::cout << "Dumping Header(" << header_data.size() << " bytes): ";      for ( std::vector<vpr::Uint8>::const_iterator i = header_data.begin();            i != header_data.end(); i++ )      {         std::cout << (int)*i << " ";      }      std::cout << std::endl;   }}

void ConfigPacket::printData(int debugLevel) const{   vprDEBUG_BEGIN(gadgetDBG_RIM,debugLevel)       <<  clrOutBOLD(clrYELLOW,"==== Config Packet Data ====/n") << vprDEBUG_FLUSH;      Packet::printData(debugLevel);   vprDEBUG(gadgetDBG_RIM,debugLevel)       << clrOutBOLD(clrYELLOW, "Config:       ") << mConfig      << std::endl << vprDEBUG_FLUSH;   vprDEBUG(gadgetDBG_RIM,debugLevel)       << clrOutBOLD(clrYELLOW, "Type          ") << mType      << std::endl << vprDEBUG_FLUSH;   vprDEBUG_END(gadgetDBG_RIM,debugLevel)       <<  clrOutBOLD(clrYELLOW,"====================================/n") << vprDEBUG_FLUSH;}

void EventPacket::printData(int debugLevel) const{   vprDEBUG_BEGIN(gadgetDBG_RIM,debugLevel)       <<  clrOutBOLD(clrYELLOW,"==== Event Packet ====/n") << vprDEBUG_FLUSH;      Packet::printData(debugLevel);   vprDEBUG(gadgetDBG_RIM,debugLevel)       << clrOutBOLD(clrYELLOW, "Plugin ID: ") << mPluginId.toString()      << std::endl << vprDEBUG_FLUSH;   vprDEBUG(gadgetDBG_RIM,debugLevel)       << clrOutBOLD(clrYELLOW, "Name: ") << mName      << std::endl << vprDEBUG_FLUSH;   vprDEBUG_END(gadgetDBG_RIM,debugLevel)       <<  clrOutBOLD(clrYELLOW,"============================/n") << vprDEBUG_FLUSH;}

void VRPN_CALLBACK handleAnalogChange(void* userdata, vrpn_ANALOGCB b){   vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL)      << "VRPN driver handleAnalogChange() called/n" << vprDEBUG_FLUSH;   gadget::Vrpn* this_ptr = static_cast<gadget::Vrpn*>(userdata);   this_ptr->analogChange(b);}

char* StringSubjectImpl::getValue()   throw(CORBA::SystemException){   vpr::Guard<vpr::Mutex> val_guard(mValueLock);   vprDEBUG(vprDBG_ALL, vprDBG_STATE_LVL)      << "Returning '" << mValue << "' to caller/n" << vprDEBUG_FLUSH;   return CORBA::string_dup(mValue.c_str());}

void VRPN_CALLBACK handleTrackerChange(void* userdata, vrpn_TRACKERCB t){   vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL)      << "VRPN driver handleTrackerChange() called/n" << vprDEBUG_FLUSH;   gadget::Vrpn* this_ptr = static_cast<gadget::Vrpn*>(userdata);   this_ptr->trackerChange(t);}

bool DataGlove::startSampling(){   vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL)         << "[dataglove] Begin sampling/n"         << vprDEBUG_FLUSH;   bool started(false);   if (mThread == NULL)   {      int maxAttempts=0;      bool result = false;      while (result == false && maxAttempts < 5)      {         vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)               << "[dataglove] Connecting to "               << mPortName << " at "               << mBaudRate << ".../n"               << vprDEBUG_FLUSH;         result = mGlove->connectToHardware( mPortName , mBaudRate);         if (result == false)         {            vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)               << "[dataglove] ERROR: Can't open or it is already opened."               << vprDEBUG_FLUSH;            vpr::System::usleep(14500);            maxAttempts++;         }      }      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)         << "[dataglove] Successfully connected, Now sampling dataglove data."         << vprDEBUG_FLUSH;      // Create a new thread to handle the control and set exit flag to false      mExitFlag = false;      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)         << "[dataglove] Spawning control thread/n" << vprDEBUG_FLUSH;      try      {         mThread = new vpr::Thread(boost::bind(&DataGlove::controlLoop, this));         vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)            << "[dataglove] DataGlove is active " << std::endl            << vprDEBUG_FLUSH;         mActive = true;         started = true;      }      catch (vpr::Exception& ex)      {         vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)            << clrOutBOLD(clrRED, "ERROR")            << ": Failed to spawn thread for 5DT DataGlove driver!/n"            << vprDEBUG_FLUSH;         vprDEBUG_NEXT(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)            << ex.what() << std::endl << vprDEBUG_FLUSH;      }   }   return started;}

bool SdlJoystick::startSampling(){   //return init();   if (!init())   {      vprDEBUG(vprDBG_ERROR,vprDBG_CRITICAL_LVL)         << clrOutNORM(clrRED,"ERROR:")         << " gadget::SdlJoystick::startSampling() SDL init failed./n"         << vprDEBUG_FLUSH;      return false;   }   if(mThread != NULL)   {      vprDEBUG(vprDBG_ERROR,vprDBG_CRITICAL_LVL)         << clrOutNORM(clrRED,"ERROR:")         << " gadget::SdlJoystick::startSampling() called, when already "         << "sampling./n" << vprDEBUG_FLUSH;      return false;   }   // Set flag that will later allow us to stop the control loop.   mDone = false;   bool started(true);   // Create a new thread to handle the control   try   {      mThread = new vpr::Thread(boost::bind(&SdlJoystick::controlLoop,                                this));   }   catch (vpr::Exception& ex)   {      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)         << clrOutBOLD(clrRED, "ERROR")         << ": Failed to spawn thread for SDL Joystick driver!/n"         << vprDEBUG_FLUSH;      vprDEBUG_NEXT(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)         << ex.what() << std::endl << vprDEBUG_FLUSH;      started = false;   }   return started;}

void Node::debugDump(int debug_level){   vpr::DebugOutputGuard dbg_output(gadgetDBG_NET_MGR, debug_level,                              std::string("-------------- Node --------------/n"),                              std::string("-----------------------------------------/n"));   vprDEBUG(gadgetDBG_NET_MGR, debug_level) << "Node Name: "      << mName << std::endl << vprDEBUG_FLUSH;   vprDEBUG(gadgetDBG_NET_MGR, debug_level) << "Hostname:  "      << mHostname << std::endl << vprDEBUG_FLUSH;   vprDEBUG(gadgetDBG_NET_MGR, debug_level) << "Port:      "      << mPort << std::endl << vprDEBUG_FLUSH;   vprDEBUG(gadgetDBG_NET_MGR, debug_level) << "SockStream "      << (NULL == mSockStream ? "is NULL" : "is NOT NULL") << std::endl << vprDEBUG_FLUSH;   if (CONNECTED == getStatus())   {      vprDEBUG(gadgetDBG_NET_MGR, debug_level) << clrOutBOLD(clrGREEN,"CONNECTED") << std::endl << vprDEBUG_FLUSH;   }   else if (NEWCONNECTION == getStatus())   {      vprDEBUG(gadgetDBG_NET_MGR, debug_level) << clrOutBOLD(clrRED,"NEW CONNECTION") << std::endl << vprDEBUG_FLUSH;   }   else   {      vprDEBUG(gadgetDBG_NET_MGR, debug_level) << clrOutBOLD(clrRED,"DISCONNECTED") << std::endl << vprDEBUG_FLUSH;   }}

 void ClusterDelta::receiveResponce() {    getPacket(1);    mAccept = mReader->readBool();    if ( mAccept == false )    {       vprDEBUG(gadgetDBG_RIM,vprDBG_VERB_LVL) << clrOutNORM(clrRED,"[SYNC]FAILED SYNC") << "/n" << vprDEBUG_FLUSH;    } }

void DataGloveUltraWireless::controlLoop(){   vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL)         << "[DataGloveUltraWireless] Entered control thread/n"         << vprDEBUG_FLUSH;   // Go until mDone is set to true   while( !mDone )   {      sample();      vpr::System::msleep(10);   }   vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL)         << "[DataGloveUltraWireless] Exited control thread/n"         << vprDEBUG_FLUSH;}

// Stop sampling.bool MotionStar::stopSampling(){   bool retval;   // If we are not active, we cannot stop the device.   if ( isActive() == false )   {      retval = false;   }   // If the sampling thread was started, stop it and the device.   else if ( mMyThread != NULL )   {      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)         << "Stopping the MotionStar thread .../n" << vprDEBUG_FLUSH;      mExitFlag = true;      mMyThread->join();      delete mMyThread;      mMyThread = NULL;      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)         << "  Stopping the MotionStar .../n" << vprDEBUG_FLUSH;      try      {         mMotionStar.stop();         vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)            << "MotionStar server shut down./n" << vprDEBUG_FLUSH;         retval = true;      }      catch(mstar::CommandException&)      {         vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)            << "MotionStar server did not shut down./n" << vprDEBUG_FLUSH;         retval = false;      }   }   // If the thread was not started, then the device is stopped.   else   {      retval = true;   }   return retval;}

// Reconfigure the file handle so that it is in blocking mode.void FileHandleImplUNIX::setBlocking(bool blocking){   if ( ! mOpen )   {      mOpenBlocking = blocking;   }   else   {      int cur_flags, new_flags;      // Get the current flags.      cur_flags = getFlags();      if ( blocking )      {#ifdef _SGI_SOURCE         // On IRIX, mask FNONBLK and FNDELAY.  We mask FNDELAY to ensure that         // it is not set by the operating system at some level.         new_flags = cur_flags & ~(FNONBLK | FNDELAY);#else         // On everything else, mask O_NONBLOCK and O_NDELAY.  We mask O_NDELAY         // to ensure that it is not set by the operating system at some level.         new_flags = cur_flags & ~(O_NONBLOCK | O_NDELAY);#endif      }      else      {#ifdef _SVR4_SOURCE         // On SysV, set FNONBLK.  We do not set FNDELAY because it just adds         // confusion.  FNONBLK is preferred.         new_flags = cur_flags | FNONBLK;#else         // On everything else, set O_NONBLOCK.  We do not set O_NDELAY because         // it just adds confusion.  O_NONBLOCK is preferred.         new_flags = cur_flags | O_NONBLOCK;#endif      }      // Set the file descriptor to be blocking with the new flags.      if ( setFlags(new_flags) == -1 )      {         vprDEBUG(vprDBG_ERROR, vprDBG_CRITICAL_LVL)            << "[vpr::FileHandleImplUNIX::setBlocking()] Failed to set "            << (blocking ? "blocking" : "non-blocking") << " state on "            << mName << ": " << strerror(errno) << std::endl << vprDEBUG_FLUSH;         throw IOException("[vpr::FileHandleImplUNIX::setBlocking()] Failed to set "            + std::string(blocking ? "blocking" : "non-blocking") + " state on "            + mName + ": " + std::string(strerror(errno)), VPR_LOCATION);      }      else      {         mBlocking = blocking;      }   }}

void X_IST::controlLoop(){   vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_STATE_LVL)      << "[X-IST] Entered control thread/n" << vprDEBUG_FLUSH;// Go until mExitFlag is set to true   while ( ! mExitFlag )   {      sample();   }}

void ApplicationBarrierManager::handlePacket(PacketPtr packet, gadget::NodePtr node){   vprDEBUG(gadgetDBG_RIM, vprDBG_HVERB_LVL)         << clrOutBOLD(clrMAGENTA,"[ApplicationBarrierManager::handlePacket()]")         << "In handlePacket./n" << vprDEBUG_FLUSH;   if ( NULL != packet.get() && NULL != node.get() )   {      switch ( packet->getPacketType() )      {      case cluster::Header::RIM_DATA_PACKET:      {         DataPacketPtr data_packet = boost::dynamic_pointer_cast<DataPacket>(packet);         vprASSERT(NULL != data_packet.get() && "Dynamic cast failed!");         // Find the ApplicationBarrier Object that we have received data         // for.         ApplicationBarrier* barrier =            getApplicationBarrier(data_packet->getObjectId());         if (barrier != NULL)         {            // Parse the object's data using the temporary ObjectReader            barrier->incWaitingNodes();         }         else         {            vprDEBUG(gadgetDBG_RIM,vprDBG_WARNING_LVL)               << clrOutBOLD(clrCYAN,"[ApplicationBarrierManager] ")               << "Got data for an unknown ApplicationBarrier object: "               << data_packet->getObjectId() << std::endl << vprDEBUG_FLUSH;         }         break;      }      default:         vprDEBUG(gadgetDBG_RIM,vprDBG_WARNING_LVL)            << clrOutBOLD(clrCYAN,"[ApplicationBarrierManager] ")            << "Don't know how to handle a packet of type: "            << packet->getPacketType() << std::endl << vprDEBUG_FLUSH;         break;      }   }}

void Vrpn::buttonChange(const vrpn_BUTTONCB& b){   vpr::Guard<vpr::Mutex> g(mButtonMutex);   if ( b.button > mButtonNumber )   {      vprDEBUG(vprDBG_ALL, vprDBG_CONFIG_LVL)         << "Vrpn: button " << b.button         << " out of declared range ("<<mButtons.size()<<")"<<std::endl         << vprDEBUG_FLUSH;      mButtons.resize(b.button + 1);   }   vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_VERB_LVL)      << "Button #" << b.button << " state " << b.state << std::endl      << vprDEBUG_FLUSH;   mButtons[b.button] = static_cast<DigitalState::State>(b.state);}

   /**    * Adds a new plugin to the ClusterManager.    */   void AbstractNetworkManager::addHandler(PacketHandler* new_handler)   {         std::pair<vpr::GUID, PacketHandler*> p             = std::make_pair( new_handler->getHandlerGUID(), new_handler );         mHandlerMap.insert( p );         vprDEBUG( gadgetDBG_NET_MGR, vprDBG_CONFIG_LVL )            << clrOutBOLD( clrMAGENTA, "[Reactor] " )            << "Adding Handler: " << new_handler->getHandlerName() << std::endl << vprDEBUG_FLUSH;   }

vpr::IOSys::Handle FileHandleImplUNIX::getHandle() const{#ifdef VPR_USE_NSPR   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)       << "ERROR: Cannot get handle for UNIX file descriptor with NSPR!/n";   return vpr::IOSys::NullHandle;#else   return mFdesc;#endif}

// Called by the spawn routine to start the user thread function.void ThreadPosix::startThread(){   // WE are a new thread... yeah!!!!   // TELL EVERYONE THAT WE LIVE!!!!   ThreadManager::instance()->lock();      // Lock manager   {      threadIdKey().setspecific((void*)this);  // Store the pointer to me      registerThread(true);                    // Finish thread initialization   }   ThreadManager::instance()->unlock();   // Signal that thread registration is complete.   mThreadStartCondVar.acquire();   {      mThreadStartCompleted = true;      mThreadStartCondVar.signal();   }   mThreadStartCondVar.release();   try   {      emitThreadStart(this);      // --- CALL USER FUNCTOR --- //      mUserThreadFunctor();      emitThreadExit(this);   }   catch (std::exception& ex)   {      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)         << clrOutNORM(clrYELLOW, "WARNING:")         << " Caught an unhandled exception of type " << typeid(ex).name()         << " in thread:" << std::endl         << ex.what() << std::endl << vprDEBUG_FLUSH;      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)         << "Thread exiting due to uncaught exception/n" << vprDEBUG_FLUSH;      mCaughtException = true;      mException.setException(ex);   }}

bool IntersenseAPI::stopSampling(){   // Make sure that we are sampling in the first place.   if (this->isActive() == false)   {      return false;   }   if (mThread != NULL)   {      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)         << "[gadget::IntersenseAPI::stopSampling()] Stopping the InterSense "         << "thread.../n" << vprDEBUG_FLUSH;      // Set the done flag to attempt to cause the control loop to exit      // naturally.      mDone = true;      mThread->join();      delete mThread;      mThread = NULL;      // Close the connection to the tracker      mTracker.close();      // If the tracker failed to stop      if (isActive() == true)      {         vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)            << clrOutNORM(clrRED,"/nERROR:")            << " [gadget::IntersenseAPI::stopSampling()] InterSense tracker "            << "failed to stop./n" << vprDEBUG_FLUSH;         return false;      }      vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CONFIG_LVL)         << "*** IntersenseAPI has been shutdown. ***" << std::endl         << vprDEBUG_FLUSH;   }   return true;}

bool Vrpn::stopSampling(){   if ( NULL != mThread )   {      vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)         << "[Vrpn::stopSampling()] Stopping sample thread" << std::endl         << vprDEBUG_FLUSH;      mExitFlag = true;      // Wait for thread to exit..      mThread->join();      vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)         << "[Vrpn::stopSampling()] Sample thread stopped" << std::endl         << vprDEBUG_FLUSH;      delete mThread;      mThread = NULL;   }   return true;}

/** * kill the sound API, deallocating any sounds, etc... * @postconditions sound API is ready to go. * @semantics this function could be called any time, the function could be *            called multiple times, so it should be smart. */void AudiereSoundImplementation::shutdownAPI(){   if ( this->isStarted() == false )   {      vprDEBUG(snxDBG, vprDBG_CONFIG_LVL)         << clrOutNORM(clrYELLOW, "Auidere| WARNING:")         << "API not started, nothing to shutdown [dev="         << std::hex << mDev.get() << std::dec << "]/n" << vprDEBUG_FLUSH;      return;   }   this->unbindAll();   mDev = NULL;   vprDEBUG(snxDBG, vprDBG_CONFIG_LVL)      << clrOutNORM(clrYELLOW, "Audiere| NOTICE:")      << " Audiere API closed: [dev="      << std::hex << mDev.get() << std::dec << "]/n" << vprDEBUG_FLUSH;}

bool Analog::config(jccl::ConfigElementPtr element){   mMin = element->getProperty<float>("min");   mMax = element->getProperty<float>("max");   vprDEBUG(vprDBG_ALL, vprDBG_VERB_LVL)      << "[gadget::Analog::config()] min:" << mMin      << " max:" << mMax << "/n" << vprDEBUG_FLUSH;   return true;}

//: Start the main functionint SyncIncrementer::start(){    // Create a new thread to handle the control    vpr::Thread* control_thread =        new vpr::Thread(boost::bind(&SyncIncrementer::main, this));    vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL) << "SyncIncrementer::start: Just started main loop.  "            << control_thread << std::endl << vprDEBUG_FLUSH;    return 1;}