Question

我正在解析一个字符串，如：

\read(customer) hello world


~> \method(arg, arg, ...)

进入复合数据结构， 1 持续 n 参数， requestLeaf对象，其中参数可以是 requestLeaf对象（如果它只是纯文本，应该像上面那样返回（“hello world”））或其他 requestComposite对象（如果有一些计算）继续（比如read-＆gt; customer）直到它再次只是纯文本。

requestComposite Object
(
  [requests:protected] => Array
      (
          [0] => commandRequest Object
              (
                  [methodName:protected] => read
                  [arguments:protected] => Array
                      (
                        [0] => commandRequest Object
                          (
                            [methodName:protected] => text
                            [arguments:protected] => customer
                          )
                      )
              )
          [1] => commandRequest Object
              (
                  [methodName:protected] => text
                  [arguments:protected] =>  hello world
              )
      )
)

我想要实现的是遍历整个复合体，以便呈现某种文档。

第一个复合的参数或 leafs 表示用于打印到文档的 root 或Level 0。
我想为此使用一个库。这个库可以处理打印文本，图像等，但无法评估任何内容！

一切＆gt;等级0 应在另一个库中计算该库可以读取成员值，进行一些数学运算等，并将其最终值（仅限字符串）返回到根以打印出来。
其他所有内容都通过例如明确打印。 \ img（）或\ text（）

可能有

\read(x)

令牌查找成员值X，
哪个值应隐式打印，（不将其包装到另一个\ text（））！

可能有一个\ list（）标记，用于通过指定的成员列表循环其参数，如：

\list(\read(x)))

X可能是另一个Y

\list(\read(\read(y))).

换句话说：我不知道结构会有多深。

发现我对Design Patterns和OO特别陌生。
我现在正在摆弄责任链模式以“执行”，其中渲染/输出库和计算库正在构建处理程序链。
但我对CoR是否满足我的需求感到有些好奇：

你会如何解决这样的问题？

编辑：我现在的方法

迭代复合材料。
传递 Mediator 对象
其中包含输出库和计算库。
如果当前叶是文本
检查当前是否为根
如果否访问计算库以评估实际值并将其传递给可能涉及的人（例如\ read（），\ varput（），...）
如果是访问输出库将其打印出来

我想到的是我必须在两个库中实现每个requestMethod才能实现自动根打印。即
输出中的\ read（）应将文本打印到文档中，
计算库中的\ read（）应查找成员值。

我在这里过分复杂了吗？

Answer 1

继续评论，并假设您已根据输入构建了复合树，您需要做什么，不能这样做：

import java.util.ArrayList;
import java.util.List;
interface Component {
    void add(Component component);
    List<Component> children();
}
class Composite implements Component {
    @Override public void add(Component component) {
        children.add(component);
    }
    @Override public List<Component> children() {
        return children;
    }
    List<Component> children=new ArrayList<>();
}
class Leaf implements Component {
    @Override public void add(Component component) {
        throw new UnsupportedOperationException();
    }
    @Override public List<Component> children() {
        return null;
    }
}
public class So34886186 {
    static String indent(int n) {
        String s="";
        for(int i=0;i<n;i++)
            s+=" ";
        return s;
    }
    static void print(Component root,Component component,int indent) {
        if(component instanceof Leaf)
            if(component.equals(root))
                System.out.println(indent(indent)+"    root: leaf: "+component);
            else System.out.println(indent(indent)+"not root: leaf: "+component);
        else {
            if(component.equals(root)) {
                System.out.println(indent(indent)+"    root: composite: "+component+": (");
                for(Component component2:((Composite)component).children)
                    print(root,component2,indent+4);
                System.out.println(indent(indent)+")");
            } else {
                System.out.println(indent(indent)+"not root: composite: "+component+": (");
                for(Component component2:((Composite)component).children)
                    print(root,component2,indent+4);
                System.out.println(indent(indent)+")");
            }
        }
    }
    public static void main(String[] args) {
        Component root=new Composite();
        root.add(new Leaf());
        Component one=new Composite();
        root.add(one);
        one.add(new Leaf());
        Component two=new Composite();
        root.add(two);
        print(root,root,0);
    }
}

用于在不同“输出级别”

1 个答案: