Adding in an internal buffer to Serial, this is independent of the SerialImpl and buffers reads to help performance.

Also correcting my styles to match the style guide and adding in some documentation.

Makefile

@@ -1,10 +1,9 @@
-# ash_gti's dumb downed makefile so I can more easily test stuff
+# # ash_gti's dumb downed makefile so I can more easily test stuff
 # CXX=clang++
-# CXXFLAGS=-g -I./include
+# CXXFLAGS=-g -I./include -ferror-limit=5 -O3 -Wall -Weffc++ -pedantic -pedantic-errors -Wextra  -Wall -Waggregate-return -Wcast-align -Wcast-qual  -Wchar-subscripts  -Wcomment -Wconversion -Wdisabled-optimization -Wfloat-equal  -Wformat  -Wformat=2 -Wformat-nonliteral -Wformat-security  -Wformat-y2k -Wimplicit  -Wimport  -Winit-self  -Winline -Winvalid-pch   -Wlong-long -Wmissing-braces -Wmissing-field-initializers -Wmissing-format-attribute   -Wmissing-include-dirs -Wmissing-noreturn -Wpacked -Wparentheses  -Wpointer-arith -Wredundant-decls -Wreturn-type -Wsequence-point  -Wshadow -Wsign-compare  -Wstack-protector -Wstrict-aliasing -Wstrict-aliasing=2 -Wswitch  -Wswitch-default -Wswitch-enum -Wtrigraphs  -Wuninitialized -Wunknown-pragmas  -Wunreachable-code -Wunused -Wunused-function  -Wunused-label  -Wunused-parameter -Wunused-value  -Wunused-variable  -Wvariadic-macros -Wvolatile-register-var  -Wwrite-strings
 # 
 # test: tests/serial_tests.o src/serial.o src/impl/unix.o
 # 	$(CXX) -o test tests/serial_tests.o src/serial.o src/impl/unix.o
-# 
 ifdef ROS_ROOT
 include $(shell rospack find mk)/cmake.mk
 else

include/serial/impl/unix.h

@@ -8,7 +8,7 @@
  *
  * The MIT License
  *
- * Copyright (c) 2011 William Woodall
+ * Copyright (c) 2011 William Woodall, John Harrison
  *
  * Permission is hereby granted, free of charge, to any person obtaining a 
  * copy of this software and associated documentation files (the "Software"),
@@ -30,7 +30,9 @@
  *
  * \section DESCRIPTION
  *
- * This provides a unix based pimpl for the Serial class.
+ * This provides a unix based pimpl for the Serial class. This implementation is
+ * based off termios.h and uses select for multiplexing the IO ports.
+ *
  */
 
 #ifndef SERIAL_IMPL_UNIX_H
@@ -42,6 +44,7 @@ namespace serial {
 
 using std::string;
 using std::invalid_argument;
+
 using serial::SerialExecption;
 using serial::IOException;
 
@@ -57,47 +60,98 @@ public:
 
   virtual ~SerialImpl ();
 
-  void open ();
+  void
-  void close () ;
+  open ();
-  bool isOpen () const;
 
-  size_t available ();
+  void
-  string read (size_t size = 1);
+  close ();
-  size_t write (const string &data);
 
-  void flush ();
+  bool
-  void flushInput ();
+  isOpen () const;
-  void flushOutput ();
 
-  void sendBreak(int duration);
+  size_t
-  void setBreak(bool level);
+  available ();
-  void setRTS(bool level);
-  void setDTR(bool level);
-  bool getCTS();
-  bool getDSR();
-  bool getRI();
-  bool getCD();
 
-  void setPort (const string &port);
+  size_t
-  string getPort () const;
+  read (char* buf, size_t size = 1);
 
-  void setTimeout (long timeout);
+  size_t
-  long getTimeout () const;
+  write (const string &data);
 
-  void setBaudrate (unsigned long baudrate);
+  void
-  unsigned long getBaudrate () const;
+  flush ();
 
-  void setBytesize (bytesize_t bytesize);
+  void
-  bytesize_t getBytesize () const;
+  flushInput ();
 
-  void setParity (parity_t parity);
+  void
-  parity_t getParity () const;
+  flushOutput ();
 
-  void setStopbits (stopbits_t stopbits);
+  void
-  stopbits_t getStopbits () const;
+  sendBreak(int duration);
 
-  void setFlowcontrol (flowcontrol_t flowcontrol);
+  void
-  flowcontrol_t getFlowcontrol () const;
+  setBreak(bool level);
+
+  void
+  setRTS(bool level);
+
+  void
+  setDTR(bool level);
+  
+  bool
+  getCTS();
+  
+  bool
+  getDSR();
+  
+  bool
+  getRI();
+  
+  bool
+  getCD();
+
+  void
+  setPort (const string &port);
+  
+  string
+  getPort () const;
+
+  void
+  setTimeout (long timeout);
+  
+  long
+  getTimeout () const;
+
+  void
+  setBaudrate (unsigned long baudrate);
+  
+  unsigned long
+  getBaudrate () const;
+
+  void
+  setBytesize (bytesize_t bytesize);
+  
+  bytesize_t
+  getBytesize () const;
+
+  void
+  setParity (parity_t parity);
+
+  parity_t
+  getParity () const;
+
+  void
+  setStopbits (stopbits_t stopbits);
+
+  stopbits_t
+  getStopbits () const;
+
+  void
+  setFlowcontrol (flowcontrol_t flowcontrol);
+
+  flowcontrol_t
+  getFlowcontrol () const;
 
 protected:
   void reconfigurePort ();
@@ -106,14 +160,10 @@ private:
   string port_;               // Path to the file descriptor
   int fd_;                    // The current file descriptor
 
-  int interCharTimeout_;
-  int writeTimeout_;
   bool isOpen_;
   bool xonxoff_;
   bool rtscts_;
 
-  char ___; // lol padding
-
   long timeout_;              // Timeout for read operations
   unsigned long baudrate_;    // Baudrate
 

include/serial/serial.h

@@ -153,6 +153,9 @@ public:
   * FLOWCONTROL_NONE, possible values are: FLOWCONTROL_NONE,
   * FLOWCONTROL_SOFTWARE, FLOWCONTROL_HARDWARE
   *
+  * \param buffer_size The maximum size of the internal buffer, defaults
+  * to 256 bytes (2^8).
+  *
   * \throw PortNotOpenedException
   */
   Serial (const std::string &port = "",
@@ -161,7 +164,8 @@ public:
           bytesize_t bytesize = EIGHTBITS,
           parity_t parity = PARITY_NONE,
           stopbits_t stopbits = STOPBITS_ONE,
-          flowcontrol_t flowcontrol = FLOWCONTROL_NONE);
+          flowcontrol_t flowcontrol = FLOWCONTROL_NONE,
+          const size_t buffer_size = 256);
 
   /*! Destructor */
   virtual ~Serial ();
@@ -197,22 +201,6 @@ public:
   size_t
   available();
 
-  /*! Read a given amount of bytes from the serial port.
-  * 
-  * If a timeout is set it may return less characters than requested. With
-  * no timeout it will block until the requested number of bytes have been
-  * read or until an exception occurs.
-  * 
-  * \param buffer An unsigned char array large enough to hold incoming data 
-  * up to the requested size.
-  * 
-  * \param size A size_t defining how many bytes to be read.
-  * 
-  * \return A size_t representing the number of bytes actually read.
-  */
-  //size_t
-  //read (unsigned char* buffer, size_t size = 1);
-
   /*! Read a given amount of bytes from the serial port.
   *
   * If a timeout is set it may return less characters than requested. With
@@ -226,36 +214,30 @@ public:
   std::string
   read (size_t size = 1);
 
-  std::string readline(size_t size = std::numeric_limits<std::size_t>::max(),
+  /*! Reads in a line or until a given delimiter has been processed
+  *
+  * Reads from the serial port until a single line has been read.
+  *
+  * \param size A maximum length of a line defaults to size_t::max()
+  * \param eol A string to match against for the EOL.
+  *
+  * \return A std::string containing the line.
+  */
+  std::string
+  readline(size_t      size = std::numeric_limits<std::size_t>::max(),
            std::string eol  = "\n");
 
-  std::vector<std::string> readlines(std::string eol = "\n");
+  /*! Reads in multiple lines until the serail port times out.
-
-  /*! Read a given amount of bytes from the serial port.
   *
-  * Reads into a std::string by reference rather than returning it.
+  * This requires a timeout > 0 before it can be run. It will read until a
+  * timeout occurs and return a list of strings.
   *
-  * \param buffer A std::string reference for reading to.
+  * \param eol A string to match against for the EOL.
-  * \param size A size_t defining how many bytes to be read.
   *
-  * \return A size_t that represents how many bytes were read.
+  * \return A vector<string> containing the lines.
-  * 
-  * \see Serial::read(size_t)
   */
-  //size_t
+  std::vector<std::string>
-  //read (std::string &buffer, size_t size = 1);
+  readlines(std::string eol = "\n");
-
-  /*! Write bytes from the data to the serial port by given length.
-  * 
-  * \param data An unsigned char array containing data to be written to the
-  * serial port.
-  * 
-  * \param length A size_t representing the number of bytes to be written.
-  * 
-  * \return A size_t representing the number of bytes actually written.
-  */
-  //size_t
-  //write (unsigned char* data, size_t length);
 
   /*! Write a string to the serial port.
   *
@@ -412,17 +394,41 @@ public:
   flowcontrol_t
   getFlowcontrol () const;
 
-  void flush();
+  /*! Flush the input and output buffers */
-  void flushInput();
+  void
-  void flushOutput();
+  flush ();
-  void sendBreak(int duration);
+
-  void setBreak(bool level = true);
+  /*! Flush only the input buffer */
-  void setRTS(bool level = true);
+  void
-  void setDTR(bool level = true);
+  flushInput ();
-  bool getCTS();
+
-  bool getDSR();
+  /*! Flush only the output buffer */
-  bool getRI();
+  void
-  bool getCD();
+  flushOutput ();
+
+  void
+  sendBreak (int duration);
+
+  void
+  setBreak (bool level = true);
+
+  void
+  setRTS (bool level = true);
+
+  void
+  setDTR (bool level = true);
+
+  bool
+  getCTS ();
+
+  bool
+  getDSR ();
+
+  bool
+  getRI ();
+
+  bool
+  getCD ();
 
 private:
   // Disable copy constructors
@@ -430,9 +436,12 @@ private:
   void operator=(const Serial&);
   const Serial& operator=(Serial);
 
+  const size_t buffer_size_;
+  char *read_cache_; //!< Cache for doing reads in chunks.
+
   // Pimpl idiom, d_pointer
   class SerialImpl;
-  SerialImpl *pimpl;
+  SerialImpl *pimpl_;
 };
 
 } // namespace serial

serial.cmake

@@ -15,7 +15,7 @@ IF(EXISTS /usr/bin/clang)
   set(CMAKE_CXX_COMPILER /usr/bin/clang++)
   set(CMAKE_OSX_DEPLOYMENT_TARGET "")
   # set(CMAKE_CXX_FLAGS "-ferror-limit=5 -std=c++0x -stdlib=libc++")
-  set(CMAKE_CXX_FLAGS "-ferror-limit=5 -m64 -Wall -Weffc++ -pedantic -pedantic-errors -Wextra  -Wall -Waggregate-return -Wcast-align -Wcast-qual  -Wchar-subscripts  -Wcomment -Wconversion -Wdisabled-optimization -Wfloat-equal  -Wformat  -Wformat=2 -Wformat-nonliteral -Wformat-security  -Wformat-y2k -Wimplicit  -Wimport  -Winit-self  -Winline -Winvalid-pch   -Wlong-long -Wmissing-braces -Wmissing-field-initializers -Wmissing-format-attribute   -Wmissing-include-dirs -Wmissing-noreturn -Wpacked  -Wpadded -Wparentheses  -Wpointer-arith -Wredundant-decls -Wreturn-type -Wsequence-point  -Wshadow -Wsign-compare  -Wstack-protector -Wstrict-aliasing -Wstrict-aliasing=2 -Wswitch  -Wswitch-default -Wswitch-enum -Wtrigraphs  -Wuninitialized -Wunknown-pragmas  -Wunreachable-code -Wunused -Wunused-function  -Wunused-label  -Wunused-parameter -Wunused-value  -Wunused-variable  -Wvariadic-macros -Wvolatile-register-var  -Wwrite-strings")
+  set(CMAKE_CXX_FLAGS "-ferror-limit=5 -O3 -Wall -Weffc++ -pedantic -pedantic-errors -Wextra  -Wall -Waggregate-return -Wcast-align -Wcast-qual  -Wchar-subscripts  -Wcomment -Wconversion -Wdisabled-optimization -Wfloat-equal  -Wformat  -Wformat=2 -Wformat-nonliteral -Wformat-security  -Wformat-y2k -Wimplicit  -Wimport  -Winit-self  -Winline -Winvalid-pch   -Wlong-long -Wmissing-braces -Wmissing-field-initializers -Wmissing-format-attribute   -Wmissing-include-dirs -Wmissing-noreturn -Wpacked -Wparentheses  -Wpointer-arith -Wredundant-decls -Wreturn-type -Wsequence-point  -Wshadow -Wsign-compare  -Wstack-protector -Wstrict-aliasing -Wstrict-aliasing=2 -Wswitch  -Wswitch-default -Wswitch-enum -Wtrigraphs  -Wuninitialized -Wunknown-pragmas  -Wunreachable-code -Wunused -Wunused-function  -Wunused-label  -Wunused-parameter -Wunused-value  -Wunused-variable  -Wvariadic-macros -Wvolatile-register-var  -Wwrite-strings")
   set(CMAKE_BUILD_TYPE Debug)
 ENDIF(EXISTS /usr/bin/clang)
 

src/impl/unix.cc

@@ -1,3 +1,5 @@
+/* Copyright 2012 William Woodall and John Harrison */
+
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
@@ -33,31 +35,36 @@ Serial::SerialImpl::SerialImpl (const string &port, unsigned long baudrate,
                                 long timeout, bytesize_t bytesize,
                                 parity_t parity, stopbits_t stopbits,
                                 flowcontrol_t flowcontrol)
-: port_(port), fd_(-1), interCharTimeout_(-1), writeTimeout_(-1),
+: port_ (port), fd_ (-1), isOpen_ (false), xonxoff_ (true), rtscts_ (false),
-  isOpen_(false), xonxoff_(false), rtscts_(false), ___(0), timeout_(timeout),
+  timeout_ (timeout), baudrate_ (baudrate), parity_ (parity), bytesize_ (bytesize),
-  baudrate_(baudrate), parity_(parity), bytesize_(bytesize),
+  stopbits_ (stopbits), flowcontrol_ (flowcontrol)
-  stopbits_(stopbits), flowcontrol_(flowcontrol)
 {
-  if (port_.empty() == false) this->open();
+  if (port_.empty () == false)
+    open ();
 }
 
-Serial::SerialImpl::~SerialImpl () {
+Serial::SerialImpl::~SerialImpl ()
-  this->close();
+{
+  close();
 }
 
 void
-Serial::SerialImpl::open () {
+Serial::SerialImpl::open ()
-  if (port_.empty()) {
+{
-    throw invalid_argument("bad port specified");
+  if (port_.empty())
+  {
+    throw invalid_argument ("bad port specified");
   }
-  if (isOpen_ == true) {
+  if (isOpen_ == true)
-    throw SerialExecption("port already open");
+  {
+    throw SerialExecption ("port already open");
   }
 
   fd_ = ::open (port_.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK);
 
-  if (fd_ == -1) {
+  if (fd_ == -1)
-    throw IOException("invalid file descriptor");
+  {
+    throw IOException ("invalid file descriptor");
   }
 
   reconfigurePort();
@@ -65,31 +72,25 @@ Serial::SerialImpl::open () {
 }
 
 void
-Serial::SerialImpl::reconfigurePort () {
+Serial::SerialImpl::reconfigurePort ()
-  if (fd_ == -1) {
+{
+  if (fd_ == -1)
+  {
     // Can only operate on a valid file descriptor
-    throw IOException("invalid file descriptor");
+    throw IOException ("invalid file descriptor");
   }
 
-  struct termios options; // The current options for the file descriptor
+  struct termios options; // The options for the file descriptor
-  struct termios originalTTYAttrs; // The orignal file descriptor options
 
-  uint8_t vmin = 0, vtime = 0; // timeout is done via select
+  if (tcgetattr(fd_, &options) == -1)
-  if (interCharTimeout_ == -1) {
+  {
-    vmin = 1;
+    throw IOException ("::tcgetattr");
-    vtime = uint8_t(interCharTimeout_ * 10);
   }
 
-  if (tcgetattr(fd_, &originalTTYAttrs) == -1) {
-    throw IOException("::tcgetattr");
-  }
-
-  options = originalTTYAttrs;
-
   // set up raw mode / no echo / binary
-  options.c_cflag |= (unsigned long)(CLOCAL|CREAD);
+  options.c_cflag |= (unsigned long)  (CLOCAL|CREAD);
-  options.c_lflag &= (unsigned long) ~(ICANON|ECHO|ECHOE|ECHOK
+  options.c_lflag &= (unsigned long) ~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|
-                       |ECHONL|ISIG|IEXTEN); //|ECHOPRT
+                                       ISIG|IEXTEN); //|ECHOPRT
 
   options.c_oflag &= (unsigned long) ~(OPOST);
   options.c_iflag &= (unsigned long) ~(INLCR|IGNCR|ICRNL|IGNBRK);
@@ -115,7 +116,7 @@ Serial::SerialImpl::reconfigurePort () {
   else if (bytesize_ == FIVEBITS)
       options.c_cflag |= CS5;
   else
-      throw invalid_argument("Invalid char len");
+      throw invalid_argument ("Invalid char len");
   // setup stopbits
   if (stopbits_ == STOPBITS_ONE)
       options.c_cflag &= (unsigned long) ~(CSTOPB);
@@ -124,21 +125,25 @@ Serial::SerialImpl::reconfigurePort () {
   else if (stopbits_ == STOPBITS_TWO)
       options.c_cflag |=  (CSTOPB);
   else
-      throw invalid_argument("invalid stop bit");
+      throw invalid_argument ("invalid stop bit");
   // setup parity
   options.c_iflag &= (unsigned long) ~(INPCK|ISTRIP);
-  if (parity_ == PARITY_NONE) {
+  if (parity_ == PARITY_NONE)
+  {
     options.c_cflag &= (unsigned long) ~(PARENB|PARODD);
   }
-  else if (parity_ == PARITY_EVEN) {
+  else if (parity_ == PARITY_EVEN)
+  {
     options.c_cflag &= (unsigned long) ~(PARODD);
     options.c_cflag |=  (PARENB);
   }
-  else if (parity_ == PARITY_ODD) {
+  else if (parity_ == PARITY_ODD)
+  {
     options.c_cflag |=  (PARENB|PARODD);
   }
-  else {
+  else
-    throw invalid_argument("invalid parity");
+  {
+    throw invalid_argument ("invalid parity");
   }
   // setup flow control
   // xonxoff
@@ -168,21 +173,21 @@ Serial::SerialImpl::reconfigurePort () {
 #error "OS Support seems wrong."
 #endif
 
-  // buffer
+  options.c_cc[VMIN] = 1; // Minimum of 1 character in the buffer
-  // vmin "minimal number of characters to be read. = for non blocking"
+  options.c_cc[VTIME] = 0; // timeout on waiting for new data
-  options.c_cc[VMIN] = vmin;
-  // vtime
-  options.c_cc[VTIME] = vtime;
 
   // activate settings
-  ::tcsetattr(fd_, TCSANOW, &options);
+  ::tcsetattr (fd_, TCSANOW, &options);
 }
 
 void
-Serial::SerialImpl::close () {
+Serial::SerialImpl::close ()
-  if (isOpen_ == true) {
+{
-    if (fd_ != -1) {
+  if (isOpen_ == true)
-      ::close(fd_); // Ignoring the outcome
+  {
+    if (fd_ != -1)
+    {
+      ::close (fd_); // Ignoring the outcome
       fd_ = -1;
     }
     isOpen_ = false;
@@ -190,266 +195,318 @@ Serial::SerialImpl::close () {
 }
 
 bool
-Serial::SerialImpl::isOpen () const {
+Serial::SerialImpl::isOpen () const
+{
   return isOpen_;
 }
 
 size_t
-Serial::SerialImpl::available () {
+Serial::SerialImpl::available ()
-  if (!isOpen_) {
+{
+  if (!isOpen_)
+  {
     return 0;
   }
   int count = 0;
-  int result = ioctl(fd_, TIOCINQ, &count);
+  int result = ioctl (fd_, TIOCINQ, &count);
-  if (result == 0) {
+  if (result == 0)
-    return (size_t)count;
+  {
+    return static_cast<size_t> (count);
   }
-  else {
+  else
-    throw IOException("ioctl");
+  {
+    throw IOException ("ioctl");
   }
 }
 
-string
+size_t
-Serial::SerialImpl::read (size_t size) {
+Serial::SerialImpl::read (char* buf, size_t size)
-  if (!isOpen_) {
+{
-    throw PortNotOpenedException("Serial::read");
+  if (!isOpen_)
-  }
+  {
-  string message = "";
+    throw PortNotOpenedException ("Serial::read");
-  char *buf = NULL;
-  // Using size+1 to leave room for a null character
-  if (size > 1024) {
-    buf = (char*)malloc((size + 1) * sizeof(*buf));
-  }
-  else {
-    buf = (char*)alloca((size + 1) * sizeof(*buf));
   }
   fd_set readfds;
-  memset(buf, 0, (size + 1) * sizeof(*buf));
   ssize_t bytes_read = 0;
-  while (bytes_read < size) {
+  while (true)
-    if (timeout_ != -1) {
+  {
-      FD_ZERO(&readfds);
+    if (timeout_ != -1)
-      FD_SET(fd_, &readfds);
+    {
+      FD_ZERO (&readfds);
+      FD_SET (fd_, &readfds);
       struct timeval timeout;
       timeout.tv_sec =                    timeout_ / 1000;
-      timeout.tv_usec = (int) timeout_ % 1000;
+      timeout.tv_usec = static_cast<int> (timeout_ % 1000);
-      int r = select(fd_ + 1, &readfds, NULL, NULL, &timeout);
+      int r = select (fd_ + 1, &readfds, NULL, NULL, &timeout);
 
       if (r == -1 && errno == EINTR)
         continue;
 
-      if (r == -1) {
+      if (r == -1)
+      {
         perror("select()");
         exit(EXIT_FAILURE);
       }
     }
 
-    if (timeout_ == -1 || FD_ISSET(fd_, &readfds)) {
+    if (timeout_ == -1 || FD_ISSET (fd_, &readfds))
-      ssize_t newest_read = ::read(fd_,
+    {
-                                   buf + bytes_read,
+      bytes_read = ::read (fd_, buf, size);
-                                   size - static_cast<size_t>(bytes_read));
       // read should always return some data as select reported it was
       // ready to read when we get to this point.
-      if (newest_read < 1) {
+      // printf("bytes_read: %lu\n", bytes_read);
+      if (bytes_read < 1)
+      {
         // Disconnected devices, at least on Linux, show the
         // behavior that they are always ready to read immediately
         // but reading returns nothing.
-        throw SerialExecption("device reports readiness to read but "
+        throw SerialExecption ("device reports readiness to read but "
                                "returned no data (device disconnected?)");
       }
-      bytes_read += newest_read;
+      break;
-    }
-    else {
-      break; // Timeout
     }
   }
-  if (bytes_read > 0)
+  return static_cast<size_t> (bytes_read);
-    message.append(buf, (size_t)bytes_read);
-  if (size > 1024)
-    free(buf);
-  return message;
 }
 
 size_t
-Serial::SerialImpl::write (const string &data) {
+Serial::SerialImpl::write (const string &data)
+{
   if (isOpen_ == false) {
-    throw PortNotOpenedException("Serial::write");
+    throw PortNotOpenedException ("Serial::write");
   }
-  ssize_t n = ::write(fd_, data.c_str(), data.length());
+  ssize_t n = ::write (fd_, data.c_str (), data.length ());
   if (n == -1) {
-    throw IOException("Write");
+    throw IOException ("Write");
   }
-  return (size_t)n;
+  return static_cast<size_t> (n);
 }
 
 void
-Serial::SerialImpl::setPort (const string &port) {
+Serial::SerialImpl::setPort (const string &port)
+{
   port_ = port;
 }
 
 string
-Serial::SerialImpl::getPort () const {
+Serial::SerialImpl::getPort () const
+{
   return port_;
 }
 
 void
-Serial::SerialImpl::setTimeout (long timeout) {
+Serial::SerialImpl::setTimeout (long timeout)
+{
   timeout_ = timeout;
-  if (isOpen_) reconfigurePort();
+  if (isOpen_)
+    reconfigurePort ();
 }
 
 long
-Serial::SerialImpl::getTimeout () const {
+Serial::SerialImpl::getTimeout () const
+{
   return timeout_;
 }
 
 void
-Serial::SerialImpl::setBaudrate (unsigned long baudrate) {
+Serial::SerialImpl::setBaudrate (unsigned long baudrate)
+{
   baudrate_ = baudrate;
-  if (isOpen_) reconfigurePort();
+  if (isOpen_)
+    reconfigurePort ();
 }
 
 unsigned long
-Serial::SerialImpl::getBaudrate () const {
+Serial::SerialImpl::getBaudrate () const
+{
   return baudrate_;
 }
 
 void
-Serial::SerialImpl::setBytesize (serial::bytesize_t bytesize) {
+Serial::SerialImpl::setBytesize (serial::bytesize_t bytesize)
+{
   bytesize_ = bytesize;
-  if (isOpen_) reconfigurePort();
+  if (isOpen_)
+    reconfigurePort ();
 }
 
 serial::bytesize_t
-Serial::SerialImpl::getBytesize () const {
+Serial::SerialImpl::getBytesize () const
+{
   return bytesize_;
 }
 
 void
-Serial::SerialImpl::setParity (serial::parity_t parity) {
+Serial::SerialImpl::setParity (serial::parity_t parity)
+{
   parity_ = parity;
-  if (isOpen_) reconfigurePort();
+  if (isOpen_)
+    reconfigurePort ();
 }
 
 serial::parity_t
-Serial::SerialImpl::getParity () const {
+Serial::SerialImpl::getParity () const
+{
   return parity_;
 }
 
 void
-Serial::SerialImpl::setStopbits (serial::stopbits_t stopbits) {
+Serial::SerialImpl::setStopbits (serial::stopbits_t stopbits)
+{
   stopbits_ = stopbits;
-  if (isOpen_) reconfigurePort();
+  if (isOpen_)
+    reconfigurePort ();
 }
 
 serial::stopbits_t
-Serial::SerialImpl::getStopbits () const {
+Serial::SerialImpl::getStopbits () const
+{
   return stopbits_;
 }
 
 void
-Serial::SerialImpl::setFlowcontrol (serial::flowcontrol_t flowcontrol) {
+Serial::SerialImpl::setFlowcontrol (serial::flowcontrol_t flowcontrol)
+{
   flowcontrol_ = flowcontrol;
-  if (isOpen_) reconfigurePort();
+  if (isOpen_)
+    reconfigurePort ();
 }
 
 serial::flowcontrol_t
-Serial::SerialImpl::getFlowcontrol () const {
+Serial::SerialImpl::getFlowcontrol () const
+{
   return flowcontrol_;
 }
 
-void Serial::SerialImpl::flush () {
+void
-  if (isOpen_ == false) {
+Serial::SerialImpl::flush ()
-    throw PortNotOpenedException("Serial::flush");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::flush");
   }
-  tcdrain(fd_);
+  tcdrain (fd_);
 }
 
-void Serial::SerialImpl::flushInput () {
+void
-  if (isOpen_ == false) {
+Serial::SerialImpl::flushInput ()
-    throw PortNotOpenedException("Serial::flushInput");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::flushInput");
   }
-  tcflush(fd_, TCIFLUSH);
+  tcflush (fd_, TCIFLUSH);
 }
 
-void Serial::SerialImpl::flushOutput () {
+void
-  if (isOpen_ == false) {
+Serial::SerialImpl::flushOutput ()
-    throw PortNotOpenedException("Serial::flushOutput");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::flushOutput");
   }
-  tcflush(fd_, TCOFLUSH);
+  tcflush (fd_, TCOFLUSH);
 }
 
-void Serial::SerialImpl::sendBreak(int duration) {
+void
-  if (isOpen_ == false) {
+Serial::SerialImpl::sendBreak (int duration)
-    throw PortNotOpenedException("Serial::sendBreak");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::sendBreak");
   }
-  tcsendbreak(fd_, int(duration/4));
+  tcsendbreak (fd_, static_cast<int> (duration/4));
 }
 
-void Serial::SerialImpl::setBreak(bool level) {
+void
-  if (isOpen_ == false) {
+Serial::SerialImpl::setBreak (bool level)
-    throw PortNotOpenedException("Serial::setBreak");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::setBreak");
   }
-  if (level) {
+  if (level)
-    ioctl(fd_, TIOCSBRK);
+  {
+    ioctl (fd_, TIOCSBRK);
   }
   else {
-    ioctl(fd_, TIOCCBRK);
+    ioctl (fd_, TIOCCBRK);
   }
 }
 
-void Serial::SerialImpl::setRTS(bool level) {
+void
-  if (isOpen_ == false) {
+Serial::SerialImpl::setRTS (bool level)
-    throw PortNotOpenedException("Serial::setRTS");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::setRTS");
   }
-  if (level) {
+  if (level)
-    ioctl(fd_, TIOCMBIS, TIOCM_RTS);
+  {
+    ioctl (fd_, TIOCMBIS, TIOCM_RTS);
   }
   else {
-    ioctl(fd_, TIOCMBIC, TIOCM_RTS);
+    ioctl (fd_, TIOCMBIC, TIOCM_RTS);
   }
 }
 
-void Serial::SerialImpl::setDTR(bool level) {
+void
-  if (isOpen_ == false) {
+Serial::SerialImpl::setDTR (bool level)
-    throw PortNotOpenedException("Serial::setDTR");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::setDTR");
   }
-  if (level) {
+  if (level)
-    ioctl(fd_, TIOCMBIS, TIOCM_DTR);
+  {
+    ioctl (fd_, TIOCMBIS, TIOCM_DTR);
   }
-  else {
+  else
-    ioctl(fd_, TIOCMBIC, TIOCM_DTR);
+  {
+    ioctl (fd_, TIOCMBIC, TIOCM_DTR);
   }
 }
 
-bool Serial::SerialImpl::getCTS() {
+bool
-  if (isOpen_ == false) {
+Serial::SerialImpl::getCTS ()
-    throw PortNotOpenedException("Serial::getCTS");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::getCTS");
   }
-  int s = ioctl(fd_, TIOCMGET, 0);
+  int s = ioctl (fd_, TIOCMGET, 0);
   return (s & TIOCM_CTS) != 0;
 }
 
-bool Serial::SerialImpl::getDSR() {
+bool
-  if (isOpen_ == false) {
+Serial::SerialImpl::getDSR()
-    throw PortNotOpenedException("Serial::getDSR");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::getDSR");
   }
   int s = ioctl(fd_, TIOCMGET, 0);
   return (s & TIOCM_DSR) != 0;
 }
 
-bool Serial::SerialImpl::getRI() {
+bool
-  if (isOpen_ == false) {
+Serial::SerialImpl::getRI()
-    throw PortNotOpenedException("Serial::getRI");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::getRI");
   }
-  int s = ioctl(fd_, TIOCMGET, 0);
+  int s = ioctl (fd_, TIOCMGET, 0);
   return (s & TIOCM_RI) != 0;
 }
 
-bool Serial::SerialImpl::getCD() {
+bool
-  if (isOpen_ == false) {
+Serial::SerialImpl::getCD()
-    throw PortNotOpenedException("Serial::getCD");
+{
+  if (isOpen_ == false)
+  {
+    throw PortNotOpenedException ("Serial::getCD");
   }
-  int s = ioctl(fd_, TIOCMGET, 0);
+  int s = ioctl (fd_, TIOCMGET, 0);
   return (s & TIOCM_CD) != 0;
 }

src/serial.cc

@@ -1,3 +1,10 @@
+/* Copyright 2012 William Woodall and John Harrison */
+
+#include <alloca.h>
+
+#include <cstring>
+#include <algorithm>
+
 #include "serial/serial.h"
 
 #ifdef _WIN32
@@ -6,11 +13,14 @@
 #include "serial/impl/unix.h"
 #endif
 
-using std::string;
-using std::vector;
-using std::numeric_limits;
-using std::size_t;
 using std::invalid_argument;
+using std::memset;
+using std::min;
+using std::numeric_limits;
+using std::vector;
+using std::size_t;
+using std::string;
+
 using serial::Serial;
 using serial::SerialExecption;
 using serial::IOException;
@@ -21,204 +31,301 @@ using serial::flowcontrol_t;
 
 Serial::Serial (const string &port, unsigned long baudrate, long timeout,
                 bytesize_t bytesize, parity_t parity, stopbits_t stopbits,
-                flowcontrol_t flowcontrol)
+                flowcontrol_t flowcontrol, const size_t buffer_size)
+ : buffer_size_(buffer_size)
 {
-  pimpl = new SerialImpl(port, baudrate, timeout, bytesize, parity,
+  pimpl_ = new SerialImpl (port, baudrate, timeout, bytesize, parity,
                            stopbits, flowcontrol);
+  read_cache_ = new char[buffer_size_];
+  memset (read_cache_, 0, buffer_size_ * sizeof (char));
 }
 
-Serial::~Serial () {
+Serial::~Serial ()
-  delete pimpl;
+{
+  delete   pimpl_;
+  delete[] read_cache_;
 }
 
 void
-Serial::open () {
+Serial::open ()
-  this->pimpl->open ();
+{
+  pimpl_->open ();
 }
 
 void
-Serial::close () {
+Serial::close ()
-  this->pimpl->close ();
+{
+  pimpl_->close ();
+  memset (read_cache_, 0, buffer_size_ * sizeof (char));
 }
 
 bool
-Serial::isOpen () const {
+Serial::isOpen () const
-  return this->pimpl->isOpen ();
+{
+  return pimpl_->isOpen ();
 }
 
 size_t
-Serial::available () {
+Serial::available ()
-  return this->pimpl->available();
+{
+  return pimpl_->available ();
 }
 
 string
-Serial::read (size_t size) {
+Serial::read (size_t size)
-  return this->pimpl->read (size);
+{
+  size_t cache_size = strlen (read_cache_);
+  if (cache_size >= size)
+  {
+    // Don't need to do a new read.
+    string result (read_cache_, size);
+    memmove (read_cache_, read_cache_ + size, cache_size - size);
+    *(read_cache_ + cache_size - size) = '\0';
+    return result;
+  }
+  else
+  {
+    // Needs to read, loop until we have read enough... or timeout
+    size_t chars_left = 0;
+    string result = "";
+
+    if (cache_size > 0)
+    {
+      result.append (read_cache_, cache_size);
+      memset (read_cache_, 0, buffer_size_);
+      chars_left = size - cache_size;
+    }
+    else
+    {
+      chars_left = size;
+    }
+
+    while (true)
+    {
+      size_t chars_read = pimpl_->read (read_cache_, buffer_size_ - 1);
+      if (chars_read > 0)
+      {
+        *(read_cache_ + chars_read) = '\0';
+        if (chars_left > chars_read)
+        {
+          memset (read_cache_, 0, buffer_size_);
+          result.append (read_cache_);
+          chars_left -= chars_read;
+        }
+        else
+        {
+          result.append (read_cache_, static_cast<size_t> (chars_left));
+          memmove (read_cache_, read_cache_ + chars_left, chars_read - chars_left);
+          *(read_cache_ + chars_read - chars_left) = '\0';
+          memset (read_cache_ + chars_read - chars_left, 0,
+                  buffer_size_ - chars_read - chars_left);
+          // Finished reading all of the data
+          break;
+        }
+      }
+      else
+        break; // Timeout occured
+    }
+    return result;
+  }
 }
 
 string
-Serial::readline(size_t size, string eol) {
+Serial::readline (size_t size, string eol)
-  size_t leneol = eol.length();
+{
+  size_t leneol = eol.length ();
   string line = "";
-  while (true) {
+  while (true)
-    string c = pimpl->read(1);
+  {
-    if (!c.empty()) {
+    string c = read (1);
-      line.append(c);
+    if (!c.empty ())
-      if (line.length() > leneol
+    {
-       && line.substr(line.length() - leneol, leneol) == eol)
+      line.append (c);
+      if (line.length () > leneol &&
+          line.substr (line.length () - leneol, leneol) == eol)
         break;
-      if (line.length() >= size) {
+      if (line.length () >= size)
+      {
         break;
       }
     }
-    else {
+    else
       // Timeout
       break;
   }
-  }
   return line;
 }
 
 vector<string>
-Serial::readlines(string eol) {
+Serial::readlines(string eol)
-  if (this->pimpl->getTimeout() < 0) {
+{
+  if (pimpl_->getTimeout () < 0)
+  {
     throw "Error, must be set for readlines";
   }
-  size_t leneol = eol.length();
+  size_t leneol = eol.length ();
   vector<string> lines;
-  while (true) {
+  while (true)
-    string line = readline(numeric_limits<size_t>::max(), eol);
+  {
-    if (!line.empty()) {
+    string line = readline (numeric_limits<size_t>::max (), eol);
-      lines.push_back(line);
+    if (!line.empty ())
-      if (line.substr(line.length() - leneol, leneol) == eol)
+    {
+      lines.push_back (line);
+      if (line.substr (line.length () - leneol, leneol) == eol)
         break;
     }
-    else {
+    else
       // Timeout
       break;
   }
-  }
   return lines;
 }
 
 size_t
-Serial::write (const string &data) {
+Serial::write (const string &data)
-  return this->pimpl->write (data);
+{
+  return pimpl_->write (data);
 }
 
 void
-Serial::setPort (const string &port) {
+Serial::setPort (const string &port)
-  bool was_open = pimpl->isOpen();
+{
-  if (was_open) this->close();
+  bool was_open = pimpl_->isOpen();
-  this->pimpl->setPort (port);
+  if (was_open) close();
-  if (was_open) this->open();
+  pimpl_->setPort (port);
+  if (was_open) open();
 }
 
 string
-Serial::getPort () const {
+Serial::getPort () const
-  return this->pimpl->getPort ();
+{
+  return pimpl_->getPort ();
 }
 
 void
-Serial::setTimeout (long timeout) {
+Serial::setTimeout (long timeout)
-  this->pimpl->setTimeout (timeout);
+{
+  pimpl_->setTimeout (timeout);
 }
 
 long
 Serial::getTimeout () const {
-  return this->pimpl->getTimeout ();
+  return pimpl_->getTimeout ();
 }
 
 void
-Serial::setBaudrate (unsigned long baudrate) {
+Serial::setBaudrate (unsigned long baudrate)
-  this->pimpl->setBaudrate (baudrate);
+{
+  pimpl_->setBaudrate (baudrate);
 }
 
 unsigned long
-Serial::getBaudrate () const {
+Serial::getBaudrate () const
-  return this->pimpl->getBaudrate ();
+{
+  return pimpl_->getBaudrate ();
 }
 
 void
-Serial::setBytesize (bytesize_t bytesize) {
+Serial::setBytesize (bytesize_t bytesize)
-  this->pimpl->setBytesize (bytesize);
+{
+  pimpl_->setBytesize (bytesize);
 }
 
 bytesize_t
-Serial::getBytesize () const {
+Serial::getBytesize () const
-  return this->pimpl->getBytesize ();
+{
+  return pimpl_->getBytesize ();
 }
 
 void
-Serial::setParity (parity_t parity) {
+Serial::setParity (parity_t parity)
-  this->pimpl->setParity (parity);
+{
+  pimpl_->setParity (parity);
 }
 
 parity_t
-Serial::getParity () const {
+Serial::getParity () const
-  return this->pimpl->getParity ();
+{
+  return pimpl_->getParity ();
 }
 
 void
-Serial::setStopbits (stopbits_t stopbits) {
+Serial::setStopbits (stopbits_t stopbits)
-  this->pimpl->setStopbits (stopbits);
+{
+  pimpl_->setStopbits (stopbits);
 }
 
 stopbits_t
-Serial::getStopbits () const {
+Serial::getStopbits () const
-  return this->pimpl->getStopbits ();
+{
+  return pimpl_->getStopbits ();
 }
 
 void
-Serial::setFlowcontrol (flowcontrol_t flowcontrol) {
+Serial::setFlowcontrol (flowcontrol_t flowcontrol)
-  this->pimpl->setFlowcontrol (flowcontrol);
+{
+  pimpl_->setFlowcontrol (flowcontrol);
 }
 
 flowcontrol_t
-Serial::getFlowcontrol () const {
+Serial::getFlowcontrol () const
-  return this->pimpl->getFlowcontrol ();
+{
+  return pimpl_->getFlowcontrol ();
 }
 
-void Serial::flush() {
+void Serial::flush ()
-  this->pimpl->flush();
+{
+  pimpl_->flush ();
+  memset (read_cache_, 0, buffer_size_);
 }
 
-void Serial::flushInput() {
+void Serial::flushInput ()
-  this->pimpl->flushInput();
+{
+  pimpl_->flushInput ();
 }
 
-void Serial::flushOutput() {
+void Serial::flushOutput ()
-  this->pimpl->flushOutput();
+{
+  pimpl_->flushOutput ();
+  memset (read_cache_, 0, buffer_size_);
 }
 
-void Serial::sendBreak(int duration) {
+void Serial::sendBreak (int duration)
-  this->pimpl->sendBreak(duration);
+{
+  pimpl_->sendBreak (duration);
 }
 
-void Serial::setBreak(bool level) {
+void Serial::setBreak (bool level)
-  this->pimpl->setBreak(level);
+{
+  pimpl_->setBreak (level);
 }
 
-void Serial::setRTS(bool level) {
+void Serial::setRTS (bool level)
-  this->pimpl->setRTS(level);
+{
+  pimpl_->setRTS (level);
 }
 
-void Serial::setDTR(bool level) {
+void Serial::setDTR (bool level)
-  this->pimpl->setDTR(level);
+{
+  pimpl_->setDTR (level);
 }
 
-bool Serial::getCTS() {
+bool Serial::getCTS ()
-  return this->pimpl->getCTS();
+{
+  return pimpl_->getCTS ();
 }
 
-bool Serial::getDSR() {
+bool Serial::getDSR ()
-  return this->pimpl->getDSR();
+{
+  return pimpl_->getDSR ();
 }
 
-bool Serial::getRI() {
+bool Serial::getRI ()
-  return this->pimpl->getRI();
+{
+  return pimpl_->getRI ();
 }
 
-bool Serial::getCD() {
+bool Serial::getCD ()
-  return this->pimpl->getCD();
+{
+  return pimpl_->getCD ();
 }

src/serial_listener.cc

@@ -1,3 +1,5 @@
+/* Copyright 2012 William Woodall and John Harrison */
+
 #include "serial/serial_listener.h"
 
 /***** Inline Functions *****/

tests/serial_tests.cc

@@ -1,10 +1,3 @@
-#include "gtest/gtest.h"
-
-#include <boost/bind.hpp>
-
-// OMG this is so nasty...
-// #define private public
-// #define protected public
 #include <string>
 #include <iostream>
 
@@ -14,17 +7,27 @@ using std::string;
 using std::cout;
 using std::endl;
 using serial::Serial;
+using serial::SerialExecption;
 
 int main(int argc, char **argv) {
+  try {
     Serial s("/dev/tty.usbserial-A900adHq", 115200, 2000);
     s.flush();
-  int count = 0;
+    long long count = 0;
     while (1) {
-    size_t available = s.available();
+      // size_t available = s.available();
-    cout << "avialable: " << available << endl;
+      // cout << "avialable: " << available << endl;
       string line = s.readline();
-    cout << count << ": " << line;
+      cout << count << ": " << line << line.length() << endl;
       count++;
     }
-  cout << endl << endl;
+  }
+  catch (SerialExecption e)
+  {
+    cout << "Caught SerialException: " << e.what() << endl;
+  }
+  catch (...)
+  {
+    cout << "Caught an error." << endl;
+  }
 }