Misplaced Pages

This is an old revision of this page, as edited by 84.58.20.210 (talk) at 08:10, 10 August 2007 (→Technical structure format: item INVOICE as part of the preformatted box). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

This article's tone or style may not reflect the encyclopedic tone used on Misplaced Pages. See Misplaced Pages's guide to writing better articles for suggestions. (Learn how and when to remove this message)

SDXF stands for "Structured Data eXchange Format", and was published as Internet RFC 3072.

It allows arbitrary structured data of different types to be assembled together for exchanging between computers of different architectures.

The ability to arbitrarily structure your data and serialize it into a self-describing format is reminiscent of XML, but SDXF is not a text format (as XML)--you cannot manipulate a SDXF structure with a text editor.

Technical structure format

SDXF data can be structured in arbitrary level of deepness. The particular data elements are self-described, that means the information about the type of data (numeric, character string or structure) are encoded into the data elements. The design of this format is very simple, but nevertheless transparent: computer programs accesses SDXF data with the help of well defined functions, it is not necessary for the programmer to care about the precise layout of the data.

The word "exchange" in the labelling SDXF reflects another kind of transparency: the SDXF functions care for a computer architecture independent conversion of the data, the composed structure can be exchanged to other computers (via direct network, file transfer or CD) without further measures. The SDXF functions on the receiving side cares for the correct adaptation.

What exactly means "structured data"? In fact it is not so easily to find an example for non-structured data: Also a common text is structured in lines, paragraphs, etc. But in this context structures have to be recognized and processed by the related programs. Here an example out off the commercial area: Two companies wants to exchange their issuing of invoices on an electronic base. An invoice is therefore an electronic document with following hierarchical nested structure:

INVOICE
│
├─ INVOICE_NO  
├─ DATE
├─ ADDRESS_SENDER
│    ├─ NAME
│    ├─ NAME
│    ├─ STREET
│    ├─ ZIP
│    ├─ CITY
│    └─ COUNTRY
├─ ADDRESS_RECIPIENT
│    ├─ NAME
│    ├─ NAME
│    ├─ STREET
│    ├─ ZIP
│    ├─ CITY
│    └─ COUNTRY
├─ INVOICE_SUM
├─ SINGLE_ITEMS
│    ├─ SINGLE_ITEM
│    │    ├─ QUANTITY
│    │    ├─ ITEM_NUMBER
│    │    ├─ ITEM_TEXT
│    │    ├─ CHARGE
│    │    └─ SUM
│    └─ ...           
├─ CONDITIONS
...

Similar and more complex structures has to be covered with SDXF. How is an SDXF structure build up?

The basic construction element is a "Chunk". The whole SDXF structure is a chunk and a chunk can consist out off a set of chunks. A chunk itself has a very simple construction: It is composed of a header prefix of six bytes, followed by the actual data. The header contains an identification of this chunk as a 2-byte binary number (Chunk_ID), the length and a specification about the type of the following data. It may also contains additional information about compression, encryption and others.

The specification about the type of the data informs us if the data consists of text (a string of characters), or if it presents a binary number (can be an integer or a floating point representation) or if the chunk is build up out off a sequence of other chunks (giving a structured chunk).

Especially the availability of structured chunks enables the programmer to pack such hierarchically constructions as the INVOICE above into an SDXF structure in a simple way: In a first step every named term (INVOICE, INVOICE_NO, DATE, ADDRESS_SENDER, etc.) has to be associated a unique number out off the range 1 to 65535 (2 byte binary integer without sign). At next a first chunk is to be constructed with the ID INVOICE (that means with the associated numerical chunk_ID) as a structured chunk on level 1. This INVOICE chunk will be filled step by step with a sequence of other chunks on level 2: INVOICE_NO, DATE, ADDRESS_SENDER, ADDRESS_RECIPIENT, INVOICE_SUM, SINGLE_ITEMS, CONDITIONS. Some of these chunks on level 2 are structured in turn as for the two addresses and SINGLE_ITEMS. For the date one has the possibility to specify it in text format e.g. in the form YYYY-MM-DD (as standardized in ISO norm 8601) or alternatively as a structure consisting of the three numerical chunks YEAR, MONTH, DAY.

For a precise description see page 2 of the RFC or alternatively (http://pinpi.com/en/SDXF_2.htm)

The concept for SDXF determines also that the programmer has to work on SDXF structures with a well defined set of functions. There are only few of them:

With the invoice example above a creation program may be looks like following code:

 init (sdx, buffersize=1000);   // initialize the SDXF parameter structure sdx
 create (sdx, ID=INVOICE, datatype=STRUCTURED); // start of the main structure
 create (sdx, ID=INVOICE_NO, datatype=NUMERIC, value=123456); // create an elementary Chunk
 create (sdx, ID=DATE, datatype=CHAR, value="2005-06-17"); // once more
 create (sdx, ID=ADDRESS_SENDER, datatype=STRUCTURED); // Substructure
 create (sdx, ID=NAME, datatype=CHAR, value="Peter Somebody"); // element. Chunk inside this substructure
 ...
 create (sdx, ID= COUNTRY, datatype=CHAR, value="France"); // the last one inside this substructure
 leave; // closing the substructure ADDRESS_SENDER
 ...
 leave; // closing the substructure INVOICE

The Syntax of this code is only fictive to simplify matters, for a complete example in the programming language "C" look here.

A code to readout the INVOICE structure looks like:

 init (sdx, container=pointer to an SDXF-structure);   // initialize the SDXF parameter structure sdx
 enter (sdx); // join into the INVOICE structure.
              //
 do while (sdx.rc == SDX_RC_ok)
 {
     switch (sdx.Chunk_ID)
    {
        case INVOICE_NO:
          extract (sdx);    
          invno = sdx.value;  // the extract function put integer values into the parameter field 'value'
          break;
          //
        case DATE:
          extract (sdx);    
          strcpy (invdate, sdx.data); // sdx.data is a pointer to the extracted character string
          break;
          //
        case ADDRESS_SENDER:
          enter (sdx);  // we use 'enter' because ADDRESS is a structured Chunk
          do while (sdx.rc == SDX_RC_ok) // inner loop
           ...
          break;
       ...
    }  
 }

As the example shows the individual SDXF Chunks will be constructed step by step. At a first glance this appears somehow cumbersome, but:

1. This reflects exactly programmer's everyday life: The individual elements are distributed in various program variables or data base fields, in case of external data these elements are not all accessible at the same time.
2. With the processing step by step it is warranted that in case of a structure which consists of mixed data type these data will be transformed to a normalized form, so that the resulting structure can transferred from one computer to an other without further adaptation. Even if these computer differs in their architecture. The problematic of different presentation of data is outlined here (presentation of characters) and there (byte swapping problem).
   With the use of the SDXF functions the application programmer is completely freed from these problems.
3. Encryption (e.g. AES) and compressing (e.g. ZIP) will be maintained by the SDXF functions too. It is also possible to encrypt or compress only parts of a structure. While extracting Chunks the decompressing and decryption will be automatically done (if the encryption key matches).

SDXF is not designed for readability by humans or that it can be modified by text editors. If someone wish to do so a special format is available which reflects an SDXF structure one to one, named SDEF.

See also

• External Data Representation

External links

• Introduction chapter of a more detailed description

• Internet standards
• Internet protocols