Python设计模式(十八)【组合模式】

天空黑暗到一定程度，星辰就会熠熠生辉。

"""组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。"""

"""
一个类定义的组合对象，它可以用名称来存储分层使用的字典。

这个类是相同的分层字典，但它按名称提供方法来添加/访问/修改子元素，就像一个组合。

"""

def normalize(val):
    """ 正常化一个特殊字符的字符串，以便它可以被用来作为一个Python对象一个属性
    """

    if val.find('-') != -1:
        val = val.replace('-', '_')

    return val


def denormalize(val):
    """ 非规范化一个字符串"""

    if val.find('_') != -1:
        val = val.replace('_', '-')

    return val


class SpecialDict(dict):

    """
    字典类，允许其键直接访问属性
    """

    def __getattr__(self, name):

        if name in self.__dict__:
            return self.__dict__[name]
        elif name in self:
            return self.get(name)
        else:
            # 检查非规范化的名字
            name = denormalize(name)
            if name in self:
                return self.get(name)
            else:
                raise AttributeError('没有属性名称 %s' % name)

    def __setattr__(self, name, value):

        if name in self.__dict__:
            self.__dict__[name] = value
        elif name in self:
            self[name] = value
        else:
            # 检查非规范化的名字
            name2 = denormalize(name)
            if name2 in self:
                self[name2] = value
            else:
                # 新属性
                self[name] = value


class CompositeDict(SpecialDict):

    """一类像一个层次词典。
    这个类是基于组合设计模式"""

    ID = 0

    def __init__(self, name=''):

        if name:
            self._name = name
        else:
            self._name = ''.join(('id#', str(self.__class__.ID)))
            self.__class__.ID += 1

        self._children = []
        # 链接到父亲
        self._father = None
        self[self._name] = SpecialDict()

    def __getattr__(self, name):

        if name in self.__dict__:
            return self.__dict__[name]
        elif name in self:
            return self.get(name)
        else:
            #  检查非规范化的名字
            name = denormalize(name)
            if name in self:
                return self.get(name)
            else:
                #查看孩子列表
                child = self.findChild(name)
                if child:
                    return child
                else:
                    attr = getattr(self[self._name], name)
                    if attr:
                        return attr

                    raise AttributeError('no attribute named %s' % name)

    def isRoot(self):
        """ Return 我是否根组件"""

        # 如果我没有父母，我的根节点
        return not self._father

    def isLeaf(self):
        """ Return 叶节点 """

        # 我是一片叶节点，如果我没有孩子
        return not self._children

    def getName(self):
        """ 返回ConfigInfo对象的名称 """

        return self._name

    def getIndex(self, child):
        """返回孩子ConfigInfo对象的'child'的索引"""

        if child in self._children:
            return self._children.index(child)
        else:
            return -1

    def getDict(self):
        """ 返回包含的词典"""

        return self[self._name]

    def getProperty(self, child, key):
        """ 返回属性值"""

        # 首先get孩子的字典
        childDict = self.getInfoDict(child)
        if childDict:
            return childDict.get(key, None)

    def setProperty(self, child, key, value):
        """
        设置属性的“key”的值
        """

        #首先get孩子的字典
        childDict = self.getInfoDict(child)
        if childDict:
            childDict[key] = value

    def getChildren(self):
        """ 返回此对象的直接子列表 """

        return self._children

    def getAllChildren(self):
        """ 返回此对象的所有子列表 """

        l = []
        for child in self._children:
            l.append(child)
            l.extend(child.getAllChildren())

        return l

    def getChild(self, name):
        """
         用给定名称返回直接子对象
        """

        for child in self._children:
            if child.getName() == name:
                return child

    def findChild(self, name):
        """
            从树返回(用给定的名称)子对象
        """

        # 这将返回给定名称的第一个子对象
        #任何其他具有类似名称的子对象不被考虑
        for child in self.getAllChildren():
            if child.getName() == name:
                return child

    def findChildren(self, name):
        """ 从树返回给定名称的子对象列表"""

        #这将返回给定名称的所有子项的列表，不论查询的深度
        children = []

        for child in self.getAllChildren():
            if child.getName() == name:
                children.append(child)

        return children

    def getPropertyDict(self):
        """ 返回属性字典"""

        d = self.getChild('__properties')
        if d:
            return d.getDict()
        else:
            return {}

    def getParent(self):

        return self._father

    def __setChildDict(self, child):
        """
        私有方法来设置子对象的'child'的字典在内部字典
        """

        d = self[self._name]
        d[child.getName()] = child.getDict()

    def setParent(self, father):

        self._father = father

    def setName(self, name):
        """
            设置此ConfigInfo对象的名称为'name'
        """

        self._name = name

    def setDict(self, d):
        self[self._name] = d.copy()

    def setAttribute(self, name, value):
        self[self._name][name] = value

    def getAttribute(self, name):
        return self[self._name][name]

    def addChild(self, name, force=False):
        """
        添加一个新的子节点
        如果可选标志“force”设置为True，子对象被覆盖，如果它已经存在。
        该函数返回子对象，无论是新的或现有的
        """

        if type(name) != str:
            raise ValueError('Argument should be a string!')

        child = self.getChild(name)
        if child:
            # print('Child %s present!' % name)
            # 如果force==True 更换它
            if force:
                index = self.getIndex(child)
                if index != -1:
                    child = self.__class__(name)
                    self._children[index] = child
                    child.setParent(self)

                    self.__setChildDict(child)
            return child
        else:
            child = self.__class__(name)
            child.setParent(self)

            self._children.append(child)
            self.__setChildDict(child)

            return child

    def addChild2(self, child):
        """
        添加子对象'child'。如果它已经存在，它由缺省覆盖
        """
        currChild = self.getChild(child.getName())
        if currChild:
            index = self.getIndex(currChild)
            if index != -1:
                self._children[index] = child
                child.setParent(self)
                # 未设置现有的子节点的父级
                currChild.setParent(None)
                del currChild

                self.__setChildDict(child)
        else:
            child.setParent(self)
            self._children.append(child)
            self.__setChildDict(child)


if __name__ == "__main__":
    window = CompositeDict('Window')
    frame = window.addChild('Frame')
    tfield = frame.addChild('Text Field')
    tfield.setAttribute('size', '20')

    btn = frame.addChild('Button1')
    btn.setAttribute('label', '提交')

    btn = frame.addChild('Button2')
    btn.setAttribute('label', '浏览')

    #print(window)
    #print(window.Frame)
    #print(window.Frame.Button1)
    #print(window.Frame.Button2)
    print(window.Frame.Button1.label)
    print(window.Frame.Button2.label)

运行结果如图: