----------------------------------------
  FABRIC
----------------------------------------

Fabric is a framework for code generation based on several scientific
publications [1,2,3,4,5]. It is comprised of components for

  - parsing XML Schema and WSDL files into a tree structure, for

  - a module API to walk the tree for codegeneration, and for

  - code generation (Java, C, C++) using simple APIs instead of
    writing to stdout.

In addition, a number of modules are contained that generate code:

  - typegen: A generator to create JavaBean-like container
    classes from XML Schema documents for both Java and C++.

  - exi: An implementation of the Efficient XML Interchange
    specification (http://www.w3.org/TR/exi) for XML (de-)
    serialization.

  - midgen4j: A framework [5] to create a service provider for
    various message-oriented Java middleware technologies.

  - midgen4j-rest: A MidGen4J extension to create a REST
    interface for the Java service provider.

  - midgen4j-websockets: A MidGen4J extension to create a
    WebSockets interface for the Java service provider as
    well as a test client to use the service in a browser.

Formerly, the framework also contained the following modules,
which are no longer included and/or maintained:

  - microFibre: An XML (de-)compression scheme usable for
    ressource-constraint devices [2,3] that generates code
    for Java and C++.

  - macroFibre: An XML (de-)serialization scheme for
    ressource-constraint devices [3] that generates code
    for Java and C++.

  - XML: XML (de-)serialization for easy conversion from/to
    microFibre/macroFibre.

  - protobuf: Converts XML Schema files to Google protobuf
    (http://code.google.com/p/protobuf) files.

Fabric works as follows:

  1.) Input files are XML Schema or WSDL documents, which are parsed
    into a tree. This tree contains most information from the schema
    but abstracts away from all the nasty details of XML Schema
    and WSDL. It automatically resolves all imports, references,
    etc. and the resulting tree can directly be used for code
    generation based on tree-walking.

  2.) A so-called workspace is created that can be used for code
    generation. A workspace represents a set of files of a certain
    language (e.g., Java files) in memory. Users of the workspace use
    language-specific APIs to add components to the files (e.g., a
    Java class). To such elements, further stuff can be added (e.g.,
    methods). The benefit over directly writing code to stdout is
    that code can be added at any time and in almost any order. Once
    the generation is done, the workspace can be serialized to disk.

  3.) A set of modules is invoked to handle the parsed documents. Each
    module may provide multiple item handlers, e.g. to walk the object
    tree of an XML Schema or to process the elements of a WSDL file.

  4.) Eventually, the workspace is written to disk.

----------------------------------------
  CONTACT / WEBSITE
----------------------------------------

Any feedback concerning Fabric or one of its modules is greatly
appreciated. The GitHub fork https://github.com/nepa/fabric is
currently maintained by:

  Sascha Seidel <NetPanther@gmx.net>

Further information about the Fabric framework can be found at:

  http://www.nptech.de/fabric

----------------------------------------
  INSTALLATION / BUILDING
----------------------------------------

No installation is required. To build Fabric, you need at
least Java 6 and Maven 2 or later (http://maven.apache.org).

Before cloning this repository, be sure to enable automatic
conversion of CRLF/LF on your machine using:

  git config --global core.autocrlf input

For more information, please refer to:

  https://help.github.com/articles/dealing-with-line-endings

Clone the repository using:

  git clone git://github.com/nepa/fabric.git

To build the project, run "mvn install" from the command line.
This will build Fabric and place the generated jar file in
target/ and in your local Maven repository.

If you encounter dependency problems, read third-party/INSTALL.

----------------------------------------
  USAGE
----------------------------------------

  java -jar core/target/fabric.core-1.0.one-jar.jar --help

----------------------------------------
  LICENSE
----------------------------------------

Fabric is released under the Modified BSD license. For more
details, please see src/etc/license-header.txt.

When you use Fabric for scientific publications, we would
appreciate if the papers below are referenced.

----------------------------------------
  REFERENCES
----------------------------------------

[1] Dennis Pfisterer, Horst Hellbrueck, and Stefan Fischer. Fabric:
  Towards data type-centric middleware synthesis. In Proceedings
  of the Euro-American Workshop on Middleware for Sensor Networks
  in conjunction with the International Conference on Distributed
  Computing (DCOSS 06), 2006.

[2] Dennis Pfisterer, Marco Wegner, Horst Hellbrueck, Christian Werner,
  and Stefan Fischer. Energy-optimized data serialization for
  heterogeneous WSNs using middleware synthesis. In Proceedings of
  The Sixth Annual Mediterranean Ad Hoc Networking Workshop
  (Med-Hoc-Net 2007), pages 180-187, June 2007.

[3] Dennis Pfisterer: Comprehensive Development Support for Wireless
  Sensor Networks, PhD Thesis, Institute of Telematics, University
  of Luebeck, Germany, 2007.

[4] Sascha Seidel: Metaebene - Fabric als Code Generation Framework
  für Java, C und C++. In Proceedings of LinuxTag Berlin, May 2012.

[5] Sascha Seidel: Middleware generation based upon machine-readable
  service descriptions. Master thesis. Lübeck, July 2013.