X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsn_stage.c;h=ae61578099057eee7e7a4de7da3057f5c8ea015f;hb=664f1e7c27a7bcea7ebb5a4329087bad22a87a01;hp=bbc311cc279fa9f4e272252bfed479323551832a;hpb=8e4a1e11b964e446370df12fbc2d072eb31a7fda;p=sort-networks.git

diff --git a/src/sn_stage.c b/src/sn_stage.c
index bbc311c..ae61578 100644
--- a/src/sn_stage.c
+++ b/src/sn_stage.c
@@ -1,6 +1,6 @@
 /**
- * collectd - src/sn_stage.c
- * Copyright (C) 2008  Florian octo Forster
+ * libsortnetwork - src/sn_stage.c
+ * Copyright (C) 2008-2010  Florian octo Forster
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -16,12 +16,20 @@
  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  *
  * Authors:
- *   Florian octo Forster <octo at verplant.org>
+ *   Florian octo Forster <ff at octo.it>
  **/
 
+#ifndef _ISOC99_SOURCE
+# define _ISOC99_SOURCE
+#endif
+#ifndef _POSIX_C_SOURCE
+# define _POSIX_C_SOURCE 200112L
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+#include <errno.h>
 
 #include "sn_comparator.h"
 #include "sn_stage.h"
@@ -49,15 +57,43 @@ void sn_stage_destroy (sn_stage_t *s)
   free (s);
 } /* void sn_stage_destroy */
 
+int sn_stage_sort (sn_stage_t *s, int *values)
+{
+  sn_comparator_t *c;
+  int i;
+
+  for (i = 0; i < s->comparators_num; i++)
+  {
+    c = s->comparators + i;
+    if (values[c->min] > values[c->max])
+    {
+      int temp;
+      
+      temp = values[c->min];
+      values[c->min] = values[c->max];
+      values[c->max] = temp;
+    }
+  }
+
+  return (0);
+} /* int sn_stage_sort */
+
 int sn_stage_comparator_add (sn_stage_t *s, const sn_comparator_t *c)
 {
   sn_comparator_t *temp;
   int i;
 
+  if ((s == NULL) || (c == NULL))
+    return (EINVAL);
+
+  i = sn_stage_comparator_check_conflict (s, c);
+  if (i != 0)
+    return (i);
+
   temp = (sn_comparator_t *) realloc (s->comparators,
       (s->comparators_num + 1) * sizeof (sn_comparator_t));
   if (temp == NULL)
-    return (-1);
+    return (ENOMEM);
   s->comparators = temp;
   temp = NULL;
 
@@ -84,6 +120,9 @@ int sn_stage_comparator_remove (sn_stage_t *s, int c_num)
   int nmemb = s->comparators_num - (c_num + 1);
   sn_comparator_t *temp;
 
+  if ((s == NULL) || (s->comparators_num <= c_num))
+    return (EINVAL);
+
   assert (c_num < s->comparators_num);
   assert (c_num >= 0);
 
@@ -113,6 +152,7 @@ int sn_stage_comparator_remove (sn_stage_t *s, int c_num)
 sn_stage_t *sn_stage_clone (const sn_stage_t *s)
 {
   sn_stage_t *s_copy;
+  int i;
 
   s_copy = sn_stage_create (s->depth);
   if (s_copy == NULL)
@@ -126,8 +166,13 @@ sn_stage_t *sn_stage_clone (const sn_stage_t *s)
     return (NULL);
   }
 
-  memcpy (s_copy->comparators, s->comparators,
-      s->comparators_num * sizeof (sn_comparator_t));
+  for (i = 0; i < s->comparators_num; i++)
+  {
+    SN_COMP_MIN (s_copy->comparators + i) = SN_COMP_MIN (s->comparators + i);
+    SN_COMP_MAX (s_copy->comparators + i) = SN_COMP_MAX (s->comparators + i);
+    SN_COMP_USER_DATA (s_copy->comparators + i) = NULL;
+    SN_COMP_FREE_FUNC (s_copy->comparators + i) = NULL;
+  }
   s_copy->comparators_num = s->comparators_num;
 
   return (s_copy);
@@ -165,7 +210,6 @@ int sn_stage_show (sn_stage_t *s)
   int j;
   int k;
 
-
   for (i = 0; i < s->comparators_num; i++)
   {
     lines[i] = -1;
@@ -249,16 +293,39 @@ int sn_stage_invert (sn_stage_t *s)
 {
   int i;
 
+  if (s == NULL)
+    return (EINVAL);
+
   for (i = 0; i < s->comparators_num; i++)
     sn_comparator_invert (s->comparators + i);
 
   return (0);
 } /* int sn_stage_invert */
 
+int sn_stage_shift (sn_stage_t *s, int sw, int inputs_num)
+{
+  int i;
+
+  if ((s == NULL) || (inputs_num < 2))
+    return (EINVAL);
+
+  sw %= inputs_num;
+  if (sw == 0)
+    return (0);
+
+  for (i = 0; i < s->comparators_num; i++)
+    sn_comparator_shift (s->comparators + i, sw, inputs_num);
+
+  return (0);
+} /* int sn_stage_shift */
+
 int sn_stage_swap (sn_stage_t *s, int con0, int con1)
 {
   int i;
 
+  if (s == NULL)
+    return (EINVAL);
+
   for (i = 0; i < s->comparators_num; i++)
     sn_comparator_swap (s->comparators + i, con0, con1);
 
@@ -270,6 +337,9 @@ int sn_stage_cut_at (sn_stage_t *s, int input, enum sn_network_cut_dir_e dir)
   int new_position = input;
   int i;
 
+  if ((s == NULL) || (input < 0))
+    return (-EINVAL);
+
   for (i = 0; i < s->comparators_num; i++)
   {
     sn_comparator_t *c = s->comparators + i;
@@ -296,6 +366,47 @@ int sn_stage_cut_at (sn_stage_t *s, int input, enum sn_network_cut_dir_e dir)
   return (new_position);
 } /* int sn_stage_cut_at */
 
+int sn_stage_cut (sn_stage_t *s, int *mask, /* {{{ */
+    sn_stage_t **prev)
+{
+  int i;
+
+  if ((s == NULL) || (mask == NULL) || (prev == NULL))
+    return (EINVAL);
+
+  for (i = 0; i < s->comparators_num; i++)
+  {
+    sn_comparator_t *c = s->comparators + i;
+    int left = SN_COMP_LEFT (c);
+    int right = SN_COMP_RIGHT (c);
+
+    if ((mask[left] == 0)
+        && (mask[right] == 0))
+      continue;
+
+    /* Check if we need to update the cut position */
+    if ((mask[left] != mask[right])
+        && ((mask[left] > 0) || (mask[right] < 0)))
+    {
+      int tmp;
+      int j;
+
+      tmp = mask[right];
+      mask[right] = mask[left];
+      mask[left] = tmp;
+
+      for (j = s->depth - 1; j >= 0; j--)
+        sn_stage_swap (prev[j],
+            left, right);
+    }
+
+    sn_stage_comparator_remove (s, i);
+    i--;
+  } /* for (i = 0; i < s->comparators_num; i++) */
+
+  return (0);
+} /* }}} int sn_stage_cut */
+
 int sn_stage_remove_input (sn_stage_t *s, int input)
 {
   int i;
@@ -378,4 +489,122 @@ int sn_stage_write (sn_stage_t *s, FILE *fh)
   return (0);
 } /* int sn_stage_write */
 
-/* vim: set shiftwidth=2 softtabstop=2 : */
+int sn_stage_serialize (sn_stage_t *s,
+    char **ret_buffer, size_t *ret_buffer_size)
+{
+  char *buffer;
+  size_t buffer_size;
+  int status;
+  int i;
+
+  if (s->comparators_num <= 0)
+    return (0);
+
+  buffer = *ret_buffer;
+  buffer_size = *ret_buffer_size;
+
+#define SNPRINTF_OR_FAIL(...) \
+  status = snprintf (buffer, buffer_size, __VA_ARGS__); \
+  if ((status < 1) || (((size_t) status) >= buffer_size)) \
+    return (-1); \
+  buffer += status; \
+  buffer_size -= status;
+
+  for (i = 0; i < s->comparators_num; i++)
+  {
+    SNPRINTF_OR_FAIL ("%i %i\r\n",
+	SN_COMP_MIN (s->comparators + i),
+	SN_COMP_MAX (s->comparators + i));
+  }
+
+  SNPRINTF_OR_FAIL ("\r\n");
+
+  *ret_buffer = buffer;
+  *ret_buffer_size = buffer_size;
+  return (0);
+} /* int sn_stage_serialize */
+
+sn_stage_t *sn_stage_unserialize (char **ret_buffer, size_t *ret_buffer_size)
+{
+  sn_stage_t *s;
+  char *buffer;
+  size_t buffer_size;
+  int status;
+
+  buffer = *ret_buffer;
+  buffer_size = *ret_buffer_size;
+
+  if (buffer_size == 0)
+    return (NULL);
+
+  s = sn_stage_create (0);
+  if (s == NULL)
+    return (NULL);
+
+  status = 0;
+  while (buffer_size > 0)
+  {
+    sn_comparator_t c;
+    char *endptr;
+    char *substr;
+    size_t substr_length;
+
+    endptr = strchr (buffer, '\n');
+    if (endptr == NULL)
+    {
+      status = -1;
+      break;
+    }
+
+    *endptr = 0;
+    endptr++;
+
+    substr = buffer;
+    substr_length = strlen (buffer);
+    buffer = endptr;
+    buffer_size -= (substr_length + 1);
+
+    if ((substr_length > 0) && (substr[substr_length - 1] == '\r'))
+    {
+      substr[substr_length - 1] = 0;
+      substr_length--;
+    }
+
+    if (substr_length == 0)
+    {
+      status = 0;
+      break;
+    }
+
+    endptr = NULL;
+    c.min = (int) strtol (substr, &endptr, 0);
+    if (substr == endptr)
+    {
+      status = -1;
+      break;
+    }
+
+    substr = endptr;
+    endptr = NULL;
+    c.max = (int) strtol (substr, &endptr, 0);
+    if (substr == endptr)
+    {
+      status = -1;
+      break;
+    }
+
+    sn_stage_comparator_add (s, &c);
+  } /* while (buffer_size > 0) */
+
+  if ((status != 0) || (s->comparators_num == 0))
+  {
+    sn_stage_destroy (s);
+    return (NULL);
+  }
+
+  *ret_buffer = buffer;
+  *ret_buffer_size = buffer_size;
+  return (s);
+} /* sn_stage_t *sn_stage_unserialize */
+
+/* vim: set shiftwidth=2 softtabstop=2 expandtab : */