CN106469051B - Object delivery method and device - Google Patents
Object delivery method and device Download PDFInfo
- Publication number
- CN106469051B CN106469051B CN201510512106.4A CN201510512106A CN106469051B CN 106469051 B CN106469051 B CN 106469051B CN 201510512106 A CN201510512106 A CN 201510512106A CN 106469051 B CN106469051 B CN 106469051B
- Authority
- CN
- China
- Prior art keywords
- script
- constructor
- program
- thread
- host
- 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.)
- Active
Links
Images
Landscapes
- Stored Programmes (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The application discloses an object transfer method and device, wherein the method comprises the following steps: when a host program in a host thread interacts with a script program in a script thread, the host program acquires a constructor and original data of the object; and transmitting the constructor of the object and the original data to the script program, calling the constructor on the script thread by the script program, and creating the object according to the original data. The embodiment of the application has universality and is suitable for different script languages.
Description
Technical Field
The application belongs to the technical field of computers, and particularly relates to an object transfer method and device.
Background
In an application environment where a host program interacts with a script program, the host program transmits an object to the script program, and the script program is triggered to execute, if the host language is different from the script language, how to express the object becomes a main problem facing the interaction between the host program and the script program.
An object refers to programming content used to represent a concrete thing, an abstract rule, a plan, or time, in object-oriented programming.
In an object delivery method in the prior art, a host program expands one or more script language types according to needs, instantiates an object of the script language by using the types, and delivers the object to the script program.
However, if the host program and the script program run in different threads, the object is created in the host thread of the host program according to the prior art, and the object is accessed in the script thread of the script program, but because some script languages do not support multithreading, operations for the same context are required to be performed on the same thread, such as the language Lua of the script. Therefore, the existing method is poor in universality and cannot be supported by all scripting languages.
Disclosure of Invention
In view of this, the present application provides an object transfer method and an object transfer device, which improve the universality of the object transfer method.
In order to solve the above technical problem, the present application discloses an object delivery method, including:
when a host program in a host thread interacts with a script program in a script thread, the host program acquires a constructor and original data of the object;
and transmitting the constructor of the object and the original data to the script program, calling the constructor on the script thread by the script program, and creating the object according to the original data.
Preferably, the passing the constructor of the object and the raw data to the script program comprises:
according to the script language type of the script program, converting the constructor into a constructor of the script language type;
and transferring the converted constructor and the original data to the script program.
Preferably, the passing the constructor of the object and the raw data to the script program comprises:
and packaging the constructor and the original data of the object into a closure, and transmitting the closure to the script program.
Preferably, before the constructor of the object and the raw data are passed to the script program, the method further comprises:
establishing a transmission queue between a host program and a script program;
the passing the constructor and the raw data of the object to the script program comprises:
and transmitting the constructor of the object and the original data to the script program through the transmission queue.
An object delivery method, comprising:
when a host program in a host thread interacts with a script program in a script thread, the script program acquires a constructor and original data transmitted by the host program;
and calling the constructor on a script thread, and creating the object according to the original data.
An object delivery apparatus comprising:
the acquisition module is used for acquiring a constructor and original data of the object when a host program in a host thread interacts with a script program in a script thread; wherein the host thread is different from the script thread;
and the transfer module is used for transferring the constructor and the original data of the object to the script program, calling the constructor on the script thread by the script program, and creating the object according to the original data.
Preferably, the transfer module includes:
the conversion unit is used for converting the constructor into a constructor of the script language type according to the script language type of the script program;
and the transfer unit is used for transferring the converted constructor and the original data to the script program.
Preferably, the transfer module is specifically configured to package the constructor and the raw data of the object into a closure, and transfer the closure to the script program.
Preferably, the method further comprises the following steps:
the establishing module is used for establishing a transmission queue between the host program and the script program;
the transfer module is specifically configured to transfer the constructor of the object and the raw data to the script program through the transfer queue.
An object delivery apparatus comprising:
the system comprises a receiving module, a processing module and a processing module, wherein the receiving module is used for obtaining a constructor and original data transmitted by a host program when the host program in a host thread interacts with a script program in a script thread;
and the creating module is used for calling the constructor on a script thread and creating the object according to the original data.
Compared with the prior art, the application can obtain the following technical effects:
the host program transmits the structure function and the original data of the object to the script program, and the script program creates the object in the script thread, so that the creation and the access of the object are in the same thread, the method can be suitable for different script languages, and the universality of the object transmission mode is ensured.
Of course, it is not necessary for any one product to achieve all of the above-described technical effects simultaneously.
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 flow chart of one embodiment of an object delivery method of the present application;
FIG. 2 is a flow chart of another embodiment of an object delivery method according to an embodiment of the present application;
FIG. 3 is a flow chart of yet another embodiment of an object delivery method of an embodiment of the present application;
FIG. 4 is a schematic diagram of an embodiment of an object delivery apparatus according to an embodiment of the present application;
fig. 5 is a schematic structural diagram of another embodiment of an object delivery apparatus according to an embodiment of the present application;
FIG. 6 is a schematic diagram of an object delivery apparatus according to another embodiment of the present application;
fig. 7 is a schematic structural diagram of an object delivery apparatus according to another embodiment of the present application.
Detailed Description
Embodiments of the present application will be described in detail with reference to the drawings and examples, so that how to implement technical means to solve technical problems and achieve technical effects of the present application can be fully understood and implemented.
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 tape 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, computer readable media does not include non-transitory computer readable media (transient media), such as modulated data signals and carrier waves.
Fig. 1 is a flowchart of an embodiment of an object delivery method provided in an embodiment of the present application, where the method may include the following steps:
101: and when the host program in the host thread interacts with the script program in the script thread, the host program acquires the constructor and the original data of the object.
102: and transmitting the constructor and the original data of the object to the script program, calling the constructor on the script thread by the script program, and generating the object according to the original data.
A Script program, called Script (Script) for short, is a program code, which is an instruction execution sequence provided by a certain system (such as an operating system) or Server (such as Web Server) or application program (such as AutoCAD, MSOffice, etc.), that is, a host program, and can automate the functions of the environment.
And a Scripting Language (Scripting Language) is formed in order to legally write specifications, rules, definitions and the like of formal grammar and semantics made by a script program.
The software environment in which the script program depends on to live is called a Host program (Host), the Host program can be an operating system, a Server program and an application program, and the program Language for developing the Host program (for example, C Language is generally used for developing the operating system, C Language or Java Language is generally used for developing the Web Server, and C + +/Java/C # Language is generally used for developing the application program) is called a Host Language (Host Language).
As the host language is relatively complex, in order to meet the requirements of different users, a relatively simple and convenient script language is provided for the users to use.
In the product embedded with the host language for executing the script language, the interaction between the host program and the script program is usually involved, and in the interaction process, the host program needs to transmit an object to the script program in a one-way mode to trigger the script program to execute.
In the embodiment of the application, when the host program interacts with the script program, the host program transmits the acquired construction function and the original data of the object to the script program, the script program calls the construction function, and the object is created according to the original data, so that the transmission of the object is realized. The creation and access of the object are both executed by the script program, and the creation and access of the object are ensured to be in the same thread even if the host program and the script program are in different threads, so that the method can be suitable for different script languages, can be supported by different script languages, and ensures the universality of an object transmission mode.
In the embodiment of the present application, the original data refers to data for constructing an object, and when a constructor is used for being called, an object of a scripting language is created according to the original data.
Both the raw data and the constructor are user supplied.
Since there are many types of scripting languages, such as javascript, Lua, VBscript, etc., in order to create an object of the scripting language type of the script program, a possible implementation manner needs to provide a constructor for creating the scripting language type of the corresponding script program by a user.
In order to reduce complexity, as another embodiment, the constructor provided by the user may be a constructor of a specific script language type or a constructor described in a preset abstract description manner.
And after the host program obtains the original data of the object and the construction function provided by the user, converting the construction function according to the script language type of the interactive script program, so that the script program can be called.
As shown in fig. 2, a flowchart of another embodiment of an object delivery method provided in the embodiment of the present application may include the following steps:
201: and when the host program in the host thread interacts with the script program in the script thread, the host program acquires the constructor and the original data of the object.
202: and converting the constructor into a constructor of the script language type according to the script language type of the script program.
203: and transferring the converted constructor and the original data to the script program, calling the constructor on the script thread by the script program, and creating the object according to the original data.
The host thread and the script thread may be the same or different.
When the constructor provided by the user is described by the preset abstract description mode, the constructor is converted into the constructor of the script language type, and the constructor can be converted into the constructor of the script language type of the script program according to the corresponding relation between the preset abstract description mode and the script language description modes of different script language types.
The following illustrates one possible abstract description of the presets:
NewObject () creates an empty object and returns
SetIntegerField (o, name, i) sets the name field of a designated object o to an integer i
SetFloatField (o, name, f) sets the name field of the designated object o to a floating point number f
SetStringField (o, name, s) sets the name field of object o to string s
SetObjectField (o, name, o1) sets the name field of object o to object o1
Finish () completes the creation of the object.
Since there are various types of scripting languages, the scripting languages for implementing different functions in the above abstract description mode are not described herein again.
When the constructor provided by the user is described by using a specific script language, if the script language type corresponding to the constructor is different from the script language type of the script program, the constructor can be converted according to the preset corresponding relationship of different types of script languages.
According to the embodiment of the application, the constructors are converted, so that a user is not required to provide constructors of different scripting language types, the constructors of different scripting language types can be automatically converted only by providing a through preset description mode, and complexity is reduced.
Wherein, a producer-consumer queue, i.e. a transfer queue, can be created between the host program and the script program, so that the host program can transfer the constructor and the original data to the script program through the transfer queue. The transmission queue adopts a first-in first-out mode.
In order to execute the construction process of the object in the script thread, the constructor and the raw data may be packaged into a closure, specifically, the closure is transferred to the script program, and the closure may be transferred to the script program through a transfer queue.
Fig. 3 is a flowchart of another embodiment of an object delivery method provided in an embodiment of the present application, where the method may include the following steps:
301: when a host program in a host thread interacts with a script program in a script thread, the script program acquires a constructor and original data transmitted by the host program;
302: and calling the constructor on a script thread, and creating the object according to the original data.
The host thread and the script thread may be different or the same.
The constructor passed by the host program and the original data are provided by the user.
The constructor and the original data can be packaged into a closure and transmitted in the form of the closure.
A transfer queue can be created between the host program and the script program, and the constructor transferred by the host program and the original data can be obtained through the transfer queue.
After creating the object by calling the constructor, the job calling the constructor can also be used to return the created object to the upper layer of the script program, and executed by the upper layer of the script program.
In the embodiment of the application, when the host program interacts with the script program, the host program transmits the acquired construction function and the original data of the object to the script program, the script program calls the construction function, and the object is generated according to the original data. The creation and access of the object are executed by the script program, and even if the host program and the script program are in different threads, the creation and access of the object are ensured to be in the same thread, so that the method can be suitable for different script languages, and the universality of the object transmission mode is ensured.
An embodiment of the present application further provides an object delivery apparatus, and as shown in fig. 4, the apparatus may include, for a schematic structural diagram of an embodiment of the object delivery apparatus provided in the embodiment of the present application:
the obtaining module 401 is configured to obtain a constructor and original data of the object when a host program in the host thread interacts with a script program in the script thread.
A transfer module 402, configured to transfer the constructor and the raw data of the object to the script program, where the script program calls the constructor on the script thread, and creates the object according to the raw data.
The host thread and the script thread may be the same or different.
In this embodiment, when the host program interacts with the script program, the obtained constructor of the object and the original data are transferred to the script program, the script program calls the constructor, and the object is created according to the original data, thereby implementing the transfer of the object. The creation and access of the object are executed by the script program, and even if the host program and the script program are in different threads, the creation and access of the object are ensured to be in the same thread, so that the method can be suitable for different script languages, and the universality of the object transmission mode is ensured.
The object transfer apparatus in this embodiment is specifically applied to a host program.
As another example, as illustrated in fig. 5, the transferring module 402 may include:
a conversion unit 501, configured to convert the constructor into a constructor of the scripting language type according to the scripting language of the scripting program;
a transfer unit 502, configured to transfer the transformed constructor and the original data to the script program.
By converting the constructors, the constructors of different scripting language types can be automatically converted by providing a preset description mode without providing constructors of different scripting language types by a user, and complexity is reduced.
Wherein, a producer-consumer queue, i.e. a transfer queue, can be created between the host program and the script program, so that the host program can transfer the constructor and the original data to the script program through the transfer queue. The transmission queue adopts a first-in first-out mode.
Therefore, as illustrated in fig. 6, the apparatus may further include:
an establishing module 403, configured to establish a transfer queue between the host program and the script program;
the transfer module 402 is specifically configured to transfer the constructor and the raw data of the object to the script program through the transfer queue.
When the transfer module is composed of a conversion unit and a transfer unit, the transfer unit is specifically configured to transfer the constructor of the object and the raw data to the script program through the transfer queue.
As another embodiment, the constructor and the raw data may be packaged into a closure, and therefore, the transfer module is specifically configured to package the constructor and the raw data of the object into a closure, and transfer the closure to the script program, which may be transfer of the closure to the script program through a transfer queue.
Fig. 7 is a schematic structural diagram of another embodiment of an object delivery apparatus according to an embodiment of the present application, where the apparatus of this embodiment is specifically applied to a script program, and the apparatus may include:
a receiving module 701, configured to, when a host program in a host thread interacts with a script program in a script thread, obtain, by the script program, a constructor and original data transferred by the host program;
a creating module 702, configured to call the constructor on a script thread, and create the object according to the original data.
The host thread and the script thread may be different or the same.
The constructor passed by the host program and the original data are provided by the user.
The constructor and the original data can be packaged into a closure and transmitted in the form of the closure.
A transfer queue can be created between the host program and the script program, and the constructor transferred by the host program and the original data can be obtained through the transfer queue.
After creating the object by calling the constructor, the job calling the constructor can also be used to return the created object to the upper layer of the script program, and executed by the upper layer of the script program.
In this embodiment, when the host program interacts with the script program, the host program transfers the acquired constructor of the object and the original data to the script program, and the script program calls the constructor and creates the object according to the original data. The creation and access of the object are executed by the script program, and even if the host program and the script program are in different threads, the creation and access of the object are ensured to be in the same thread, so that the method can be suitable for different script languages, and the universality of the object transmission mode is ensured.
The technical solution of the present invention will be described with reference to a practical application scenario:
assume that the host language is C + +, the scripting language is Lua, and the object to be transferred is Student, which includes attributes of a Student number (id, integer data) and a name (name, string data). The threads that the host language and the scripting language each run have been created and the queue for transferring objects is ready.
First, a constructor is prepared that accepts the study number, name as raw data, and a builder (builder) for building the Lua object. The builder is contained in a library of functions provided by the host program.
The C + + code of the constructor adopting the preset abstract description mode is as follows:
void StudentConstructor(Builder b,int id,string name)
{
new Object (); creation of an empty object
Setintegratfield ("id", id); // set its id field
Setstringfield ("name", name); v/set its name field
Finish (o); v/completion of the build Process
}
Then, the constructor and the original data of the object are made into a closure, and then the closure is pushed into a queue for transferring the object. In the host language, the closure functions to "bind" (bind) the constructor and the original data of the object together; a closure is also an extension of scripting languages in which it can be called once to execute a constructed procedure and return the created object.
The host program transfers the constructor and the original data, and the script program creates the execution of the object according to the following codes:
C++ code:
int id 31; // raw data: school number 31
string name ═ mark "; // raw data: name mark
Closure c (bind, id, name)// construct the Closure
Push (c); // put the closure into queue
Lua code:
Pop () - -take the next closure from the queue
Do _ constraint () -actual creation process
assert(o.id＝＝31)
assert(o.name＝＝“mark”)
As used in the specification and in the claims, certain terms are used to refer to particular components. As one skilled in the art will appreciate, manufacturers may refer to a component by different names. This specification and claims do not intend to distinguish between components that differ in name but not function. In the following description and in the claims, the terms "include" and "comprise" are used in an open-ended fashion, and thus should be interpreted to mean "include, but not limited to. "substantially" means within an acceptable error range, and a person skilled in the art can solve the technical problem within a certain error range to substantially achieve the technical effect. Furthermore, the term "coupled" is intended to encompass any direct or indirect electrical coupling. Thus, if a first device couples to a second device, that connection may be through a direct electrical coupling or through an indirect electrical coupling via other devices and couplings. The description which follows is a preferred embodiment of the present application, but is made for the purpose of illustrating the general principles of the application and not for the purpose of limiting the scope of the application. The protection scope of the present application shall be subject to the definitions of the appended claims.
It is also noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a good or system that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such good or system. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a commodity or system that includes the element.
The foregoing description shows and describes several preferred embodiments of the present application, but as aforementioned, it is to be understood that the application is not limited to the forms disclosed herein, but is not to be construed as excluding other embodiments and is capable of use in various other combinations, modifications, and environments and is capable of changes within the scope of the application as described herein, commensurate with the above teachings, or the skill or knowledge of the relevant art. And that modifications and variations may be effected by those skilled in the art without departing from the spirit and scope of the application, which is to be protected by the claims appended hereto.
Claims (8)
1. An object delivery method, comprising:
when a host program in a host thread interacts with a script program in a script thread, the host program acquires a constructor and original data of the object;
according to the script language type of the script program, converting the constructor into a constructor of the script language type;
and transferring the converted constructor and the original data to the script program, calling the converted constructor on the script thread by the script program, and creating the object according to the original data so as to enable the creation and the access of the object to be in the same thread.
2. The method of claim 1, wherein passing the transformed constructor and raw data to the script program comprises:
and packaging the converted constructor and the original data into a closure, and transmitting the closure to the script program.
3. The method of claim 1, wherein before passing the constructor after conversion and the raw data to the script program, the method further comprises:
establishing a transmission queue between a host program and a script program;
the transferring the converted constructor and the raw data to the script program includes:
and transmitting the constructor after conversion and the original data to the script program through the transmission queue.
4. An object delivery method, comprising:
when a host program in a host thread interacts with a script program in a script thread, the script program acquires a constructor and original data transmitted by the host program; the constructor is obtained by converting an original constructor according to the script language type of the script program;
and calling the constructor on a script thread, and creating the object according to the original data so as to enable the creation and the access of the object to be in the same thread.
5. An object delivery apparatus, comprising:
the acquisition module is used for acquiring a constructor and original data of the object when a host program in a host thread interacts with a script program in a script thread; wherein the host thread is different from the script thread;
the conversion unit is used for converting the constructor into a constructor of the script language type according to the script language type of the script program;
and the transfer module is used for transferring the converted constructor and the original data to the script program, calling the converted constructor on the script thread by the script program, and creating the object according to the original data so as to enable the creation and the access of the object to be in the same thread.
6. The apparatus of claim 5, wherein the transfer module is specifically configured to package the transformed constructor and the raw data into a closure for transfer to the script program.
7. The apparatus of claim 5, further comprising:
the establishing module is used for establishing a transmission queue between the host program and the script program;
the transfer module is specifically configured to transfer the converted constructor and the original data to the script program through the transfer queue.
8. An object delivery apparatus, comprising:
the system comprises a receiving module, a processing module and a processing module, wherein the receiving module is used for obtaining a constructor and original data transmitted by a host program when the host program in a host thread interacts with a script program in a script thread; the constructor is obtained by converting an original constructor according to the script language type of the script program;
and the creating module is used for calling the constructor on a script thread and creating the object according to the original data so as to enable the creation and the access of the object to be in the same thread.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510512106.4A CN106469051B (en) | 2015-08-19 | 2015-08-19 | Object delivery method and device |
| PCT/CN2016/094321 WO2017028720A1 (en) | 2015-08-19 | 2016-08-10 | Object sending method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510512106.4A CN106469051B (en) | 2015-08-19 | 2015-08-19 | Object delivery method and device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN106469051A CN106469051A (en) | 2017-03-01 |
| CN106469051B true CN106469051B (en) | 2020-03-27 |
Family
ID=58050705
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201510512106.4A Active CN106469051B (en) | 2015-08-19 | 2015-08-19 | Object delivery method and device |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN106469051B (en) |
| WO (1) | WO2017028720A1 (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107562516A (en) * | 2017-08-07 | 2018-01-09 | 北京金山安全管理系统技术有限公司 | Multithread processing method and device, storage medium and processor |
| CN109032583B (en) * | 2018-07-25 | 2022-06-17 | 北京小米移动软件有限公司 | Data interaction method and device |
| CN110134386B (en) * | 2019-04-04 | 2023-04-18 | 成都娄外科技有限公司 | Program editing method and device |
| CN110825383B (en) * | 2019-10-14 | 2023-08-22 | 北京奇艺世纪科技有限公司 | Video interaction method and device and computer readable storage medium |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101458633A (en) * | 2007-12-13 | 2009-06-17 | 华为软件技术有限公司 | Method for accessing host program by script program, and system and apparatus thereof |
| CN102141917A (en) * | 2011-04-02 | 2011-08-03 | 南京天溯自动化控制系统有限公司 | Method for realizing multi-service linkage based on IronPython script language |
| CN103825811A (en) * | 2013-10-11 | 2014-05-28 | 江苏飞尚安全监测咨询有限公司 | Implementation scheme for accessing sensor protocol self-identification IOT (internet of things) gateway |
| CN104298534A (en) * | 2014-10-23 | 2015-01-21 | 广州华多网络科技有限公司 | Programming method and device based on Lua language |
Family Cites Families (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6275868B1 (en) * | 1997-03-12 | 2001-08-14 | Microsoft Corporation | Script Engine interface for multiple languages |
| US20040205709A1 (en) * | 2001-05-09 | 2004-10-14 | Sun Microsystems, Inc. | Method,system, and program for providing patch expressions used in determining whether to install a patch |
| US20080016253A1 (en) * | 2006-07-11 | 2008-01-17 | Boctor Design, Llc | Graphical user interface for navigating and manipulating objects exposed by a host |
| US8522200B2 (en) * | 2008-08-28 | 2013-08-27 | Microsoft Corporation | Detouring in scripting systems |
| US9411568B2 (en) * | 2010-04-15 | 2016-08-09 | Microsoft Technology Licensing, Llc | Asynchronous workflows |
| CN104391700A (en) * | 2014-11-11 | 2015-03-04 | 百度在线网络技术（北京）有限公司 | Method and device for expanding functions of application program |
-
2015
- 2015-08-19 CN CN201510512106.4A patent/CN106469051B/en active Active
-
2016
- 2016-08-10 WO PCT/CN2016/094321 patent/WO2017028720A1/en active Application Filing
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101458633A (en) * | 2007-12-13 | 2009-06-17 | 华为软件技术有限公司 | Method for accessing host program by script program, and system and apparatus thereof |
| CN102141917A (en) * | 2011-04-02 | 2011-08-03 | 南京天溯自动化控制系统有限公司 | Method for realizing multi-service linkage based on IronPython script language |
| CN103825811A (en) * | 2013-10-11 | 2014-05-28 | 江苏飞尚安全监测咨询有限公司 | Implementation scheme for accessing sensor protocol self-identification IOT (internet of things) gateway |
| CN104298534A (en) * | 2014-10-23 | 2015-01-21 | 广州华多网络科技有限公司 | Programming method and device based on Lua language |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2017028720A1 (en) | 2017-02-23 |
| CN106469051A (en) | 2017-03-01 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10026041B2 (en) | Interoperable machine learning platform | |
| CN109308224B (en) | Cross-platform data communication and cross-platform data processing method, device and system | |
| CN111176626B (en) | Cross-programming-language code calling method and device, medium and equipment | |
| CN106469051B (en) | Object delivery method and device | |
| RU2638727C2 (en) | Method and device for starting external application in browser | |
| US10176270B2 (en) | Performance of template based javascript widgets | |
| US10853096B2 (en) | Container-based language runtime loading an isolated method | |
| WO2018072626A1 (en) | Method and apparatus for invoking component, and method and apparatus for processing component data | |
| CN111158690B (en) | Desktop application framework, construction method, desktop application running method and storage medium | |
| WO2017219526A1 (en) | Method for using graphic file format and storage device | |
| WO2018140487A1 (en) | System and method for encapsulating computer communications | |
| WO2024011825A1 (en) | System, method and apparatus for introducing applet into third-party app, and medium | |
| CN108733432B (en) | Method for realizing private method in programming environment, calling method and device thereof | |
| CN109062714A (en) | The method, apparatus and electronic equipment of long-range control Android device | |
| US10891214B2 (en) | Transferring a debug configuration amongst carrier threads for debugging a carried thread | |
| US9525721B2 (en) | Client-side aggregation of nested resource dependencies | |
| US8510530B1 (en) | Memory management for programs operating asynchronously | |
| CN111324395B (en) | Calling method, device and computer readable storage medium | |
| US10802855B2 (en) | Producing an internal representation of a type based on the type's source representation | |
| CN103150161A (en) | Task encapsulation method and device based on MapReduce computation module | |
| KR20130068564A (en) | Terminal apparatus having operating system based on web and method for providing service using thereof | |
| CN116166457A (en) | Data processing method and related equipment | |
| US9411560B2 (en) | Error propagation | |
| US9720660B2 (en) | Binary interface instrumentation | |
| CN112148299A (en) | Byte code object copying method, device, equipment and storage medium |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |