KR100938226B1 - Method for storing data according to a size of asn.1 file - Google Patents

Abstract

PURPOSE: A data storing method for storing an ASN.1 file at low cost is provided to efficiently store an ANS.1 file according to the size of the ANS.1 file and to reduce the cost of the ASN.1. CONSTITUTION: A data storing method confirms whether the size of an ASN.1 file is greater than a specified value(S210). If the ASN.1 file is greater than a specific value, information about the ASN.1 file is stored in a general tree structure(S211). If the ASN.1 file is smaller than a specific value, information about ASN.1 file is stored in an array table structure(S220). The ASN.1 file is compiled using the related stored information(S230). A source file and a header file are generated(S240).

Description

How to save data according to the size of the AS.1 file {Method for storing data according to a size of ASN.1 file}

The present invention relates to a method for storing data, and more particularly, to a method for storing a small ASN.1 file (which is a document defined using ASN.1) in an array structure according to the size of the ASN.1 file. will be.

ASN.1 stands for Abstract Syntax Notation # 1, defined in X.680 as a protocol that defines the exchange of data over networks defined by the International Telecommunication Union (ITU). In the OSI reference model, ASN.1 is a notation used to describe data structures, such as managed entities in a network management system.

The different kinds of systems on the network each have their own unique way of representing data. Thus, to exchange messages over a network, it is necessary to define a compatible data representation that is acceptable to all systems. In this environment, ASN.1 is defined. In this ASN.1, Integer or String-type data is defined, and the data representation method such as Sequence or Set, which is a collection of such ASN.1 contents, is defined. Therefore, messages exchanged on most networks can be represented according to the ASN.1 method.

However, in general, information such as reference relations, data types, and constraints between objects in the process of compiling ASN.1 information objects defined in the ASN.1 file (also referred to as ASN.1 document) Meta Data) must be stored, which is essential for the compiler to produce the final output. Since this metadata has a tree-type dependency, the compiler typically stores the metadata in a storage structure having a tree structure.

As such, the tree structure is used as a general information storage structure of the compiler. However, in order to store data in a tree structure method, a relatively large amount of system resources need to be allocated, and processing time also increases. This is because complex implementation of functions such as insert, delete, and search, which are essential functions for configuring tree information, are complicated.

The present invention has been proposed to solve the disadvantages of the prior art described above, and an object thereof is to provide a method for effectively storing an ASN.1 file.

Another object is to provide a way to save ASN.1 files at low cost and reduce compilation time.

To this end, the present invention is a data storage method according to the size of the ASN.1 file. To provide. This storage method includes the steps of reading an ASN.1 file, checking whether the size of the ASN.1 file is greater than or equal to the set value, and storing the relevant information of the ASN.1 file in a general tree structure if the size is larger than the set value. And storing the related information of the ASN.1 file in an array table structure if it is less than the set value, and generating a source and header file by compiling the ASN.1 file using the stored related information.

Of course, for the array table structure, distinguishing the relevant information into equivalent data and components corresponding to the tree structure, and designating a predetermined distance from the current data to at least one of the equivalent data and components based on the current data. A step may be included.

In this case, the predetermined distance may be a distance between the current data and the next equivalent data, or a distance between the current data and the first component.

Therefore, it becomes possible to reconstruct from the array table structure into the tree structure.

According to the present invention, according to the present invention, according to the size of the ANS.1 file to be compiled, the ANS.1 file of medium size or more is stored using a tree structure, and in the case of a small file, the metadata is efficiently stored in an array table. This has the effect of saving a document from ANS.1.

In addition, the present invention can be implemented as a small system resources by storing according to the size of the ANS.1 file, and has another effect of reducing the compilation time.

In addition, the present invention is advantageous in that the search is convenient by using the array table structure, and the logical relationship to the structure of the information can be clearly understood.

Hereinafter, exemplary embodiments of the present invention will be described with reference to the accompanying drawings.

1 is a diagram illustrating a process of developing an application program using an ASN.1 compiler in general. In order to make it easier to understand the sequence number is described as follows.

1) An ASN.1 file (ie, an ASN.1 definition document) 100 is created so that it can be input to the ASN.1 compiler 110. The ASN.1 file 100 can use data definitions defined in the International Standard (ITU-T) or can be defined by the application developer itself.

Therefore, when an application developer creates an ASN.1 file 100 to be used, it can be compiled into the ANS.1 compiler 110.

2) The ASN.1 compiler 110 receives the ASN.1 file 100 and analyzes the generated ASN.1 file 100 to generate a source (.c) file and a header (.h) file 120 including functions such as encoding / decoding. All.

Normally, the ASN.1 compiler is the C source code compiler for ASN.1. That is, the compiler takes the source file of ASN.1 as input, the header (.h) file contains C typedefs, and the source (.c) file contains encoding and decoding functions.

3) The application developer can write a program, a communication flow, and other necessary programs that generate and interpret data exchange packets based on the functions generated by the ASN.1 compiler 110.

4) The application program developer uses the C language compiler 130 suitable for the target system, the program 121 written by the developer, the source 120 generated by the ASN.1 compiler 110, and the data processing software. The library 122 generates an application program 140 that can be compiled and executed together.

In short, when using the ASN.1 compiler 110, it automatically generates encoding / decoding functions related to ASN.1 data and reduces development time and avoids manual development of programs that can provide such functionality. It is possible to reduce the error of the maximum.

That is, the ASN.1 compiler plays the role of parsing the ASN.1 file that defines the data structure using ASN.1 to produce it in the form of the desired program source. In other words, according to the ASN.1 compiler characteristics, ASN.1 files are output as C, C ++, Java, and C # sources, and application developers only need to program the sources in the project.

Based on the understanding of FIG. 1, an embodiment for implementing the present invention will now be described. 2 is a flowchart illustrating a process of compiling according to the size of an ASN.1 file according to an embodiment of the present invention. This is described as follows.

As described above, it is assumed that the ASN.1 file 100 of FIG. 1 is created or provided. Recall that you can use data definitions defined in international standards or you can define your own by the application developer.

The ASN.1 compiler 110 of FIG. 1 reads the ASN.1 file 100 (step S200). At this time, during the compilation of the ASN.1 information objects defined in the ASN.1 file 100, information (meta data) such as reference relations, data types, and constraints between the objects must be stored. These are essential for the compiler to produce the final output. Since this metadata has a tree-type dependency, the compiler usually stores the metadata in a storage structure having a tree structure (hereinafter, referred to as a tree storage structure). An example of this tree structure is shown in FIG.

Therefore, the compiler 110 goes through a process of checking whether the ASN.1 file 100 is a large size (step S210). If the size of the ASN.1 file 100 is large (that is, larger than the set value), the meta data is stored in the tree storage structure (step S211). That is, metadata is stored in the tree structure shown in FIG. 3.

Alternatively, if the size of the ASN.1 file 100 is not large (i.e., smaller than the set value), the meta data is stored in the array table storage structure (step S220). Examples of this are shown in FIGS. 4 and 5. That is, a process of storing meta data by expressing the tree structure shown in FIG. 3 as an array structure is required, which will be described later for clear and easy understanding of the present invention.

Whether the data is stored in the tree storage structure or the array table storage structure, when the storing of the meta data is completed, compilation of the ASN.1 file 100 is performed (step S230).

When the compilation is completed, a write file is performed to be used for the application program (step S240). In other words, a process of parsing the application to an application program and producing it in the form of a desired program source is performed. That is, the source / header 120 of C, C ++, Java, or C # type is generated in the ASN.1 file 100 according to the ASN.1 compiler characteristics. Thus, applying this source / header 120 to the project enables implementation of the present invention.

3 to 5, a process of storing data in an array table method when the size of the ASCII file, which is a feature of the present invention, is small. First, a general tree structure for storing data to understand this is as shown in FIG. 3 is a diagram illustrating a tree structure for storing ASN.1 files of medium and large sizes according to an embodiment of the present invention.

That is, starting with node 0, which is the highest level, from this node 0, node 2 and node 5 are composed of subordinate nodes, and node 2 is configured with node 2, node 3, node 4, node 5 is node 6, It consists of node 7. Of course, the example of FIG. 3 is for the sake of understanding, and the subnodes may be configured more and may have a different tree structure. Therefore, it will be understood by those skilled in the art that the present invention is not limited thereto.

Referring to the tree structure of FIG. 3, the concept of first expressing a tree structure as an array table in order to express the array table is as shown in Table 1 below.

Node Component Equivalent data 0 One - One 2 5 2 - 3 3 - 4 4 - - 5 6 - 6 - 7 7 - -

Here, the component represents data having an inclusion relationship, and the equivalent data represents data having no inclusion relationship.

Table 1 above can be seen as a definition for representing a tree structure as an array table. Therefore, FIG. 4 is a diagram to help understand the process of implementing the array table using this definition.

That is, FIG. 4 is a table showing a relationship with an array table for storing ASN.1 files having a small size, according to an embodiment of the present invention. To illustrate this, in Table 1, for components, [1], [2], and [6] are denoted by "1", indicating that there is a component, and [-] by "0". This means that there is no item. In the case of equivalent data, it becomes [5]-> "4", and [3], [4], and [7] are represented by "1". In other words, if there is similar data and the distance is close, it is indicated as "1". Of course, [-] is represented by "0". This is for the purpose of understanding and the present invention is not limited thereto.

Then, the process of creating and implementing the above process as a program will be described in outline.

First, look at the table:

struct ASN1_INFO_Table

{

ASN1_INFO * asn1_info;

int diff_neighbor;

int diff_child;

}

Here, asn_info is a variable that stores ASN.1 data information, diff_neighbor is the distance between the current data and the next equivalent data in the array, and diff_child defines the distance between the current data and the first component in the array.

Of course, the ASN definition is

A :: = SEQUENCE

{

b B,

f F

}

B :: = SEQUENCE

{

c C,

d D,

   e E

}

F :: = SEQUENCE

{

g G,

   h H

}

That is, the ASN definition represents the tree structure shown in FIG.

struct ASN1_INFO_Table * T =

{

{asn1_info_A, 1 ， 0} ，

{asn1_info_B, 1 ， 4} ，

{asn1_info_C, 0 ， 1} ，

{asn1_info_D, 0 ， 1} ，

{asn1_info_E, 0 ， 0} ，

{asn1_info_F, 1 ， 0} ，

{asn1_info_G, 0 ， 1} ，

{asn1_info_H, 0 ， 0} ，

}

The relevant information in A is as follows.

struct ASN1_INFO_Table * A_info = & T + 0;

The relevant information in B is as follows:

struct ASN1_INFO_Table * B_info = & T + 1;

The relevant information in F is as follows:

struct ASN1_INFO_Table * F_info = & T + 5;

In other words, it is necessary to indicate only that there is a component, so the above can be written.

Then, in order to be able to reconstruct the entire tree structure using B, the contents of the related information asn1_info_B in B are as follows.

struct ASN1_INFO_Table * B_info =

{

Information about the component and equivalent data of {asn1_info_B, 1, 4}, // B, and there is a component because it is 1, and +4 at the current position has information about the equivalent data.

Component of {asn1_info_C, 0 ， 1} ， // B, where equivalent data is 1 apart

Component of {asn1_info_D, 0 ， 1} ， // B, where equivalent data is 1 apart

{asn1_info_E, 0, 0}, // A component of B, no equivalent data

}

That is, this is conceptually shown in FIG. 5 for easy understanding. That is, if the tree of only B shown in FIG. 5 is stored in the "ASN1_INFO_Table * B_info" structure above, the entire tree structure (ie, see FIG. 3) can be derived.

While an embodiment of the present invention has been described above with reference to the accompanying drawings, it will be understood by those skilled in the art that the described embodiments are merely exemplary and not limiting. In addition, those skilled in the art will understand that the present invention can be modified and modified in many ways without changing the technical spirit or essential features. Therefore, the limitations of the present invention should be defined by the contents described in the claims and their equivalents.

1 is a diagram illustrating a process of developing an application program using an ASN.1 compiler in general.

2 is a flowchart illustrating a process of compiling according to the size of an ASN.1 file according to an embodiment of the present invention.

3 is a diagram illustrating a general tree structure for storing an ASN.1 file according to an embodiment of the present invention.

4 is a table showing a relationship with an array table storing an ASN.1 file having a small size according to an embodiment of the present invention.

5 is a diagram illustrating the structure of some trees for reconstructing the entire tree structure according to an embodiment of the present invention.

Claims (5)

Reading the ASN.1 file, Checking whether a size of the ASN.1 file is equal to or larger than a set value; Storing the related information of the ASN.1 file in a general tree structure if the set value is higher than the set value; Storing the related information of the ASN.1 file in an array table structure if the set value is less than the set value; Generating a source and header file by compiling the ASN.1 file using the stored related information Data storage method according to the size of the ASN.1 file including. The method of claim 1, Storing in the array table structure, Distinguishing the related information into equivalent data and components corresponding to the tree structure; And specifying a predetermined distance from the current data to at least one of the equivalent data and the component based on the current data. The method of claim 2, The predetermined distance is a data storage method according to a size of an ASN.1 file, which is a distance between current data and next equivalent data, or a distance between current data and a first component. The method of claim 3, wherein And reconstructing the array table structure from the array table structure to the tree structure. The method of claim 1, The related information is metadata and includes reference relationships, data types, and constraints between objects, The source and header file is a data storage method according to the size of the ASN.1 file of the C, C ++, Java, C # form.

Images