Methods, apparatus, storage media, and computer equipment for generating source code files

Abstract

This application discloses a method, apparatus, storage medium, and computer device for generating source code files, relating to the field of low-code development. This application parses a configuration file to obtain the project source code structure; generates an adapter work queue based on the adapters of each directory node; retrieves an adapter from the adapter work queue in a first-in, first-out (FIFO) order; uses the retrieved adapter to transform the design content of the low-code development platform to obtain the output result; and assembles the output result into the code template corresponding to the retrieved adapter to generate the source code file. This application abstracts the source code file generation process, where the adapter operates in a pipeline mode. The adapters on the pipeline process data according to preset instructions, without concern for the specific content, function, or final use of the data.

Description

Technical Field

[0001] This application relates to the field of low-code development, and more particularly to a method, apparatus, storage medium, and computer device for generating source code files. Background Technology

[0002] Low-code development platforms are platforms that allow developers to quickly generate applications with minimal code. They offer a visual approach to application development, enabling developers of varying experience levels to create web and mobile applications through a graphical user interface using drag-and-drop components and model-driven logic. After developers complete their design work through the user interface, the user-designed content is exported as the application's source code file. This export method involves the vendor providing a pre-built standard project structure in a compressed package or directory file. Based on this standard project structure, the user's design content is hard-coded into the corresponding source code file within the standard project structure's directory. In addition to the pre-built standard project structure, low-code development platforms can also customize project structures according to user requirements. The resulting source code files often exhibit complex logic, multiple functionalities, and the inclusion of unrelated code. The same data may be read from the database multiple times in different locations, and other source code files or directory structures may even be generated within the current logic. This leads to chaotic and disorganized business logic, high coupling, and ultimately, increasing bloat and complexity. As business capabilities grow, maintaining and adding new features becomes extremely difficult. During the maintenance phase, it becomes quite difficult for developers to access the business logic in the source code files. They may even struggle to find out how a particular piece of code in the source code file was generated and where a particular file directory in the source code file was generated. Summary of the Invention

[0003] This application provides a method, apparatus, storage medium, and computer equipment for generating source code files, which can solve the problem of difficulty in maintaining source code files generated in the prior art. The technical solution is as follows:

[0004] In a first aspect, embodiments of this application provide a method for generating source code files, the method comprising:

[0005] Receive configuration file;

[0006] The configuration file is parsed to obtain the project source code structure; wherein, the project source code structure includes at least one directory node, each directory node corresponds to a structure object, and the structure object includes an adapter and a cache.

[0007] Generate an adapter work queue based on the adapters of each directory node;

[0008] One adapter is retrieved from the adapter work queue in a first-in, first-out order;

[0009] The retrieved adapter-associated cache is parsed, and the values ​​in the cache are used to dynamically assign values ​​to expressions in the configuration file.

[0010] The output result is obtained by transforming the design content using the extracted adapter;

[0011] The output results are then assembled into the code template corresponding to the extracted adapter to generate the source code file.

[0012] Secondly, embodiments of this application provide a source code file generation apparatus, the apparatus comprising:

[0013] The transceiver unit is used to receive configuration files;

[0014] A parsing unit is used to parse the configuration file to obtain the project source code structure; wherein, the project source code structure includes at least one directory node, each directory node corresponds to a structure object, and the structure object includes an adapter and a cache.

[0015] The generation unit is used to generate an adapter work queue based on the adapters of each directory node;

[0016] A retrieval unit is used to retrieve an adapter from the adapter work queue in a first-in, first-out order;

[0017] The assignment unit is used to parse the cache associated with the retrieved adapter and to dynamically assign values ​​to expressions in the configuration file using the values ​​in the cache.

[0018] The conversion unit is used to convert the design content through the extracted adapter to obtain the output result;

[0019] The generation unit is used to assemble the output results into the code template corresponding to the extracted adapter to generate source code files.

[0020] Thirdly, embodiments of this application provide a computer storage medium storing a plurality of instructions adapted for loading by a processor and executing the above-described method steps.

[0021] Fourthly, embodiments of this application provide a computer device, which may include: a processor and a memory; wherein the memory stores a computer program, the computer program being adapted to be loaded by the processor and to execute the above-described method steps.

[0022] The beneficial effects of the technical solutions provided in some embodiments of this application include at least the following:

[0023] The process involves parsing the configuration file to obtain the project source code structure; generating an adapter work queue based on the adapters in each directory node; retrieving an adapter from the adapter work queue in a first-in-first-out order; converting the design content of the low-code development platform using the retrieved adapter to obtain the output result; and assembling the output result into the code template corresponding to the retrieved adapter to generate source code files. This application abstracts the source code file generation process, eliminating the need for developers to focus on the project structure, understand the code generation logic, debug the code, or use global searches to find out how a file was generated, and eliminating the need to focus on content outside the generated files, thus facilitating the maintenance of source code files. Attached Figure Description

[0024] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0025] Figure 1 This is a schematic diagram of the network architecture provided in the embodiments of this application;

[0026] Figure 2 This is a flowchart illustrating the method for generating source code files provided in an embodiment of this application;

[0027] Figure 3 This is a schematic diagram of the configuration file structure provided in an embodiment of this application;

[0028] Figure 4 This is a schematic diagram illustrating the lifecycle changes of the adapter provided in this application embodiment;

[0029] Figure 5 This is a schematic diagram of the structure of a source code file generation device provided in this application;

[0030] Figure 6 This is a schematic diagram of the structure of a computer device provided in this application. Detailed Implementation

[0031] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0032] It should be noted that the method for generating source code files provided in this application is generally executed by computer equipment, and correspondingly, the source code file generation device is generally located in the computer equipment.

[0033] Figure 1An exemplary system architecture is shown that can be applied to the source code file generation method or source code file generation apparatus of this application.

[0034] like Figure 1 As shown, the system architecture may include a computer device 101 and a server 102. The computer device 101 and the server 102 can communicate via a network, which serves as the medium for providing communication links between the various units. The network may include various types of wired or wireless communication links, such as wired communication links including fiber optic cables, twisted-pair cables, or coaxial cables, and wireless communication links including Bluetooth communication links, Wi-Fi communication links, or microwave communication links.

[0035] The server 102 contains a configuration file and a low-code development platform. The computer device 101 parses the configuration file and exports the application's source code file based on the design content of the low-code development platform.

[0036] This application employs a structured description language to describe the project structure, code style guidelines, code content generator (adapter), and cache. A visual interface binds the content of the configuration file, and the user inputs enterprise standards to derive enterprise standard expressions. When generating the application, the expression from the structured configuration file is read, and an application conforming to the expression is output.

[0037] The configuration file in this application is used for: 1. describing the directory structure of the project (what is the directory structure? Can you give an example? How to describe it?), resulting in a complete project structure; 2. describing the provider of the cache, which is used by the device to parse expressions to achieve dynamic assignment and data sharing caching capabilities; 3. describing the provider of the adapter, which is used by the device to generate source code files; 4. describing the code template used by the adapter, which is used by the device to generate source code files.

[0038] After startup, computer device 101 analyzes the project source code structure description data in the incoming configuration file. By parsing the data, it derives a complete project source code structure. Each directory node corresponds to a structure object, which contains an adapter, a buffer, and extended project source code structure description data. The adapter and buffer for each directory node are added to the adapter work queue. Using a first-in, first-out (FIFO) rule, the buffer is parsed first, dynamically assigning values ​​to expressions within the current description data. Then, the business logic code of the source code content generator (adapter) is executed. The device assembles the adapter's output into the code template and automatically generates the source code file. Next, computer device 101 checks if the structure object contains extended project source code structure description data. This value allows the adapter to load another set of project source code structure description data. If so, a new device startup method is executed in the current thread, with the current value as input, initiating a recursive work task. After completing the work of the current adapter, computer device 101 continues to execute the next adapter until all adapters in the adapter work queue have been executed.

[0039] It should be noted that computer device 101 and server 102 can be either hardware or software. When computer device 101 and server 102 are hardware, they can be implemented as a distributed server cluster consisting of multiple servers, or as a single server. When computer device 101 and server 102 are software, they can be implemented as multiple software programs or software modules (e.g., used to provide distributed services), or as a single software program or software module; no specific limitations are made here.

[0040] The computer device described in this application can be equipped with various communication client applications, such as video recording applications, video playback applications, voice interaction applications, search applications, instant messaging tools, email clients, social platform software, etc.

[0041] Computer devices can be either hardware or software. When a computer device is hardware, it can be any computer device with a display screen, including but not limited to smartphones, tablets, laptops, and desktop computers. When a computer device is software, it can be installed on the computer devices listed above. It can be implemented as multiple software programs or software modules (e.g., used to provide distributed services) or as a single software program or software module; no specific limitation is made here.

[0042] When a computer device is used as hardware, it can also be equipped with a display device and a camera. The display device can be any device capable of displaying information, and the camera is used to capture video streams. Examples of display devices include cathode ray tube displays (CR), light-emitting diode displays (LED), e-ink screens, liquid crystal displays (LCD), and plasma display panels (PDP). Users can utilize the display device on their computer to view displayed text, images, videos, and other information.

[0043] It should be understood that Figure 1 The number of computer devices, networks, and servers shown is for illustrative purposes only. The number of computer devices, networks, and servers can be any number, depending on the implementation requirements.

[0044] The following will be combined with the appendix Figure 2 This application provides a detailed description of the method for generating source code files according to embodiments of the present application. The source code file generation device in these embodiments may be... Figure 1 The computer equipment shown.

[0045] Please see Figure 2 This is a flowchart illustrating a method for generating source code files, as provided in an embodiment of this application. Figure 2 As shown, the method described in this application embodiment may include the following steps:

[0046] S201, Receive configuration file.

[0047] The configuration file is pre-configured. After the source code file generation device (hereinafter referred to as the generation device) starts, it creates the current processing thread, which receives the configuration file transmitted by the server. The configuration file is used to describe the project source code structure, code style, adapter (code generator) and cache properties.

[0048] For example, see Figure 3 The diagram shown is a schematic of the configuration file. Figure 3 The application structure configuration file is the same as the configuration file in S201. Figure 3 The upper part represents the reference relationship between the various sub-files in the configuration file. Figure 3 The lower part represents the source code of the configuration file, which shows that the configuration file uses a structured description.

[0049] S202. Parse the configuration file to obtain the project source code structure.

[0050] The configuration file includes project source code structure description data, which describes the directory structure representing the project source code. The project source code structure includes at least one directory node, and each directory node corresponds to a structure object. The structure object includes an adapter and a cache.

[0051] S203. Generate an adapter work queue based on the adapters of each directory node.

[0052] S204. Take an adapter from the work queue in first-in-first-out order.

[0053] Specifically, the adapters corresponding to each directory node are added to an empty work queue to generate an adapter work queue. The adapters in the adapter work queue are enqueued or dequeued in a first-out-first-out manner. During the enqueue operation, one adapter is added to the tail of the queue, and during the dequeue operation, one adapter is taken from the head of the queue.

[0054] S205, parse the retrieved adapter-associated cache, and dynamically assign values ​​to expressions in the configuration file using the values ​​in the cache.

[0055] Each adapter is associated with a cache. The cache associated with the adapter is determined by the configuration file. The cache stores a value, which is used to dynamically assign values ​​to expressions in the configuration file.

[0056] Furthermore, in order to better monitor the lifecycle of each adapter in the adapter work queue, each adapter is divided into the following four states: created, started, running, and completed.

[0057] For example: see Figure 4 The diagram illustrates the lifecycle changes of an adapter. The process is as follows: When an adapter is retrieved from the adapter work queue, its status is set to "Created"; when the retrieved adapter starts, its status is set to "Started". When an adapter successfully starts and is in execution, its status is set to "Running"; when the adapter finishes execution, its status is set to "Completed". Then, it checks if the queue is empty, i.e., whether there is a next adapter in the queue. If yes, the queue's resources, including hardware and software resources, are released; if no, the next adapter is retrieved from the queue.

[0058] In some embodiments, the processing of all adapters in the adapter work queue is a single transaction. All data in the DAO layer is cached in a cache, and the data needed by the adapter is retrieved or created from the cache, which can reduce the number of database queries and improve data processing efficiency.

[0059] S206. The design content is transformed using the extracted adapter to obtain the output result.

[0060] The business logic code that executes the adapter transforms the design content specified in the low-code development platform using the retrieved adapter to obtain the output result.

[0061] S207. Assemble the output results into the code template corresponding to the extracted adapter to generate source code files.

[0062] In this process, the output of each adapter is assembled into the corresponding code file, and the sum of the results of all adapters generates the final source code file.

[0063] In some embodiments, the configuration file may also include extended project source code structure description data, that is, the configuration file is a nested structure, and the extended project source code structure description data is used to describe the source code results of third-party projects. For example, the configuration file of project A includes source code result description data of project B. The nested structure can enrich the functionality of the application.

[0064] In some embodiments, the adapter version (e.g., Tianhong from YUANGUANG Software) and adapter path used by the current adapter can be specified from the configuration file, for example: see Figure 3 The configuration file shown contains information on how data from the DAO (Data Access Object) layer or other adapters is shared throughout a single request transaction. For designs with the same code content but different project structures, the configuration file can be directly modified for reuse. When the target structure changes, only the result of the configuration file needs to be changed.

[0065] In some embodiments, the step of generating an adapter work queue based on the adapters of each directory node includes:

[0066] Get the creation time of each adapter;

[0067] An adapter work queue is generated based on its creation time; the earlier the adapter is created, the earlier it is positioned in the queue.

[0068] In some embodiments, the step of assembling the output result into the code template corresponding to the extracted adapter to generate a source code file includes:

[0069] Retrieves anchors in the code template; the code target contains one or more anchors, and the anchors may be different from each other.

[0070] The output is inserted into the code template based on the anchors to generate the source code file.

[0071] In the embodiments of this application, when generating source code files for a low-code development platform, the configuration file is parsed to obtain the project source code structure; an adapter work queue is generated based on the adapters of each directory node; an adapter is retrieved from the adapter work queue in a first-in-first-out order; the design content of the low-code development platform is transformed using the retrieved adapter to obtain the output result; and the output result is assembled into the code template corresponding to the retrieved adapter to generate the source code file. This application abstracts the source code file generation process, so developers do not need to pay attention to the project structure, do not need to understand the code generation logic, do not need to debug the code, do not need to find out how a certain file is generated through global search, and do not need to pay attention to content other than the generated file, which facilitates the maintenance of source code files.

[0072] In this embodiment, developers only need to focus on a very simple aspect, and the code logic is also very straightforward. Developers only need to know what content their generated file should contain. By using structured descriptive data, they can quickly locate which file generated the content, what template was used, and in which directory. All the logic is clear at a glance, isolating the business code of other files. At the same time, it solves the code conflicts caused by multiple people collaborating to modify the same file. The entire business logic code serves only this output source code file, thus limiting the possibility of developers coupling various unrelated logics from the framework. Even if the manufacturer continuously iterates and updates the functions, under this device, no matter how complex the business code is written, it only belongs to the business code of this file.

[0073] The following are embodiments of the apparatus described in this application, which can be used to execute the embodiments of the method described in this application. For details not disclosed in the apparatus embodiments of this application, please refer to the embodiments of the method described in this application.

[0074] Please see Figure 4 This illustration shows a schematic diagram of a source code file generation apparatus provided in an exemplary embodiment of this application, hereinafter referred to as apparatus 5. Apparatus 5 can be implemented as all or part of a computer device through software, hardware, or a combination of both. Apparatus 5 includes: a transceiver unit 501, a parsing unit 502, a generation unit 503, an extraction unit 504, an assignment unit 505, a conversion unit 506, and a generation unit 507.

[0075] Transceiver unit 501 is used to receive configuration files;

[0076] The parsing unit 502 is used to parse the configuration file to obtain the project source code structure; wherein, the project source code structure includes at least one directory node, each directory node corresponds to a structure object, and the structure object includes an adapter and a cache.

[0077] The generation unit 503 is used to generate an adapter work queue based on the adapters of each directory node;

[0078] The retrieval unit 504 is used to retrieve an adapter from the adapter work queue according to the first-in-first-out order;

[0079] Assignment unit 505 is used to parse the retrieved adapter-associated cache and dynamically assign values ​​to expressions in the configuration file using the values ​​in the cache.

[0080] The conversion unit 506 is used to convert the design content through the extracted adapter to obtain the output result;

[0081] The generation unit 507 is used to assemble the output result into the code template corresponding to the extracted adapter to generate a source code file.

[0082] In one or more possible embodiments, the directory node further includes: extended project source code structure description data.

[0083] In one or more possible embodiments, it also includes:

[0084] The monitoring unit is used to monitor the lifecycle of each adapter; wherein the status of the adapter is divided into: created, started, running, or completed.

[0085] In one or more possible embodiments, it also includes:

[0086] The release unit is used to release the resources of the adapter work queue when it is detected that the adapter work queue is an empty queue.

[0087] In one or more possible embodiments, the step of generating an adapter work queue based on the adapters of each directory node includes:

[0088] Get the creation time of each adapter;

[0089] An adapter work queue is generated based on its creation time; the earlier the adapter was created, the earlier it is positioned.

[0090] In one or more possible embodiments, the step of assembling the output result into the code template corresponding to the extracted adapter to generate a source code file includes:

[0091] Locate the anchor in the query code template;

[0092] The output is inserted into the code template based on the anchors to generate the source code file.

[0093] In one or more possible embodiments, the configuration file may further include: adapter version and adapter path.

[0094] It should be noted that the apparatus 5 provided in the above embodiments is only illustrated by the division of the above functional modules when executing the source code file generation method. In practical applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the above functions. In addition, the source code file generation apparatus and the source code file generation method embodiments provided in the above embodiments belong to the same concept, and the implementation process is detailed in the method embodiments, which will not be repeated here.

[0095] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0096] This application also provides a computer storage medium that can store multiple instructions, which are adapted to be loaded and executed by a processor as described above. Figure 2 The method steps of the illustrated embodiment can be found in the following documentation for detailed execution. Figure 2 The specific details of the illustrated embodiments will not be elaborated here.

[0097] This application also provides a computer program product that stores at least one instruction, which is loaded and executed by the processor to implement the source code file generation method described in the above embodiments.

[0098] Please see Figure 6 This document provides a schematic diagram of the structure of a computer device according to an embodiment of this application. Figure 6 As shown, the computer device 600 may include: at least one processor 601, at least one network interface 604, a user interface 603, a memory 605, and at least one communication bus 602.

[0099] The communication bus 602 is used to enable communication between these components.

[0100] The user interface 603 may include a display screen and a camera. Optionally, the user interface 603 may also include a standard wired interface and a wireless interface.

[0101] The network interface 604 may optionally include a standard wired interface or a wireless interface (such as a Wi-Fi interface).

[0102] The processor 601 may include one or more processing cores. The processor 601 connects to various parts of the computer device 600 using various interfaces and lines, and performs various functions and processes data by running or executing instructions, programs, code sets, or instruction sets stored in the memory 605, and by calling data stored in the memory 605. Optionally, the processor 601 may be implemented using at least one hardware form of Digital Signal Processing (DSP), Field-Programmable Gate Array (FPGA), or Programmable Logic Array (PLA). The processor 601 may integrate one or a combination of several of the following: Central Processing Unit (CPU), Graphics Processing Unit (GPU), and modem. The CPU primarily handles the operating system, user interface, and applications; the GPU is responsible for rendering and drawing the content to be displayed on the screen; and the modem handles wireless communication. It is understood that the modem may also not be integrated into the processor 601 and may be implemented as a separate chip.

[0103] The memory 605 may include random access memory (RAM) or read-only memory. Optionally, the memory 605 may include a non-transitory computer-readable storage medium. The memory 605 can be used to store instructions, programs, code, code sets, or instruction sets. The memory 605 may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for at least one function (such as touch function, sound playback function, image playback function, etc.), instructions for implementing the above-described method embodiments, etc.; the data storage area may store data involved in the above-described method embodiments, etc. Optionally, the memory 605 may also be at least one storage device located remotely from the aforementioned processor 601. Figure 6 As shown, the memory 605, which serves as a computer storage medium, may include an operating system, a network communication module, a user interface module, and application programs.

[0104] exist Figure 6In the computer device 600 shown, the user interface 603 is mainly used to provide an input interface for the user and to obtain user input data; while the processor 601 can be used to call the application program stored in the memory 605 and specifically execute, such as Figure 2 The method shown can be referred to for details. Figure 2 As shown, it will not be elaborated further here.

[0105] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory, or random access memory, etc.

[0106] The above-disclosed embodiments are merely preferred embodiments of this application and should not be construed as limiting the scope of this application. Therefore, any equivalent variations made in accordance with the claims of this application shall still fall within the scope of this application.

Claims

1. A method for generating source code files, characterized in that, include: Receive configuration file; The configuration file is used to describe the project source code structure, code style, adapter and cache properties; The configuration file also includes extended project source code structure description data, which describes the source code results of third-party projects. The configuration file has a nested structure, which enriches the application's functionality. The configuration file also includes adapter version and adapter path. The configuration file is parsed to obtain the project source code structure; wherein, the project source code structure includes at least one directory node, each directory node corresponds to a structure object, and the structure object includes an adapter and a cache. Generate an adapter work queue based on the adapters of each directory node, including: obtaining the creation time of each adapter; generating the adapter work queue based on the creation time; wherein, the earlier the creation time of the adapter, the earlier its position. One adapter is retrieved from the adapter work queue in a first-in, first-out order; The retrieved adapter-associated cache is parsed, and the values ​​in the cache are used to dynamically assign values ​​to the expressions in the configuration file. The output result is obtained by transforming the design content using the extracted adapter; The output results are assembled into the code template corresponding to the extracted adapter to generate source code files; including: assembling the output results of each adapter into the corresponding code file, and the superposition of the results of all adapters to generate the final source code file.

2. The method according to claim 1, characterized in that, Also includes: Monitor the lifecycle of each adapter; the status of the adapter is divided into: created, started, running, or completed.

3. The method according to claim 2, characterized in that, Also includes: When the adapter work queue is detected to be empty, the resources of the adapter work queue are released.

4. The method according to claim 1, characterized in that, The step of assembling the output result into the code template corresponding to the extracted adapter to generate the source code file includes: Locate the anchor in the query code template; The output is inserted into the code template based on the anchors to generate the source code file.

5. A source code file generation apparatus, characterized in that, include: The transceiver unit is used to receive configuration files; The configuration file is used to describe the project source code structure, code style, adapter and cache attributes; the configuration file also includes extended project source code structure description data. The configuration file is a nested structure, and the extended project source code structure description data is used to describe the source code results of third-party projects, enriching the application's functionality through the nested structure; the configuration file also includes adapter version and adapter path; A parsing unit is used to parse the configuration file to obtain the project source code structure; wherein, the project source code structure includes at least one directory node, each directory node corresponds to a structure object, and the structure object includes an adapter and a cache. The generation unit is used to generate an adapter work queue based on the adapters of each directory node, including: obtaining the creation time of each adapter; generating the adapter work queue based on the creation time; wherein, the earlier the creation time of the adapter, the earlier its position. A retrieval unit is used to retrieve an adapter from the adapter work queue in a first-in, first-out order; The assignment unit is used to parse the cache associated with the retrieved adapter and to dynamically assign values ​​to expressions in the configuration file using the values ​​in the cache. The conversion unit is used to convert the design content through the extracted adapter to obtain the output result; The generation unit is used to assemble the output results into the code template corresponding to the extracted adapter to generate source code files; including: assembling the output results of each adapter into the corresponding code file, and the superposition of the results of all adapters to generate the final source code file.

6. A computer storage medium, characterized in that, The computer storage medium stores a plurality of instructions, which are adapted to be loaded by a processor and executed as method steps as claimed in any one of claims 1 to 4.

7. A computer device, characterized in that, include: A processor and a memory; wherein the memory stores a computer program adapted to be loaded by the processor and executed the method steps as claimed in any one of claims 1 to 4.

Images