Rename zckRange to zckRangeItem and zckRangeInfo to zckRange

Signed-off-by: Jonathan Dieter <jdieter@gmail.com>

diff --git a/include/zck.h b/include/zck.h
index f1ecf6f4784ed1c5092a827cc87a355227059959..0a2ecbf4c218eb3cae28678ad201f818138879ca 100644 (file)
--- a/include/zck.h
+++ b/include/zck.h
@@ -41,20 +41,20 @@ typedef struct zckIndex {
     zckIndexItem *first;
 } zckIndex;
 
-typedef struct zckRange {
+typedef struct zckRangeItem {
     size_t start;
     size_t end;
-    struct zckRange *next;
-    struct zckRange *prev;
-} zckRange;
+    struct zckRangeItem *next;
+    struct zckRangeItem *prev;
+} zckRangeItem;
 
-typedef struct zckRangeInfo {
+typedef struct zckRange {
     unsigned int count;
     unsigned int segments;
     unsigned int max_ranges;
-    zckRange *first;
+    zckRangeItem *first;
     zckIndex index;
-} zckRangeInfo;
+} zckRange;
 
 typedef struct zckDLPriv zckDLPriv;
 typedef struct zckCtx zckCtx;
@@ -67,7 +67,7 @@ typedef struct zckDL {
     size_t dl_chunk_data;
     int dst_fd;
     char *boundary;
-    zckRangeInfo info;
+    zckRange info;
     zckDLPriv *priv;
     struct zckCtx *zck;
     zckIndexItem *tgt_check;
@@ -150,16 +150,16 @@ int zck_get_tmp_fd();
 
 
 /* Get any matching chunks from src and put them in the right place in tgt */
-int zck_dl_copy_src_chunks(zckRangeInfo *info, zckCtx *src, zckCtx *tgt);
+int zck_dl_copy_src_chunks(zckRange *info, zckCtx *src, zckCtx *tgt);
 /* Update info with the maximum number of ranges in a single request */
-int zck_range_calc_segments(zckRangeInfo *info, unsigned int max_ranges);
+int zck_range_calc_segments(zckRange *info, unsigned int max_ranges);
 /* Get index of chunks not available in src, and put them in info */
-int zck_range_get_need_dl(zckRangeInfo *info, zckCtx *zck_src, zckCtx *zck_tgt);
+int zck_range_get_need_dl(zckRange *info, zckCtx *zck_src, zckCtx *zck_tgt);
 /* Get array of range request strings.  ra must be allocated to size
  * info->segments, and the strings must be freed by the caller after use */
-int zck_range_get_array(zckRangeInfo *info, char **ra);
-/* Free any resources in zckRangeInfo */
-void zck_range_close(zckRangeInfo *info);
+int zck_range_get_array(zckRange *info, char **ra);
+/* Free any resources in zckRange */
+void zck_range_close(zckRange *info);
 
 
 /* Initialize curl stuff, should be run at beginning of any program using any

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 83bc9040c04ac3ba6217cf815a693dd4bff0c202..37907f4fc4a3f9a09aeb4d1708f7695a532ccc2b 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -179,8 +179,8 @@ int zck_dl_write_range(zckDL *dl, const char *at, size_t length) {
 }
 
 char *zck_dl_get_range_char(unsigned int start, unsigned int end) {
-    zckRange r = {0};
-    zckRange *range = &r;
+    zckRangeItem r = {0};
+    zckRangeItem *range = &r;
 
     r.start = start;
     r.end = end;
@@ -212,7 +212,7 @@ static size_t write_data(void *ptr, size_t l, size_t c, void *dl_v) {
     return wb;
 }
 
-int zck_dl_write_and_verify(zckRangeInfo *info, zckCtx *src, zckCtx *tgt,
+int zck_dl_write_and_verify(zckRange *info, zckCtx *src, zckCtx *tgt,
                             zckIndexItem *src_idx, zckIndexItem *tgt_idx) {
     static char buf[BUF_SIZE] = {0};
 
@@ -258,7 +258,7 @@ int zck_dl_write_and_verify(zckRangeInfo *info, zckCtx *src, zckCtx *tgt,
     return True;
 }
 
-int zck_dl_copy_src_chunks(zckRangeInfo *info, zckCtx *src, zckCtx *tgt) {
+int zck_dl_copy_src_chunks(zckRange *info, zckCtx *src, zckCtx *tgt) {
     zckIndex *tgt_info = zck_get_index(tgt);
     zckIndex *src_info = zck_get_index(src);
     zckIndexItem *tgt_idx = tgt_info->first;

diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index 24fb44dad06575af755960f3c8060fc57b894370..3fc2aaf1aa8cb507555cd99559c993f29e018042 100644 (file)
--- a/src/lib/dl/range.c
+++ b/src/lib/dl/range.c
@@ -34,7 +34,7 @@
 
 #include "zck_private.h"
 
-void zck_range_remove(zckRange *range) {
+void zck_range_remove(zckRangeItem *range) {
     if(range->prev)
         range->prev->next = range->next;
     if(range->next)
@@ -42,24 +42,24 @@ void zck_range_remove(zckRange *range) {
     free(range);
 }
 
-void zck_range_close(zckRangeInfo *info) {
-    zckRange *next = info->first;
+void zck_range_close(zckRange *info) {
+    zckRangeItem *next = info->first;
     while(next) {
-        zckRange *tmp = next;
+        zckRangeItem *tmp = next;
         next = next->next;
         free(tmp);
     }
     zck_index_clean(&(info->index));
-    memset(info, 0, sizeof(zckRangeInfo));
+    memset(info, 0, sizeof(zckRange));
 }
 
-zckRange *zck_range_insert_new(zckRange *prev, zckRange *next, uint64_t start,
-                               uint64_t end, zckRangeInfo *info,
+zckRangeItem *zck_range_insert_new(zckRangeItem *prev, zckRangeItem *next, uint64_t start,
+                               uint64_t end, zckRange *info,
                                zckIndexItem *idx, int add_index) {
-    zckRange *new = zmalloc(sizeof(zckRange));
+    zckRangeItem *new = zmalloc(sizeof(zckRangeItem));
     if(!new) {
         zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
-                sizeof(zckRange));
+                sizeof(zckRangeItem));
         return NULL;
     }
     new->start = start;
@@ -81,12 +81,12 @@ zckRange *zck_range_insert_new(zckRange *prev, zckRange *next, uint64_t start,
     return new;
 }
 
-void zck_range_merge_combined(zckRangeInfo *info) {
+void zck_range_merge_combined(zckRange *info) {
     if(!info) {
-        zck_log(ZCK_LOG_ERROR, "zckRangeInfo not allocated\n");
+        zck_log(ZCK_LOG_ERROR, "zckRange not allocated\n");
         return;
     }
-    for(zckRange *ptr=info->first; ptr;) {
+    for(zckRangeItem *ptr=info->first; ptr;) {
         if(ptr->next && ptr->end >= ptr->next->start-1) {
             if(ptr->end < ptr->next->end)
                 ptr->end = ptr->next->end;
@@ -98,9 +98,9 @@ void zck_range_merge_combined(zckRangeInfo *info) {
     }
 }
 
-int zck_range_add(zckRangeInfo *info, zckIndexItem *idx, zckCtx *zck) {
+int zck_range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck) {
     if(info == NULL || idx == NULL) {
-        zck_log(ZCK_LOG_ERROR, "zckRangeInfo or zckIndexItem not allocated\n");
+        zck_log(ZCK_LOG_ERROR, "zckRange or zckIndexItem not allocated\n");
         return False;
     }
     size_t header_len = 0;
@@ -112,8 +112,8 @@ int zck_range_add(zckRangeInfo *info, zckIndexItem *idx, zckCtx *zck) {
 
     size_t start = idx->start + header_len;
     size_t end = idx->start + header_len + idx->length - 1;
-    zckRange *prev = info->first;
-    for(zckRange *ptr=info->first; ptr;) {
+    zckRangeItem *prev = info->first;
+    for(zckRangeItem *ptr=info->first; ptr;) {
         prev = ptr;
         if(start > ptr->start) {
             ptr = ptr->next;
@@ -137,7 +137,7 @@ int zck_range_add(zckRangeInfo *info, zckIndexItem *idx, zckCtx *zck) {
         }
     }
     /* We've only reached here if we should be last item */
-    zckRange *new = zck_range_insert_new(prev, NULL, start, end, info, idx, add_index);
+    zckRangeItem *new = zck_range_insert_new(prev, NULL, start, end, info, idx, add_index);
     if(new == NULL)
         return False;
     if(info->first == NULL)
@@ -147,7 +147,7 @@ int zck_range_add(zckRangeInfo *info, zckIndexItem *idx, zckCtx *zck) {
     return True;
 }
 
-int zck_range_calc_segments(zckRangeInfo *info, unsigned int max_ranges) {
+int zck_range_calc_segments(zckRange *info, unsigned int max_ranges) {
     if(max_ranges == 0)
         return False;
     info->segments = (info->count + max_ranges - 1) / max_ranges;
@@ -155,7 +155,7 @@ int zck_range_calc_segments(zckRangeInfo *info, unsigned int max_ranges) {
     return True;
 }
 
-int zck_range_get_need_dl(zckRangeInfo *info, zckCtx *zck_src, zckCtx *zck_tgt) {
+int zck_range_get_need_dl(zckRange *info, zckCtx *zck_src, zckCtx *zck_tgt) {
     zckIndex *tgt_info = zck_get_index(zck_tgt);
     zckIndex *src_info = zck_get_index(zck_src);
     zckIndexItem *tgt_idx = tgt_info->first;
@@ -180,7 +180,7 @@ int zck_range_get_need_dl(zckRangeInfo *info, zckCtx *zck_src, zckCtx *zck_tgt)
     return True;
 }
 
-char *zck_range_get_char(zckRange **range, int max_ranges) {
+char *zck_range_get_char(zckRangeItem **range, int max_ranges) {
     int buf_size=32768;
     char *output=malloc(buf_size);
     if(!output) {
@@ -232,12 +232,12 @@ char *zck_range_get_char(zckRange **range, int max_ranges) {
     return output;
 }
 
-int zck_range_get_array(zckRangeInfo *info, char **ra) {
+int zck_range_get_array(zckRange *info, char **ra) {
     if(!info) {
-        zck_log(ZCK_LOG_ERROR, "zckRangeInfo not allocated\n");
+        zck_log(ZCK_LOG_ERROR, "zckRange not allocated\n");
         return False;
     }
-    zckRange *tmp = info->first;
+    zckRangeItem *tmp = info->first;
     for(int i=0; i<info->segments; i++) {
         ra[i] = zck_range_get_char(&tmp, info->max_ranges);
         if(ra[i] == NULL)
@@ -246,6 +246,6 @@ int zck_range_get_array(zckRangeInfo *info, char **ra) {
     return True;
 }
 
-int zck_range_get_max(zckRangeInfo *info, char *url) {
+int zck_range_get_max(zckRange *info, char *url) {
     return True;
 }

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index 2a92b7d342242ac539f65bee273b795b89bb514a..c6a2f57d4fc9ccc70f72c32d10c647967b3be446 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -141,8 +141,8 @@ int zck_read_header(zckCtx *zck, int src_fd);
 int zck_write_header(zckCtx *zck);
 
 /* dl/range.c */
-char *zck_range_get_char(zckRange **range, int max_ranges);
-int zck_range_add(zckRangeInfo *info, zckIndexItem *idx, zckCtx *zck);
+char *zck_range_get_char(zckRangeItem **range, int max_ranges);
+int zck_range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck);
 
 /* dl/multipart.c */
 size_t zck_multipart_extract(zckDL *dl, char *b, size_t l);