serialize.c

/*
Author: Maximilian Huber
Copyright (C) 2018, TNG Technology Consulting GmbH

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along
 with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#include "serialize.h"

#include "monk.h"
#include "license.h"
#include "string_operations.h"
#include <stdio.h>
#include <errno.h>

/*
 * serialization
 */

int serializeToFile(Licenses* licenses, char* filename) {
  FILE* fp = fopen(filename, "w+");
  if (fp == NULL) {
    return 0;
  }
  int retCode = serialize(licenses, fp);
  fclose(fp);
  return retCode;
}

int serialize(Licenses* licenses, FILE* fp) {
  return serializeGArray(licenses->licenses, fp);
}

int serializeGArray(GArray* licenses, FILE* fp) {
  int retCode;
  for (guint i = 0; i < licenses->len; i++) {
    retCode = serializeOne(license_index(licenses, i), fp);
    if (retCode == 0) {
      return retCode;
    }
  }
  return 1;
}

int serializeOne(License* license, FILE* fp) {
  return serializeOneMeta(license, fp) &&
    serializeOneShortname(license, fp) &&
    serializeOneTokens(license->tokens, fp);
}

int serializeOneMeta(License* license, FILE* fp) {
  SerializingMeta meta = { .refId = license->refId,
                           .shortnameLen = strlen(license->shortname),
                           .tokensLen = license->tokens->len };

  return fwrite(&meta, sizeof(SerializingMeta), 1, fp) == 1;
}

int serializeOneShortname(License* license, FILE* fp) {
  return fprintf(fp, "%s", license->shortname) > 0;
}

int serializeOneTokens(GArray* tokens, FILE* fp) {
  for (guint i = 0; i < tokens->len; i++) {
    if (fwrite(tokens_index(tokens,i), sizeof(Token), 1, fp) != 1) {
      return 0;
    }
  }
  return 1;
}

/*
 * deserialization
 */

Licenses* deserializeFromFile(char* filename, unsigned minAdjacentMatches, unsigned maxLeadingDiff) {
  FILE* fp = fopen(filename, "r");
  if(fp == NULL) {
    exit(3);
  }
  Licenses* result = deserialize(fp, minAdjacentMatches, maxLeadingDiff);
  fclose(fp);
  return result;
}

Licenses* deserialize(FILE* fp, unsigned minAdjacentMatches, unsigned maxLeadingDiff) {
  GArray* licenses = g_array_new(TRUE, FALSE, sizeof(License));

  SerializingMeta meta;
  while (fread(&meta, sizeof(SerializingMeta), 1, fp) == 1) {
    License license = { .refId = meta.refId };

    license.shortname = calloc(1,(size_t) meta.shortnameLen + 1);
    if(fread(license.shortname, sizeof(char), meta.shortnameLen, fp) != meta.shortnameLen){
      strerror(errno);
    }

    license.tokens = deserializeTokens(fp, meta.tokensLen);

    g_array_append_vals(licenses, &license, 1);
  }

  return buildLicenseIndexes(licenses, minAdjacentMatches, maxLeadingDiff);
}

GArray* deserializeTokens(FILE* fp, guint tokensLen) {
  Token* freadResult = malloc(sizeof(Token) * tokensLen);
  if(fread(freadResult, sizeof(Token), tokensLen, fp) != tokensLen){
    strerror(errno);
  }

  GArray* tokens = g_array_new(FALSE, FALSE, sizeof(Token));
  g_array_append_vals(tokens,
                      freadResult,
                      tokensLen);
  free(freadResult);

  return tokens;
}