Event refactor builds on Windows

include/icsneo/device/device.h

@@ -4,7 +4,7 @@
 #include <vector>
 #include <memory>
 #include <cstring>
-#include "icsneo/api/errormanager.h"
+#include "icsneo/api/eventmanager.h"
 #include "icsneo/device/neodevice.h"
 #include "icsneo/device/idevicesettings.h"
 #include "icsneo/device/nullsettings.h"
@@ -88,7 +88,7 @@ protected:
 	bool online = false;
 	int messagePollingCallbackID = 0;
 	int internalHandlerCallbackID = 0;
-	device_errorhandler_t err;
+	device_eventhandler_t report;
 
 	// START Initialization Functions
 	Device(neodevice_t neodevice = { 0 }) {
@@ -98,7 +98,7 @@ protected:
 	
 	template<typename Transport, typename Settings = NullSettings>
 	void initialize() {
-		err = makeErrorHandler();
+		report = makeEventHandler();
 		auto transport = makeTransport<Transport>();
 		setupTransport(*transport);
 		auto packetizer = makePacketizer();
@@ -115,31 +115,31 @@ protected:
 		setupSupportedTXNetworks(supportedTXNetworks);
 	}
 
-	virtual device_errorhandler_t makeErrorHandler() {
-		return [this](APIError::ErrorType type) { 
+	virtual device_eventhandler_t makeEventHandler() {
+		return [this](APIEvent::Type type, APIEvent::Severity severity) { 
 			if(!destructing)
-				ErrorManager::GetInstance().add(type, this); 
+				EventManager::GetInstance().add(type, severity, this); 
 		};
 	}
 
 	template<typename Transport>
-	std::unique_ptr<ICommunication> makeTransport() { return std::unique_ptr<ICommunication>(new Transport(err, getWritableNeoDevice())); }
+	std::unique_ptr<ICommunication> makeTransport() { return std::unique_ptr<ICommunication>(new Transport(report, getWritableNeoDevice())); }
 	virtual void setupTransport(ICommunication&) {}
 
-	virtual std::shared_ptr<Packetizer> makePacketizer() { return std::make_shared<Packetizer>(err); }
+	virtual std::shared_ptr<Packetizer> makePacketizer() { return std::make_shared<Packetizer>(report); }
 	virtual void setupPacketizer(Packetizer&) {}
 
-	virtual std::unique_ptr<Encoder> makeEncoder(std::shared_ptr<Packetizer> p) { return std::unique_ptr<Encoder>(new Encoder(err, p)); }
+	virtual std::unique_ptr<Encoder> makeEncoder(std::shared_ptr<Packetizer> p) { return std::unique_ptr<Encoder>(new Encoder(report, p)); }
 	virtual void setupEncoder(Encoder&) {}
 
-	virtual std::unique_ptr<Decoder> makeDecoder() { return std::unique_ptr<Decoder>(new Decoder(err)); }
+	virtual std::unique_ptr<Decoder> makeDecoder() { return std::unique_ptr<Decoder>(new Decoder(report)); }
 	virtual void setupDecoder(Decoder&) {}
 
 	virtual std::shared_ptr<Communication> makeCommunication(
 		std::unique_ptr<ICommunication> t,
 		std::shared_ptr<Packetizer> p,
 		std::unique_ptr<Encoder> e,
-		std::unique_ptr<Decoder> d) { return std::make_shared<Communication>(err, std::move(t), p, std::move(e), std::move(d)); }
+		std::unique_ptr<Decoder> d) { return std::make_shared<Communication>(report, std::move(t), p, std::move(e), std::move(d)); }
 	virtual void setupCommunication(Communication&) {}
 
 	template<typename Settings>

include/icsneo/device/idevicesettings.h

@@ -334,7 +334,7 @@ public:
 	static CANBaudrate GetEnumValueForBaudrate(int64_t baudrate);
 	static int64_t GetBaudrateValueForEnum(CANBaudrate enumValue);
 
-	IDeviceSettings(std::shared_ptr<Communication> com, size_t size) : com(com), err(com->err), structSize(size) {}
+	IDeviceSettings(std::shared_ptr<Communication> com, size_t size) : com(com), report(com->report), structSize(size) {}
 	virtual ~IDeviceSettings() {}
 	bool ok() { return !disabled && settingsLoaded; }
 	
@@ -406,7 +406,7 @@ public:
 	bool disableGSChecksumming = false;
 protected:
 	std::shared_ptr<Communication> com;
-	device_errorhandler_t err;
+	device_eventhandler_t report;
 	size_t structSize;
 
 	// if we hold any local copies of the device settings
@@ -418,7 +418,7 @@ protected:
 	// Parameter createInoperableSettings exists because it is serving as a warning that you probably don't want to do this
 	typedef void* warn_t;
 	IDeviceSettings(warn_t createInoperableSettings, std::shared_ptr<Communication> com)
-		: disabled(true), readonly(true), err(com->err), structSize(0) { (void)createInoperableSettings; }
+		: disabled(true), readonly(true), report(com->report), structSize(0) { (void)createInoperableSettings; }
 };
 
 }

include/icsneo/device/plasion/plasion.h

@@ -14,7 +14,7 @@ protected:
 		std::shared_ptr<Packetizer> packetizer,
 		std::unique_ptr<Encoder> encoder,
 		std::unique_ptr<Decoder> decoder
-	) override { return std::make_shared<MultiChannelCommunication>(err, std::move(transport), packetizer, std::move(encoder), std::move(decoder)); }
+	) override { return std::make_shared<MultiChannelCommunication>(report, std::move(transport), packetizer, std::move(encoder), std::move(decoder)); }
 
 	// TODO: This is done so that Plasion can still transmit it's basic networks, awaiting VLAN support
 	virtual bool isSupportedRXNetwork(const Network&) const override { return true; }