Esempio n. 1
0
// Read label category (all datasets)
char AH5_read_label(hid_t file_id, AH5_label_t *label)
{
    char path[AH5_ABSOLUTE_PATH_LENGTH], rdata = AH5_TRUE;
    AH5_children_t children;
    hsize_t i;

    AH5_init_label(label);

    if (AH5_path_valid(file_id, AH5_C_LABEL))
    {
        children = AH5_read_children_name(file_id, AH5_C_LABEL);
        label->nb_datasets = children.nb_children;
        if (children.nb_children > 0)
        {
			label->datasets = (AH5_lbl_dataset_t *) malloc((size_t) children.nb_children * sizeof(AH5_lbl_dataset_t));
            for (i = 0; i < children.nb_children; i++)
            {
                strcpy(path, AH5_C_LABEL);
                strcat(path, children.childnames[i]);
                if(!AH5_read_lbl_dataset(file_id, path, label->datasets + i))
                    rdata = AH5_FALSE;
                free(children.childnames[i]);
            }
            free(children.childnames);
        }
    }
    else
    {
        AH5_print_err_path(AH5_C_LABEL, AH5_C_LABEL);
        rdata = AH5_FALSE;
    }
    return rdata;
}
Esempio n. 2
0
// Read externalElement category (all datasets)
char AH5_read_external_element (hid_t file_id, AH5_external_element_t *external_element)
{
    char path[AH5_ABSOLUTE_PATH_LENGTH], rdata = AH5_TRUE;
    AH5_children_t children;
    hsize_t i;

    external_element->datasets = NULL;

    if (AH5_path_valid(file_id, AH5_C_EXTERNAL_ELEMENT))
    {
        children = AH5_read_children_name(file_id, AH5_C_EXTERNAL_ELEMENT);
        external_element->nb_datasets = children.nb_children;
        if (children.nb_children > 0)
        {
            external_element->datasets = (AH5_eet_dataset_t *) malloc(children.nb_children * sizeof(AH5_eet_dataset_t));
            for (i = 0; i < children.nb_children; i++)
            {
                strcpy(path, AH5_C_EXTERNAL_ELEMENT);
                strcat(path, children.childnames[i]);
                if (!AH5_read_eet_dataset(file_id, path, external_element->datasets + i))
                    rdata = AH5_FALSE;
                free(children.childnames[i]);
            }
            free(children.childnames);
        }
    }
    else
    {
        AH5_print_err_path(AH5_C_EXTERNAL_ELEMENT, AH5_C_EXTERNAL_ELEMENT);
        rdata = AH5_FALSE;
    }
    return rdata;
}
Esempio n. 3
0
// Read localizationSystem instance
char AH5_read_lsm_instance (hid_t file_id, const char *path, AH5_lsm_instance_t *lsm_instance)
{
  char mandatory[][AH5_ATTR_LENGTH] = {AH5_A_DIMENSION}, rdata = AH5_TRUE;
  char *path2;
  AH5_children_t children;
  hsize_t i;

  lsm_instance->path = strdup(path);
  lsm_instance->transformations = NULL;
  lsm_instance->opt_attrs.instances = NULL;

  if (AH5_path_valid(file_id, path))
  {
    AH5_read_opt_attrs(file_id, path, &(lsm_instance->opt_attrs), mandatory,
                       sizeof(mandatory)/AH5_ATTR_LENGTH);
    AH5_read_int_attr(file_id, path, AH5_A_DIMENSION, &(lsm_instance->dimension));

    children = AH5_read_children_name(file_id, path);
    lsm_instance->nb_transformations = children.nb_children;
    if (children.nb_children > 0)
    {
      lsm_instance->transformations = (AH5_lsm_transf_t *) malloc((size_t) children.nb_children * sizeof(
                                        AH5_lsm_transf_t));
      for (i = 0; i < children.nb_children; i++)
      {
        path2 = malloc((strlen(path) + strlen(children.childnames[i]) + 1) * sizeof(*path2));
        strcpy(path2, path);
        strcat(path2, children.childnames[i]);
        if (!AH5_read_lsm_transformation(file_id, path2, lsm_instance->transformations + i))
          rdata = AH5_FALSE;
        free(children.childnames[i]);
        free(path2);
      }
      free(children.childnames);
    }
  }
  else
  {
    AH5_print_err_path(AH5_C_LOCALIZATION_SYSTEM, path);
    rdata = AH5_FALSE;
  }
  return rdata;
}
Esempio n. 4
0
// Read localizationSystem category
char AH5_read_localization_system (hid_t file_id, AH5_localization_system_t *localization_system)
{
  char *path;
  char rdata = AH5_TRUE;
  AH5_children_t children;
  hsize_t i;

  localization_system->instances = NULL;

  if (AH5_path_valid(file_id, AH5_C_LOCALIZATION_SYSTEM))
  {
    children = AH5_read_children_name(file_id, AH5_C_LOCALIZATION_SYSTEM);
    localization_system->nb_instances = children.nb_children;
    if (children.nb_children > 0)
    {
      localization_system->instances = (AH5_lsm_instance_t *) malloc((size_t) children.nb_children *
                                       sizeof(AH5_lsm_instance_t));
      for (i = 0; i < children.nb_children; i++)
      {
        path = malloc((strlen(AH5_C_LOCALIZATION_SYSTEM) + strlen(children.childnames[i]) + 1) * sizeof(*path));
        strcpy(path, AH5_C_LOCALIZATION_SYSTEM);
        strcat(path, children.childnames[i]);
        if(!AH5_read_lsm_instance(file_id, path, localization_system->instances + i))
          rdata = AH5_FALSE;
        free(children.childnames[i]);
        free(path);
      }
      free(children.childnames);
    }
  }
  else
  {
    AH5_print_err_path(AH5_C_LOCALIZATION_SYSTEM, AH5_C_LOCALIZATION_SYSTEM);
    rdata = AH5_FALSE;
  }
  return rdata;
}
Esempio n. 5
0
// Read simulation category (all instances)
char AH5_read_simulation (hid_t file_id, AH5_simulation_t *simulation)
{
  char *path, rdata = AH5_TRUE;
  AH5_children_t children;
  hsize_t i;

  simulation->instances = NULL;

  if (AH5_path_valid(file_id, AH5_C_SIMULATION))
  {
    children = AH5_read_children_name(file_id, AH5_C_SIMULATION);
    simulation->nb_instances = children.nb_children;
    if (children.nb_children > 0)
    {
      simulation->instances = (AH5_sim_instance_t *) malloc((size_t) children.nb_children * sizeof(
                                AH5_sim_instance_t));
      for (i = 0; i < children.nb_children; i++)
      {
        path = malloc((strlen(AH5_C_SIMULATION) + strlen(children.childnames[i]) + 1)* sizeof(*path));
        strcpy(path, AH5_C_SIMULATION);
        strcat(path, children.childnames[i]);
        if (!AH5_read_sim_instance(file_id, path, simulation->instances + i))
          rdata = AH5_FALSE;
        free(children.childnames[i]);
        free(path);
      }
      free(children.childnames);
    }
  }
  else
  {
    AH5_print_err_path(AH5_C_SIMULATION, AH5_C_SIMULATION);
    rdata = AH5_FALSE;
  }
  return rdata;
}