/*

* Copyright (c) 2000 - 2001 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "cxml_internal.h"

#include "nw_dom_attribute.h"

#include "nw_wbxml_dictionary.h"

#include "nw_tinydom.h"

#include "nw_string_string.h"

#include "nw_dom_wbxmltypes.h"

/*

 * ATTRIBUTE LIST HANDLE

 * is used to iterate over the list of attributes of an element

 */

/*

 * Allocates memory for NW_DOM_AttributeListIterator

 * Returns NULL in case of failure to do so

 */

NW_DOM_AttributeListIterator_t *

NW_DOM_AttributeListIterator_new(void)

{

  NW_DOM_AttributeListIterator_t *handle =

    (NW_DOM_AttributeListIterator_t *) 

    NW_Mem_Malloc(sizeof (NW_DOM_AttributeListIterator_t));

  if (handle == NULL)

    return NULL;

  handle->node = NULL;

  return handle;

}

/* 

 * Initializes an AttributeListIterator

 * Returns NW_STAT_SUCCESS

 */

NW_Status_t

NW_DOM_AttributeListIterator_initialize(NW_DOM_AttributeListIterator_t *handle)

{

  NW_ASSERT(handle != NULL);  

  handle->node = NULL;

  handle->attrListHandle.state = NW_STAT_SUCCESS;

  handle->attrListHandle.offset = 0;

  handle->attrListHandle.tiny_parser = NULL;

  handle->attrListHandle.context = NULL;

  return NW_STAT_SUCCESS;

}

NW_Status_t

NW_DOM_AttributeListIterator_delete(NW_DOM_AttributeListIterator_t *handle)

{

  NW_ASSERT(handle != NULL);

  NW_Mem_Free(handle);

  return NW_STAT_SUCCESS;

}

/*

 * Returns 

 *   NW_STAT_WBXML_ITERATE_MORE

 *   NW_STAT_WBXML_ITERATE_DONE

 *

 * MODIFIED attributeHandle

 */

EXPORT_C NW_Status_t

NW_DOM_AttributeListIterator_getNextAttribute(NW_DOM_AttributeListIterator_t* listHandle, 

                                              NW_DOM_AttributeHandle_t *attributeHandle)

{

  NW_TinyTree_Offset_t offset = 0;

  NW_TinyDom_Parser_t *parser = NULL;

  NW_ASSERT(listHandle != NULL);

  NW_ASSERT(listHandle->node != NULL);

  NW_ASSERT(attributeHandle != NULL);

  if (listHandle->attrListHandle.state == NW_STAT_WBXML_ITERATE_MORE){

    parser = listHandle->attrListHandle.tiny_parser;

    offset = NW_TinyDom_AttrListHandle_iterate(&listHandle->attrListHandle);

    if (offset != 0){

      NW_DOM_AttributeHandle_initWithOffset(attributeHandle, parser, offset);

      return NW_STAT_WBXML_ITERATE_MORE;

    }

  }

  /*

   * Once we are done iterating over the initial set of attributes, 

   * next attribute node is located. A reference to this node is kept,

   * so that in subsequent call to this method we can proceed from there

   */

  NW_ASSERT(listHandle->node != NULL);

  listHandle->node = NW_TinyTree_findNextSibling(listHandle->node);

  parser = listHandle->attrListHandle.tiny_parser;

  if (parser == NULL)

    return NW_STAT_FAILURE; 

  while (listHandle->node){

    if (NW_TinyDom_Node_getType(listHandle->node) == T_DOM_NODE_ATTR){

      NW_DOM_AttributeHandle_initWithNode(attributeHandle, parser, listHandle->node);          

      return NW_STAT_WBXML_ITERATE_MORE;  

    }

    listHandle->node = NW_TinyTree_findNextSibling(listHandle->node);

  }

  return NW_STAT_WBXML_ITERATE_DONE;

}

NW_DOM_AttrVal_t *

NW_DOM_AttrVal_new(void)

{

  return (NW_DOM_AttrVal_t *) NW_Mem_Malloc(sizeof (NW_DOM_AttrVal_t));

}

/*

 * Initializes an AttrVal of type NW_DOM_ATTR_VAL_STRING

 * Returns NW_STAT_SUCCESS

 */

EXPORT_C NW_Status_t

NW_DOM_AttrVal_initFromString (NW_DOM_AttrVal_t *val, 

                               NW_String_t * string)

{

  NW_Status_t status;

  NW_ASSERT(val != NULL);

  NW_ASSERT(string != NULL);

  status = NW_DOM_AttrVal_setType(val, NW_DOM_ATTR_VAL_STRING);

  if (status != NW_STAT_SUCCESS)

    return status;

  val->component.string = *string;

  return NW_STAT_SUCCESS;

}

/*

 * Initializes an AttrVal of type NW_WBXML_ATTR_COMPONENT_ENTITY

 * Returns NW_STAT_SUCCESS

 */

NW_Status_t

NW_DOM_AttrVal_initFromEntity (NW_DOM_AttrVal_t *val, 

                               NW_Uint32 entity)

{

  NW_ASSERT(val != NULL);

  val->type = NW_WBXML_ATTR_COMPONENT_ENTITY;

  val->component.entity = entity;

  return NW_STAT_SUCCESS;

}

/*

 Initializes an AttrVal of type NW_WBXML_ATTR_COMPONENT_EXT

 Returns NW_STAT_SUCCESS or NW_STAT_FAILURE if args are not valid.

 Makes a shallow copy of str.

 */

NW_Status_t

NW_DOM_AttrVal_initFromExtension (NW_DOM_AttrVal_t *val, 

                                  NW_Uint16 token, 

                                  NW_String_t *str)

{

  NW_Uint8 t; /* 8-bit token */

  NW_ASSERT(val != NULL);

  NW_ASSERT(token != 0);

  val->type = NW_WBXML_ATTR_COMPONENT_INVALID;

  t = (NW_Uint8)token;

  if ((t == NW_WBXML_EXT_0)

      || (t == NW_WBXML_EXT_1)

      || (t == NW_WBXML_EXT_2)

      || (t == NW_WBXML_EXT_T_0)

      || (t == NW_WBXML_EXT_T_1)

      || (t == NW_WBXML_EXT_T_2)

      || (t == NW_WBXML_EXT_I_0)

      || (t == NW_WBXML_EXT_I_1)

      || (t == NW_WBXML_EXT_I_2)) {

    if ((t != NW_WBXML_EXT_0)

        && (t != NW_WBXML_EXT_1)

        && (t != NW_WBXML_EXT_2)

        && (str->storage == NULL)) {

      return NW_STAT_FAILURE;

    }

  val->type = NW_WBXML_ATTR_COMPONENT_EXT;

    val->component.ext.type = NW_TINYDOM_EXTENSION_TYPE_NORMAL;

  val->component.ext.token = token;

    if ((t == NW_WBXML_EXT_0)

        || (t == NW_WBXML_EXT_1)

        || (t == NW_WBXML_EXT_2)) {

      NW_String_initialize(&(val->component.ext.value.string), NULL, 0);

    } else {

      /* struct assignment, shallow copy */

      val->component.ext.value.string = *str;

    }

  return NW_STAT_SUCCESS;

}

  return NW_STAT_FAILURE;

}

NW_Status_t

NW_DOM_AttrVal_initFromExtensionInt (NW_DOM_AttrVal_t* val,

                                     NW_Uint16 token,

                                     NW_Uint32 x)

{

  NW_Uint8 t = (NW_Uint8)token;

  NW_ASSERT(val != NULL);

  if ((t == NW_WBXML_EXT_T_0)

      || (t == NW_WBXML_EXT_T_1)

      || (t == NW_WBXML_EXT_T_2)) {

    val->type = NW_WBXML_ATTR_COMPONENT_EXT;

    val->component.ext.type = NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER;

    val->component.ext.token = token;

    val->component.ext.value.x = x;

    return NW_STAT_SUCCESS;

  }

  return NW_STAT_FAILURE;

}

/*

 * Initializes an AttrVal of type NW_WBXML_ATTR_COMPONENT_OPAQUE

 * Returns NW_STAT_SUCCESS

 */

NW_Status_t

NW_DOM_AttrVal_initFromOpaque (NW_DOM_AttrVal_t *val, 

                               NW_Uint32 length, 

                               NW_Byte* data)

{

  NW_ASSERT(val != NULL);

  NW_ASSERT(data != NULL);

  val->type = NW_WBXML_ATTR_COMPONENT_OPAQUE;

  val->component.opaque.data = data;

  val->component.opaque.length = length;

  return NW_STAT_SUCCESS;

}

/*

 * Initializes an AttrVal of type NW_WBXML_ATTR_COMPONENT_TOKEN

 * Returns NW_STAT_SUCCESS

 */

EXPORT_C NW_Status_t

NW_DOM_AttrVal_initFromToken (NW_DOM_AttrVal_t *val, NW_Uint16 token)

{

  NW_ASSERT(val != NULL); 

  val->type = NW_WBXML_ATTR_COMPONENT_TOKEN;

  val->component.value_token = (NW_Uint32)token;

  return NW_STAT_SUCCESS;

}

NW_Status_t

NW_DOM_AttrVal_delete (NW_DOM_AttrVal_t * attrVal)

{

  NW_ASSERT(attrVal != NULL);

  NW_Mem_Free(attrVal);

  return NW_STAT_SUCCESS;

}

/*

 * Returns the type of attribute value

 */

EXPORT_C NW_Uint16

NW_DOM_AttrVal_getType(NW_DOM_AttrVal_t *val)

{

  NW_ASSERT(val != NULL);

  switch(val->type)

  {

    case NW_WBXML_ATTR_COMPONENT_EXT:

      return NW_DOM_ATTR_VAL_EXTENSION;

    case NW_WBXML_ATTR_COMPONENT_STRING:

      return NW_DOM_ATTR_VAL_STRING;

    case NW_WBXML_ATTR_COMPONENT_ENTITY:

      return NW_DOM_ATTR_VAL_ENTITY;

    case NW_WBXML_ATTR_COMPONENT_TOKEN:

      return NW_DOM_ATTR_VAL_TOKEN;

    case NW_WBXML_ATTR_COMPONENT_OPAQUE:

      return NW_DOM_ATTR_VAL_OPAQUE;

    default: 

      return 0;

  }

}

/*

 * Sets the type of attribute value

 * Returns NW_STAT_SUCCESS

 */

/* TBD This is a very dangerous function and should be made internal

   use only (i.e., static)! */

NW_Status_t

NW_DOM_AttrVal_setType(NW_DOM_AttrVal_t *val, 

                       NW_Uint16 type)

{

  NW_ASSERT(val != NULL);

  switch(type)

  {

    case NW_DOM_ATTR_VAL_EXTENSION:

      val->type = NW_WBXML_ATTR_COMPONENT_EXT;

      break;

    case NW_DOM_ATTR_VAL_STRING:

      val->type = NW_WBXML_ATTR_COMPONENT_STRING;

      break;

    case NW_DOM_ATTR_VAL_ENTITY:

      val->type = NW_WBXML_ATTR_COMPONENT_ENTITY;

      break;

    case NW_DOM_ATTR_VAL_TOKEN:

      val->type = NW_WBXML_ATTR_COMPONENT_TOKEN;

      break;

    case NW_DOM_ATTR_VAL_OPAQUE:

      val->type = NW_WBXML_ATTR_COMPONENT_OPAQUE;

      break;

    default:

      return NW_STAT_BAD_INPUT_PARAM;

  }

  return NW_STAT_SUCCESS;

}

/*

 * Returns

 *    NW_STAT_WBXML_ERROR_CHARSET_UNSUPPORTED - invalid encoding

 *    NW_STAT_DOM_NO_STRING_RETURNED - if the type of AttrVal was invalid

 *    NW_STAT_SUCCESS

 * 

 *  MODIFIED string (the value of NW_DOM_AttrVal)

 */

EXPORT_C NW_Status_t

NW_DOM_AttrVal_toString(NW_DOM_AttrVal_t *av, 

                        NW_String_t * string, 

                        NW_Uint32 encoding)

{

  NW_Status_t status;

  NW_ASSERT(av != NULL);

  NW_ASSERT(string != NULL);

  NW_String_initialize(string, NULL, 0);

  if ((NW_String_charsetValid(encoding)) != NW_STAT_SUCCESS)

    return NW_STAT_WBXML_ERROR_CHARSET_UNSUPPORTED;

  switch (NW_DOM_AttrVal_getType(av))

  {

    case NW_DOM_ATTR_VAL_TOKEN:

      status = NW_String_tokenToString(av->component.value_token, string, encoding);

      if(status != NW_STAT_SUCCESS){

        return NW_STAT_DOM_NO_STRING_RETURNED;

      }

      return NW_STAT_SUCCESS;

    case NW_DOM_ATTR_VAL_STRING:

      {

        NW_Byte *storage = av->component.string.storage;

        status = NW_String_initialize(string, storage, encoding);

        if(status != NW_STAT_SUCCESS){

          return NW_STAT_DOM_NO_STRING_RETURNED;

        }

        return NW_STAT_SUCCESS; 

      }

    case NW_DOM_ATTR_VAL_ENTITY:

      status = NW_String_entityToString(av->component.entity,

                                        string, encoding);

      if(status != NW_STAT_SUCCESS){

        return NW_STAT_DOM_NO_STRING_RETURNED;

      }

      return NW_STAT_SUCCESS; 

    case NW_DOM_ATTR_VAL_OPAQUE:

      return NW_STAT_DOM_NO_STRING_RETURNED;

    case NW_DOM_ATTR_VAL_EXTENSION:

      {

        NW_Uint8 t; /* 8-bit token */

        t = (NW_Uint8)(av->component.ext.token);

        if ((t == NW_WBXML_EXT_0)

            || (t == NW_WBXML_EXT_1)

            || (t == NW_WBXML_EXT_2)) {

          return NW_STAT_DOM_NO_STRING_RETURNED;

        }

        if (av->component.ext.value.string.storage == NULL) {

          return NW_STAT_DOM_NO_STRING_RETURNED;

        }

        /* struct assignment, shallow copy */

        *string = av->component.ext.value.string;

        return NW_STAT_SUCCESS; 

      }

    default:

      return NW_STAT_DOM_NO_STRING_RETURNED;

  }

}

/*

 * If attribute value is of type NW_DOM_ATTR_VAL_ENTITY 

 * return the associated entity

 */

NW_Uint32

NW_DOM_AttrVal_getEntity(NW_DOM_AttrVal_t *val)

{

  NW_ASSERT(val != NULL);

  if (NW_DOM_AttrVal_getType(val) != NW_DOM_ATTR_VAL_ENTITY)

    return val->component.entity;

  return 0;

}

NW_Status_t

NW_DOM_AttrVal_getExtensionToken(NW_DOM_AttrVal_t* val,

                                 NW_Uint16* token)

{

  if (NW_DOM_AttrVal_getType(val) != NW_DOM_ATTR_VAL_EXTENSION) {

    return NW_STAT_FAILURE;

  }

  *token = (NW_Uint16)(val->component.ext.token);

  return NW_STAT_SUCCESS;

}

/* If attribute value is of type NW_DOM_TEXT_ITEM_EXTENSION returns token

 otherwise returns 0 and returns str->length = 0, str->storage = NULL.

 All returned strings are shallow copies and the only proper way to

 free these is to call NW_String_delete(pStr). */

EXPORT_C NW_Uint16

NW_DOM_AttrVal_getExtension(NW_DOM_AttrVal_t *val, 

                            NW_String_t *str)

{

  NW_Uint16 fqToken;

  NW_Uint8 t; /* 8-bit token */

  NW_ASSERT (val != NULL);

  NW_ASSERT (str != NULL);

  NW_String_initialize(str, NULL, 0);

  if (NW_DOM_AttrVal_getType(val) != NW_DOM_ATTR_VAL_EXTENSION) {

    return 0;

  }

  /* TBD If it could be gauranteed that the extension was constructed

     correctly then it would be enough to just unconditionally

     shallowCopy. */

  fqToken = (NW_Uint16)(val->component.ext.token);

  t = (NW_Uint8)fqToken;

  if (((t == NW_WBXML_EXT_T_0)

       || (t == NW_WBXML_EXT_T_1)

       || (t == NW_WBXML_EXT_T_2))

      && (val->component.ext.type

         == NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER)) {

    /* This function is not for this case: use "getExtensionInt" form. */

    return 0;

  }

  if ((t != NW_WBXML_EXT_0) && (t != NW_WBXML_EXT_1) && (t != NW_WBXML_EXT_2)) {

    /* By fiat we do nothing with the single byte extension tokens.  A

     more correct version might be to callback to the client to

     request a mapping to a client determined string.

     In the normal case where EXT_T refers to the string table, both

     the EXT_T and EXT_I forms are represented by an explicit pointer

     to the string value since for the EXT_T form we don't have a

     pointer to the string table anyway. */

     NW_String_shallowCopy(str, &val->component.ext.value.string);

  }

  return fqToken;

}

NW_Status_t

NW_DOM_AttrVal_getExtensionInt(NW_DOM_AttrVal_t* val,

                               NW_Uint32* x)

{

  NW_Uint16 fqToken;

  NW_Uint8 t; /* 8-bit token */

  NW_ASSERT(val != NULL);

  NW_ASSERT(x != NULL);

  if ((NW_DOM_AttrVal_getType(val) != NW_DOM_ATTR_VAL_EXTENSION)

      || ((val->component.ext.type

           != NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER)))

  {

    return NW_STAT_FAILURE;

  }

  fqToken = (NW_Uint16)(val->component.ext.token);

  t = (NW_Uint8)fqToken;

  if ((t == NW_WBXML_EXT_T_0)

      || (t == NW_WBXML_EXT_T_1)

      || (t == NW_WBXML_EXT_T_2)) {

    *x = val->component.ext.value.x;

    return NW_STAT_SUCCESS;

  }

  return NW_STAT_FAILURE;

}