API: remove UniqueResult, lower-case at, size for ResultSet

src/caosdb/transaction.cpp

@@ -110,7 +110,7 @@ ResultSet::iterator::iterator(const ResultSet *result_set_param, int index)
   : current_index(index), result_set(result_set_param) {}
 
 auto ResultSet::iterator::operator*() const -> const Entity & {
-  return this->result_set->At(current_index);
+  return this->result_set->at(current_index);
 }
 
 auto ResultSet::iterator::operator++() -> ResultSet::iterator & {
@@ -133,17 +133,12 @@ auto ResultSet::begin() const -> ResultSet::iterator {
 }
 
 auto ResultSet::end() const -> ResultSet::iterator {
-  return ResultSet::iterator(this, Size());
+  return ResultSet::iterator(this, size());
 }
 
 MultiResultSet::MultiResultSet(std::vector<std::unique_ptr<Entity>> result_set)
   : entities(std::move(result_set)) {}
 
-[[nodiscard]] auto UniqueResult::GetEntity() const -> const Entity & {
-  const Entity *result = this->entity.get();
-  return *result;
-}
-
 Transaction::Transaction(
   std::shared_ptr<EntityTransactionService::Stub> service_stub)
   : request(google::protobuf::Arena::CreateMessage<MultiTransactionRequest>(
@@ -282,86 +277,61 @@ auto Transaction::ExecuteAsynchronously() noexcept -> StatusCode {
 }
 
 auto Transaction::WaitForIt() const noexcept -> TransactionStatus {
-  if (this->response->responses_size() == 1) {
-    auto *responses = this->response->mutable_responses(0);
-    switch (responses->wrapped_response_case()) {
+  auto *responses = this->response->mutable_responses();
+  std::vector<std::unique_ptr<Entity>> entities;
+  for (auto sub_response : *responses) {
+    std::unique_ptr<Entity> result;
+    switch (sub_response.wrapped_response_case()) {
+
     case WrappedResponseCase::kRetrieveResponse: {
-      auto *retrieve_response = responses->mutable_retrieve_response();
+      auto *retrieve_response = sub_response.mutable_retrieve_response();
+
       switch (retrieve_response->query_response_case()) {
       case QueryResponseCase::kEntity: {
-        auto *entity = retrieve_response->release_entity();
-        if (!entity->errors().empty()) {
-          this->status = TransactionStatus::TRANSACTION_ERROR(
-            "The request returned with errors.");
-        }
-        this->result_set = std::make_unique<UniqueResult>(entity);
+        auto *retrieve_entity_response = retrieve_response->release_entity();
+        result = std::make_unique<Entity>(retrieve_entity_response);
       } break;
       case QueryResponseCase::kSelectResult: {
         // TODO(tf) Select queries
       } break;
       case QueryResponseCase::kCountResult: {
         this->query_count = retrieve_response->count_result();
-        std::vector<std::unique_ptr<Entity>> entities;
-        this->result_set =
-          std::make_unique<MultiResultSet>(std::move(entities));
       } break;
       default:
         // TODO(tf) Error
         break;
       }
-    } break;
-    case WrappedResponseCase::kUpdateResponse: {
-      auto *updatedIdResponse = responses->mutable_update_response();
-      if (!updatedIdResponse->entity_errors().empty()) {
-        this->status = TransactionStatus::TRANSACTION_ERROR(
-          "The request returned with errors.");
-      }
-      this->result_set = std::make_unique<UniqueResult>(updatedIdResponse);
-    } break;
+
+      break;
+    }
+
     case WrappedResponseCase::kInsertResponse: {
-      auto *insertedIdResponse = responses->mutable_insert_response();
-      if (!insertedIdResponse->entity_errors().empty()) {
-        this->status = TransactionStatus::TRANSACTION_ERROR(
-          "The request returned with errors.");
-      }
-      this->result_set = std::make_unique<UniqueResult>(insertedIdResponse);
-    } break;
+      auto *inserted_id_response = sub_response.release_insert_response();
+      result = std::make_unique<Entity>(inserted_id_response);
+      break;
+    }
     case WrappedResponseCase::kDeleteResponse: {
-      auto *deletedIdResponse = responses->mutable_delete_response();
-      if (!deletedIdResponse->entity_errors().empty()) {
-        this->status = TransactionStatus::TRANSACTION_ERROR(
-          "The request returned with errors.");
-      }
-      this->result_set = std::make_unique<UniqueResult>(deletedIdResponse);
-    } break;
+      auto *deleted_id_response = sub_response.release_delete_response();
+      result = std::make_unique<Entity>(deleted_id_response);
+      break;
+    }
+    case WrappedResponseCase::kUpdateResponse: {
+      auto *updated_id_response = sub_response.release_update_response();
+      result = std::make_unique<Entity>(updated_id_response);
+      break;
+    }
     default:
-      // TODO(tf) Error and Update
+      // TODO(tf) Error
       break;
     }
-  } else {
-    auto *responses = this->response->mutable_responses();
-    std::vector<std::unique_ptr<Entity>> entities;
-    for (auto sub_response : *responses) {
-      switch (sub_response.wrapped_response_case()) {
-      case WrappedResponseCase::kRetrieveResponse:
-        entities.push_back(std::make_unique<Entity>(
-          sub_response.mutable_retrieve_response()->release_entity()));
-        break;
-      case WrappedResponseCase::kInsertResponse:
-        entities.push_back(
-          std::make_unique<Entity>(sub_response.release_insert_response()));
-        break;
-      case WrappedResponseCase::kDeleteResponse:
-        entities.push_back(
-          std::make_unique<Entity>(sub_response.release_insert_response()));
-        break;
-      default:
-        // TODO(tf) Updates
-        break;
-      }
+    if (result->HasErrors()) {
+      this->status = TransactionStatus::TRANSACTION_ERROR(
+        "The request terminated with errors.");
     }
-    this->result_set = std::make_unique<MultiResultSet>(std::move(entities));
+    entities.push_back(std::move(result));
   }
+  this->result_set = std::make_unique<MultiResultSet>(std::move(entities));
+  //}
 
   return this->status;
 }