Work on marshalling

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 41 insertions, 45 deletions

diff --git a/src/filter.c b/src/filter.c
index fe239f1..80e3ed1 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -15,9 +15,10 @@
  * You should have received a copy of the GNU General Public License
  * along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
-#define _GNU_SOURCE
 #include "filter.h"
+#include "util.h"
 
+#include <stdlib.h>
 #include <string.h>
 
 
@@ -26,68 +27,68 @@
  * Free all resources allocated to a filter.
  * The allocation of `filter` itself is not freed.
  * 
- * @param  filter  The filter.
+ * @param  this  The filter
  */
-void filter_destroy(struct filter* filter)
+void filter_destroy(struct filter* this)
 {
-  free(filter->crtc);
-  free(filter->class);
-  free(filter->ramps);
+  free(this->crtc);
+  free(this->class);
+  free(this->ramps);
 }
 
 
 /**
- * Marshal a filter.
+ * Marshal a filter
  * 
- * @param   filter      The filter.
- * @param   buf         Output buffer for the marshalled filter.
+ * @param   this        The filter
+ * @param   buf         Output buffer for the marshalled filter,
  *                      `NULL` just measure how large the buffers
- *                      needs to be.
- * @param   ramps_size  The byte-size of `filter->ramps`
+ *                      needs to be
+ * @param   ramps_size  The byte-size of `this->ramps`
  * @return              The number of marshalled byte
  */
-size_t filter_marshal(const struct filter* filter, char* buf, size_t ramps_size)
+size_t filter_marshal(const struct filter* this, char* buf, size_t ramps_size)
 {
   size_t off = 0, n;
   char nonnulls = 0;
   
   if (buf != NULL)
     {
-      if (filter->crtc  != NULL)  nonnulls |= 1;
-      if (filter->class != NULL)  nonnulls |= 2;
-      if (filter->ramps != NULL)  nonnulls |= 4;
+      if (this->crtc  != NULL)  nonnulls |= 1;
+      if (this->class != NULL)  nonnulls |= 2;
+      if (this->ramps != NULL)  nonnulls |= 4;
       *(buf + off) = nonnulls;
     }
   off += 1;
   
   if (buf != NULL)
-    *(int64_t*)(buf + off) = filter->priority;
+    *(int64_t*)(buf + off) = this->priority;
   off += sizeof(int64_t);
   
   if (buf != NULL)
-    *(enum lifespan*)(buf + off) = filter->lifespan;
+    *(enum lifespan*)(buf + off) = this->lifespan;
   off += sizeof(enum lifespan);
   
-  if (filter->crtc != NULL)
+  if (this->crtc != NULL)
     {
-      n = strlen(filter->crtc) + 1;
+      n = strlen(this->crtc) + 1;
       if (buf != NULL)
-	memcpy(buf + off, filter->crtc, n);
+	memcpy(buf + off, this->crtc, n);
       off += n;
     }
   
-  if (filter->class != NULL)
+  if (this->class != NULL)
     {
-      n = strlen(filter->class) + 1;
+      n = strlen(this->class) + 1;
       if (buf != NULL)
-	memcpy(buf + off, filter->class, n);
+	memcpy(buf + off, this->class, n);
       off += n;
     }
   
-  if (filter->ramps != NULL)
+  if (this->ramps != NULL)
     {
       if (buf != NULL)
-	memcpy(buf + off, filter->ramps, ramps_size);
+	memcpy(buf + off, this->ramps, ramps_size);
       off += n;
     }
   
@@ -96,14 +97,14 @@ size_t filter_marshal(const struct filter* filter, char* buf, size_t ramps_size)
 
 
 /**
- * Unmarshal a filter.
+ * Unmarshal a filter
  * 
- * @param   filter      Output for the filter, `NULL` to skip unmarshalling
+ * @param   this        Output for the filter
  * @param   buf         Buffer with the marshalled filter
- * @param   ramps_size  The byte-size of `filter->ramps`
+ * @param   ramps_size  The byte-size of `this->ramps`
  * @return              The number of unmarshalled bytes, 0 on error
  */
-size_t filter_unmarshal(struct filter* filter, const char* buf, size_t ramps_size)
+size_t filter_unmarshal(struct filter* this, const char* buf, size_t ramps_size)
 {
   size_t off = 0, n;
   char nonnulls = 0;
@@ -111,25 +112,20 @@ size_t filter_unmarshal(struct filter* filter, const char* buf, size_t ramps_siz
   nonnulls = *(buf + off);
   off += 1;
   
-  if (filter != NULL)
-    {
-      filter->crtc  = NULL;
-      filter->class = NULL;
-      filter->ramps = NULL;
-    }
+  this->crtc  = NULL;
+  this->class = NULL;
+  this->ramps = NULL;
   
-  if (filter != NULL)
-    filter->priority = *(int64_t*)(buf + off);
+  this->priority = *(int64_t*)(buf + off);
   off += sizeof(int64_t);
   
-  if (filter != NULL)
-    filter->lifespan = *(enum lifespan*)(buf + off);
+  this->lifespan = *(enum lifespan*)(buf + off);
   off += sizeof(enum lifespan);
   
   if (nonnulls & 1)
     {
       n = strlen(buf + off) + 1;
-      if ((filter != NULL) && (!(filter->crtc = memdup(buf + off, n))))
+      if (!(this->crtc = memdup(buf + off, n)))
 	goto fail;
       off += n;
     }
@@ -137,14 +133,14 @@ size_t filter_unmarshal(struct filter* filter, const char* buf, size_t ramps_siz
   if (nonnulls & 2)
     {
       n = strlen(buf + off) + 1;
-      if ((filter != NULL) && (!(filter->class = memdup(buf + off, n))))
+      if (!(this->class = memdup(buf + off, n)))
 	goto fail;
       off += n;
     }
   
   if (nonnulls & 4)
     {
-      if ((filter != NULL) && (!(filter->ramps = memdup(buf + off, ramps_size))))
+      if (!(this->ramps = memdup(buf + off, ramps_size)))
 	goto fail;
       off += n;
     }
@@ -152,9 +148,9 @@ size_t filter_unmarshal(struct filter* filter, const char* buf, size_t ramps_siz
   return off;
   
  fail:
-  free(filter->crtc);
-  free(filter->class);
-  free(filter->ramps);
+  free(this->crtc);
+  free(this->class);
+  free(this->ramps);
   return 0;
 }