reapply clang format

hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -1,233 +1,223 @@
-#include "fsfw/FSFW.h"
-
 #include "fsfw_hal/linux/i2c/I2cComIF.h"
-#include "fsfw_hal/linux/utility.h"
-#include "fsfw_hal/linux/UnixFileGuard.h"
 
-#include "fsfw/serviceinterface.h"
-
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <linux/i2c-dev.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <linux/i2c-dev.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
 
 #include <cstring>
 
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+#include "fsfw_hal/linux/utility.h"
 
-I2cComIF::I2cComIF(object_id_t objectId): SystemObject(objectId){
-}
+I2cComIF::I2cComIF(object_id_t objectId) : SystemObject(objectId) {}
 
 I2cComIF::~I2cComIF() {}
 
 ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
+  address_t i2cAddress;
+  std::string deviceFile;
 
-    address_t i2cAddress;
-    std::string deviceFile;
-
-    if(cookie == nullptr) {
+  if (cookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::initializeInterface: Invalid cookie!" << std::endl;
+    sif::error << "I2cComIF::initializeInterface: Invalid cookie!" << std::endl;
 #endif
-        return NULLPOINTER;
-    }
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
+    return NULLPOINTER;
+  }
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::initializeInterface: Invalid I2C cookie!" << std::endl;
+    sif::error << "I2cComIF::initializeInterface: Invalid I2C cookie!" << std::endl;
 #endif
-        return NULLPOINTER;
-    }
+    return NULLPOINTER;
+  }
 
-    i2cAddress = i2cCookie->getAddress();
+  i2cAddress = i2cCookie->getAddress();
 
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if(i2cDeviceMapIter == i2cDeviceMap.end()) {
-        size_t maxReplyLen = i2cCookie->getMaxReplyLen();
-        I2cInstance i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
-        auto statusPair = i2cDeviceMap.emplace(i2cAddress, i2cInstance);
-        if (not statusPair.second) {
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+    size_t maxReplyLen = i2cCookie->getMaxReplyLen();
+    I2cInstance i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
+    auto statusPair = i2cDeviceMap.emplace(i2cAddress, i2cInstance);
+    if (not statusPair.second) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "I2cComIF::initializeInterface: Failed to insert device with address " <<
-                    i2cAddress << "to I2C device " << "map" << std::endl;
+      sif::error << "I2cComIF::initializeInterface: Failed to insert device with address "
+                 << i2cAddress << "to I2C device "
+                 << "map" << std::endl;
 #endif
-            return HasReturnvaluesIF::RETURN_FAILED;
-        }
-        return HasReturnvaluesIF::RETURN_OK;
+      return HasReturnvaluesIF::RETURN_FAILED;
     }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "I2cComIF::initializeInterface: Device with address " << i2cAddress <<
-            "already in use" << std::endl;
+  sif::error << "I2cComIF::initializeInterface: Device with address " << i2cAddress
+             << "already in use" << std::endl;
+#endif
+  return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
+  ReturnValue_t result;
+  int fd;
+  std::string deviceFile;
+
+  if (sendData == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Send Data is nullptr" << std::endl;
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
-}
+  }
 
-ReturnValue_t I2cComIF::sendMessage(CookieIF *cookie,
-        const uint8_t *sendData, size_t sendLen) {
-
-    ReturnValue_t result;
-    int fd;
-    std::string deviceFile;
-
-    if(sendData == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::sendMessage: Send Data is nullptr"
-                << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    if(sendLen == 0) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::sendMessage: Invalid I2C Cookie!" << std::endl;
-#endif
-        return NULLPOINTER;
-    }
-
-    address_t i2cAddress = i2cCookie->getAddress();
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
-                << "registered in i2cDeviceMap" << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    deviceFile = i2cCookie->getDeviceFile();
-    UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::sendMessage");
-    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-        return fileHelper.getOpenResult();
-    }
-    result = openDevice(deviceFile, i2cAddress, &fd);
-    if (result != HasReturnvaluesIF::RETURN_OK){
-        return result;
-    }
-
-    if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
-                "device with error code " << errno << ". Error description: "
-                << strerror(errno) << std::endl;
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+  if (sendLen == 0) {
     return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Invalid I2C Cookie!" << std::endl;
+#endif
+    return NULLPOINTER;
+  }
+
+  address_t i2cAddress = i2cCookie->getAddress();
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
+               << "registered in i2cDeviceMap" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  deviceFile = i2cCookie->getDeviceFile();
+  UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::sendMessage");
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+    return fileHelper.getOpenResult();
+  }
+  result = openDevice(deviceFile, i2cAddress, &fd);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+
+  if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
+                  "device with error code "
+               << errno << ". Error description: " << strerror(errno) << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t I2cComIF::getSendSuccess(CookieIF *cookie) {
+ReturnValue_t I2cComIF::getSendSuccess(CookieIF* cookie) { return HasReturnvaluesIF::RETURN_OK; }
+
+ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+  ReturnValue_t result;
+  int fd;
+  std::string deviceFile;
+
+  if (requestLen == 0) {
     return HasReturnvaluesIF::RETURN_OK;
-}
+  }
 
-ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF *cookie,
-        size_t requestLen) {
-    ReturnValue_t result;
-    int fd;
-    std::string deviceFile;
-
-    if (requestLen == 0) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!" << std::endl;
+    sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!" << std::endl;
 #endif
-        i2cDeviceMapIter->second.replyLen = 0;
-        return NULLPOINTER;
-    }
+    i2cDeviceMapIter->second.replyLen = 0;
+    return NULLPOINTER;
+  }
 
-    address_t i2cAddress = i2cCookie->getAddress();
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+  address_t i2cAddress = i2cCookie->getAddress();
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
-                << "registered in i2cDeviceMap" << std::endl;
+    sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
+               << "registered in i2cDeviceMap" << std::endl;
 #endif
-        i2cDeviceMapIter->second.replyLen = 0;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+    i2cDeviceMapIter->second.replyLen = 0;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
 
-    deviceFile = i2cCookie->getDeviceFile();
-    UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
-    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-        return fileHelper.getOpenResult();
-    }
-    result = openDevice(deviceFile, i2cAddress, &fd);
-    if (result != HasReturnvaluesIF::RETURN_OK){
-        i2cDeviceMapIter->second.replyLen = 0;
-        return result;
-    }
+  deviceFile = i2cCookie->getDeviceFile();
+  UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
+  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+    return fileHelper.getOpenResult();
+  }
+  result = openDevice(deviceFile, i2cAddress, &fd);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    i2cDeviceMapIter->second.replyLen = 0;
+    return result;
+  }
 
-    uint8_t* replyBuffer = i2cDeviceMapIter->second.replyBuffer.data();
+  uint8_t* replyBuffer = i2cDeviceMapIter->second.replyBuffer.data();
 
-    int readLen = read(fd, replyBuffer, requestLen);
-    if (readLen != static_cast<int>(requestLen)) {
+  int readLen = read(fd, replyBuffer, requestLen);
+  if (readLen != static_cast<int>(requestLen)) {
 #if FSFW_VERBOSE_LEVEL >= 1 and FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
-                << "device failed with error code " << errno <<". Description"
-                << " of error: " << strerror(errno) << std::endl;
-        sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from "
-                << requestLen << " bytes" << std::endl;
+    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
+               << "device failed with error code " << errno << ". Description"
+               << " of error: " << strerror(errno) << std::endl;
+    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
+               << " bytes" << std::endl;
 #endif
-        i2cDeviceMapIter->second.replyLen = 0;
+    i2cDeviceMapIter->second.replyLen = 0;
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::debug << "I2cComIF::requestReceiveMessage: Read "  << readLen << " of " << requestLen << " bytes" << std::endl;
+    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
+               << " bytes" << std::endl;
 #endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
 
-    i2cDeviceMapIter->second.replyLen = requestLen;
-    return HasReturnvaluesIF::RETURN_OK;
+  i2cDeviceMapIter->second.replyLen = requestLen;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t I2cComIF::readReceivedMessage(CookieIF *cookie,
-        uint8_t **buffer, size_t* size) {
-    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
-    if(i2cCookie == nullptr) {
+ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::readReceivedMessage: Invalid I2C Cookie!" << std::endl;
+    sif::error << "I2cComIF::readReceivedMessage: Invalid I2C Cookie!" << std::endl;
 #endif
-        return NULLPOINTER;
-    }
+    return NULLPOINTER;
+  }
 
-    address_t i2cAddress = i2cCookie->getAddress();
-    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
-    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+  address_t i2cAddress = i2cCookie->getAddress();
+  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  if (i2cDeviceMapIter == i2cDeviceMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
-                << "found in i2cDeviceMap" << std::endl;
+    sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
+               << "found in i2cDeviceMap" << std::endl;
 #endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    *buffer = i2cDeviceMapIter->second.replyBuffer.data();
-    *size = i2cDeviceMapIter->second.replyLen;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  *buffer = i2cDeviceMapIter->second.replyBuffer.data();
+  *size = i2cDeviceMapIter->second.replyLen;
 
-    return HasReturnvaluesIF::RETURN_OK;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t I2cComIF::openDevice(std::string deviceFile,
-        address_t i2cAddress, int* fileDescriptor) {
-
-    if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
+ReturnValue_t I2cComIF::openDevice(std::string deviceFile, address_t i2cAddress,
+                                   int* fileDescriptor) {
+  if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "I2cComIF: Specifying target device failed with error code " << errno << "."
-                << std::endl;
-        sif::warning << "Error description " << strerror(errno) << std::endl;
+    sif::warning << "I2cComIF: Specifying target device failed with error code " << errno << "."
+                 << std::endl;
+    sif::warning << "Error description " << strerror(errno) << std::endl;
 #else
-        sif::printWarning("I2cComIF: Specifying target device failed with error code %d.\n");
-        sif::printWarning("Error description: %s\n", strerror(errno));
+    sif::printWarning("I2cComIF: Specifying target device failed with error code %d.\n");
+    sif::printWarning("Error description: %s\n", strerror(errno));
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
 }

hal/src/fsfw_hal/linux/i2c/I2cComIF.h

@@ -1,13 +1,14 @@
 #ifndef LINUX_I2C_I2COMIF_H_
 #define LINUX_I2C_I2COMIF_H_
 
-#include "I2cCookie.h"
-#include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
 
 #include <unordered_map>
 #include <vector>
 
+#include "I2cCookie.h"
+
 /**
  * @brief 	This is the communication interface for I2C devices connected
  * 			to a system running a Linux OS.
@@ -16,46 +17,41 @@
  *
  * @author 	J. Meier
  */
-class I2cComIF: public DeviceCommunicationIF, public SystemObject {
-public:
-	I2cComIF(object_id_t objectId);
+class I2cComIF : public DeviceCommunicationIF, public SystemObject {
+ public:
+  I2cComIF(object_id_t objectId);
 
-	virtual ~I2cComIF();
+  virtual ~I2cComIF();
 
-	ReturnValue_t initializeInterface(CookieIF * cookie) override;
-	ReturnValue_t sendMessage(CookieIF *cookie,const uint8_t *sendData,
-			size_t sendLen) override;
-	ReturnValue_t getSendSuccess(CookieIF *cookie) override;
-	ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) override;
-	ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-			size_t *size) override;
+  ReturnValue_t initializeInterface(CookieIF *cookie) override;
+  ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) override;
 
-private:
+ private:
+  struct I2cInstance {
+    std::vector<uint8_t> replyBuffer;
+    size_t replyLen;
+  };
 
-	struct I2cInstance {
-		std::vector<uint8_t> replyBuffer;
-		size_t replyLen;
-	};
+  using I2cDeviceMap = std::unordered_map<address_t, I2cInstance>;
+  using I2cDeviceMapIter = I2cDeviceMap::iterator;
 
-	using I2cDeviceMap = std::unordered_map<address_t, I2cInstance>;
-	using I2cDeviceMapIter = I2cDeviceMap::iterator;
+  /* In this map all i2c devices will be registered with their address and
+   * the appropriate file descriptor will be stored */
+  I2cDeviceMap i2cDeviceMap;
+  I2cDeviceMapIter i2cDeviceMapIter;
 
-	/* In this map all i2c devices will be registered with their address and
-	 * the appropriate file descriptor will be stored */
-	I2cDeviceMap i2cDeviceMap;
-	I2cDeviceMapIter i2cDeviceMapIter;
-
-	/**
-	 * @brief	This function opens an I2C device and binds the opened file
-	 * 			to a specific I2C address.
-	 * @param deviceFile	The name of the device file. E.g. i2c-0
-	 * @param i2cAddress	The address of the i2c slave device.
-	 * @param fileDescriptor	Pointer to device descriptor.
-	 * @return	RETURN_OK if successful, otherwise RETURN_FAILED.
-	 */
-	ReturnValue_t openDevice(std::string deviceFile,
-			address_t i2cAddress, int* fileDescriptor);
+  /**
+   * @brief	This function opens an I2C device and binds the opened file
+   * 			to a specific I2C address.
+   * @param deviceFile	The name of the device file. E.g. i2c-0
+   * @param i2cAddress	The address of the i2c slave device.
+   * @param fileDescriptor	Pointer to device descriptor.
+   * @return	RETURN_OK if successful, otherwise RETURN_FAILED.
+   */
+  ReturnValue_t openDevice(std::string deviceFile, address_t i2cAddress, int *fileDescriptor);
 };
 
 #endif /* LINUX_I2C_I2COMIF_H_ */

hal/src/fsfw_hal/linux/i2c/I2cCookie.cpp

@@ -1,20 +1,12 @@
 #include "fsfw_hal/linux/i2c/I2cCookie.h"
 
-I2cCookie::I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
-		std::string deviceFile_) :
-		i2cAddress(i2cAddress_), maxReplyLen(maxReplyLen_), deviceFile(deviceFile_) {
-}
+I2cCookie::I2cCookie(address_t i2cAddress_, size_t maxReplyLen_, std::string deviceFile_)
+    : i2cAddress(i2cAddress_), maxReplyLen(maxReplyLen_), deviceFile(deviceFile_) {}
 
-address_t I2cCookie::getAddress() const {
-	return i2cAddress;
-}
+address_t I2cCookie::getAddress() const { return i2cAddress; }
 
-size_t I2cCookie::getMaxReplyLen() const {
-	return maxReplyLen;
-}
+size_t I2cCookie::getMaxReplyLen() const { return maxReplyLen; }
 
-std::string I2cCookie::getDeviceFile() const {
-	return deviceFile;
-}
+std::string I2cCookie::getDeviceFile() const { return deviceFile; }
 
 I2cCookie::~I2cCookie() {}

hal/src/fsfw_hal/linux/i2c/I2cCookie.h

@@ -2,6 +2,7 @@
 #define LINUX_I2C_I2CCOOKIE_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
+
 #include <string>
 
 /**
@@ -9,30 +10,27 @@
  *
  * @author 	J. Meier
  */
-class I2cCookie: public CookieIF {
-public:
+class I2cCookie : public CookieIF {
+ public:
+  /**
+   * @brief	Constructor for the I2C cookie.
+   * @param i2cAddress_	The i2c address of the target device.
+   * @param maxReplyLen_	The maximum expected length of a reply from the
+   * 						target device.
+   * @param devicFile_    The device file specifying the i2c interface to use. E.g. "/dev/i2c-0".
+   */
+  I2cCookie(address_t i2cAddress_, size_t maxReplyLen_, std::string deviceFile_);
 
-	/**
-	 * @brief	Constructor for the I2C cookie.
-	 * @param i2cAddress_	The i2c address of the target device.
-	 * @param maxReplyLen_	The maximum expected length of a reply from the
-	 * 						target device.
-	 * @param devicFile_    The device file specifying the i2c interface to use. E.g. "/dev/i2c-0".
-	 */
-	I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
-			std::string deviceFile_);
+  virtual ~I2cCookie();
 
-	virtual ~I2cCookie();
+  address_t getAddress() const;
+  size_t getMaxReplyLen() const;
+  std::string getDeviceFile() const;
 
-	address_t getAddress() const;
-	size_t getMaxReplyLen() const;
-	std::string getDeviceFile() const;
-
-private:
-
-	address_t i2cAddress = 0;
-	size_t maxReplyLen = 0;
-	std::string deviceFile;
+ private:
+  address_t i2cAddress = 0;
+  size_t maxReplyLen = 0;
+  std::string deviceFile;
 };
 
 #endif /* LINUX_I2C_I2CCOOKIE_H_ */