Rename zck_compress to zck_write and zck_decompress to zck_read and

reorder some functions in comp.c

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

diff --git a/include/zck.h b/include/zck.h
index 59d833d08d7350b992ce7b07813772f1341eba3f..73f06ded40b73573d62fe71ecbad4fad8d4d9687 100644 (file)
--- a/include/zck.h
+++ b/include/zck.h
@@ -117,13 +117,13 @@ int zck_comp_init(zckCtx *zck);
  * type and parameters */
 int zck_comp_close(zckCtx *zck);
 /* Compress data src of size src_size, and write to chunk */
-int zck_compress(zckCtx *zck, const char *src, const size_t src_size);
+int zck_write(zckCtx *zck, const char *src, const size_t src_size);
 /* Finish compressing chunk */
 int zck_end_chunk(zckCtx *zck);
 /* Decompress data src of size src_size, and write to dst, while setting
  * dst_size */
-int zck_decompress(zckCtx *zck, const char *src, const size_t src_size,
-                   char **dst, size_t dst_size);
+int zck_read(zckCtx *zck, const char *src, const size_t src_size, char **dst,
+             size_t dst_size);
 
 /*******************************************************************
  * Creating a zchunk file

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index 891b3b17c3b0520853d7fdb029da0e9e9d78b59a..c1716e20ece935587da4df3eb8756df327bf7ba2 100644 (file)
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -101,7 +101,78 @@ int zck_comp_init(zckCtx *zck) {
     return True;
 }
 
-int zck_compress(zckCtx *zck, const char *src, const size_t src_size) {
+int zck_comp_close(zckCtx *zck) {
+    VALIDATE(zck);
+
+    zck->comp.started = 0;
+    if(zck->comp.close == NULL)
+        return True;
+    return zck->comp.close(&(zck->comp));
+}
+
+int zck_set_compression_type(zckCtx *zck, int type) {
+    VALIDATE(zck);
+
+    zckComp *comp = &(zck->comp);
+
+    /* Cannot change compression type after compression has started */
+    if(comp->started) {
+        zck_log(ZCK_LOG_ERROR,
+                "Unable to set compression type after initialization\n");
+        return False;
+    }
+
+    /* Set all values to 0 before setting compression type */
+    memset(comp, 0, sizeof(zckComp));
+    if(type == ZCK_COMP_NONE) {
+        return zck_nocomp_setup(comp);
+#ifdef ZCHUNK_ZSTD
+    } else if(type == ZCK_COMP_ZSTD) {
+        return zck_zstd_setup(comp);
+#endif
+    } else {
+        zck_log(ZCK_LOG_ERROR, "Unsupported compression type: %s\n",
+                zck_comp_name_from_type(type));
+        return False;
+    }
+    zck_log(ZCK_LOG_DEBUG, "Setting compression to %s\n",
+            zck_comp_name_from_type(type));
+    return True;
+}
+
+int zck_set_comp_parameter(zckCtx *zck, int option, void *value) {
+    VALIDATE(zck);
+
+    /* Cannot change compression parameters after compression has started */
+    if(zck && zck->comp.started) {
+        zck_log(ZCK_LOG_ERROR,
+                "Unable to set compression parameters after initialization\n");
+        return False;
+    }
+    if(option == ZCK_COMMON_DICT) {
+        zck->comp.dict = value;
+    }else if(option == ZCK_COMMON_DICT_SIZE) {
+        zck->comp.dict_size = *(size_t*)value;
+    }else {
+        if(zck && zck->comp.set_parameter)
+            return zck->comp.set_parameter(&(zck->comp), option, value);
+
+        zck_log(ZCK_LOG_ERROR, "Unsupported compression parameter: %i\n",
+                option);
+        return False;
+    }
+    return True;
+}
+
+const char *zck_comp_name_from_type(int comp_type) {
+    if(comp_type > 1) {
+        snprintf(unknown+8, 21, "%i)", comp_type);
+        return unknown;
+    }
+    return COMP_NAME[comp_type];
+}
+
+int zck_write(zckCtx *zck, const char *src, const size_t src_size) {
     VALIDATE(zck);
 
     if(!zck->comp.started && !zck_comp_init(zck))
@@ -156,8 +227,8 @@ int zck_end_chunk(zckCtx *zck) {
     return True;
 }
 
-int zck_decompress(zckCtx *zck, const char *src, const size_t src_size,
-                   char **dst, size_t dst_size) {
+int zck_read(zckCtx *zck, const char *src, const size_t src_size, char **dst,
+             size_t dst_size) {
     VALIDATE(zck);
 
     zckComp *comp = &(zck->comp);
@@ -176,74 +247,3 @@ int zck_decompress(zckCtx *zck, const char *src, const size_t src_size,
 
     return True;
 }
-
-int zck_comp_close(zckCtx *zck) {
-    VALIDATE(zck);
-
-    zck->comp.started = 0;
-    if(zck->comp.close == NULL)
-        return True;
-    return zck->comp.close(&(zck->comp));
-}
-
-int zck_set_compression_type(zckCtx *zck, int type) {
-    VALIDATE(zck);
-
-    zckComp *comp = &(zck->comp);
-
-    /* Cannot change compression type after compression has started */
-    if(comp->started) {
-        zck_log(ZCK_LOG_ERROR,
-                "Unable to set compression type after initialization\n");
-        return False;
-    }
-
-    /* Set all values to 0 before setting compression type */
-    memset(comp, 0, sizeof(zckComp));
-    if(type == ZCK_COMP_NONE) {
-        return zck_nocomp_setup(comp);
-#ifdef ZCHUNK_ZSTD
-    } else if(type == ZCK_COMP_ZSTD) {
-        return zck_zstd_setup(comp);
-#endif
-    } else {
-        zck_log(ZCK_LOG_ERROR, "Unsupported compression type: %s\n",
-                zck_comp_name_from_type(type));
-        return False;
-    }
-    zck_log(ZCK_LOG_DEBUG, "Setting compression to %s\n",
-            zck_comp_name_from_type(type));
-    return True;
-}
-
-int zck_set_comp_parameter(zckCtx *zck, int option, void *value) {
-    VALIDATE(zck);
-
-    /* Cannot change compression parameters after compression has started */
-    if(zck && zck->comp.started) {
-        zck_log(ZCK_LOG_ERROR,
-                "Unable to set compression parameters after initialization\n");
-        return False;
-    }
-    if(option == ZCK_COMMON_DICT) {
-        zck->comp.dict = value;
-    }else if(option == ZCK_COMMON_DICT_SIZE) {
-        zck->comp.dict_size = *(size_t*)value;
-    }else {
-        if(zck && zck->comp.set_parameter)
-            return zck->comp.set_parameter(&(zck->comp), option, value);
-
-        zck_log(ZCK_LOG_ERROR, "Unsupported compression parameter: %i\n",
-                option);
-        return False;
-    }
-    return True;
-}
-
-const char *zck_comp_name_from_type(int comp_type) {
-    if(comp_type > 1) {
-        snprintf(unknown+8, 21, "%i)", comp_type);
-        return unknown;
-    }
-    return COMP_NAME[comp_type];
-}

diff --git a/src/lib/zck.c b/src/lib/zck.c
index a5d0e52aaac51550fb06e771d1a1051f1057411f..6b47440a2e6fe7872a22e88547ca84bf9c234d6f 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -386,7 +386,7 @@ int zck_decompress_to_file(zckCtx *zck, int src_fd, int dst_fd) {
         }
 
         char *data = NULL;
-        if(!zck_decompress(zck, cdata, csize, &data, size)) {
+        if(!zck_read(zck, cdata, csize, &data, size)) {
             free(cdata);
             zck_log(ZCK_LOG_ERROR, "Unable to decompress chunk %i\n", count);
             return False;

diff --git a/src/zck.c b/src/zck.c
index 23d84ce627968078d1ec19749ae9cabce430233a..a35da14cdc8f706bff13b58968316068ab8af99f 100644 (file)
--- a/src/zck.c
+++ b/src/zck.c
@@ -162,7 +162,7 @@ int main (int argc, char *argv[]) {
                     }
                     prev_srpm = next_srpm;
                     printf("Compressing %li bytes\n", next-found);
-                    if(!zck_compress(zck, found, next-found))
+                    if(!zck_write(zck, found, next-found))
                         exit(1);
                     if(!zck_end_chunk(zck))
                         exit(1);
@@ -172,7 +172,7 @@ int main (int argc, char *argv[]) {
                         search = data + in_size;
                 } else {
                     printf("Completing %li bytes\n", data+in_size-found);
-                    if(!zck_compress(zck, found, data+in_size-found))
+                    if(!zck_write(zck, found, data+in_size-found))
                         exit(1);
                     if(!zck_end_chunk(zck))
                         exit(1);
@@ -206,7 +206,7 @@ int main (int argc, char *argv[]) {
                     cur_loc = data + in_size;
                 }
                 printf("Completing %li bytes\n", cur_loc-start);
-                if(!zck_compress(zck, start, cur_loc-start))
+                if(!zck_write(zck, start, cur_loc-start))
                     exit(1);
                 if(!zck_end_chunk(zck))
                     exit(1);