celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bpe...@apache.org
Subject celix git commit: CELIX-323: moved version and version_range from framework to tests (Note that the mocks are still in the framework)
Date Mon, 14 Dec 2015 13:40:03 GMT
Repository: celix
Updated Branches:
  refs/heads/develop c5bc7496c -> 8e6e4572a


CELIX-323: moved version and version_range from framework to tests (Note that the mocks are
still in the framework)


Project: http://git-wip-us.apache.org/repos/asf/celix/repo
Commit: http://git-wip-us.apache.org/repos/asf/celix/commit/8e6e4572
Tree: http://git-wip-us.apache.org/repos/asf/celix/tree/8e6e4572
Diff: http://git-wip-us.apache.org/repos/asf/celix/diff/8e6e4572

Branch: refs/heads/develop
Commit: 8e6e4572ae1eb308b8f01f06ce22de47c5e64b8b
Parents: c5bc749
Author: Bjoern Petri <bpetri@apache.org>
Authored: Mon Dec 14 14:39:13 2015 +0100
Committer: Bjoern Petri <bpetri@apache.org>
Committed: Mon Dec 14 14:39:13 2015 +0100

----------------------------------------------------------------------
 utils/private/include/version_private.h       |  41 +++
 utils/private/include/version_range_private.h |  41 +++
 utils/private/src/version.c                   | 242 ++++++++++++++
 utils/private/src/version_range.c             | 179 +++++++++++
 utils/private/test/version_range_test.cpp     | 254 +++++++++++++++
 utils/private/test/version_test.cpp           | 356 +++++++++++++++++++++
 utils/public/include/version.h                | 161 ++++++++++
 utils/public/include/version_range.h          | 111 +++++++
 8 files changed, 1385 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/include/version_private.h
----------------------------------------------------------------------
diff --git a/utils/private/include/version_private.h b/utils/private/include/version_private.h
new file mode 100644
index 0000000..15e5c89
--- /dev/null
+++ b/utils/private/include/version_private.h
@@ -0,0 +1,41 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version_private.h
+ *
+ *  \date       Dec 18, 2012
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+
+#ifndef VERSION_PRIVATE_H_
+#define VERSION_PRIVATE_H_
+
+#include "version.h"
+
+struct version {
+	int major;
+	int minor;
+	int micro;
+	char *qualifier;
+};
+
+
+#endif /* VERSION_PRIVATE_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/include/version_range_private.h
----------------------------------------------------------------------
diff --git a/utils/private/include/version_range_private.h b/utils/private/include/version_range_private.h
new file mode 100644
index 0000000..dfccd59
--- /dev/null
+++ b/utils/private/include/version_range_private.h
@@ -0,0 +1,41 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version_range_private.h
+ *
+ *  \date       Dec 18, 2012
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+
+#ifndef VERSION_RANGE_PRIVATE_H_
+#define VERSION_RANGE_PRIVATE_H_
+
+#include "version_range.h"
+
+struct versionRange {
+	version_pt low;
+	bool isLowInclusive;
+	version_pt high;
+	bool isHighInclusive;
+
+};
+
+#endif /* VERSION_RANGE_PRIVATE_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/src/version.c
----------------------------------------------------------------------
diff --git a/utils/private/src/version.c b/utils/private/src/version.c
new file mode 100644
index 0000000..3f8ddfa
--- /dev/null
+++ b/utils/private/src/version.c
@@ -0,0 +1,242 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version.c
+ *
+ *  \date       Jul 12, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "celix_errno.h"
+#include "version_private.h"
+
+celix_status_t version_createVersion(int major, int minor, int micro, char * qualifier, version_pt
*version) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	if (*version != NULL) {
+		status = CELIX_ILLEGAL_ARGUMENT;
+	} else {
+		*version = (version_pt) malloc(sizeof(**version));
+		if (!*version) {
+			status = CELIX_ENOMEM;
+		} else {
+			unsigned int i;
+
+			(*version)->major = major;
+			(*version)->minor = minor;
+			(*version)->micro = micro;
+			if (qualifier == NULL) {
+				qualifier = "";
+			}
+			(*version)->qualifier = strdup(qualifier);
+
+			if (major < 0) {
+				status = CELIX_ILLEGAL_ARGUMENT;
+			}
+			if (minor < 0) {
+				status = CELIX_ILLEGAL_ARGUMENT;
+			}
+			if (micro < 0) {
+				status = CELIX_ILLEGAL_ARGUMENT;
+			}
+
+			for (i = 0; i < strlen(qualifier); i++) {
+				char ch = qualifier[i];
+				if (('A' <= ch) && (ch <= 'Z')) {
+					continue;
+				}
+				if (('a' <= ch) && (ch <= 'z')) {
+					continue;
+				}
+				if (('0' <= ch) && (ch <= '9')) {
+					continue;
+				}
+				if ((ch == '_') || (ch == '-')) {
+					continue;
+				}
+				status = CELIX_ILLEGAL_ARGUMENT;
+				break;
+			}
+		}
+	}
+
+	return status;
+}
+
+celix_status_t version_clone(version_pt version, version_pt *clone) {
+	return version_createVersion(version->major, version->minor, version->micro, version->qualifier,
clone);
+}
+
+celix_status_t version_destroy(version_pt version) {
+	version->major = 0;
+	version->minor = 0;
+	version->micro = 0;
+	free(version->qualifier);
+	version->qualifier = NULL;
+	free(version);
+	return CELIX_SUCCESS;
+}
+
+celix_status_t version_createVersionFromString(char * versionStr, version_pt *version) {
+	celix_status_t status = CELIX_SUCCESS;
+
+	int major = 0;
+	int minor = 0;
+	int micro = 0;
+	char * qualifier = NULL;
+
+	char delims[] = ".";
+	char *token = NULL;
+	char *last = NULL;
+
+	int i = 0;
+
+	token = strtok_r(versionStr, delims, &last);
+	if (token != NULL) {
+		for (i = 0; i < strlen(token); i++) {
+			char ch = token[i];
+			if (('0' <= ch) && (ch <= '9')) {
+				continue;
+			}
+			status = CELIX_ILLEGAL_ARGUMENT;
+			break;
+		}
+		major = atoi(token);
+		token = strtok_r(NULL, delims, &last);
+		if (token != NULL) {
+			for (i = 0; i < strlen(token); i++) {
+				char ch = token[i];
+				if (('0' <= ch) && (ch <= '9')) {
+					continue;
+				}
+				status = CELIX_ILLEGAL_ARGUMENT;
+				break;
+			}
+			minor = atoi(token);
+			token = strtok_r(NULL, delims, &last);
+			if (token != NULL) {
+				for (i = 0; i < strlen(token); i++) {
+					char ch = token[i];
+					if (('0' <= ch) && (ch <= '9')) {
+						continue;
+					}
+					status = CELIX_ILLEGAL_ARGUMENT;
+					break;
+				}
+				micro = atoi(token);
+				token = strtok_r(NULL, delims, &last);
+				if (token != NULL) {
+					qualifier = strdup(token);
+					token = strtok_r(NULL, delims, &last);
+					if (token != NULL) {
+						*version = NULL;
+						status = CELIX_ILLEGAL_ARGUMENT;
+					}
+				}
+			}
+		}
+	}
+	if (status == CELIX_SUCCESS) {
+		status = version_createVersion(major, minor, micro, qualifier, version);
+	}
+
+	if (qualifier != NULL) {
+	    free(qualifier);
+	}
+
+	return status;
+}
+
+celix_status_t version_createEmptyVersion(version_pt *version) {
+	return version_createVersion(0, 0, 0, "", version);
+}
+
+celix_status_t version_getMajor(version_pt version, int *major) {
+	celix_status_t status = CELIX_SUCCESS;
+	*major = version->major;
+	return status;
+}
+
+celix_status_t version_getMinor(version_pt version, int *minor) {
+	celix_status_t status = CELIX_SUCCESS;
+	*minor = version->minor;
+	return status;
+}
+
+celix_status_t version_getMicro(version_pt version, int *micro) {
+	celix_status_t status = CELIX_SUCCESS;
+	*micro = version->micro;
+	return status;
+}
+
+celix_status_t version_getQualifier(version_pt version, char **qualifier) {
+	celix_status_t status = CELIX_SUCCESS;
+	*qualifier = version->qualifier;
+	return status;
+}
+
+celix_status_t version_compareTo(version_pt version, version_pt compare, int *result) {
+	celix_status_t status = CELIX_SUCCESS;
+	if (compare == version) {
+		*result = 0;
+	} else {
+		int res = version->major - compare->major;
+		if (res != 0) {
+			*result = res;
+		} else {
+			res = version->minor - compare->minor;
+			if (res != 0) {
+				*result = res;
+			} else {
+				res = version->micro - compare->micro;
+				if (res != 0) {
+					*result = res;
+				} else {
+					*result = strcmp(version->qualifier, compare->qualifier);
+				}
+			}
+		}
+	}
+
+	return status;
+}
+
+celix_status_t version_toString(version_pt version, char **string) {
+    celix_status_t status = CELIX_SUCCESS;
+	if (strlen(version->qualifier) > 0) {
+	    char str[512];
+	    int written = snprintf(str, 512, "%d.%d.%d.%s", version->major, version->minor,
version->micro, version->qualifier);
+	    if (written >= 512 || written < 0) {
+	        status = CELIX_BUNDLE_EXCEPTION;
+	    }
+	    *string = strdup(str);
+	} else {
+	    char str[512];
+        int written = snprintf(str, 512, "%d.%d.%d", version->major, version->minor,
version->micro);
+        if (written >= 512 || written < 0) {
+            status = CELIX_BUNDLE_EXCEPTION;
+        }
+        *string = strdup(str);
+	}
+	return status;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/src/version_range.c
----------------------------------------------------------------------
diff --git a/utils/private/src/version_range.c b/utils/private/src/version_range.c
new file mode 100644
index 0000000..bb3d82e
--- /dev/null
+++ b/utils/private/src/version_range.c
@@ -0,0 +1,179 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version_range.c
+ *
+ *  \date       Jul 12, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "version_range_private.h"
+
+celix_status_t versionRange_createVersionRange(version_pt low, bool isLowInclusive,
+			version_pt high, bool isHighInclusive, version_range_pt *range) {
+	celix_status_t status = CELIX_SUCCESS;
+	*range = (version_range_pt) malloc(sizeof(**range));
+	if (!*range) {
+		status = CELIX_ENOMEM;
+	} else {
+		(*range)->low = low;
+		(*range)->isLowInclusive = isLowInclusive;
+		(*range)->high = high;
+		(*range)->isHighInclusive = isHighInclusive;
+	}
+
+	return status;
+}
+
+celix_status_t versionRange_destroy(version_range_pt range) {
+    if (range->high != NULL) {
+        version_destroy(range->high);
+    }
+    if (range->low != NULL) {
+        version_destroy(range->low);
+    }
+
+	range->high = NULL;
+	range->isHighInclusive = false;
+	range->low = NULL;
+	range->isLowInclusive = false;
+
+	free(range);
+
+	return CELIX_SUCCESS;
+}
+
+celix_status_t versionRange_createInfiniteVersionRange(version_range_pt *range) {
+	celix_status_t status;
+
+	version_pt version = NULL;
+	status = version_createEmptyVersion(&version);
+	if (status == CELIX_SUCCESS) {
+		status = versionRange_createVersionRange(version, true, NULL, true, range);
+	}
+
+	return status;
+}
+
+celix_status_t versionRange_isInRange(version_range_pt versionRange, version_pt version,
bool *inRange) {
+	celix_status_t status;
+	if (versionRange->high == NULL) {
+		int cmp;
+		status = version_compareTo(version, versionRange->low, &cmp);
+		if (status == CELIX_SUCCESS) {
+			*inRange = (cmp >= 0);
+		}
+	} else if (versionRange->isLowInclusive && versionRange->isHighInclusive)
{
+		int low, high;
+		status = version_compareTo(version, versionRange->low, &low);
+		if (status == CELIX_SUCCESS) {
+			status = version_compareTo(version, versionRange->high, &high);
+			if (status == CELIX_SUCCESS) {
+				*inRange = (low >= 0) && (high <= 0);
+			}
+		}
+	} else if (versionRange->isHighInclusive) {
+		int low, high;
+		status = version_compareTo(version, versionRange->low, &low);
+		if (status == CELIX_SUCCESS) {
+			status = version_compareTo(version, versionRange->high, &high);
+			if (status == CELIX_SUCCESS) {
+				*inRange = (low > 0) && (high <= 0);
+			}
+		}
+	} else if (versionRange->isLowInclusive) {
+		int low, high;
+		status = version_compareTo(version, versionRange->low, &low);
+		if (status == CELIX_SUCCESS) {
+			status = version_compareTo(version, versionRange->high, &high);
+			if (status == CELIX_SUCCESS) {
+				*inRange = (low >= 0) && (high < 0);
+			}
+		}
+	} else {
+		int low, high;
+		status = version_compareTo(version, versionRange->low, &low);
+		if (status == CELIX_SUCCESS) {
+			status = version_compareTo(version, versionRange->high, &high);
+			if (status == CELIX_SUCCESS) {
+				*inRange = (low > 0) && (high < 0);
+			}
+		}
+	}
+
+	return status;
+}
+
+celix_status_t versionRange_parse(char * rangeStr, version_range_pt *range) {
+	celix_status_t status;
+	if (strchr(rangeStr, ',') != NULL) {
+			int vlowL = strcspn(rangeStr+1, ",");
+			char * vlow = (char *) malloc(sizeof(char) * (vlowL + 1));
+			if (!vlow) {
+				status = CELIX_ENOMEM;
+			} else {
+				int vhighL;
+				char * vhigh;
+				vlow = strncpy(vlow, rangeStr+1, vlowL);
+				vlow[vlowL] = '\0';
+				vhighL = strlen(rangeStr+1) - vlowL - 2;
+				vhigh = (char *) malloc(sizeof(char) * (vhighL+1));
+				if (!vhigh) {
+					status = CELIX_ENOMEM;
+				} else {					
+					version_pt versionLow = NULL;
+					int rangeL = strlen(rangeStr);
+					char start = rangeStr[0];
+					char end = rangeStr[rangeL-1];
+
+					vhigh = strncpy(vhigh, rangeStr+vlowL+2, vhighL);
+					vhigh[vhighL] = '\0';
+					status = version_createVersionFromString(vlow, &versionLow);
+					if (status == CELIX_SUCCESS) {
+						version_pt versionHigh = NULL;
+						status = version_createVersionFromString(vhigh, &versionHigh);
+						if (status == CELIX_SUCCESS) {
+							status = versionRange_createVersionRange(
+									versionLow,
+									start == '[',
+									versionHigh,
+									end ==']',
+									range
+								);
+						}
+					}
+					free(vhigh);
+				}
+				free(vlow);
+
+		}
+	} else {
+		version_pt version = NULL;
+		status = version_createVersionFromString(rangeStr, &version);
+		if (status == CELIX_SUCCESS) {
+			status = versionRange_createVersionRange(version, true, NULL, false, range);
+		}
+	}
+
+	return status;
+}

http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/test/version_range_test.cpp
----------------------------------------------------------------------
diff --git a/utils/private/test/version_range_test.cpp b/utils/private/test/version_range_test.cpp
new file mode 100644
index 0000000..1e1336c
--- /dev/null
+++ b/utils/private/test/version_range_test.cpp
@@ -0,0 +1,254 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version_range_test.cpp
+ *
+ *  \date       Dec 18, 2012
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+
+#include "CppUTest/TestHarness.h"
+#include "CppUTest/TestHarness_c.h"
+#include "CppUTest/CommandLineTestRunner.h"
+#include "CppUTestExt/MockSupport.h"
+#include "string.h"
+
+extern "C"
+{
+#include "version_range_private.h"
+#include "version_private.h"
+
+#include "celix_log.h"
+
+framework_logger_pt logger = (framework_logger_pt) 0x42;
+}
+
+int main(int argc, char** argv) {
+	return RUN_ALL_TESTS(argc, argv);
+}
+
+static char* my_strdup(const char* s) {
+	if (s == NULL) {
+		return NULL;
+	}
+
+	size_t len = strlen(s);
+
+	char *d = (char*) calloc(len + 1, sizeof(char));
+
+	if (d == NULL) {
+		return NULL;
+	}
+
+	strncpy(d, s, len);
+	return d;
+}
+
+//----------------------TESTGROUP DEFINES----------------------
+
+TEST_GROUP(version_range) {
+
+	void setup(void) {
+	}
+
+	void teardown() {
+		mock().checkExpectations();
+		mock().clear();
+	}
+};
+
+TEST(version_range, create) {
+	celix_status_t status = CELIX_SUCCESS;
+	version_range_pt range = NULL;
+	version_pt version = (version_pt) malloc(sizeof(*version));
+
+	status = versionRange_createVersionRange(version, false, version, true, &range);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C((range != NULL));
+	LONGS_EQUAL(true, range->isHighInclusive);
+	LONGS_EQUAL(false, range->isLowInclusive);
+	POINTERS_EQUAL(version, range->low);
+	POINTERS_EQUAL(version, range->high);
+
+	mock().expectNCalls(2, "version_destroy")
+			.withParameter("version", version);
+
+	versionRange_destroy(range);
+	free(version);
+}
+
+TEST(version_range, createInfinite) {
+	celix_status_t status = CELIX_SUCCESS;
+	version_range_pt range = NULL;
+	version_pt version = (version_pt) malloc(sizeof(*version));
+	version->major = 1;
+	version->minor = 2;
+	version->micro = 3;
+
+	mock()
+	.expectOneCall("version_createEmptyVersion")
+	.withOutputParameterReturning("version", &version, sizeof("version"));
+	status = versionRange_createInfiniteVersionRange(&range);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(range != NULL);
+	LONGS_EQUAL(true, range->isHighInclusive);
+	LONGS_EQUAL(true, range->isLowInclusive);
+	POINTERS_EQUAL(version, range->low);
+	POINTERS_EQUAL(NULL, range->high);
+
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", version);
+
+	versionRange_destroy(range);
+	free(version);
+}
+
+TEST(version_range, isInRange) {
+	bool result;
+	version_range_pt range = NULL;
+	version_pt version = (version_pt) malloc(sizeof(*version));
+	version->major = 1;
+	version->minor = 2;
+	version->micro = 3;
+
+	version_pt low = (version_pt) malloc(sizeof(*low));
+	low->major = 1;
+	low->minor = 2;
+	low->micro = 3;
+
+	version_pt high = (version_pt) malloc(sizeof(*high));
+	high->major = 1;
+	high->minor = 2;
+	high->micro = 3;
+
+	int stat = 1;
+	mock()
+	.expectNCalls(5, "version_compareTo")
+	.withParameter("version", version)
+	.withParameter("compare", low)
+	.withOutputParameterReturning("result", &stat, sizeof(int));
+	int stat2 = -1;
+	mock()
+	.expectNCalls(4, "version_compareTo")
+	.withParameter("version", version)
+	.withParameter("compare", high)
+	.withOutputParameterReturning("result", &stat2, sizeof(int));
+
+	versionRange_createVersionRange(low, true, high, true, &range);
+	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+	LONGS_EQUAL(true, result);
+
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", low);
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", high);
+	versionRange_destroy(range);
+
+	versionRange_createVersionRange(low, true, NULL, true, &range);
+	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+	LONGS_EQUAL(true, result);
+
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", low);
+	versionRange_destroy(range);
+
+	versionRange_createVersionRange(low, false, high, true, &range);
+	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+	LONGS_EQUAL(true, result);
+
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", low);
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", high);
+	versionRange_destroy(range);
+
+	versionRange_createVersionRange(low, true, high, false, &range);
+	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+	LONGS_EQUAL(true, result);
+
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", low);
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", high);
+	versionRange_destroy(range);
+
+	versionRange_createVersionRange(low, false, high, false, &range);
+	LONGS_EQUAL(CELIX_SUCCESS, versionRange_isInRange(range, version, &result));
+	LONGS_EQUAL(true, result);
+
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", low);
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", high);
+	versionRange_destroy(range);
+
+	free(version);
+	free(high);
+	free(low);
+}
+
+TEST(version_range, parse) {
+	version_range_pt range = NULL;
+	version_pt low = (version_pt) malloc(sizeof(*low));
+	version_pt high = (version_pt) malloc(sizeof(*high));
+	char * version = my_strdup("[1.2.3,7.8.9]");
+	low->major = 1;
+	low->minor = 2;
+	low->micro = 3;
+
+	high->major = 7;
+	high->minor = 8;
+	high->micro = 9;
+
+	mock().expectOneCall("version_destroy")
+			.withParameter("version", high);
+
+	mock().expectNCalls(2, "version_destroy")
+			.withParameter("version", low);
+
+	mock().expectOneCall("version_createVersionFromString")
+		   .withParameter("versionStr", "1.2.3")
+		   .withOutputParameterReturning("version", &low, sizeof(low));
+
+	mock().expectOneCall("version_createVersionFromString")
+			.withParameter("versionStr", "7.8.9")
+			.withOutputParameterReturning("version", &high, sizeof(high));
+
+	LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
+
+	versionRange_destroy(range);
+	free(version);
+	version = my_strdup("[1.2.3");
+
+	mock().expectOneCall("version_createVersionFromString")
+			.withParameter("versionStr", "[1.2.3")
+			.withOutputParameterReturning("version", &low, sizeof(low));
+
+	LONGS_EQUAL(CELIX_SUCCESS, versionRange_parse(version, &range));
+
+	versionRange_destroy(range);
+	free(version);
+	free(high);
+	free(low);
+}
+
+
+
+

http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/private/test/version_test.cpp
----------------------------------------------------------------------
diff --git a/utils/private/test/version_test.cpp b/utils/private/test/version_test.cpp
new file mode 100644
index 0000000..e1b0eee
--- /dev/null
+++ b/utils/private/test/version_test.cpp
@@ -0,0 +1,356 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version_test.cpp
+ *
+ *  \date       Dec 18, 2012
+ *  \author     <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright  Apache License, Version 2.0
+ */
+#include <string.h>
+
+#include "CppUTest/TestHarness.h"
+#include "CppUTest/TestHarness_c.h"
+#include "CppUTest/CommandLineTestRunner.h"
+#include "CppUTestExt/MockSupport.h"
+
+extern "C"
+{
+#include "version_private.h"
+#include "celix_log.h"
+
+framework_logger_pt logger = (framework_logger_pt) 0x666;
+}
+
+int main(int argc, char** argv) {
+	return RUN_ALL_TESTS(argc, argv);
+}
+
+static char* my_strdup(const char* s){
+	if(s==NULL){
+		return NULL;
+	}
+
+	size_t len = strlen(s);
+
+	char *d = (char*) calloc (len + 1,sizeof(char));
+
+	if (d == NULL){
+		return NULL;
+	}
+
+	strncpy (d,s,len);
+	return d;
+}
+
+TEST_GROUP(version) {
+
+	void setup(void) {
+	}
+
+	void teardown() {
+		mock().checkExpectations();
+		mock().clear();
+	}
+
+};
+
+
+TEST(version, create) {
+	version_pt version = NULL;
+	char * str;
+
+//	str = my_strdup("abc");
+//	status = version_createVersion(1, 2, 3, str, &version);
+//	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
+
+	str = my_strdup("abc");
+	LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
+	CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+	LONGS_EQUAL(2, version->minor);
+	LONGS_EQUAL(3, version->micro);
+	STRCMP_EQUAL("abc", version->qualifier);
+
+	version_destroy(version);
+	version = NULL;
+	LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, NULL, &version));
+	CHECK_C(version != NULL);
+	LONGS_EQUAL(1, version->major);
+	LONGS_EQUAL(2, version->minor);
+	LONGS_EQUAL(3, version->micro);
+	STRCMP_EQUAL("", version->qualifier);
+
+	version_destroy(version);
+	version = NULL;
+	free(str);
+	str = my_strdup("abc");
+	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(-1, -2, -3, str, &version));
+
+	version_destroy(version);
+	version = NULL;
+	free(str);
+	str = my_strdup("abc|xyz");
+	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersion(1, 2, 3, str, &version));
+
+	version_destroy(version);
+	free(str);
+}
+
+TEST(version, clone) {
+	version_pt version = NULL, clone = NULL;
+	char * str;
+
+	str = my_strdup("abc");
+	LONGS_EQUAL(CELIX_SUCCESS, version_createVersion(1, 2, 3, str, &version));
+	LONGS_EQUAL(CELIX_SUCCESS, version_clone(version, &clone));
+	CHECK_C(version != NULL);
+    LONGS_EQUAL(1, clone->major);
+	LONGS_EQUAL(2, clone->minor);
+	LONGS_EQUAL(3, clone->micro);
+	STRCMP_EQUAL("abc", clone->qualifier);
+
+	version_destroy(clone);
+	version_destroy(version);
+	free(str);
+}
+
+TEST(version, createFromString) {
+	version_pt version = NULL;
+	celix_status_t status = CELIX_SUCCESS;
+	char * str;
+
+	str = my_strdup("1");
+	LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
+	CHECK_C(version != NULL);
+	LONGS_EQUAL(1, version->major);
+
+	version_destroy(version);
+
+	free(str);
+	str = my_strdup("a");
+	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+	free(str);
+	str = my_strdup("1.a");
+	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+	free(str);
+	str = my_strdup("1.1.a");
+	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+	free(str);
+	str = my_strdup("-1");
+	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, version_createVersionFromString(str, &version));
+
+	free(str);
+	str = my_strdup("1.2");
+	version = NULL;
+	LONGS_EQUAL(CELIX_SUCCESS, version_createVersionFromString(str, &version));
+	CHECK_C(version != NULL);
+	LONGS_EQUAL(1, version->major);
+	LONGS_EQUAL(2, version->minor);
+
+	version_destroy(version);
+
+	free(str);
+	str = my_strdup("1.2.3");
+	version = NULL;
+	status = version_createVersionFromString(str, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+	LONGS_EQUAL(1, version->major);
+	LONGS_EQUAL(2, version->minor);
+	LONGS_EQUAL(3, version->micro);
+
+	version_destroy(version);
+	free(str);
+	str = my_strdup("1.2.3.abc");
+	version = NULL;
+	status = version_createVersionFromString(str, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+	LONGS_EQUAL(2, version->minor);
+	LONGS_EQUAL(3, version->micro);
+	STRCMP_EQUAL("abc", version->qualifier);
+
+	version_destroy(version);
+	free(str);
+	str = my_strdup("1.2.3.abc_xyz");
+	version = NULL;
+	status = version_createVersionFromString(str, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+	LONGS_EQUAL(2, version->minor);
+	LONGS_EQUAL(3, version->micro);
+	STRCMP_EQUAL("abc_xyz", version->qualifier);
+
+	version_destroy(version);
+	free(str);
+	str = my_strdup("1.2.3.abc-xyz");
+	version = NULL;
+	status = version_createVersionFromString(str, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+    LONGS_EQUAL(1, version->major);
+	LONGS_EQUAL(2, version->minor);
+	LONGS_EQUAL(3, version->micro);
+	STRCMP_EQUAL("abc-xyz", version->qualifier);
+
+	version_destroy(version);
+	free(str);
+	str = my_strdup("1.2.3.abc|xyz");
+	status = version_createVersionFromString(str, &version);
+	LONGS_EQUAL(CELIX_ILLEGAL_ARGUMENT, status);
+
+	free(str);
+}
+
+TEST(version, createEmptyVersion) {
+	version_pt version = NULL;
+	celix_status_t status = CELIX_SUCCESS;
+
+	status = version_createEmptyVersion(&version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+    LONGS_EQUAL(0, version->major);
+	LONGS_EQUAL(0, version->minor);
+	LONGS_EQUAL(0, version->micro);
+	STRCMP_EQUAL("", version->qualifier);
+
+	version_destroy(version);
+}
+
+TEST(version, getters) {
+	version_pt version = NULL;
+	celix_status_t status = CELIX_SUCCESS;
+	char * str;
+	int major, minor, micro;
+	char *qualifier;
+
+	str = my_strdup("abc");
+	status = version_createVersion(1, 2, 3, str, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+
+	version_getMajor(version, &major);
+    LONGS_EQUAL(1, major);
+
+    version_getMinor(version, &minor);
+	LONGS_EQUAL(2, minor);
+
+	version_getMicro(version, &micro);
+	LONGS_EQUAL(3, micro);
+
+	version_getQualifier(version, &qualifier);
+	STRCMP_EQUAL("abc", qualifier);
+
+	version_destroy(version);
+	free(str);
+}
+
+TEST(version, compare) {
+	version_pt version = NULL, compare = NULL;
+	celix_status_t status = CELIX_SUCCESS;
+	char * str;
+	int result;
+
+	// Base version to compare
+	str = my_strdup("abc");
+	status = version_createVersion(1, 2, 3, str, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+
+	// Compare equality
+	free(str);
+	str = my_strdup("abc");
+	compare = NULL;
+	status = version_createVersion(1, 2, 3, str, &compare);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+	status = version_compareTo(version, compare, &result);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	LONGS_EQUAL(0, result);
+
+	// Compare against a higher version
+	free(str);
+	str = my_strdup("bcd");
+	version_destroy(compare);
+	compare = NULL;
+	status = version_createVersion(1, 2, 3, str, &compare);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+	status = version_compareTo(version, compare, &result);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK(result < 0);
+
+	// Compare againts a lower version
+	free(str);
+	str = my_strdup("abc");
+	version_destroy(compare);
+	compare = NULL;
+	status = version_createVersion(1, 1, 3, str, &compare);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+	status = version_compareTo(version, compare, &result);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK(result > 0);
+
+	version_destroy(compare);
+	version_destroy(version);
+	free(str);
+}
+
+TEST(version, toString) {
+	version_pt version = NULL;
+	celix_status_t status = CELIX_SUCCESS;
+	char * str;
+	char *result = NULL;
+
+	str = my_strdup("abc");
+	status = version_createVersion(1, 2, 3, str, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+
+	status = version_toString(version, &result);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(result != NULL);
+	STRCMP_EQUAL("1.2.3.abc", result);
+	free(result);
+
+	version_destroy(version);
+	version = NULL;
+	status = version_createVersion(1, 2, 3, NULL, &version);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(version != NULL);
+
+	status = version_toString(version, &result);
+	LONGS_EQUAL(CELIX_SUCCESS, status);
+	CHECK_C(result != NULL);
+	STRCMP_EQUAL("1.2.3", result);
+
+	version_destroy(version);
+	free(result);
+	free(str);
+}
+
+
+

http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/public/include/version.h
----------------------------------------------------------------------
diff --git a/utils/public/include/version.h b/utils/public/include/version.h
new file mode 100644
index 0000000..ca1a2fa
--- /dev/null
+++ b/utils/public/include/version.h
@@ -0,0 +1,161 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version.h
+ *
+ *  \date       Jul 12, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#ifndef VERSION_H_
+#define VERSION_H_
+
+#include "celix_errno.h"
+/**
+ * The definition of the version_pt abstract data type.
+ */
+typedef struct version * version_pt;
+
+/**
+ * Creates a new version_pt using the supplied arguments.
+ *
+ * @param major Major component of the version identifier.
+ * @param minor Minor component of the version identifier.
+ * @param micro Micro component of the version identifier.
+ * @param qualifier Qualifier component of the version identifier. If
+ *        <code>null</code> is specified, then the qualifier will be set to
+ *        the empty string.
+ * @param version The created version_pt
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
+ * 		  or the qualifier string is invalid.
+ */
+celix_status_t version_createVersion(int major, int minor, int micro, char * qualifier, version_pt
*version);
+
+celix_status_t version_destroy(version_pt version);
+
+/**
+ * Creates a clone of <code>version</code>.
+ *
+ * @param version The version to clone
+ * @param clone The cloned version
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative
+ * 		  or the qualifier string is invalid.
+ */
+celix_status_t version_clone(version_pt version, version_pt *clone);
+
+/**
+ * Creates a version identifier from the specified string.
+ *
+ * <p>
+ * Here is the grammar for version strings.
+ *
+ * <pre>
+ * version ::= major('.'minor('.'micro('.'qualifier)?)?)?
+ * major ::= digit+
+ * minor ::= digit+
+ * micro ::= digit+
+ * qualifier ::= (alpha|digit|'_'|'-')+
+ * digit ::= [0..9]
+ * alpha ::= [a..zA..Z]
+ * </pre>
+ *
+ * There must be no whitespace in version.
+ *
+ * @param versionStr String representation of the version identifier.
+ * @param version The created version_pt
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ * 		  	the qualifier string is invalid or <code>versionStr</code> is improperly
formatted.
+ */
+celix_status_t version_createVersionFromString(char * versionStr, version_pt *version);
+
+/**
+ * The empty version "0.0.0".
+ *
+ * @param version The created version_pt
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ * 		- CELIX_ENOMEM If allocating memory for <code>version</code> failed.
+ * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ * 		  	the qualifier string is invalid or <code>versionStr</code> is improperly
formatted.
+ */
+celix_status_t version_createEmptyVersion(version_pt *version);
+
+celix_status_t version_getMajor(version_pt version, int *major);
+celix_status_t version_getMinor(version_pt version, int *minor);
+celix_status_t version_getMicro(version_pt version, int *micro);
+celix_status_t version_getQualifier(version_pt version, char **qualifier);
+
+/**
+ * Compares this <code>Version</code> object to another object.
+ *
+ * <p>
+ * A version is considered to be <b>less than </b> another version if its
+ * major component is less than the other version's major component, or the
+ * major components are equal and its minor component is less than the other
+ * version's minor component, or the major and minor components are equal
+ * and its micro component is less than the other version's micro component,
+ * or the major, minor and micro components are equal and it's qualifier
+ * component is less than the other version's qualifier component (using
+ * <code>String.compareTo</code>).
+ *
+ * <p>
+ * A version is considered to be <b>equal to</b> another version if the
+ * major, minor and micro components are equal and the qualifier component
+ * is equal (using <code>String.compareTo</code>).
+ *
+ * @param version The <code>version_pt</code> to be compared with <code>compare</code>.
+ * @param compare The <code>version_pt</code> to be compared with <code>version</code>.
+ * @param result A negative integer, zero, or a positive integer if <code>version</code>
is
+ *         less than, equal to, or greater than the <code>compare</code>.
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ */
+celix_status_t version_compareTo(version_pt version, version_pt compare, int *result);
+
+/**
+ * Returns the string representation of <code>version</code> identifier.
+ *
+ * <p>
+ * The format of the version string will be <code>major.minor.micro</code>
+ * if qualifier is the empty string or
+ * <code>major.minor.micro.qualifier</code> otherwise.
+ *
+ * @return The string representation of this version identifier.
+ * @param version The <code>version_pt</code> to get the string representation
from.
+ * @param string Pointer to the string (char *) in which the result will be placed.
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ */
+celix_status_t version_toString(version_pt version, char **string);
+
+/**
+ * @}
+ */
+
+#endif /* VERSION_H_ */

http://git-wip-us.apache.org/repos/asf/celix/blob/8e6e4572/utils/public/include/version_range.h
----------------------------------------------------------------------
diff --git a/utils/public/include/version_range.h b/utils/public/include/version_range.h
new file mode 100644
index 0000000..a979eca
--- /dev/null
+++ b/utils/public/include/version_range.h
@@ -0,0 +1,111 @@
+/**
+ *Licensed to the Apache Software Foundation (ASF) under one
+ *or more contributor license agreements.  See the NOTICE file
+ *distributed with this work for additional information
+ *regarding copyright ownership.  The ASF licenses this file
+ *to you under the Apache License, Version 2.0 (the
+ *"License"); you may not use this file except in compliance
+ *with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *Unless required by applicable law or agreed to in writing,
+ *software distributed under the License is distributed on an
+ *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ *specific language governing permissions and limitations
+ *under the License.
+ */
+/*
+ * version_range.h
+ *
+ *  \date       Jul 12, 2010
+ *  \author    	<a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ *  \copyright	Apache License, Version 2.0
+ */
+
+#ifndef VERSION_RANGE_H_
+#define VERSION_RANGE_H_
+
+/**
+ * @defgroup VersionRange Version Range functions
+ * @ingroup framework
+ * @{
+ */
+
+#include "celixbool.h"
+#include "celix_errno.h"
+#include "version.h"
+
+/**
+ * Type definition for the version_range_pt abstract data type.
+ */
+typedef struct versionRange * version_range_pt;
+
+/**
+ * Creates a new <code>version_range_pt</code>.
+ *
+ * @param low Lower bound version
+ * @param isLowInclusive True if lower bound should be included in the range
+ * @param high Upper bound version
+ * @param isHighInclusive True if upper bound should be included in the range
+ * @param versionRange The created range
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ * 		- CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
+ */
+celix_status_t versionRange_createVersionRange(version_pt low, bool isLowInclusive, version_pt
high, bool isHighInclusive, version_range_pt *versionRange);
+
+/**
+ * Creates an infinite version range using ::version_createEmptyVersion for the low version,
+ * 	NULL for the high version and high and low inclusive set to true.
+ *
+ * @param range The created range
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ * 		- CELIX_ENOMEM If allocating memory for <code>range</code> failed.
+ */
+celix_status_t versionRange_createInfiniteVersionRange(version_range_pt *range);
+
+celix_status_t versionRange_destroy(version_range_pt range);
+
+/**
+ * Determine if the specified version is part of the version range or not.
+ *
+ * @param versionRange The range to check <code>version</code> against.
+ * @param version The version to check.
+ * @param inRange True if the specified version is included in this version range, false
otherwise.
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ */
+celix_status_t versionRange_isInRange(version_range_pt versionRange, version_pt version,
bool *inRange);
+
+/**
+ * Parses a version range from the specified string.
+ *
+ * <p>
+ * Here is the grammar for version range strings.
+ *
+ * <pre>
+ * version-range ::= interval | atleast
+ * interval ::= ( '[' | '(' ) floor ',' ceiling ( ']' | ')' )
+ * atleast ::= version
+ * floor ::= version
+ * ceiling ::= version
+ * </pre>
+ *
+ * @param rangeStr String representation of the version range.
+ * @param range The created version_range_pt.
+ * @return Status code indication failure or success:
+ * 		- CELIX_SUCCESS when no errors are encountered.
+ * 		- CELIX_ENOMEM If allocating memory for <code>versionRange</code> failed.
+ * 		- CELIX_ILLEGAL_ARGUMENT If the numerical components are negative,
+ * 		  	the qualifier string is invalid or <code>versionStr</code> is impropertly
formatted.
+ */
+celix_status_t versionRange_parse(char * rangeStr, version_range_pt *range);
+
+/**
+ * @}
+ */
+
+#endif /* VERSION_RANGE_H_ */


Mime
View raw message