/*
 * Copyright (C) 1998 Spizella Software
 *                    All rights reserved.
 *
 * Programmer:  Robb Matzke <robb@arborea.spizella.com>
 *              Thursday, January 15, 1998
 *
 * Purpose:     Provides I/O facilities for multi-dimensional arrays of bytes
 *              stored with various layout policies.
 */
#include <H5private.h>
#include <H5Dprivate.h>
#include <H5Eprivate.h>
#include <H5Fprivate.h>
#include <H5MFprivate.h>
#include <H5Oprivate.h>

/* Interface initialization */
#define PABLO_MASK      H5F_arr_mask
#define INTERFACE_INIT  NULL
static intn             interface_initialize_g = FALSE;

/*-------------------------------------------------------------------------
 * Function:    H5F_arr_create
 *
 * Purpose:     Creates an array of bytes. When called to create an array of
 *              some type, the fastest varying dimension corresponds to an
 *              instance of that type.  That is, a 10x20 array of int32 is
 *              really a 10x20x4 array of bytes.
 *
 * Return:      Success:        SUCCEED
 *
 *              Failure:        FAIL
 *
 * Programmer:  Robb Matzke
 *              Friday, January 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5F_arr_create(H5F_t *f, struct H5O_layout_t *layout /*in,out */ )
{
    intn                    i;
    size_t                  nbytes;

    FUNC_ENTER(H5F_arr_create, FAIL);

    /* check args */
    assert(f);
    assert(layout);
    H5F_addr_undef(&(layout->addr));    /*just in case we fail */

    switch (layout->type) {
    case H5D_CONTIGUOUS:
        /* Reserve space in the file for the entire array */
        for (i = 0, nbytes = 1; i < layout->ndims; i++)
            nbytes *= layout->dim[i];
        assert(nbytes > 0);
        if (H5MF_alloc(f, H5MF_RAW, nbytes, &(layout->addr) /*out */ ) < 0) {
            HRETURN_ERROR(H5E_IO, H5E_NOSPACE, FAIL,
                          "unable to reserve file space");
        }
        break;

    case H5D_CHUNKED:
        /* Create the root of the B-tree that describes chunked storage */
        if (H5F_istore_create(f, layout /*out */ ) < 0) {
            HRETURN_ERROR(H5E_IO, H5E_CANTINIT, FAIL,
                          "unable to initialize chunked storage");
        }
        break;

    default:
        assert("not implemented yet" && 0);
        HRETURN_ERROR(H5E_IO, H5E_UNSUPPORTED, FAIL,
                      "unsupported storage layout");
        break;
    }

    FUNC_LEAVE(SUCCEED);
}

/*-------------------------------------------------------------------------
 * Function:    H5F_arr_read
 *
 * Purpose:     Reads a hyperslab of a file byte array into a byte array in
 *              memory which has the same dimensions as the hyperslab.
 *
 * Return:      Success:        SUCCEED
 *
 *              Failure:        FAIL
 *
 * Programmer:  Robb Matzke
 *              Friday, January 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t 
H5F_arr_read(H5F_t *f, const struct H5O_layout_t *layout,
             const size_t offset[], const size_t size[],
             void *buf /*out */ )
{
    intn                    i;
    size_t                  nbytes;
    size_t                  zero_offset[H5O_LAYOUT_NDIMS];

    FUNC_ENTER(H5F_arr_read, FAIL);

    /* Check args */
    assert(f);
    assert(layout);
    if (!offset) {
        HDmemset(zero_offset, 0, sizeof zero_offset);
        offset = zero_offset;
    }
    assert(size);
    assert(buf);

    switch (layout->type) {
    case H5D_CONTIGUOUS:
        /*
         * We currently only support complete I/O.
         */
        for (i = 0; i < layout->ndims; i++) {
            assert(0 == offset[i]);
            assert(size[i] == layout->dim[i]);
        }
        for (i = 0, nbytes = 1; i < layout->ndims; i++)
            nbytes *= layout->dim[i];
        if (H5F_block_read(f, &(layout->addr), nbytes, buf) < 0) {
            HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
        }
        break;

    case H5D_CHUNKED:
        if (H5F_istore_read(f, layout, offset, size, buf) < 0) {
            HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "chunked read failed");
        }
        break;

    default:
        assert("not implemented yet" && 0);
        HRETURN_ERROR(H5E_IO, H5E_UNSUPPORTED, FAIL,
                      "unsupported storage layout");
        break;
    }

    FUNC_LEAVE(SUCCEED);
}

/*-------------------------------------------------------------------------
 * Function:    H5F_arr_write
 *
 * Purpose:     Writes an array to a hyperslab of a file byte array.  The
 *              memory array and the hyperslab are the same size.
 *
 * Return:      Success:        SUCCEED
 *
 *              Failure:        FAIL
 *
 * Programmer:  Robb Matzke
 *              Friday, January 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t 
H5F_arr_write(H5F_t *f, const struct H5O_layout_t *layout,
              const size_t offset[], const size_t size[],
              const void *buf)
{
    intn                    i;
    size_t                  nbytes;

    FUNC_ENTER(H5F_arr_write, FAIL);

    /* Check args */
    assert(f);
    assert(layout);
    assert(offset);
    assert(size);
    assert(buf);

    switch (layout->type) {
    case H5D_CONTIGUOUS:
        /*
         * We currently only support complete I/O.
         */
        for (i = 0; i < layout->ndims; i++) {
            assert(0 == offset[i]);
            assert(size[i] == layout->dim[i]);
        }
        for (i = 0, nbytes = 1; i < layout->ndims; i++)
            nbytes *= layout->dim[i];
        if (H5F_block_write(f, &(layout->addr), nbytes, buf) < 0) {
            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
        }
        break;

    case H5D_CHUNKED:
        if (H5F_istore_write(f, layout, offset, size, buf) < 0) {
            HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "chunked write failed");
        }
        break;

    default:
        assert("not implemented yet" && 0);
        HRETURN_ERROR(H5E_IO, H5E_UNSUPPORTED, FAIL,
                      "unsupported storage layout");
        break;
    }

    FUNC_LEAVE(SUCCEED);
}