/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of HDF5.  The full HDF5 copyright notice, including     *
 * terms governing use, modification, and redistribution, is contained in    *
 * the LICENSE file, which can be found at the root of the source code       *
 * distribution tree, or in https://www.hdfgroup.org/licenses.               *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
 * Module Info: This module contains the functionality for setting & querying
 *      the datatype byte order for the H5T interface.
 */

/****************/
/* Module Setup */
/****************/

#include "H5Tmodule.h" /* This source code file is part of the H5T module */

/***********/
/* Headers */
/***********/
#include "H5private.h"  /* Generic Functions			*/
#include "H5Eprivate.h" /* Error handling		  	*/
#include "H5Iprivate.h" /* IDs			  		*/
#include "H5Tpkg.h"     /* Datatypes				*/

/****************/
/* Local Macros */
/****************/

/******************/
/* Local Typedefs */
/******************/

/********************/
/* Package Typedefs */
/********************/

/********************/
/* Local Prototypes */
/********************/
static herr_t H5T__set_order(H5T_t *dtype, H5T_order_t order);

/*********************/
/* Public Variables */
/*********************/

/*********************/
/* Package Variables */
/*********************/

/*****************************/
/* Library Private Variables */
/*****************************/

/*******************/
/* Local Variables */
/*******************/

/*-------------------------------------------------------------------------
 * Function:	H5Tget_order
 *
 * Purpose:	Returns the byte order of a datatype.
 *
 * Return:	Success:	A byte order constant.  If the type is compound
 *				and its members have mixed orders, this function
 *				returns H5T_ORDER_MIXED.
 *		Failure:	H5T_ORDER_ERROR (Negative)
 *
 *-------------------------------------------------------------------------
 */
H5T_order_t
H5Tget_order(hid_t type_id)
{
    H5T_t      *dt;        /* Datatype to query */
    H5T_order_t ret_value; /* Return value */

    FUNC_ENTER_API(H5T_ORDER_ERROR)

    /* Check args */
    if (NULL == (dt = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
        HGOTO_ERROR(H5E_DATATYPE, H5E_BADTYPE, H5T_ORDER_ERROR, "not a datatype");

    /* Get order */
    if (H5T_ORDER_ERROR == (ret_value = H5T_get_order(dt)))
        HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, H5T_ORDER_ERROR, "can't get order for specified datatype");

done:
    FUNC_LEAVE_API(ret_value)
} /* end H5Tget_order() */

/*-------------------------------------------------------------------------
 * Function:	H5T_get_order
 *
 * Purpose:	Returns the byte order of a datatype.
 *
 * Return:	Success:	A byte order constant
 *		Failure:	H5T_ORDER_ERROR (Negative)
 *
 *-------------------------------------------------------------------------
 */
H5T_order_t
H5T_get_order(const H5T_t *dtype)
{
    H5T_order_t ret_value = H5T_ORDER_NONE; /* Return value */

    FUNC_ENTER_NOAPI(H5T_ORDER_ERROR)

    /* Defer to parent */
    while (dtype->shared->parent)
        dtype = dtype->shared->parent;

    /* Set order for atomic type. */
    if (H5T_IS_ATOMIC(dtype->shared))
        ret_value = dtype->shared->u.atomic.order;
    else {
        /* Check for compound datatype */
        if (H5T_COMPOUND == dtype->shared->type) {
            H5T_order_t memb_order = H5T_ORDER_NONE;
            int         nmemb; /* Number of members in compound & enum types */
            int         i;     /* Local index variable */

            /* Retrieve the number of members */
            if ((nmemb = H5T_get_nmembers(dtype)) < 0)
                HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_ORDER_ERROR,
                            "can't get number of members from compound data type");

            /* Get order for each compound member type. */
            for (i = 0; i < nmemb; i++) {
                /* Get order for member */
                if ((memb_order = H5T_get_order(dtype->shared->u.compnd.memb[i].type)) == H5T_ORDER_ERROR)
                    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTGET, H5T_ORDER_ERROR,
                                "can't get order for compound member");

                /* Ignore the H5T_ORDER_NONE, write down the first non H5T_ORDER_NONE order. */
                if (memb_order != H5T_ORDER_NONE && ret_value == H5T_ORDER_NONE)
                    ret_value = memb_order;

                /* If the orders are mixed, stop the loop and report it.
                 * (H5T_ORDER_NONE is ignored)
                 */
                if (memb_order != H5T_ORDER_NONE && ret_value != H5T_ORDER_NONE && memb_order != ret_value) {
                    ret_value = H5T_ORDER_MIXED;
                    break;
                } /* end if */
            }     /* end for */
        }         /* end if */
    }             /* end else */

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5T_get_order() */

/*-------------------------------------------------------------------------
 * Function:	H5Tset_order
 *
 * Purpose:	Sets the byte order for a datatype.
 *
 * Notes:	There are some restrictions on this operation:
 *		1. For enum type, members shouldn't be defined yet.
 *		2. H5T_ORDER_NONE only works for reference and fixed-length
 *			string.
 *		3. For opaque type, the order will be ignored.
 *		4. For compound type, all restrictions above apply to the
 *			members.
 *
 * Return:	Non-negative on success/Negative on failure
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5Tset_order(hid_t type_id, H5T_order_t order)
{
    H5T_t *dt        = NULL;    /* Datatype to modify */
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_API(FAIL)

    /* Check args */
    if (NULL == (dt = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
        HGOTO_ERROR(H5E_DATATYPE, H5E_BADTYPE, FAIL, "not a datatype");
    if (order < H5T_ORDER_LE || order > H5T_ORDER_NONE || order == H5T_ORDER_MIXED)
        HGOTO_ERROR(H5E_DATATYPE, H5E_BADVALUE, FAIL, "illegal byte order");
    if (NULL != dt->vol_obj)
        HGOTO_ERROR(H5E_ARGS, H5E_CANTSET, FAIL, "datatype is already committed");
    if (H5T_STATE_TRANSIENT != dt->shared->state)
        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype is read-only");

    /* Call internal routine to set the order */
    if (H5T__set_order(dt, order) < 0)
        HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "can't set order");

done:
    FUNC_LEAVE_API(ret_value)
} /* end H5Tset_order() */

/*-------------------------------------------------------------------------
 * Function:	H5T__set_order
 *
 * Purpose:	Private function to set the byte order for a datatype.
 *
 * Return:	Non-negative on success/Negative on failure
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5T__set_order(H5T_t *dtype, H5T_order_t order)
{
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    if (H5T_ENUM == dtype->shared->type && dtype->shared->u.enumer.nmembs > 0)
        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "operation not allowed after enum members are defined");

    /* For derived data type, defer to parent */
    while (dtype->shared->parent)
        dtype = dtype->shared->parent;

    /* Check for setting order on inappropriate datatype */
    if (order == H5T_ORDER_NONE && !(H5T_REFERENCE == dtype->shared->type ||
                                     H5T_OPAQUE == dtype->shared->type || H5T_IS_FIXED_STRING(dtype->shared)))
        HGOTO_ERROR(H5E_DATATYPE, H5E_BADVALUE, FAIL, "illegal byte order for type");

    /* For atomic data type */
    if (H5T_IS_ATOMIC(dtype->shared))
        dtype->shared->u.atomic.order = order;
    else {
        /* Check for compound datatype */
        if (H5T_COMPOUND == dtype->shared->type) {
            int nmemb; /* Number of members in type */
            int i;     /* Local index variable */

            /* Retrieve the number of fields in the compound datatype */
            if ((nmemb = H5T_get_nmembers(dtype)) < 0)
                HGOTO_ERROR(H5E_DATATYPE, H5E_CANTGET, FAIL,
                            "can't get number of members from compound data type");

            /* Check for uninitialized compound datatype */
            if (nmemb == 0)
                HGOTO_ERROR(H5E_DATATYPE, H5E_UNINITIALIZED, FAIL, "no member is in the compound data type");

            /* Loop through all fields of compound type, setting the order */
            for (i = 0; i < nmemb; i++)
                if (H5T__set_order(dtype->shared->u.compnd.memb[i].type, order) < 0)
                    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "can't set order for compound member");
        } /* end if */
    }     /* end else */

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5T__set_order() */
