WO2022140880A1

WO2022140880A1 - Method and apparatus for controlling finite state machine, computer device, and storage medium

Info

Publication number: WO2022140880A1
Application number: PCT/CN2020/139828
Authority: WO
Inventors: 陈绍昆
Original assignee: 深圳元戎启行科技有限公司
Priority date: 2020-12-28
Filing date: 2020-12-28
Publication date: 2022-07-07
Also published as: CN115885253A

Abstract

A method for controlling a finite state machine comprises: receiving a control signal, the control signal carrying signalling information; on the basis of the signalling information, converting the control signal into an event; invoking an event handling class to handle the event, wherein the event handling class comprises a state machine class and a state class, the state machine class being used for implementing state jumping logic, and the state class being used for completing handling of a specific service logic; when handling the event, if on the basis of the current state the state machine class determines to accept handling of the event, then implementing corresponding service logic handling for the event, and returning the corresponding handling state; and, on the basis of the handling state, determining the handling means corresponding to the next state.

Description

Control method, device, computer equipment and storage medium for finite state machine

technical field

The present application relates to the field of computer technology, and in particular, to a control method, apparatus, computer device and storage medium for a finite state machine.

Background technique

With the development of computer technology, finite state machine (FSM) can effectively and conveniently describe the dynamic behavior of systems and components, which is widely used in the development of telecommunication software applications. FSM has a limited number of states, generally including states and transition relationships between states. At present, in software programming engineering, the commonly used way to implement FSM is to use procedural language, such as C language, and the FSM implemented by this method is essentially described by conditional statements.

However, in the current control method of the finite state machine, the switching relationship between the states needs to be registered in advance, and the state machine is not universal, so the state cannot be dynamically added flexibly. Rollback, that is, the inability to dynamically control the jump between different states, easily leads to low control efficiency.

SUMMARY OF THE INVENTION

According to various embodiments disclosed in the present application, a control method, apparatus, computer device and storage medium for a finite state machine are provided.

A control method for a finite state machine, comprising:

receiving a control signal; the control signal carries signaling information; converting the control signal into an event according to the signaling information; calling an event processing class to process the event; wherein the event processing class includes a state machine class and state class; the state machine class is used to implement the logic of state jumping; the state class is used to complete the processing of specific business logic; when processing the event, if the state machine class according to the current state, If it is determined that the event is accepted to be processed, corresponding business logic processing is performed on the event, and a corresponding processing state is returned; and a processing mode corresponding to the next state is determined according to the processing state.

A control device for a finite state machine, comprising:

a receiving module for receiving a control signal; the control signal carries signaling information; a conversion module for converting the control signal into an event according to the signaling information; a calling module for calling an event processing class pair The event is processed; wherein, the event processing class includes a state machine class and a state class; the state machine class is used to implement the logic of state jumping; the state class is used to complete the processing of specific business logic; processing module , used to process the event, if the state machine class decides to accept and process the event according to the current state, perform corresponding business logic processing on the event, and return the corresponding processing state; and determine the module, use According to the processing state, the processing mode corresponding to the next state is determined.

A computer device comprising a memory and one or more processors, the memory having computer-readable instructions stored therein, the computer-readable instructions, when executed by the processor, cause the one or more processors to execute The following steps: get product information;

One or more computer storage media storing computer-readable instructions that, when executed by one or more processors, cause the one or more processors to perform the following steps: obtain product information;

The details of one or more embodiments of the application are set forth in the accompanying drawings and the description below. Other features and advantages of the present application will be apparent from the description, drawings, and claims.

Description of drawings

In order to illustrate the technical solutions in the embodiments of the present application more clearly, the following briefly introduces the drawings required in the embodiments. Obviously, the drawings in the following description are only some embodiments of the present application. For those of ordinary skill in the art, other drawings can also be obtained from these drawings without any creative effort.

Fig. 1 is the application environment diagram of the control method of finite state machine in one embodiment;

2 is a schematic flowchart of a control method for a finite state machine in one embodiment;

FIG. 3 is a schematic flowchart of steps of determining a processing mode corresponding to a next state according to a processing state in one embodiment;

FIG. 4 is a schematic flowchart of obtaining a processing strategy step corresponding to the current state in one embodiment;

Fig. 5 is when the processing strategy that GetStrategy function returns is replacement event in one embodiment, then according to the event, create a new state to replace the current state, the schematic flow chart of the event processing step;

6A is a schematic flowchart of a control method for a finite state machine in another embodiment;

6B is a schematic diagram of a calling relationship when a finite state machine processes an event in one embodiment;

7 is a structural block diagram of a control device of a finite state machine in one embodiment;

FIG. 8 is a diagram of the internal structure of a computer device in one embodiment.

Detailed ways

In order to make the technical solutions and advantages of the present application clearer, the present application will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application, but not to limit the present application.

The control method of the finite state machine provided in the embodiment of the present application can be applied to the application environment shown in FIG. 1 , where the terminal 102 communicates with the terminal 104 through the network through the network. The terminal 102 receives the control signal sent by the terminal 104, and the control signal carries signaling information. The terminal 102 converts the control signal into an event according to the signaling information. The terminal 102 invokes the event processing class to process the event. The event processing class includes a state machine class and a state class. The state machine class is used to implement the logic of state jumping, and the state class is used to complete the processing of specific business logic. When the terminal 102 processes the event, if the state machine class determines that the event is to be processed according to the current state, it performs corresponding business logic processing on the event, and returns the corresponding processing state. The terminal 102 determines the processing mode corresponding to the next state according to the processing state. The terminal 102 may be, but is not limited to, various personal computers, notebook computers, smart phones, tablet computers, and portable wearable devices.

The following embodiments illustrate that the control method of the finite state machine is applied to the terminal in FIG. 1 as an example, but it should be noted that in practical application, the method is not limited to the above-mentioned terminal.

As shown in FIG. 2 , in one embodiment, a flow chart of a control method for a finite state machine, the method specifically includes the following steps:

Step 202: Receive a control signal, where the control signal carries signaling information.

A finite state machine is a tool for modeling object behavior. Its role is to describe the sequence of states that an object experiences in its life cycle and how to respond to various events from the outside world. In computer science, finite state machines are widely used in modeling application behavior, hardware circuit system design, software engineering, compilers, network protocols, and research in computing and languages. The state machine is composed of a state register and a combinational logic circuit, which can perform state transition according to a preset state according to a control signal, and is a control center that coordinates the actions of related signals and completes specific operations.

A finite state machine is abbreviated as FSM (Finite State Machine). A finite state machine is a mathematical model that represents a finite number of states and behaviors such as transitions and actions between these states. A common computer uses a finite state machine as a computing model. For different states of memory, the central processing unit (CPU, Central Processing Unit), that is, the CPU, performs calculations by reading the memory value and updates the state in the memory. The CPU also accepts instructions from external input devices (such as keyboard and mouse) through the message bus, changes the state in memory after calculation, outputs the calculation results to external display devices (such as monitors), and persists them on the hard disk. Finite state machine models are also frequently used in game design. Taking the fruit ninja game as an example, the state of the fruit in the game is a finite state, and its running trajectory is calculated by a calculation formula that simulates the laws of physical motion. After a banana is thrown, it will run in a parabola, and its position changes every frame. It is a state change, and the state change is determined by a calculation formula. The game also involves complex human-computer interaction events, such as "cutting" fruit on the screen with your hands. After the fruit perceives this event, it will enter an explosion state according to program logic.

Specifically, the terminal may receive a control signal, and the control signal carries signaling information. A control signal is a signal used for control, and the computer is controlled by means of the control signal as a medium. The control signal may be sent to the terminal by different devices, and the different devices may include third-party devices, terminal devices, servers, and IoT devices. The signaling information refers to the specific content of the signaling, that is, the control information carried by the control signal. In a wireless communication system, signaling is a control signal required to ensure normal communication in order to make the entire network work in an orderly manner, in addition to transmitting user information. That is, signaling is actually a signal for control.

Step 204: Convert the control signal into an event according to the signaling information.

After the terminal receives the control signal sent by different devices, the terminal can convert the control signal into an event according to the signaling information carried in the control signal. An event refers to an object's response to an external action. When an event occurs in an object, the code corresponding to the event of the object will be executed. This code is called an "event procedure". The terminal can convert the received signal into an event according to the specific content of the signaling, that is, the terminal abstracts the received signal into an event, and an event can include event type, event identifier (ie event id) and event content (msg). Specifically, the terminal can convert the signal into an internally defined event type, event identifier and event content according to the specific content of the signaling, and save these values in the structure of the event Event. The event type and event identifier can be stored as an integer variable type, and the event content is the memory address of the signaling stored through the void pointer, so that different signals can be converted into events that can be handled uniformly. A void pointer refers to a special kind of pointer, denoted as an "untyped pointer", which is used in ANSIC to replace "char*" as the type of generic pointer. Since a void pointer has no specific type, it can point to any type of data. That is, a pointer of any type can be directly assigned to a void pointer without other related casts.

Step 206, call the event processing class to process the event; wherein, the event processing class includes a state machine class and a state class; the state machine class is used to implement the logic of state jumping, and the state class is used to complete the processing of specific business logic.

After the terminal converts the control signal into an event according to the signaling information, the terminal can call the event processing class to process the abstract event. Class is the basis for object-oriented programming (OOP, Object-Oriented Programming) to realize information encapsulation. A class is a user-defined reference data type, also known as a class type. Each class contains data descriptions and a set of functions that manipulate data or pass messages. An instance of a class is called an object. An event processing class refers to a set of reusable business functions, including some objects and their behaviors, which can be invoked to achieve the purpose of reusing functions. The event processing class can include a state machine class and a state class. The state machine class is used to implement the logic of state jumping, and the state class is used to complete the processing of specific business logic. Specifically, after the terminal converts the signal into an event according to the signaling information, the terminal can call the event processing class to process the converted event. That is, the event processing class in the terminal can inherit from a class (Handler class), and the Handler class contains the HandEvent function. The state machine class is the StateMachine class, and the state class is the State class. The StateMachine class and the State class are essentially classes that process events. Therefore, by abstracting an event processing Handler class, an abstract interface HandEvent event handler is provided. The HandEvent function can be implemented in the subclass. Specifically, the HandEvent function in the subclass StateMachine implements the logic of state jumping, and the HandEvent function in the subclass State completes the processing of specific business logic. Each state State contains the Enter function, the function used to enter the state, the HandEvent function, the function used to process the events that the current state can accept, the Exit function, the function used to exit the state, the GetStrategy function, used to get the current state A function of the processing strategy for the accepted event.

Step 208 , when the event is processed, if the state machine class determines that the event is to be processed according to the current state, the event is processed by corresponding business logic, and the corresponding processing state is returned.

When the terminal invokes the event processing class to process the event, if the state machine class determines that the event is to be processed according to the current state, it will perform corresponding business logic processing on the event and return the corresponding processing state. Specifically, when the terminal calls the Handler class to process the event, if the StateMachine class decides to accept the processing event according to the current state, the HandEvent function in the subclass State will process the event corresponding to the business logic, and return the corresponding processing state. That is, the terminal calls the HandEvent function of the current state, performs corresponding business logic processing on the event, and returns the corresponding processing state. The processing status is that each status returns the corresponding status code after processing the event, and the status code is the return value of the HandEvent function. That is, the status code refers to the return value of the state processing function, and the StateMachine class can determine the next action based on this return value.

Step 210: Determine the processing mode corresponding to the next state according to the processing state.

The terminal calls the event processing class to process the event, and after returning the corresponding processing state, the terminal can continue to call the event processing class, and determine the processing method corresponding to the next state according to the returned processing state. For example, the terminal performs corresponding business logic processing on the current event through the HandEvent function in the subclass State. The HandEvent function can return three processing states of DONE_EVENT, CONTINUE_EVENT, and UNKOWN_EVENT according to the processing of the current event. DONE_EVENT means that the current state has finished processing the event, and can jump to the next state; CONTINUE_EVENT means that the current state continues to process the event without state jumping; UNKOWN_EVENT means that the current state cannot accept the event, and the StateMachine class needs to be based on the GetStrategy of the current state function to get the strategy of the current state, and execute the next steps according to the obtained strategy.

In the traditional control method of finite state machine, when the state jumps, it is necessary to specify the next state to be jumped in the state machine, so it is inconvenient to add a new state. Each time a state is added, the code corresponding to the state machine needs to be modified. . In this embodiment, however, by receiving a control signal, the control signal carries signaling information, and according to the signaling information, the control signal is converted into an event, and an event processing class is invoked to process the event. The event processing class includes a state machine class and a state class. The state machine class is used to implement the logic of state jumping, and the state class is used to complete the processing of specific business logic. When processing an event, if the state machine class decides to accept and process the event according to the current state, it will perform corresponding business logic processing on the event, return the corresponding processing state, and determine the processing method corresponding to the next state according to the processing state. As a result, by abstracting various signals into a unified parameter Event to process events and jump between states, the state machine part can be made more general, and it is convenient to add new states without modifying the state. The code of the machine part can flexibly create states and perform state jumps according to the event processing strategy, thereby effectively improving the control efficiency.

In one embodiment, as shown in FIG. 3 , the processing status includes processing completed, continuing processing and not accepting processing. According to the processing status, the steps of determining the processing mode corresponding to the next status include:

Step 302, when the returned processing state is that the processing is completed, jump to the next state to process the event.

Step 304, when the returned processing state is to continue processing, no state jump is performed, and the HandEvent function of the current state is called to continue processing the event.

Step 306, when the returned processing status is not accepting processing, acquire the processing strategy corresponding to the current status.

The terminal calls the event processing class to process the event, and after returning the corresponding processing state, the terminal can continue to call the event processing class, and determine the processing method corresponding to the next state according to the processing state returned in the previous step. Processing status includes processing completed, continuing processing, and not accepting processing. Specifically, when the HandEvent function returns the processing status according to the processing of the current event, the StateMachine class can jump to the next status to process the event. When the returned processing state is to continue processing, no state jump is performed, and the StateMachine class calls the HandEvent function of the current state to continue processing the event. When the returned processing status is not accepting processing, the StateMachine class obtains the processing strategy corresponding to the current status. That is, only when the state of UNKOWN_EVENT (not accepting processing) is returned, the StateMachine class will call the GetStrategy function of the current state to obtain the corresponding processing strategy.

Specifically, when processing the current event through the HandEvent function, the terminal judges whether the event Event is an event processed in the current state by calling the HandEvent function of the State class according to the event type and event identifier of the event Event, and if so, uses the HandEvent function. Perform specific business logic processing on the current event; if not, it indicates that the current state cannot process the event, and returns the processing state of UNKOWN_EVENT. Each state processes the event and returns the corresponding status code. When returning to the processing state of CONTINUE_EVENT, it means that the current state can process the event continuously, and there is no need to perform state jumps, which can reduce unnecessary state jumps. There is no need to jump from the current state to the current state, and the jump between different states can be dynamically controlled, thereby effectively improving the control efficiency.

In one of the embodiments, as shown in FIG. 4 , the steps of acquiring the processing strategy corresponding to the current state include:

Step 402, calling the GetStrategy function to obtain the processing strategy corresponding to the current state, and the processing strategy includes an ignore event, a replacement event and a rollback event.

Step 404, when the processing strategy returned by the GetStrategy function is to ignore the event, ignore the event.

Step 406, when the processing strategy returned by the GetStrategy function is a replacement event, then according to the event, a new state is created to replace the current state, and the event is processed.

Step 408, when the processing strategy returned by the GetStrategy function is a rollback event, restore to the previous state to process the event.

The terminal calls the event processing class to process the event. When the returned processing status is not accepting processing, the StateMachine class can obtain the processing strategy corresponding to the current status. Specifically, the StateMachine class can obtain the processing strategy corresponding to the current state by calling the GetStrategy function, and the processing strategy includes an ignore event (IGNORE), a replacement event (REPLACE), and a rollback event (RECOVER). That is, the GetStrategy function can return three strategies: IGNORE, REPLACE and RECOVER for the current event. IGNORE means to ignore the current event, REPLACE means to create a new state based on the current event to replace the current state to process the event, RECOVER means to restore the previous state to process the current event. That is, when the processing strategy returned by the GetStrategy function is to ignore the event, the event is ignored. When the processing strategy returned by the GetStrategy function is a replacement event, a new state is created to replace the current state according to the event, and the event is processed. When the processing strategy returned by the GetStrategy function is a rollback event, it restores to the previous state to process the event. Compared with the control method of the traditional finite state machine, since the previous state is not saved and there is no dynamic processing strategy for events, the state rollback cannot be realized, and the problem of when the state can be rolled back cannot be solved. In this embodiment, the state jumping strategy is implemented in a specific state, so that it is possible to decide how to jump to the next state or roll back to the previous state according to the current state at runtime. Because the state machine StateMachine saves the previous state, if the current state's event processing strategy is RECOVER, the StateMachine can be rolled back to the previous state, enabling flexible state creation and state jumping according to the event processing strategy.

In one embodiment, as shown in Figure 5, when the processing strategy returned by the GetStrategy function is a replacement event, then according to the event, a new state is created to replace the current state, and the steps of processing the event include:

Step 502, when the processing strategy returned by the GetStrategy function is the replacement event, the state factory class is called, and the CreateState function is used to create a corresponding new state according to the event type and event identifier of the event.

Step 504 , replace the current state with a new state, and use the new state to process the event.

The terminal calls the event processing class to process the event. When the returned processing status is not accepting processing, the StateMachine class can obtain the processing strategy corresponding to the current status by calling the GetStrategy function. When the processing strategy returned by the GetStrategy function is a replacement event, a new state is created to replace the current state according to the event, and the event is processed. The StateMachine class, the state machine class, contains a state factory class (ie, a StateFactory class object) and two states. The two states are the current state (cur_state) and the previous state (last_state). StateFactory is a class that creates specific State class objects and is responsible for the creation of specific states, that is, the StateFactory class is mainly used to create corresponding states based on events. last_state represents the last state of StateMachine, which is used when the state is rolled back. cur_state represents the current state of StateMachine. The function of cur_state is that when StateMachine receives an event, StateMachine first tries to call the HandEvent function of cur_state to process the event, and decides the next process according to the processing result of cur_state. For example, the next flow can include creating a new state to handle events, ignoring current events, and doing state rollbacks.

Specifically, when the processing strategy returned by the GetStrategy function is a replacement event, the StateMachine class can call the StateFactory, and the StateFactory uses the CreateState function to create a corresponding new state according to the event type and event identifier of the current event. Further, StateMachine replaces the current state with a new state, and uses the new state to process the event. StateFactory provides a CreateState function to create a specific state, and the function parameter is the event Event. As a result, StateMachine does not need to care about how the specific state is created, and only needs to use the state factory to create the next state, so that the flexible creation of the state can be realized. In addition, encapsulating the process of state creation into the state factory class can easily extend the state. When a new state needs to be added, only part of the code in the state factory class needs to be modified, and the specific user of the state StateMachine It is said that there is no need to make any changes, which is convenient for code expansion, and can realize flexible state creation and state jumping according to the event processing strategy.

In one of the embodiments, as shown in FIG. 6A , a method for controlling a finite state machine is provided, and the method is applied to the terminal in FIG. 1 as an example for description, including the following steps:

Step 602: Receive a control signal, where the control signal carries signaling information.

Step 604, according to the signaling information, convert the control signal into an event.

Step 606, call the event processing class to process the event. Among them, the event processing class includes a state machine class and a state class. The state machine class is used to implement the logic of state jumping, and the state class is used to complete the processing of specific business logic.

Step 608 , when processing the event, if the state machine class determines to accept the processing event according to the current state, it calls the HandEvent function of the current state, performs corresponding business logic processing on the event, and returns the corresponding processing state. Among them, the processing state is that each state returns the corresponding state code after processing the event, and the state code is the return value of the HandEvent function.

Step 610, when the event is processed, if the state machine class determines that the event is not accepted for processing according to the current state, the return state is that the processing is not accepted; the processing strategy corresponding to the current state is obtained, and the event is processed according to the processing strategy, Returns the corresponding processing status.

Step 612, when the returned processing state is that the processing is completed, then jump to the next state to process the event; when the returned processing state is to continue processing, then no state jump is performed, and the HandEvent function of the current state is called to continue. Process the event; when the returned processing status is not accepting processing, the processing strategy corresponding to the current status is obtained.

As shown in FIG. 6B , it is a schematic diagram of a calling relationship when a finite state machine processes an event. After the terminal receives the control signal sent by different devices, the terminal can convert the signal into an event according to the signaling information carried in the control signal. Different devices can include third-party devices, terminal devices, servers, and IoT devices. Further, the terminal can call the event processing class to process the event. The event processing class includes a state machine class and a state class. The state machine class is used to implement the logic of state jumping, and the state class is used to complete the processing of specific business logic. When processing an event, if the state machine class decides to accept the processing event according to the current state, it will call the HandEvent function of the current state, process the corresponding business logic of the event, and return the corresponding processing state. The processing status is that each status returns the corresponding status code after processing the event, and the status code is the return value of the HandEvent function. In addition, when the event is processed, if the state machine class determines that the event is not accepted according to the current state, the return state is that the processing is not accepted. When the return status is not accepting processing, the terminal obtains the processing strategy corresponding to the current status through StateMachine, processes the event according to the obtained processing strategy, and returns the corresponding processing status. Further, when the returned processing state is completed, StateMachine jumps to the next state to process the event; when the returned processing state is to continue processing, StateMachine does not perform state jump and calls the HandEvent function of the current state. , continue to process the event; when the returned processing status is not accepting processing, StateMachine continues to obtain the processing strategy corresponding to the current status. An event can include event type, event identifier (ie event id) and event content (MSG is a structure in Windows programs, and in Windows programs, messages are represented by the MSG structure). Event type (Event_type), which represents a type of event. The event identifier is the event id (Event_id), which represents a specific event. Therefore, the processing function of each event can be flexibly processed according to the event type and event id. For example, in the parent state, you can only care about the event type and the specific event. The logic can be handled in substates.

The following is an example of an unmanned vehicle. After the system receives a signal, that is, when the terminal receives the signal sent by the IoT device vehicle A, the terminal can convert the signal into an internal event A according to the control information carried in the signal. Further, the terminal can call the state machine to process the event A, and the state machine determines whether the current event A can be accepted and processed according to the current state. process and return the corresponding processing status. For example, the status of vehicle A may include normal operation and failure. The state machine can determine whether the current event A can be accepted and processed according to the current state, that is, whether the state of the vehicle A corresponding to the event A is normal operation or failure. When the state machine determines to accept and process event A according to the current state, it means that the state of vehicle A corresponding to event A is normal operation, and then the next process is entered. If it is determined that the event A is not accepted for processing, it means that the state of the vehicle A corresponding to the event A is faulty, and the event A cannot be accepted and processed, and the process of acquiring the processing strategy is entered, and the event A is processed according to the acquired processing strategy. , returns the corresponding processing status. For example, when the processing strategy obtained by the state machine is a replacement event (REPLACE), the state machine can call the state factory to create a new state to process the event A, and return the corresponding processing state. If none of the above steps can effectively handle the event A, then ignore the event A. When the vehicle A is running normally, it can receive command tasks, and the command tasks include task start, task suspension, task cancellation, and task end. The state machine can realize the transition of the state of the vehicle A during normal operation, that is, control the vehicle A to execute the command task start, task suspension, task cancellation or task end. That is, the system can define a large parent state, save a state machine in the parent state to complete the jump of the child state, realize the nesting of the state machine, and add child states to the parent state conveniently and flexibly. That said, the performance is the same, so complex nesting can be done internally without worrying about affecting the users of the state machine.

In this embodiment, all signals are abstracted into events, and corresponding processing can be flexibly made according to the event type or event identifier through the event processing class. For example, only the event type is concerned in the parent state, and specific events are processed in the child state. , so that the state can be created flexibly and the state jump can be performed according to the event processing strategy. At the same time, the state can also be rolled back according to the strategy at runtime, which can dynamically control the jump between different states and effectively improve the control efficiency.

In one embodiment, the event processing class is a Handler class, which is a computer term, a Java subclass and an inherited interface. Handler class can include subclasses StateMachine class and State class, both StateMachine class and State class inherit from Handler class. A Handler pointer to the StateMachine class is saved in the State class, and the Handler pointer is used to implement the nesting of parent-child state machines. Since both the StateMachine class and the State class inherit from the abstract event processing class, that is, the Handler class, a StateMachine class can be injected into the State class, which can flexibly combine each Handler class and support the nesting of state machines. You can use the decoration mode to save a Handler pointer to the StateMachine class in the State, so that another state machine is nested in the state, that is, it is convenient to use the decoration mode to realize the infinite nesting of the parent-child state machine. In the traditional finite state machine control method, the nesting of states is supported but the nesting of state machines is not supported. It is also necessary to maintain the switching of child states in the parent state, which makes the boundary between the state and the state machine unclear, and the concept is somewhat confusing. In this embodiment, the outside world can only use a pointer of a Handler class without caring about the specific processing class, which is convenient for code expansion and modification of some codes in the state factory class, and will not affect the users of the Handler. . Since both StateMachine and State inherit from Hander, the relationship between StateMachine and State can be flexibly combined to realize the combination of parent-child state and the state jump of child state.

It should be understood that although the steps in the flowcharts of FIGS. 1-6 are shown in sequence according to the arrows, these steps are not necessarily executed in the sequence shown by the arrows. Unless explicitly stated herein, the execution of these steps is not strictly limited to the order, and these steps may be performed in other orders. Moreover, at least a part of the steps in FIGS. 1-6 may include multiple steps or multiple stages. These steps or stages are not necessarily executed at the same time, but may be executed at different times. The execution of these steps or stages The order is also not necessarily sequential, but may be performed alternately or alternately with other steps or at least a portion of the steps or phases within the other steps.

In one of the embodiments, as shown in FIG. 7, a control apparatus for a finite state machine is provided, including: a receiving module 702, a converting module 704, a calling module 706, a processing module 708 and a determining module 710, wherein:

The receiving module 702 is configured to receive a control signal, where the control signal carries signaling information.

The conversion module 704 is configured to convert the control signal into an event according to the signaling information.

The calling module 706 is used to call the event processing class to process the event, wherein the event processing class includes a state machine class and a state class, the state machine class is used to implement the logic of state jumping, and the state class is used to complete the processing of specific business logic .

The processing module 708 is configured to, when processing the event, if the state machine class determines to accept the processing event according to the current state, perform corresponding business logic processing on the event, and return the corresponding processing state.

The determining module 710 is configured to determine the processing mode corresponding to the next state according to the processing state.

In one embodiment, the calling module is further configured to call the HandEvent function of the current state, perform corresponding business logic processing on the event, and return the corresponding processing state, wherein the processing state is that each state processes the event and returns the corresponding processing state. The status code, the status code is the return value of the HandEvent function.

In one of the embodiments, the apparatus further includes: a jumping module and an obtaining module.

The jump module is used to jump to the next state to process the event when the returned processing state is completed. The calling module is also used to call the HandEvent function of the current state and continue to process the event when the returned processing state is to continue processing without performing state jump. The obtaining module is used to obtain the processing strategy corresponding to the current state when the returned processing status is not accepting processing.

In one embodiment, the calling module is further configured to call the GetStrategy function to obtain a processing strategy corresponding to the current state, and the processing strategy includes an ignore event, a replacement event, and a rollback event. The processing module is also used to ignore the event when the processing strategy returned by the GetStrategy function is to ignore the event; when the processing strategy returned by the GetStrategy function is to replace the event, create a new state to replace the current state and process the event according to the event; When the processing strategy returned by the GetStrategy function is a rollback event, it returns to the previous state to process the event.

In one embodiment, the calling module is further configured to call the state factory class when the processing strategy returned by the GetStrategy function is a replacement event, and use the CreateState function to create a corresponding new state according to the event type and event identifier of the event. The processing module is also used to replace the current state with a new state, and use the new state to process events.

In one embodiment, the processing module is further configured to, when processing the event, if the state machine class determines, according to the current state, that the event is not accepted for processing, the return state is that the processing is not accepted. The acquiring module is also used to acquire the processing strategy corresponding to the current state, process the event according to the processing strategy, and return the corresponding processing state.

In one of the embodiments, the apparatus further includes: a saving module.

The saving module is used to save a Handler pointer to the StateMachine class in the State class, and the Handler pointer is used to implement the nesting of parent-child state machines.

For the specific limitation of the control device of the finite state machine, reference may be made to the limitation of the control method of the finite state machine above, which will not be repeated here. Each module in the control device of the above-mentioned finite state machine can be implemented in whole or in part by software, hardware and combinations thereof. The above modules can be embedded in or independent of the processor in the computer device in the form of hardware, or stored in the memory in the computer device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

In one of the embodiments, a computer device is provided, and the computer device may be a terminal, and the internal structure diagram thereof may be as shown in FIG. 8 . The computer equipment includes a processor, memory, a communication interface, a display screen, and an input device connected by a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium, an internal memory. The nonvolatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the execution of the operating system and computer programs in the non-volatile storage medium. The communication interface of the computer device is used for wired or wireless communication with an external terminal, and the wireless communication can be realized by WIFI, operator network, NFC (Near Field Communication) or other technologies. The computer program implements a control method of a finite state machine when executed by a processor. The display screen of the computer equipment may be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment may be a touch layer covered on the display screen, or a button, a trackball or a touchpad set on the shell of the computer equipment , or an external keyboard, trackpad, or mouse.

Those skilled in the art can understand that the structure shown in FIG. 8 is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the computer equipment to which the solution of the present application is applied. Include more or fewer components than shown in the figures, or combine certain components, or have a different arrangement of components.

A computer device including a memory and one or more processors, the memory having computer-readable instructions stored in the memory, and one or more non-volatile storage media storing the computer-readable instructions, the computer-readable instructions being stored by one or more non-volatile storage media When executed by each processor, one or more processors are made to implement the steps of the finite state machine control method provided in any one of the embodiments of this application.

Those of ordinary skill in the art can understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing the relevant hardware through computer-readable instructions, and the computer-readable instructions can be stored in a non-volatile computer. In the readable storage medium, the computer-readable instructions, when executed, may include the processes of the foregoing method embodiments. Wherein, any reference to memory, storage, database or other media used in the various embodiments provided in this application may include at least one of non-volatile and volatile memory. Non-volatile memory may include read-only memory (Read-Only Memory, ROM), magnetic tape, floppy disk, flash memory, or optical memory, and the like. Volatile memory may include random access memory (RAM) or external cache memory. By way of illustration and not limitation, the RAM may be in various forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM).

The technical features of the above embodiments can be combined arbitrarily. For the sake of brevity, all possible combinations of the technical features in the above embodiments are not described. However, as long as there is no contradiction in the combination of these technical features, all It is considered to be the range described in this specification.

The above-mentioned embodiments only represent several embodiments of the present application, and the descriptions thereof are relatively specific and detailed, but should not be construed as a limitation on the scope of the invention patent. It should be pointed out that for those skilled in the art, without departing from the concept of the present application, several modifications and improvements can be made, which all belong to the protection scope of the present application. Therefore, the scope of protection of the patent of the present application should be determined by the appended claims.

Claims

A control method for a finite state machine, comprising:

receiving a control signal; the control signal carries signaling information; converting the control signal into an event according to the signaling information; calling an event processing class to process the event; wherein the event processing class includes a state machine class and state class; the state machine class is used to implement the logic of state jumping; the state class is used to complete the processing of specific business logic; when processing the event, if the state machine class according to the current state, If it is determined that the event is accepted to be processed, corresponding business logic processing is performed on the event, and a corresponding processing state is returned; and a processing mode corresponding to the next state is determined according to the processing state.
The method according to claim 1, wherein, performing corresponding business logic processing on the event and returning a corresponding processing status, comprising:

Call the HandEvent function of the current state, perform corresponding business logic processing on the event, and return the corresponding processing status; wherein, the processing status is that each status returns the corresponding status code after processing the event, The status code is the return value of the HandEvent function.
The method according to claim 1, wherein the processing status includes processing completed, continuing processing and not accepting processing, and determining a processing mode corresponding to the next status according to the processing status, comprising:

When the returned processing state is that the processing is completed, then jump to the next state to process the event; when the returned processing state is to continue processing, no state jump is performed, and the current state is called. The HandEvent function continues to process the event; and when the returned processing status is not accepting processing, the processing strategy corresponding to the current status is obtained.
The method according to claim 3, wherein the acquiring the processing strategy corresponding to the current state comprises:

Call the GetStrategy function to obtain the processing strategy corresponding to the current state; the processing strategy includes an ignore event, a replacement event and a rollback event; when the processing strategy returned by the GetStrategy function is to ignore the event, then ignore the event; When the processing strategy returned by the GetStrategy function is a replacement event, then according to the event, a new state is created to replace the current state, and the event is processed; and when the processing strategy returned by the GetStrategy function is a rollback event , then revert to the previous state to process the event.
The method according to claim 4, wherein, when the processing strategy returned by the GetStrategy function is a replacement event, a new state is created to replace the current state according to the event, and the event is processed, include:

When the processing strategy returned by the GetStrategy function is a replacement event, call the state factory class, and use the CreateState function to create a corresponding new state according to the event type and event identifier of the event; and replace the current state with the new state state, the event is processed with the new state.
The method of claim 1, wherein the method further comprises:

When processing the event, if the state machine class determines not to accept the processing of the event according to the current state, the return state is not to accept the processing; obtain the processing strategy corresponding to the current state; and according to the processing strategy , process the event and return the corresponding processing status.
The method of claim 1, wherein the method further comprises:

Described event handling class is Handler class, described Handler class includes subclass StateMachine class and State class; Described StateMachine class and State class both inherit from described Handler class; And save a Handler pointer to StateMachine class in State class , the Handler pointer is used to implement the nesting of parent-child state machines.
A control device for a finite state machine, comprising:

a receiving module for receiving a control signal; the control signal carries signaling information; a conversion module for converting the control signal into an event according to the signaling information; a calling module for calling an event processing class pair The event is processed; wherein, the event processing class includes a state machine class and a state class; the state machine class is used to implement the logic of state jumping; the state class is used to complete the processing of specific business logic; processing module , used to process the event, if the state machine class decides to accept and process the event according to the current state, perform corresponding business logic processing on the event, and return the corresponding processing state; and determine the module, use According to the processing state, the processing mode corresponding to the next state is determined.
The control device for a finite state machine according to claim 8, wherein the device further comprises:

The calling module is also used to call the HandEvent function of the current state, perform corresponding business logic processing on the event, and return the corresponding processing state; wherein, the processing state is that each state processes the event Then, the corresponding status code is returned, and the status code is the return value of the HandEvent function.
The control device for a finite state machine according to claim 8, wherein the device further comprises:

The jumping module is used to jump to the next state to process the event when the returned processing state is completed; the calling module is also used to continue processing when the returned processing state is , then no state jump is performed, the HandEvent function of the current state is called, and the event is continued to be processed; and an acquisition module is used to acquire the current state when the returned processing state is not to accept processing corresponding processing strategy.
The control apparatus for a finite state machine according to claim 10, wherein the apparatus further comprises:

The calling module is also used to call the GetStrategy function to obtain the processing strategy corresponding to the current state; the processing strategy includes an ignore event, a replacement event and a rollback event; a return module is used when the processing strategy returned by the GetStrategy function is: When the event is ignored, the event is ignored; the creation module is used to create a new state to replace the current state according to the event when the processing strategy returned by the GetStrategy function is a replacement event, and perform the operation on the event. processing; and a recovery module, configured to restore to the previous state to process the event when the processing strategy returned by the GetStrategy function is a rollback event.
The control apparatus for a finite state machine according to claim 11, wherein the apparatus further comprises:

The calling module is also used to call the state factory class when the processing strategy returned by the GetStrategy function is a replacement event, and use the CreateState function to create a corresponding new state according to the event type and event identifier of the event; and the replacement module, It is used to replace the current state with the new state, and use the new state to process the event.
The control device for a finite state machine according to claim 8, wherein the device further comprises:

The determining module is used to, when processing the event, if the state machine class determines that the event is not accepted for processing according to the current state, the return state is that the processing is not accepted; the obtaining module is further configured to obtain the current state processing strategy corresponding to the state; and the processing module is further configured to process the event according to the processing strategy, and return the corresponding processing state.
The control device for a finite state machine according to claim 8, wherein the device further comprises:

The saving module is used to save a Handler pointer to the StateMachine class in the State class, where the Handler pointer is used to implement the nesting of the parent-child state machine.
A computer device comprising a memory and one or more processors, the memory having computer-readable instructions stored in the memory that, when executed by the one or more processors, cause the one or more processors to A processor performs the steps of the method of any one of claims 1 to 7.
One or more computer storage media storing computer readable instructions which, when executed by one or more processors, cause the one or more processors to perform any one of claims 1 to 7 the steps of the method.