ENH: Add datatypes and value classes to Extern C interface

Summary

See https://gitlab.indiscale.com/caosdb/customers/lfpb/management/-/issues/420. Adapts the

Focus

The single get_value functions are now split up into get_<datatype>_value, get_value_list_length, and get_<datatype>_list_value_at functions. Also, importances, roles, and datatypes are now cast from string to enums and back for getting and setting. In the case of datatypes, two additional Booleans for is_reference and is_list.

In addition, the way memory si allocated in case of char pointers has been fixed.

Test Environment

Unit tests and integration tests should be sufficient. Integration testing with deploy in f-grpc and server in f-grpc-f-consolidation, as usual.

Check List for the Author

Please, prepare your MR for a review. Be sure to write a summary and a focus and create gitlab comments for the reviewer. They should guide the reviewer through the changes, explain your changes and also point out open questions. For further good practices have a look at our review guidelines

• All automated tests pass
• Reference related Issues
• Up-to-date CHANGELOG.md
• Annotations in code (Gitlab comments)
  • Intent of new code
  • Problems with old code
  • Why this implementation?

Check List for the Reviewer

• I understand the intent of this MR
• All automated tests pass
• Up-to-date CHANGELOG.md
• The test environment setup works and the intended behavior is reproducible in the test environment
• In-code documentation and comments are up-to-date.
• Check: Are there specifications? Are they satisfied?

For further good practices have a look at our review guidelines.

src/ccaosdb.cpp

@@ -552,9 +552,37 @@ ERROR_RETURN_CODE(GENERIC_ERROR,
                   })
 CAOSDB_ENTITY_GET(name, GetName())
 CAOSDB_ENTITY_GET(description, GetDescription())
-// TODO(fspreck)
-// CAOSDB_ENTITY_GET(datatype, strcpy(out,
-// wrapped_entity->GetDatatype().c_str());)
+ERROR_RETURN_CODE(GENERIC_ERROR,
+                  int caosdb_entity_entity_get_datatype(caosdb_entity_entity *entity, char **name,
+                                                        bool *is_ref, bool *is_list),
+                  {
+                    auto *wrapped_entity = WRAPPED_ENTITY_CAST(entity);
+                    const auto &datatype = wrapped_entity->GetDataType();
+                    *is_list = datatype.IsList();
+                    std::string datatype_name;
+                    if (*is_list) {
+                      const auto &list_datatype = datatype.AsList();
+                      *is_ref = list_datatype.IsListOfReference();
+                      if (*is_ref) {
+                        datatype_name = list_datatype.GetReferenceDataType().GetName();
+                      } else {
+                        datatype_name =
+                          ENUM_NAME_FROM_VALUE(list_datatype.GetAtomicDataType(), AtomicDataType);
+                      }
+                    } else {
+                      *is_ref = datatype.IsReference();
+                      if (*is_ref) {
+                        datatype_name = datatype.AsReference().GetName();
+                      } else {
+                        datatype_name = ENUM_NAME_FROM_VALUE(datatype.AsAtomic(), AtomicDataType);
+                      }
+                    }
+                    char *tmp = (char *)malloc(sizeof(char) * datatype_name.length() + 1);
+                    strcpy(tmp, datatype_name.c_str());
+                    delete[] * name;
+                    *name = tmp;
+                    return 0;
+                  })
 ERROR_RETURN_CODE(GENERIC_ERROR,
                   int caosdb_entity_entity_get_int_value(caosdb_entity_entity *entity, long *out), {
                     auto *wrapped_entity = WRAPPED_ENTITY_CAST(entity);
@@ -773,9 +801,39 @@ ERROR_RETURN_CODE(GENERIC_ERROR,
                     *out = tmp;
                     return 0;
                   })
-// TODO(fspreck)
-// CAOSDB_PROPERTY_GET(datatype,
-//                    strcpy(out, wrapped_property->GetDatatype().c_str());)
+
+ERROR_RETURN_CODE(GENERIC_ERROR,
+                  int caosdb_entity_property_get_datatype(caosdb_entity_property *property,
+                                                          char **name, bool *is_ref, bool *is_list),
+                  {
+                    auto *wrapped_property = WRAPPED_PROPERTY_CAST(property);
+                    const auto &datatype = wrapped_property->GetDataType();
+                    *is_list = datatype.IsList();
+                    std::string datatype_name;
+                    if (*is_list) {
+                      const auto &list_datatype = datatype.AsList();
+                      *is_ref = list_datatype.IsListOfReference();
+                      if (*is_ref) {
+                        datatype_name = list_datatype.GetReferenceDataType().GetName();
+                      } else {
+                        datatype_name =
+                          ENUM_NAME_FROM_VALUE(list_datatype.GetAtomicDataType(), AtomicDataType);
+                      }
+                    } else {
+                      *is_ref = datatype.IsReference();
+                      if (*is_ref) {
+                        datatype_name = datatype.AsReference().GetName();
+                      } else {
+                        datatype_name = ENUM_NAME_FROM_VALUE(datatype.AsAtomic(), AtomicDataType);
+                      }
+                    }
+                    char *tmp = (char *)malloc(sizeof(char) * datatype_name.length() + 1);
+                    strcpy(tmp, datatype_name.c_str());
+                    delete[] * name;
+                    *name = tmp;
+                    return 0;
+                  })
+
 CAOSDB_PROPERTY_GET(unit, GetUnit())
 
 ERROR_RETURN_CODE(GENERIC_ERROR,
@@ -893,9 +951,29 @@ ERROR_RETURN_CODE(GENERIC_ERROR,
 CAOSDB_ENTITY_SET(name, name, wrapped_entity->SetName(std::string(name));)
 CAOSDB_ENTITY_SET(description, description,
                   wrapped_entity->SetDescription(std::string(description));)
-// TODO(fspreck)
-// CAOSDB_ENTITY_SET(datatype, datatype,
-//                  wrapped_entity->SetDataType(std::string(datatype));)
+ERROR_RETURN_CODE(GENERIC_ERROR,
+                  int caosdb_entity_entity_set_datatype(caosdb_entity_entity *entity,
+                                                        const char *datatype, const bool is_ref,
+                                                        const bool is_list),
+                  {
+                    auto *wrapped_entity = WRAPPED_ENTITY_CAST(entity);
+                    if (is_ref) {
+                      // Refernce datatype with name of reference
+                      wrapped_entity->SetDataType(std::string(datatype), is_list);
+                      return 0;
+                    } else {
+                      // Atomic datatype so get from enum
+                      try {
+                        auto enum_value =
+                          ENUM_VALUE_FROM_NAME(std::string(datatype), AtomicDataType);
+                        wrapped_entity->SetDataType(enum_value, is_list);
+                        return 0;
+                      } catch (const std::out_of_range &exc) {
+                        caosdb::logging::caosdb_log_fatal(CCAOSDB_LOGGER_NAME, exc.what());
+                        return caosdb::StatusCode::ENUM_MAPPING_ERROR;
+                      }
+                    }
+                  })
 CAOSDB_ENTITY_SET(unit, unit, wrapped_entity->SetUnit(std::string(unit));)
 
 ERROR_RETURN_CODE(GENERIC_ERROR,
@@ -1042,9 +1120,31 @@ CAOSDB_PARENT_SET(name, name, wrapped_parent->SetName(std::string(name));)
 
 CAOSDB_PROPERTY_SET(name, name, wrapped_property->SetName(std::string(name));)
 CAOSDB_PROPERTY_SET(id, id, wrapped_property->SetId(std::string(id));)
-// TODO(fspreck)
-// CAOSDB_PROPERTY_SET(datatype, datatype,
-//                    wrapped_property->SetDataType(std::string(datatype));)
+
+ERROR_RETURN_CODE(GENERIC_ERROR,
+                  int caosdb_entity_property_set_datatype(caosdb_entity_property *property,
+                                                          const char *datatype, const bool is_ref,
+                                                          const bool is_list),
+                  {
+                    auto *wrapped_property = WRAPPED_PROPERTY_CAST(property);
+                    if (is_ref) {
+                      // Refernce datatype with name of reference
+                      wrapped_property->SetDataType(std::string(datatype), is_list);
+                      return 0;
+                    } else {
+                      // Atomic datatype so get from enum
+                      try {
+                        auto enum_value =
+                          ENUM_VALUE_FROM_NAME(std::string(datatype), AtomicDataType);
+                        wrapped_property->SetDataType(enum_value, is_list);
+                        return 0;
+                      } catch (const std::out_of_range &exc) {
+                        caosdb::logging::caosdb_log_fatal(CCAOSDB_LOGGER_NAME, exc.what());
+                        return caosdb::StatusCode::ENUM_MAPPING_ERROR;
+                      }
+                    }
+                  })
+
 ERROR_RETURN_CODE(GENERIC_ERROR,
                   int caosdb_entity_property_set_importance(caosdb_entity_property *property,
                                                             const char *importance),