/* AUTORIGHTS
Copyright (C) 2007 Princeton University
      
This file is part of Ferret Toolkit.

Ferret Toolkit is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

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 <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include <cass.h>

//#define barrier() __asm__ __volatile__("": : :"memory")
#define barrier()


void  __matrix_check (void **matrix)
{
	char data;
	cass_size_t width, i, j;
	assert(matrix[1] != NULL);
	width = matrix[1] - matrix[0];
	i = 2;
	while (matrix[i] != NULL)
	{
		assert(matrix[i] - matrix[i-1] == width);
		i++;
	}
	i--;
	for (j = 0; j < width; j++)
	{
		data = ((char *)matrix[i])[j];
		barrier();
		((char *)matrix[i])[j] = data;
	}
}

cass_size_t __matrix_col (void **data, cass_size_t size)
{
	assert(data[1] != NULL);
	return (data[1] - data[0]) / size;
}

cass_size_t __matrix_row (void **data)
{
	cass_size_t i = 0;
	while (data[i] != NULL) i++;
	return i;
}

void **__array2matrix (cass_size_t row, cass_size_t col, cass_size_t size, void *data)
{
	cass_size_t i;
	void **idx = (void **)malloc((row + 1) * sizeof (void *));
	assert(idx != NULL);
	idx[0] = data;
	assert(idx[0] != NULL);
	for (i = 1; i < row; i++)
	{
		idx[i] = idx[i-1] + col * size;
	}
	idx[row] = NULL;
	return idx;
}

void *__matrix2array (void **data)
{
	void *ret = data[0];
	free(data);
	return ret;
}

void **__matrix_alloc (cass_size_t row, cass_size_t col, cass_size_t size)
{
	cass_size_t i;
	void **idx = (void **)malloc((row + 1)* sizeof (void *));
	assert(idx != NULL);
	idx[0] = calloc(row * col, size);
	assert(idx[0] != NULL);
	for (i = 1; i <= row; i++)
	{
		idx[i] = idx[i-1] + col * size;
	}
	assert(idx[row] - idx[0] == row * col * size);
	idx[row] = NULL;
	return idx;
}

void __matrix_free (void **data)
{
	free(data[0]);
	free(data);
}


int matrix_load_stream (FILE *fin, cass_size_t *size, cass_size_t *row, cass_size_t *col, void ***matrix)
{
	void **_matrix;
	int ret;
	cass_size_t nmemb;
	*row = 0;
	*col = 0;
	*size = 0;
	ret = cass_read_size(size, 1, fin);
	ret += cass_read_size(row, 1, fin);
	ret += cass_read_size(col, 1, fin);
	assert(ret == 3);
	_matrix = __matrix_alloc(*row, *col, *size);
	assert(_matrix != NULL);
	nmemb = (*row) * (*col);
	ret = cass_read(_matrix[0], *size, nmemb, fin);
	assert(ret == nmemb);
	*matrix = _matrix;
	return 0;
}


int matrix_dump_stream (FILE *fout, cass_size_t size, cass_size_t row, cass_size_t col, void **matrix)
{
	int ret;
	cass_size_t nmemb;
	ret = cass_write_size(&size, 1, fout);
	ret += cass_write_size(&row, 1, fout);
	ret += cass_write_size(&col, 1, fout);
	assert(ret == 3);
	nmemb = row * col;
	ret = cass_write(matrix[0], size, nmemb, fout);
	assert(ret == nmemb);
	return 0;
}

int matrix_load_file (const char *filename, cass_size_t *size, cass_size_t *row, cass_size_t *col, void ***matrix)
{
	FILE *fin = fopen(filename, "r");
	assert(fin != NULL);
	matrix_load_stream(fin, size, row, col, matrix);
	fclose(fin);
	return 0;
}

int matrix_dump_file (const char *filename, cass_size_t size, cass_size_t row, cass_size_t col, void **matrix)
{
	FILE *fout = fopen(filename, "w");
	assert(fout != NULL);
	matrix_dump_stream(fout, size, row, col, matrix);
	fclose(fout);
	return 0;
}

int matrix_load_file_head (const char *filename, cass_size_t *size, cass_size_t *row, cass_size_t *col)
{
	FILE *fin = fopen(filename, "rb");
	int ret;
	assert(fin != NULL);
	*row = *col = *size = 0;
	ret = cass_read_size(size, 1, fin);
	ret += cass_read_size(row, 1, fin);
	ret += cass_read_size(col, 1, fin);
	assert(ret == 3);
	fclose(fin);
	return 0;
}

void **__matrix_dup (cass_size_t row, cass_size_t col, cass_size_t size, void **data)
{
	void **ret = __matrix_alloc(row, col, size);
	memcpy(ret[0], data[0], row * col * size);
	return ret;
}

void ***__matrix3_alloc (cass_size_t num, cass_size_t row, cass_size_t col, cass_size_t size)
{
	void ***ret;
	int i;
	ret = (void ***)calloc(num+1, sizeof(void **));
	for (i = 0; i < num; i++)
	{
		ret[i] = __matrix_alloc(row, col, size);
		assert(ret[i] != NULL);
	}
	ret[num] = NULL;
	return ret;
}

void __matrix3_free (void ***data)
{
	int i = 0;
	for (;;)
	{
		if (data[i] == NULL) break;
		__matrix_free(data[i]);
		i++;
	}
	free(data);
}