/home/verbeek/openrobotino_src/openrobotino1/lib/rec/robotino/com/Com.h

//  Copyright (C) 2004-2008, Robotics Equipment Corporation GmbH

#ifndef _REC_ROBOTINO_COM_COM_H_
#define _REC_ROBOTINO_COM_COM_H_

#include "rec/robotino/com/ComId.h"
#include "rec/robotino/com/RobotinoException.h"
#include "rec/iocontrol/remotestate/SetState.h"
#include "rec/iocontrol/remotestate/SensorState.h"
#include <string>

namespace rec
{
        namespace robotino
        {
                namespace com
                {
                        class ComImpl;

                        class
#ifdef WIN32
#  ifdef rec_robotino_com_EXPORTS
                __declspec(dllexport)
#endif
#  ifdef rec_robotino_com2_EXPORTS
                __declspec(dllexport)
#endif
#  ifdef rec_robotino_com3_EXPORTS
                __declspec(dllexport)
#endif
#endif
                        Com
                        {
                        public:
                                typedef enum
                                {
                                        NoError,
                                        ErrorConnectionRefused,
                                        ErrorSocketSend,
                                        ErrorSocketRead,
                                        ErrorImageServerCreate,
                                        ErrorImageServerBind,
                                        ErrorTimeout,
                                        ErrorConnectionBusy,
                                        ErrorClientCreate,
                                        ErrorHostNotFound,
                                        ErrorUndefined,
                                        ErrorWinsock2Initialization,
                                        ErrorAlreadyConnected
                                } Error;

                                typedef enum
                                {
                                        NotConnected = 0,
                                        HostLookupState = 1,
                                        Connecting = 2,
                                        Connected = 3,
                                        ClosingState = 6
                                } ConnectionState;

                                Com( bool useQueuedCallback = false );
                                
                                virtual ~Com();

                                ComId id() const;

                                void connect( bool isBlocking = true );

                                void disconnect();

                                bool isConnected() const;

                                void setAddress( const char* address );

                                const char* address() const;

                                void setImageServerPort( unsigned int port = 8080 );

                                unsigned int imageServerPort() const;

                                ConnectionState connectionState() const;

                                bool isPassiveMode() const;

                                bool waitForUpdate( unsigned int timeout = 200 );

                                void setMinimumUpdateCycleTime( unsigned int msecs );

                                rec::iocontrol::remotestate::SensorState sensorState();

                                void setSetState( const rec::iocontrol::remotestate::SetState& setState );

                                void processEvents();

                                bool hasPendingEvents() const;

                                virtual void errorEvent( Error error, const char* errorString );

                                virtual void connectedEvent();

                                virtual void connectionClosedEvent();

                                virtual void connectionStateChangedEvent( ConnectionState newState, ConnectionState oldState );

                                virtual void updateEvent();

                                virtual void modeChangedEvent( bool isPassiveMode );

                        private:
                                ComImpl* _impl;
                        };

                        class ComException : public RobotinoException
                        {
                        public:
                                ComException( Com::Error e, const char* message )
                                        : RobotinoException( message )
                                        , error( e )
                                {
                                }

                                const Com::Error error;
                        };
                }
        }
}
#endif

---