CN113051002A - Data editing method, device and storage medium - Google Patents
Data editing method, device and storage medium Download PDFInfo
- Publication number
- CN113051002A CN113051002A CN202110297464.3A CN202110297464A CN113051002A CN 113051002 A CN113051002 A CN 113051002A CN 202110297464 A CN202110297464 A CN 202110297464A CN 113051002 A CN113051002 A CN 113051002A
- Authority
- CN
- China
- Prior art keywords
- class
- data
- unit
- data unit
- behavior
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 92
- 238000003860 storage Methods 0.000 title claims abstract description 17
- 230000007246 mechanism Effects 0.000 claims abstract description 38
- 230000006399 behavior Effects 0.000 claims description 147
- 230000006870 function Effects 0.000 claims description 81
- 238000011068 loading method Methods 0.000 claims description 16
- 238000004590 computer program Methods 0.000 claims description 13
- 238000011161 development Methods 0.000 abstract description 5
- 230000008569 process Effects 0.000 description 13
- 238000010586 diagram Methods 0.000 description 11
- 238000004891 communication Methods 0.000 description 9
- 238000005516 engineering process Methods 0.000 description 9
- 238000007726 management method Methods 0.000 description 9
- 230000009471 action Effects 0.000 description 8
- 238000009877 rendering Methods 0.000 description 5
- 230000008878 coupling Effects 0.000 description 4
- 238000010168 coupling process Methods 0.000 description 4
- 238000005859 coupling reaction Methods 0.000 description 4
- 230000000694 effects Effects 0.000 description 4
- 230000004048 modification Effects 0.000 description 4
- 238000012986 modification Methods 0.000 description 4
- 238000012545 processing Methods 0.000 description 4
- 230000003068 static effect Effects 0.000 description 4
- 230000003542 behavioural effect Effects 0.000 description 3
- 238000005286 illumination Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 230000004044 response Effects 0.000 description 3
- 238000005520 cutting process Methods 0.000 description 2
- 238000012423 maintenance Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000013523 data management Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 239000011800 void material Substances 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The embodiment of the application provides a data editing method, data editing equipment and a storage medium. In the data editing method, data units are stored in classes, each class having a class description. When the data unit is required to be edited, the data unit can be acquired based on a reflection mechanism only by acquiring the class description of the class in which the data unit is located without paying attention to the structure of the data unit. On one hand, the code frame for generating the editing panel for the data unit can be reused for the data units with various different structures, so that the development cost is reduced; on the other hand, when the structure of the data unit changes, the mode of accessing the data unit is not affected, and the access efficiency is improved.
Description
Technical Field
The present application relates to the field of internet technologies, and in particular, to a data editing method, device, and storage medium.
Background
A large system needs to organize and manage a large amount of data and to process the corresponding data using corresponding behaviors. Typically, similar data, or data that needs to be used in an activity, will be organized together. When a system executes a certain function based on data, it needs to find out the behaviors corresponding to the data and execute the behaviors on the data. In a large-scale system, how to process shared data and behaviors and create a reasonable association mode for the data and the behaviors are key links for improving the performance of the system.
In a common prior art, common data and behaviors are extracted as units respectively, and different system functions are realized based on a unit combination mode. However, in this method, the extracted cells are not directly oriented to the system function, and readability and usability are poor. Meanwhile, the coupling of the behavior unit and the data unit is high, which is not beneficial to improving the cohesion of the system. Therefore, a new solution is yet to be proposed.
Disclosure of Invention
Aspects of the present disclosure provide a data editing method, device, and storage medium to improve system cohesiveness and system code reusability.
An embodiment of the present application provides a data-driven system function loading method, where a source file of the system includes: a plurality of classes, each class having a class description; in the multiple classes, the class for storing the behavior unit and the class for storing the data unit are mutually decoupled; the method comprises the following steps: acquiring configuration data of the system, wherein the configuration data comprises an identifier of a behavior unit corresponding to a function to be loaded; determining a class description of a first target class corresponding to the identification of the behavior unit from the registered class descriptions based on a reflection mechanism; according to the class description of the first target class, inquiring member methods corresponding to the behavior units from the first target class; and calling a member method corresponding to the behavior unit, creating the behavior unit in a memory of the system, and driving the function of the system based on the configuration data.
Further optionally, before invoking the member method corresponding to the behavior unit and creating the behavior unit in the memory of the system, the method further includes: determining an identity of a data unit required by the system; based on a reflection mechanism, determining the class description of the second target class where the data unit is located according to the identifier of the data unit; accessing the second target class in the resource file according to the class description of the second target class to obtain the data unit; and loading the data unit into a memory for use by the behavior unit to drive a function of the system based on the data unit.
Further optionally, the method further comprises: responding to the editing operation of an editor, and determining the identification of the data unit to be edited; determining the class description of a third target class in which the data unit to be edited is located according to the identifier of the data unit to be edited; determining member variables corresponding to the data unit to be edited from the third target class according to the class description of the third target class based on a reflection mechanism; assigning values to the editing objects in the code template of the editor according to the member variables to obtain editing codes of the data units to be edited; and operating the editing codes of the data units to be edited, and generating an editing panel of the data units to be edited so that a user can edit the data units to be edited.
Further optionally, based on a reflection mechanism, according to the class description of the third target class, determining, from the third target class, a member variable corresponding to the data unit to be edited, including: accessing member variables in the third target class based on the class description of the third target class; if the type of the accessed member variable is the basic data type, taking the accessed member variable as a member variable corresponding to the data unit to be edited; if the accessed member variable is of the type of the class description, performing recursive traversal on the accessed member variable based on the class description of the accessed member variable until the member variable of the basic data type is accessed and is used as the member variable corresponding to the data unit to be edited.
Further optionally, the method further comprises: responding to the operation of the newly added behavior unit, and acquiring the class description of a fourth target class in which the newly added behavior unit is located; and registering the class description of the fourth target class to update the registered class description so as to access the newly added behavior unit subsequently according to the class description of the fourth target class.
Further optionally, the method further comprises: responding to the operation of the newly added data unit, and acquiring the class description of a fifth target class in which the newly added data unit is positioned; and registering the class description of the fifth target class to update the registered class description so as to access the newly added data unit according to the class description of the fifth target class subsequently.
Further optionally, the method further comprises: acquiring real-time load data of the system; displaying the real-time load data so that a user can update the configuration data according to the real-time load data; and acquiring updated configuration data, and dynamically adjusting the behavior unit which runs in the system in real time according to the updated configuration data.
Further optionally, the method further comprises: determining a functional module contained in the system; and splitting the functional module according to the sub-functions contained in the functional module to obtain behavior units corresponding to the sub-functions.
In the system function loading system provided by the embodiment of the application, a source file of the system includes a plurality of classes in which behavior units are stored, and each class has a class description; when the function is loaded, the method decides which member methods in the classes are called to create the behavior unit according to the externally input data (namely, configuration data), and can determine the system operation logic based on the external data, thereby realizing the data driving of the system. On the premise that the behavior of the system is determined by externally input data, the operation behavior of the system can be changed by changing the externally input data, so that a new system function is realized, and the usability and reusability of the system are improved.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:
fig. 1 is a schematic flowchart of a system function loading method according to an exemplary embodiment of the present application;
FIG. 2 is a schematic flow diagram of a runtime creation subsystem provided by an exemplary embodiment of the present application;
fig. 3 is a schematic structural diagram of an electronic device according to an exemplary embodiment of the present application.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the technical solutions of the present application will be described in detail and completely with reference to the following specific embodiments of the present application and the accompanying drawings. It should be apparent that the described embodiments are only some of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
A system with specific functions needs to organize and manage a large amount of data and process the corresponding data with corresponding behaviors. Typically, similar data, or data that needs to be used in an activity, will be organized together. The system finds the behaviors corresponding to the data through some solutions and executes the behaviors on the data to complete the execution of one system function.
When building a system, the following points are usually needed to improve the system performance:
first, how to handle shared data and behavior. The need for a system provides a multitude of different functions, some of which require some common data and behavior. Therefore, when designing a system, if a plurality of functions can share part of data and behaviors, it is possible to avoid repeatedly implementing the same data structure in each behavior.
And secondly, the association mode of data and behaviors. Each action requires specific data, and how to find the required data when executing a certain action determines the coupling degree of the action and the data. If the coupling between the behavior and the data is too high, the reusability of the behavior and the data is deteriorated, and further, when a similar behavior is realized for a similar data structure, a large amount of codes are easily added due to a slight difference.
And thirdly, how to describe data and behaviors to realize functions. The data structures and behaviors are typically hard-coded with specific code. If different functions need to be realized, codes need to be directly modified to modify a data structure or behavior logic, so that the expansion cost and the maintenance cost of the system are higher.
In view of the above technical problems, in some embodiments of the present application, a solution is provided, which on one hand decouples the relationship between the operation logic and the behavior of the function and the data, and on the other hand, adopts a data driving concept, so that the function of the system is driven by the externally input data, thereby improving the cohesion of the system. The technical solutions provided by the embodiments of the present application are described in detail below with reference to the accompanying drawings.
In the embodiment of the application, the functions of the system can be previously split into a plurality of behavior units (or called components) and a plurality of data units according to the functions of the system, that is, behaviors and data which need to be shared are extracted as units to be shared.
The data unit comprises a group of data which are strongly related in logic and use. For example, the data unit may include: location data unit, color data unit, distance data unit, angle data unit, scene data unit, etc.
The behavior unit includes a function that can perform a specific operation on data. One unit of behavior can be used to perform one behavior alone. For example, the behavior unit may include: a move (move) unit, a culling (culling) unit, a rendering (render) unit, a data management (management) unit, and so on.
The system in this embodiment may be implemented as a game system, a logistics storage system, a business over management system, and the like, but the embodiment includes but is not limited to this. When the system needs to be implemented as a system with a specific function, the function of the system can be split into an appropriate behavior unit and an appropriate data unit according to the business logic of the system.
Taking the system implemented as a game system as an example, in a game scene, the functions of objects (entities) in the game system can be decomposed into a plurality of behavior units and data units required by the behaviors, and the units are combined to obtain the final entities in the game system.
The combination of the action units and the data units can be various, and game entities with different functions can be obtained by freely combining the action units and the data units based on various kinds. For example, for objects in a game system, position data is needed, as well as the act of updating the position data. At this time, the location data unit and the behavior unit of the mobile location can be extracted to be shared by all entities.
The behavior unit and the data unit can be respectively packaged in the classes, and the behavior unit and the data unit are located in different classes to achieve decoupling between the behavior unit and the data unit. That is, among the plurality of classes included in the system source file, the class for storing the behavior unit and the class for storing the data unit are decoupled from each other to reduce the dependency relationship between the data unit and the behavior unit.
The behavior taken by the action unit may depend on the data content contained in the data unit combined with the action unit.
Continuing with the game system as an example, in a game scenario, a pointer or index of a class of data units may be stored in a game entity, and the data units may be obtained through the pointer or index. A pointer or index to a set of data elements may constitute a game entity. When the data units of the game entity are combined with different behavior units, different functions of the game entity can be realized. For example, when a color data unit of a game entity is combined with a rendering unit, the rendering unit may implement a color rendering function of the game entity; when the color data unit of the game entity is combined with the light-emitting unit, the light-emitting unit can realize the function of enabling the game entity to emit light with color; when the color data unit of the game entity is combined with the drawing unit, the drawing unit can realize the function of drawing the image with the specific color by the game entity, and the description is omitted.
In the present embodiment, a method for accessing a data unit and a behavior unit based on a "reflection (reflection) mechanism" is provided. In the reflection mechanism, for each class packaged with a data unit and a behavior unit, a corresponding class description is generated, and when the system runs, the class can be accessed, detected or modified through the class description. The class description comprises information of member variables, member functions, static variables, static functions, alignment modes, memory sizes, class names, inheritance relationships and the like of the class.
The class description obtained by the method provided in this embodiment may include a Type (Type) of the class, a member list members of the class: list < ClassDataMember >, List of Member methods in class methods: list < ClassMethod >, class name: const char, etc.
When accessing data in the class based on the class description, a pre-written access function can be adopted, and the accessed class description is used as a variable in the function, so that the data in the class is accessed. In some embodiments, the function of accessing a class according to a class description may include:
and according to the description name of the data member in the class description, searching a function of the data member in the class: findMember (const char name): const ClassDataMember.
According to the description name of the member method in the class description, searching a function of the member method in the class: findMethod (const char name): const ClassDataMethod.
Function to detect inheritance relationships: IsTypeOf (const ClassDescriptor cd): and (4) a sol.
Function to detect whether a member variable is included: hasMember (const char name): and (4) a sol.
Function to detect whether a member method is included: hasMethod (const char name): and (4) a sol.
Function to get the name of the class description: getName (): const char.
The above functions are only used for exemplary illustration, and the functions provided by the embodiments of the present application for implementing reflection include, but are not limited to, the above functions. The function can be used as a code template, and can be reused when a developer encodes, so that the access to the class of any data structure is realized.
Optionally, to implement the reflection mechanism, a class description (ClassDescriptor) of each class in the system may be registered in advance, and the identifier of the registered class and the corresponding relationship of the class description may be organized to generate index information for querying. Furthermore, when a certain class is accessed, the identification of the class can be provided, and based on the identification of the class, query is carried out in the index information to obtain class description of the class.
The identification of the class may be a name of the class, and the name may be represented by a character string. For example, for class M to be queried, a class description of class M may be obtained by typedistpenser. The reflection mechanism may be implemented based on C + + (a programming language), or may be implemented based on other types of programming languages, which is not limited in this embodiment.
Based on the above, an embodiment of the present application provides a data-driven system function loading method, where fig. 1 is a schematic flow chart of the data-driven system function loading method, and as shown in fig. 1, the method includes:
And 102, determining the class description of the first target class corresponding to the identification of the behavior unit from the registered class descriptions based on a reflection mechanism.
And 104, calling a member method corresponding to the behavior unit, and creating the behavior unit in a memory of the system so as to drive the function of the system based on the configuration data.
And configuring data to configure the functional requirements of the system. Typically, this configuration data may be written in a configuration file. After determining the operating logic of the system, a user or a system function developer may write, in a configuration file, an identification of one or more behavior units required to implement one or more functions of the system. The identifier of the behavior unit may be a name of the behavior unit, or a number of the behavior unit, and the embodiment is not limited.
As shown in FIG. 2, after the configuration file is entered into the system, a reflection operation may be performed by the reflection module according to the configuration file. In the reflection operation, the target class where the behavior unit corresponding to the function to be loaded is located can be determined according to the corresponding relation between the identifier of the behavior unit and the class, and the class description of the target class is determined from the registered class descriptions. For convenience of description and distinction, the target class in which the behavior unit is located is described as a first target class.
After the class description of the first target class is determined, the first target class can be uniquely determined according to the class description of the first target class, and the member method corresponding to the behavior unit is inquired from the first target class. After the member method corresponding to the behavior unit is inquired, the member method can be called and executed to create the behavior unit in the memory of the system. One of the behavior units may also be referred to as a subsystem, as shown in fig. 2. After one or more subsystems are created based on the class description and reflection mechanism, the one or more subsystems may be managed by a system manager, which is not described herein.
The following description will be given with reference to specific examples.
It is assumed that there exists class a, which contains member variables number 1, number 2, and number 3, and member methods 1, method 2. If a reflection mechanism based on class descriptions is not used, then given class A instance a, when method1 is called, the following call is required:
a.method1()；
this way of invoking depends on the structure of instance a at compile time and requires explicit knowledge of whether class A has method1, requiring a check at compile time.
If the reflection mechanism provided by the embodiment based on the class description is used, the following can be called:
Method*method1＝classDescriptorOfA.findMethod(“method1”)；
If(method1！＝nullptr){invoke()；}
wherein, classDescriptorOfA represents the class description corresponding to the class A;
classdescriptorona findmethod ("method 1"), which means that a specified member method "method 1 is looked up from class a according to the class description corresponding to class a.
This manner of invocation does not depend on any structure at compile time, but only on the lookup and invocation of methods at runtime. At call time, it is not necessary to know whether this class has this method, nor is it necessary to check at compile time.
For example, a function has an input parameter obj, and when the moveTo () method of this input class is called, if the reflection mechanism based on the class description is not used, it should know the type of the incoming class, such as a & obj, or B & obj, and then call obj.
If a reflection mechanism based on class description is used, only one input parameter of void obj and one class description (ClassDescriptor) are needed to make the method call, and the type of the parameter at compile time does not need to be known.
For example, when detecting classes through class descriptions, the class descriptions may be used to detect relationships between classes. For example, the inheritance relationship of class a may be detected by class descriptor a.
For example, when the class is modified by the class description, the class description of the member variable in the class can be found first based on the class description, and then the member variable is modified based on the modification function and the class description of the member variable.
For example, the description dataMemberDescriptor of the member variable may be obtained using classdescriptor.
For another example, a class contains a member variable position, a type of vector, a member variable Color, and a type of Color. When outputting the information of this class, display (object) can be called to output based on the reflection mechanism, as shown in the following code:
the displayPOD () can process all basic data types, and the output function can display data in any class. If a reflection mechanism based on class description is not used, then, if the output of information can be performed on all classes, a reloading method matched with the number of the classes needs to be written, and the workload is very high.
In this embodiment, the source file of the system comprises a plurality of classes in which behavior units are stored, each class having a class description; when the function is loaded, the method decides which member methods in the classes are called to create the behavior unit according to the externally input data (namely, configuration data), and can determine the system operation logic based on the external data, thereby realizing the data driving of the system. On the premise that the behavior of the system is determined by externally input data, the operation behavior of the system can be changed by changing the externally input data, so that a new system function is realized, and the usability and reusability of the system are improved.
In some exemplary embodiments, the data units required by the behavior units may be loaded into the memory before the behavior units are created in the memory of the system based on the member methods corresponding to the behavior units.
Alternatively, the identity of the data units required by the system may be determined from the declaration information of the system. The declaration information of the system can be written in a code file of the system in a macro definition mode. And reading and analyzing the macro definition in the code file, so as to determine the identification of the data unit required by the system.
After the identifier of the data unit is obtained, the class description of the target class where the data unit is located can be determined according to the identifier of the data unit based on a reflection mechanism. In some embodiments, the operation of determining the class description of the second target class in which the data unit is located according to the identifier of the data unit may be implemented based on a getclassdescriptor (name) function. In this embodiment, the target class where the data unit is located is described as the second target class. Then, based on the reflection mechanism, the second target class in the resource file is accessed according to the class description of the second target class to obtain a data unit, and the data unit is loaded into the memory for use by the behavior unit.
Where the system is implemented as a gaming system, the data units may be implemented as scene data units of the gaming system. Based on the reflection mechanism, the scene data unit is loaded into the memory and can be used by the scene management unit, so as to realize the scene management function of the game system.
The operation of accessing the data unit in the second target class and loading the data unit into the memory according to the class description of the second target class may be implemented based on a pre-edited code template, where the code template includes a function (such as the enumerated function in the foregoing embodiment) for accessing the class based on the class description, and is used to implement access logic and loading logic for a certain variable. Wherein the value of the variable in the code template is externally accessible. After the data unit is determined from the second target class, the member variable corresponding to the data unit can be transmitted into the code template, that is, the variable in the code template is assigned according to the member variable corresponding to the data unit, so as to obtain a code for accessing and loading the data unit, and further, the access and loading of the data unit are realized.
Based on the above, after the behavior unit is created in the memory, the behavior unit may traverse the entity having the data unit of the specific type in the memory, and execute the corresponding function according to the data included in the traversed data unit. For example, after loading the mobile unit (Move unit) into the memory, the mobile unit may traverse all the Position type data units in the system through the reflection mechanism, and update the Position of the entity corresponding to the Position type data unit according to the Position data included in the Position type data unit.
In the method for loading the data unit, a reflection mechanism based on class description is adopted, so that the code template has extremely high reuse rate, the type of the class where the data unit is located does not need to be considered, and the access operation aiming at the data unit in any type of class can be completed.
In the embodiment of the present application, one behavior of the whole system determined by the external input data (i.e. configuration data) is represented as: the execution of each behavior unit in the system is determined by the attributes of the data unit. The behavior unit is based on the class description of the class, and after the data unit is found, whether the behavior unit is executed or not and how to execute the behavior unit can be judged according to the type of the data unit.
For example, for a mobile unit (Move unit), when performing a moving operation, it can be quickly determined whether a certain Object has a Position type data unit through a reflection mechanism. If yes, the Move unit can execute a moving operation on the object according to the position data in the data unit; otherwise, the Move unit does not perform the Move operation.
For another example, for a light-emitting unit, when a light-emitting operation is performed, the attribute of a light source data unit that a certain Object has can be quickly determined by a reflection mechanism. The attributes of the data cell of the light source may include: light source type (point light source, line light source), illumination distance, color, illumination angle, and the like. If the attribute of the light source data unit is: the light-emitting unit can perform the light-emitting operation of the red point light source, so that the object has the effect of emitting the red point light source. If the attribute of the light source data unit is: the light emitting unit can perform horizontal light emitting operation of the green line light source on the object so that the object has the effect of emitting the green horizontal illumination line light source.
In the embodiment of the present application, another behavior of the whole system determined by the external input data (i.e. configuration file) is represented as: how many behavior units are executed in the system is determined by external input data.
Based on the reflection mechanism, all behavioral units can be created and managed at runtime. The list of the required behavior units is stored in an external configuration file, namely the required behavior units can be dynamically created through the configuration file when the program instance is created, and further the initial state of the whole program instance is determined.
Further, by adding parameters for controlling the behavior unit, such as the size of the cache space required by the behavior unit, the thread number of the behavior unit, and the like, to the configuration file, the operation of the whole program can be controlled.
Based on the above, the behavior unit running in real time can be dynamically modified during the running period of the system by modifying the configuration file. Namely, according to the reflection mechanism based on the class description, the load balance of the system is dynamically adjusted. As will be exemplified below.
Optionally, the system or the device running the system may obtain real-time load data of the system, and display the real-time load data, so that the user may update the configuration file of the system according to the real-time load data; after the user updates the configuration file, the system can load or unload the designated behavior unit according to the updated configuration file, so as to dynamically adjust the behavior unit running in real time in the system. Furthermore, the method for adjusting the system load in real time during running is realized, and the healthy running of the system is facilitated.
Further, based on the class description and reflection mechanism, a runtime data editing method independent of the data structure can also be implemented, which will be exemplified below.
Optionally, in response to an editing operation by an editor, an identity of a data unit to be edited may be determined; wherein the identification of the data unit to be edited can be provided by an editing user. And then, according to the identification of the data unit to be edited, determining the class description of the target class where the data unit to be edited is located. For the sake of distinction, the class in which the data unit to be edited is located is described as the third target class hereinafter.
Then, based on the reflection mechanism, according to the class description of the third target class, the third target class in the resource file is accessed, and the member variable corresponding to the data unit to be edited is obtained from the third target class. And then, according to the member variable corresponding to the data unit to be edited, assigning the value to the editing object in the code template of the editor to obtain the editing code of the data unit to be edited. And operating the editing code of the data unit to be edited to generate an editing panel of the data unit to be edited, so that a user can edit the data unit to be edited.
In this way, when there is a need to edit a data unit, the data unit can be acquired based on the reflection mechanism by acquiring the class description of the class in which the data unit is located without paying attention to the structure of the data unit. On one hand, the code frame for generating the editing panel for the data unit can be reused for the data units with various different structures, so that the development cost is reduced; on the other hand, when the structure of the data unit changes, the mode of accessing the data unit is not affected, and the access efficiency is improved.
In this embodiment, all data units may be stored in a resource file of the system in JSON (JSON Object Notation) format. The resource file includes a class description (ClassDescriptor) name of each object, and values of each member variable in the class. Wherein, the values of the member variables in the class can be nested, i.e. the member variables themselves can also be a type corresponding to the ClassDescriptor.
Therefore, based on the class description of the third target class, when the member variable in the third target class is accessed, the type of the member variable can be further judged; and if the accessed member variable is of the basic data type, taking the accessed member variable as a member variable corresponding to the data unit to be edited, and directly generating an editing panel of the member variable.
If the accessed member variable is of a type of class description, the accessed member variable can be recursively traversed based on the class description of the accessed member variable until the member variable of the basic data type is accessed, the member variable is used as a member variable corresponding to the data unit to be edited, and an editing panel of the variable is generated for the member of the basic type.
Wherein, the basic type refers to the data type carried by the language tool, including: byte, short, int, long, float, double, char, bootean, pointer type, unsigned int, unsigned short, and so on.
That is, after reading an object from a resource file stored in the JSON format, the object may be traversed by a ClassDescriptor. In the process of traversing, for the member variable of each basic data type, a corresponding editing panel can be used; for member variables that are not of the underlying data type, this process may be performed recursively until all values are of the underlying data type. If the member variable is a non-basic type, the member variable can be considered to be nested with other types, and at the moment, recursive search can be carried out based on the ClassDescriptor until the values of all the searched member variables are basic types.
In this way, when the values of the member variables in the classes are nested, a reflection mechanism can be used to create corresponding editing panels for the member variables of the basic data types, and based on a recursive method, the member variables of the non-basic data structure can be edited, thereby avoiding the repeated writing of the editing panels for each class.
The process of generating an edit panel for a data unit generally comprises: reading data units from the resource file, storing the data units to the file in a serialization way, generating an editing interface and the like. The above process can be represented in pseudo code as:
based on the algorithm, all variables of non-fundamental data types can be processed recursively, and the process relies only on data at runtime. Furthermore, no matter serialization, deserialization and editor, only one set of basic code is needed to face the vast majority of data structure changes.
On the basis of the above embodiments of the present application, if there is a need for a new behavior unit and a new data unit, it is only necessary to generate a class description for the new behavior unit or the new data unit and register the class description without rewriting a new code. As will be exemplified below.
Optionally, in response to the operation of the newly added behavior unit, a class description of a fourth target class of the newly added behavior unit may be obtained; next, the class description of the fourth target class is registered to update the registered class description in the source file. When the added behavior unit is subsequently accessed, the class description of the fourth target class can be acquired from the registered class descriptions, and the added behavior unit is accessed based on the class description of the fourth class. When the system is implemented as a game system, the added behavior unit can be implemented as an added scene management unit.
Optionally, in response to the operation of adding the new data unit, a class description of a fifth target class in which the new data unit is located may be obtained; next, the class description of the fifth target class may be registered to update the registered class description in the source file. When subsequently accessing the newly added data unit, the class description of the fifth target class may be obtained from the registered class descriptions, and the newly added data unit may be accessed based on the class description of the fifth class. When the system is implemented as a game system, the newly added data unit can be implemented as a newly added scene data unit.
Based on the above embodiment, when a behavior unit or a data unit is newly added, the new addition can be realized without complex code editing, so that the development efficiency is greatly improved, and the development cost is reduced.
In some optional embodiments, the system modules can be freed from logical dependency by performing fine-grained splitting on the system. Optionally, when the system is subjected to fine-grained splitting, functional modules contained in the system can be determined; and then, splitting the functional module according to the sub-functions contained in the functional module to obtain behavior units corresponding to the sub-functions.
For example, taking a clipping (clipping) function module in a game system as an example, clipping is divided into a plurality of different clipping modes, such as quad tree clipping, octree clipping, view frustum clipping, and the like. According to each cutting mode, behavior units can be created, and each behavior unit can be used as a subsystem (subsystem) independently. When the system runs, the configuration cutting function module can contain one or more behavior units in the plurality of behavior units based on the configuration data.
Based on this embodiment, for each non-core functional module in the system, each implementation manner of the functional module may be packaged as one behavioral unit, and then, a three-layer structure of behavioral units (subsystems) - > functional modules- > system modules is formed.
Except for the core module, optionally, for the core module of the system, when the system runs, the functional module specifically included in the core module may also be configured by a configuration file, thereby implementing a running mode of the "data (configuration file)" system.
Taking a game system as an example, a core module (core module) of a game may include a plurality of functional modules such as asset management, thread management, rendering, and the like. The core system module specifically includes which functional modules, and can be configured by a configuration file. In some other embodiments, function modules such as a math module (math module), a scene module (scene module), an object pool module (object module), an editor module (editor module) and the like can be configured in the configuration file according to requirements.
The coupling degree between the functional modules is low, so that the functional requirements can be realized by combining different functional modules according to the requirements when the functional modules face different functional requirements. For example, in an editor scenario or a test scenario, an editor module or a debugging module is added to a core module through a configuration file to implement an editing function or a debugging function.
The mode of combining and managing the functional modules and the behavior units based on the configuration files realizes the driving of the system based on external data, avoids the modification of codes of the system, and reduces the development cost and the maintenance cost of the system. In addition, each subsystem obtained by splitting the system has higher independence, and the interdependence between the systems is only reflected on the data stream and does not exist in the system code. Besides the necessary basic system, some subsystems can be started and stopped dynamically according to the running load, and the flexibility is high.
It should be noted that the execution subjects of the steps of the methods provided in the above embodiments may be the same device, or different devices may be used as the execution subjects of the methods. For example, the execution subjects of steps 101 to 104 may be device a; for another example, the execution subject of steps 101 and 102 may be device a, and the execution subject of step 103 may be device B; and so on.
In addition, in some of the flows described in the above embodiments and the drawings, a plurality of operations are included in a specific order, but it should be clearly understood that the operations may be executed out of the order presented herein or in parallel, and the sequence numbers of the operations, such as 101, 102, etc., are merely used for distinguishing different operations, and the sequence numbers do not represent any execution order per se. Additionally, the flows may include more or fewer operations, and the operations may be performed sequentially or in parallel. It should be noted that, the descriptions of "first", "second", etc. in this document are used for distinguishing different messages, devices, modules, etc., and do not represent a sequential order, nor limit the types of "first" and "second" to be different.
Fig. 3 is a schematic structural diagram of an electronic device according to an exemplary embodiment of the present application, and as shown in fig. 3, the electronic device includes: a memory 301 and a processor 302.
The memory 301 is used for storing computer programs and may be configured to store other various data to support operations on the electronic device. Examples of such data include instructions for any application or method operating on the electronic device, contact data, phonebook data, messages, pictures, videos, and so forth.
The memory 301 may be implemented, among other things, by any type of volatile or non-volatile storage device or combination thereof, such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disk.
The electronic device shown in fig. 3 is configured to execute a data-driven system function loading method, where a source file of the system includes a plurality of classes, and each class has a class description; among the classes, the class for storing the behavior units and the class for storing the data units are decoupled from each other.
In performing the above system function loading method, the processor 302, coupled to the memory 301, is configured to execute the computer program in the memory 301, so as to: acquiring configuration data of a system, wherein the configuration data comprises an identifier of a behavior unit corresponding to a function to be loaded; determining a class description of a first target class corresponding to the identification of the behavior unit from the registered class descriptions based on a reflection mechanism; according to the class description of the first target class, inquiring member methods corresponding to the behavior units from the first target class; and calling a member method corresponding to the behavior unit, and creating the behavior unit in the memory of the system to execute the function.
Further optionally, before invoking the member method corresponding to the behavior unit and creating the behavior unit in the memory of the system, the processor 302 is further configured to: determining an identity of a data unit required by the system; based on a reflection mechanism, determining the class description of the second target class where the data unit is located according to the identifier of the data unit; accessing the second target class in the resource file according to the class description of the second target class to obtain the data unit; and loading the data unit into a memory for use by the behavior unit to drive a function of the system based on the data unit.
Further optionally, the processor 302 is further configured to: responding to the editing operation of an editor, and determining the identification of the data unit to be edited; determining the class description of a third target class in which the data unit to be edited is located according to the identifier of the data unit to be edited; determining member variables corresponding to the data unit to be edited from the third target class according to the class description of the third target class based on a reflection mechanism; assigning values to the editing objects in the code template of the editor according to the member variables to obtain editing codes of the data units to be edited; and operating the editing codes of the data units to be edited, and generating an editing panel of the data units to be edited so that a user can edit the data units to be edited.
Further optionally, when determining, based on the reflection mechanism and according to the class description of the third target class, the member variable corresponding to the data unit to be edited from the third target class, the processor 302 is specifically configured to: accessing member variables in the third target class based on the class description of the third target class; if the type of the accessed member variable is the basic data type, taking the accessed member variable as a member variable corresponding to the data unit to be edited; if the accessed member variable is of the type of the class description, performing recursive traversal on the accessed member variable based on the class description of the accessed member variable until the member variable of the basic data type is accessed and is used as the member variable corresponding to the data unit to be edited.
Further optionally, the processor 302 is further configured to: responding to the operation of the newly added behavior unit, and acquiring the class description of a fourth target class in which the newly added behavior unit is located; and registering the class description of the fourth target class to update the registered class description so as to access the newly added behavior unit subsequently according to the class description of the fourth target class.
Further optionally, the processor 302 is further configured to: responding to the operation of the newly added data unit, and acquiring the class description of a fifth target class in which the newly added data unit is positioned; and registering the class description of the fifth target class to update the registered class description so as to access the newly added data unit according to the class description of the fifth target class subsequently.
Further optionally, the processor 302 is further configured to: acquiring real-time load data of the system; displaying the real-time load data so that a user can update the configuration data according to the real-time load data; and acquiring updated configuration data, and dynamically adjusting the behavior unit which runs in the system in real time according to the updated configuration data.
Further optionally, the processor 302 is further configured to: determining a functional module contained in the system; and splitting the functional module according to the sub-functions contained in the functional module to obtain behavior units corresponding to the sub-functions.
Further, as shown in fig. 3, the electronic device further includes: display component 303, communication component 304, power component 305, audio component 306, and other components. Only some of the components are schematically shown in fig. 3, and it is not meant that the electronic device comprises only the components shown in fig. 3.
Wherein the communication component 303 is configured to facilitate communication between the device in which the communication component is located and other devices in a wired or wireless manner. The device in which the communication component is located may access a wireless network based on a communication standard, such as WiFi, 2G, 3G, 4G, or 5G, or a combination thereof. In an exemplary embodiment, the communication component receives a broadcast signal or broadcast related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component may be implemented based on Near Field Communication (NFC) technology, Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, Ultra Wideband (UWB) technology, Bluetooth (BT) technology, and other technologies.
The display 304 includes a screen, which may include a Liquid Crystal Display (LCD) and a Touch Panel (TP), among others. If the screen includes a touch panel, the screen may be implemented as a touch screen to receive an input signal from a user. The touch panel includes one or more touch sensors to sense touch, slide, and gestures on the touch panel. The touch sensor may not only sense the boundary of a touch or slide action, but also detect the duration and pressure associated with the touch or slide operation.
The power supply assembly 305 provides power to various components of the device in which the power supply assembly is located. The power components may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power for the device in which the power component is located.
In this embodiment, a source file of the system includes a plurality of classes in which behavior units are stored, each class having a class description; when the function is loaded, the method decides which member methods in the classes are called to create the behavior unit according to the externally input data (namely, configuration data), and can determine the system operation logic based on the external data, thereby realizing the data driving of the system. On the premise that the behavior of the system is determined by externally input data, the operation behavior of the system can be changed by changing the externally input data, so that a new system function is realized, and the usability and reusability of the system are improved. In addition, in some embodiments, dynamic load balancing of the system may be achieved by modifying the configuration data. By matching with a reflection and data driving method, after the system is started, configuration data can be modified according to the load condition, and some behavior units or modules can be dynamically started and stopped, so that the load of the system is balanced.
Accordingly, the present application further provides a computer-readable storage medium storing a computer program, where the computer program is capable of implementing the steps that can be executed by the electronic device in the foregoing method embodiments when executed.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.
Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, a computer readable medium does not include a transitory computer readable medium such as a modulated data signal and a carrier wave.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
The above description is only an example of the present application and is not intended to limit the present application. Various modifications and changes may occur to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.
Claims (9)
1. A data editing method, wherein a source file of a system to be edited includes: a plurality of classes, each class having a class description; in the multiple classes, the class for storing the behavior unit and the class for storing the data unit are mutually decoupled; the method comprises the following steps:
responding to the editing operation of an editor, and determining the identification of the data unit to be edited;
determining the class description of a third target class in which the data unit to be edited is located according to the identifier of the data unit to be edited;
determining member variables corresponding to the data unit to be edited from the third target class according to the class description of the third target class based on a reflection mechanism;
assigning values to the editing objects in the code template of the editor according to the member variables to obtain editing codes of the data units to be edited;
and operating the editing codes of the data units to be edited, and generating an editing panel of the data units to be edited so that a user can edit the data units to be edited.
2. The method according to claim 1, wherein determining, based on a reflection mechanism and according to the class description of the third target class, a member variable corresponding to the data unit to be edited from the third target class comprises:
accessing member variables in the third target class based on the class description of the third target class;
if the type of the accessed member variable is the basic data type, taking the accessed member variable as a member variable corresponding to the data unit to be edited;
if the accessed member variable is of the type of the class description, performing recursive traversal on the accessed member variable based on the class description of the accessed member variable until the member variable of the basic data type is accessed and is used as the member variable corresponding to the data unit to be edited.
3. The method of claim 1, further comprising:
acquiring configuration data of the system, wherein the configuration data comprises an identifier of a behavior unit corresponding to a function to be loaded;
determining a class description of a first target class corresponding to the identification of the behavior unit from the registered class descriptions based on a reflection mechanism;
according to the class description of the first target class, inquiring member methods corresponding to the behavior units from the first target class;
calling a member method corresponding to the behavior unit, creating the behavior unit in a memory of the system, and driving the function of the system based on the configuration data; calling a member method corresponding to the behavior unit, and before creating the behavior unit in the memory of the system, further comprising:
determining an identity of a data unit required by the system;
based on a reflection mechanism, determining the class description of the second target class where the data unit is located according to the identifier of the data unit;
accessing the second target class in the resource file according to the class description of the second target class to obtain the data unit;
and loading the data unit into a memory for use by the behavior unit to drive a function of the system based on the data unit.
4. The method of claim 3, further comprising:
responding to the operation of the newly added behavior unit, and acquiring the class description of a fourth target class in which the newly added behavior unit is located;
and registering the class description of the fourth target class to update the registered class description so as to access the newly added behavior unit subsequently according to the class description of the fourth target class.
5. The method of claim 3, further comprising:
responding to the operation of the newly added data unit, and acquiring the class description of a fifth target class in which the newly added data unit is positioned;
and registering the class description of the fifth target class to update the registered class description so as to access the newly added data unit according to the class description of the fifth target class subsequently.
6. The method according to any one of claims 3-5, further comprising:
acquiring real-time load data of the system;
displaying the real-time load data so that a user can update the configuration data according to the real-time load data;
and acquiring updated configuration data, and dynamically adjusting the behavior unit which runs in the system in real time according to the updated configuration data.
7. The method according to any one of claims 3-5, further comprising:
determining a functional module contained in the system;
and splitting the functional module according to the sub-functions contained in the functional module to obtain behavior units corresponding to the sub-functions.
8. An electronic device, comprising: a memory and a processor;
the memory is to store one or more computer instructions;
the processor is to execute the one or more computer instructions to: performing the steps of the method of any one of claims 1-7.
9. A computer-readable storage medium storing a computer program, wherein the computer program is capable of performing the steps of the method of any one of claims 1 to 7 when executed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110297464.3A CN113051002A (en) | 2020-12-24 | 2020-12-24 | Data editing method, device and storage medium |
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011541278.1A CN112256355B (en) | 2020-12-24 | 2020-12-24 | Data-driven system function loading method, equipment and storage medium |
| CN202110297464.3A CN113051002A (en) | 2020-12-24 | 2020-12-24 | Data editing method, device and storage medium |
Related Parent Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011541278.1A Division CN112256355B (en) | 2020-12-24 | 2020-12-24 | Data-driven system function loading method, equipment and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113051002A true CN113051002A (en) | 2021-06-29 |
Family
ID=74225818
Family Applications (2)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011541278.1A Active CN112256355B (en) | 2020-12-24 | 2020-12-24 | Data-driven system function loading method, equipment and storage medium |
| CN202110297464.3A Pending CN113051002A (en) | 2020-12-24 | 2020-12-24 | Data editing method, device and storage medium |
Family Applications Before (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011541278.1A Active CN112256355B (en) | 2020-12-24 | 2020-12-24 | Data-driven system function loading method, equipment and storage medium |
Country Status (2)
| Country | Link |
|---|---|
| CN (2) | CN112256355B (en) |
| WO (1) | WO2022134717A1 (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112256355B (en) * | 2020-12-24 | 2021-05-11 | 完美世界(北京)软件科技发展有限公司 | Data-driven system function loading method, equipment and storage medium |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6912541B1 (en) * | 2000-12-01 | 2005-06-28 | Unisys Corporation | Method and apparatus for implementing persistent data in object oriented programs |
| CN104391731A (en) * | 2014-09-29 | 2015-03-04 | 北京广利核系统工程有限公司 | Editing method based on C# and irrelevant to data types |
| CN110308836A (en) * | 2019-06-24 | 2019-10-08 | 北京字节跳动网络技术有限公司 | A kind of data processing method, device, terminal and storage medium |
| CN110413266A (en) * | 2019-08-05 | 2019-11-05 | 广东三维家信息科技有限公司 | A kind of improved method and system of the reflection mechanism of haxe |
| CN111666072A (en) * | 2020-06-09 | 2020-09-15 | 南京及物智能技术有限公司 | Software code and document robot method |
| CN111736916A (en) * | 2020-06-08 | 2020-10-02 | 北京达佳互联信息技术有限公司 | Dynamic expansion method and device based on Java language, electronic equipment and storage medium |
Family Cites Families (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7620959B2 (en) * | 2003-05-12 | 2009-11-17 | Microsoft Corporation | Reflection-based processing of input parameters for commands |
| US9292270B2 (en) * | 2014-03-27 | 2016-03-22 | Microsoft Technology Licensing, Llc | Supporting dynamic behavior in statically compiled programs |
| CN106547681B (en) * | 2015-09-18 | 2020-03-03 | 北京京东尚科信息技术有限公司 | Method and device for testing data automatic loading and multiplexing simulation service |
| CN110764748B (en) * | 2019-10-23 | 2023-03-14 | 北京字节跳动网络技术有限公司 | Code calling method, device, terminal and storage medium |
| CN111737166B (en) * | 2020-05-15 | 2023-04-07 | 完美世界(北京)软件科技发展有限公司 | Data object processing method, device and equipment |
| CN112035180A (en) * | 2020-08-19 | 2020-12-04 | 北京城市网邻信息技术有限公司 | Automatic instance loading method and device, electronic equipment and storage medium |
| CN112256355B (en) * | 2020-12-24 | 2021-05-11 | 完美世界(北京)软件科技发展有限公司 | Data-driven system function loading method, equipment and storage medium |
| CN112604273B (en) * | 2020-12-24 | 2021-08-24 | 完美世界(北京)软件科技发展有限公司 | Data-driven game system function loading method, device and storage medium |
-
2020
- 2020-12-24 CN CN202011541278.1A patent/CN112256355B/en active Active
- 2020-12-24 CN CN202110297464.3A patent/CN113051002A/en active Pending
-
2021
- 2021-09-28 WO PCT/CN2021/121451 patent/WO2022134717A1/en active Application Filing
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6912541B1 (en) * | 2000-12-01 | 2005-06-28 | Unisys Corporation | Method and apparatus for implementing persistent data in object oriented programs |
| CN104391731A (en) * | 2014-09-29 | 2015-03-04 | 北京广利核系统工程有限公司 | Editing method based on C# and irrelevant to data types |
| CN110308836A (en) * | 2019-06-24 | 2019-10-08 | 北京字节跳动网络技术有限公司 | A kind of data processing method, device, terminal and storage medium |
| CN110413266A (en) * | 2019-08-05 | 2019-11-05 | 广东三维家信息科技有限公司 | A kind of improved method and system of the reflection mechanism of haxe |
| CN111736916A (en) * | 2020-06-08 | 2020-10-02 | 北京达佳互联信息技术有限公司 | Dynamic expansion method and device based on Java language, electronic equipment and storage medium |
| CN111666072A (en) * | 2020-06-09 | 2020-09-15 | 南京及物智能技术有限公司 | Software code and document robot method |
Non-Patent Citations (1)
| Title |
|---|
| 金百东;李文举;: "利用C++ ATL技术实现反射机制", 微型机与应用, no. 02, 25 January 2013 (2013-01-25) * |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2022134717A1 (en) | 2022-06-30 |
| CN112256355B (en) | 2021-05-11 |
| CN112256355A (en) | 2021-01-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9934005B2 (en) | Dynamically building locale objects or subsections of locale objects based on historical data | |
| US10061573B2 (en) | User interfaces of application porting software platform | |
| CN109739600B (en) | Data processing method, medium, device and computing equipment | |
| CN112604273B (en) | Data-driven game system function loading method, device and storage medium | |
| CN113296786B (en) | Data processing method, device, electronic equipment and storage medium | |
| CN111111201B (en) | Skill creation method, device, server and medium based on game | |
| US20120159515A1 (en) | Sharing object representations | |
| CN112256355B (en) | Data-driven system function loading method, equipment and storage medium | |
| US9141352B2 (en) | Dynamically building locale objects at run-time | |
| US9280361B2 (en) | Methods and systems for a real time transformation of declarative model and layout into interactive, digital, multi device forms | |
| US20210173641A1 (en) | Generation of knowledge graphs based on repositories of code | |
| WO2021047662A1 (en) | Method and apparatus for enabling autonomous acceleration of dataflow ai applications | |
| EP3834080B1 (en) | Static reconcilliation of application view hierarchies | |
| CN114449063A (en) | Message processing method, device and equipment | |
| CN113342399A (en) | Application structure configuration method and device and readable storage medium | |
| US20180032929A1 (en) | Risk-adaptive agile software development | |
| CN105393216B (en) | Run-time memory is adjusted | |
| US11449493B2 (en) | Persistent and configurable multidimensional data constraints | |
| CN117055967A (en) | Data processing method, data system, electronic device and storage medium | |
| US9792093B2 (en) | Dynamically building subsections of locale objects at run-time | |
| CN113296777A (en) | Dependency analysis and program compilation method, apparatus, and storage medium | |
| CN115756680A (en) | Component information display method and device, computer equipment and storage medium | |
| CN117992101A (en) | Application program modification method and device, electronic equipment and storage medium | |
| CN117234899A (en) | Regression testing method, device, equipment and computer medium | |
| CN117632111A (en) | Low code implementation method and device applied to embedded Linux equipment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| EE01 | Entry into force of recordation of patent licensing contract | ||
| EE01 | Entry into force of recordation of patent licensing contract |
Application publication date: 20210629 Assignee: Beijing Xuanguang Technology Co.,Ltd. Assignor: Perfect world (Beijing) software technology development Co.,Ltd. Contract record no.: X2022990000514 Denomination of invention: Data editing method, device and storage medium License type: Exclusive License Record date: 20220817 |