xmlwriter.c

来自「General Hidden Markov Model Library 一个通用」· C语言 代码 · 共 1,065 行 · 第 1/3 页

/*******************************************************************************
*
*       This file is part of the General Hidden Markov Model Library,
*       GHMM version 0.8_beta1, see http://ghmm.org
*
*       Filename: ghmm/ghmm/xmlwriter.h
*       Authors:  Janne Grunau
*
*       Copyright (C) 1998-2006 Alexander Schliep 
*       Copyright (C) 1998-2001 ZAIK/ZPR, Universitaet zu Koeln
*	Copyright (C) 2002-2006 Max-Planck-Institut fuer Molekulare Genetik, 
*                               Berlin
*                                   
*       Contact: [e-mail]             
*
*       This library is free software; you can redistribute it and/or
*       modify it under the terms of the GNU Library General Public
*       License as published by the Free Software Foundation; either
*       version 2 of the License, or (at your option) any later version.
*
*       This library 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
*       Library General Public License for more details.
*
*       You should have received a copy of the GNU Library General Public
*       License along with this library; if not, write to the Free
*       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*
*       This file is version $Revision: 1927 $ 
*                       from $Date: 2007-10-23 14:13:49 +0200 (Tue, 23 Oct 2007) $
*             last change by $Author: grunau $.
*
*******************************************************************************/
#ifdef HAVE_CONFIG_H
#  include "../config.h"
#endif

#include <math.h>
#include <stdio.h>
#include <string.h>
#include <libxml/encoding.h>
#include <libxml/xmlwriter.h>

#include "ghmm.h"
#include "mes.h"
#include "mprintf.h"
#include "ghmm_internals.h"
#include "xmlwriter.h"

#define kAlphabet      0
#define kLabelAlphabet 1

/* Bitmask to test the modeltype against to choose the type of the model pointer
   we use in the union */
#define PTR_TYPE_MASK (GHMM_kDiscreteHMM + GHMM_kTransitionClasses + GHMM_kPairHMM + GHMM_kContinuousHMM)

#if defined(LIBXML_WRITER_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)

#define MY_ENCODING "ISO-8859-1"

#define DTD_VERSION "1.0"

#define WRITE_DOUBLE_ATTRIBUTE(XMLW, NAME, VALUE)                             \
          if (0 > xmlTextWriterWriteFormatAttribute(XMLW, BAD_CAST (NAME),    \
                                                    "%.8f", (VALUE))) {       \
            estr=ighmm_mprintf(NULL,0, "failed to write attribute %s (%.8f)", \
                               (NAME), (VALUE));                              \
            GHMM_LOG(LERROR, estr); m_free(estr); goto STOP;} else


/* ========================================================================= */
static unsigned char * replaceXMLEntity(unsigned char* str) {
#define CUR_PROC "replaceXMLEntity"
  int i, written = 0;
  int len = strlen(str);
  char* retval = malloc(len*4+1);
  for (i=0; i<len; ++i) {
    switch (str[i]) {
    case '<':
      strncpy(retval, "&lt;", 4);
      written += 4;
      break;
    case '>':
      strncpy(retval, "&gt;", 4);
      written += 4;
      break;
    default:
      retval[written++] = str[i];
    }
  }
  retval[written++] = '\0';

  return realloc(retval, written);
#undef CUR_PROC
}

/* ========================================================================= */
static char * strModeltype(int modelType) {
#define CUR_PROC "strModelType"

  int end;
  char * mt;

  ARRAY_CALLOC(mt, 200);

  if (modelType > 0) {
    if (modelType & GHMM_kLeftRight)
      strcat(mt, "left-right ");
    if (modelType & GHMM_kSilentStates)
      strcat(mt, "silent ");
    if (modelType & GHMM_kTiedEmissions)
      strcat(mt, "tied ");
    if (modelType & GHMM_kHigherOrderEmissions)
      strcat(mt, "higher-order ");
    if (modelType & GHMM_kBackgroundDistributions)
      strcat(mt, "background ");
    if (modelType & GHMM_kLabeledStates)
      strcat(mt, "labeled ");
    if (modelType & GHMM_kTransitionClasses)
      strcat(mt, "transition-classes ");
    if (modelType & GHMM_kDiscreteHMM)
      strcat(mt, "discrete ");
    if (modelType & GHMM_kContinuousHMM)
      strcat(mt, "continuous ");
    if (modelType & GHMM_kPairHMM)
      strcat(mt, "pair ");
  } else {
    GHMM_LOG(LERROR, "can't write models with unspecified modeltype");
    goto STOP;
  }

  /* overwrite the last space */
  end = strlen(mt);
  mt[end-1] = '\0';
  
  return mt;
 STOP:
  m_free(mt);
  return NULL;
#undef CUR_PROC
}

/* ========================================================================= */
static char * doubleArrayToCSV(double * array, int size) {
#define CUR_PROC "doubleArrayToCSV"

  int i, pos=0;
  char * csv;
  int maxlength = (10+2)*size;

  ARRAY_MALLOC(csv, maxlength);

  for (i=0; i<size-1 && pos<maxlength-10; i++) {
    pos += sprintf(csv+pos, "%.8f, ", array[i]);
  }
  if (i<size-1) {
    GHMM_LOG(LERROR, "writing CSV failed");
    goto STOP;
  } else {
    pos += sprintf(csv+pos, "%.8f", array[i]);
  }
  /*printf("%d bytes of %d written\n", pos, maxlength);*/
  return csv;
STOP:
  return NULL;
#undef  CUR_PROC
}


/* ========================================================================= */
static int writeAlphabet(xmlTextWriterPtr writer, ghmm_alphabet * alfa, int type) {
#define CUR_PROC "writeAlphabet"

  int i;

  if (0 > xmlTextWriterStartElement(writer, BAD_CAST (type == kAlphabet ? "alphabet" : "classAlphabet"))) {
    GHMM_LOG(LERROR, "Error at xmlTextWriterStartElement");
    goto STOP;;
  }
  
  if (type == kAlphabet)
    if (0 > xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "id", "%d", alfa->id))
      GHMM_LOG_PRINTF(LERROR, LOC, "failed to write id-attribute for alphabet"
               "with id %d", alfa->id);
  
  for (i=0; i<alfa->size; i++) {
    if (0 > xmlTextWriterStartElement(writer, BAD_CAST "symbol")) {
      GHMM_LOG_PRINTF(LERROR, LOC, "failed to start symbol-tag no %d", i);
      goto STOP;
    }
    if (0 > xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "code", "%d", i)) {
      GHMM_LOG_PRINTF(LERROR, LOC, "failed to write code-attribute for symbol %s"
			   "with code %d", alfa->symbols[i], i);
      goto STOP;
    }
    
    if (0 > xmlTextWriterWriteRaw(writer, BAD_CAST replaceXMLEntity(alfa->symbols[i]))) {
      GHMM_LOG_PRINTF(LERROR, LOC, "failed to write symbol %s with code %d",
			   alfa->symbols[i], i);
      goto STOP;
    }
    
    if (0 > xmlTextWriterEndElement(writer)) {
      GHMM_LOG_PRINTF(LERROR, LOC, "failed to end symbol-tag no %d", i);
      goto STOP;
    }
  }

  if (0 > xmlTextWriterEndElement(writer)) {
    GHMM_LOG(LERROR, "Error at ending alphabet");
    goto STOP;
  }

  return 0;
 STOP:
  return -1;
#undef CUR_PROC
}

/* ========================================================================= */
static int writeBackground(xmlTextWriterPtr writer, ghmm_dbackground* bg) {
#define CUR_PROC "writeBackground"
  
  int i;
  char * tmp=NULL;

  for (i=0; i<bg->n; i++) {

    if (0 > xmlTextWriterStartElement(writer, BAD_CAST "background")) {
      GHMM_LOG_PRINTF(LERROR, LOC, "Error at starting backgroung %d", i);
      return -1;
    }

    if (!(bg->name)) {
      if (0 > xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "key", "bg_%d", i))
        GHMM_LOG(LERROR, "Error at writing background key");
    }
    else {
      if (0 > xmlTextWriterWriteAttribute(writer, BAD_CAST "key", BAD_CAST (bg->name[i])))
        GHMM_LOG(LERROR, "Error at writing background key");
    }

    if (0 < bg->order[i])
      if (0 > xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "order", "%d", bg->order[i]))
	GHMM_LOG(LERROR, "can't write background order attribute");
    
    tmp = doubleArrayToCSV(bg->b[i], pow(bg->m, bg->order[i]+1));
    if (tmp) {
      if (0 > xmlTextWriterWriteRaw(writer, BAD_CAST tmp)) {
	GHMM_LOG(LERROR, "Error at xmlTextWriterWriteRaw while writing"
		 "background distribution CSV");
	m_free(tmp);
	return -1;
      }
      m_free(tmp);
    } else {
      GHMM_LOG(LERROR, "converting array to CSV failed for background distribution");
      return -1;
    }

    if (0 > xmlTextWriterEndElement(writer)) {
      GHMM_LOG(LERROR, "Error at xmlTextWriterEndElement while ending"
	       "background distribution");
      return -1;
    }
  }
  return 0;
#undef CUR_PROC
}

/* ========================================================================= */
static int writeDiscreteStateContents(xmlTextWriterPtr writer, ghmm_xmlfile* f,
				      int moNo, int sNo) {
#define CUR_PROC "writeDiscreteStateContents"

  int bgId, cLabel, rc, order, tied;
  char * tmp=NULL;

  if (f->model.d[moNo]->model_type & GHMM_kSilentStates && f->model.d[moNo]->silent[sNo])
  {
    if (0 > xmlTextWriterStartElement(writer, BAD_CAST "silent")) {
      GHMM_LOG(LERROR, "Error at xmlTextWriterStartElement (silent)");
      goto STOP;
    }
    /* end silent */
    if (0 > xmlTextWriterEndElement(writer)) {
      GHMM_LOG(LERROR, "Error at xmlTextWriterEndElement (silent)");
      goto STOP;
    }
  }
  else
  {
    /* writing discrete distribution */
    if (0 > xmlTextWriterStartElement(writer, BAD_CAST "discrete")) {
      GHMM_LOG(LERROR, "Error at xmlTextWriterStartElement (discrete)");
      goto STOP;
    }

    if (0 > xmlTextWriterWriteAttribute(writer, BAD_CAST "id", BAD_CAST "0")) {
      GHMM_LOG(LERROR, "failed to write alphabet id");
      goto STOP;
    }

    if (f->model.d[moNo]->s[sNo].fix)
      if (0 > xmlTextWriterWriteAttribute(writer, BAD_CAST "fixed", BAD_CAST "1")) {
        GHMM_LOG(LERROR, "failed to write fixed attribute");
        goto STOP;
      }

    if ((f->model.d[moNo]->model_type & GHMM_kHigherOrderEmissions)
        && f->model.d[moNo]->order[sNo]) {
      order = f->model.d[moNo]->order[sNo];
      if (0 > xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "order", "%d", order)) {
        GHMM_LOG(LERROR, "failed to write order attribute for discrete distribution");
        goto STOP;
      }
    } else
      order = 0;

    tmp = doubleArrayToCSV(f->model.d[moNo]->s[sNo].b, pow(f->model.d[moNo]->M, order+1));
    if (tmp) {
      if (0 > xmlTextWriterWriteRaw(writer, BAD_CAST tmp)) {
        GHMM_LOG(LERROR, "Error at xmlTextWriterWriteRaw while writing"
                 "discrete distribution CSV");
        m_free(tmp);
        goto STOP;
      }
      m_free(tmp);
    } else {
      GHMM_LOG(LERROR, "converting array to CSV failed for discrete distribution");
      goto STOP;
    }
  
    /* end discrete distribution */
    if (0 > xmlTextWriterEndElement(writer)) {
      GHMM_LOG(LERROR, "Error at xmlTextWriterEndElement (discrete)");
      goto STOP;
    }
  }

  /* writing backgroung key */
  if (f->model.d[moNo]->model_type & GHMM_kBackgroundDistributions) {
    bgId = f->model.d[moNo]->background_id[sNo];
    if (bgId != GHMM_kNoBackgroundDistribution) {
/*       if (f->model.d[moNo]->bp->name[bgId]) { */
      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "backgroundKey", "bg_%d", bgId);
/* 				       BAD_CAST f->model.d[moNo]->bp->name[bgId]); */
      if (rc<0) {
        GHMM_LOG(LERROR, "Error at xmlTextWriterWriteElement (backgroundKey)");
        goto STOP;
      }
/*       } else { */
/* 	GHMM_LOG(LERROR, "background name is NULL pointer, invalid model"); */