0

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

\read(customer) hello world


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

成一个复合数据结构，它包含1到n 个参数，它们是requestLeaf 对象，这些参数可以是requestLeaf 对象（如果它只是纯文本，应该像上面那样返回（“hello world”））或另一个requestComposite 对象（如果有一些计算正在进行（如读取-> 客户），直到它再次变成纯文本。

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
              )
      )
)

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

第一个组合的参数或叶子代表打印到文档的根或级别 0。 我想为此使用图书馆。这个库可以处理打印文本、图像等，但不能评估任何东西！

Everything > Level 0应该在另一个库中计算。
这个库可以读取成员值，做一些数学运算等，并将其最终值（仅是字符串）返回到要打印的根。
其他所有内容都通过例如 \img() 或 \text() 显式打印

可能有一个

\read(x)

用于查找成员值 X 的标记，
该值应隐式打印（不将其包装到另一个 \text() 中）！

可能有一个 \list() 令牌通过指定的成员列表循环其参数，如：

\list(\read(x)))

X 可能是另一个 Y

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

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

碰巧我对设计模式和 OO 还很陌生。
我现在正在摆弄“执行”的责任链模式，其中渲染/输出库和计算库正在构建处理程序链。
但我有点好奇 CoR 是否真的能满足我的需求：

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

编辑：我现在的方法

  1. 遍历复合材料。
    传递一个 包含输出库和计算库的中介对象。

  2. 如果当前叶子是文本
    检查当前是否是根
    如果不是访问计算库以评估实际值并将其传递给它可能关注的人（例如\read（），\varput（），...）
    如果是访问输出库打印出来

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

我在这里把事情复杂化了吗？

4

1 回答 1

0

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

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);
    }
}
于 2016-01-20T22:54:42.710 回答