Error system now functional in C and C++ APIs

api/icsneoc/icsneoc.cpp

@@ -376,4 +376,83 @@ bool icsneo_describeDevice(const neodevice_t* device, char* str, size_t* maxLeng
 
 neoversion_t icsneo_getVersion(void) {
 	return icsneo::GetVersion();
+}
+
+bool icsneo_getErrors(neoerror_t* errors, size_t* size) {
+	if(size == nullptr) {
+		ErrorManager::GetInstance().add(APIError::RequiredParameterNull);
+		return false;
+	}
+
+	if(errors == nullptr) {
+		*size = icsneo::ErrorCount();
+		return false;
+	}
+
+	auto cppErrors = icsneo::GetErrors(*size);
+	for(size_t i = 0; i < cppErrors.size(); i++)
+		memcpy(&errors[i], cppErrors[i].getNeoError(), sizeof(neoerror_t));
+	*size = cppErrors.size();
+
+	return true;
+}
+
+bool icsneo_getDeviceErrors(const neodevice_t* device, neoerror_t* errors, size_t* size) {
+	if(!icsneo_isValidNeoDevice(device)) {
+		ErrorManager::GetInstance().add(APIError::InvalidNeoDevice);
+		return false;
+	}
+
+	if(size == nullptr) {
+		ErrorManager::GetInstance().add(APIError::RequiredParameterNull);
+		return false;
+	}
+
+	ErrorFilter filter = (icsneo::Device*)device->device;
+
+	if(errors == nullptr) {
+		*size = icsneo::ErrorCount(filter);
+		return false;
+	}
+
+	auto cppErrors = icsneo::GetErrors(*size, filter);
+	for(size_t i = 0; i < cppErrors.size(); i++)
+		memcpy(&errors[i], cppErrors[i].getNeoError(), sizeof(neoerror_t));
+	*size = cppErrors.size();
+
+	return true;
+}
+
+bool icsneo_getLastError(neoerror_t* error) {
+	if(error == nullptr) {
+		ErrorManager::GetInstance().add(APIError::RequiredParameterNull);
+		return false;
+	}
+
+	APIError cppErr;
+	if(!icsneo::GetLastError(cppErr))
+		return false;
+	memcpy(error, cppErr.getNeoError(), sizeof(neoerror_t));
+	return true;
+}
+
+void icsneo_discardAllErrors(void) {
+	icsneo::DiscardErrors();
+}
+
+void icsneo_discardDeviceErrors(const neodevice_t* device) {
+	if(!icsneo_isValidNeoDevice(device)) {
+		ErrorManager::GetInstance().add(APIError::InvalidNeoDevice);
+		return;
+	}
+
+	icsneo::DiscardErrors(icsneo::ErrorFilter((icsneo::Device*)device->device));
+}
+
+void icsneo_setErrorLimit(size_t newLimit) {
+	icsneo::SetErrorLimit(newLimit);
+}
+
+size_t icsneo_getErrorLimit(void) {
+	return icsneo::GetErrorLimit();
 }

api/icsneocpp/errormanager.cpp

@@ -27,20 +27,25 @@ void ErrorManager::get(std::vector<APIError>& errorOutput, size_t max, ErrorFilt
 			if(count++ >= max)
 				break; // We now have as many written to output as we can
 		} else {
-			it++;
+			std::advance(it, 1);
 		}
 	}
 }
 
-bool ErrorManager::getOne(APIError& errorOutput, ErrorFilter filter) {
-	std::vector<APIError> output;
-	get(output, filter, 1);
+bool ErrorManager::getLastError(APIError& errorOutput, ErrorFilter filter) {
+	std::lock_guard<std::mutex> lk(mutex);
 	
-	if(output.size() == 0)
-		return false;
-	
-	errorOutput = output[0];
-	return true;
+	auto it = errors.rbegin();
+	while(it != errors.rend()) {
+		if(filter.match(*it)) {
+			errorOutput = *it;
+			errors.erase(std::next(it).base());
+			return true;
+		}
+		std::advance(it, 1);
+	}
+
+	return false;
 }
 
 void ErrorManager::discard(ErrorFilter filter) {

api/icsneocpp/icsneocpp.cpp

@@ -5,4 +5,40 @@ using namespace icsneo;
 
 std::vector<std::shared_ptr<Device>> icsneo::FindAllDevices() {
 	return DeviceFinder::FindAll();
+}
+
+size_t icsneo::ErrorCount(ErrorFilter filter) {
+	return ErrorManager::GetInstance().count(filter);
+}
+
+std::vector<APIError> icsneo::GetErrors(ErrorFilter filter, size_t max) {
+	return ErrorManager::GetInstance().get(filter, max);
+}
+
+std::vector<APIError> icsneo::GetErrors(size_t max, ErrorFilter filter) {
+	return ErrorManager::GetInstance().get(max, filter);
+}
+
+void icsneo::GetErrors(std::vector<APIError>& errors, ErrorFilter filter, size_t max) {
+	ErrorManager::GetInstance().get(errors, filter, max);
+}
+
+void icsneo::GetErrors(std::vector<APIError>& errors, size_t max, ErrorFilter filter) {
+	ErrorManager::GetInstance().get(errors, max, filter);
+}
+
+bool icsneo::GetLastError(APIError& error, ErrorFilter filter) {
+	return ErrorManager::GetInstance().getLastError(error, filter);
+}
+
+void icsneo::DiscardErrors(ErrorFilter filter) {
+	ErrorManager::GetInstance().discard(filter);
+}
+
+void icsneo::SetErrorLimit(size_t newLimit) {
+	ErrorManager::GetInstance().setErrorLimit(newLimit);
+}
+
+size_t icsneo::GetErrorLimit() {
+	return ErrorManager::GetInstance().getErrorLimit();
 }