Compare revisions

51f202ec · 51f202ec · 51f202ec · 51f202ec · 51f202ec · 51f202ec
--- a/include/caosdb/info.h
+++ b/include/caosdb/info.h
@@ -54,21 +54,13 @@ public:
   * server behind the given connection.
   */
  explicit inline VersionInfo(ProtoVersionInfo *info) : info(info){};
-  [[nodiscard]] inline auto GetMajor() const -> int32_t {
+  [[nodiscard]] inline auto GetMajor() const -> int32_t { return this->info->major(); }
-    return this->info->major();
+  [[nodiscard]] inline auto GetMinor() const -> int32_t { return this->info->minor(); }
-  }
+  [[nodiscard]] inline auto GetPatch() const -> int32_t { return this->info->patch(); }
-  [[nodiscard]] inline auto GetMinor() const -> int32_t {
-    return this->info->minor();
-  }
-  [[nodiscard]] inline auto GetPatch() const -> int32_t {
-    return this->info->patch();
-  }
  [[nodiscard]] inline auto GetPreRelease() const -> const std::string & {
    return this->info->pre_release();
  }
-  [[nodiscard]] inline auto GetBuild() const -> const std::string & {
+  [[nodiscard]] inline auto GetBuild() const -> const std::string & { return this->info->build(); }
-    return this->info->build();
-  }
 private:
  /// This object is the owner of the Protobuf VersionInfo message.

--- a/include/caosdb/logging.h
+++ b/include/caosdb/logging.h
@@ -38,8 +38,7 @@ namespace caosdb::logging {
 const std::string logger_name = "caosdb::logging";
-typedef boost::log::sources::severity_channel_logger_mt<int, std::string>
+typedef boost::log::sources::severity_channel_logger_mt<int, std::string> boost_logger_class;
-  boost_logger_class;
 BOOST_LOG_GLOBAL_LOGGER(logger, boost_logger_class)
@@ -67,8 +66,7 @@ public:
  virtual ~LoggingConfiguration() = default;
  LoggingConfiguration(int level);
  auto AddSink(const std::shared_ptr<SinkConfiguration> &sink) -> void;
-  auto GetSinks() const
+  auto GetSinks() const -> const std::vector<std::shared_ptr<SinkConfiguration>> &;
-    -> const std::vector<std::shared_ptr<SinkConfiguration>> &;
 private:
  std::vector<std::shared_ptr<SinkConfiguration>> sinks;
@@ -102,8 +100,7 @@ public:
  [[nodiscard]] virtual auto GetDestination() const -> const std::string & = 0;
  friend auto initialize_logging_defaults() -> int;
-  friend auto
+  friend auto initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
-  initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
 protected:
  virtual auto Configure(boost::log::settings &settings) const -> void;
@@ -118,8 +115,7 @@ public:
  ConsoleSinkConfiguration(const std::string &name, int level);
  [[nodiscard]] auto GetDestination() const -> const std::string & override;
  friend auto initialize_logging_defaults() -> int;
-  friend auto
+  friend auto initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
-  initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
 protected:
  typedef SinkConfiguration sink_configuration;
@@ -139,12 +135,10 @@ class FileSinkConfiguration : public SinkConfiguration {
 public:
  virtual ~FileSinkConfiguration() = default;
  FileSinkConfiguration(const std::string &name, int level);
-  [[nodiscard]] virtual auto GetDestination() const
+  [[nodiscard]] virtual auto GetDestination() const -> const std::string & override;
-    -> const std::string & override;
  auto SetDirectory(const std::string &directory) -> void;
  friend auto initialize_logging_defaults() -> int;
-  friend auto
+  friend auto initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
-  initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
 protected:
  typedef SinkConfiguration sink_configuration;
@@ -159,8 +153,7 @@ class SyslogSinkConfiguration : public SinkConfiguration {
 public:
  virtual ~SyslogSinkConfiguration() = default;
  SyslogSinkConfiguration(const std::string &name, int level);
-  [[nodiscard]] virtual auto GetDestination() const
+  [[nodiscard]] virtual auto GetDestination() const -> const std::string & override;
-    -> const std::string & override;
 private:
  const std::string destination = "Syslog";
@@ -193,29 +186,22 @@ void caosdb_log_trace(const char *channel, const char *msg);
 } // namespace caosdb::logging
-#define CAOSDB_LOG_FATAL(Channel)                                              \
+#define CAOSDB_LOG_FATAL(Channel)                                                                  \
-  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel, CAOSDB_LOG_LEVEL_FATAL)
-                        CAOSDB_LOG_LEVEL_FATAL)
+#define CAOSDB_LOG_ERROR(Channel)                                                                  \
-#define CAOSDB_LOG_ERROR(Channel)                                              \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel, CAOSDB_LOG_LEVEL_ERROR)
-  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+#define CAOSDB_LOG_WARN(Channel)                                                                   \
-                        CAOSDB_LOG_LEVEL_ERROR)
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel, CAOSDB_LOG_LEVEL_WARN)
-#define CAOSDB_LOG_WARN(Channel)                                               \
+#define CAOSDB_LOG_INFO(Channel)                                                                   \
-  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel, CAOSDB_LOG_LEVEL_INFO)
-                        CAOSDB_LOG_LEVEL_WARN)
+#define CAOSDB_LOG_DEBUG(Channel)                                                                  \
-#define CAOSDB_LOG_INFO(Channel)                                               \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel, CAOSDB_LOG_LEVEL_DEBUG)
-  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+#define CAOSDB_LOG_TRACE(Channel)                                                                  \
-                        CAOSDB_LOG_LEVEL_INFO)
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel, CAOSDB_LOG_LEVEL_TRACE)
-#define CAOSDB_LOG_DEBUG(Channel)                                              \
-  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+#define CAOSDB_LOG_ERROR_AND_RETURN_STATUS(Channel, StatusCode, Message)                           \
-                        CAOSDB_LOG_LEVEL_DEBUG)
+  CAOSDB_LOG_ERROR(Channel) << "StatusCode (" << StatusCode << ") "                                \
-#define CAOSDB_LOG_TRACE(Channel)                                              \
+                            << caosdb::get_status_description(StatusCode) << ": " << Message;      \
-  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
-                        CAOSDB_LOG_LEVEL_TRACE)
-#define CAOSDB_LOG_ERROR_AND_RETURN_STATUS(Channel, StatusCode, Message)       \
-  CAOSDB_LOG_ERROR(Channel)                                                    \
-    << "StatusCode (" << StatusCode << ") "                                    \
-    << caosdb::get_status_description(StatusCode) << ": " << Message;          \
  return StatusCode;
 #endif
--- a/include/caosdb/message_code.h
+++ b/include/caosdb/message_code.h
@@ -41,17 +41,16 @@ namespace caosdb::entity {
 enum MessageCode {
  UNSPECIFIED = caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_UNSPECIFIED,
  UNKNOWN = caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_UNKNOWN,
-  ENTITY_DOES_NOT_EXIST =
+  ENTITY_DOES_NOT_EXIST = caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_ENTITY_DOES_NOT_EXIST,
-    caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_ENTITY_DOES_NOT_EXIST,
+  ENTITY_HAS_NO_PROPERTIES =
-  ENTITY_HAS_NO_PROPERTIES = caosdb::entity::v1alpha1::MessageCode::
+    caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_ENTITY_HAS_NO_PROPERTIES,
-    MESSAGE_CODE_ENTITY_HAS_NO_PROPERTIES,
 };
 [[nodiscard]] inline auto get_message_code(int code) noexcept -> MessageCode {
  // TODO(tf) smarter, less forgot-it-prone implementation
-  static MessageCode all_codes[] = {
+  static MessageCode all_codes[] = {MessageCode::UNSPECIFIED, MessageCode::UNKNOWN,
-    MessageCode::UNSPECIFIED, MessageCode::UNKNOWN,
+                                    MessageCode::ENTITY_DOES_NOT_EXIST,
-    MessageCode::ENTITY_DOES_NOT_EXIST, MessageCode::ENTITY_HAS_NO_PROPERTIES};
+                                    MessageCode::ENTITY_HAS_NO_PROPERTIES};
  for (MessageCode known_code : all_codes) {
    if (known_code == code) {

--- a/include/caosdb/protobuf_helper.h
+++ b/include/caosdb/protobuf_helper.h
@@ -26,11 +26,11 @@
 #include <google/protobuf/arena.h>         // for Arena
 #include <google/protobuf/extension_set.h> // for Arena
-#define CAOSDB_DEBUG_MESSAGE_STRING(message, out)                              \
+#define CAOSDB_DEBUG_MESSAGE_STRING(message, out)                                                  \
-  std::string out;                                                             \
+  std::string out;                                                                                 \
-  {                                                                            \
+  {                                                                                                \
-    google::protobuf::util::JsonOptions options;                               \
+    google::protobuf::util::JsonOptions options;                                                   \
-    google::protobuf::util::MessageToJsonString(message, &out, options);       \
+    google::protobuf::util::MessageToJsonString(message, &out, options);                           \
  }
 namespace caosdb::utility {
@@ -42,15 +42,13 @@ auto get_arena() -> Arena *;
 template <typename P> class ProtoMessageWrapper {
 public:
  ProtoMessageWrapper(const ProtoMessageWrapper &other) = default;
-  inline auto CopyFrom(const ProtoMessageWrapper &other) noexcept
+  inline auto CopyFrom(const ProtoMessageWrapper &other) noexcept -> StatusCode {
-    -> StatusCode {
    this->wrapped->CopyFrom(*other.wrapped);
    return StatusCode::SUCCESS;
  }
 protected:
-  ProtoMessageWrapper()
+  ProtoMessageWrapper() : ProtoMessageWrapper(Arena::CreateMessage<P>(get_arena())) {}
-    : ProtoMessageWrapper(Arena::CreateMessage<P>(get_arena())) {}
  ProtoMessageWrapper(P *wrapped) : wrapped(wrapped) {}
  P *wrapped;
 };

--- a/include/caosdb/transaction.h
+++ b/include/caosdb/transaction.h
--- a/include/caosdb/transaction_handler.h
+++ b/include/caosdb/transaction_handler.h
@@ -17,14 +17,12 @@ class EntityTransactionHandler final : public UnaryRpcHandler {
 public:
  EntityTransactionHandler(HandlerTag tag, EntityTransactionService::Stub *stub,
                           grpc::CompletionQueue *completion_queue,
-                           MultiTransactionRequest *request,
+                           MultiTransactionRequest *request, MultiTransactionResponse *response);
-                           MultiTransactionResponse *response);
  ~EntityTransactionHandler() override = default;
  EntityTransactionHandler(const EntityTransactionHandler &) = delete;
-  EntityTransactionHandler &
+  EntityTransactionHandler &operator=(const EntityTransactionHandler &) = delete;
-  operator=(const EntityTransactionHandler &) = delete;
  EntityTransactionHandler(EntityTransactionHandler &&) = delete;
  EntityTransactionHandler &operator=(EntityTransactionHandler &&) = delete;
@@ -35,8 +33,7 @@ protected:
  EntityTransactionService::Stub *stub_;
-  std::unique_ptr<grpc::ClientAsyncResponseReader<MultiTransactionResponse>>
+  std::unique_ptr<grpc::ClientAsyncResponseReader<MultiTransactionResponse>> rpc_;
-    rpc_;
  MultiTransactionRequest *request_;
  MultiTransactionResponse *response_;

--- a/include/caosdb/transaction_status.h
+++ b/include/caosdb/transaction_status.h
@@ -39,11 +39,11 @@ using caosdb::exceptions::TransactionTypeError;
 /**
 * Define static factory method in the TransactionStatus class.
 */
-#define CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(_StatusName, _StatusCode)    \
+#define CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(_StatusName, _StatusCode)                        \
-  inline static auto _StatusName()->const TransactionStatus & {                \
+  inline static auto _StatusName()->const TransactionStatus & {                                    \
-    static const TransactionStatus instance(                                   \
+    static const TransactionStatus instance(_StatusCode,                                           \
-      _StatusCode, caosdb::get_status_description(_StatusCode));               \
+                                            caosdb::get_status_description(_StatusCode));          \
-    return instance;                                                           \
+    return instance;                                                                               \
  }
 /**
@@ -99,25 +99,21 @@ public:
   * possibly due to misconfiguration of the client, errors in the network or
   * because the server is down.
   */
-  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(CONNECTION_ERROR,
+  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(CONNECTION_ERROR, StatusCode::CONNECTION_ERROR)
-                                            StatusCode::CONNECTION_ERROR)
  /**
   * Factory for an AUTHENTICATION_ERROR status.
   *
   * This status means that the RPC layer reported an authentication error.
   */
-  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(AUTHENTICATION_ERROR,
+  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(AUTHENTICATION_ERROR, StatusCode::AUTHENTICATION_ERROR)
-                                            StatusCode::AUTHENTICATION_ERROR)
  /**
   * Another factory for an TRANSACTION_ERROR Status with a detailed
   * description.
   */
-  inline static auto AUTHENTICATION_ERROR(const std::string &details)
+  inline static auto AUTHENTICATION_ERROR(const std::string &details) -> const TransactionStatus {
-    -> const TransactionStatus {
+    return TransactionStatus(StatusCode::AUTHENTICATION_ERROR,
-    return TransactionStatus(
+                             caosdb::get_status_description(StatusCode::AUTHENTICATION_ERROR) +
-      StatusCode::AUTHENTICATION_ERROR,
+                               " Original error: " + details);
-      caosdb::get_status_description(StatusCode::AUTHENTICATION_ERROR) +
-        " Original error: " + details);
  }
  /**
   * Factory for a FILE_UPLOAD_ERROR status.
@@ -125,49 +121,43 @@ public:
   * This status means that the transaction failed during the upload of the
   * file blobs of file entities.
   */
-  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(FILE_UPLOAD_ERROR,
+  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(FILE_UPLOAD_ERROR, StatusCode::FILE_UPLOAD_ERROR);
-                                            StatusCode::FILE_UPLOAD_ERROR);
  /**
   * Factory for a FILE_DOWN_ERROR status.
   *
   * This status means that the transaction failed during the download of the
   * file blobs of file entities.
   */
-  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(FILE_DOWNLOAD_ERROR,
+  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(FILE_DOWNLOAD_ERROR, StatusCode::FILE_DOWNLOAD_ERROR);
-                                            StatusCode::FILE_DOWNLOAD_ERROR);
  /**
   * Factory for a TRANSACTION_ERROR status.
   *
   * This status means that the transaction failed due to errors thrown by the
   * server.
   */
-  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(
+  CAOSDB_TRANSACTION_STATUS_DEFAULT_FACTORY(TRANSACTION_ERROR,
-    TRANSACTION_ERROR, StatusCode::GENERIC_TRANSACTION_ERROR)
+                                            StatusCode::GENERIC_TRANSACTION_ERROR)
  /**
   * Another factory for a TRANSACTION_ERROR status with a detailed
   * description.
   */
-  inline static auto TRANSACTION_ERROR(const std::string &details)
+  inline static auto TRANSACTION_ERROR(const std::string &details) -> const TransactionStatus {
-    -> const TransactionStatus {
+    return TransactionStatus(StatusCode::GENERIC_TRANSACTION_ERROR,
-    return TransactionStatus(
+                             caosdb::get_status_description(StatusCode::GENERIC_TRANSACTION_ERROR) +
-      StatusCode::GENERIC_TRANSACTION_ERROR,
+                               " Original error: " + details);
-      caosdb::get_status_description(StatusCode::GENERIC_TRANSACTION_ERROR) +
-        " Original error: " + details);
  }
  /**
   * Factory for a RPC_ERROR with a detailed description.
   *
   * This status is used for any error on the RPC layer.
   */
-  inline static auto RPC_ERROR(const std::string &details)
+  inline static auto RPC_ERROR(const std::string &details) -> const TransactionStatus {
-    -> const TransactionStatus {
    // We use the GENERIC_RPC_ERROR here because we might want to add further
    // RPC_ERROR states with different error codes (which stem from GRPC) here
    // in the future.
-    return TransactionStatus(
+    return TransactionStatus(StatusCode::GENERIC_RPC_ERROR,
-      StatusCode::GENERIC_RPC_ERROR,
+                             caosdb::get_status_description(StatusCode::GENERIC_RPC_ERROR) +
-      caosdb::get_status_description(StatusCode::GENERIC_RPC_ERROR) +
+                               " Original error: " + details);
-        " Original error: " + details);
  }
  /**
@@ -177,18 +167,16 @@ public:
   * supposedly do not have a special handling.
   */
  inline static auto GENERIC_ERROR(const std::string &details) {
-    return TransactionStatus(
+    return TransactionStatus(StatusCode::GENERIC_ERROR,
-      StatusCode::GENERIC_ERROR,
+                             caosdb::get_status_description(StatusCode::GENERIC_ERROR) +
-      caosdb::get_status_description(StatusCode::GENERIC_ERROR) +
+                               "Original error: " + details);
-        "Original error: " + details);
  }
  inline auto ThrowExceptionIfError() const -> void {
    TransactionStatus::ThrowExceptionIfError(this->code, this->description);
  }
-  inline static auto ThrowExceptionIfError(StatusCode code,
+  inline static auto ThrowExceptionIfError(StatusCode code, const std::string &description)
-                                           const std::string &description)
    -> void {
    if (!IsError(code)) {
      return;
@@ -222,18 +210,14 @@ public:
  /**
   * Return true if this TransactionStatus represents an erroneous state.
   */
-  inline auto IsError() const -> bool {
+  inline auto IsError() const -> bool { return TransactionStatus::IsError(this->code); };
-    return TransactionStatus::IsError(this->code);
-  };
  /**
   * Return a description of the erroneous state.
   *
   * No description yields an empty string.
   */
-  inline auto GetDescription() const -> const std::string & {
+  inline auto GetDescription() const -> const std::string & { return this->description; }
-    return this->description;
-  }
  /**
   * Return the status code of the state.

--- a/include/caosdb/unary_rpc_handler.h
+++ b/include/caosdb/unary_rpc_handler.h
@@ -60,8 +60,7 @@ namespace caosdb::transaction {
 class UnaryRpcHandler : public HandlerInterface {
 public:
  inline UnaryRpcHandler(grpc::CompletionQueue *completion_queue)
-    : HandlerInterface(), state_(CallState::NewCall),
+    : HandlerInterface(), state_(CallState::NewCall), completion_queue(completion_queue) {}
-      completion_queue(completion_queue) {}
  void Start() override {
    transaction_status = TransactionStatus::EXECUTING();

--- a/include/caosdb/utility.h
+++ b/include/caosdb/utility.h
@@ -21,20 +21,25 @@
 #ifndef CAOSDB_UTILS_H
 #define CAOSDB_UTILS_H
+#include "caosdb/entity.h"
+#include "caosdb/data_type.h"
 #include <boost/beast/core/detail/base64.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
 #include <boost/filesystem/string_file.hpp>
+#include <boost/lexical_cast.hpp> // for lexical_cast
 #include <boost/json.hpp>
 #include <cassert>
 #include <cstdlib>
+#include <exception> // for logic_error
 #include <fstream>
 #include <iostream>
+#include <map>
 #include <memory>
-#include <string>
-#include <string_view>
 #include <mutex>
 #include <shared_mutex>
+#include <string>
+#include <string_view>
 namespace caosdb::utility {
 using boost::filesystem::exists;
@@ -43,6 +48,43 @@ using boost::filesystem::path;
 using boost::json::stream_parser;
 using boost::json::value;
+/**
+ * @brief Get the name of the enum value.  May be useful for higher-order CaosDB clients.
+ */
+template <typename Enum> auto getEnumNameFromValue(Enum v) -> std::string {
+  if (std::is_same_v<std::underlying_type_t<Enum>, int>) {
+    return boost::lexical_cast<std::string>(static_cast<int>(v));
+  }
+  throw std::logic_error(std::string("Enum type ") + typeid(v).name() + " not implemented.");
+}
+// Forward declaration of specializations
+template <>
+auto getEnumNameFromValue<caosdb::entity::AtomicDataType>(caosdb::entity::AtomicDataType v)
+  -> std::string;
+template <>
+auto getEnumNameFromValue<caosdb::entity::Importance>(caosdb::entity::Importance v) -> std::string;
+template <> auto getEnumNameFromValue<caosdb::entity::Role>(caosdb::entity::Role v) -> std::string;
+/**
+ * @brief Get the enum value from a string.
+ *
+ * @detail May be useful for higher-order CaosDB clients and only makes sense if specialized.
+ */
+template <typename Enum> auto getEnumValueFromName(const std::string &name) -> Enum {
+  throw std::logic_error(std::string("Enum type ") + typeid(Enum).name() + " not implemented.");
+}
+// Forward declaration of specializations
+template <>
+auto getEnumValueFromName<caosdb::entity::AtomicDataType>(const std::string &name)
+  -> caosdb::entity::AtomicDataType;
+template <>
+auto getEnumValueFromName<caosdb::entity::Importance>(const std::string &name)
+  -> caosdb::entity::Importance;
+template <>
+auto getEnumValueFromName<caosdb::entity::Role>(const std::string &name) -> caosdb::entity::Role;
 /**
 * @brief Read a text file into a string and return the file's content.
 */
@@ -68,8 +110,7 @@ inline auto get_env_var(const char *key, const char *fallback) -> const char * {
 * @brief Return the value of an environment variable or - if undefined - the
 * fallback value.
 */
-inline auto get_env_var(const std::string &key, const std::string &fallback)
+inline auto get_env_var(const std::string &key, const std::string &fallback) -> const std::string {
-  -> const std::string {
  const char *val = get_env_var(key.c_str(), fallback.c_str());
  auto const result = std::string(val);
@@ -84,8 +125,7 @@ inline auto base64_encode(const std::string &plain) -> std::string {
  auto size_encoded = boost::beast::detail::base64::encoded_size(size_plain);
  std::unique_ptr<char[]> encoded(new char[size_encoded]);
-  boost::beast::detail::base64::encode(encoded.get(), plain.c_str(),
+  boost::beast::detail::base64::encode(encoded.get(), plain.c_str(), size_plain);
-                                       size_plain);
  // the encoded char[] is not null terminated, so explicitely set the length
  return std::string(encoded.get(), encoded.get() + size_encoded);

--- a/include/caosdb/value.h
+++ b/include/caosdb/value.h
@@ -29,12 +29,11 @@
 #include <string>                           // for string
 #include <vector>                           // for vector
-#define LIST_VALUE_CONSTRUCTOR(TYPE, SETTER)                                   \
+#define LIST_VALUE_CONSTRUCTOR(TYPE, SETTER)                                                       \
-  explicit inline Value(const std::vector<TYPE> &values)                       \
+  explicit inline Value(const std::vector<TYPE> &values) : ProtoMessageWrapper<ProtoValue>() {     \
-    : ProtoMessageWrapper<ProtoValue>() {                                      \
+    for (const auto &value : values) {                                                             \
-    for (const auto &value : values) {                                         \
+      this->wrapped->mutable_list_values()->add_values()->SETTER(value);                           \
-      this->wrapped->mutable_list_values()->add_values()->SETTER(value);       \
+    }                                                                                              \
-    }                                                                          \
  }
 namespace caosdb::entity {
@@ -58,16 +57,12 @@ enum SpecialValue {
 class ScalarValue : public ProtoMessageWrapper<ProtoScalarValue> {
 public:
-  inline ScalarValue(ProtoScalarValue *wrapped)
+  inline ScalarValue(ProtoScalarValue *wrapped) : ProtoMessageWrapper<ProtoScalarValue>(wrapped) {}
-    : ProtoMessageWrapper<ProtoScalarValue>(wrapped) {}
  [[nodiscard]] inline auto IsString() const noexcept -> bool {
-    return (this->wrapped->scalar_value_case() ==
+    return (this->wrapped->scalar_value_case() == ScalarValueCase::kStringValue) ||
-            ScalarValueCase::kStringValue) ||
+           (this->wrapped->scalar_value_case() == ScalarValueCase::kSpecialValue &&
-           (this->wrapped->scalar_value_case() ==
+            this->wrapped->special_value() == ProtoSpecialValue::SPECIAL_VALUE_EMPTY_STRING);
-              ScalarValueCase::kSpecialValue &&
-            this->wrapped->special_value() ==
-              ProtoSpecialValue::SPECIAL_VALUE_EMPTY_STRING);
    return false;
  }
  [[nodiscard]] inline auto AsString() const noexcept -> const std::string & {
@@ -76,24 +71,21 @@ public:
  }
  [[nodiscard]] inline auto IsDouble() const noexcept -> bool {
-    return (this->wrapped->scalar_value_case() ==
+    return (this->wrapped->scalar_value_case() == ScalarValueCase::kDoubleValue);
-            ScalarValueCase::kDoubleValue);
  }
  [[nodiscard]] inline auto AsDouble() const noexcept -> double {
    return this->wrapped->double_value();
  }
  [[nodiscard]] inline auto IsInteger() const noexcept -> bool {
-    return (this->wrapped->scalar_value_case() ==
+    return (this->wrapped->scalar_value_case() == ScalarValueCase::kIntegerValue);
-            ScalarValueCase::kIntegerValue);
  }
  [[nodiscard]] inline auto AsInteger() const noexcept -> int64_t {
    return this->wrapped->integer_value();
  }
  [[nodiscard]] inline auto IsBool() const noexcept -> bool {
-    return (this->wrapped->scalar_value_case() ==
+    return (this->wrapped->scalar_value_case() == ScalarValueCase::kBooleanValue);
-            ScalarValueCase::kBooleanValue);
  }
  [[nodiscard]] inline auto AsBool() const noexcept -> bool {
    return this->wrapped->boolean_value();
@@ -105,10 +97,8 @@ public:
  inline Value() : ProtoMessageWrapper<ProtoValue>() {
    // has NULL_VALUE now
  }
-  explicit inline Value(ProtoValue *wrapped)
+  explicit inline Value(ProtoValue *wrapped) : ProtoMessageWrapper<ProtoValue>(wrapped) {}
-    : ProtoMessageWrapper<ProtoValue>(wrapped) {}
+  explicit inline Value(const std::string &value) : ProtoMessageWrapper<ProtoValue>() {
-  explicit inline Value(const std::string &value)
-    : ProtoMessageWrapper<ProtoValue>() {
    this->wrapped->mutable_scalar_value()->set_string_value(value);
  }
  explicit inline Value(const char *value) : ProtoMessageWrapper<ProtoValue>() {
@@ -139,10 +129,8 @@ public:
  [[nodiscard]] inline auto IsString() const noexcept -> bool {
    if (this->wrapped->value_case() == ValueCase::kScalarValue) {
-      return (this->wrapped->scalar_value().scalar_value_case() ==
+      return (this->wrapped->scalar_value().scalar_value_case() == ScalarValueCase::kStringValue) ||
-              ScalarValueCase::kStringValue) ||
+             (this->wrapped->scalar_value().scalar_value_case() == ScalarValueCase::kSpecialValue &&
-             (this->wrapped->scalar_value().scalar_value_case() ==
-                ScalarValueCase::kSpecialValue &&
              this->wrapped->scalar_value().special_value() ==
                ProtoSpecialValue::SPECIAL_VALUE_EMPTY_STRING);
    }
@@ -156,8 +144,7 @@ public:
  [[nodiscard]] inline auto IsDouble() const noexcept -> bool {
    if (this->wrapped->value_case() == ValueCase::kScalarValue) {
-      return (this->wrapped->scalar_value().scalar_value_case() ==
+      return (this->wrapped->scalar_value().scalar_value_case() == ScalarValueCase::kDoubleValue);
-              ScalarValueCase::kDoubleValue);
    }
    return false;
  }
@@ -168,8 +155,7 @@ public:
  [[nodiscard]] inline auto IsInteger() const noexcept -> bool {
    if (this->wrapped->value_case() == ValueCase::kScalarValue) {
-      return (this->wrapped->scalar_value().scalar_value_case() ==
+      return (this->wrapped->scalar_value().scalar_value_case() == ScalarValueCase::kIntegerValue);
-              ScalarValueCase::kIntegerValue);
    }
    return false;
  }
@@ -180,8 +166,7 @@ public:
  [[nodiscard]] inline auto IsBool() const noexcept -> bool {
    if (this->wrapped->value_case() == ValueCase::kScalarValue) {
-      return (this->wrapped->scalar_value().scalar_value_case() ==
+      return (this->wrapped->scalar_value().scalar_value_case() == ScalarValueCase::kBooleanValue);
-              ScalarValueCase::kBooleanValue);
    }
    return false;
  }
@@ -192,16 +177,14 @@ public:
  [[nodiscard]] inline auto IsList() const noexcept -> bool {
    return this->wrapped->value_case() == ValueCase::kListValues;
  }
-  [[nodiscard]] inline auto AsList() const noexcept
+  [[nodiscard]] inline auto AsList() const noexcept -> const std::vector<ScalarValue> & {
-    -> const std::vector<ScalarValue> & {
    if (!IsList()) {
      // create empty list
      this->list_values = std::make_unique<std::vector<ScalarValue>>();
    }
    if (this->list_values == nullptr) {
      this->list_values = std::make_unique<std::vector<ScalarValue>>();
-      for (auto &scalar :
+      for (auto &scalar : *(this->wrapped->mutable_list_values()->mutable_values())) {
-           *(this->wrapped->mutable_list_values()->mutable_values())) {
        this->list_values->push_back(ScalarValue(&scalar));
      }
    }
@@ -209,8 +192,7 @@ public:
  }
  inline auto operator==(const Value &other) const noexcept -> bool {
-    return this->wrapped->SerializeAsString() ==
+    return this->wrapped->SerializeAsString() == other.wrapped->SerializeAsString();
-           other.wrapped->SerializeAsString();
  }
  inline auto ToString() const noexcept -> const std::string {

--- a/include/ccaosdb.h
+++ b/include/ccaosdb.h
@@ -137,8 +137,7 @@ int caosdb_connection_create_pem_file_certificate_provider(
 *
 * EXPERT USE ONLY.  Only use it when you know what you are doing.
 */
-int caosdb_connection_delete_certificate_provider(
+int caosdb_connection_delete_certificate_provider(caosdb_connection_certificate_provider *provider);
-  caosdb_connection_certificate_provider *provider);
 /**
 * Create a tls-secured connection configuration.
@@ -153,8 +152,8 @@ int caosdb_connection_delete_certificate_provider(
 * Only use it when you know what you are doing.
 */
 int caosdb_connection_create_tls_connection_configuration(
-  caosdb_connection_connection_configuration *out, const char *host,
+  caosdb_connection_connection_configuration *out, const char *host, const int port,
-  const int port, caosdb_authentication_authenticator *authenticator,
+  caosdb_authentication_authenticator *authenticator,
  caosdb_connection_certificate_provider *provider);
 /**
@@ -173,8 +172,7 @@ int caosdb_connection_create_tls_connection_configuration(
 * Only use it when you know what you are doing.
 */
 int caosdb_connection_create_insecure_connection_configuration(
-  caosdb_connection_connection_configuration *out, const char *host,
+  caosdb_connection_connection_configuration *out, const char *host, const int port);
-  const int port);
 /**
 * Destructor function for the caosdb_connection_connection_configuration
@@ -192,8 +190,7 @@ int caosdb_connection_delete_connection_configuration(
 * @param cacert path to a pem-file.
 */
 int caosdb_connection_configuration_add_cacert(
-  caosdb_connection_connection_configuration *configuration,
+  caosdb_connection_connection_configuration *configuration, const char *cacert);
-  const char *cacert);
 /**
 * Create a plain password authenticator.
@@ -206,16 +203,14 @@ int caosdb_connection_configuration_add_cacert(
 * Only use it when you know what you are doing.
 */
 int caosdb_authentication_create_plain_password_authenticator(
-  caosdb_authentication_authenticator *out, const char *username,
+  caosdb_authentication_authenticator *out, const char *username, const char *password);
-  const char *password);
 /**
 * Destructor function for the caosdb_authentication_authenticator struct.
 *
 * EXPERT USE ONLY.  Only use it when you know what you are doing.
 */
-int caosdb_authentication_delete_authenticator(
+int caosdb_authentication_delete_authenticator(caosdb_authentication_authenticator *authenticator);
-  caosdb_authentication_authenticator *authenticator);
 /**
 * Create a connection instance.
@@ -239,31 +234,28 @@ int caosdb_connection_create_connection(
 *
 * EXPERT USE ONLY.  Only use it when you know what you are doing.
 */
-int caosdb_connection_delete_connection(
+int caosdb_connection_delete_connection(caosdb_connection_connection *connection);
-  caosdb_connection_connection *connection);
 /**
 * Request the version of the server.
 */
-int caosdb_connection_get_version_info(
+int caosdb_connection_get_version_info(caosdb_info_version_info *out,
-  caosdb_info_version_info *out,
+                                       const caosdb_connection_connection *connection);
-  const caosdb_connection_connection *connection);
 /**
 * Get the default connection from the ConnectionManager.
 *
 * The default connection is to be specified in a configuration file.
 */
-int caosdb_connection_connection_manager_get_default_connection(
+int caosdb_connection_connection_manager_get_default_connection(caosdb_connection_connection *out);
-  caosdb_connection_connection *out);
 /**
 * Get a named connection from the ConnectionManager.
 *
 * The named connection is to be specified in a configuration file.
 */
-int caosdb_connection_connection_manager_get_connection(
+int caosdb_connection_connection_manager_get_connection(caosdb_connection_connection *out,
-  caosdb_connection_connection *out, const char *name);
+                                                        const char *name);
 /****************************************************************************
 * ENTITY STUFF AND TRANSACTIONS
@@ -282,19 +274,16 @@ typedef struct {
 * This transaction has to be deleted manually by
 * caosdb_transaction_delete_transaction() later on.
 */
-int caosdb_connection_connection_create_transaction(
+int caosdb_connection_connection_create_transaction(caosdb_connection_connection *connection,
-  caosdb_connection_connection *connection,
+                                                    caosdb_transaction_transaction *out);
-  caosdb_transaction_transaction *out);
+int caosdb_transaction_delete_transaction(caosdb_transaction_transaction *transaction);
-int caosdb_transaction_delete_transaction(
+int caosdb_transaction_transaction_retrieve_by_id(caosdb_transaction_transaction *transaction,
-  caosdb_transaction_transaction *transaction);
+                                                  const char *id);
-int caosdb_transaction_transaction_retrieve_by_id(
+int caosdb_transaction_transaction_retrieve_by_ids(caosdb_transaction_transaction *transaction,
-  caosdb_transaction_transaction *transaction, const char *id);
+                                                   const char *ids[], int length);
-int caosdb_transaction_transaction_retrieve_by_ids(
+int caosdb_transaction_transaction_query(caosdb_transaction_transaction *transaction,
-  caosdb_transaction_transaction *transaction, const char *ids[], int length);
+                                         const char *query);
-int caosdb_transaction_transaction_query(
+int caosdb_transaction_transaction_execute(caosdb_transaction_transaction *transaction);
-  caosdb_transaction_transaction *transaction, const char *query);
-int caosdb_transaction_transaction_execute(
-  caosdb_transaction_transaction *transaction);
 // TODO(fspreck) execute_asynchronously may be added as a separate
 // function once we actually support asynchronous execution.
@@ -303,12 +292,11 @@ typedef struct {
  bool _deletable = false;
 } caosdb_transaction_result_set;
-int caosdb_transaction_transaction_get_result_set(
+int caosdb_transaction_transaction_get_result_set(caosdb_transaction_transaction *transaction,
-  caosdb_transaction_transaction *transaction,
+                                                  caosdb_transaction_result_set *out);
-  caosdb_transaction_result_set *out);
-int caosdb_transaction_transaction_get_count_result(
+int caosdb_transaction_transaction_get_count_result(caosdb_transaction_transaction *transaction,
-  caosdb_transaction_transaction *transaction, long *out);
+                                                    long *out);
 typedef struct {
  void *wrapped_entity;
@@ -317,8 +305,7 @@ typedef struct {
 int caosdb_transaction_result_set_at(caosdb_transaction_result_set *result_set,
                                     caosdb_entity_entity *entity, int index);
-int caosdb_transaction_result_set_size(
+int caosdb_transaction_result_set_size(caosdb_transaction_result_set *result_set, int *out);
-  caosdb_transaction_result_set *result_set, int *out);
 typedef struct {
  void *wrapped_property;
@@ -337,55 +324,41 @@ typedef struct {
 int caosdb_entity_entity_get_id(caosdb_entity_entity *entity, char *out);
 int caosdb_entity_entity_get_role(caosdb_entity_entity *entity, char *out);
 int caosdb_entity_entity_get_name(caosdb_entity_entity *entity, char *out);
-int caosdb_entity_entity_get_description(caosdb_entity_entity *entity,
+int caosdb_entity_entity_get_description(caosdb_entity_entity *entity, char *out);
-                                         char *out);
 int caosdb_entity_entity_get_datatype(caosdb_entity_entity *entity, char *out);
 int caosdb_entity_entity_get_unit(caosdb_entity_entity *entity, char *out);
 int caosdb_entity_entity_get_value(caosdb_entity_entity *entity, char *out);
-int caosdb_entity_entity_get_version_id(caosdb_entity_entity *entity,
+int caosdb_entity_entity_get_version_id(caosdb_entity_entity *entity, char *out);
-                                        char *out);
+int caosdb_entity_entity_get_errors_size(caosdb_entity_entity *entity, int *out);
-int caosdb_entity_entity_get_errors_size(caosdb_entity_entity *entity,
+int caosdb_entity_entity_get_error(caosdb_entity_entity *entity, caosdb_entity_message *out,
-                                         int *out);
+                                   int index);
-int caosdb_entity_entity_get_error(caosdb_entity_entity *entity,
+int caosdb_entity_entity_get_warnings_size(caosdb_entity_entity *entity, int *out);
-                                   caosdb_entity_message *out, int index);
+int caosdb_entity_entity_get_warning(caosdb_entity_entity *entity, caosdb_entity_message *out,
-int caosdb_entity_entity_get_warnings_size(caosdb_entity_entity *entity,
+                                     int index);
-                                           int *out);
-int caosdb_entity_entity_get_warning(caosdb_entity_entity *entity,
-                                     caosdb_entity_message *out, int index);
 int caosdb_entity_entity_get_infos_size(caosdb_entity_entity *entity, int *out);
-int caosdb_entity_entity_get_info(caosdb_entity_entity *entity,
+int caosdb_entity_entity_get_info(caosdb_entity_entity *entity, caosdb_entity_message *out,
-                                  caosdb_entity_message *out, int index);
+                                  int index);
-int caosdb_entity_entity_get_properties_size(caosdb_entity_entity *entity,
+int caosdb_entity_entity_get_properties_size(caosdb_entity_entity *entity, int *out);
-                                             int *out);
+int caosdb_entity_entity_get_property(caosdb_entity_entity *entity, caosdb_entity_property *out,
-int caosdb_entity_entity_get_property(caosdb_entity_entity *entity,
+                                      int index);
-                                      caosdb_entity_property *out, int index);
+int caosdb_entity_entity_get_parents_size(caosdb_entity_entity *entity, int *out);
-int caosdb_entity_entity_get_parents_size(caosdb_entity_entity *entity,
+int caosdb_entity_entity_get_parent(caosdb_entity_entity *entity, caosdb_entity_parent *out,
-                                          int *out);
+                                    int index);
-int caosdb_entity_entity_get_parent(caosdb_entity_entity *entity,
-                                    caosdb_entity_parent *out, int index);
 int caosdb_entity_property_get_id(caosdb_entity_property *property, char *out);
-int caosdb_entity_property_get_name(caosdb_entity_property *property,
+int caosdb_entity_property_get_name(caosdb_entity_property *property, char *out);
-                                    char *out);
+int caosdb_entity_property_get_description(caosdb_entity_property *property, char *out);
-int caosdb_entity_property_get_description(caosdb_entity_property *property,
+int caosdb_entity_property_get_importance(caosdb_entity_property *property, char *out);
-                                           char *out);
+int caosdb_entity_property_get_datatype(caosdb_entity_property *property, char *out);
-int caosdb_entity_property_get_importance(caosdb_entity_property *property,
+int caosdb_entity_property_get_unit(caosdb_entity_property *property, char *out);
-                                          char *out);
+int caosdb_entity_property_get_value(caosdb_entity_property *property, char *out);
-int caosdb_entity_property_get_datatype(caosdb_entity_property *property,
-                                        char *out);
-int caosdb_entity_property_get_unit(caosdb_entity_property *property,
-                                    char *out);
-int caosdb_entity_property_get_value(caosdb_entity_property *property,
-                                     char *out);
 int caosdb_entity_parent_get_id(caosdb_entity_parent *parent, char *out);
 int caosdb_entity_parent_get_name(caosdb_entity_parent *parent, char *out);
-int caosdb_entity_parent_get_description(caosdb_entity_parent *parent,
+int caosdb_entity_parent_get_description(caosdb_entity_parent *parent, char *out);
-                                         char *out);
 int caosdb_entity_message_get_code(caosdb_entity_message *message, int *out);
-int caosdb_entity_message_get_description(caosdb_entity_message *message,
+int caosdb_entity_message_get_description(caosdb_entity_message *message, char *out);
-                                          char *out);
 // CONSTRUCTORS AND DESTRUCTORS
 int caosdb_entity_create_entity(caosdb_entity_entity *out);
@@ -396,42 +369,27 @@ int caosdb_entity_create_parent(caosdb_entity_parent *out);
 int caosdb_entity_delete_parent(caosdb_entity_parent *out);
 // SETTERS FOR EVERYTHING THAT MAY BE SET
-int caosdb_entity_entity_set_role(caosdb_entity_entity *entity,
+int caosdb_entity_entity_set_role(caosdb_entity_entity *entity, const char *role);
-                                  const char *role);
+int caosdb_entity_entity_set_name(caosdb_entity_entity *entity, const char *name);
-int caosdb_entity_entity_set_name(caosdb_entity_entity *entity,
+int caosdb_entity_entity_set_description(caosdb_entity_entity *entity, const char *description);
-                                  const char *name);
+int caosdb_entity_entity_set_datatype(caosdb_entity_entity *entity, const char *datatype);
-int caosdb_entity_entity_set_description(caosdb_entity_entity *entity,
+int caosdb_entity_entity_set_unit(caosdb_entity_entity *entity, const char *unit);
-                                         const char *description);
+int caosdb_entity_entity_set_value(caosdb_entity_entity *entity, const char *value);
-int caosdb_entity_entity_set_datatype(caosdb_entity_entity *entity,
+int caosdb_entity_entity_append_parent(caosdb_entity_entity *entity, caosdb_entity_parent *parent);
-                                      const char *datatype);
-int caosdb_entity_entity_set_unit(caosdb_entity_entity *entity,
-                                  const char *unit);
-int caosdb_entity_entity_set_value(caosdb_entity_entity *entity,
-                                   const char *value);
-int caosdb_entity_entity_append_parent(caosdb_entity_entity *entity,
-                                       caosdb_entity_parent *parent);
 int caosdb_entity_entity_remove_parent(caosdb_entity_entity *entity, int index);
 int caosdb_entity_entity_append_property(caosdb_entity_entity *entity,
                                         caosdb_entity_property *property);
-int caosdb_entity_entity_remove_property(caosdb_entity_entity *entity,
+int caosdb_entity_entity_remove_property(caosdb_entity_entity *entity, int index);
-                                         int index);
+int caosdb_entity_property_set_id(caosdb_entity_property *property, const char *id);
-int caosdb_entity_property_set_id(caosdb_entity_property *property,
+int caosdb_entity_property_set_name(caosdb_entity_property *property, const char *name);
-                                  const char *id);
+int caosdb_entity_property_set_datatype(caosdb_entity_property *property, const char *datatype);
-int caosdb_entity_property_set_name(caosdb_entity_property *property,
+int caosdb_entity_property_set_importance(caosdb_entity_property *property, const char *importance);
-                                    const char *name);
+int caosdb_entity_property_set_unit(caosdb_entity_property *property, const char *unit);
-int caosdb_entity_property_set_datatype(caosdb_entity_property *property,
+int caosdb_entity_property_set_value(caosdb_entity_property *property, const char *value);
-                                        const char *datatype);
-int caosdb_entity_property_set_importance(caosdb_entity_property *property,
-                                          const char *importance);
-int caosdb_entity_property_set_unit(caosdb_entity_property *property,
-                                    const char *unit);
-int caosdb_entity_property_set_value(caosdb_entity_property *property,
-                                     const char *value);
 int caosdb_entity_parent_set_id(caosdb_entity_parent *parent, const char *id);
-int caosdb_entity_parent_set_name(caosdb_entity_parent *parent,
+int caosdb_entity_parent_set_name(caosdb_entity_parent *parent, const char *name);
-                                  const char *name);
 #ifdef __cplusplus
 }

--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -29,6 +29,7 @@ set(libcaosdb_SRC
    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/protobuf_helper.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/transaction.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/transaction_handler.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/utility.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/unary_rpc_handler.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/file_transmission/register_file_upload_handler.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/file_transmission/upload_request_handler.cpp

--- a/src/caosdb/authentication.cpp
+++ b/src/caosdb/authentication.cpp
@@ -34,28 +34,28 @@ using grpc::MetadataCredentialsPlugin;
 using grpc::Status;
 using grpc::string_ref;
-MetadataCredentialsPluginImpl::MetadataCredentialsPluginImpl(std::string key,
+MetadataCredentialsPluginImpl::MetadataCredentialsPluginImpl(std::string key, std::string value)
-                                                             std::string value)
  : key(std::move(key)), value(std::move(value)) {}
-auto MetadataCredentialsPluginImpl::GetMetadata(
+auto MetadataCredentialsPluginImpl::GetMetadata(string_ref /*service_url*/,
-  string_ref /*service_url*/, string_ref /*method_name*/,
+                                                string_ref /*method_name*/,
-  const AuthContext & /*channel_auth_context*/,
+                                                const AuthContext & /*channel_auth_context*/,
-  std::multimap<grpc::string, grpc::string> *metadata) -> Status {
+                                                std::multimap<grpc::string, grpc::string> *metadata)
+  -> Status {
  metadata->insert(std::make_pair(this->key, this->value));
  return Status::OK;
 }
-PlainPasswordAuthenticator::PlainPasswordAuthenticator(
+PlainPasswordAuthenticator::PlainPasswordAuthenticator(const std::string &username,
-  const std::string &username, const std::string &password) {
+                                                       const std::string &password) {
  this->basic = "Basic " + base64_encode(username + ":" + password);
 }
 auto PlainPasswordAuthenticator::GetCallCredentials() const
  -> std::shared_ptr<grpc::CallCredentials> {
-  auto call_creds = grpc::MetadataCredentialsFromPlugin(
+  auto call_creds =
-    std::unique_ptr<grpc::MetadataCredentialsPlugin>(
+    grpc::MetadataCredentialsFromPlugin(std::unique_ptr<grpc::MetadataCredentialsPlugin>(
      new MetadataCredentialsPluginImpl("authentication", this->basic)));
  return call_creds;
 }

--- a/src/caosdb/configuration.cpp
+++ b/src/caosdb/configuration.cpp
@@ -75,8 +75,7 @@ auto PemFileCertificateProvider::GetCertificatePem() const -> std::string {
  return this->certificate_provider;
 }
-PemCertificateProvider::PemCertificateProvider(
+PemCertificateProvider::PemCertificateProvider(const std::string &certificate_provider) {
-  const std::string &certificate_provider) {
  this->certificate_provider = certificate_provider;
 }
@@ -84,26 +83,21 @@ auto PemCertificateProvider::GetCertificatePem() const -> std::string {
  return this->certificate_provider;
 }
-ConnectionConfiguration::ConnectionConfiguration(const std::string &host,
+ConnectionConfiguration::ConnectionConfiguration(const std::string &host, int port) {
-                                                 int port) {
  this->host = host;
  this->port = port;
 }
-auto ConnectionConfiguration::GetHost() const -> std::string {
+auto ConnectionConfiguration::GetHost() const -> std::string { return this->host; }
-  return this->host;
-}
 auto ConnectionConfiguration::GetPort() const -> int { return this->port; }
-auto operator<<(std::ostream &out, const ConnectionConfiguration &configuration)
+auto operator<<(std::ostream &out, const ConnectionConfiguration &configuration) -> std::ostream & {
-  -> std::ostream & {
  out << configuration.ToString();
  return out;
 }
-InsecureConnectionConfiguration::InsecureConnectionConfiguration(
+InsecureConnectionConfiguration::InsecureConnectionConfiguration(const std::string &host, int port)
-  const std::string &host, int port)
  : ConnectionConfiguration(host, port) {
  this->credentials = InsecureChannelCredentials();
 }
@@ -118,41 +112,38 @@ auto InsecureConnectionConfiguration::ToString() const -> std::string {
         std::to_string(this->GetPort()) + ")";
 }
-TlsConnectionConfiguration::TlsConnectionConfiguration(const std::string &host,
+TlsConnectionConfiguration::TlsConnectionConfiguration(const std::string &host, int port)
-                                                       int port)
  : ConnectionConfiguration(host, port) {
  SslCredentialsOptions options;
  this->credentials = SslCredentials(options);
 }
 TlsConnectionConfiguration::TlsConnectionConfiguration(
-  const std::string &host, int port,
+  const std::string &host, int port, const CertificateProvider &certificate_provider)
-  const CertificateProvider &certificate_provider)
  : ConnectionConfiguration(host, port) {
  SslCredentialsOptions options;
  options.pem_root_certs = certificate_provider.GetCertificatePem();
  this->credentials = SslCredentials(options);
 }
-TlsConnectionConfiguration::TlsConnectionConfiguration(
+TlsConnectionConfiguration::TlsConnectionConfiguration(const std::string &host, int port,
-  const std::string &host, int port, const Authenticator &authenticator)
+                                                       const Authenticator &authenticator)
  : ConnectionConfiguration(host, port) {
  SslCredentialsOptions options;
-  this->credentials = grpc::CompositeChannelCredentials(
+  this->credentials =
-    SslCredentials(options), authenticator.GetCallCredentials());
+    grpc::CompositeChannelCredentials(SslCredentials(options), authenticator.GetCallCredentials());
 }
 TlsConnectionConfiguration::TlsConnectionConfiguration(
-  const std::string &host, int port,
+  const std::string &host, int port, const CertificateProvider &certificate_provider,
-  const CertificateProvider &certificate_provider,
  const Authenticator &authenticator)
  : ConnectionConfiguration(host, port) {
  SslCredentialsOptions options;
  options.pem_root_certs = certificate_provider.GetCertificatePem();
-  this->credentials = grpc::CompositeChannelCredentials(
+  this->credentials =
-    SslCredentials(options), authenticator.GetCallCredentials());
+    grpc::CompositeChannelCredentials(SslCredentials(options), authenticator.GetCallCredentials());
 }
 auto TlsConnectionConfiguration::GetChannelCredentials() const
@@ -161,31 +152,29 @@ auto TlsConnectionConfiguration::GetChannelCredentials() const
 }
 auto TlsConnectionConfiguration::ToString() const -> std::string {
-  return "TlsConnectionConfiguration(" + this->GetHost() + "," +
+  return "TlsConnectionConfiguration(" + this->GetHost() + "," + std::to_string(this->GetPort()) +
-         std::to_string(this->GetPort()) + "," + this->certificate_provider +
+         "," + this->certificate_provider + ")";
-         ")";
 }
-auto ConnectionConfigurationHelper::CreateCertificateProvider(
+auto ConnectionConfigurationHelper::CreateCertificateProvider(const object &from) const
-  const object &from) const -> std::unique_ptr<CertificateProvider> {
+  -> std::unique_ptr<CertificateProvider> {
  std::unique_ptr<CertificateProvider> certificate_provider;
  if (from.contains("server_certificate_path")) {
    const value &path_str = from.at("server_certificate_path");
    assert(path_str.is_string() == true);
    const path certificate_file = path(path_str.as_string().c_str());
    if (!exists(certificate_file)) {
-      throw ConfigurationError(
+      throw ConfigurationError("File does not exist (server_certificate_path): " +
-        "File does not exist (server_certificate_path): " +
+                               certificate_file.string());
-        certificate_file.string());
    }
-    certificate_provider = std::make_unique<PemFileCertificateProvider>(
+    certificate_provider =
-      path(path_str.as_string().c_str()));
+      std::make_unique<PemFileCertificateProvider>(path(path_str.as_string().c_str()));
  }
  return certificate_provider;
 }
-auto ConnectionConfigurationHelper::CreateAuthenticator(
+auto ConnectionConfigurationHelper::CreateAuthenticator(const object &from) const
-  const object &from) const -> std::unique_ptr<Authenticator> {
+  -> std::unique_ptr<Authenticator> {
  std::unique_ptr<Authenticator> authenticator;
  if (from.contains("authentication")) {
    assert(from.at("authentication").is_object());
@@ -205,8 +194,7 @@ auto ConnectionConfigurationHelper::CreateAuthenticator(
      assert(password.is_string());
      authenticator = std::make_unique<PlainPasswordAuthenticator>(
-        std::string(username.as_string().c_str()),
+        std::string(username.as_string().c_str()), std::string(password.as_string().c_str()));
-        std::string(password.as_string().c_str()));
    } else {
      throw ConfigurationError("Unknow authentication type: '" + type + "'.");
    }
@@ -216,22 +204,19 @@ auto ConnectionConfigurationHelper::CreateAuthenticator(
 auto ConnectionConfigurationHelper::CreateConnectionConfiguration(
  const bool tls, const std::string &host, const int port,
-  const CertificateProvider *certificate_provider,
+  const CertificateProvider *certificate_provider, const Authenticator *authenticator) const
-  const Authenticator *authenticator) const
  -> std::unique_ptr<ConnectionConfiguration> {
  if (tls) {
    if (certificate_provider != nullptr && authenticator != nullptr) {
      // authenticated and special certificate
-      return std::make_unique<TlsConnectionConfiguration>(
+      return std::make_unique<TlsConnectionConfiguration>(host, port, *certificate_provider,
-        host, port, *certificate_provider, *authenticator);
+                                                          *authenticator);
    } else if (certificate_provider != nullptr) {
      // unauthenticated, special certificate
-      return std::make_unique<TlsConnectionConfiguration>(
+      return std::make_unique<TlsConnectionConfiguration>(host, port, *certificate_provider);
-        host, port, *certificate_provider);
    } else if (authenticator != nullptr) {
      // authenticated, no special certificate
-      return std::make_unique<TlsConnectionConfiguration>(host, port,
+      return std::make_unique<TlsConnectionConfiguration>(host, port, *authenticator);
-                                                          *authenticator);
    }
    // unauthenticated, no special certificate
    return std::make_unique<TlsConnectionConfiguration>(host, port);
@@ -250,8 +235,8 @@ auto ConnectionConfigurationHelper::IsTls(const object &from) const -> bool {
  return tls;
 }
-auto ConnectionConfigurationHelper::CreateConnectionConfiguration(
+auto ConnectionConfigurationHelper::CreateConnectionConfiguration(const object &from) const
-  const object &from) const -> std::unique_ptr<ConnectionConfiguration> {
+  -> std::unique_ptr<ConnectionConfiguration> {
  assert(from.contains("host"));
  const auto &host = from.at("host");
  assert(host.is_string());
@@ -266,28 +251,30 @@ auto ConnectionConfigurationHelper::CreateConnectionConfiguration(
  auto authenticator = CreateAuthenticator(from);
-  return CreateConnectionConfiguration(
+  return CreateConnectionConfiguration(tls, std::string(host.as_string().c_str()),
-    tls, std::string(host.as_string().c_str()),
+                                       static_cast<int>(port.as_int64()),
-    static_cast<int>(port.as_int64()), certificate_provider.get(),
+                                       certificate_provider.get(), authenticator.get());
-    authenticator.get());
 }
-auto LoggingConfigurationHelper::CreateConsoleSinkConfiguration(
+auto LoggingConfigurationHelper::CreateConsoleSinkConfiguration(const object & /*from*/,
-  const object & /*from*/, const std::string &name, int level) const
+                                                                const std::string &name,
+                                                                int level) const
  -> std::shared_ptr<caosdb::logging::SinkConfiguration> {
  auto result = std::make_shared<ConsoleSinkConfiguration>(name, level);
  return result;
 }
-auto LoggingConfigurationHelper::CreateSyslogSinkConfiguration(
+auto LoggingConfigurationHelper::CreateSyslogSinkConfiguration(const object & /*from*/,
-  const object & /*from*/, const std::string &name, int level) const
+                                                               const std::string &name,
+                                                               int level) const
  -> std::shared_ptr<caosdb::logging::SinkConfiguration> {
  auto result = std::make_shared<SyslogSinkConfiguration>(name, level);
  return result;
 }
-auto LoggingConfigurationHelper::CreateFileSinkConfiguration(
+auto LoggingConfigurationHelper::CreateFileSinkConfiguration(const object &from,
-  const object &from, const std::string &name, int level) const
+                                                             const std::string &name,
+                                                             int level) const
  -> std::shared_ptr<caosdb::logging::SinkConfiguration> {
  auto result = std::make_shared<FileSinkConfiguration>(name, level);
  if (from.contains("directory")) {
@@ -296,16 +283,15 @@ auto LoggingConfigurationHelper::CreateFileSinkConfiguration(
  return result;
 }
-auto LoggingConfigurationHelper::CreateSinkConfiguration(
+auto LoggingConfigurationHelper::CreateSinkConfiguration(const object &from,
-  const object &from, const std::string &name, int default_level) const
+                                                         const std::string &name,
+                                                         int default_level) const
  -> std::shared_ptr<caosdb::logging::SinkConfiguration> {
  assert(from.contains("destination"));
-  const auto &destination =
+  const auto &destination = std::string(from.at("destination").as_string().c_str());
-    std::string(from.at("destination").as_string().c_str());
-  int level = from.contains("level")
+  int level =
-                ? ConvertLogLevel(from.at("level").as_string().c_str())
+    from.contains("level") ? ConvertLogLevel(from.at("level").as_string().c_str()) : default_level;
-                : default_level;
  if (destination == "file") {
    return CreateFileSinkConfiguration(from, name, level);
@@ -318,8 +304,7 @@ auto LoggingConfigurationHelper::CreateSinkConfiguration(
  }
 }
-auto LoggingConfigurationHelper::ConvertLogLevel(
+auto LoggingConfigurationHelper::ConvertLogLevel(const std::string &string_level) const -> int {
-  const std::string &string_level) const -> int {
  static std::map<std::string, int> log_level_names = {
    {"", CAOSDB_DEFAULT_LOG_LEVEL},    {"off", CAOSDB_LOG_LEVEL_OFF},
    {"fatal", CAOSDB_LOG_LEVEL_FATAL}, {"error", CAOSDB_LOG_LEVEL_ERROR},
@@ -333,11 +318,10 @@ auto LoggingConfigurationHelper::ConvertLogLevel(
  }
 }
-auto LoggingConfigurationHelper::CreateLoggingConfiguration(
+auto LoggingConfigurationHelper::CreateLoggingConfiguration(const object &from) const
-  const object &from) const -> LoggingConfiguration {
+  -> LoggingConfiguration {
-  auto default_level_str = from.contains("level")
+  auto default_level_str =
-                             ? std::string(from.at("level").as_string().c_str())
+    from.contains("level") ? std::string(from.at("level").as_string().c_str()) : "";
-                             : "";
  int default_level = ConvertLogLevel(default_level_str);
  auto result = LoggingConfiguration(default_level);
@@ -351,8 +335,8 @@ auto LoggingConfigurationHelper::CreateLoggingConfiguration(
      const auto *elem = sinks.begin();
      while (elem != sinks.end()) {
-        result.AddSink(CreateSinkConfiguration(
+        result.AddSink(CreateSinkConfiguration(elem->value().as_object(), elem->key().to_string(),
-          elem->value().as_object(), elem->key().to_string(), default_level));
+                                               default_level));
        elem = std::next(elem);
      }
    }
@@ -369,9 +353,8 @@ auto ConfigurationManager::mReset() noexcept -> int {
  } catch (const caosdb::exceptions::Exception &exc) {
    return exc.GetCode();
  } catch (const std::exception &exc) {
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "Unknown error during the reset of the ConfigurationManager: "
-      << "Unknown error during the reset of the ConfigurationManager: "
+                                  << exc.what();
-      << exc.what();
    return StatusCode::CONFIGURATION_ERROR;
  }
 }
@@ -384,15 +367,13 @@ auto ConfigurationManager::mClear() noexcept -> int {
  } catch (const caosdb::exceptions::Exception &exc) {
    return exc.GetCode();
  } catch (const std::exception &exc) {
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "Unknown error during the reset of the ConfigurationManager: "
-      << "Unknown error during the reset of the ConfigurationManager: "
+                                  << exc.what();
-      << exc.what();
    return StatusCode::CONFIGURATION_ERROR;
  }
 }
-auto ConfigurationManager::mLoadSingleJSONConfiguration(const path &json_file)
+auto ConfigurationManager::mLoadSingleJSONConfiguration(const path &json_file) -> void {
-  -> void {
  if (!json_configuration.is_null()) {
    throw ConfigurationError("This CaosDB client has already been configured.");
  }
@@ -403,11 +384,10 @@ auto ConfigurationManager::mLoadSingleJSONConfiguration(const path &json_file)
  json_configuration = load_json_file(json_file);
 }
-auto ConfigurationManager::mGetConnectionConfiguration(
+auto ConfigurationManager::mGetConnectionConfiguration(const std::string &name) const
-  const std::string &name) const -> std::unique_ptr<ConnectionConfiguration> {
+  -> std::unique_ptr<ConnectionConfiguration> {
  auto connection_json = GetConnection(name);
-  return connection_configuration_helper.CreateConnectionConfiguration(
+  return connection_configuration_helper.CreateConnectionConfiguration(connection_json);
-    connection_json);
 }
 auto ConfigurationManager::mGetDefaultConnectionName() const -> std::string {
@@ -442,33 +422,28 @@ auto ConfigurationManager::GetConfiguration() const -> const object & {
 auto ConfigurationManager::GetConnections() const -> const object & {
  const auto &configuration = GetConfiguration();
  if (!configuration.contains("connections")) {
-    throw ConfigurationError(
+    throw ConfigurationError("This CaosDB client hasn't any configured connections.");
-      "This CaosDB client hasn't any configured connections.");
  }
  const auto &connections_value = configuration.at("connections");
  if (connections_value.is_null()) {
-    throw ConfigurationError(
+    throw ConfigurationError("This CaosDB client hasn't any configured connections.");
-      "This CaosDB client hasn't any configured connections.");
  }
  assert(connections_value.is_object());
  const auto &connections_object = connections_value.as_object();
  if (connections_object.empty()) {
-    throw ConfigurationError(
+    throw ConfigurationError("This CaosDB client hasn't any configured connections.");
-      "This CaosDB client hasn't any configured connections.");
  }
  return connections_object;
 }
-auto ConfigurationManager::GetConnection(const std::string &name) const
+auto ConfigurationManager::GetConnection(const std::string &name) const -> const object & {
-  -> const object & {
  const auto &connections = GetConnections();
  if (connections.contains(name)) {
    const auto &result_connection = connections.at(name);
    assert(result_connection.is_object());
    return result_connection.as_object();
  }
-  throw ConfigurationError("The connection '" + name +
+  throw ConfigurationError("The connection '" + name + "' has not been defined.");
-                           "' has not been defined.");
 }
 // TODO(tf) This has apparently a cognitive complexity of 34>25 (threshold).
@@ -476,13 +451,11 @@ auto ConfigurationManager::InitializeDefaults() -> int { // NOLINT
  // find the configuration file...
  std::unique_ptr<path> configuration_file_path;
-  for (const char *const &configuration_file :
+  for (const char *const &configuration_file : caosdb::LIBCAOSDB_CONFIGURATION_FILES_PRECEDENCE) {
-       caosdb::LIBCAOSDB_CONFIGURATION_FILES_PRECEDENCE) {
    if (strcmp(configuration_file, "$CAOSDB_CLIENT_CONFIGURATION") == 0) {
      // user specified a file via the environment variable
      // TODO(tf) make this thread-secure (concurrency-mt-unsafe)
-      const auto *from_env_var =
+      const auto *from_env_var = getenv("CAOSDB_CLIENT_CONFIGURATION"); // NOLINT
-        getenv("CAOSDB_CLIENT_CONFIGURATION"); // NOLINT
      if (from_env_var != nullptr) {
        configuration_file_path = std::make_unique<path>(from_env_var);
        if (exists(*configuration_file_path)) {
@@ -532,10 +505,9 @@ auto ConfigurationManager::InitializeDefaults() -> int { // NOLINT
                                    "We are using the default configuration";
  }
-  if (configuration_file_path != nullptr &&
+  if (configuration_file_path != nullptr && this->json_configuration.is_object()) {
-      this->json_configuration.is_object()) {
+    CAOSDB_LOG_INFO(logger_name) << "Loaded configuration from " << *(configuration_file_path.get())
-    CAOSDB_LOG_INFO(logger_name) << "Loaded configuration from "
+                                 << ".";
-                                 << *(configuration_file_path.get()) << ".";
  }
  return 0;

--- a/src/caosdb/connection.cpp
+++ b/src/caosdb/connection.cpp
@@ -48,17 +48,14 @@ using caosdb::transaction::TransactionStatus;
 Connection::Connection(const ConnectionConfiguration &configuration) {
  const std::string target =
    configuration.GetHost() + ":" + std::to_string(configuration.GetPort());
-  this->channel =
+  this->channel = grpc::CreateChannel(target, configuration.GetChannelCredentials());
-    grpc::CreateChannel(target, configuration.GetChannelCredentials());
  this->general_info_service = GeneralInfoService::NewStub(this->channel);
  this->entity_transaction_service =
    std::make_shared<EntityTransactionService::Stub>(this->channel);
-  this->file_transmission_service =
+  this->file_transmission_service = std::make_shared<FileTransmissionService::Stub>(this->channel);
-    std::make_shared<FileTransmissionService::Stub>(this->channel);
 }
-auto Connection::RetrieveVersionInfoNoExceptions() const noexcept
+auto Connection::RetrieveVersionInfoNoExceptions() const noexcept -> TransactionStatus {
-  -> TransactionStatus {
  const GetVersionInfoRequest request;
  GetVersionInfoResponse response;
@@ -70,20 +67,18 @@ auto Connection::RetrieveVersionInfoNoExceptions() const noexcept
  if (!grpc_status.ok()) {
    switch (grpc_status.error_code()) {
    case grpc::StatusCode::UNAUTHENTICATED:
-      status =
+      status = TransactionStatus::AUTHENTICATION_ERROR(grpc_status.error_message());
-        TransactionStatus::AUTHENTICATION_ERROR(grpc_status.error_message());
      break;
    case grpc::StatusCode::UNAVAILABLE:
      status = TransactionStatus::CONNECTION_ERROR();
      break;
    default:
      auto error_message = grpc_status.error_message();
-      status = TransactionStatus::RPC_ERROR(
+      status = TransactionStatus::RPC_ERROR(std::to_string(grpc_status.error_code()) + " - " +
-        std::to_string(grpc_status.error_code()) + " - " + error_message);
+                                            error_message);
    }
  } else {
-    this->version_info =
+    this->version_info = std::make_unique<VersionInfo>(response.release_version_info());
-      std::make_unique<VersionInfo>(response.release_version_info());
  }
  return status;
@@ -96,8 +91,7 @@ auto Connection::RetrieveVersionInfo() const -> const VersionInfo & {
  return *GetVersionInfo();
 }
-[[nodiscard]] auto Connection::CreateTransaction() const
+[[nodiscard]] auto Connection::CreateTransaction() const -> std::unique_ptr<Transaction> {
-  -> std::unique_ptr<Transaction> {
  auto entity_service = this->entity_transaction_service;
  auto file_service = this->file_transmission_service;
  return std::make_unique<Transaction>(entity_service, file_service);
@@ -115,19 +109,17 @@ auto ConnectionManager::mGetConnection(const std::string &name) const
      auto connection = ConfigurationManager::GetConnectionConfiguration(name);
      connections[name] = std::make_shared<Connection>(*connection.release());
    } catch (const caosdb::exceptions::ConfigurationError &exc) {
-      throw caosdb::exceptions::UnknownConnectionError("No connection named '" +
+      throw caosdb::exceptions::UnknownConnectionError("No connection named '" + name +
-                                                       name + "' present.");
+                                                       "' present.");
    }
  }
  return this->connections.at(name);
 }
-auto ConnectionManager::mGetDefaultConnection() const
+auto ConnectionManager::mGetDefaultConnection() const -> const std::shared_ptr<Connection> & {
-  -> const std::shared_ptr<Connection> & {
  if (!HasConnection(default_connection_name)) {
    default_connection_name = ConfigurationManager::GetDefaultConnectionName();
-    auto default_connection =
+    auto default_connection = ConfigurationManager::GetDefaultConnectionConfiguration();
-      ConfigurationManager::GetDefaultConnectionConfiguration();
    connections[default_connection_name] =
      std::make_shared<Connection>(*default_connection.release());
  }

--- a/src/caosdb/entity.cpp
+++ b/src/caosdb/entity.cpp
@@ -54,19 +54,13 @@ auto Parent::CreateProtoParent() -> ProtoParent * {
  return Arena::CreateMessage<ProtoParent>(get_arena());
 }
-auto Parent::SetName(const std::string &name) -> void {
+auto Parent::SetName(const std::string &name) -> void { this->wrapped->set_name(name); }
-  this->wrapped->set_name(name);
-}
 auto Parent::SetId(const std::string &id) -> void { this->wrapped->set_id(id); }
-[[nodiscard]] auto Parent::GetId() const -> const std::string & {
+[[nodiscard]] auto Parent::GetId() const -> const std::string & { return this->wrapped->id(); }
-  return this->wrapped->id();
-}
-[[nodiscard]] auto Parent::GetName() const -> const std::string & {
+[[nodiscard]] auto Parent::GetName() const -> const std::string & { return this->wrapped->name(); }
-  return this->wrapped->name();
-}
 [[nodiscard]] auto Parent::GetDescription() const -> const std::string & {
  return this->wrapped->description();
@@ -78,9 +72,7 @@ auto Property::CreateProtoProperty() -> ProtoProperty * {
  return Arena::CreateMessage<ProtoProperty>(get_arena());
 }
-[[nodiscard]] auto Property::GetId() const -> const std::string & {
+[[nodiscard]] auto Property::GetId() const -> const std::string & { return this->wrapped->id(); }
-  return this->wrapped->id();
-}
 [[nodiscard]] auto Property::GetName() const -> const std::string & {
  return this->wrapped->name();
@@ -94,25 +86,17 @@ auto Property::CreateProtoProperty() -> ProtoProperty * {
  return static_cast<Importance>(this->wrapped->importance());
 }
-[[nodiscard]] auto Property::GetValue() const -> const Value & {
+[[nodiscard]] auto Property::GetValue() const -> const Value & { return this->value; }
-  return this->value;
-}
 [[nodiscard]] auto Property::GetUnit() const -> const std::string & {
  return this->wrapped->unit();
 }
-[[nodiscard]] auto Property::GetDataType() const -> const DataType & {
+[[nodiscard]] auto Property::GetDataType() const -> const DataType & { return this->data_type; }
-  return this->data_type;
-}
-auto Property::SetId(const std::string &id) -> void {
+auto Property::SetId(const std::string &id) -> void { this->wrapped->set_id(id); }
-  this->wrapped->set_id(id);
-}
-auto Property::SetName(const std::string &name) -> void {
+auto Property::SetName(const std::string &name) -> void { this->wrapped->set_name(name); }
-  this->wrapped->set_name(name);
-}
 auto Property::SetDescription(const std::string &description) -> void {
  this->wrapped->set_description(description);
@@ -122,21 +106,13 @@ auto Property::SetImportance(Importance importance) -> void {
  this->wrapped->set_importance(static_cast<ProtoImportance>(importance));
 }
-auto Property::SetValue(const Value &value) -> StatusCode {
+auto Property::SetValue(const Value &value) -> StatusCode { return this->value.CopyFrom(value); }
-  return this->value.CopyFrom(value);
-}
-auto Property::SetValue(const std::string &value) -> StatusCode {
+auto Property::SetValue(const std::string &value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Property::SetValue(const char *value) -> StatusCode {
+auto Property::SetValue(const char *value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Property::SetValue(double value) -> StatusCode {
+auto Property::SetValue(double value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
 auto Property::SetValue(const std::vector<std::string> &values) -> StatusCode {
  return SetValue(Value(values));
@@ -158,51 +134,35 @@ auto Property::SetValue(const std::vector<bool> &values) -> StatusCode {
  return SetValue(Value(values));
 }
-auto Property::SetValue(const int64_t value) -> StatusCode {
+auto Property::SetValue(const int64_t value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Property::SetValue(const bool value) -> StatusCode {
+auto Property::SetValue(const bool value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Property::SetUnit(const std::string &unit) -> void {
+auto Property::SetUnit(const std::string &unit) -> void { this->wrapped->set_unit(unit); }
-  this->wrapped->set_unit(unit);
-}
 auto Property::SetDataType(const DataType &new_data_type) -> StatusCode {
  return this->data_type.CopyFrom(new_data_type);
 }
-auto Property::SetDataType(const AtomicDataType new_data_type) -> StatusCode {
+auto Property::SetDataType(const AtomicDataType new_data_type, bool list_type) -> StatusCode {
-  return SetDataType(DataType(new_data_type));
+  return SetDataType(DataType(new_data_type, list_type));
 }
-auto Property::SetDataType(const std::string &new_data_type) -> StatusCode {
+auto Property::SetDataType(const std::string &new_data_type, bool list_type) -> StatusCode {
-  return SetDataType(DataType(new_data_type));
+  return SetDataType(DataType(new_data_type, list_type));
 }
-[[nodiscard]] auto Entity::GetParents() const -> const Parents & {
+[[nodiscard]] auto Entity::GetParents() const -> const Parents & { return parents; }
-  return parents;
-}
-auto Entity::AppendParent(const Parent &parent) -> void {
+auto Entity::AppendParent(const Parent &parent) -> void { this->parents.Append(parent); }
-  this->parents.Append(parent);
-}
 auto Entity::RemoveParent(int index) -> void { this->parents.Remove(index); }
-[[nodiscard]] auto Entity::GetProperties() const -> const Properties & {
+[[nodiscard]] auto Entity::GetProperties() const -> const Properties & { return properties; }
-  return properties;
-}
-auto Entity::AppendProperty(const Property &property) -> void {
+auto Entity::AppendProperty(const Property &property) -> void { this->properties.Append(property); }
-  this->properties.Append(property);
-}
-auto Entity::RemoveProperty(int index) -> void {
+auto Entity::RemoveProperty(int index) -> void { this->properties.Remove(index); }
-  this->properties.Remove(index);
-}
 auto Entity::CreateProtoEntity() -> ProtoEntity * {
  return Arena::CreateMessage<ProtoEntity>(get_arena());
@@ -228,17 +188,11 @@ auto Entity::SetVersionId(const std::string &id) -> void {
  this->wrapped->mutable_version()->set_id(id);
 }
-auto Entity::CopyTo(ProtoEntity *target) -> void {
+auto Entity::CopyTo(ProtoEntity *target) -> void { target->CopyFrom(*(this->wrapped)); }
-  target->CopyFrom(*(this->wrapped));
-}
-auto Entity::SetRole(Role role) -> void {
+auto Entity::SetRole(Role role) -> void { this->wrapped->set_role(static_cast<EntityRole>(role)); }
-  this->wrapped->set_role(static_cast<EntityRole>(role));
-}
-auto Entity::SetName(const std::string &name) -> void {
+auto Entity::SetName(const std::string &name) -> void { this->wrapped->set_name(name); }
-  this->wrapped->set_name(name);
-}
 auto Entity::SetDescription(const std::string &description) -> void {
  this->wrapped->set_description(description);
@@ -251,17 +205,11 @@ auto Entity::SetValue(const Value &value) -> StatusCode {
  return this->value.CopyFrom(value);
 }
-auto Entity::SetValue(const std::string &value) -> StatusCode {
+auto Entity::SetValue(const std::string &value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Entity::SetValue(const char *value) -> StatusCode {
+auto Entity::SetValue(const char *value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Entity::SetValue(double value) -> StatusCode {
+auto Entity::SetValue(double value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
 auto Entity::SetValue(const std::vector<std::string> &values) -> StatusCode {
  return SetValue(Value(values));
@@ -283,17 +231,11 @@ auto Entity::SetValue(const std::vector<bool> &values) -> StatusCode {
  return SetValue(Value(values));
 }
-auto Entity::SetValue(const int64_t value) -> StatusCode {
+auto Entity::SetValue(const int64_t value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Entity::SetValue(const bool value) -> StatusCode {
+auto Entity::SetValue(const bool value) -> StatusCode { return SetValue(Value(value)); }
-  return SetValue(Value(value));
-}
-auto Entity::SetUnit(const std::string &unit) -> void {
+auto Entity::SetUnit(const std::string &unit) -> void { this->wrapped->set_unit(unit); }
-  this->wrapped->set_unit(unit);
-}
 auto Entity::SetDataType(const DataType &new_data_type) -> StatusCode {
  if (GetRole() != Role::PROPERTY) {
@@ -302,12 +244,12 @@ auto Entity::SetDataType(const DataType &new_data_type) -> StatusCode {
  return this->data_type.CopyFrom(new_data_type);
 }
-auto Entity::SetDataType(const AtomicDataType new_data_type) -> StatusCode {
+auto Entity::SetDataType(const AtomicDataType new_data_type, bool list_type) -> StatusCode {
-  return SetDataType(DataType(new_data_type));
+  return SetDataType(DataType(new_data_type, list_type));
 }
-auto Entity::SetDataType(const std::string &new_data_type) -> StatusCode {
+auto Entity::SetDataType(const std::string &new_data_type, bool list_type) -> StatusCode {
-  return SetDataType(DataType(new_data_type));
+  return SetDataType(DataType(new_data_type, list_type));
 }
 auto Entity::SetFilePath(const std::string &path) -> void {

--- a/src/caosdb/file_transmission/download_request_handler.cpp
+++ b/src/caosdb/file_transmission/download_request_handler.cpp
@@ -76,14 +76,13 @@ using caosdb::StatusCode;
 using caosdb::utility::get_arena;
 using google::protobuf::Arena;
-DownloadRequestHandler::DownloadRequestHandler(
+DownloadRequestHandler::DownloadRequestHandler(HandlerTag tag, FileTransmissionService::Stub *stub,
-  HandlerTag tag, FileTransmissionService::Stub *stub,
+                                               grpc::CompletionQueue *cq,
-  grpc::CompletionQueue *cq, FileDescriptor file_descriptor)
+                                               FileDescriptor file_descriptor)
  : tag_(tag), stub_(stub), cq_(cq),
    request_(Arena::CreateMessage<FileDownloadRequest>(get_arena())),
-    response_(Arena::CreateMessage<FileDownloadResponse>(get_arena())),
+    response_(Arena::CreateMessage<FileDownloadResponse>(get_arena())), state_(CallState::NewCall),
-    state_(CallState::NewCall), file_descriptor_(std::move(file_descriptor)),
+    file_descriptor_(std::move(file_descriptor)), bytesReceived_(0) {}
-    bytesReceived_(0) {}
 bool DownloadRequestHandler::OnNext(bool ok) {
  try {
@@ -105,15 +104,13 @@ bool DownloadRequestHandler::OnNext(bool ok) {
    return true;
  } catch (std::exception &e) {
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "DownloadRequestHandler caught an exception: " << e.what();
-      << "DownloadRequestHandler caught an exception: " << e.what();
    transaction_status = TransactionStatus::GENERIC_ERROR(e.what());
    state_ = CallState::CallComplete;
  } catch (...) {
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "Transaction error: unknown exception caught";
-      << "Transaction error: unknown exception caught";
+    transaction_status =
-    transaction_status = TransactionStatus::GENERIC_ERROR(
+      TransactionStatus::GENERIC_ERROR("DownloadRequestHandler caught an unknown exception");
-      "DownloadRequestHandler caught an unknown exception");
    state_ = CallState::CallComplete;
  }
@@ -129,36 +126,30 @@ bool DownloadRequestHandler::OnNext(bool ok) {
 void DownloadRequestHandler::Cancel() { ctx_.TryCancel(); }
 void DownloadRequestHandler::handleNewCallState() {
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Enter DownloadRequestHandler::handleNewCallState. local_path = "
-    << "Enter DownloadRequestHandler::handleNewCallState. local_path = "
+                                << file_descriptor_.local_path
-    << file_descriptor_.local_path
+                                << ", download_id = " << file_descriptor_.file_transmission_id;
-    << ", download_id = " << file_descriptor_.file_transmission_id;
  fileWriter_ = std::make_unique<FileWriter>(file_descriptor_.local_path);
-  request_->mutable_file_transmission_id()->CopyFrom(
+  request_->mutable_file_transmission_id()->CopyFrom(*(file_descriptor_.file_transmission_id));
-    *(file_descriptor_.file_transmission_id));
  rpc_ = stub_->PrepareAsyncFileDownload(&ctx_, *request_, cq_);
  transaction_status = TransactionStatus::EXECUTING();
  state_ = CallState::SendingRequest;
  rpc_->StartCall(tag_);
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Leave DownloadRequestHandler::handleNewCallState";
-    << "Leave DownloadRequestHandler::handleNewCallState";
 }
 void DownloadRequestHandler::handleSendingRequestState() {
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Enter DownloadRequestHandler::handleSendingRequestState";
-    << "Enter DownloadRequestHandler::handleSendingRequestState";
  state_ = CallState::ReceivingFile;
  rpc_->Read(response_, tag_);
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Leave DownloadRequestHandler::handleSendingRequestState";
-    << "Leave DownloadRequestHandler::handleSendingRequestState";
 }
 void DownloadRequestHandler::handleReceivingFileState() {
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Enter DownloadRequestHandler::handleReceivingFileState";
-    << "Enter DownloadRequestHandler::handleReceivingFileState";
  if (response_->has_chunk()) {
    const auto &chunkData = response_->chunk().data();
    if (chunkData.empty()) {
@@ -174,35 +165,30 @@ void DownloadRequestHandler::handleReceivingFileState() {
  } else {
    throw std::runtime_error("File chunk expected");
  }
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Leave DownloadRequestHandler::handleReceivingFileState";
-    << "Leave DownloadRequestHandler::handleReceivingFileState";
 }
 void DownloadRequestHandler::handleCallCompleteState() {
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Enter DownloadRequestHandler::handleCallCompleteState";
-    << "Enter DownloadRequestHandler::handleCallCompleteState";
  switch (status_.error_code()) {
  case grpc::OK: {
-    CAOSDB_LOG_INFO(logger_name)
+    CAOSDB_LOG_INFO(logger_name) << "DownloadRequestHandler finished successfully ("
-      << "DownloadRequestHandler finished successfully ("
+                                 << file_descriptor_.local_path << "): Download complete, "
-      << file_descriptor_.local_path << "): Download complete, "
+                                 << bytesReceived_ << " bytes received.";
-      << bytesReceived_ << " bytes received.";
  } break;
  default: {
    auto code(static_cast<StatusCode>(status_.error_code()));
    std::string description(get_status_description(code) +
                            " Original message: " + status_.error_message());
    transaction_status = TransactionStatus(code, description);
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "DownloadRequestHandler finished with an error ("
-      << "DownloadRequestHandler finished with an error ("
+                                  << file_descriptor_.local_path << "): Download aborted with code "
-      << file_descriptor_.local_path << "): Download aborted with code " << code
+                                  << code << " - " << description;
-      << " - " << description;
  } break;
  }
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Leave DownloadRequestHandler::handleCallCompleteState";
-    << "Leave DownloadRequestHandler::handleCallCompleteState";
 }
 } // namespace caosdb::transaction
--- a/src/caosdb/file_transmission/file_writer.cpp
+++ b/src/caosdb/file_transmission/file_writer.cpp
@@ -53,8 +53,7 @@
 namespace caosdb::transaction {
-FileWriter::FileWriter(boost::filesystem::path filename)
+FileWriter::FileWriter(boost::filesystem::path filename) : filename_(std::move(filename)) {
-  : filename_(std::move(filename)) {
  this->openFile();
 }

--- a/src/caosdb/file_transmission/register_file_upload_handler.cpp
+++ b/src/caosdb/file_transmission/register_file_upload_handler.cpp
@@ -59,26 +59,24 @@ namespace caosdb::transaction {
 RegisterFileUploadHandler::~RegisterFileUploadHandler() = default;
-RegisterFileUploadHandler::RegisterFileUploadHandler(
+RegisterFileUploadHandler::RegisterFileUploadHandler(HandlerTag tag,
-  HandlerTag tag, FileTransmissionService::Stub *stub,
+                                                     FileTransmissionService::Stub *stub,
-  grpc::CompletionQueue *completion_queue, RegisterFileUploadRequest *request,
+                                                     grpc::CompletionQueue *completion_queue,
-  RegisterFileUploadResponse *response)
+                                                     RegisterFileUploadRequest *request,
-  : UnaryRpcHandler(completion_queue), tag_(tag), stub_(stub),
+                                                     RegisterFileUploadResponse *response)
-    request_(request), response_(response) {}
+  : UnaryRpcHandler(completion_queue), tag_(tag), stub_(stub), request_(request),
+    response_(response) {}
 void RegisterFileUploadHandler::handleNewCallState() {
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Enter RegisterFileUploadHandler::handleNewCallState.";
-    << "Enter RegisterFileUploadHandler::handleNewCallState.";
-  rpc_ = stub_->PrepareAsyncRegisterFileUpload(&call_context, *request_,
+  rpc_ = stub_->PrepareAsyncRegisterFileUpload(&call_context, *request_, completion_queue);
-                                               completion_queue);
  state_ = CallState::CallComplete;
  rpc_->StartCall();
  rpc_->Finish(response_, &status_, tag_);
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Leave RegisterFileUploadHandler::handleNewCallState";
-    << "Leave RegisterFileUploadHandler::handleNewCallState";
 }
 } // namespace caosdb::transaction
--- a/src/caosdb/file_transmission/upload_request_handler.cpp
+++ b/src/caosdb/file_transmission/upload_request_handler.cpp
@@ -78,15 +78,12 @@ using caosdb::StatusCode;
 using caosdb::utility::get_arena;
 using google::protobuf::Arena;
-UploadRequestHandler::UploadRequestHandler(HandlerTag tag,
+UploadRequestHandler::UploadRequestHandler(HandlerTag tag, FileTransmissionService::Stub *stub,
-                                           FileTransmissionService::Stub *stub,
                                           grpc::CompletionQueue *cq,
                                           FileDescriptor file_descriptor)
-  : tag_(tag), stub_(stub), cq_(cq),
+  : tag_(tag), stub_(stub), cq_(cq), request_(Arena::CreateMessage<FileUploadRequest>(get_arena())),
-    request_(Arena::CreateMessage<FileUploadRequest>(get_arena())),
+    response_(Arena::CreateMessage<FileUploadResponse>(get_arena())), state_(CallState::NewCall),
-    response_(Arena::CreateMessage<FileUploadResponse>(get_arena())),
+    file_descriptor_(std::move(file_descriptor)), bytesToSend_(0) {}
-    state_(CallState::NewCall), file_descriptor_(std::move(file_descriptor)),
-    bytesToSend_(0) {}
 bool UploadRequestHandler::OnNext(bool ok) {
  try {
@@ -110,15 +107,13 @@ bool UploadRequestHandler::OnNext(bool ok) {
    return true;
  } catch (std::exception &e) {
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "UploadRequestHandler caught an exception: " << e.what();
-      << "UploadRequestHandler caught an exception: " << e.what();
    transaction_status = TransactionStatus::GENERIC_ERROR(e.what());
    state_ = CallState::CallComplete;
  } catch (...) {
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "Transaction error: unknown exception caught";
-      << "Transaction error: unknown exception caught";
+    transaction_status =
-    transaction_status = TransactionStatus::GENERIC_ERROR(
+      TransactionStatus::GENERIC_ERROR("UploadRequestHandler caught an unknown exception");
-      "UploadRequestHandler caught an unknown exception");
    state_ = CallState::CallComplete;
  }
@@ -188,31 +183,27 @@ void UploadRequestHandler::handleExpectingResponseState() {
 }
 void UploadRequestHandler::handleCallCompleteState() {
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Enter UploadRequestHandler::handleCallCompleteState";
-    << "Enter UploadRequestHandler::handleCallCompleteState";
  switch (status_.error_code()) {
  case grpc::OK: {
    auto bytesSent = fileReader_ != nullptr ? fileReader_->fileSize() : 0;
-    CAOSDB_LOG_INFO(logger_name)
+    CAOSDB_LOG_INFO(logger_name) << "UploadRequestHandler finished successfully ("
-      << "UploadRequestHandler finished successfully ("
+                                 << file_descriptor_.local_path << "): upload complete, "
-      << file_descriptor_.local_path << "): upload complete, " << bytesSent
+                                 << bytesSent << " bytes sent";
-      << " bytes sent";
  } break;
  default: {
    auto code(static_cast<StatusCode>(status_.error_code()));
    std::string description(get_status_description(code) +
                            " Original message: " + status_.error_message());
    transaction_status = TransactionStatus(code, description);
-    CAOSDB_LOG_ERROR(logger_name)
+    CAOSDB_LOG_ERROR(logger_name) << "UploadRequestHandler finished with an error ("
-      << "UploadRequestHandler finished with an error ("
+                                  << file_descriptor_.local_path << "): Upload aborted with code "
-      << file_descriptor_.local_path << "): Upload aborted with code " << code
+                                  << code << " - " << description;
-      << " - " << description;
  } break;
  }
-  CAOSDB_LOG_TRACE(logger_name)
+  CAOSDB_LOG_TRACE(logger_name) << "Leave UploadRequestHandler::handleCallCompleteState";
-    << "Leave UploadRequestHandler::handleCallCompleteState";
 }
 } // namespace caosdb::transaction
No results found