/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* dbus-marshal-recursive.h  Marshalling routines for recursive types
 *
 * Copyright (C) 2004, 2005 Red Hat, Inc.
 *
 * Licensed under the Academic Free License version 2.1
 *
 * This program 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 of the License, 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
 *
 */

#ifndef DBUS_MARSHAL_RECURSIVE_H
#define DBUS_MARSHAL_RECURSIVE_H

#include <config.h>
#include <dbus/dbus-protocol.h>
#include <dbus/dbus-list.h>

#ifndef PACKAGE
#error "config.h not included here"
#endif

typedef struct DBusTypeReader      DBusTypeReader;
typedef struct DBusTypeWriter      DBusTypeWriter;
typedef struct DBusTypeReaderClass DBusTypeReaderClass;
typedef struct DBusArrayLenFixup   DBusArrayLenFixup;

/**
 * The type reader is an iterator for reading values from a block of
 * values.
 */
struct DBusTypeReader
{
  dbus_uint32_t byte_order : 8; /**< byte order of the block */

  dbus_uint32_t finished : 1;   /**< marks we're at end iterator for cases
                                 * where we don't have another way to tell
                                 */
  dbus_uint32_t array_len_offset : 3; /**< bytes back from start_pos that len ends */
  const DBusString *type_str;   /**< string containing signature of block */
  int type_pos;                 /**< current position in signature */
  const DBusString *value_str;  /**< string containing values of block */
  int value_pos;                /**< current position in values */

  const DBusTypeReaderClass *klass; /**< the vtable for the reader */
  union
  {
    struct {
      int start_pos;                /**< for array readers, the start of the array values */
    } array;
  } u; /**< class-specific data */
};

/**
 * The type writer is an iterator for writing to a block of values.
 */
struct DBusTypeWriter
{
  dbus_uint32_t byte_order : 8;            /**< byte order to write values with */

  dbus_uint32_t container_type : 8;        /**< what are we inside? (e.g. struct, variant, array) */

  dbus_uint32_t type_pos_is_expectation : 1; /**< type_pos can be either an insertion point for or an expected next type */

  dbus_uint32_t enabled : 1; /**< whether to write values */

  DBusString *type_str; /**< where to write typecodes (or read type expectations) */
  int type_pos;         /**< current pos in type_str */
  DBusString *value_str; /**< where to write values */
  int value_pos;         /**< next position to write */

  union
  {
    struct {
      int start_pos; /**< position of first element in the array */
      int len_pos;   /**< position of length of the array */
      int element_type_pos; /**< position of array element type in type_str */
    } array;
  } u; /**< class-specific data */
};

/**
 * When modifying an existing block of values, array lengths may need
 * to be adjusted; those adjustments are described by this struct.
 */
struct DBusArrayLenFixup
{
  int len_pos_in_reader; /**< where the length was in the original block */
  int new_len;           /**< the new value of the length in the written-out block */
};

void        _dbus_type_reader_init                      (DBusTypeReader        *reader,
                                                         int                    byte_order,
                                                         const DBusString      *type_str,
                                                         int                    type_pos,
                                                         const DBusString      *value_str,
                                                         int                    value_pos);
void        _dbus_type_reader_init_types_only           (DBusTypeReader        *reader,
                                                         const DBusString      *type_str,
                                                         int                    type_pos);
int         _dbus_type_reader_get_current_type          (const DBusTypeReader  *reader);
int         _dbus_type_reader_get_element_type          (const DBusTypeReader  *reader);
int         _dbus_type_reader_get_value_pos             (const DBusTypeReader  *reader);
void        _dbus_type_reader_read_basic                (const DBusTypeReader  *reader,
                                                         void                  *value);
int         _dbus_type_reader_get_array_length          (const DBusTypeReader  *reader);
void        _dbus_type_reader_read_fixed_multi          (const DBusTypeReader  *reader,
                                                         void                  *value,
                                                         int                   *n_elements);
void        _dbus_type_reader_read_raw                  (const DBusTypeReader  *reader,
                                                         const unsigned char  **value_location);
void        _dbus_type_reader_recurse                   (DBusTypeReader        *reader,
                                                         DBusTypeReader        *subreader);
dbus_bool_t _dbus_type_reader_next                      (DBusTypeReader        *reader);
dbus_bool_t _dbus_type_reader_has_next                  (const DBusTypeReader  *reader);
void        _dbus_type_reader_get_signature             (const DBusTypeReader  *reader,
                                                         const DBusString     **str_p,
                                                         int                   *start_p,
                                                         int                   *len_p);
dbus_bool_t _dbus_type_reader_set_basic                 (DBusTypeReader        *reader,
                                                         const void            *value,
                                                         const DBusTypeReader  *realign_root);
dbus_bool_t _dbus_type_reader_delete                    (DBusTypeReader        *reader,
                                                         const DBusTypeReader  *realign_root);
dbus_bool_t _dbus_type_reader_greater_than              (const DBusTypeReader  *lhs,
                                                         const DBusTypeReader  *rhs);

dbus_bool_t _dbus_type_reader_equal_values              (const DBusTypeReader *lhs,
                                                         const DBusTypeReader *rhs);

void        _dbus_type_signature_next                   (const char            *signature,
							 int                   *type_pos);

void        _dbus_type_writer_init                 (DBusTypeWriter        *writer,
                                                    int                    byte_order,
                                                    DBusString            *type_str,
                                                    int                    type_pos,
                                                    DBusString            *value_str,
                                                    int                    value_pos);
void        _dbus_type_writer_init_types_delayed   (DBusTypeWriter        *writer,
                                                    int                    byte_order,
                                                    DBusString            *value_str,
                                                    int                    value_pos);
void        _dbus_type_writer_add_types            (DBusTypeWriter        *writer,
                                                    DBusString            *type_str,
                                                    int                    type_pos);
void        _dbus_type_writer_remove_types         (DBusTypeWriter        *writer);
void        _dbus_type_writer_init_values_only     (DBusTypeWriter        *writer,
                                                    int                    byte_order,
                                                    const DBusString      *type_str,
                                                    int                    type_pos,
                                                    DBusString            *value_str,
                                                    int                    value_pos);
dbus_bool_t _dbus_type_writer_write_basic          (DBusTypeWriter        *writer,
                                                    int                    type,
                                                    const void            *value);
dbus_bool_t _dbus_type_writer_write_fixed_multi    (DBusTypeWriter        *writer,
                                                    int                    element_type,
                                                    const void            *value,
                                                    int                    n_elements);
dbus_bool_t _dbus_type_writer_recurse              (DBusTypeWriter        *writer,
                                                    int                    container_type,
                                                    const DBusString      *contained_type,
                                                    int                    contained_type_start,
                                                    DBusTypeWriter        *sub);
dbus_bool_t _dbus_type_writer_unrecurse            (DBusTypeWriter        *writer,
                                                    DBusTypeWriter        *sub);
dbus_bool_t _dbus_type_writer_append_array         (DBusTypeWriter        *writer,
                                                    const DBusString      *contained_type,
                                                    int                    contained_type_start,
                                                    DBusTypeWriter        *sub);
dbus_bool_t _dbus_type_writer_write_reader         (DBusTypeWriter        *writer,
                                                    DBusTypeReader        *reader);
dbus_bool_t _dbus_type_writer_write_reader_partial (DBusTypeWriter        *writer,
                                                    DBusTypeReader        *reader,
                                                    const DBusTypeReader  *start_after,
                                                    int                    start_after_new_pos,
                                                    int                    start_after_new_len,
                                                    DBusList             **fixups);
void        _dbus_type_writer_set_enabled          (DBusTypeWriter        *writer,
                                                    dbus_bool_t            enabled);


#endif /* DBUS_MARSHAL_RECURSIVE_H */
