/* $Id$
 *
 * Copyright (c) 2006-2008 Daisuke Maki <daisuke@endeworks.jp>
 * All rights reserved.
 */

#include "text-mecab.h"
#ifndef __TEXT_MECAB_CLONE_C__
#define __TEXT_MECAB_CLONE_C__

/* Deep Copy Memory Management Strategy:
 *
 * When we call dclone(), we actually clone the *entire* node list.
 * that is, we go back to the first node in the list, and start from
 * there.
 *
 * When ->next, ->prev is called, we update the node->head struct's
 * refcnt. When this refcnt is zero, we finally free the struct
 */

void
TextMeCab_Node_Cloned_free(TextMeCab_Node_Cloned *node)
{
    TextMeCab_Node_Cloned_Meta *meta;
    TextMeCab_Node_Cloned      *tmp;

    if (node == NULL || node->meta == NULL) { /* sanity */
        return;
    }

    meta = node->meta;
    if (meta->refcnt != 0)
        return;

    meta->refcnt--;
    node = meta->first;
    while (node != NULL) {
        tmp = node->next;
        Safefree(node->actual);
        Safefree(node);
        node = tmp;
    }
    Safefree(meta);
}

#if 0
pmecab_node_clone_t *
pmecab_deep_clone_node(mecab_node_t *node)
{
    pmecab_node_clone_head_t *xs_head;
    pmecab_node_clone_t *xs_node;
    pmecab_node_clone_t *cur_xs_node;
    pmecab_node_clone_t *tmp_xs;
    mecab_node_t *cur_node;
    mecab_node_t *tmp;
    if (node == NULL)
        return NULL;

    /* First, create the clone node list head. Then create the node that 
     * requested to be cloned.
     */
    Newz(1234, xs_head, 1, pmecab_node_clone_head_t);

    xs_node = pmecab_clone_node(node);
    xs_node->head = xs_head;

    cur_node = node->prev;
    cur_xs_node = xs_node;
    while (cur_node != NULL) {
        tmp = cur_node->prev;
        tmp_xs = pmecab_clone_node(cur_node);
        tmp_xs->head = xs_head;

        if (tmp == NULL) {
            xs_head->first = tmp_xs;
        }

        cur_xs_node->prev = tmp_xs;
        cur_xs_node->actual->prev = tmp_xs->actual;
        
        tmp_xs->next = cur_xs_node;
        tmp_xs->actual->next = cur_xs_node->actual;

        cur_node = tmp;
        cur_xs_node = tmp_xs;
    }

    cur_node    = node;
    cur_xs_node = xs_node;
    while (cur_node != NULL) {
        tmp = cur_node->next;
        tmp_xs = pmecab_clone_node(cur_node);
        tmp_xs->head = xs_head;

        cur_xs_node->next = tmp_xs;
        cur_xs_node->actual->next = tmp_xs->actual;
        tmp_xs->prev = cur_xs_node;
        tmp_xs->actual->prev = cur_xs_node->actual;

        cur_node = tmp;
        cur_xs_node = tmp_xs;
    }

    xs_head->refcnt++;

    return xs_node;
}
#endif

unsigned int
TextMeCab_Node_Cloned_id(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_ID(node->actual);
}

unsigned int
TextMeCab_Node_Cloned_length(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_LENGTH(node->actual);
}

unsigned int
TextMeCab_Node_Cloned_rlength(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_RLENGTH(node->actual);
}

TextMeCab_Node_Cloned *
TextMeCab_Node_Cloned_next(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_NEXT(node);
}

TextMeCab_Node_Cloned *
TextMeCab_Node_Cloned_prev(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_PREV(node);
}

const char *
TextMeCab_Node_Cloned_surface(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_SURFACE(node->actual);
}

const char *
TextMeCab_Node_Cloned_feature(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_FEATURE(node->actual);
}

unsigned short
TextMeCab_Node_Cloned_rcattr(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_RCATTR(node->actual);
}

unsigned short
TextMeCab_Node_Cloned_lcattr(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_LCATTR(node->actual);
}

unsigned short
TextMeCab_Node_Cloned_posid(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_POSID(node->actual);
}

unsigned char
TextMeCab_Node_Cloned_char_type(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_CHAR_TYPE(node->actual);
}

unsigned char
TextMeCab_Node_Cloned_stat(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_STAT(node->actual);
}

unsigned char
TextMeCab_Node_Cloned_isbest(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_ISBEST(node->actual);
}

float
TextMeCab_Node_Cloned_alpha(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_ALPHA(node->actual);
}

float
TextMeCab_Node_Cloned_beta(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_BETA(node->actual);
}

float
TextMeCab_Node_Cloned_prob(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_PROB(node->actual);
}

long
TextMeCab_Node_Cloned_cost(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_COST(node->actual);
}

short
TextMeCab_Node_Cloned_wcost(node)
        TextMeCab_Node_Cloned *node;
{
    return MECAB_NODE_WCOST(node->actual);
}

const char *
TextMeCab_Node_Cloned_format(node, mecab)
        TextMeCab_Node_Cloned *node;
        TextMeCab             *mecab;
{
    return mecab_format_node(mecab, node->actual);
}

#endif /* __TEXT_MECAB_CLONE_C__ */

