Index: trunk/lttoolbox/lttoolbox/Makefile.am
===================================================================
--- trunk/lttoolbox/lttoolbox/Makefile.am	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/Makefile.am	(revision 71731)
@@ -1,8 +1,8 @@
 
 h_sources = alphabet.h att_compiler.h buffer.h compiler.h compression.h  \
-            entry_token.h expander.h fst_processor.h lt_locale.h ltstr.h \
-            match_exe.h match_node.h match_state.h my_stdio.h node.h \
-            pattern_list.h regexp_compiler.h sorted_vector.h state.h \
+            deserialiser.h entry_token.h expander.h fst_processor.h lt_locale.h \
+            ltstr.h match_exe.h match_node.h match_state.h my_stdio.h node.h \
+            pattern_list.h regexp_compiler.h serialiser.h sorted_vector.h state.h \
             transducer.h trans_exe.h xml_parse_util.h exception.h tmx_compiler.h
 cc_sources = alphabet.cc att_compiler.cc compiler.cc compression.cc entry_token.cc \
              expander.cc fst_processor.cc lt_locale.cc match_exe.cc \
Index: trunk/lttoolbox/lttoolbox/alphabet.cc
===================================================================
--- trunk/lttoolbox/lttoolbox/alphabet.cc	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/alphabet.cc	(revision 71731)
@@ -17,6 +17,8 @@
 #include <lttoolbox/alphabet.h>
 #include <lttoolbox/compression.h>
 #include <lttoolbox/my_stdio.h>
+#include <lttoolbox/serialiser.h>
+#include <lttoolbox/deserialiser.h>
 
 #include <cctype>
 #include <cstdlib>
@@ -171,6 +173,30 @@
 }
 
 void
+Alphabet::serialise(std::ostream &serialised) const
+{
+  Serialiser<const vector<wstring> >::serialise(slexicinv, serialised);
+  Serialiser<vector<pair<int, int> > >::serialise(spairinv, serialised);
+}
+
+void
+Alphabet::deserialise(std::istream &serialised)
+{
+  slexicinv.clear();
+  slexic.clear();
+  spairinv.clear();
+  spair.clear();
+  slexicinv = Deserialiser<vector<wstring> >::deserialise(serialised);
+  for (size_t i = 0; i < slexicinv.size(); i++) {
+    slexic[slexicinv[i]] = i;
+  }
+  spairinv = Deserialiser<vector<pair<int, int> > >::deserialise(serialised);
+  for (size_t i = 0; i < slexicinv.size(); i++) {
+    spair[spairinv[i]] = i;
+  }
+}
+
+void
 Alphabet::writeSymbol(int const symbol, FILE *output) const
 {
   if(symbol < 0)
Index: trunk/lttoolbox/lttoolbox/alphabet.h
===================================================================
--- trunk/lttoolbox/lttoolbox/alphabet.h	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/alphabet.h	(revision 71731)
@@ -133,6 +133,9 @@
    */
   void read(FILE *input);
 
+  void serialise(std::ostream &serialised) const;
+  void deserialise(std::istream &serialised);
+
   /**
    * Write a symbol enclosed by angle brackets in the output stream.
    * @param symbol symbol code.
Index: trunk/lttoolbox/lttoolbox/deserialiser.h
===================================================================
--- trunk/lttoolbox/lttoolbox/deserialiser.h	(nonexistent)
+++ trunk/lttoolbox/lttoolbox/deserialiser.h	(revision 71731)
@@ -0,0 +1,185 @@
+// Copyright (C) 2005 Universitat d'Alacant / Universidad de Alicante
+//
+// 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, see <http://www.gnu.org/licenses/>.
+
+#ifndef DESERIALISER_H
+#define DESERIALISER_H
+
+#include "exception.h"
+
+#include <lttoolbox/stdint_shim.h>
+#include <cstddef>
+#include <limits>
+#include <istream>
+#include <limits>
+#include <map>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <typeinfo>
+
+template <typename T>
+struct remove_const
+{
+    typedef T type;
+};
+template <typename T>
+struct remove_const<const T>
+{
+    typedef T type;
+};
+
+template <typename DeserialisedType> class Deserialiser;
+
+template <typename value_type>
+class Deserialiser<std::basic_string<value_type> > {
+public:
+  inline static std::basic_string<value_type>
+  deserialise(std::istream &Stream_);
+};
+
+template <typename first_type, typename second_type>
+class Deserialiser<std::pair<first_type, second_type> > {
+public:
+  inline static std::pair<first_type, second_type>
+  deserialise(std::istream &Stream_);
+};
+
+template <> class Deserialiser<signed int> {
+public:
+  inline static signed int deserialise(std::istream &Stream_);
+};
+
+template <> class Deserialiser<size_t> {
+public:
+  inline static size_t deserialise(std::istream &Stream_);
+};
+
+template <> class Deserialiser<wchar_t> {
+public:
+  inline static wchar_t deserialise(std::istream &Stream_);
+};
+
+template <> class Deserialiser<char> {
+public:
+  inline static char deserialise(std::istream &Stream_);
+};
+
+template<> class Deserialiser<double> {
+public:
+  inline static double deserialise(std::istream &Stream_);
+};
+
+template <typename Container>
+class Deserialiser {
+public:
+  inline static Container deserialise(std::istream &Stream_);
+};
+
+template <typename value_type>
+std::basic_string<value_type>
+Deserialiser<std::basic_string<value_type> >::deserialise(
+    std::istream &Stream_) {
+  std::size_t SerialisedValueCount =
+      Deserialiser<std::size_t>::deserialise(Stream_);
+  std::basic_string<value_type> SerialisedType_;
+
+  for (; SerialisedValueCount != 0; --SerialisedValueCount) {
+    SerialisedType_.push_back(Deserialiser<value_type>::deserialise(Stream_));
+  }
+
+  return SerialisedType_;
+}
+
+template <typename first_type, typename second_type>
+std::pair<first_type, second_type>
+Deserialiser<std::pair<first_type, second_type> >::deserialise(
+    std::istream &Stream_) {
+  first_type a = Deserialiser<typename remove_const<first_type>::type>::deserialise(Stream_);
+  second_type b = Deserialiser<typename remove_const<second_type>::type>::deserialise(Stream_);
+  return std::make_pair(a, b);
+}
+
+template <typename integer_type>
+integer_type int_deserialise(std::istream &Stream_) {
+  try {
+    integer_type SerialisedType_ = 0;
+    unsigned char SerialisedTypeSize = Stream_.get();
+
+    if (!Stream_)
+      throw DeserialisationException("can't deserialise size");
+
+    for (; SerialisedTypeSize != 0;) {
+      SerialisedType_ +=
+          static_cast<integer_type>(Stream_.get())
+          << std::numeric_limits<unsigned char>::digits * --SerialisedTypeSize;
+
+      if (!Stream_)
+        throw DeserialisationException("can't deserialise byte");
+    }
+
+    return SerialisedType_;
+  } catch (const std::exception &exc) {
+    std::stringstream what_;
+    what_ << "can't deserialise " << sizeof(integer_type) << " byte integer type: " << exc.what();
+    throw DeserialisationException(what_.str().c_str());
+  }
+}
+
+signed int Deserialiser<signed int>::deserialise(std::istream &Stream_) {
+  // Assumes size_t >= int and signed int != size_t
+  return Deserialiser<size_t>::deserialise(Stream_);
+}
+
+size_t Deserialiser<size_t>::deserialise(std::istream &Stream_) {
+  // Assumes size_t == uint64_t, ie it is fixed across platforms
+  return int_deserialise<size_t>(Stream_);
+}
+
+wchar_t Deserialiser<wchar_t>::deserialise(std::istream &Stream_) {
+  return int_deserialise<wchar_t>(Stream_);
+}
+
+char Deserialiser<char>::deserialise(std::istream &Stream_) {
+  return int_deserialise<char>(Stream_);
+}
+
+double Deserialiser<double>::deserialise(std::istream &Stream_) {
+  union {
+    uint64_t i;
+    double d;
+  } u;
+  u.i = Deserialiser<uint64_t>::deserialise(Stream_);
+  return u.d;
+}
+
+template <typename Container>
+Container
+Deserialiser<Container>::deserialise(std::istream &Stream_) {
+  std::size_t SerialisedValueCount =
+      Deserialiser<std::size_t>::deserialise(Stream_);
+  typename remove_const<Container>::type SerialisedType_;
+  std::insert_iterator<typename remove_const<Container>::type> insert_it =
+      std::inserter(SerialisedType_, SerialisedType_.begin());
+
+  for (; SerialisedValueCount != 0; --SerialisedValueCount) {
+    *(insert_it++) = Deserialiser<typename Container::value_type>::deserialise(Stream_);
+  }
+
+  return SerialisedType_;
+}
+
+#endif // DESERIALISER_H
Index: trunk/lttoolbox/lttoolbox/exception.h
===================================================================
--- trunk/lttoolbox/lttoolbox/exception.h	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/exception.h	(revision 71731)
@@ -42,4 +42,19 @@
   std::string msg;
 };
 
+class IOException : public Exception {
+public:
+  IOException(const char* _msg) throw () : Exception(_msg) {};
+};
+
+class SerialisationException : public IOException {
+public:
+  SerialisationException(const char* _msg) throw () : IOException(_msg) {};
+};
+
+class DeserialisationException : public IOException {
+public:
+  DeserialisationException(const char* _msg) throw () : IOException(_msg) {};
+};
+
 #endif
Index: trunk/lttoolbox/lttoolbox/pattern_list.cc
===================================================================
--- trunk/lttoolbox/lttoolbox/pattern_list.cc	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/pattern_list.cc	(revision 71731)
@@ -16,6 +16,8 @@
  */
 #include <lttoolbox/pattern_list.h>
 #include <lttoolbox/compression.h>
+#include <lttoolbox/serialiser.h>
+#include <lttoolbox/deserialiser.h>
 
 #include <cstdlib>
 #include <iostream>
@@ -399,6 +401,22 @@
   }
 }
 
+void
+PatternList::serialise(std::ostream &serialised) const
+{
+  alphabet.serialise(serialised);
+  transducer.serialise(serialised);
+  Serialiser<map<int, int> >::serialise(final_type, serialised);
+}
+
+void
+PatternList::deserialise(std::istream &serialised)
+{
+  alphabet.deserialise(serialised);
+  transducer.deserialise(serialised);
+  final_type = Deserialiser<map<int, int> >::deserialise(serialised);
+}
+
 MatchExe *
 PatternList::newMatchExe()
 {
Index: trunk/lttoolbox/lttoolbox/pattern_list.h
===================================================================
--- trunk/lttoolbox/lttoolbox/pattern_list.h	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/pattern_list.h	(revision 71731)
@@ -136,6 +136,9 @@
    * @param output the output stream
    */
   void write(FILE *output);
+
+  void serialise(std::ostream &serialised) const;
+  void deserialise(std::istream &serialised);
   
   /**
    * Create a new MatchExe from PatternList, must be freed with 'delete'
Index: trunk/lttoolbox/lttoolbox/serialiser.h
===================================================================
--- trunk/lttoolbox/lttoolbox/serialiser.h	(nonexistent)
+++ trunk/lttoolbox/lttoolbox/serialiser.h	(revision 71731)
@@ -0,0 +1,216 @@
+// Copyright (C) 2005 Universitat d'Alacant / Universidad de Alicante
+//
+// 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, see <http://www.gnu.org/licenses/>.
+
+#ifndef SERIALISER_H
+#define SERIALISER_H
+
+#include "exception.h"
+
+#include <lttoolbox/stdint_shim.h>
+#include <cstddef>
+#include <limits>
+#include <ios>
+#include <limits>
+#include <map>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace {
+template <typename SerialisedType>
+static unsigned char compressedSize(const SerialisedType &SerialisedType_) {
+  unsigned char compressedSize_ = 0;
+
+  // Have to be careful here, if we shift >> 64 it's the same as >> 0 so make
+  // sure only to shift up to >> 56
+  for (; (SerialisedType_ >>
+          std::numeric_limits<unsigned char>::digits * compressedSize_ > 255);
+       ++compressedSize_) {
+  }
+  ++compressedSize_;
+
+  return compressedSize_;
+}
+
+template <typename SerialisedType> class Serialiser;
+
+template <typename value_type>
+class Serialiser<std::basic_string<value_type> > {
+public:
+  inline static void
+  serialise(const std::basic_string<value_type> &SerialisedType_,
+            std::ostream &Output);
+};
+
+template <typename first_type, typename second_type>
+class Serialiser<std::pair<first_type, second_type> > {
+public:
+  inline static void
+  serialise(const std::pair<first_type, second_type> &SerialisedType_,
+            std::ostream &Output);
+};
+
+template <> class Serialiser<signed int> {
+public:
+  inline static void serialise(const signed int &SerialisedType_,
+                               std::ostream &Output);
+};
+
+template <> class Serialiser<size_t> {
+public:
+  inline static void serialise(const size_t &SerialisedType_,
+                               std::ostream &Output);
+};
+
+template <> class Serialiser<wchar_t> {
+public:
+  inline static void serialise(const wchar_t &SerialisedType_,
+                               std::ostream &Output);
+};
+
+template <> class Serialiser<char> {
+public:
+  inline static void serialise(const char &SerialisedType_,
+                               std::ostream &Output);
+};
+
+template<> class Serialiser<double> {
+public:
+  inline static void serialise(const double &SerialisedType_,
+                               std::ostream &Output);
+};
+
+template <typename Container>
+class Serialiser {
+public:
+  inline static void serialise(const Container &SerialisedType_,
+                               std::ostream &Output);
+};
+}
+
+template <typename SerialisedType>
+inline void serialise(const SerialisedType &SerialisedType_,
+                      std::ostream &Output) {
+  Serialiser<SerialisedType>::serialise(SerialisedType_, Output);
+}
+
+template <typename value_type>
+void Serialiser<std::basic_string<value_type> >::serialise(
+    const std::basic_string<value_type> &SerialisedType_,
+    std::ostream &Output) {
+  ::serialise(SerialisedType_.size(), Output);
+
+  for (typename std::basic_string<value_type>::const_iterator
+           SerialisedType_iterator = SerialisedType_.begin();
+       // Call .end() each iteration to save memory.
+       SerialisedType_iterator != SerialisedType_.end();
+       ++SerialisedType_iterator) {
+    ::serialise(*SerialisedType_iterator, Output);
+  }
+}
+
+template <typename first_type, typename second_type>
+void Serialiser<std::pair<first_type, second_type> >::serialise(
+    const std::pair<first_type, second_type> &SerialisedType_,
+    std::ostream &Output) {
+  ::serialise(SerialisedType_.first, Output);
+  ::serialise(SerialisedType_.second, Output);
+}
+
+template <typename integer_type>
+void int_serialise(const integer_type &SerialisedType_,
+                   std::ostream &Output) {
+  try {
+    Output.put(compressedSize(SerialisedType_));
+
+    if (!Output) {
+      std::stringstream what_;
+      what_ << "can't serialise size " << std::hex
+            << /* [1] */ +compressedSize(SerialisedType_) << std::dec;
+      throw SerialisationException(what_.str().c_str());
+    }
+
+    for (unsigned char CompressedSize = compressedSize(SerialisedType_);
+         CompressedSize != 0; Output.put(static_cast<unsigned char>(
+             SerialisedType_ >>
+             std::numeric_limits<unsigned char>::digits * --CompressedSize))) {
+      if (!Output) {
+        std::stringstream what_;
+        what_ << "can't serialise byte " << std::hex
+              << /* [1] */ +static_cast<unsigned char>(
+                     SerialisedType_ >>
+                     std::numeric_limits<unsigned char>::digits *
+                         CompressedSize) << std::dec;
+        throw SerialisationException(what_.str().c_str());
+      }
+    }
+  } catch (const SerialisationException &exc) {
+    std::stringstream what_;
+    what_ << "can't serialise const " << sizeof(integer_type) << " byte integer type: "
+          << exc.what();
+    throw SerialisationException(what_.str().c_str());
+  }
+}
+
+void Serialiser<signed int>::serialise(const signed int &SerialisedType_,
+                                   std::ostream &Output) {
+  // Assumes size_t >= int and signed int != size_t
+  Serialiser<size_t>::serialise(SerialisedType_, Output);
+}
+
+void Serialiser<size_t>::serialise(const size_t &SerialisedType_,
+                                   std::ostream &Output) {
+  // Assumes size_t == uint64_t, ie it is fixed across platforms
+  int_serialise(SerialisedType_, Output);
+}
+
+void Serialiser<wchar_t>::serialise(const wchar_t &SerialisedType_,
+                                    std::ostream &Output) {
+  int_serialise(SerialisedType_, Output);
+}
+
+void Serialiser<char>::serialise(const char &SerialisedType_,
+                                 std::ostream &Output) {
+  int_serialise(SerialisedType_, Output);
+}
+
+void Serialiser<double>::serialise(const double &SerialisedType_,
+                                   std::ostream &Output) {
+  union {
+    uint64_t i;
+    double d;
+  } u;
+  u.d = SerialisedType_;
+  Serialiser<uint64_t>::serialise(u.i, Output);
+}
+
+template <typename Container>
+void Serialiser<Container>::serialise(
+    const Container &SerialisedType_, std::ostream &Output) {
+  ::serialise(SerialisedType_.size(), Output);
+
+  for (typename Container::const_iterator value_type_ =
+           SerialisedType_.begin();
+       // Call .end() each iteration to save memory.
+       value_type_ != SerialisedType_.end(); ++value_type_) {
+    ::serialise(*value_type_, Output);
+  }
+}
+
+// [1] operator+ promotes its operand to a printable integral type.
+
+#endif // SERIALISER_H
Index: trunk/lttoolbox/lttoolbox/stdint_shim.h
===================================================================
--- trunk/lttoolbox/lttoolbox/stdint_shim.h	(nonexistent)
+++ trunk/lttoolbox/lttoolbox/stdint_shim.h	(revision 71731)
@@ -0,0 +1,6 @@
+#ifdef _MSC_VER
+typedef unsigned __int64 uint64_t;
+typedef signed __int64 int64_t;
+#else
+#include <stdint.h>
+#endif
Index: trunk/lttoolbox/lttoolbox/transducer.cc
===================================================================
--- trunk/lttoolbox/lttoolbox/transducer.cc	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/transducer.cc	(revision 71731)
@@ -19,6 +19,8 @@
 #include <lttoolbox/alphabet.h>
 #include <lttoolbox/lttoolbox_config.h>
 #include <lttoolbox/my_stdio.h>
+#include <lttoolbox/deserialiser.h>
+#include <lttoolbox/serialiser.h>
 
 #include <cstdlib>
 #include <iostream>
@@ -561,6 +563,22 @@
 }
 
 void
+Transducer::serialise(std::ostream &serialised) const
+{
+  Serialiser<int>::serialise(initial, serialised);
+  Serialiser<set<int> >::serialise(finals, serialised);
+  Serialiser<map<int, multimap<int, int> > >::serialise(transitions, serialised);
+}
+
+void
+Transducer::deserialise(std::istream &serialised)
+{
+  initial = Deserialiser<int>::deserialise(serialised);
+  finals = Deserialiser<set<int> >::deserialise(serialised);
+  transitions = Deserialiser<map<int, multimap<int, int> > >::deserialise(serialised);
+}
+
+void
 Transducer::copy(Transducer const &t)
 {
   initial = t.initial;
Index: trunk/lttoolbox/lttoolbox/transducer.h
===================================================================
--- trunk/lttoolbox/lttoolbox/transducer.h	(revision 71730)
+++ trunk/lttoolbox/lttoolbox/transducer.h	(revision 71731)
@@ -278,6 +278,9 @@
    */
   void read(FILE *input, int const decalage = 0);
 
+  void serialise(std::ostream &serialised) const;
+  void deserialise(std::istream &serialised);
+
   /**
    * Insert another transducer into this, unifying source and targets.
    * Does not minimize.