Convert channel_count to unsigned int to prevent MSVC warnings

Author: tstenner

src/data_receiver.cpp

@@ -71,7 +71,7 @@ void data_receiver::close_stream() {
 }
 
 template <class T>
-double data_receiver::pull_sample_typed(T *buffer, int buffer_elements, double timeout) {
+double data_receiver::pull_sample_typed(T *buffer, uint32_t buffer_elements, double timeout) {
 	if (conn_.lost())
 		throw lost_error("The stream read by this outlet has been lost. To recover, you need to "
 						 "re-resolve the source and re-create the inlet.");
@@ -95,13 +95,13 @@ double data_receiver::pull_sample_typed(T *buffer, int buffer_elements, double t
 	}
 }
 
-template double data_receiver::pull_sample_typed<char>(char *, int, double);
-template double data_receiver::pull_sample_typed<int16_t>(int16_t *, int, double);
-template double data_receiver::pull_sample_typed<int32_t>(int32_t *, int, double);
-template double data_receiver::pull_sample_typed<int64_t>(int64_t *, int, double);
-template double data_receiver::pull_sample_typed<float>(float *, int, double);
-template double data_receiver::pull_sample_typed<double>(double *, int, double);
-template double data_receiver::pull_sample_typed<std::string>(std::string *, int, double);
+template double data_receiver::pull_sample_typed<char>(char *, uint32_t, double);
+template double data_receiver::pull_sample_typed<int16_t>(int16_t *, uint32_t, double);
+template double data_receiver::pull_sample_typed<int32_t>(int32_t *, uint32_t, double);
+template double data_receiver::pull_sample_typed<int64_t>(int64_t *, uint32_t, double);
+template double data_receiver::pull_sample_typed<float>(float *, uint32_t, double);
+template double data_receiver::pull_sample_typed<double>(double *, uint32_t, double);
+template double data_receiver::pull_sample_typed<std::string>(std::string *, uint32_t, double);
 
 double data_receiver::pull_sample_untyped(void *buffer, int buffer_bytes, double timeout) {
 	if (conn_.lost())

src/data_receiver.h

@@ -61,7 +61,7 @@ class data_receiver : public cancellable_registry {
 
 	/// Retrieve a sample from the sample queue and assign its contents to the given typed buffer.
 	template <class T>
-	double pull_sample_typed(T *buffer, int buffer_elements, double timeout = FOREVER);
+	double pull_sample_typed(T *buffer, uint32_t buffer_elements, double timeout = FOREVER);
 
 	/// Read sample from the inlet and read it into a pointer to raw data.
 	double pull_sample_untyped(void *buffer, int buffer_bytes, double timeout = FOREVER);

src/lsl_inlet_c.cpp

@@ -282,7 +282,7 @@ LIBLSL_C_API unsigned long lsl_pull_chunk_str(lsl_inlet in, char **data_buffer,
 		// capture output in a temporary string buffer
 		if (data_buffer_elements) {
 			std::vector<std::string> tmp(data_buffer_elements);
-			unsigned long result = in->pull_chunk_multiplexed(&tmp[0], timestamp_buffer,
+			uint32_t result = in->pull_chunk_multiplexed(&tmp[0], timestamp_buffer,
 				data_buffer_elements, timestamp_buffer_elements, timeout);
 			// allocate memory and copy over into buffer
 			for (std::size_t k = 0; k < tmp.size(); k++) {
@@ -320,7 +320,7 @@ LIBLSL_C_API unsigned long lsl_pull_chunk_buf(lsl_inlet in, char **data_buffer,
 		// capture output in a temporary string buffer
 		if (data_buffer_elements) {
 			std::vector<std::string> tmp(data_buffer_elements);
-			unsigned long result = in->pull_chunk_multiplexed(&tmp[0], timestamp_buffer,
+			uint32_t result = in->pull_chunk_multiplexed(&tmp[0], timestamp_buffer,
 				data_buffer_elements, timestamp_buffer_elements, timeout);
 			// allocate memory and copy over into buffer
 			for (uint32_t k = 0; k < tmp.size(); k++) {

src/lsl_resolver_c.cpp

@@ -28,8 +28,8 @@ LIBLSL_C_API int32_t lsl_resolver_results(
 		std::vector<stream_info_impl> tmp = res->results(buffer_elements);
 		// allocate new stream_info_impl's and assign to the buffer
 		for (uint32_t k = 0; k < tmp.size(); k++) buffer[k] = new stream_info_impl(tmp[k]);
-		return tmp.size();
-	} catch (std::exception &e) {
+		return static_cast<int32_t>(tmp.size());
+	} catch(std::exception &e) {
 		LOG_F(WARNING, "Unexpected error querying lsl_resolver_results: %s", e.what());
 		return lsl_internal_error;
 	}

src/sample.cpp

@@ -5,12 +5,12 @@
 
 using namespace lsl;
 
-bool sample::operator==(const sample &rhs) const BOOST_NOEXCEPT {
+bool sample::operator==(const sample &rhs) const noexcept {
 	if ((timestamp != rhs.timestamp) || (format_ != rhs.format_) ||
 		(num_channels_ != rhs.num_channels_))
 		return false;
 	if (format_ != cft_string)
-		return memcmp(&(rhs.data_), &data_, format_sizes[format_] * num_channels_) == 0;
+		return memcmp(&(rhs.data_), &data_, datasize()) == 0;
 	else {
 		std::string *data = (std::string *)&data_;
 		std::string *rhsdata = (std::string *)&(rhs.data_);
@@ -111,7 +111,7 @@ void sample::load_raw(std::streambuf &sb, void *address, std::size_t count) {
 }
 
 void sample::save_streambuf(
-	std::streambuf &sb, int protocol_version, int use_byte_order, void *scratchpad) const {
+	std::streambuf &sb, int /*protocol_version*/, int use_byte_order, void *scratchpad) const {
 	// write sample header
 	if (timestamp == DEDUCED_TIMESTAMP) {
 		save_value(sb, TAG_DEDUCED_TIMESTAMP, use_byte_order);
@@ -146,17 +146,16 @@ void sample::save_streambuf(
 	} else {
 		// write numeric data in binary
 		if (use_byte_order == BOOST_BYTE_ORDER || format_sizes[format_] == 1) {
-			save_raw(sb, &data_, format_sizes[format_] * num_channels_);
+			save_raw(sb, &data_, datasize());
 		} else {
-			memcpy(scratchpad, &data_, format_sizes[format_] * num_channels_);
+			memcpy(scratchpad, &data_, datasize());
 			convert_endian(scratchpad);
-			save_raw(sb, scratchpad, format_sizes[format_] * num_channels_);
+			save_raw(sb, scratchpad, datasize());
 		}
 	}
 }
 
-void sample::load_streambuf(
-	std::streambuf &sb, int protocol_version, int use_byte_order, bool suppress_subnormals) {
+void sample::load_streambuf(std::streambuf &sb, int, int use_byte_order, bool suppress_subnormals) {
 	// read sample header
 	uint8_t tag;
 	load_value(sb, tag, use_byte_order);
@@ -208,7 +207,7 @@ void sample::load_streambuf(
 		}
 	} else {
 		// read numeric channel data
-		load_raw(sb, &data_, format_sizes[format_] * num_channels_);
+		load_raw(sb, &data_, datasize());
 		if (use_byte_order != BOOST_BYTE_ORDER && format_sizes[format_] > 1) convert_endian(&data_);
 		if (suppress_subnormals && format_float[format_]) {
 			if (format_ == cft_float32) {
@@ -226,8 +225,7 @@ void sample::load_streambuf(
 	}
 }
 
-template <class Archive>
-void sample::serialize_channels(Archive &ar, const uint32_t archive_version) {
+template <class Archive> void sample::serialize_channels(Archive &ar, const uint32_t) {
 	switch (format_) {
 	case cft_float32:
 		for (float *p = (float *)&data_, *e = p + num_channels_; p < e; ar & *p++)
@@ -289,52 +287,49 @@ void sample::load(eos::portable_iarchive &ar, const uint32_t archive_version) {
 	serialize_channels(ar, archive_version);
 }
 
+template <typename T> void test_pattern(T *data, uint32_t num_channels, int offset) {
+	const int mod = std::is_integral<T>::value ? (int)std::numeric_limits<T>::max() : 1;
+	for (std::size_t k = 0; k < num_channels; k++) {
+		data[k] = static_cast<T>((k + static_cast<std::size_t>(offset)) % mod);
+		if (k % 2 == 1) data[k] = -data[k];
+	}
+}
+
 sample &sample::assign_test_pattern(int offset) {
 	pushthrough = 1;
 	timestamp = 123456.789;
 
 	switch (format_) {
-	case cft_float32: {
-		float *data = (float *)&data_;
-		for (int k = 0; k < num_channels_; k++)
-			data[k] = ((float)k + (float)offset) * (k % 2 == 0 ? 1 : -1);
+	case cft_float32:
+		test_pattern(reinterpret_cast<float *>(&data_), num_channels_, offset + 0);
 		break;
-	}
-	case cft_double64: {
-		double *data = (double *)&data_;
-		for (int k = 0; k < num_channels_; k++)
-			data[k] = (k + offset + 16777217) * (k % 2 == 0 ? 1 : -1);
+	case cft_double64:
+		test_pattern(reinterpret_cast<double *>(&data_), num_channels_, offset + 16777217);
 		break;
-	}
 	case cft_string: {
 		std::string *data = (std::string *)&data_;
-		for (int k = 0; k < num_channels_; k++)
-			data[k] = to_string((k + 10) * (k % 2 == 0 ? 1 : -1));
+		offset += 10;
+		for (uint32_t k = 0u; k < num_channels_; k++)
+			data[k] = to_string(k * (k % 2 == 0 ? 1 : -1));
 		break;
 	}
-	case cft_int32: {
-		int32_t *data = (int32_t *)&data_;
-		for (int k = 0; k < num_channels_; k++)
-			data[k] = ((k + offset + 65537) % 2147483647) * (k % 2 == 0 ? 1 : -1);
+	case cft_int32:
+		test_pattern(reinterpret_cast<int32_t *>(&data_), num_channels_, offset + 65537);
 		break;
-	}
-	case cft_int16: {
-		int16_t *data = (int16_t *)&data_;
-		for (int k = 0; k < num_channels_; k++)
-			data[k] = (int16_t)(((k + offset + 257) % 32767) * (k % 2 == 0 ? 1 : -1));
+	case cft_int16:
+		test_pattern(reinterpret_cast<int16_t *>(&data_), num_channels_, offset + 257);
 		break;
-	}
-	case cft_int8: {
-		int8_t *data = (int8_t *)&data_;
-		for (int k = 0; k < num_channels_; k++)
-			data[k] = (int8_t)(((k + offset + 1) % 127) * (k % 2 == 0 ? 1 : -1));
+	case cft_int8:
+		test_pattern(reinterpret_cast<int8_t *>(&data_), num_channels_, offset + 1);
 		break;
-	}
 #ifndef BOOST_NO_INT64_T
 	case cft_int64: {
 		int64_t *data = (int64_t *)&data_;
-		for (int k = 0; k < num_channels_; k++)
-			data[k] = ((2 + k + (int64_t)offset + 2147483647)) * (int64_t)(k % 2 == 0 ? 1 : -1);
+		int64_t offset64 = 2147483649ll + offset;
+		for (uint32_t k = 0; k < num_channels_; k++) {
+			data[k] = (k + offset64);
+			if (k % 2 == 1) data[k] = -data[k];
+		}
 		break;
 	}
 #endif
@@ -344,11 +339,11 @@ sample &sample::assign_test_pattern(int offset) {
 	return *this;
 }
 
-factory::factory(lsl_channel_format_t fmt, int num_chans, int num_reserve)
+factory::factory(lsl_channel_format_t fmt, uint32_t num_chans, uint32_t num_reserve)
 	: fmt_(fmt), num_chans_(num_chans),
 	  sample_size_(
 		  ensure_multiple(sizeof(sample) - sizeof(char) + format_sizes[fmt] * num_chans, 16)),
-	  storage_size_(sample_size_ * std::max(1, num_reserve)), storage_(new char[storage_size_]),
+	  storage_size_(sample_size_ * std::max(1u, num_reserve)), storage_(new char[storage_size_]),
 	  sentinel_(new_sample_unmanaged(fmt, num_chans, 0.0, false)), head_(sentinel_),
 	  tail_(sentinel_) {
 	// pre-construct an array of samples in the storage area and chain into a freelist
@@ -374,7 +369,7 @@ sample_p factory::new_sample(double timestamp, bool pushthrough) {
 }
 
 sample *factory::new_sample_unmanaged(
-	lsl_channel_format_t fmt, int num_chans, double timestamp, bool pushthrough) {
+	lsl_channel_format_t fmt, uint32_t num_chans, double timestamp, bool pushthrough) {
 #pragma warning(suppress : 4291)
 	sample *result = new (new char[ensure_multiple(
 		sizeof(sample) - sizeof(char) + format_sizes[fmt] * num_chans, 16)])

src/sample.h

@@ -40,7 +40,7 @@ const uint8_t TAG_DEDUCED_TIMESTAMP = 1;
 const uint8_t TAG_TRANSMITTED_TIMESTAMP = 2;
 
 /// channel format properties
-const int format_sizes[] = {0, sizeof(float), sizeof(double), sizeof(std::string), sizeof(int32_t),
+const uint8_t format_sizes[] = {0, sizeof(float), sizeof(double), sizeof(std::string), sizeof(int32_t),
 	sizeof(int16_t), sizeof(int8_t), 8};
 const bool format_ieee754[] = {false, std::numeric_limits<float>::is_iec559,
 	std::numeric_limits<double>::is_iec559, false, false, false, false, false};
@@ -54,8 +54,13 @@ const bool format_float[] = {false, true, true, false, false, false, false, fals
 /// A factory to create samples of a given format/size. Must outlive all of its created samples.
 class factory {
 public:
-	/// Create a new factory and optionally pre-allocate samples.
-	factory(lsl_channel_format_t fmt, int num_chans, int num_reserve);
+	/**
+	 * Create a new factory and optionally pre-allocate samples.
+	 * @param fmt Sample format
+	 * @param num_chans nr of channels
+	 * @param num_reserve nr of samples to pre-allocate in the storage pool
+	 */
+	factory(lsl_channel_format_t fmt, uint32_t num_chans, uint32_t num_reserve);
 
 	/// Destroy the factory and delete all of its samples.
 	~factory();
@@ -69,7 +74,7 @@ class factory {
 
 	/// Create a new sample whose memory is not managed by the factory.
 	static sample *new_sample_unmanaged(
-		lsl_channel_format_t fmt, int num_chans, double timestamp, bool pushthrough);
+		lsl_channel_format_t fmt, uint32_t num_chans, double timestamp, bool pushthrough);
 
 private:
 	/// ensure that a given value is a multiple of some base, round up if necessary
@@ -84,11 +89,11 @@ class factory {
 	/// the channel format to construct samples with
 	lsl_channel_format_t fmt_;
 	/// the number of channels to construct samples with
-	int num_chans_;
+	const uint32_t num_chans_;
 	/// size of a sample, in bytes
-	int sample_size_;
+	const uint32_t sample_size_;
 	/// size of the allocated storage, in bytes
-	int storage_size_;
+	uint32_t storage_size_;
 	/// a slab of storage for pre-allocated samples
 	char *storage_;
 	/// a sentinel element for our freelist
@@ -116,15 +121,15 @@ class sample {
 	/// the channel format
 	lsl_channel_format_t format_;
 	/// number of channels
-	int num_channels_;
+	uint32_t num_channels_;
 	/// reference count used by sample_p
 	std::atomic<int> refcount_;
 	/// linked list of samples, for use in a freelist
 	std::atomic<sample *> next_;
 	/// the factory used to reclaim this sample, if any
 	factory *factory_;
 	/// the data payload begins here
-	BOOST_ALIGNMENT(8) char data_;
+	alignas(8) char data_;
 
 public:
 	// === Construction ===
@@ -150,14 +155,16 @@ class sample {
 	/// Test for equality with another sample.
 	bool operator==(const sample &rhs) const noexcept;
 
+	std::size_t datasize() const { return format_sizes[format_] * num_channels_; }
+
 	// === type-safe accessors ===
 
 	/// Assign an array of numeric values (with type conversions).
 	template <class T> sample &assign_typed(const T *s) {
 		if ((sizeof(T) == format_sizes[format_]) &&
 			((std::is_integral<T>::value && format_integral[format_]) ||
 				(std::is_floating_point<T>::value && format_float[format_]))) {
-			memcpy(&data_, s, format_sizes[format_] * num_channels_);
+			memcpy(&data_, s, datasize());
 		} else {
 			switch (format_) {
 			case cft_float32:
@@ -207,7 +214,7 @@ class sample {
 		if ((sizeof(T) == format_sizes[format_]) &&
 			((std::is_integral<T>::value && format_integral[format_]) ||
 				(std::is_floating_point<T>::value && format_float[format_]))) {
-			memcpy(d, &data_, format_sizes[format_] * num_channels_);
+			memcpy(d, &data_, datasize());
 		} else {
 			switch (format_) {
 			case cft_float32:
@@ -258,7 +265,7 @@ class sample {
 	/// Assign numeric data to the sample.
 	sample &assign_untyped(const void *newdata) {
 		if (format_ != cft_string)
-			memcpy(&data_, newdata, format_sizes[format_] * num_channels_);
+			memcpy(&data_, newdata, datasize());
 		else
 			throw std::invalid_argument("Cannot assign untyped data to a string-formatted sample.");
 		return *this;
@@ -267,7 +274,7 @@ class sample {
 	/// Retrieve numeric data from the sample.
 	sample &retrieve_untyped(void *newdata) {
 		if (format_ != cft_string)
-			memcpy(newdata, &data_, format_sizes[format_] * num_channels_);
+			memcpy(newdata, &data_, datasize());
 		else
 			throw std::invalid_argument(
 				"Cannot retrieve untyped data from a string-formatted sample.");
@@ -295,7 +302,7 @@ class sample {
 	}
 
 	/// Load a value from a stream buffer; specialization of the above.
-	void load_value(std::streambuf &sb, uint8_t &v, int use_byte_order) {
+	void load_value(std::streambuf &sb, uint8_t &v, int) {
 		load_raw(sb, &v, sizeof(v));
 	}
 
@@ -353,7 +360,7 @@ class sample {
 
 private:
 	/// Construct a new sample for a given channel format/count combination.
-	sample(lsl_channel_format_t fmt, int num_channels, factory *fact)
+	sample(lsl_channel_format_t fmt, uint32_t num_channels, factory *fact)
 		: format_(fmt), num_channels_(num_channels), refcount_(0), next_(nullptr), factory_(fact) {
 		if (format_ == cft_string)
 			for (std::string *p = (std::string *)&data_, *e = p + num_channels_; p < e;

src/send_buffer.cpp

@@ -3,8 +3,6 @@
 #include <memory>
 
 
-// === implementation of the send_buffer class ===
-
 using namespace lsl;
 
 /**

src/stream_info_impl.h

@@ -108,7 +108,7 @@ class stream_info_impl {
 	const std::string &type() const { return type_; }
 
 	/// Get the number of channels of a stream.
-	int channel_count() const { return channel_count_; }
+	uint32_t channel_count() const { return channel_count_; }
 
 	/// Get the sampling rate of a stream (in Hz) as advertised by the device.
 	double nominal_srate() const { return nominal_srate_; }
@@ -227,7 +227,7 @@ class stream_info_impl {
 	// data information
 	std::string name_;
 	std::string type_;
-	int channel_count_;
+	uint32_t channel_count_;
 	double nominal_srate_;
 	lsl_channel_format_t channel_format_;
 	std::string source_id_;