header doc + rename slice with composition

src/Makefile.am

@@ -2,6 +2,6 @@ AM_CFLAGS = -Wall -Werror -pedantic
 
 lib_LTLIBRARIES = libexcit.la
 
-libexcit_la_SOURCES = excit.c slice.c prod.c cons.c repeat.c hilbert2d.c range.c tleaf.c
+libexcit_la_SOURCES = excit.c composition.c prod.c cons.c repeat.c hilbert2d.c range.c tleaf.c
 
 include_HEADERS = excit.h

src/slice.c → src/composition.c

 #include "dev/excit.h"
-#include "slice.h"
+#include "composition.h"
 
-static int slice_it_alloc(excit_t data)
+static int composition_it_alloc(excit_t data)
 {
-	struct slice_it_s *it = (struct slice_it_s *)data->data;
+	struct composition_it_s *it = (struct composition_it_s *)data->data;
 
 	it->src = NULL;
 	it->indexer = NULL;
 	return EXCIT_SUCCESS;
 }
 
-static void slice_it_free(excit_t data)
+static void composition_it_free(excit_t data)
 {
-	struct slice_it_s *it = (struct slice_it_s *)data->data;
+	struct composition_it_s *it = (struct composition_it_s *)data->data;
 
 	excit_free(it->src);
 	excit_free(it->indexer);
 }
 
-static int slice_it_copy(excit_t dst, const excit_t src)
+static int composition_it_copy(excit_t dst, const excit_t src)
 {
-	const struct slice_it_s *it = (const struct slice_it_s *)src->data;
-	struct slice_it_s *result = (struct slice_it_s *)dst->data;
+	const struct composition_it_s *it = (const struct composition_it_s *)src->data;
+	struct composition_it_s *result = (struct composition_it_s *)dst->data;
 
 	result->src = excit_dup(it->src);
 	if (!result->src)
@@ -34,9 +34,9 @@ static int slice_it_copy(excit_t dst, const excit_t src)
 	return EXCIT_SUCCESS;
 }
 
-static int slice_it_next(excit_t data, ssize_t *indexes)
+static int composition_it_next(excit_t data, ssize_t *indexes)
 {
-	struct slice_it_s *it = (struct slice_it_s *)data->data;
+	struct composition_it_s *it = (struct composition_it_s *)data->data;
 	ssize_t n;
 	int err = excit_next(it->indexer, &n);
 
@@ -45,9 +45,9 @@ static int slice_it_next(excit_t data, ssize_t *indexes)
 	return excit_nth(it->src, n, indexes);
 }
 
-static int slice_it_peek(const excit_t data, ssize_t *indexes)
+static int composition_it_peek(const excit_t data, ssize_t *indexes)
 {
-	const struct slice_it_s *it = (const struct slice_it_s *)data->data;
+	const struct composition_it_s *it = (const struct composition_it_s *)data->data;
 	ssize_t n;
 	int err = excit_peek(it->indexer, &n);
 
@@ -56,23 +56,23 @@ static int slice_it_peek(const excit_t data, ssize_t *indexes)
 	return excit_nth(it->src, n, indexes);
 }
 
-static int slice_it_size(const excit_t data, ssize_t *size)
+static int composition_it_size(const excit_t data, ssize_t *size)
 {
-	const struct slice_it_s *it = (const struct slice_it_s *)data->data;
+	const struct composition_it_s *it = (const struct composition_it_s *)data->data;
 
 	return excit_size(it->indexer, size);
 }
 
-static int slice_it_rewind(excit_t data)
+static int composition_it_rewind(excit_t data)
 {
-	struct slice_it_s *it = (struct slice_it_s *)data->data;
+	struct composition_it_s *it = (struct composition_it_s *)data->data;
 
 	return excit_rewind(it->indexer);
 }
 
-static int slice_it_nth(const excit_t data, ssize_t n, ssize_t *indexes)
+static int composition_it_nth(const excit_t data, ssize_t n, ssize_t *indexes)
 {
-	const struct slice_it_s *it = (const struct slice_it_s *)data->data;
+	const struct composition_it_s *it = (const struct composition_it_s *)data->data;
 	ssize_t p;
 	int err = excit_nth(it->indexer, n, &p);
 
@@ -81,10 +81,10 @@ static int slice_it_nth(const excit_t data, ssize_t n, ssize_t *indexes)
 	return excit_nth(it->src, p, indexes);
 }
 
-static int slice_it_rank(const excit_t data, const ssize_t *indexes,
+static int composition_it_rank(const excit_t data, const ssize_t *indexes,
 			 ssize_t *n)
 {
-	const struct slice_it_s *it = (const struct slice_it_s *)data->data;
+	const struct composition_it_s *it = (const struct composition_it_s *)data->data;
 	ssize_t inner_n;
 	int err = excit_rank(it->src, indexes, &inner_n);
 
@@ -93,16 +93,16 @@ static int slice_it_rank(const excit_t data, const ssize_t *indexes,
 	return excit_rank(it->indexer, &inner_n, n);
 }
 
-static int slice_it_pos(const excit_t data, ssize_t *n)
+static int composition_it_pos(const excit_t data, ssize_t *n)
 {
-	const struct slice_it_s *it = (const struct slice_it_s *)data->data;
+	const struct composition_it_s *it = (const struct composition_it_s *)data->data;
 
 	return excit_pos(it->indexer, n);
 }
 
-static int slice_it_split(const excit_t data, ssize_t n, excit_t *results)
+static int composition_it_split(const excit_t data, ssize_t n, excit_t *results)
 {
-	const struct slice_it_s *it = (const struct slice_it_s *)data->data;
+	const struct composition_it_s *it = (const struct composition_it_s *)data->data;
 	int err = excit_split(it->indexer, n, results);
 
 	if (err)
@@ -114,7 +114,7 @@ static int slice_it_split(const excit_t data, ssize_t n, excit_t *results)
 		excit_t tmp2;
 
 		tmp = results[i];
-		results[i] = excit_alloc(EXCIT_SLICE);
+		results[i] = excit_alloc(EXCIT_COMPOSITION);
 		if (!results[i]) {
 			excit_free(tmp);
 			err = -EXCIT_ENOMEM;
@@ -126,7 +126,7 @@ static int slice_it_split(const excit_t data, ssize_t n, excit_t *results)
 			err = -EXCIT_ENOMEM;
 			goto error;
 		}
-		err = excit_slice_init(results[i], tmp2, tmp);
+		err = excit_composition_init(results[i], tmp2, tmp);
 		if (err) {
 			excit_free(tmp);
 			excit_free(tmp2);
@@ -140,26 +140,26 @@ error:
 	return err;
 }
 
-struct excit_func_table_s excit_slice_func_table = {
-	slice_it_alloc,
-	slice_it_free,
-	slice_it_copy,
-	slice_it_next,
-	slice_it_peek,
-	slice_it_size,
-	slice_it_rewind,
-	slice_it_split,
-	slice_it_nth,
-	slice_it_rank,
-	slice_it_pos
+struct excit_func_table_s excit_composition_func_table = {
+	composition_it_alloc,
+	composition_it_free,
+	composition_it_copy,
+	composition_it_next,
+	composition_it_peek,
+	composition_it_size,
+	composition_it_rewind,
+	composition_it_split,
+	composition_it_nth,
+	composition_it_rank,
+	composition_it_pos
 };
 
-int excit_slice_init(excit_t it, excit_t src, excit_t indexer)
+int excit_composition_init(excit_t it, excit_t src, excit_t indexer)
 {
-	if (!it || it->type != EXCIT_SLICE || !src || !indexer
+	if (!it || it->type != EXCIT_COMPOSITION || !src || !indexer
 	    || indexer->dimension != 1)
 		return -EXCIT_EINVAL;
-	struct slice_it_s *slice_it = (struct slice_it_s *)it->data;
+	struct composition_it_s *composition_it = (struct composition_it_s *)it->data;
 	ssize_t size_src;
 	ssize_t size_indexer;
 	int err = excit_size(src, &size_src);
@@ -171,8 +171,8 @@ int excit_slice_init(excit_t it, excit_t src, excit_t indexer)
 		return err;
 	if (size_indexer > size_src)
 		return -EXCIT_EDOM;
-	slice_it->src = src;
-	slice_it->indexer = indexer;
+	composition_it->src = src;
+	composition_it->indexer = indexer;
 	it->dimension = src->dimension;
 	return EXCIT_SUCCESS;
 }

src/slice.h → src/composition.h

@@ -4,12 +4,12 @@
 #include "excit.h"
 #include "dev/excit.h"
 
-struct slice_it_s {
+struct composition_it_s {
 	excit_t src;
 	excit_t indexer;
 };
 
-extern struct excit_func_table_s excit_slice_func_table;
+extern struct excit_func_table_s excit_composition_func_table;
 
 #endif //EXCIT_SLICE_H
 

src/excit.c

 #include <stdlib.h>
 #include "excit.h"
 #include "dev/excit.h"
-#include "slice.h"
+#include "composition.h"
 #include "prod.h"
 #include "cons.h"
 #include "repeat.h"
@@ -19,7 +19,7 @@ const char *excit_type_name(enum excit_type_e type)
 		CASE(EXCIT_REPEAT);
 		CASE(EXCIT_HILBERT2D);
 		CASE(EXCIT_PRODUCT);
-		CASE(EXCIT_SLICE);
+		CASE(EXCIT_COMPOSITION);
 		CASE(EXCIT_USER);
 		CASE(EXCIT_TYPE_MAX);
 	default:
@@ -115,8 +115,8 @@ excit_t excit_alloc(enum excit_type_e type)
 	case EXCIT_PRODUCT:
 		ALLOC_EXCIT(prod);
 		break;
-	case EXCIT_SLICE:
-		ALLOC_EXCIT(slice);
+	case EXCIT_COMPOSITION:
+		ALLOC_EXCIT(composition);
 		break;
 	case EXCIT_TLEAF:
 		ALLOC_EXCIT(tleaf);
@@ -270,12 +270,12 @@ int excit_split(const excit_t it, ssize_t n, excit_t *results)
 			if (!tmp)
 				goto error2;
 			tmp2 = results[i];
-			results[i] = excit_alloc(EXCIT_SLICE);
+			results[i] = excit_alloc(EXCIT_COMPOSITION);
 			if (!results[i]) {
 				excit_free(tmp2);
 				goto error2;
 			}
-			err = excit_slice_init(results[i], tmp, tmp2);
+			err = excit_composition_init(results[i], tmp, tmp2);
 			if (err) {
 				excit_free(tmp2);
 				goto error2;

tests/Makefile.am

@@ -12,9 +12,9 @@ excit_repeat_SOURCES = $(LIBHSOURCES) $(LIBCSOURCES) excit_repeat.c
 excit_cons_SOURCES = $(LIBHSOURCES) $(LIBCSOURCES) excit_cons.c
 excit_tleaf_SOURCES = $(LIBHSOURCES) $(LIBCSOURCES) excit_tleaf.c
 excit_hilbert2d_SOURCES = $(LIBHSOURCES) $(LIBCSOURCES) excit_hilbert2d.c
-excit_slice_SOURCES = $(LIBHSOURCES) $(LIBCSOURCES) excit_slice.c
+excit_composition_SOURCES = $(LIBHSOURCES) $(LIBCSOURCES) excit_composition.c
 
-UNIT_TESTS = excit_range excit_product excit_repeat excit_cons excit_hilbert2d excit_slice excit_tleaf
+UNIT_TESTS = excit_range excit_product excit_repeat excit_cons excit_hilbert2d excit_composition excit_tleaf
 
 # all tests
 check_PROGRAMS = $(UNIT_TESTS)

tests/excit_slice.c → tests/excit_composition.c

@@ -15,16 +15,16 @@ excit_t create_test_range(ssize_t start, ssize_t stop, ssize_t step)
 	return it;
 }
 
-void test_alloc_init_slice(excit_t source, excit_t indexer)
+void test_alloc_init_composition(excit_t source, excit_t indexer)
 {
 	excit_t it;
 	ssize_t dim, expected_dim, size, expected_size;
 
-	it = excit_alloc_test(EXCIT_SLICE);
+	it = excit_alloc_test(EXCIT_COMPOSITION);
 	assert(excit_dimension(it, &dim) == ES);
 	assert(dim == 0);
 
-	assert(excit_slice_init(it, excit_dup(source), excit_dup(indexer)) ==
+	assert(excit_composition_init(it, excit_dup(source), excit_dup(indexer)) ==
 	       ES);
 	assert(excit_dimension(it, &dim) == ES);
 	assert(excit_dimension(source, &expected_dim) == ES);
@@ -36,19 +36,19 @@ void test_alloc_init_slice(excit_t source, excit_t indexer)
 	excit_free(it);
 }
 
-excit_t create_test_slice(excit_t source, excit_t indexer)
+excit_t create_test_composition(excit_t source, excit_t indexer)
 {
 	excit_t it;
 
-	it = excit_alloc_test(EXCIT_SLICE);
-	assert(excit_slice_init(it, excit_dup(source), excit_dup(indexer)) ==
+	it = excit_alloc_test(EXCIT_COMPOSITION);
+	assert(excit_composition_init(it, excit_dup(source), excit_dup(indexer)) ==
 	       ES);
 	return it;
 }
 
-void test_next_slice(excit_t source, excit_t indexer)
+void test_next_composition(excit_t source, excit_t indexer)
 {
-	excit_t it = create_test_slice(source, indexer);
+	excit_t it = create_test_composition(source, indexer);
 
 	excit_t iit = excit_dup(indexer);
 
@@ -73,16 +73,16 @@ void test_next_slice(excit_t source, excit_t indexer)
 	excit_free(iit);
 }
 
-void test_slice_iterator(excit_t source, excit_t indexer)
+void test_composition_iterator(excit_t source, excit_t indexer)
 {
-	test_alloc_init_slice(source, indexer);
+	test_alloc_init_composition(source, indexer);
 
-	test_next_slice(source, indexer);
+	test_next_composition(source, indexer);
 
 	int i = 0;
 
 	while (synthetic_tests[i]) {
-		excit_t it = create_test_slice(source, indexer);
+		excit_t it = create_test_composition(source, indexer);
 
 		synthetic_tests[i] (it);
 		excit_free(it);
@@ -96,13 +96,13 @@ int main(int argc, char *argv[])
 
 	source = create_test_range(-15, 14, 2);
 	indexer = create_test_range(4, 12, 3);
-	test_slice_iterator(source, indexer);
+	test_composition_iterator(source, indexer);
 
 	source2 = excit_alloc_test(EXCIT_PRODUCT);
 	assert(excit_product_add(source2, create_test_range(-15, 14, 2)) == ES);
 	assert(excit_product_add(source2, create_test_range(4, 12, 3)) == ES);
 	indexer2 = create_test_range(4, 35, 2);
-	test_slice_iterator(source2, indexer2);
+	test_composition_iterator(source2, indexer2);
 
 	excit_free(source);
 	excit_free(source2);