Mercurial Hosting > nabble

comparison src/nabble/view/web/template/NodeList.java @ 0:7ecd1a4ef557

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add content
author Franklin Schmidt <fschmidt@gmail.com>
date Thu, 21 Mar 2019 19:15:52 -0600
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:7ecd1a4ef557
1 package nabble.view.web.template;
2
3 import fschmidt.util.java.Filter;
4 import nabble.model.ModelHome;
5 import nabble.model.Node;
6 import nabble.model.NodeIterator;
7 import nabble.model.NodeSearcher;
8 import nabble.model.User;
9 import nabble.naml.compiler.Command;
10 import nabble.naml.compiler.CommandSpec;
11 import nabble.naml.compiler.IPrintWriter;
12 import nabble.naml.compiler.Interpreter;
13 import nabble.naml.compiler.Namespace;
14 import nabble.naml.compiler.ScopedInterpreter;
15 import nabble.naml.namespaces.ListSequence;
16
17 import java.util.ArrayList;
18 import java.util.Arrays;
19 import java.util.Collection;
20 import java.util.Collections;
21 import java.util.List;
22
23
24 @Namespace (
25 name = "node_list",
26 global = true
27 )
28 public final class NodeList extends ListSequence<Node> {
29
30 static void subapps(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,String filter) {
31 List<Node> nodes = loopNode.getChildApps(filter).get(0, 100);
32 NodeList loop = new NodeList(nodes, loopNode, false);
33 Object block = interp.getArg(loop,"do");
34 out.print(block);
35 }
36
37 static void descendantApps(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode) {
38 List<Node> nodes = loopNode.getDescendantApps().get(0, 1000);
39 NodeList loop = new NodeList(nodes, loopNode, false);
40 Object block = interp.getArg(loop,"do");
41 out.print(block);
42 }
43
44 static void ancestors(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,String order) {
45 Node parent = loopNode.getParent();
46 List<Node> nodes = parent != null? parent.getAncestors().get(0, 1000) : Collections.<Node>emptyList();
47 if ("reverse".equalsIgnoreCase(order) && nodes.size() > 1)
48 Collections.reverse(nodes);
49 NodeList loop = new NodeList(nodes, loopNode, false);
50 Object block = interp.getArg(loop,"do");
51 out.print(block);
52 }
53
54 private static boolean hasMore(List<Node> nodes,int size) {
55 if( nodes.size() <= size )
56 return false;
57 nodes.remove(size);
58 return true;
59 }
60
61 public static void children(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,NodeIterator<? extends Node> nodeIter,int indexRecord,int length) {
62 List<Node> nodes = nodeIter.get(indexRecord, length+1);
63 boolean hasMore = hasMore(nodes,length);
64 NodeList loop = new NodeList(nodes, loopNode, hasMore);
65 Object block = interp.getArg(loop,"do");
66 out.print(block);
67 }
68
69 public static void topics(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,NodeIterator<? extends Node> nodeIter,int indexRecord,int length) {
70 List<Node> nodes = nodeIter.get(indexRecord, length+1);
71 boolean hasMore = hasMore(nodes,length);
72 NodeList loop = new NodeList(nodes, loopNode, hasMore);
73 Object block = interp.getArg(loop,"do");
74 out.print(block);
75 }
76
77 public static void posts(IPrintWriter out,ScopedInterpreter<NodeList> interp,Node loopNode,int indexRecord,int length,String sortBy,Filter<Node> filter) {
78 List<Node> nodes;
79 if ("date-ascending".equals(sortBy)) {
80 nodes = loopNode.getPostsByDateAscending(filter).get(indexRecord, length+1);
81 } else if ("date-descending".equals(sortBy)) {
82 nodes = loopNode.getPostsByDate(filter).get(indexRecord, length+1);
83 } else {
84 throw new RuntimeException("'sort' attribute not set");
85 }
86 boolean hasMore = hasMore(nodes,length);
87 NodeList loop = new NodeList(nodes, loopNode, hasMore);
88 Object block = interp.getArg(loop,"do");
89 out.print(block);
90 }
91
92 static void userNodes(IPrintWriter out,ScopedInterpreter<NodeList> interp, NodeIterator<? extends Node> nodeIter, int indexRecord,int length) {
93 List<Node> nodes = nodeIter.get(indexRecord,length+1);
94 boolean hasMore = hasMore(nodes,length);
95 NodeList loop = new NodeList(nodes, null, hasMore);
96 Object block = interp.getArg(loop,"do");
97 out.print(block);
98 }
99
100
101 private final Node loopNode;
102 private final boolean hasMore;
103
104 /**
105 * Cache the lastNodes to prevent them from being
106 * garbage collected so that there aren't multiple
107 * database accesses. This is an optimization.
108 */
109 private final Collection<Node> lastNodes;
110
111 public NodeList(List<Node> nodes, Node loopNode,boolean hasMore) {
112 super(nodes);
113 this.loopNode = loopNode;
114 this.hasMore = hasMore;
115 lastNodes = NabbleNamespace.current().site().cacheLastNodes(nodes);
116 }
117
118 public static final CommandSpec preload_messages = CommandSpec.NO_OUTPUT;
119
120 @Command public void preload_messages(IPrintWriter out,Interpreter interp) {
121 ModelHome.preloadMessages(elements);
122 }
123
124 @Command public void there_is_more(IPrintWriter out,Interpreter interp) {
125 out.print( hasMore );
126 }
127
128 @Command public void has_loop_node(IPrintWriter out,Interpreter interp) {
129 out.print( loopNode != null );
130 }
131
132 public static final CommandSpec loop_node = CommandSpec.DO;
133
134 @Command public void loop_node(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
135 out.print( interp.getArg(new NodeNamespace(loopNode),"do") );
136 }
137
138 public static final CommandSpec current_node = CommandSpec.DO;
139
140 @Command public void current_node(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
141 NodeNamespace row = new NodeNamespace(get());
142 Object block = interp.getArg(row,"do");
143 out.print(block);
144 }
145
146 public static final CommandSpec node_at = CommandSpec.DO()
147 .parameters("index")
148 .build()
149 ;
150
151 @Command public void node_at(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
152 int index = interp.getArgAsInt("index");
153 NodeNamespace row = new NodeNamespace(elements.get(index));
154 Object block = interp.getArg(row,"do");
155 out.print(block);
156 }
157
158 @Command public void next_node(IPrintWriter out,Interpreter interp) {
159 next_element(out,interp);
160 }
161
162 @Command public void has_previous_node(IPrintWriter out,Interpreter interp) {
163 out.print( getPrevious() != null );
164 }
165
166 public static final CommandSpec previous_node = CommandSpec.DO;
167
168 @Command public void previous_node(IPrintWriter out,ScopedInterpreter<NodeNamespace> interp) {
169 NodeNamespace row = new NodeNamespace(getPrevious());
170 Object block = interp.getArg(row,"do");
171 out.print(block);
172 }
173
174 public static final CommandSpec sub_list = CommandSpec.DO()
175 .parameters("length")
176 .optionalParameters("start")
177 .build()
178 ;
179
180 @Command public void sub_list(IPrintWriter out,ScopedInterpreter<NodeList> interp) {
181 int start = interp.getArgAsInt("start",0);
182 int length = interp.getArgAsInt("length");
183 NodeList ns ;
184 if( start==0 && length >= elements.size() ) {
185 ns = this;
186 } else {
187 ns = new NodeList( elements.subList(start,Math.min(elements.size(),start+length)), loopNode, false );
188 }
189 out.print( interp.getArg(ns,"do") );
190 }
191
192 }