Free xml schema software for linux

DTD to XML Schema translator allows you to translate a Document Type Definition (DTD) into an XML Schema.

DTD to XML Schema translator lets you translate a Document Type Definition into an XML Schema (REC-xmlschema-1-20010502).

The translator can map meaningful DTD entities onto XML Schema constructs (simpleType, attributeGroup, group); the XML document model is not anonymized.

In addition, the translator can map DTD comments onto XML Schema documentation nodes in various ways.

Free available as Java class, Standalone application and as Web tool.

Objective of this project to provide benchmarking toolset for all available multiplatform C/C++ (and some Java) XML parsers.
Main features:
Currently following parsers are supported:
- LibXML2 + GDome + LibXSLT + XML Security
- Apache Xerces for C + Apache Xalan for C + Apacge XML Security for C
- IBM XML4C + IBM Lotus XSL
- Expat + CenterPoint XML + Sablotron + Arabica
- RXP Parser
- Oracle XDK for C/C++
- Oracle XDK for Java
- QT XML Module
- Sun Crismon + Java WebServices Developer Pack 1.2 + Apache XML Security
Following separate benchmarks provided:
- Non-Validating Parsing with Native,SAX,DOM Engines Benchmark
- Creating + Serializing DOM treee Benchmark
- Schema Validation Benchmark
- XSL Transformation Benchmark
- XML Security (Signature, Encryption) Benchmark
Following XML sources supported:
- Any valid XML file (with optional XSL, XSD companions)
- Auto-generated random simple XML file (variable size)
- Auto-generated random XML OPC-DA message sequence (variable size and length
Enhancements:
- Support Apache XML Security for C++, Version: CVS 08.02.2004
- Experemental support for XML Encryption Benchmark for Apache XML Security for C++ from CVS tree.
- Tested againist latest libraries

XML::Compile::Schema is a Perl module to compile a schema.

INHERITANCE

XML::Compile::Schema
is a XML::Compile

SYNOPSIS

# preparation
my $parser = XML::LibXML->new;
my $tree = $parser->parse...(...);

my $schema = XML::Compile::Schema->new($tree);

my $schema = XML::Compile::Schema->new($xml_string);
my $read = $schema->compile(READER => mytype);
my $hash = $read->($xml);

my $doc = XML::LibXML::Document->new(1.0, UTF-8);
my $write = $schema->compile(WRITER => mytype);
my $xml = $write->($doc, $hash);
print $xml->toString;

This module collects knowledge about a schema. The most important method is compile() which can create XML file readers and writers based on the schema information and some selected type.

WARNING: The compiler is implemented in XML::Compile::Schema::Translate, which is NOT FINISHED. See that manual page about the specific behavior and its (current) limitations! Please help to find missing pieces and mistakes.

WARNING: the provided schema is not validated! In some cases, compile-time and run-time errors will be reported, but typically only in cases that the parser has no idea what to do with such a mistake. On the other hand, the processed data is validated: the output should follow the specs closely.

Two implementations use the translator, and more can be added later. Both get created with the compile() method.

XML Reader

The XML reader produces a hash from a XML::LibXML::Node tree, or an XML string. The values are checked and will be ignored if the value is not according to the specs.

XML Writer

The writer produces schema compliant XML, based on a hash. To get the data encoding correct, you are required to pass a document in which the XML nodes may get a place later.

XML::Schema::Type::Simple is a base class for simple XML Schema datatypes.

SYNOPSIS

package XML::Schema::Type::whatever;
use base qw( XML::Schema::Type::Simple );
use vars qw( @FACETS );

@FACETS = (
minLength => 10,
maxLength => 30,
otherFacet => {
value => $n,
fixed => 1,
annotation => "a comment",
},
);

package main;

my $type = XML::Schema::Type::whatever->new()
|| die XML::Schema::Type::whatever->error();

my $item = $type->instance(some instance value)
|| die $type->error();

# NOTE: some issues still to resolve on the precise
# nature and structure of instances (currently hash ref).
print $item->{ value };

The XML::Schema::Type::Simple module is a base class for objects that represent XML Schema simple types.

Schema Crawler project is a platform (database and OS) independent command-line tool to output your database schema and data in a readable form.
The output is designed to be diff-ed with previous versions of your database schema. Schema Crawler is also an API that improves on standard JDBC metadata.
Build
Ant Build
The ant build is a quick build that builds the Schema Crawler jar without compiling and running unit tests. Download ant, and run it from the Schema Crawler directory. The jar file will be created in the _distrib directory. The main targets are all.build and all.clean.
Maven Build
The maven build is a more comprehensive build that runs unit tests, and also creates the project web-site. Download maven, and run it from the Schema Crawler directory. The jar file will be created in the _distrib directory. The main goals are all.build and all.clean.
Eclipse
Schema Crawler consists of two Eclipse projects, dbconnector and schemacrawler. Since schemacrawler depends on dbconnector, you will need to import both projects into Eclipse.
Enhancements:
- Database properties are now retrieved, along with column data types, both system data types, and UDTs.
- A new command, maximum_schema, gives all possible details of the schema, including database system properties.
- Bugs with the merge rows option and with appending output for multiple runs of SchemaCrawler are fixed.
- An SQL exception with the Oracle Database 10g Express Edition driver on outputting views is fixed.

XMLBeans project is a technology for accessing XML by binding it to Java types. XMLBeans provides several ways to get at the XML, including:
- Through XML schema that has been compiled to generate Java types that represent schema types. In this way, you can access instances of the schema through JavaBeans-style accessors after the fashion of "getFoo" and "setFoo".
- The XMLBeans API also allows you to reflect into the XML schema itself through an XML Schema Object model.
- A cursor model through which you can traverse the full XML infoset.
- Support for XML DOM.
Start off with your own stuff:
If you want to get right to it with your own XML schema and instance, follow these basic steps:
Install XMLBeans.
Compile your schema. Use scomp to compile the schema, generating and jarring Java types. For example, to create a employeeschema.jar from an employeesschema.xsd file:
scomp -out employeeschema.jar employeeschema.xsd
Write code. With the generated JAR on your classpath, write code to bind an XML instance to the Java types representing your schema. Heres an example that would use types generated from an employees schema:
File xmlFile = new File("c:employees.xml");
// Bind the instance to the generated XMLBeans types.
EmployeesDocument empDoc =
EmployeesDocument.Factory.parse(xmlFile);
// Get and print pieces of the XML instance.
Employees emps = empDoc.getEmployees();
Employee[] empArray = emps.getEmployeeArray();
for (int i = 0; i < empArray.length; i++)
{
System.out.println(empArray[i]);
}
Enhancements:
- Updated to the latest XMLSchema.xsd - January 25, 2006
- Updated XmlBeans to work with SaxonB-8.6.1 in place of SaxonB8.1
- XQuery external variable binding support

XML::Compile::Schema::XmlReader Perl module contains bricks to translate XML to HASH.

SYNOPSIS

my $schema = XML::Compile::Schema- >new(...);
my $code = $schema- >compile(READER = > ...);

The translator understands schemas, but does not encode that into actions. This module implements those actions to translate from XML into a (nested) Perl HASH structure.

DETAILS

Processing Wildcards

If you want to collect information from the XML structure, which is permitted by any and anyAttribute specifications in the schema, you have to implement that yourself. The problem is XML::Compile has less knowledge than you about the possible data.

anyAttribute

By default, the anyAttribute specification is ignored. When TAKE_ALL is given, all attributes which are fulfilling the name-space requirement added to the returned data-structure. As key, the absolute element name will be used, with as value the related unparsed XML element.

In the current implementation, if an explicit attribute is also covered by the name-spaces permitted by the anyAttribute definition, then it will also appear in that list (and hence the handler will be called as well).

Use XML::Compile::Schema::compile(anyAttribute) to write your own handler, to influence the behavior. The handler will be called for each attribute, and you must return list of pairs of derived information. When the returned is empty, the attribute data is lost. The value may be a complex structure.

Example: anyAttribute in XmlReader

Say your schema looks like this:

< schema targetNamespace="http://mine"
xmlns:me="http://mine" ... >
< element name="el" >
< complexType >
< attribute name="a" type="xs:int" / >
< anyAttribute namespace="##targetNamespace"
processContents="lax" >
< / complexType >
< / element >
< simpleType name="non-empty" >
< restriction base="xs:NCName" / >
< / simpleType >
< / schema >

Then, in an application, you write:

my $r = $schema- >compile(READER = > {http://mine}el
, anyAttribute = > ALL
);

my $h = $r- >( < < __XML );
< el xmlns:me="http://mine" >
< a >42< /a >
< b type="me:non-empty" >
everything
< / b >
< / el >
__XML

use Data::Dumper Dumper;
print Dumper $h;
__XML__
The output is something like
$VAR1 =
{ a = > 42
, {http://mine}a = > ... # XML::LibXML::Node with < a >42< /a >
, {http://mine}b = > ... # XML::LibXML::Node with < b >everything< /b >
};

You can improve the reader with a callback. When you know that the extra attribute is always of type non-empty, then you can do

my $read = $schema- >compile
( READER = > {http://mine}el
, anyAttribute = > &filter
);

my $anyAttRead = $schema- >compile
( READER = > {http://mine}non-empty
);

sub filter($$$$)
{ my ($fqn, $xml, $path, $translator) = @_;
return () if $fqn ne {http://mine}b;
(b = > $anyAttRead- >($xml));
}

my $h = $r- >( see above );
print Dumper $h;
Which will result in
$VAR1 =
{ a = > 42
, b = > everything
};

The filter will be called twice, but return nothing in the first case. You can implement any kind of complex processing in the filter.

XML Copy Editor is an XML editor with DTD/XML Schema/RELAX NG validation, XSLT, XPath, pretty-printing, syntax highlighting, folding, tag completion/locking and lossless import/export of Microsoft Word documents.
Enhancements:
- This release fixes a number of bugs and introduces support for CSS.