serial.h

#pragma once
 
 

 
 
//#include <limits>
//#include <vector>
//#include <string>
//#include <cstring>
//#include <sstream>
//#include <exception>
//#include <stdexcept>
//#include <serial/v8stdint.h>
 
#define THROW(exceptionClass, message) throw ::exception( exceptionClass(__FILE__, __LINE__, (message) ) )
 
namespace serial
{
 

   enum enum_byte_size
   {
      e_byte_size_five = 5,
      e_byte_size_six = 6,
      e_byte_size_seven = 7,
      e_byte_size_eight = 8
   };

   enum enum_parity
   {
      e_parity_none = 0,
      e_parity_odd = 1,
      e_parity_even = 2,
      e_parity_mark = 3,
      e_parity_space = 4
   };

   enum enum_stop_bit
   {
      e_stop_bit_one = 1,
      e_stop_bit_two = 2,
      e_stop_bit_one_point_five
   };

   enum enum_flow_control
   {
      e_flow_control_none = 0,
      e_flow_control_software,
      e_flow_control_hardware
   };

   struct CLASS_DECL_ACME timeout
   {
#ifdef maximum
# undef maximum
#endif
      static ::u32 maximum()
      {
         return numeric_info<::u32>::maximum();
      }
      virtual timeout simpleTimeout(const class time & time);

      class ::time m_timeInterByteTimeout;
      class ::time m_timeReadTimeoutConstant;
      ::u32 m_uReadTimeoutMultiplier;
      class ::time m_timeWriteTimeoutConstant;
      ::u32 m_uWriteTimeoutMultiplier;
 
 
      explicit timeout (const class time & timeInterByteTimeout=0_ms,
         const class time & timeReadTimeoutConstant=0_ms,
                        ::u32 uReadTimeoutMultiplier=0,
         const class time & timeWriteTimeoutConstant=0_ms,
                        ::u32 uWriteTimeoutMultiplier=0)
         : m_timeInterByteTimeout(timeInterByteTimeout),
           m_timeReadTimeoutConstant(timeReadTimeoutConstant),
           m_uReadTimeoutMultiplier(uReadTimeoutMultiplier),
           m_timeWriteTimeoutConstant(timeWriteTimeoutConstant),
           m_uWriteTimeoutMultiplier(uWriteTimeoutMultiplier)
      {}
      timeout(nullptr_t) : timeout() { }
   };

   class CLASS_DECL_ACME serial :
      virtual public particle
   {
   public:
 
 

 

      serial ();

      virtual ~serial ();
 
 
      virtual void initialize_serial(
         const string &port = "",
         ::u32 baudrate = 9600,
         struct timeout timeout = nullptr,
         enum_byte_size ebytesize = e_byte_size_eight,
         enum_parity eparity = e_parity_none,
         enum_stop_bit estopbit = e_stop_bit_one,
         enum_flow_control eflowcontrol = e_flow_control_none);

      virtual void
      open ();

      virtual bool
      isOpen () const;

      virtual void close ();
 
      //virtual void readLock();
      //virtual void readUnlock();
      //virtual void writeLock();
      //virtual void writeUnlock();
 
      virtual ::particle * read_synchronization();
      virtual ::particle * write_synchronization();

      virtual size_t
      available ();

      virtual bool
      waitReadable ();

      virtual void
      waitByteTimes (size_t count);

      virtual size_t
      read (::u8 *buffer, size_t size);

      virtual size_t
      read (memory &buffer, size_t size = 1);

      virtual size_t
      read (string &buffer, size_t size = 1);

      virtual string
      read (size_t size = 1);

      virtual size_t
      readline (string &buffer, size_t size = 65536, string eol = "\n");

      virtual string
      readline (size_t size = 65536, string eol = "\n");

      virtual string_array_base
      readlines (size_t size = 65536, string eol = "\n");

      virtual size_t
      write (const ::u8 *data, size_t size);

      virtual size_t
      write (const memory &data);

      virtual size_t
      write (const string &data);

      virtual void setPort (const string &port);
 
 
      virtual void _setPort(const string& port);

      virtual string
      getPort () const;

      virtual void set_timeout (const struct timeout &timeout);
      virtual void set_timeout(const class ::time & inter_byte_timeout, const class ::time & read_timeout_constant,
                  ::u32 read_timeout_multiplier, const class ::time & write_timeout_constant,
                  ::u32 write_timeout_multiplier)
      {
         struct timeout timeout(inter_byte_timeout, read_timeout_constant,
                         read_timeout_multiplier, write_timeout_constant,
                         write_timeout_multiplier);
         return set_timeout(timeout);
      }

      virtual struct timeout getTimeout () const;

      virtual void
      setBaudrate (::u32 baudrate);

      virtual ::u32
      getBaudrate () const;

      virtual void
      setBytesize (enum_byte_size ebytesize);

      virtual enum_byte_size
      getBytesize () const;

      virtual void
      setParity (enum_parity eparity);

      virtual enum_parity
      getParity () const;

      virtual void
      setStopbits (enum_stop_bit estopbit);

      virtual enum_stop_bit
      getStopbits () const;

      virtual void
      setFlowcontrol (enum_flow_control eflowcontrol);

      virtual enum_flow_control
      getFlowcontrol () const;

      virtual void
      flush ();

      virtual void
      flushInput ();

      virtual void
      flushOutput ();

      virtual void
      sendBreak (::i32 time);

      virtual void
      setBreak (bool level = true);

      virtual void
      setRTS (bool level = true);

      virtual void
      setDTR (bool level = true);

      virtual bool
      waitForChange ();

      virtual bool
      getCTS ();

      virtual bool
      getDSR ();

      virtual bool
      getRI ();

      virtual bool getCD ();
 
      // Read common function
      virtual size_t _read(::u8 *buffer, size_t size);
      
      // Write common function
      virtual size_t _write(const ::u8 *data, size_t length);
 
 
      virtual void _flush();
 
 
      virtual void _flushOutput();
 
      virtual void _flushInput();
 
 
   };
 
 
 
   //::exception exception(const string& description);
   //::exception io_exception(string file, ::i32 line, ::i32 errnum);
   //::exception io_exception_descripton(string file, ::i32 line, const_char_pointer description);
   //::exception port_opened_exception_descripton(string file, ::i32 line, const_char_pointer description);
 
   class serial_exception : public ::exception
   {
   //   
   //   // Disable copy constructors
   //   serial_exception& operator=(const serial_exception&);
   //   
   //   string e_what_;
 
   public:
 
      serial_exception(const string & description) :
         ::exception(error_serial)
      {
//         ::string_stream str;
  //       str << "serial_exception " << description << " failed.";
    //     e_what_ = str;
      }
   //   serial_exception (const serial_exception& other) : e_what_(other.e_what_) {}
   //   virtual ~serial_exception() noexcept {}
   //   virtual const_char_pointer what () const noexcept
   //   {
   //      return e_what_.c_str();
   //   }
   };
 
   class io_exception : public ::exception
   {
//      // Disable copy constructors
//      io_exception& operator=(const io_exception&);
//      string file_;
//      ::i32 line_;
//      string e_what_;
//      ::i32 errno_;
   public:
      explicit io_exception(string file, ::i32 line, ::i32 errnum) :
         ::exception(error_serial_io)
      {
         //: file_(file), line_(line), errno_(errnum)
//            ::string_stream str;
//#if defined(_WIN32) && !defined(__MINGW32__)
//         ::i8 error_str [1024];
//         strerror_s(error_str, 1024, errnum);
//#else
//         char_pointer error_str = strerror(errnum);
//#endif
//         str << "IO Exception (" << errno_ << "): " << error_str;
//         set_file(file_);
//         m_iLine = line_;
//         e_what_ = str;
      }
 
      explicit io_exception(string file, ::i32 line, const_char_pointer description) :
         ::exception(error_serial_io)
      {
//         ::string_stream str;
//         str << "IO Exception: " << description;
//         set_file(file_);
//         m_iLine = line_;
//         e_what_ = str;
      }
//      virtual ~io_exception() noexcept {}
//      io_exception (const io_exception& other) : line_(other.line_), e_what_(other.e_what_), errno_(other.errno_) {}
//
//      ::i32 getErrorNumber () const
//      {
//         return errno_;
//      }
//
//      virtual const_char_pointer what () const noexcept
//      {
//         return e_what_.c_str();
//      }
   };
 
   class port_not_opened_exception : public ::exception
   {
      // Disable copy constructors
   //   const port_not_opened_exception& operator=(port_not_opened_exception);
   //   string e_what_;
   public:
      port_not_opened_exception (const_char_pointer description)
      {
         //::string_stream str;
         //str << "port_not_opened_exception " << description << " failed.";
         //e_what_ = str;
      }
   //   port_not_opened_exception (const port_not_opened_exception& other) : e_what_(other.e_what_) {}
   //   virtual ~port_not_opened_exception() noexcept {}
   //   virtual const_char_pointer what () const noexcept
   //   {
   //      return e_what_.c_str();
   //   }
   };
 
 
//   /* Lists the serial ports available on the system
//    *
//    * Returns a vector of available serial ports, each represented
//    * by a serial::port_info data structure:
//    *
//    * \return vector of serial::port_info.
//    */
//   CLASS_DECL_ACME array<port_info>  list_ports();
 
 
 
   //class scoped_read_lock
   //{
   //public:
 
 
   //   serial * m_pserial;
 
 
   //   scoped_read_lock(serial * pserial) : 
   //      m_pserial(pserial)
   //   {
 
   //      m_pserial->readLock();
 
   //   }
 
 
   //   ~scoped_read_lock()
   //   {
 
   //      m_pserial->readUnlock();
 
   //   }
 
   //};
 
 
   //class scoped_write_lock
   //{
   //public:
 
   //   serial* m_pserial;
 
 
   //   scoped_write_lock(serial * pserial) :
   //      m_pserial(pserial)
   //   {
   //      
   //      m_pserial->writeLock();
 
   //   }
 
 
   //   ~scoped_write_lock()
   //   {
 
   //      m_pserial->writeUnlock();
 
   //   }
 
   //};
 
 
} // namespace serial