diff options
author | Bastien Montagne <montagne29@wanadoo.fr> | 2019-12-20 16:28:29 +0300 |
---|---|---|
committer | Bastien Montagne <montagne29@wanadoo.fr> | 2019-12-20 16:29:35 +0300 |
commit | 5804f18b1fc56166ca0caa573beec67d697d1132 (patch) | |
tree | f15428de31066ac0bd05948623455d5b5595a8b8 /source/blender/blenkernel/intern/library.c | |
parent | 46607bc09d5cd9fa3570e5ad4b01ea4ea7adaffc (diff) |
Cleanup: in ID name management code: root_name -> base_name.
`root_name` did not really meant much here, `base_name` is much more
accurate.
Diffstat (limited to 'source/blender/blenkernel/intern/library.c')
-rw-r--r-- | source/blender/blenkernel/intern/library.c | 90 |
1 files changed, 45 insertions, 45 deletions
diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c index 8a4814e1a92..00126ab7eac 100644 --- a/source/blender/blenkernel/intern/library.c +++ b/source/blender/blenkernel/intern/library.c @@ -1651,40 +1651,40 @@ void id_sort_by_name(ListBase *lb, ID *id, ID *id_sorting_hint) #define MAX_NUMBERS_IN_USE 1024 /** - * Helper building final ID name from given root_name and number. + * Helper building final ID name from given base_name and number. * * If everything goes well and we do generate a valid final ID anme in given name, we return true. * In case the final name would overflow the allowed ID name length, or given number is bigger than - * maximum allowed value, we truncate further the root_name (and given name, which is assumed to - * have the same 'root_name' part), and return false. + * maximum allowed value, we truncate further the base_name (and given name, which is assumed to + * have the same 'base_name' part), and return false. */ -static bool id_name_final_build(char *name, char *root_name, size_t root_name_len, int number) +static bool id_name_final_build(char *name, char *base_name, size_t base_name_len, int number) { char number_str[11]; /* Dot + nine digits + NULL terminator. */ size_t number_str_len = BLI_snprintf_rlen(number_str, ARRAY_SIZE(number_str), ".%.3d", number); /* If the number would lead to an overflow of the maximum ID name length, we need to truncate - * the root name part and do all the number checks again. */ - if (root_name_len + number_str_len >= MAX_ID_NAME - 2 || number >= MAX_NUMBER) { - if (root_name_len + number_str_len >= MAX_ID_NAME - 2) { - root_name_len = MAX_ID_NAME - 2 - number_str_len - 1; + * the base name part and do all the number checks again. */ + if (base_name_len + number_str_len >= MAX_ID_NAME - 2 || number >= MAX_NUMBER) { + if (base_name_len + number_str_len >= MAX_ID_NAME - 2) { + base_name_len = MAX_ID_NAME - 2 - number_str_len - 1; } else { - root_name_len--; + base_name_len--; } - root_name[root_name_len] = '\0'; + base_name[base_name_len] = '\0'; /* Code above may have generated invalid utf-8 string, due to raw truncation. * Ensure we get a valid one now. */ - root_name_len -= (size_t)BLI_utf8_invalid_strip(root_name, root_name_len); + base_name_len -= (size_t)BLI_utf8_invalid_strip(base_name, base_name_len); /* Also truncate orig name, and start the whole check again. */ - name[root_name_len] = '\0'; + name[base_name_len] = '\0'; return false; } /* We have our final number, we can put it in name and exit the function. */ - BLI_strncpy(name + root_name_len, number_str, number_str_len + 1); + BLI_strncpy(name + base_name_len, number_str, number_str_len + 1); return true; } @@ -1712,9 +1712,9 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ const short id_type = (short)GS(id_test->name); /* Static storage of previous handled ID/name info, used to perform a quicker test and optimize - * creation of huge number of IDs using the same given root name. */ - static char prev_orig_root_name[MAX_ID_NAME - 2] = {0}; - static char prev_final_root_name[MAX_ID_NAME - 2] = {0}; + * creation of huge number of IDs using the same given base name. */ + static char prev_orig_base_name[MAX_ID_NAME - 2] = {0}; + static char prev_final_base_name[MAX_ID_NAME - 2] = {0}; static short prev_id_type = ID_LINK_PLACEHOLDER; /* Should never exist in actual ID list. */ static int prev_number = MIN_NUMBER - 1; @@ -1723,28 +1723,28 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ * available number in some cases, and benefits of this special case handling mostly show up with * high numbers anyway. */ if (id_type == prev_id_type && prev_number >= MAX_NUMBERS_IN_USE && - prev_number < MAX_NUMBER - 1 && name[0] == prev_final_root_name[0]) { + prev_number < MAX_NUMBER - 1 && name[0] == prev_final_base_name[0]) { /* Get the name and number parts ("name.number"). */ - char root_name[MAX_ID_NAME - 2]; + char base_name[MAX_ID_NAME - 2]; int number = MIN_NUMBER; - size_t root_name_len = BLI_split_name_num(root_name, &number, name, '.'); - size_t prev_final_root_name_len = strlen(prev_final_root_name); - size_t prev_orig_root_name_len = strlen(prev_orig_root_name); + size_t base_name_len = BLI_split_name_num(base_name, &number, name, '.'); + size_t prev_final_base_name_len = strlen(prev_final_base_name); + size_t prev_orig_base_name_len = strlen(prev_orig_base_name); - if (root_name_len == prev_orig_root_name_len && - STREQLEN(root_name, prev_orig_root_name, prev_orig_root_name_len)) { - /* Once we have ensured given root_name and original previous one are the same, we can check + if (base_name_len == prev_orig_base_name_len && + STREQLEN(base_name, prev_orig_base_name, prev_orig_base_name_len)) { + /* Once we have ensured given base_name and original previous one are the same, we can check * that previously used number is actually used, and that next one is free. */ - /* Note that from now on, we only used previous final root name, as it might have been + /* Note that from now on, we only used previous final base name, as it might have been * truncated from original one due to number suffix length. */ char final_name[MAX_ID_NAME - 2]; char prev_final_name[MAX_ID_NAME - 2]; - BLI_strncpy(final_name, prev_final_root_name, prev_final_root_name_len + 1); - BLI_strncpy(prev_final_name, prev_final_root_name, prev_final_root_name_len + 1); + BLI_strncpy(final_name, prev_final_base_name, prev_final_base_name_len + 1); + BLI_strncpy(prev_final_name, prev_final_base_name, prev_final_base_name_len + 1); - if (id_name_final_build(final_name, root_name, prev_final_root_name_len, prev_number + 1) && - id_name_final_build(prev_final_name, root_name, prev_final_root_name_len, prev_number)) { + if (id_name_final_build(final_name, base_name, prev_final_base_name_len, prev_number + 1) && + id_name_final_build(prev_final_name, base_name, prev_final_base_name_len, prev_number)) { /* We succeffuly built valid final names of previous and current iterations, now we have to * ensure that previous final name is indeed used in curent ID list, and that current one * is not. */ @@ -1767,8 +1767,8 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ } if (is_valid) { - /* Only the number changed, prev_orig_root_name, prev_root_name and prev_id_type remain - * the same. */ + /* Only the number changed, prev_orig_base_name, prev_final_base_name and prev_id_type + * remain the same. */ prev_number++; strcpy(name, final_name); @@ -1785,13 +1785,13 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ bool is_first_run = true; while (true) { /* Get the name and number parts ("name.number"). */ - char root_name[MAX_ID_NAME - 2]; + char base_name[MAX_ID_NAME - 2]; int number = MIN_NUMBER; - size_t root_name_len = BLI_split_name_num(root_name, &number, name, '.'); + size_t base_name_len = BLI_split_name_num(base_name, &number, name, '.'); - /* Store previous original given root name now, as we might alter it later in code below. */ + /* Store previous original given base name now, as we might alter it later in code below. */ if (is_first_run) { - strcpy(prev_orig_root_name, root_name); + strcpy(prev_orig_base_name, base_name); is_first_run = false; } @@ -1804,17 +1804,17 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ bool is_orig_name_used = false; for (id_test = lb->first; id_test; id_test = id_test->next) { - char root_name_test[MAX_ID_NAME - 2]; + char base_name_test[MAX_ID_NAME - 2]; int number_test; if ((id != id_test) && !ID_IS_LINKED(id_test) && (name[0] == id_test->name[2]) && - (id_test->name[root_name_len + 2] == '.' || id_test->name[root_name_len + 2] == '\0') && - STREQLEN(name, id_test->name + 2, root_name_len) && - (BLI_split_name_num(root_name_test, &number_test, id_test->name + 2, '.') == - root_name_len)) { + (id_test->name[base_name_len + 2] == '.' || id_test->name[base_name_len + 2] == '\0') && + STREQLEN(name, id_test->name + 2, base_name_len) && + (BLI_split_name_num(base_name_test, &number_test, id_test->name + 2, '.') == + base_name_len)) { /* If we did not yet encounter exact same name as the given one, check the remaining parts * of the strings. */ if (!is_orig_name_used) { - is_orig_name_used = STREQ(name + root_name_len, id_test->name + 2 + root_name_len); + is_orig_name_used = STREQ(name + base_name_len, id_test->name + 2 + base_name_len); } /* Mark number of current id_test name as used, if possible. */ if (number_test < MAX_NUMBERS_IN_USE) { @@ -1835,7 +1835,7 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ /* Don't bother updating prev_ static variables here, this case is not supposed to happen * that often, and is not straight-forward here, so just ignore and reset them to default. */ prev_id_type = ID_LINK_PLACEHOLDER; - prev_final_root_name[0] = '\0'; + prev_final_base_name[0] = '\0'; prev_number = MIN_NUMBER - 1; /* Value set previously is meaningless in that case. */ @@ -1866,7 +1866,7 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ /* If id_name_final_build helper returns false, it had to truncate further given name, hence we * have to go over the whole check again. */ - if (!id_name_final_build(name, root_name, root_name_len, number)) { + if (!id_name_final_build(name, base_name, base_name_len, number)) { /* We have to clear our list of small used numbers before we do the whole check again. */ memset(ids_in_use, 0, sizeof(ids_in_use)); @@ -1874,9 +1874,9 @@ static bool check_for_dupid(ListBase *lb, ID *id, char *name, ID **r_id_sorting_ } /* Update prev_ static variables, in case next call is for the same type of IDs and with the - * same initial root name, we can skip a lot of above process. */ + * same initial base name, we can skip a lot of above process. */ prev_id_type = id_type; - strcpy(prev_final_root_name, root_name); + strcpy(prev_final_base_name, base_name); prev_number = number; return is_name_changed; |