Myth/serial
1
0
Fork 0
mirror of https://github.com/wjwwood/serial.git synced 2026-01-22 11:44:53 +08:00
Code Issues Projects Releases Wiki Activity

Fixed all of the warnings from serial_listener

Browse Source
This commit is contained in:
William Woodall 2012-01-13 10:09:49 -06:00
parent 0046f3f61f
commit a870d49b10
2 changed files with 39 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/serial/serial_listener.h
View File

@ -159,11 +159,11 @@ class Filter
{
public:
Filter (ComparatorType comparator, DataCallback callback)
: comparator(comparator), callback(callback) {}
: comparator_(comparator), callback_(callback) {}
virtual ~Filter () {}
ComparatorType comparator;
DataCallback callback;
ComparatorType comparator_;
DataCallback callback_;
};
/*!
@ -206,14 +206,14 @@ typedef boost::shared_ptr<BufferedFilter> BufferedFilterPtr;
* \param e_what is a std::string that describes the cause of the error.
*/
class SerialListenerException : public std::exception {
const std::string e_what;
const std::string e_what_;
public:
SerialListenerException(const std::string e_what) : e_what(e_what) {}
SerialListenerException(const std::string e_what) : e_what_(e_what) {}
~SerialListenerException() throw() {std::exception::~exception();}
virtual const char* what() const throw() {
std::stringstream ss;
ss << "SerialListenerException: " << this->e_what;
ss << "SerialListenerException: " << this->e_what_;
return ss.str().c_str();
}
};
@ -250,7 +250,7 @@ public:
return true;
}
bool timed_wait_and_pop(Data& popped_value, size_t timeout) {
bool timed_wait_and_pop(Data& popped_value, long timeout) {
using namespace boost::posix_time;
bool result;
boost::mutex::scoped_lock lock(the_mutex);
@ -334,7 +334,7 @@ public:
*/
void
setChunkSize (size_t chunk_size) {
this->chunk_size = chunk_size;
this->chunk_size_ = chunk_size;
}
/***** Start and Stop Listening ******/
@ -585,10 +585,11 @@ public:
/*!
* Sleeps for a given number of milliseconds.
*
* \param ms number of milliseconds to sleep.
* \param milliseconds number of milliseconds to sleep.
*/
static void
sleep (size_t ms) {
sleep (long milliseconds) {
boost::int64_t ms(milliseconds);
boost::this_thread::sleep(boost::posix_time::milliseconds(ms));
}
@ -787,10 +788,11 @@ private:
// Persistent listening variables
bool listening;
serial::Serial * serial_port;
char serial_port_padding[7];
serial::Serial * serial_port_;
boost::thread listen_thread;
std::string data_buffer;
size_t chunk_size;
size_t chunk_size_;
// Callback related variables
// filter id, token
@ -821,13 +823,13 @@ class BlockingFilter
{
public:
BlockingFilter (ComparatorType comparator, SerialListener &listener) {
this->listener = &listener;
this->listener_ = &listener;
DataCallback cb = boost::bind(&BlockingFilter::callback, this, _1);
this->filter_ptr = this->listener->createFilter(comparator, cb);
this->filter_ptr = this->listener_->createFilter(comparator, cb);
}
virtual ~BlockingFilter () {
this->listener->removeFilter(filter_ptr);
this->listener_->removeFilter(filter_ptr);
this->result = "";
this->cond.notify_all();
}
@ -840,7 +842,7 @@ public:
*
* \return std::string token that was matched or "" if none were matched.
*/
std::string wait(size_t ms) {
std::string wait(long ms) {
this->result = "";
boost::unique_lock<boost::mutex> lock(this->mutex);
this->cond.timed_wait(lock, boost::posix_time::milliseconds(ms));
@ -855,7 +857,7 @@ public:
}
private:
SerialListener * listener;
SerialListener * listener_;
boost::condition_variable cond;
boost::mutex mutex;
std::string result;
@ -883,15 +885,15 @@ class BufferedFilter
public:
BufferedFilter (ComparatorType comparator, size_t buffer_size,
SerialListener &listener)
: buffer_size(buffer_size)
: buffer_size_(buffer_size)
{
this->listener = &listener;
this->listener_ = &listener;
DataCallback cb = boost::bind(&BufferedFilter::callback, this, _1);
this->filter_ptr = this->listener->createFilter(comparator, cb);
this->filter_ptr = this->listener_->createFilter(comparator, cb);
}
virtual ~BufferedFilter () {
this->listener->removeFilter(filter_ptr);
this->listener_->removeFilter(filter_ptr);
this->queue.clear();
this->result = "";
}
@ -907,7 +909,7 @@ public:
*
* \return std::string token that was matched or "" if none were matched.
*/
std::string wait(size_t ms) {
std::string wait(long ms) {
if (ms == 0)
if (!this->queue.try_pop(this->result))
this->result = "";
@ -935,21 +937,21 @@ public:
* Returns the capacity of the buffer.
*/
size_t capacity() {
return buffer_size;
return buffer_size_;
}
FilterPtr filter_ptr;
void callback(const std::string &token) {
std::string throw_away;
if (this->queue.size() == buffer_size)
if (this->queue.size() == this->buffer_size_)
this->queue.wait_and_pop(throw_away);
this->queue.push(token);
}
private:
size_t buffer_size;
SerialListener * listener;
size_t buffer_size_;
SerialListener * listener_;
ConcurrentQueue<std::string> queue;
std::string result;

23
src/serial_listener.cc
View File

@ -17,11 +17,10 @@ inline void defaultInfoCallback(const std::string& msg) {
inline void defaultExceptionCallback(const std::exception &error) {
std::cerr << "SerialListener Unhandled Exception: " << error.what();
std::cerr << std::endl;
throw(error);
}
inline bool defaultComparator(const std::string &token) {
return true;
return token == token;
}
using namespace serial;
@ -34,7 +33,7 @@ SerialListener::default_handler(const std::string &token) {
this->_default_handler(token);
}
SerialListener::SerialListener() : listening(false), chunk_size(5) {
SerialListener::SerialListener() : listening(false), chunk_size_(5) {
// Set default callbacks
this->handle_exc = defaultExceptionCallback;
this->info = defaultInfoCallback;
@ -68,7 +67,7 @@ SerialListener::callback() {
std::cout << (*pair.second) << std::endl;
if (this->listening) {
try {
pair.first->callback((*pair.second));
pair.first->callback_((*pair.second));
} catch (std::exception &e) {
this->handle_exc(e);
}// try callback
@ -88,8 +87,8 @@ SerialListener::startListening(Serial &serial_port) {
}
this->listening = true;
this->serial_port = &serial_port;
if (!this->serial_port->isOpen()) {
this->serial_port_ = &serial_port;
if (!this->serial_port_->isOpen()) {
throw(SerialListenerException("Serial port not open."));
return;
}
@ -110,7 +109,7 @@ SerialListener::stopListening() {
callback_thread.join();
this->data_buffer = "";
this->serial_port = NULL;
this->serial_port_ = NULL;
// Delete all the filters
this->removeAllFilters();
@ -121,20 +120,20 @@ SerialListener::determineAmountToRead() {
// TODO: Make a more intelligent method based on the length of the things
// filters are looking for. e.g.: if the filter is looking for 'V=XX\r'
// make the read amount at least 5.
return this->chunk_size;
return this->chunk_size_;
}
void
SerialListener::readSomeData(std::string &temp, size_t this_many) {
// Make sure there is a serial port
if (this->serial_port == NULL) {
if (this->serial_port_ == NULL) {
this->handle_exc(SerialListenerException("Invalid serial port."));
}
// Make sure the serial port is open
if (!this->serial_port->isOpen()) {
if (!this->serial_port_->isOpen()) {
this->handle_exc(SerialListenerException("Serial port not open."));
}
temp = this->serial_port->read(this_many);
temp = this->serial_port_->read(this_many);
}
void
@ -159,7 +158,7 @@ SerialListener::filter (FilterPtr filter, std::vector<TokenPtr> &tokens)
if (it == tokens.end()-1)
continue;
TokenPtr token = (*it);
if (filter->comparator((*token)))
if (filter->comparator_((*token)))
callback_queue.push(std::make_pair(filter,token));
}
}