INTRODUCTION Overview Download and Install Documentation Publications REPOSITORY Libraries DEVELOPER Dev Guide Dashboard PEOPLE Contributors Users Project Download Mailing lists

port.h /* * GearBox Project: Peer-Reviewed Open-Source Libraries for Robotics * http://gearbox.sf.net/ * Copyright (c) 2008 Geoffrey Biggs * * flexiport flexible hardware data communications library. * * This distribution is licensed to you under the terms described in the LICENSE file included in * this distribution. * * This work is a product of the National Institute of Advanced Industrial Science and Technology, * Japan. Registration number: H20PRO-881 * * This file is part of flexiport. * * flexiport is free software: you can redistribute it and/or modify it under the terms of the GNU * Lesser General Public License as published by the Free Software Foundation, either version 3 of * the License, or (at your option) any later version. * * flexiport is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License along with flexiport. * If not, see <http://www.gnu.org/licenses/>. */ #ifndef __PORT_H #define __PORT_H #include <string> #include <map> #if defined (WIN32) #if defined (FLEXIPORT_EXPORTS) #define FLEXIPORT_EXPORT __declspec (dllexport) #else #define FLEXIPORT_EXPORT __declspec (dllimport) #endif #else #define FLEXIPORT_EXPORT #endif #include "flexiport_types.h" #include "timeout.h" namespace flexiport { class FLEXIPORT_EXPORT Port { public: virtual ~Port (void); // API common to all ports virtual void Open (void) = 0; virtual void Close (void) = 0; virtual ssize_t Read (void * const buffer, size_t count) = 0; virtual ssize_t ReadFull (void * const buffer, size_t count) = 0; virtual ssize_t ReadString (std::string &buffer); virtual ssize_t ReadUntil (void * const buffer, size_t count, uint8_t terminator); virtual ssize_t ReadStringUntil (std::string &buffer, char terminator); virtual ssize_t ReadLine (char * const buffer, size_t count); virtual ssize_t ReadLine (std::string &buffer) { return ReadStringUntil (buffer, '\n'); } virtual ssize_t Skip (size_t count); virtual ssize_t SkipUntil (uint8_t terminator, unsigned int count); virtual ssize_t BytesAvailable (void) = 0; virtual ssize_t BytesAvailableWait (void) = 0; virtual ssize_t Write (const void * const buffer, size_t count) = 0; virtual ssize_t WriteFull (const void * const buffer, size_t count); virtual ssize_t WriteString (const char * const buffer); virtual ssize_t WriteString (const std::string &buffer) { return WriteString (buffer.c_str ()); } virtual void Flush (void) = 0; virtual void Drain (void) = 0; virtual std::string GetStatus (void) const; // Accessor methods. std::string GetPortType (void) const { return _type; } void SetDebug (int debug) { _debug = debug; } int GetDebug (void) const { return _debug; } virtual void SetTimeout (Timeout timeout) = 0; virtual Timeout GetTimeout (void) const { return _timeout; } virtual bool IsBlocking (void) const { return (_timeout._sec != 0 || _timeout._usec != 0); } virtual void SetCanRead (bool canRead) = 0; virtual bool CanRead (void) const { return _canRead; } virtual void SetCanWrite (bool canWrite) = 0; virtual bool CanWrite (void) const { return _canWrite; } virtual bool IsOpen (void) const = 0; protected: std::string _type; // Port type string (e.g. "tcp" or "serial" or "usb") unsigned int _debug; Timeout _timeout; // Timeout in milliseconds. Set to zero for non-blocking operation. bool _canRead; // If true, this port can be read from. bool _canWrite; // If true, this port can be written to. bool _alwaysOpen; // If the port should be kept open for the life of the object (including // reopening it if necessary). // Protected constructor to prevent direct creation of this class. Port (void); // Constructor for more-direct creation. Port (unsigned int debug, Timeout timeout, bool canRead, bool canWrite, bool alwaysOpen); void ProcessOptions (const std::map<std::string, std::string> &options); virtual bool ProcessOption (const std::string &option, const std::string &value); virtual void CheckPort (bool read) = 0; private: // Private copy constructor to prevent unintended copying. Port (const Port&); void operator= (const Port&); }; } // namespace flexiport #endif // __PORT_H

---