*

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and/or associated documentation files (the

 * "Materials"), to deal in the Materials without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Materials, and to

 * permit persons to whom the Materials are furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Materials.

 *

 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

 */

#ifdef __cplusplus

extern "C" {

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include "owfattributes.h"

#include "owfmemory.h"

#define OWF_ATTRIB_RANGE_START            (0)

#define OWF_ATTRIB_RANGE_UNINITIALIZED    (-1)

static OWFint OWF_Attribute_Commit(OWF_ATTRIBUTE* aAttr, OWFint aDirtyFlag, OWFint aCopyTo,OWFint aCopyFrom);

 */

#define COND_FAIL_NR(ctx, condition, error) \

    if (!(condition)) { \

        if (ctx) { \

            (ctx)->last_error = error; \

        } \

        return; \

    }

#define COND_FAIL(ctx, condition, error, r) \

    if (!(condition)) { \

        if (ctx) { \

            (ctx)->last_error = error; \

        } \

        return r; \

    }

#define CHECK_INDEX_NR(ctx, index, error) \

    if (index < (ctx)->range_start || index > (ctx)->range_end) { \

        (ctx)->last_error = error; \

        return; \

    }

#define CHECK_INDEX(ctx, index, error, r) \

    if (index < (ctx)->range_start || index > (ctx)->range_end) { \

        (ctx)->last_error = error; \

        return r; \

    }

#define CHECK_BAD_NR(ctx, index) \

    CHECK_INDEX_NR(ctx, index, ATTR_ERROR_INVALID_ATTRIBUTE); \

    if ((ctx)->attributes[index-(ctx)->range_start].attr_info.type == AT_UNDEFINED) { \

        (ctx)->last_error = ATTR_ERROR_INVALID_ATTRIBUTE; \

        return; \

    }

#define CHECK_BAD(ctx, index, r) \

    CHECK_INDEX(ctx, index, ATTR_ERROR_INVALID_ATTRIBUTE, r); \

    if ((ctx)->attributes[index-(ctx)->range_start].attr_info.type == AT_UNDEFINED) { \

        (ctx)->last_error = ATTR_ERROR_INVALID_ATTRIBUTE; \

        return r; \

    }

#define SET_ERROR(ctx, err) \

    if ((ctx)->last_error == ATTR_ERROR_NONE) { \

        (ctx)->last_error = err; \

    }

/*

=============================================================================

ATTRIBUTE CONTEXT MANAGEMENT FUNCTIONS

=============================================================================

*/

/*!

 * \brief Initializes attribute context

 *

 * \param aContext Attribute context to initialize

 * \param aStart Attribute range start

 * \param aEnd Attribute range end. Must be greater than range start.

 *

 * \return ATTR_ERROR_INVALID_ARGUMENT

 * ATTR_ERROR_NO_MEMORY

 */

OWF_API_CALL void

OWF_AttributeList_Create(OWF_ATTRIBUTE_LIST* aContext,

                         OWFint aStart,

                         OWFint aEnd)

{

    OWF_ATTRIBUTE*          temp = NULL;

    COND_FAIL_NR(aContext, aEnd >= 0, ATTR_ERROR_INVALID_ARGUMENT);

    COND_FAIL_NR(aContext, aEnd >= aStart, ATTR_ERROR_INVALID_ARGUMENT);

    aContext->range_start = OWF_ATTRIB_RANGE_START;

    aContext->range_end = OWF_ATTRIB_RANGE_UNINITIALIZED;

    temp = (OWF_ATTRIBUTE*) xalloc(aEnd - aStart + 1, sizeof(OWF_ATTRIBUTE));

    COND_FAIL_NR(aContext, temp, ATTR_ERROR_NO_MEMORY);

    memset(aContext, 0, sizeof(OWF_ATTRIBUTE_LIST));

    aContext->range_start = aStart;

    aContext->range_end = aEnd;

    aContext->attributes = temp;

    SET_ERROR(aContext, ATTR_ERROR_NONE);

    return;

}

/*!

 * \brief Destroy attribute context and free any resources (memory

 * blocks) allocated to it. All attributes are destroyed.

 *

 * \param aContext Attribute context to destroy

 *

 * \return ATTR_ERROR_INVALID_ARGUMENT

 * ATTR_ERROR_INVALID_CONTEXT

 */

OWF_API_CALL void

OWF_AttributeList_Destroy(OWF_ATTRIBUTE_LIST* aContext)

{

    OWFint                 count = 0;

    OWFint                 at = 0;

    OWFint                 cache = 0;

    COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);

    count = aContext->range_end - aContext->range_start;

    for (at = 0; at <= count; at++) {

        OWF_ATTRIBUTE* attr = &aContext->attributes[at];

        if (!attr->attr_info.readonly)

            {

            for (cache=0;cache<NUM_ATTR_VALUE_COPIES;cache++)

                {

                if (cache!=COMMITTED_ATTR_VALUE_INDEX)

                    {

                    xfree(attr->attr_value[cache].gen_ptr);

                    }

                }

            }

    }

    xfree(aContext->attributes);

    memset(aContext, 0, sizeof(OWF_ATTRIBUTE_LIST));

    SET_ERROR(aContext, ATTR_ERROR_NONE);

    return;

}

/*

 */

OWF_API_CALL OWF_ATTRIBUTE_LIST_STATUS

OWF_AttributeList_GetError(OWF_ATTRIBUTE_LIST* aContext)

{

    OWF_ATTRIBUTE_LIST_STATUS   error;

    if (!aContext) {

        return ATTR_ERROR_INVALID_ARGUMENT;

    }

    error = aContext->last_error;

    aContext->last_error = ATTR_ERROR_NONE;

    return error;

}

/*

=============================================================================

INITIALIZATION FUNCTIONS

=============================================================================

*/

static void OWF_Attribute_Init(OWF_ATTRIBUTE_LIST* aContext,

                               OWFint aName,

                               OWF_ATTRIBUTE_TYPE aType,

                               OWFint aLength,

                               void* aValue,

                               OWFboolean aRdOnly)

{

    OWF_ATTRIBUTE*          attr = NULL;

    void*                   cache = NULL;

    OWFint                  itemSize;

    OWFint                  arraySize;

    OWFint                  copy;

    COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);

    COND_FAIL_NR(aContext, aLength < MAX_ATTR_LENGTH, ATTR_ERROR_CANT_HANDLE);

    COND_FAIL_NR(aContext, aType != AT_UNDEFINED, ATTR_ERROR_INVALID_ARGUMENT);

    attr = &aContext->attributes[index];

    memset(attr, 0, sizeof(OWF_ATTRIBUTE));

    /* when allocin', size DOES matter */

    if (aType == AT_INTEGER || aType == AT_BOOLEAN) {

        itemSize = sizeof(OWFint);

    } else {

        itemSize = sizeof(OWFfloat);

    }

    arraySize=itemSize*aLength;

    /* don't allocate cache for read-only 'butes */

    attr->attr_info.type        = aType;

    attr->attr_info.length      = aLength;

    attr->attr_info.readonly    = aRdOnly;

    attr->attr_info.size        = itemSize;

    if (aRdOnly)

        {

        for (copy=0;copy<NUM_ATTR_VALUE_COPIES;copy++)

            {

            attr->attr_value[copy].gen_ptr = aValue;

            }

        }

    else

        {

        for (copy=0;copy<NUM_ATTR_VALUE_COPIES;copy++)

            {

            if (copy==COMMITTED_ATTR_VALUE_INDEX)

                {

                 attr->attr_value[COMMITTED_ATTR_VALUE_INDEX].gen_ptr = aValue;

                }

            else

                {

                cache = xalloc(arraySize,1);

                COND_FAIL_NR(aContext, NULL != cache, ATTR_ERROR_NO_MEMORY);

                attr->attr_value[copy].gen_ptr = cache;

                }

             }

       }

    SET_ERROR(aContext, ATTR_ERROR_NONE);

}

/*

 * \brief Intialize integer attribute

 *

 * \param aContext Attibute context

 * \param aName Attribute name

 * \param aValue Attribute initial value

 * \param aRdOnly Read-only flag

 *

 * \return ATTR_ERROR_INVALID_ARGUMENT

 * ATTR_ERROR_INVALID_ATTRIBUTE

 * ATTR_ERROR_INVALID_CONTEXT

 */

OWF_API_CALL void

OWF_Attribute_Initi(OWF_ATTRIBUTE_LIST* aContext,

                    OWFint aName,

                    OWF_INT_REF aValue,

                    OWFboolean aRdOnly)

{

    OWF_Attribute_Init(aContext, aName, AT_INTEGER, 1, aValue, aRdOnly);

}

/*

 * \brief Initialize float attribute

 *

 * \param aContext Attribute context

 * \param aName Attribute name

 * \param aValue Initial value for attribute

 * \param aRdOnly Read-only flag

 *

 * \return ATTR_ERROR_INVALID_ARGUMENT

 * ATTR_ERROR_INVALID_ATTRIBUTE

 * ATTR_ERROR_INVALID_CONTEXT

 */

OWF_API_CALL void

OWF_Attribute_Initf(OWF_ATTRIBUTE_LIST* aContext,

                    OWFint aName,

                    OWF_FLOAT_REF aValue,

                    OWFboolean aRdOnly)

{

    OWF_Attribute_Init(aContext, aName, AT_FLOAT, 1, aValue, aRdOnly);

}

/*

 * \brief Initialize boolean attribute

 *

 * \param aContext Attribute context

 * \param aName Attribute name

 * \param aValue Initial value for attribute

 * \param aRdOnly Read-only flag

 *

 * \return ATTR_ERROR_INVALID_ARGUMENT

 * ATTR_ERROR_INVALID_ATTRIBUTE

 * ATTR_ERROR_INVALID_CONTEXT

 */

OWF_API_CALL void

OWF_Attribute_Initb(OWF_ATTRIBUTE_LIST* aContext,

                    OWFint aName,

                    OWF_BOOL_REF aValue,

                    OWFboolean aRdOnly)

{

    OWF_Attribute_Init(aContext, aName, AT_BOOLEAN, 1, aValue, aRdOnly);

}

/*

 * \brief Initialize vector attribute

 *

 * \param aContext Attribute context

 * \param aName Attribute name

 * \param aLength Attribute (vector) length

 * \param aValues Initial value(s) for attribute

 * \param aRdOnly Read-only flag

 *

 * \return ATTR_ERROR_INVALID_ARGUMENT

 * ATTR_ERROR_INVALID_ATTRIBUTE

 * ATTR_ERROR_INVALID_CONTEXT

 * ATTR_ERROR_CANT_HANDLE

 */

OWF_API_CALL void

OWF_Attribute_Initiv(OWF_ATTRIBUTE_LIST* aContext,

                     OWFint aName,

                     OWFint aLength,

                     OWF_INT_VECTOR_REF aValues,

                     OWFboolean aRdOnly)

{

    OWF_Attribute_Init(aContext, aName, AT_INTEGER, aLength, aValues, aRdOnly);

}

/*

 * \brief Initialize vector attribute

 *

 * \param aContext Attribute context

 * \param aName Attribute name

 * \param aLength Attribute (vector) length

 * \param aValues Initial value(s) for attributes

 * \param aRdOnly Read-only flag

 *

 * \return

 */

OWF_API_CALL void

OWF_Attribute_Initfv(OWF_ATTRIBUTE_LIST* aContext,

                     OWFint aName,

                     OWFint aLength,

                     OWF_FLOAT_VECTOR_REF aValues,

                     OWFboolean aRdOnly)

{

    OWF_Attribute_Init(aContext, aName, AT_FLOAT, aLength, aValues, aRdOnly);

}

/*

=============================================================================

GETTER FUNCTIONS

=============================================================================

*/

/*

 * \brief Get attribute integer value.

 *

 * \param aContext Attribute context

 * \param aName Attribute name

 *

 * \return Attribute integer value (floats are floor()ed). For vector

 * attributes the return value will be error ATTR_ERROR_INVALID_TYPE.

 * ATTR_ERROR_INVALID_ATTRIBUTE

 * ATTR_ERROR_INVALID_CONTEXT

 */

OWF_API_CALL OWFint

OWF_Attribute_GetValuei(OWF_ATTRIBUTE_LIST* aContext,

                        OWFint aName)

{

    OWFint                  index = 0;

    OWF_ATTRIBUTE*          attr = 0;

    OWFint                  result = 0;

              aContext->attributes,

              ATTR_ERROR_INVALID_CONTEXT,

              0);

    index = aName - aContext->range_start;

    attr = &aContext->attributes[index];

    COND_FAIL(aContext,

              1 == attr->attr_info.length,

              ATTR_ERROR_INVALID_TYPE,

              0);

    SET_ERROR(aContext, ATTR_ERROR_NONE);

    switch (attr->attr_info.type) {

        case AT_FLOAT: {

            result = floor(attr->attr_value[WORKING_ATTR_VALUE_INDEX].float_value[0]);

            break;

        }

        case AT_INTEGER:

        case AT_BOOLEAN: {

            result = attr->attr_value[WORKING_ATTR_VALUE_INDEX].int_value[0];

            break;

        }

        default: {

            SET_ERROR(aContext, ATTR_ERROR_INVALID_TYPE);

            break;

        }

    }

    return result;

}

/*

 * \brief Return boolean attribute value

 *

 * \param aContext Attribute context

 * \param aName Attribute name

 *

 * \return Attribute value

 * ATTR_ERROR_INVALID_ATTRIBUTE

 * ATTR_ERROR_INVALID_TYPE

 */

OWF_API_CALL OWFboolean

OWF_Attribute_GetValueb(OWF_ATTRIBUTE_LIST* aContext,

                        OWFint aName)

{

    /* boolean is stored as int, must cast */

    return (OWFboolean) OWF_Attribute_GetValuei(aContext, aName);

}

/*

 * \brief Get attribute float value

 *

 * \param aContext

 * \param aName

 * \param aValue

 *

 * \return Attribute

 */

OWF_API_CALL OWFfloat

OWF_Attribute_GetValuef(OWF_ATTRIBUTE_LIST* aContext,

                        OWFint aName)

{

    OWFint                 index = 0;

    OWF_ATTRIBUTE*          attr = NULL;

    OWFfloat                result = 0.f;

    COND_FAIL(aContext,

              aContext->attributes,

              ATTR_ERROR_INVALID_CONTEXT,

              0);

    index = aName - aContext->range_start;

    attr = &aContext->attributes[index];