source: trunk/gsdl/lib/gsdlunicode.h@ 100

/**********************************************************************
 *
 * gsdlunicode.h -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: gsdlunicode.h 100 1999-01-08 02:33:16Z rjmcnab $
 *
 *********************************************************************/


#ifndef GSDLUNICODE_H
#define GSDLUNICODE_H

#include "text_t.h"


// converts a unicode encode text_t string to a utf-8
// encoded text_t string
text_t to_utf8 (const text_t &in);

// converts a utf-8 encoded text_t string to a unicode
// encoded text_t string
text_t to_uni (const text_t &in);



#define MAXUTF8CHARLEN 3

// convert from a utf-8 char stream to the text_t class
class utf8inconvertclass : public inconvertclass {
public:
  utf8inconvertclass();
  void reset ();
  void convert (text_t &output, status_t &status);

protected:
  // buffer to hold unconverted characters in a stream
  unsigned char utf8buf[MAXUTF8CHARLEN];
  size_t utf8buflen;

  // returns the length that the current contents of the 
  // utf8buf should be
  size_t getutf8charlen ();
};


// This class provides the option of removing zero width
// spaces (U+200B) during the output. By default this
// option is turned off. The functionality is actually
// implemented by the sub-classes, this class just provides
// the framework for these classes. 
//
// Note: by convention reset() should not reset the rzws flag.
class rzwsoutconvertclass : public outconvertclass {
public:
  rzwsoutconvertclass () {rzws = 0;};
  set_rzws (int new_rzws) {rzws = new_rzws;};

protected:
  int rzws;
};


// Convert from a text_t class to a utf-8 char stream
class utf8outconvertclass : public rzwsoutconvertclass {
public:
  utf8outconvertclass () {utf8buflen=0; utf8bufhere=0;};
  void reset ();
  // note that convert does not null-terminate the
  // output array of characters
  void convert (char *output, size_t maxlen, 
        size_t &len, status_t &status);

protected:
  unsigned char utf8buf[MAXUTF8CHARLEN];
  size_t utf8buflen;
  size_t utf8bufhere;
};


// mapdata_t is used by mapconvert to hold the map file data
class mapdata_t {
public:
  mapdata_t();
  bool loaded;
  unsigned short *ptrs[256];
};

// mapconvert is used in situations where conversion is best
// done using a map file. The mapfile should reside in 
// gsdlhome/unicode.
class mapconvert {
public:
  mapconvert ();
  ~mapconvert () {unloadmapfile();};

  // loadmapfile should be called before any conversion is done
  bool loadmapfile (const text_t &thegsdlhome, const text_t &theencoding, 
            unsigned short theabsentc);
  void unloadmapfile ();

  unsigned short convert (unsigned short c);

  // note that this version of convert has different semantics to
  // the convertclass version.
  text_t convert (const text_t &instr);

protected:
  text_t gsdlhome;
  text_t encoding;
  unsigned short absentc;
  mapdata_t mapdata;
};



#define MAXMAPCHARLEN 2

// convert from a gb char stream to the unicode text_t class
class mapinconvertclass : public inconvertclass {
public:
  mapinconvertclass();

  // loadmapfile should be called before any conversion takes
  // place
  bool loadmapfile (const text_t &thegsdlhome, const text_t &theencoding, 
            unsigned short theabsentc) {
    return converter.loadmapfile (thegsdlhome, theencoding, theabsentc);
  };

  void reset ();
  void convert (text_t &output, status_t &status);

protected:
  // buffer to hold unconverted characters in a stream
  unsigned char mapbuf[MAXMAPCHARLEN];
  size_t mapbuflen;

  // note: multiple instances of mapinconvert class are expensive
  // as each will have its own copy of the map file data. This
  // could be reduced by making map2unimap static, but then it
  // wouldn't be thread safe.
  mapconvert converter;

  // returns the length that the current contents of the 
  // mapbuf should be
  inline size_t getmapcharlen () {
    if (mapbuflen == 0) return 0;
    if (mapbuf[0] < 0x80) return 1;
    return 2;
  }
};


// Convert from a text_t class to a map char stream
class mapoutconvertclass : public rzwsoutconvertclass {
public:
  mapoutconvertclass ();

  // loadmapfile should be called before any conversion takes
  // place
  bool loadmapfile (const text_t &thegsdlhome, const text_t &theencoding, 
            unsigned short theabsentc) {
    return converter.loadmapfile (thegsdlhome, theencoding, theabsentc);
  };

  void reset ();
  void convert (char *output, size_t maxlen, 
        size_t &len, status_t &status);

protected:
  unsigned char mapbuf[MAXMAPCHARLEN];
  size_t mapbuflen;
  size_t mapbufhere;

  mapconvert converter;
};

#endif