命令队列

命令队列

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
    参考命令模式实现的命令队列例子，已封装好顺序执行、同步执行命令，顺序/同步执行命令可相互嵌套。
    撤销(undo)可参考执行(execute)的方式实现。
"""


class Command:
    """
        所有命令的基类
    """

    def __init__(self):
        self.m_executedCallbackDict = {}
        self.m_undidCallbackDict = {}

    def execute(self):
        """
            统一执行接口
        """
        # print("[execute]")
        self.executedCallback()

    def undo(self):
        """
            统一撤销接口
        """
        # print("[undo]")
        self.undidCallback()

    def setExecutedCallback(self, k, func):
        self.m_executedCallbackDict[k] = func

    def setUndidCallback(self, k, func):
        self.m_undidCallbackDict[k] = func

    def executedCallback(self):
        self.callback(self.m_executedCallbackDict)

    def undidCallback(self):
        self.callback(self.m_undidCallbackDict)

    def callback(self, callbackDict):
        for k, func in callbackDict.items():
            if callable(func):

                func(self)

    def getCommandUUID(self):
        return id(self)


class SequenceQueueCommand(Command):
    """
        容器命令-顺序执行
    """

    def __init__(self, cmds=None):
        Command.__init__(self)
        self.m_commands = [] if cmds is None else cmds
        self.m_executingCommands = []
        self.m_executedCommands = []

    def appendCommand(self, cmd):
        self.m_commands.append(cmd)

    def insertCommand(self, index, cmd):
        self.m_commands.insert(index, cmd)

    def execute(self):
        if self.m_executingCommands:
            return
        if self.m_commands:
            cmd = self.m_commands.pop(0)
            cmd.setExecutedCallback(
                k=self.getCommandUUID(), func=self.executedOneCommand)
            self.m_executingCommands = [cmd]
            cmd.execute()
        else:
            self.executedAllCommand()

    def executedOneCommand(self, cmd):
        self.m_executedCommands.append(cmd)
        if cmd in self.m_executingCommands:
            self.m_executingCommands.remove(cmd)
        self.execute()

    def executedAllCommand(self):
        self.executedCallback()

    def undo(self):
        pass


class ParallelQueueCommand(Command):
    """
        容器命令-同步执行
    """

    def __init__(self, cmds=None):
        Command.__init__(self)
        self.m_commands = [] if cmds is None else cmds
        self.m_executingCommands = []
        self.m_executedCommands = []

    def execute(self):
        if self.m_executingCommands:
            return
        for cmd in self.m_commands:
            cmd.setExecutedCallback(
                k=self.getCommandUUID(), func=self.executedOneCommand)
            self.m_executingCommands.append(cmd)
            cmd.execute()

    def executedOneCommand(self, cmd):
        self.m_executedCommands.append(cmd)
        if cmd in self.m_executingCommands:
            self.m_executingCommands.remove(cmd)
        if not self.m_executingCommands:
            self.executedAllCommand()

    def executedAllCommand(self):
        self.executedCallback()

    def undo(self):
        pass



# ---------------- test ----------------

class MoveByCommand(Command):
    def __init__(self, pWalker, x, y):
        Command.__init__(self)
        self.m_Walker = pWalker
        self.m_X = x
        self.m_Y = y

    def execute(self):
        print("[%s] MoveBy (%s, %s)" % (self.m_Walker, self.m_X, self.m_Y))
        self.m_Walker.moveBy(self.m_X, self.m_Y)
        Command.execute(self)


class JumpByCommand(Command):
    def __init__(self, pWalker, y):
        Command.__init__(self)
        self.m_Walker = pWalker
        self.m_Y = y

    def execute(self):
        print("[%s] JumpBy (%s)" % (self.m_Walker, self.m_Y))
        self.m_Walker.jumpBy(self.m_Y)
        Command.execute(self)


class ScaleByCommand(Command):
    def __init__(self, pWalker, fScaleX, fScaleY):
        Command.__init__(self)
        self.m_Walker = pWalker
        self.m_ScaleX = fScaleX
        self.m_ScaleY = fScaleY

    def execute(self):
        print("[%s] ScaleBy (%s, %s)" %
              (self.m_Walker, self.m_ScaleX, self.m_ScaleY))
        self.m_Walker.scaleBy(self.m_ScaleX, self.m_ScaleY)
        Command.execute(self)


class Walker:
    def __init__(self, sName):
        self.m_Name = sName

        self.m_X = 0
        self.m_Y = 0
        self.m_ScaleX = 1.0
        self.m_ScaleY = 1.0

    def __repr__(self):
        return self.m_Name

    def moveBy(self, x, y):
        self.m_X += x
        self.m_Y += y

    def jumpBy(self, y):
        self.m_Y += y

    def scaleBy(self, fScaleX, fScaleY):
        self.m_ScaleX += fScaleX
        self.m_ScaleY += fScaleY


if __name__ == '__main__':
    pWalker = Walker("jack")
    print("start:", pWalker.m_X, pWalker.m_Y, pWalker.m_ScaleX, pWalker.m_ScaleY)

    moveByCommand = MoveByCommand(pWalker, 10, 20)
    jumpByCommand = JumpByCommand(pWalker, 3)
    scaleByCommand = ScaleByCommand(pWalker, 0.5, -0.5)
    parallelQueueCommand = ParallelQueueCommand([moveByCommand, jumpByCommand])

    sequenceQueueCommand = SequenceQueueCommand([parallelQueueCommand, scaleByCommand])
    sequenceQueueCommand.execute()

    print("end:", pWalker.m_X, pWalker.m_Y, pWalker.m_ScaleX, pWalker.m_ScaleY)

    # 输出：
    #('start:', 0, 0, 1.0, 1.0)
    #[jack] MoveBy (10, 20)
    #[jack] ScaleBy (0.5, -0.5)
    #[jack] JumpBy (3)
    #('end:', 10, 23, 1.5, 0.5)

• 可爱的你，看完请给我点个赞哦