WO2005081408A1

WO2005081408A1 - A method of binary encode that adapts to structured data whose code is automatically generated

Info

Publication number: WO2005081408A1
Application number: PCT/CN2004/000122
Authority: WO
Inventors: Wenyuan Li
Original assignee: Utstarcom (China) Co., Ltd.
Priority date: 2004-02-13
Filing date: 2004-02-13
Publication date: 2005-09-01
Also published as: WO2005081408A9; CN1836374B; CN1836374A

Abstract

The present invention discloses a method of binary encode that adapts to structured data whose code is automatically generated, characteristics in, comprising the following steps: Defines BXML encode format; according to specific application requirement, Constructs structured data describe document that adapts to using BXML encode; Uses BXML compiler to read the structured data describe document, according to the command the BXML compiler generates certain specific computer language source code, combines with specific applied logic and transmission mode, achieves the data exchange of the whole application layer. Though providing a kind of encode definition rule, and designing a set of code generation process and rule, the method of the present invention makes the compiler that the research staff research according to these rule can automatically generate coding decoding code .The present invention have the characteristic of broad appliance fields, effectively encode, adapting to code automatically generation, simple and easily achieve.

Description

One suitable for automatic code generation

Binary encoding method for structured data

The present invention relates to a simple and easy structured data encoding technology, in particular to a binary encoding method of structured data suitable for automatic code generation, and specifically, includes description, encoding and automatic code mapping of structured data. . Background technique

Whether it is the Internet or various dedicated communication networks, the exchange of application data is unavoidable. Structured data is the most common way to express application data in the computer world. A smooth exchange between them requires a platform, programming language, and data encoding method that is independent of the transmission. The XML (Extensible Markup Language) proposed by the W3C organization is a widely used data encoding method. XML-based network communication protocols are also widely used, such as XML-RPC (Remote Process Communication), SOAP (Simple Object Access), Jabber (http://www.jabber.org) and more. However, because XML uses text encoding, it consumes a lot of network bandwidth, and parsing it consumes more computer CPU and memory resources. W3C released the XML binary encoding format WBXML (WAP Binary XML). Its core idea is to convert XML tags and attribute types. , Attribute values, and string constants are mapped into single-byte encodings, and encoding conflicts are avoided by using a coding space (codepage). WBXML was originally designed to improve the coding efficiency of WAP's application layer protocol WML (Wireless Markup Language), but because it is simple, efficient, and has characteristics independent of specific applications, it is also used in many other situations, such as Wireless Village (http://www.wireless-village.org), SyncML (http://ww.syncml.org) etc. have different characteristics. In application environments such as Wireless Village, WBXML is used as a communication protocol. Encoding format. All the passed message structures are predefined. Languages such as WML are used to describe the structure of WAP pages. The message structure is unpredictable. Known. Although WBXML has a much higher coding efficiency compared to XML, its programming model has not changed. It still needs to be documented using Document Object Model (DOM) or Simple API for XML (SAX API). This programming model may be suitable for pages. Browser, but it is not necessarily suitable for applications where WBXML is extended (such as Wireless Village), because it is not a direct mapping of computer programming language-oriented data structures, and developers need to write a lot of code to manipulate data related to application information . On the other hand, the mapping of XML tags to single-byte encoding is described by ordinary documents, and developers need to read these documents and manually map them into code. These characteristics make development inefficient and error-prone. If there is an automation tool that can help developers automatically implement data structure mapping from application data structures to computer languages, and automatically implement coding mapping of structural tags, it will greatly improve development efficiency. Summary of the invention

Based on the above analysis, a large number of structurally predictable communication occasions use simple and efficient encoding rules such as WBXML. Therefore, the technical problem to be solved by the present invention is to propose a binary encoding method of structured data suitable for automatic code generation. It is independent of platform, language and transmission of various application data exchanges, such as network communication protocols, data synchronization between intelligent devices, structured data storage, etc.

The binary encoding method for structured data suitable for automatic code generation in the present invention refers to the described encoding rule as binary extensible markup language BXML (Binary XML), and includes the following steps:

Step 1: define a BXML encoding format;

Step 2: According to specific application requirements, construct a structured data description file suitable for BXML encoding;

Step 3: Use a BXML compiler to read the structured data description file, and the BXML compiler generates the source code of a specific computer language according to the command.

Step 4: Combine with specific application logic and transmission methods to achieve complete application-layer data exchange. The method of the present invention provides a code-defined rule and a set of code generation processes and rules so that a compiler developed by a developer according to these rules can automatically generate codecs. The invention has the characteristics of wide application area, efficient coding, suitable for automatic code generation, simple and easy to implement. Overview of the drawings

FIG. 1 is a schematic flowchart of a method according to the present invention;

FIG. 2 is another specific schematic diagram of the method according to the present invention. DETAILED DESCRIPTION OF THE INVENTION

The following describes specific embodiments of the present invention with reference to the accompanying drawings.

The present invention refers to the described coding rules as "BXML (Binary XML)" to show the difference from WBXML.

A schematic flowchart of the method according to the present invention is shown in FIG. 1. The basic idea of the present invention is to first establish a BXML encoding format, which includes a description of a version number, a message length, a character set, an indefinite structure, and the like; construct a structured data description file according to the BXML encoding format; and then use a BXML compiler to read all The structured data description file is described. The BXML compiler generates the source code of a specific computer language according to the command, and combines it with specific application logic and transmission methods to implement the data structure mapping from the application data structure to the computer language. The encoding map of the label.

The following explains the establishment of a BXML encoding format, the construction of a structured data description file, and the generation of source code for a specific computer language.

The BXML encoding format proposed by the present invention is as follows:

BXMLMessage-version msgLength charset ANY

version = u_int8 containing BXML version number

msgLength = u_intl6

charset = mb_u_int32 indicating the charset

ANY = [SWITCH— PAGH codepage] TAG [struct]

struct = * content END

string = string terminated with zero

binary = length * byte

length = integer

union = content

enum = integer

array = * arrayltem END

arrayltem = ARRAY— ITEM (integer | string | binary | struct) version number version: u_int8 containing BXML version number

All BXML-encoded initial bytes represent the BXML version number, and the encoding rules are the same as WBXML. Its upper four bits represent the master version number minus one, and the lower four bits represent the slave version number. For example, version 2.7 is encoded as 0X17. If the version number of the present invention is specified as 1.1, it is encoded as 0X01. Message length msgLength = u_intl6

The message length refers to the variable number of bytes in the subsequent BXML encoding, excluding the version number and the number of bytes occupied by the message length itself. It is encoded as a double-byte integer (in network order). The purpose of this field is to facilitate the use of BXML encoding in connection-oriented transmissions (such as TCP) without affecting the decoder. Character set charset = mb_u_int32

The character set defines the encoding character set used for all basic types of strings in subsequent BXML encodings. The field itself is encoded as a multibyte integer whose integer value is the MIB number assigned by IANA to the character set. If the character set is zero, it means that the default character set has been agreed in advance by the codec.

Considering the simplicity of code generation, the present invention does not accept character sets whose end tag is not a single-byte zero value in the C language, such as UTF-16. In fact, few people use such character sets as the encoding of transmission data, and we can always replace them with other character sets, such as UTF-8 or any special character set (such as GB2312). Indefinite structure ANY = [SWITCH JPAGH codepage] TAG [struct] The ANY part is a tagged structure, and the decoder can know the type of the structure by the tag value. The TAG value is automatically assigned by the BXML compiler. The BXML compiler always assigns TAG values incrementally starting from 0X05 in the order of the structure definitions in a BXML structure description file. The TAG value of the structure is only valid in the corresponding codepage space.

The default codepage value is zero. If the codepage is not zero, the SWITCH— PAGH codepage must appear, and the codepage value specified by it only applies to the following struct. This is different from WBXML. In WBXML, the codepage always takes effect until the next SWITCH—PAGH codepage appears. The consideration of the present invention is that the structure contained in one structure may be located in another codepage space. If the coding rules of WBXML are followed, SWITCH-PAGH may appear repeatedly, and the invention considers that the decoder has predicted the type of any structure member Therefore, codepage and structure TAG are not needed for members of the structure at all, so we define SWITCH-PAGH to take effect only once. This also avoids the need for the decoder to remember the codepage state.

TAG and its space

TAG is encoded as a single byte, which has the following structure:

A TAG is always valid in the space it belongs to. There are three types of TAG spaces, as shown in the following table:

Type of label

Predefined tags are always globally valid and include:

• SWITCH— PAGE (0x00): Used to indicate non-zero codepage space in ANY type encoding, the corresponding codepage is encoded as a single byte without a predefined tag

The number of symbols follows immediately.

• END (0x01): Used to identify the end of a structure or array.

• ARRAY_ITEM (0x82): Used to identify the beginning of an array element. Structure tag values are automatically assigned by the BXML compiler. By BXML compiler always tags by structure

Follow the order of structure definition in a BXML structure description file from 0X05 To assign a TAG value.

At the time of encoding, if the structure is defined as an empty structure or all members of the structure do not appear at run time, the 7th bit of the TAG must be cleared, otherwise it must be set to 1 and ended with an END after the member encoding is finished.

Internal tags are used to identify whether a member appears. Its value is also incremented from 0X05.

The union or struct members are automatically assigned an internal tag by the BXML compiler

Internal label values, they are only valid in the internal space of the respective union or structure; when encoding, if the value of the member does not appear at runtime, the 7th bit of the internal label must be cleared, otherwise it must be set to 1, and the member The encoding of the value immediately follows. Struct = ^ content END

A structure consists of a number of content codes and an END tag. Each content represents a member of a structure. The presence or absence of a structure member is determined by the application logic. The appearance of a member can be with or without a value. The logic decides. Content = INTERNAL— TAG [integer | string | binary | struct I union | enum | array | ANY]

A content represents a member of a structure or union, and it can appear with or without a value. It consists of an internal label and the encoding of the corresponding value. Integer = mb_int32

An integer is encoded as a multi-byte integer with the same rules as WBXML. It consists of a series of bytes. The 7th (most significant) bit of each byte is a continuous flag. If it is 1, it means that the integer also includes the subsequent byte encoding, otherwise it means that the current byte is the last word of the integer. Section encoding. The integer value is represented by concatenating the bits (high to low) of the series of bytes after removing consecutive marks. String = string terminated with a single zero byte

A string is encoded in the encoding specified by the character set and ends with a single-byte zero. Considering the simplicity of code generation, the present invention does not accept character sets whose end tag is not a single-byte zero value in the C language, such as UTF-16. In fact, there are very few People use such character sets as the encoding for transmitting data, and we can always replace them with other character sets, such as UTF-8 or any special character set (such as GB2323). Binary data string binary = length ^A byte

The encoding rules for arbitrary binary data strings are the same as opaque in WBXML, which consists of a length indicator and several bytes of data. Among them, the length indicator refers to the number of bytes of the binary data string, excluding the number of bytes of itself, and it is encoded into a multi-byte integer. Union = content

A union consists of a single content encoding, which can be valued or unvalued. Enum enum = integer

Enumerations are encoded as multi-byte integers that represent the defined enumeration values. Array = * arrayltem END

An array consists of the encoding of several array elements and an END tag. Array element arrayltem = ARRAY ITEM (integer | string | binary | struct)

An array element consists of an ARRAYJ EM tag and the encoding of the element value. The array element type is predictable to the decoder.

The characteristics of WBXML inherited by the BXML encoding format of the present invention mainly include: inheriting the characteristics of elements in WBXML, including element nesting, default, single element without content, etc.

In the encoding, the element tag (Element tag) is still single-byte encoded, and the encoding space (codepage) is used to avoid encoding conflicts;

It inherits some global tokens, such as S WITCH_PAGE, END and so on.

Basic data type encoding rules are the same as WBXML, such as multibyte integers (mb-int), Inline string (opaque) and opaque data (opaque), etc .; BXML-based development process and automatic code generation

The development process is shown in Figure 2. The present invention explains the principle of automatic code generation for the most commonly used computer languages C ++ and JAVA.

First, structured data description files need to be written according to specific application requirements, and then these description files are read using a BXML compiler. The BXML compiler generates the source code of a specific computer language according to commands, such as C ++, JAVA. This automatically generated code contains the following main features:

Structured data types are directly expressed with the same class name and member name. Developers can use these codes to directly set or extract the content of structured data without indirect access like DOM or SAX API.

The code contains codec functions that can be used to generate or parse BXML encoded data. The code can include self-printing functions for easy debugging.

After using the BXML compiler to generate source code, developers can use these codes to combine with specific application logic and transmission methods to implement application data exchange. Developers no longer need to write any codec code, nor do they need to access structured data indirectly. Descriptive file of citrated data

The structured data description file is used to describe the structure of the structured data determined in advance. Its status is similar to that of XML DTD files or Schema files, but unlike XML DTD or Schema files, its purpose is not to perform BXML encoding Verification is used to instruct the compiler to automatically generate program source code and to tell the compiler what codec code should be generated. Here are the rules for structured data description files:

1) Any data exchange always takes place in a certain context (Context), such as a specific protocol interface and so on. A structured data description is always directed to such a context. A context description can consist of one or more BXML structure description files. A run of the BXML compiler is always directed to one context, and it needs to read all the description files of the context at the same time.

2) Each BXML structure description file must use the "page" keyword at the beginning of the file to specify the codepage space of the file, which is valid for all structures described in the file. In one context, the codepage must be unique.

3) Each BXML structure description file should specify the JAVA package name or C ++ namespace required after generating the program source code after the page keyword. They are valid for all descriptions in the file. For different description files in a context, you can specify the same or different JAVA package name or C ++ namespace.

4 :) In a BXML structure description file, any data type defined in the same context can be used directly, but any data type in the same context cannot have the same name.

5) Data types defined with keywords, including:

Integer: keyword is int

U character string: The keyword is string

Opaque binary byte sequence: the keyword is binary

Exclude: keywords are enum

Union: The keyword is union

Structure: The keyword is struct

Indefinite structure: the keyword is ANY

Array: The keyword is arrayof

6) The order of the structure definition in a BXML structure description file is important, it affects the TAG value assigned by the BXML compiler. Both parties to the data exchange must use the same BXML structure description file.

7) The order of member definitions within a structure or union is also important, as it affects the internal tag values assigned by the BXML compiler. The data exchange must use the same BXML structure description file.

For the convenience of developers, the present invention describes structured data in a manner similar to the C language header file. The following example illustrates the format of the description file. Where the underlined part Are keywords, all keywords are displayed.

// file testbxml, oaly for test, no actual meaning page = Q;

package com.test: // forjava

namespace com :: test; // for C ++ enum SessionType {

inband = 1;

outband = 2;

} union SessionAddress {

string url;

_int ipAddress;

} struct SessionDescriptor {

― SessionType type;

SessionAddress address;

string sessionID;

} struct Userlnfo {

string userlD;

int age;

binary key;

} arrayof Userlnfo UserlnfoList;

arrayof int IntegerList

arrayof string StringList;

arrayof binary B inaryList; struct LoginReq {

string devicelD;

UserlnfoList userList;

B inaryList blist;

StringList slist; IntegerList ilist;

} struct Logi Res {} struct Message {

SessionDescriptor desc;

ANY msgBody;

int time;

ANY addition;

}

// end of the test.xml general rules for code generation

In fact, the mapping method from a BXML structure description file to a certain computer programming language should not be unique. The present invention first describes general rules; then, it briefly describes typical mappings to C ++ and JAVA languages.

1) Any data exchange always takes place in a certain context (Context), such as a specific protocol interface and so on. A structured data description is always directed to such a context. A context description can consist of one or more BXML structure description files.

A run of the BXML compiler is always directed to one context, and it needs to read all the description files of the context at the same time. For convenience, all BXML configuration files for a context should usually be placed in the same root directory.

2) An application can have different contexts at the same time. For example, it may have multiple different types of communication interfaces at the same time, and exchange data with different entities. In this way, you need to use the BXML compiler to compile each context separately. Although the tag values of different contexts will conflict, they should be used in different communication interfaces (addresses), and there is no problem with such duplicate tag values. However, there may be situations where data type names conflict in different contexts. This situation should be resolved using different JAVA package names or C ++ namespaces.

3) In a contextual compilation, the BXML compiler starts from 0X05 for each description file: Assigns a structure TAG to each structure in turn. If there are too many structures, they can be distributed to different codepages. The maximum number of application structures for a context is: 256 codepages * (128 tags-5 predefined) = 31488

This is sufficient for most applications.

4) The BXML compiler assigns internal tags to each member of the structure or union in turn, starting from 0X05. The maximum number of internal tags of a structure or union is:

128 tags-5 predefined = 123

It is also sufficient for most structures or unions. The following describes the typical mapping to C ++ and JAVA languages through specific examples. Typical mapping to C ++ language

Enumerated mapping: _ι

BXML structure description

enum SessionType {

inband = 1;

outband = 2; summary of generated C ++ header files

class SessionType

{

public:

DWORD—value;

static const DWORD—inband = 1;

static const DWORD _outband = 2;

SessionType (DWORD value);

SessionType (const SessionType &other);

SessionType & operators—const SessionType &other); void wr / te (BXMLBuffer & buffer, BXMLWriter &w);

string toString (int level);

static SessionType * parseStatic (uBYTE id, BXMLBuffer & buffer, BXMLParser &p);

A); one .... · ·: _;:

'：：' ^: ·· ':.: ·: ·: ··::.' ■ ::

1) An enum type is mapped to a C ++ class with the same name;

2) A _value integer member variable represents the current enumeration value; 3) For each enumerated constant, use a static integer constant;

4) Copy constructor and assignment operator overloading should be supported;

5) The write member function is used to encode the enumeration object itself;

6) For debugging purposes, the toString member function is used to output the printable string of the object itself. The string should be represented in a human-readable manner. For example, the enumeration object in the above example may output the string "inband".

7) The parseStatic static member function is used to decode an enum object.

SessionDescriptor * _desc;

ANY * — msgBody;

DWORD * —time;

ANY * —addition;

bool a desc— presence;

bool—msgBody— presence;

bool—time— presence;

bool—addition— presence;

Message ();

Message (const Message &other);

Message & operator = (const Message &other);

virtual -Message ();

virtual ANY * duplicate ();

virtual uBYTE getCodepage ();

virtual uBYTE getTag ();

virtual void write (BXMLBuffer & buffer, BXMLWriter & w, bool withtag); virtual string toString (int level, boo! withtag);

virtual ANY * parse (uBYTE id, BXMLBuffer & buffer, BX LParser &p); static Message * parseStatic (uBYTE id, BXMLBuffer & buffer, BXMLParser &p); void set_desc (SessionDescriptor * desc);

void set_desc (const SessionDescriptor &desc);

void set_msgBody (ANY * msgBody);

void setJime (DWORD * time);

void set_time (DWORD time);

void set_addition (ANY * addition);

void unset_desc ();

void unset_msgBody ();

void unset_time ();

void unset_addition ();

SessionDescriptor * get a desc ();

ANY * get_msgBody ();

DWORD * getjime ();

ANY * get_addition ();

bool desc_presence ();

bool msgBody_presence ();

bool time_presence ();

bool addition presenceQ; private:

void init ();

};

-;,,

1) A structure is mapped to a C ++ class with the same name, which inherits the ANY class;

2) Jag and — codepage static member constants are used to record the codepage specified by the TAG and BXML structure description file assigned by the BXML compiler for the structure;

3) For each structure member, use a static member constant to record the internal tag value assigned by the BXML compiler;

4) For each structure member, a member pointer variable with the same name prefixed with "―" is used to represent the value of the member. If the value pointer of the member identified as being present by the corresponding presence variable is empty, it means that the member has no value;

5) For each structure member, a xxx_presence variable is used to identify whether the corresponding member appears;

6) For each structure member, there should be thousands of overloaded set_xxx member functions to set the value of the members. The set_XXX function should generally include the form of the takeover pointer and the form of the copy number.

7) For each structure member, use an unset_XXX member function to set the member to not appear;

8) Copy constructor and assignment operator overloading should be supported;

9) The write member function is used to encode the object itself;

10) For debugging purposes, the toString member function is used to output the printable string of the object itself.

11) The parse virtual member function in the base class ANY should be implemented for decoding, which calls the parseStatic function;

12) The parseStatic static member function is used to decode a structure object.

Mapping of arrays:

BXML structure description

arrayof Userlnfo UserlnfoList;

arrayof int IntegerList;

arrayof string StringList;

arrayof binary BinaryList;

Summary of generated C ++ header files

class UserlnfoList: public vector <Userlnfo *>

{

public;

UserlnfoListQ;

UserInfoList (const UserInfoList &other);

~ UserInfoList ();

UserInfoList & operator = (const UserInfoList &other);

void clean ();

void write (BX LBuf er & buffer, BXMLWriter &w);

string toString (int level); static UserlnfoList * parseStatic (uBYTE id, BXMLBuffer & buffer, BX LParser &p); void add (const UserInfo &val);

}; Class IntegerList: public vector <DWORD> public:

IntegerList ();

IntegerList (const IntegerList &other);

~ IntegerList ();

IntegerList & operator = (const IntegerList &other);

void clean ();

void write (BX LBuf er & buffer, BXMLWriter &w);

string toString (int level);

static IntegerList * parseStatic (uBYTE id, BXMLBuf er & buffer, BXMLParser &p);

}; Class StringList: public vector <string *>

{

public:

StringList ();

StringList (const StringList &other);

-StringList ();

StringList &

StringList &other);

void clean ();

void write (BXMLBuffer & buffer, BXMLWriter &w);

string toString (int level);

static StringList * parseStatic (uBYTE id, BXMLBuffer & buffer, BXMLParser &p); void add (const string &val);

void add (const char * val);

}; Class Binar List: public vector <ByteArray *> public:

Binar List ();

BinaryList (const Binar List &other);

~ BinaryList ();

BinaryList & operator = (const BinaryListfe: other); void clean ();

void write (BXMLBuf er & buffer, BX LWriter &AV);

string toString (int level);

static BinaryList * parseStatic (uBYTE id, BXMLBuf er & buffer, BX LParser &p);

void add (const ByteArray &val);

void add (const BYTE * val _a int len);

1) An array type is mapped to a C ++ class with the same name, which inherits an STL vector template class;

2) Copy constructor and assignment operator overloading should be supported;

3) The write member function is used to encode the array ³ like itself;

4) For debugging purposes, the toString member function is used to output the printable string of the object itself.

5) The parseStatic static member function is used to decode an array object. Integer mapping:

An integer is mapped to a C ++ DWORD type, and there are one in the BXML runtime; the BXMLInt class is used to support its encoding and decoding and the output function of printable strings <String mapping:

A string is mapped to the C ++ STL string type. There is a BXMLString class in the BXML runtime to support its encoding and decoding and the output of printable strings. Mapping of binary byte sequences:

A binary byte sequence is mapped to C ++ 's STL vecotor <BYTE> type. There is a BXMLBinary class in the BXML runtime to support its encoding and decoding and the ability to print strings. Indefinite structure mapping:

The indefinite structure is mapped to the ANY class in the BXML runtime, which is also the base class where all structures are mapped into C ++ classes. The definition of the ANY class is summarized as follows: class ANY public: static ANY * parseANY (uBYTE id, BXMLBuffer & buffer, BXMLParser &p); virtual -ANY () {};

virtual ANY * dupiicate () = 0;

virtual uBYTE getCodepageQ = 0;

virtual uBYTE getTag ()-0;

virtual ANY * parse (uBYTE id, BXMLBuffer & buffer, BXMLParser & p) = 0;

virtual void write (BXMLBuf er & buffer, BXMLWriter & w, bool withtag) = 0;

virtual string toString (int level, bool withtag) = 0;

In addition, there are two important classes in the BXML runtime: BXMLWriter and BXMLParser, which are used to support encoding and decoding of top-level BXML data. Mapping to Java

Enumerated mapping:

Structural mapping:

BXML structure description struct Message {

SessionDescriptor desc;

ANY msgBody; int time;

ANY addition;

public boolean time_presence ()

public boolean addition_presence ()

public ANY parse (int id, InputStream in, BXMLParser p)

public static Message parseStatic (int id, InputStream in, BXMLParser p) public void write (OutputStream out, BXMLWriter, boolean withtag) public String toString (int level, boolean withtag)

1) Similar to C ++ mapping rules, please refer to the previous description. Mapping of arrays:

BXML structure description

arrayof Userinfo UserlnfoList;

arrayof int IntegerList;

arrayof string StringList;

arrayof binary BinaryList;

Generated JAVA Class Summary

public final class UserlnfoList extends Vector

{

public Userinfo getltem (int i)

public static UserlnfoList parseStatic (int id, InputStream in, BXMLParser p) public void write (OutputStream out, BXMLWriter w)

public String toString (int level)

} public final class IntegerList extends Vector

{

public Integer getltem (int i)

public static IntegerList parseStatic (int id, InputStream in, BXMLParser p) public void write (OutputStream out, BXMLWriter w)

public String toString (int level)

} public final class StringList extends Vector

{

public String getltem (int i)

public static StringList parseStatic (int id, InputStream in, BXMLParser p) public void write (OutputStream out, BXMLWriter w)

Integer mapping:

An integer is mapped to JAVA's Integer type, which is available in the BXML runtime. • The BXMLInt class is used to support encoding and decoding of it and the output of printable strings.

Mapping of strings:

A string is mapped into the JAVA String type. There is a BXMLString class in the BXML runtime to support its encoding and decoding and the output of printable strings. Mapping of binary byte sequences:

A binary byte sequence is mapped to JAVA's byte [] type. There is a BXMLBinary class in the BXML runtime library to support encoding and decoding of it and the output of printable strings. Indefinite structure mapping:

The indefinite structure is mapped to the ANY class in the BXML runtime. It is also the base class for all structures mapped to JAVA classes. The definition of the ANY class is summarized as follows: public abstract class ANY {

public static ANY parseANY (int id, InputStream in, BXMLParser p);

public abstract ANY parse (int id, InputStream in, BXMLParser p);

public abstract void write (OutputStream out, BX LWriter w, boolean with tag);

public abstract int getCodepage ();

public abstract int getTag ();

public abstract String toString (int level, boolean withtag);

} In addition, there are two important classes in the BXML runtime: BXMLWriter and

BXMLParser, used to support encoding and decoding of top-level BXML data.

An application running example uses the BXML structure description file described in the previous example, and then uses the source code generated by the BXML compiler to develop an application that constructs structured data with the Message structure defined in the description file as the top-level structure. Then use the self-print function of this structure to output the data content, and use the encoding function to perform BXML encoding.

Self-printed output of Message structure:

Message

desc

type

outband

address

url

sip: j oe.li@utstar.com ''

sessionID

abed

msgBody

LoginReq

devicelD

UTStarcomABC

userList

Userlnfo

userlD

Joe.Ii

age 29

key

Oc 16 00 17

Userlnfo

userlD

Mike

age

25

key

38 23 Oc 43 45

biist

4e c8

15 19 06

slist

string 1

string2

ilist

30 '

800

time

540394

addition

The total length of the data after LoginRes is encoded by the encoding function is 138 bytes, and its content is expressed in hexadecimal: ^:

01 00 87 6a 89 S5 85 02 86 85 73 69 70 3a 6a 6f 65 2e 6c 69 40 75 74 73 74 61 72 2e 63 6f 6d 00 87 61 62 63 64 00 01 86 87 85 55 54 53 74 61 72 63 6f 6d 41 42 43 00 86 86 85 4a 6f 65 2e 6c 69 00 86 Id 87 04 0c 16 00 17 01 86 85 4d 69 6b 65 00 86 19 87 05 38 23 0c 43 45 01 01 87 82 02 4e c8 82 03 15 19 06 01 88 82 73 74 72 69 6e 67 31 00 82 73 74 72 69 6e 67 32 00 01 89 82 le 82 86 20 01 01 87 aO fd 6a 88 08 01 The explanation of the above BXML encoding is shown in the following table:

Byte Sequence Explanation

01 BXML version: 1.1

00 87 subsequent encoded data length is 135 bytes

6a character set is UTF-8

89 Message structured tag with content

85 Message structure internal tag desc, with content 85 Internal tag type for SessionDescriptor structure, yes.

Content

02 SessionType value outband

86 SessionDescriptor structure internal label address, with content

85 SessionAddress enumeration internal label url, with content

73 69 70 3a 6a 6f 65 2e 6c 69 The value of the url string: sip: joe. Li @ utstar. Com

40 75 74 73 74 61 72 2e 63 6f

6d 00

87.Internal label of SessionDescriptor structure

sessionID with content

61 62 63 64 00 The value of the SessionID string: abed

01 SessionDescriptor structure ends

86 Message structure's internal tag msgBody, with content

87 LoginReq structure tag with content (codepage does not appear, indicating codepage is 0)

85 Internal tag devicelD of LoginReq structure, with content

55 54 53 74 61 72 63 6f 6d 41 DevicelD string value: UTStarcomABC

42 43 00

86 LoginReq structure internal tag-userList, with content

82 ARRAY ITEM global label

85 Internal tag of Userlnfo structure-userlD, with content

4a 6f 65 2e 6c 69 00 UserlD string value: Joe.li

86 Userlnfo structure internal tag-age, with content

Id age value: 29

87 Internal label of Userlnfo structure-key, with content

04 key binary byte sequence has length 4

0c 16 00 17 content of key binary byte sequence

01 End of Userlnfo structure

82 ARRAY ITEM global label

85 Internal tag of Userlnfo structure-userlD, with content

4d 69 6b 65 00 userlD string value: Mike

86 Userlnfo structure internal tag-age, with content

19 age is 25

87 Internal label of Userlnfo structure-key, with content

05 key binary byte sequence has length 5 38 23 0c 43 45 key binary byte sequence content

01 End of Userlnfo structure

01 end of userList array

87 Internal tag of LoginReq structure-bList, with content

82 ARRAY ITEM global label

02 binary byte sequence is 2 in length

4e c8 binary byte sequence contents

82 ARRAY ITEM global label

03 Binary byte sequence is 3 in length

15 19 06 Content of binary byte sequence

01 bList array ends

88 LoginReq structure internal tag-sList, with content

82 ARRAY ITEM global label

73 74 72 69 6e 67 31 00 string: string 1

82 ARRAY ITEM global label

73 74 72 69 6e 67 32 00 string: string2

01 end of sList array

89 LoginReq structure internal tag-iList, with content

82 ARRAY ITEM global label

le integer: 30

82 ARRAY ITEM global label

86 20 Integer: 800

01 iList array ends

01 LoginReq structure ends

87 Internal tag of Message structure-time, with content

aO fd 6a integer: 540394

88 Message structure internal tag addition, with content

08 LoginRes structure tag, no content (codepage does not appear,

Means codepage is 0)

01 Message structure ends In summary, the improvement of the present invention on WBXML mainly includes:

Corresponds the elements of WBXML with the structure data type of the computer language, and all element tags represent the corresponding structure type codes;

Add the concept of internal tag. The internal tag is explained in a structure and represents a corresponding member of the structure. The internal tag can carry the content of the tag according to the needs of the runtime. (I.e. member value), may also carry no content (i.e. no value appears), or may not appear (i.e. member is absent);

The content carried by the internal tag no longer needs any other tag tags, because the type is predicted, except when the member type is an indefinite structure (ANY);

The content carried by the internal label is directly encoded according to the corresponding member type. For example, integers are encoded as multi-byte integers. Unlike WBXML, which still uses string encoding;

Add a predefined global tag-ARRAY_ITEM, used to separate array elements;

Attributes that specifically support WBXML are not considered, but attributes can be expressed by adding structure members;

Does not consider specifically supporting string constants in WBXML, but can be expressed by enumeration types;

Although the method of the present invention has been described by way of example with reference to the accompanying drawings, the present invention is not limited to these details, and the present application covers various modifications or changes within the scope of the claims. Industrial applicability

According to the method of the present invention, a binary encoding method of structured data suitable for automatic code generation is proposed. The present invention is applicable to the exchange of various application data independent of the platform, language and transmission, such as network communication protocols, Data synchronization, structured data storage, etc.

Claims

Rights request

1. A binary encoding method for structured data suitable for automatic code generation, characterized by comprising the following steps:

Step 1: define a BXML encoding format;

Step 4: Combine with specific application logic and transmission methods to achieve complete application-layer data exchange.

The method for binary encoding of structured data suitable for automatic code generation according to claim 1, characterized in that a structured data description file is constructed according to the following requirements: a structured data description is always directed to a specific context, a A context description can consist of one or more BXML structure description files; a run of the BXML compiler always reads all description files of a context simultaneously for one context.

3. The binary encoding method for structured data suitable for automatic code generation according to claim 2, wherein each BXML structure description file must use a keyword at the beginning of the file to specify the encoding space of the file. All structures described in this file are valid; in one context, the coding space must be unique.

The method for binary encoding of structured data suitable for automatic code generation according to claim 3, wherein each BXML structure description file specifies a package name or a namespace required after generating a program source code after a keyword , They are valid for all descriptions in the file; for different description files in a context, you can specify the same or different package names or namespaces. The encoding method is characterized in that a BXML structure description file can directly use a data type defined in any BXML description file of the same context, and any data type of the same context cannot have the same name.

6. The method for binary encoding of structured data suitable for automatic code generation according to claim 1, characterized in that, when defining a BXML encoding format, it further comprises defining a tag TAG, wherein the tag TAG is encoded into a single byte.

The binary encoding method for structured data suitable for automatic code generation according to claim 6, wherein the highest byte of the single byte is used to indicate whether the TAG has subsequent content encoding.

The binary encoding method for structured data suitable for automatic code generation according to claim 6, wherein the 0th to 6th bits of the single byte are used to define a TAG identifier.

The binary encoding method for structured data suitable for automatic code generation according to claim 8, wherein a certain range of the single byte is reserved as a predefined tag.

The method for binary encoding of structured data suitable for automatic code generation according to any one of claims 6 to 9, characterized in that a tag TAG is always valid in the space to which it belongs.

11. The method for binary encoding of structured data suitable for automatic code generation according to any one of claims 6-9, wherein the TAG has three types: a predefined tag that is always globally valid, a structure tag, Automatically assigned by the BXML compiler; internal tags are used to identify whether a member appears.

12. The binary encoding method for structured data suitable for automatic code generation according to claim 1, wherein the defining the BXML encoding format comprises a data type defined by a keyword:

Integer: keyword is int

String: The keyword is string

Opaque binary byte sequence: the keyword is binary

Enumeration: keyword is enum

Union: The keyword is union

Structure: The keyword is struct

Indefinite structure: the keyword is ANY

Array: The keyword is arrayof.

13. The binary encoding method for structured data suitable for automatic code generation according to claim 1, wherein a context description can be composed of one or more BXML structure description files.

14. The method for binary encoding of structured data suitable for automatic code generation according to claim 1, characterized in that, corresponding to a plurality of different types of communication interfaces, an application can have different contexts at the same time to adapt to multiple Different types of functional entities exchange data. The encoding method is characterized in that in one context compilation, the BXML compiler assigns a structure TAG to each structure in turn for each description file; if the number of structures on a page exceeds 123, it is distributed to the encoding space of different files In a context, the maximum number of application structures is 31488.

16. The method for binary encoding of structured data suitable for automatic code generation according to claim 14, wherein the BXML compiler assigns internal tags to each member of a structure or joint in turn, one structure or joint The maximum number of internal labels is 123.

17. The binary encoding method for structured data suitable for automatic code generation according to claim 1, wherein the source code provides a direct mapping of the structured data description to the code, and implements the structure automatically. The encoding mapping of tags and the corresponding BXML codec and self-printing functions.

18. The method for binary encoding of structured data suitable for automatic code generation according to claim 1, wherein the BXML encoding format includes version number, message length, character set and basic data type, union, enumeration , Structure and indefinite description.