Error spotted by Clement with Opie::Core and namespaces

4 files changed, 4 insertions, 5 deletions

diff --git a/noncore/net/opietooth/lib/device.cc b/noncore/net/opietooth/lib/device.cc
index 18d26e4..04c50d9 100644
--- a/noncore/net/opietooth/lib/device.cc
+++ b/noncore/net/opietooth/lib/device.cc
@@ -1,152 +1,152 @@
 
 #include <signal.h>
 
 #include <opie2/oprocess.h>
 
 #include "device.h"
 
 using namespace OpieTooth;
 
-using namespace Opie::Core;
+using Opie::Core::OProcess;
 namespace {
   int parsePid( const QCString& par ){
     int id=0;
     QString string( par );
     QStringList list =  QStringList::split( '\n', string );
     for( QStringList::Iterator it = list.begin(); it != list.end(); ++it ){
     qWarning("parsePID: %s", (*it).latin1() );
       if( !(*it).startsWith("CSR") ){
 	id = (*it).toInt();
 	break;
       }
     }
     return id;
   }
 }
 
 Device::Device(const QString &device, const QString &mode, const QString &speed )
   : QObject(0, "device") {
 
   qWarning("OpieTooth::Device create" );
   m_hci = 0;
   m_process = 0;
   m_attached = false;
   m_device = device;
   m_mode = mode;
   m_speed = speed;
   attach();
 }
 Device::~Device(){
   detach();
 }
 void Device::attach(){
   qWarning("attaching %s %s %s", m_device.latin1(), m_mode.latin1(), m_speed.latin1() );
   if(m_process == 0 ){
     m_output.resize(0);
     qWarning("new process to create" );
     m_process = new OProcess();
     *m_process << "hciattach";
     *m_process << "-p";
     *m_process << m_device << m_mode << m_speed;
     connect(m_process, SIGNAL( processExited(Opie::Core::OProcess*) ),
             this, SLOT( slotExited(Opie::Core::OProcess* ) ) );
     connect(m_process, SIGNAL( receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotStdOut(Opie::Core::OProcess*,char*,int ) ) );
     connect(m_process, SIGNAL(receivedStderr(Opie::Core::OProcess*, char*, int ) ),
             this, SLOT(slotStdErr(Opie::Core::OProcess*,char*,int) ) );
     if(!m_process->start(OProcess::NotifyOnExit, OProcess::AllOutput ) ){
       qWarning("Could not start" );
       delete m_process;
       m_process = 0;
     }
   };
 }
 void Device::detach(){
   delete m_hci;
   delete m_process;
   // kill the pid we got
   if(m_attached ){
     //kill the pid
     qWarning( "killing" );
     kill(pid, 9);
   }
   qWarning("detached" );
 }
 bool Device::isLoaded()const{
   return m_attached;
 }
 QString Device::devName()const {
   return QString::fromLatin1("hci0");
 };
 void Device::slotExited( OProcess* proc)
 {
   qWarning("prcess exited" );
   if(proc== m_process ){
     qWarning("proc == m_process" );
     if( m_process->normalExit() ){ // normal exit
       qWarning("normalExit" );
       int ret = m_process->exitStatus();
       if( ret == 0 ){ // attached
 	qWarning("attached" );
 	qWarning("Output: %s", m_output.data() );
 	pid = parsePid( m_output );
 	qWarning("Pid = %d", pid );
 	// now hciconfig hci0 up ( determine hciX FIXME)
 	// and call hciconfig hci0 up
 	// FIXME hardcoded to hci0 now :(
 	m_hci = new OProcess( );
 	*m_hci << "hciconfig";
 	*m_hci << "hci0 up";
 	connect(m_hci, SIGNAL( processExited(Opie::Core::OProcess*) ),
                 this, SLOT( slotExited(Opie::Core::OProcess* ) ) );
 	if(!m_hci->start() ){
 	  qWarning("could not start" );
 	  m_attached = false;
 	  emit device("hci0", false );
 	}
       }else{
         qWarning("crass" );
 	m_attached = false;
 	emit device("hci0", false );
 
       }
     }
     delete m_process;
     m_process = 0;
   }else if(proc== m_hci ){
     qWarning("M HCI exited" );
     if( m_hci->normalExit() ){
       qWarning("normal exit" );
       int ret = m_hci->exitStatus();
       if( ret == 0 ){
 	qWarning("attached really really attached" );
 	m_attached = true;
 	emit device("hci0", true );
       }else{
 	qWarning( "failed" );
 	emit device("hci0", false );
 	m_attached = false;
       }
     }// normal exit
     delete m_hci;
     m_hci = 0;
   }
 }
 void Device::slotStdOut(OProcess* proc, char* chars, int len)
 {
   qWarning("std out" );
   if( len <1 ){
     qWarning( "len < 1 " );
     return;
   }
   if(proc == m_process ){
     QCString string( chars, len+1 ); // \0 == +1
     qWarning("output: %s", string.data() );
     m_output.append( string.data() );
   }
 }
 void Device::slotStdErr(OProcess* proc, char* chars, int len)
 {
   qWarning("std err" );
   slotStdOut( proc, chars, len );
 }
diff --git a/noncore/net/opietooth/lib/device.h b/noncore/net/opietooth/lib/device.h
index f3339fc..3631c97 100644
--- a/noncore/net/opietooth/lib/device.h
+++ b/noncore/net/opietooth/lib/device.h
@@ -1,88 +1,88 @@
 
 #ifndef OpieToothDevice_H
 #define OpieToothDevice_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qvaluelist.h>
 
 #include <sys/types.h>
 
-namespace Opie {namespace Core {class Opie::Core::OProcess;}}
+namespace Opie {namespace Core {class OProcess;}}
 namespace OpieTooth {
     /**
      *  Device takes care of attaching serial
      *  devices to the blueZ stack.
      *  After attaching it hciconfig ups it
      */
     class Device : public QObject {
 
         Q_OBJECT
 
     public:
 
     /**
      * Brings up an device.
      * Usage example: new Device(/dev/ttySB0, csr)
      *
      * @param &device QString the device name
      * @param &mode QString the mode
      * @param &speed QString the speed of the device, can be left blank
      */
     Device(const QString &device, const QString& mode, const QString& speed);
 
         /**
          * unloads the device
          */
         ~Device();
 
         /**
          * attach the device
          */
         void attach();
 
         /**
          * detach the device
          */
         void detach();
 
         /**
          * Is the device loaded?
          * @return bool, if the device is loaded
 	 */
         bool isLoaded()const;
 
         /**
          * Returns the device name
          * @return QString, the device name
          */
         QString devName()const ; // hci0
 
     signals:
 
         /**
          * Signals devicename and up status
          * @return &device QString, Devicename
          * @return up bool, if the device is up or not.
          */
         void device(const QString& device, bool up );
     private slots:
         virtual void slotExited( Opie::Core::OProcess* );
         virtual void slotStdOut(Opie::Core::OProcess*, char*, int );
 	virtual void slotStdErr(Opie::Core::OProcess*, char*, int );
     private:
 	class Private;
 	Private *d;
 	QString m_device;
 	bool m_attached:1;
 	Opie::Core::OProcess* m_hci;
 	Opie::Core::OProcess* m_process;
 	QString m_devId;
 	QString m_mode;
         QString m_speed;
 	pid_t pid;
 	QCString m_output;
     };
 };
 
 #endif
diff --git a/noncore/net/opietooth/lib/manager.cc b/noncore/net/opietooth/lib/manager.cc
index 7c9ea5b..18e1df9 100644
--- a/noncore/net/opietooth/lib/manager.cc
+++ b/noncore/net/opietooth/lib/manager.cc
@@ -1,336 +1,335 @@
 
 
 #include <opie2/oprocess.h>
 
 #include "parser.h"
 #include "manager.h"
 
 
 using namespace OpieTooth;
 
-using namespace Opie::Core;
-using namespace Opie::Core;
+using Opie::Core::OProcess;
 Manager::Manager( const QString& dev )
   : QObject()
 {
     qWarning("created");
     m_device = dev;
     m_hcitool = 0;
     m_sdp = 0;
 }
 Manager::Manager( Device* /*dev*/ )
   : QObject()
 {
     m_hcitool = 0;
     m_sdp = 0;
 }
 Manager::Manager()
   : QObject()
 {
     m_hcitool = 0;
     m_sdp = 0;
 }
 Manager::~Manager(){
     delete m_hcitool;
     delete m_sdp;
 }
 void Manager::setDevice( const QString& dev ){
     m_device = dev;
 }
 void Manager::setDevice( Device* /*dev*/ ){
 
 }
 void Manager::isAvailable( const QString& device ){
     OProcess* l2ping = new OProcess();
     l2ping->setName( device.latin1() );
     *l2ping << "l2ping" << "-c1" << device;
     connect(l2ping, SIGNAL(processExited(Opie::Core::OProcess* ) ),
             this, SLOT(slotProcessExited(Opie::Core::OProcess*) ) );
     if (!l2ping->start() ) {
         emit available( device,  false );
         delete l2ping;
     }
 
 }
 
 void Manager::isAvailable( Device* /*dev*/ ){
 
 
 }
 void Manager::searchDevices( const QString& device ){
     qWarning("search devices");
     OProcess* hcitool = new OProcess();
     hcitool->setName( device.isEmpty() ? "hci0" : device.latin1() );
     *hcitool << "hcitool" << "scan";
     connect( hcitool, SIGNAL(processExited(Opie::Core::OProcess*) ) ,
              this, SLOT(slotHCIExited(Opie::Core::OProcess* ) ) );
     connect( hcitool, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int ) ),
              this, SLOT(slotHCIOut(Opie::Core::OProcess*, char*, int ) ) );
     if (!hcitool->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         qWarning("could not start");
         RemoteDevice::ValueList list;
         emit foundDevices( device, list );
         delete hcitool;
     }
 }
 
 void Manager::searchDevices(Device* /*d*/ ){
 
 
 }
 void Manager::addService(const QString& name ){
     OProcess proc;
     proc << "sdptool" << "add" << name;
     bool bo = true;
     if (!proc.start(OProcess::DontCare ) )
         bo = false;
     emit addedService( name,  bo );
 }
 void Manager::addServices(const QStringList& list){
     QStringList::ConstIterator it;
     for (it = list.begin(); it != list.end(); ++it )
         addService( (*it) );
 }
 void Manager::removeService( const QString& name ){
     OProcess prc;
     prc << "sdptool" << "del" << name;
     bool bo = true;
     if (!prc.start(OProcess::DontCare ) )
         bo = false;
     emit removedService( name,  bo );
 }
 void Manager::removeServices( const QStringList& list){
     QStringList::ConstIterator it;
     for (it = list.begin(); it != list.end(); ++it )
         removeService( (*it) );
 }
 void Manager::searchServices( const QString& remDevice ){
     OProcess *m_sdp =new OProcess();
     *m_sdp << "sdptool" << "browse" << remDevice;
     m_sdp->setName( remDevice.latin1() );
     qWarning("search Services for %s", remDevice.latin1() );
     connect(m_sdp, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotSDPExited(Opie::Core::OProcess* ) ) );
     connect(m_sdp, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*,  int ) ),
             this, SLOT(slotSDPOut(Opie::Core::OProcess*, char*, int) ) );
     if (!m_sdp->start(OProcess::NotifyOnExit,  OProcess::AllOutput) ) {
         qWarning("could not start sdptool" );
         delete m_sdp;
         Services::ValueList list;
         emit foundServices( remDevice, list );
     }
 }
 void Manager::searchServices( const RemoteDevice& dev){
     searchServices( dev.mac() );
 }
 QString Manager::toDevice( const QString& /*mac*/ ){
     return QString::null;
 }
 QString Manager::toMac( const QString &/*device*/ ){
     return QString::null;
 }
 void Manager::slotProcessExited(OProcess* proc ) {
     bool conn= false;
     if (proc->normalExit() && proc->exitStatus() == 0 )
         conn = true;
 
     QString name = QString::fromLatin1(proc->name() );
     emit available( name, conn );
     delete proc;
 }
 void Manager::slotSDPOut(OProcess* proc, char* ch, int len)
 {
     QCString str(ch,  len+1 );
     qWarning("SDP:%s", str.data() );
     QMap<QString, QString>::Iterator it;
     it = m_out.find(proc->name() );
     QString string;
     if ( it != m_out.end() ) {
         string = it.data();
     }
     string.append( str );
     m_out.replace( proc->name(), string );
 
 }
 void Manager::slotSDPExited( OProcess* proc)
 {
     qWarning("proc name %s", proc->name() );
     Services::ValueList  list;
     if (proc->normalExit()  ) {
         QMap<QString, QString>::Iterator it = m_out.find( proc->name() );
         if ( it != m_out.end() ) {
 	    qWarning("found process" );
             list = parseSDPOutput( it.data() );
             m_out.remove( it );
         }
     }
     emit foundServices( proc->name(), list );
     delete proc;
 }
 Services::ValueList Manager::parseSDPOutput( const QString& out ) {
     Services::ValueList list;
     qWarning("parsing output" );
     Parser parser( out );
     list = parser.services();
     return list;
 }
 
 void Manager::slotHCIExited(OProcess* proc ) {
     qWarning("process exited");
     RemoteDevice::ValueList list;
     if (proc->normalExit() ) {
         qWarning("normalExit %s",  proc->name() );
         QMap<QString, QString>::Iterator it = m_devices.find(proc->name() );
         if (it != m_devices.end() ) {
             qWarning("!= end ;)");
             list = parseHCIOutput( it.data() );
             m_devices.remove( it );
         }
     }
     emit foundDevices( proc->name(), list );
     delete proc;
 }
 void Manager::slotHCIOut(OProcess* proc,  char* ch,  int len) {
     QCString str( ch, len+1 );
     qWarning("hci: %s",  str.data() );
     QMap<QString, QString>::Iterator it;
     it = m_devices.find( proc->name() );
     qWarning("proc->name %s", proc->name() );
     QString string;
     if (it != m_devices.end() ) {
         qWarning("slotHCIOut ");
         string = it.data();
     }
     string.append( str );
 
     m_devices.replace( proc->name(),  string );
 }
 RemoteDevice::ValueList Manager::parseHCIOutput(const QString& output ) {
     qWarning("parseHCI %s",  output.latin1() );
     RemoteDevice::ValueList list;
     QStringList strList = QStringList::split('\n',  output );
     QStringList::Iterator it;
     QString str;
     for ( it = strList.begin(); it != strList.end(); ++it ) {
         str = (*it).stripWhiteSpace();
         qWarning("OpieTooth %s", str.latin1() );
         int pos = str.findRev(':' );
         if ( pos > 0 ) {
             QString mac = str.left(17 );
             str.remove( 0,  17 );
             qWarning("mac %s",  mac.latin1() );
             qWarning("rest:%s",  str.latin1() );
             RemoteDevice rem( mac , str.stripWhiteSpace() );
             list.append( rem );
         }
     }
     return list;
 }
 
 ////// hcitool cc and hcitool con
 
 /**
  * Create it on the stack as don't care
  * so we don't need to care for it
  * cause hcitool gets reparented
  */
 void Manager::connectTo( const QString& mac) {
     OProcess proc;
     proc << "hcitool";
     proc << "cc";
     proc << mac;
     proc.start(OProcess::DontCare); // the lib does not care at this point
 }
 
 
 void Manager::searchConnections() {
     qWarning("searching connections?");
     OProcess* proc = new OProcess();
     m_hcitoolCon = QString::null;
 
     connect(proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotConnectionExited( Opie::Core::OProcess*) ) );
     connect(proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotConnectionOutput(Opie::Core::OProcess*, char*, int) ) );
     *proc << "hcitool";
     *proc << "con";
 
     if (!proc->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         ConnectionState::ValueList list;
         emit connections( list  );
         delete proc;
     }
 }
 void Manager::slotConnectionExited( OProcess* proc ) {
     ConnectionState::ValueList list;
     list = parseConnections( m_hcitoolCon );
     emit connections(list );
     delete proc;
 }
 void Manager::slotConnectionOutput(OProcess* /*proc*/, char* cha, int len) {
     QCString str(cha, len );
     m_hcitoolCon.append( str );
     //delete proc;
 }
 ConnectionState::ValueList Manager::parseConnections( const QString& out ) {
     ConnectionState::ValueList list2;
     QStringList list = QStringList::split('\n',  out );
     QStringList::Iterator it;
     // remove the first line ( "Connections:")
     it = list.begin();
     it = list.remove( it );
     for (; it != list.end(); ++it ) {
         QString row = (*it).stripWhiteSpace();
         QStringList value = QStringList::split(' ', row );
         qWarning("0: %s", value[0].latin1() );
         qWarning("1: %s", value[1].latin1() );
         qWarning("2: %s", value[2].latin1() );
         qWarning("3: %s", value[3].latin1() );
         qWarning("4: %s", value[4].latin1() );
         qWarning("5: %s", value[5].latin1() );
         qWarning("6: %s", value[6].latin1() );
         qWarning("7: %s", value[7].latin1() );
         qWarning("8: %s", value[8].latin1() );
         ConnectionState con;
         con.setDirection( value[0] == QString::fromLatin1("<") ? Outgoing : Incoming );
         con.setConnectionMode( value[1] );
         con.setMac( value[2] );
         con.setHandle( value[4].toInt() );
         con.setState( value[6].toInt() );
         con.setLinkMode( value[8] == QString::fromLatin1("MASTER") ? Master : Client );
         list2.append( con );
     }
     return list2;
 }
 
 void Manager::signalStrength( const QString &mac ) {
 
     OProcess* sig_proc = new OProcess();
 
     connect(sig_proc, SIGNAL(processExited(Opie::Core::OProcess*) ),
             this, SLOT(slotSignalStrengthExited( Opie::Core::OProcess*) ) );
     connect(sig_proc, SIGNAL(receivedStdout(Opie::Core::OProcess*, char*, int) ),
             this, SLOT(slotSignalStrengthOutput(Opie::Core::OProcess*, char*, int) ) );
     *sig_proc << "hcitool";
     *sig_proc << "lq";
     *sig_proc << mac;
 
     sig_proc->setName( mac.latin1() );
 
     if (!sig_proc->start(OProcess::NotifyOnExit, OProcess::AllOutput) ) {
         emit signalStrength( mac, "-1" );
         delete sig_proc;
     }
 }
 
 void Manager::slotSignalStrengthOutput(OProcess* proc, char* cha, int len) {
     QCString str(cha, len );
     QString temp = QString(str).stripWhiteSpace();
     QStringList value = QStringList::split(' ', temp );
     emit signalStrength( proc->name(), value[2].latin1() );
 }
 
 
 void Manager::slotSignalStrengthExited( OProcess* proc ) {
      delete proc;
 }
diff --git a/noncore/net/opietooth/lib/manager.h b/noncore/net/opietooth/lib/manager.h
index 9b1c714..930eb56 100644
--- a/noncore/net/opietooth/lib/manager.h
+++ b/noncore/net/opietooth/lib/manager.h
@@ -1,173 +1,173 @@
 
 #ifndef OpieToothManager_H
 #define OpieToothManager_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qmap.h>
 #include <qvaluelist.h>
 
 #include "connection.h"
 #include "remotedevice.h"
 #include "services.h"
 
-namespace Opie {namespace Core {class Opie::Core::OProcess;}}
+namespace Opie {namespace Core {class OProcess;}}
 namespace OpieTooth {
     class Device;
     /** Manager manages a blueZ device (hci0 for example)
      *  without Manager you can control the things you
      *  could do from command line in a OO and asynchronus
      *  way.
      */
     class Manager : public QObject {
         Q_OBJECT
     public:
         /** c'tor whichs create a new Manager
          *  @param device is the device to use. Either a mac or blueZ device name
          *
          */
         Manager( const QString &device );
 
         /** c'tor
          * @param dev The Device to be managed
          * We don't care of Device so you need to delete it
          */
         Manager( Device* dev );
 
         /**
          * c'tor
          */
         Manager();
 
         ~Manager();
 
         /** Set the manager to control a new device
          *  @param device the new device to control (hci0 )
          */
         void setDevice( const QString& device );
 
         /**
          * Convience functions for setting a new device
          */
         void setDevice( Device *dev );
 
         /**
          * Wether or not a device is connected. The function
          * is asynchron
          * If device is empty it will take the currently managed
          * device and see if it's up
          * for Remote devices it will ping and see.
          * @param either mac or hciX
          */
         void isAvailable(const QString& device= QString::null );
 
         /**
          * same as above
          */
         void isAvailable(Device *dev );
 
         /** this searchs for devices reachable from the
          *  currently managed device
          *  or from device if @param device is not empty
          */
         void searchDevices(const QString& device= QString::null );
         /** same as above
          *
          */
         void searchDevices(Device *d );
 
         /**
          * This will add the service @param name
          * to the sdpd daemon
          * It will start the daemon if necessary
          */
         void addService(const QString &name );
 
         /**
          * This will add the services @param names
          * to the sdpd daemon
          * It will start the daemon if necessary
          */
         void addServices( const QStringList& names );
 
         /**
          * This removes a service from the sdps
          */
         void removeService(const QString &name );
 
         /**
          * Removes a list from the sdpd
          */
         void removeServices(const QStringList& );
 
         /**
          * search for services on a remote device
          *
          */
         void searchServices( const QString& remDevice );
 
         /**
          * search for services on a remote device
          */
         void searchServices( const RemoteDevice& );
 
         /**
          * Starts to connect to the device
          * in @param
          */
         void connectTo(const QString& );
 
         /**
          * Searches for active connections
          * the result is emitted with the
          * connections signal
          */
         void searchConnections();
 
 	void signalStrength( const QString &mac );
 //// not implemented yet
         /*static*/ QString toDevice( const QString& mac );
         /*static*/ QString toMac( const QString &device );
 //// not implemented yet over
 
     signals:
         // device either mac or dev name
         // the first device is the device which you access
         void available( const QString& device, bool connected );
         void addedService(  const QString& service, bool added );
         void removedService( const QString& service, bool removed );
         void foundServices( const QString& device, Services::ValueList );
         void foundDevices( const QString& device, RemoteDevice::ValueList );
         void connections( ConnectionState::ValueList );
 	void signalStrength( const QString& mac, const QString& strengh );
 
 private slots:
         void slotProcessExited(Opie::Core::OProcess* );
 
         void slotSDPExited(Opie::Core::OProcess*);
         void slotSDPOut(Opie::Core::OProcess*, char*, int);
 
         void slotHCIExited(Opie::Core::OProcess* );
         void slotHCIOut(Opie::Core::OProcess*, char*, int );
 
         void slotConnectionExited(Opie::Core::OProcess* );
         void slotConnectionOutput(Opie::Core::OProcess*, char*, int );
 
 	void slotSignalStrengthOutput( Opie::Core::OProcess*, char*, int );
 	void slotSignalStrengthExited( Opie::Core::OProcess* );
     private:
         Services::ValueList parseSDPOutput( const QString& );
         RemoteDevice::ValueList parseHCIOutput( const QString& );
         ConnectionState::ValueList parseConnections( const QString& );
         Opie::Core::OProcess *m_hcitool;
         Opie::Core::OProcess *m_sdp; // not only one
         QString m_device;
 	QMap<QString, int> m_signalStrength;
         QMap<QString, QString> m_out;
         QMap<QString, QString> m_devices;
 	QMap<Opie::Core::OProcess*, QString> m_signalMac;
         QString m_hcitoolCon;
     };
 };
 
 #endif