Whitespace changes

Author: tstenner

clirecorder.cpp

@@ -1,10 +1,10 @@
 #include "recording.h"
 #include "xdfwriter.h"
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
 	if (argc < 3 || (argc == 2 && std::string(argv[1]) == "-h")) {
 		std::cout << "Usage: " << argv[0] << " outputfile.xdf 'searchstr' ['searchstr2' ...]\n\n"
-		          << "searchstr can be anything accepted by lsl_resolve_bypred\n";
+				  << "searchstr can be anything accepted by lsl_resolve_bypred\n";
 		std::cout << "Keep in mind that your shell might remove quotes\n";
 		std::cout << "Examples:\n\t" << argv[0] << " foo.xdf 'type=\"EEG\"' ";
 		std::cout << " 'host=\"LabPC1\" or host=\"LabPC2\"'\n\t";
@@ -14,17 +14,17 @@ int main(int argc, char** argv) {
 
 	std::vector<lsl::stream_info> infos = lsl::resolve_streams(), recordstreams;
 
-	for(int i = 2; i < argc; ++i) {
+	for (int i = 2; i < argc; ++i) {
 		bool matched = false;
-		for(const auto& info: infos) {
-			if(info.matches_query(argv[i])) {
+		for (const auto &info : infos) {
+			if (info.matches_query(argv[i])) {
 				std::cout << "Found " << info.name() << '@' << info.hostname();
 				std::cout << " matching '" << argv[i] << "'\n";
 				matched = true;
 				recordstreams.emplace_back(info);
 			}
 		}
-		if(!matched) {
+		if (!matched) {
 			std::cout << '"' << argv[i] << "\" matched no stream!\n";
 			return 2;
 		}

conversions.h

@@ -6,9 +6,9 @@
 #define CONVERSIONS_H_
 
 #include <cstdint>
+#include <limits>
 #include <ostream>
 #include <vector>
-#include <limits>
 
 #ifdef EXOTIC_ARCH_SUPPORT
 #include <boost/version.hpp>
@@ -31,19 +31,21 @@ using boost::endian::native_to_little_inplace;
 // write an integer value in little endian
 // derived from portable archive code by christian.pfligersdorffer@eos.info (under boost license)
 template <typename T>
-typename std::enable_if<std::is_integral<T>::value>::type write_little_endian(std::ostream& dst, T t) {
+typename std::enable_if<std::is_integral<T>::value>::type write_little_endian(
+	std::ostream &dst, T t) {
 	native_to_little_inplace(t);
-	dst->sputn(reinterpret_cast<const char*>(&t), sizeof(t));
+	dst->sputn(reinterpret_cast<const char *>(&t), sizeof(t));
 }
 
 // write a floating-point value in little endian
 // derived from portable archive code by christian.pfligersdorffer@eos.info (under boost license)
 template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value>::type
-write_little_endian(std::ostream& dst, T t) {
-	//Get a type big enough to hold
+typename std::enable_if<std::is_floating_point<T>::value>::type write_little_endian(
+	std::ostream &dst, T t) {
+	// Get a type big enough to hold
 	using traits = typename fp::detail::fp_traits<T>::type;
-	static_assert(sizeof(typename traits::bits) == sizeof(T), "floating point type can't be represented accurately");
+	static_assert(sizeof(typename traits::bits) == sizeof(T),
+		"floating point type can't be represented accurately");
 
 	typename traits::bits bits;
 	// remap to bit representation
@@ -60,51 +62,50 @@ write_little_endian(std::ostream& dst, T t) {
 
 // store a sample's values to a stream (numeric version) */
 template <class T>
-inline const T* write_sample_values(std::ostream& dst, const T* sample, std::size_t len) {
+inline const T *write_sample_values(std::ostream &dst, const T *sample, std::size_t len) {
 	// [Value1] .. [ValueN] */
-	for(const T* end = sample + len; sample < end; ++sample)
-		write_little_endian(dst, *sample);
+	for (const T *end = sample + len; sample < end; ++sample) write_little_endian(dst, *sample);
 	return sample;
 }
 
 #else
 
 static_assert(std::numeric_limits<float>::is_iec559,
-              "Non-IEC559/IEEE754-floats need EXOTIC_ARCH_SUPPORT defined");
+	"Non-IEC559/IEEE754-floats need EXOTIC_ARCH_SUPPORT defined");
 static_assert(std::numeric_limits<float>::has_denorm, "denormalized floats not supported");
 static_assert(sizeof(float) == 4, "Unexpected float size!");
 static_assert(sizeof(double) == 8, "Unexpected double size!");
 
 template <typename T>
-typename std::enable_if<sizeof(T) == 1>::type write_little_endian(std::ostream& dst, T t) {
+typename std::enable_if<sizeof(T) == 1>::type write_little_endian(std::ostream &dst, T t) {
 	dst.put(t);
 }
 
 template <typename T>
-typename std::enable_if<sizeof(T) >= 2>::type write_little_endian(std::ostream& dst, T t) {
-	dst.write(reinterpret_cast<const char*>(&t), sizeof(T));
+typename std::enable_if<sizeof(T) >= 2>::type write_little_endian(std::ostream &dst, T t) {
+	dst.write(reinterpret_cast<const char *>(&t), sizeof(T));
 }
 
 template <class T>
-inline const T* write_sample_values(std::ostream& dst, const T* sample, std::size_t len) {
+inline const T *write_sample_values(std::ostream &dst, const T *sample, std::size_t len) {
 	// [Value1] .. [ValueN] */
-	dst.write(reinterpret_cast<const char*>(sample), len * sizeof(T));
+	dst.write(reinterpret_cast<const char *>(sample), len * sizeof(T));
 	return sample + len;
 }
 #endif
 
 template <class T>
-inline void write_sample_values(std::ostream& dst, const std::vector<T>& sample) {
+inline void write_sample_values(std::ostream &dst, const std::vector<T> &sample) {
 	write_sample_values(dst, sample.data(), sample.size());
 }
 
 template <typename T>
-inline void write_sample_values(std::ostream& buf, const std::vector<std::vector<T>>& vecs) {
-	for (const std::vector<T>& vec : vecs) write_sample_values(buf, vec);
+inline void write_sample_values(std::ostream &buf, const std::vector<std::vector<T>> &vecs) {
+	for (const std::vector<T> &vec : vecs) write_sample_values(buf, vec);
 }
 
 // write a variable-length integer (int8, int32, or int64)
-inline void write_varlen_int(std::ostream& dst, uint64_t val) {
+inline void write_varlen_int(std::ostream &dst, uint64_t val) {
 	if (val < 256) {
 		dst.put(1);
 		dst.put(static_cast<uint8_t>(val));
@@ -117,18 +118,18 @@ inline void write_varlen_int(std::ostream& dst, uint64_t val) {
 	}
 }
 
-template<typename T>
-inline void write_fixlen_int(std::ostream& dst, T val) {
+template <typename T> inline void write_fixlen_int(std::ostream &dst, T val) {
 	dst.put(sizeof(T));
 	write_little_endian(dst, val);
 }
 
 
 // store a sample's values to a stream (string version)
 template <>
-inline const std::string* write_sample_values(std::ostream& dst, const std::string* sample, std::size_t len) {
+inline const std::string *write_sample_values(
+	std::ostream &dst, const std::string *sample, std::size_t len) {
 	// [Value1] .. [ValueN] */
-	for(const std::string* end = sample + len; sample < end; ++sample) {
+	for (const std::string *end = sample + len; sample < end; ++sample) {
 		// [NumLengthBytes], [Length] (as varlen int)
 		write_varlen_int(dst, sample->size());
 		// [StringContent] */

fptest.cpp

@@ -1,23 +1,20 @@
 #include <iostream>
 
 int main() {
-	const double sampling_rate = 500,
-	      sample_interval = 1.0 / sampling_rate,
-	      first_timestamp = 60*60*24*365*48; // e.g. a unix timestamp
+	const double sampling_rate = 500, sample_interval = 1.0 / sampling_rate,
+				 first_timestamp = 60 * 60 * 24 * 365 * 48; // e.g. a unix timestamp
 	double last_timestamp = first_timestamp;
 	int full = 0, deduced = 0;
 	const int iterations = 100000;
 	double timestamps[iterations];
-	for(int i=0;i<iterations; ++i)
-		timestamps[i] = first_timestamp + i/sampling_rate;
-	for(int i=0; i<iterations; ++i) {
-		if(last_timestamp + sample_interval == timestamps[i])
+	for (int i = 0; i < iterations; ++i) timestamps[i] = first_timestamp + i / sampling_rate;
+	for (int i = 0; i < iterations; ++i) {
+		if (last_timestamp + sample_interval == timestamps[i])
 			deduced++;
-		else full++;
+		else
+			full++;
 		last_timestamp = timestamps[i];
 	}
 	std::cout << "Deduced: " << deduced << "\nFully written: " << full << std::endl;
 	return 0;
 }
-
-

main.cpp

@@ -1,18 +1,17 @@
-#include <QApplication>
 #include "mainwindow.h"
+#include <QApplication>
+
+int main(int argc, char *argv[]) {
 
-int main(int argc, char *argv[])
-{
+	// determine the startup config file...
+	const char *config_file = "default_config.cfg";
+	for (int k = 1; k < argc; k++)
+		if (std::string(argv[k]) == "-c" || std::string(argv[k]) == "--config")
+			config_file = argv[k + 1];
 
-    // determine the startup config file...
-	const char* config_file = "default_config.cfg";
-    for (int k=1;k<argc;k++)
-        if (std::string(argv[k]) == "-c" || std::string(argv[k]) == "--config")
-            config_file = argv[k+1];
+	QApplication a(argc, argv);
+	MainWindow w(nullptr, config_file);
+	w.show();
 
-    QApplication a(argc, argv);
-    MainWindow w(nullptr, config_file);
-    w.show();
-    
-    return a.exec();
+	return a.exec();
 }