Esempio n. 1
0
 protected final ArrayList<PageNode> buildNodes() {
   ArrayList<PageNode> nodes = new ArrayList<PageNode>();
   for (NodeBuilder node : this.nodes) {
     nodes.add(node.build());
   }
   return nodes;
 }
  // ignored due to: https://github.com/hazelcast/hazelcast/issues/5035
  @Ignore
  @Test
  public void testMapLoaderLoadUpdatingIndex() throws Exception {
    final int nodeCount = 3;
    String mapName = randomString();
    SampleIndexableObjectMapLoader loader = new SampleIndexableObjectMapLoader();

    Config config = createMapConfig(mapName, loader);

    NodeBuilder nodeBuilder = new NodeBuilder(nodeCount, config).build();
    HazelcastInstance node = nodeBuilder.getRandomNode();

    IMap<Integer, SampleIndexableObject> map = node.getMap(mapName);
    for (int i = 0; i < 10; i++) {
      map.put(i, new SampleIndexableObject("My-" + i, i));
    }

    final SqlPredicate predicate = new SqlPredicate("name='My-5'");
    assertPredicateResultCorrect(map, predicate);

    map.destroy();
    loader.preloadValues = true;

    node = nodeBuilder.getRandomNode();
    map = node.getMap(mapName);

    assertLoadAllKeysCount(loader, 1);
    assertPredicateResultCorrect(map, predicate);
  }
Esempio n. 3
0
 @Override
 public void init() {
   super.init();
   nodeBuilder = new NodeBuilder();
   nodeBuilder.setContext(getContext());
   nodeBuilder.setOrder(getOrder());
   nodeBuilder.setTree(getTree());
 }
  /**
   * Loads this configuration from stream<br>
   * Note: Closes the stream when finished
   *
   * @param stream to read from
   */
  public void loadFromStream(InputStream stream) throws IOException {
    try {
      InputStreamReader reader = new InputStreamReader(stream);
      StringBuilder builder = new StringBuilder();
      BufferedReader input = new BufferedReader(reader);

      try {
        String line, trimmedLine;
        HeaderBuilder header = new HeaderBuilder();
        NodeBuilder node = new NodeBuilder(this.getIndent());
        StringBuilder mainHeader = new StringBuilder();
        int indent;
        while ((line = input.readLine()) != null) {
          line = StringUtil.ampToColor(line);
          indent = StringUtil.getSuccessiveCharCount(line, ' ');
          trimmedLine = line.substring(indent);
          // Prevent new name convention errors
          if (trimmedLine.equals("*:")) {
            trimmedLine = "'*':";
            line = StringUtil.getFilledString(" ", indent) + trimmedLine;
          }
          // Handle a main header line
          if (trimmedLine.startsWith(MAIN_HEADER_PREFIX)) {
            mainHeader.append('\n').append(trimmedLine.substring(MAIN_HEADER_PREFIX.length()));
            continue;
          }
          // Handle a header line
          if (header.handle(trimmedLine)) {
            continue;
          }
          // Handle a node line
          node.handle(trimmedLine, indent);
          // Apply the header to a node if available
          if (header.hasHeader()) {
            this.setHeader(node.getPath(), header.getHeader());
            header.clear();
          }
          builder.append(line).append('\n');
        }
        // Set main header
        if (mainHeader.length() > 0) {
          this.setHeader(mainHeader.toString());
        }
      } finally {
        input.close();
      }
      try {
        this.getSource().loadFromString(builder.toString());
      } catch (InvalidConfigurationException e) {
        throw new IOException("YAML file is corrupt", e);
      }
    } catch (FileNotFoundException ex) {
      // Ignored
    }
  }
Esempio n. 5
0
  /**
   * At the highest level, we adhere to the classic b-tree insertion algorithm:
   *
   * <p>1. Add to the appropriate leaf 2. Split the leaf if necessary, add the median to the parent
   * 3. Split the parent if necessary, etc.
   *
   * <p>There is one important difference: we don't actually modify the original tree, but copy each
   * node that we modify. Note that every node on the path to the key being inserted or updated will
   * be modified; this implies that at a minimum, the root node will be modified for every update,
   * so every root is a "snapshot" of a tree that can be iterated or sliced without fear of
   * concurrent modifications.
   *
   * <p>The NodeBuilder class handles the details of buffering the copied contents of the original
   * tree and adding in our changes. Since NodeBuilder maintains parent/child references, it also
   * handles parent-splitting (easy enough, since any node affected by the split will already be
   * copied into a NodeBuilder).
   *
   * <p>One other difference from the simple algorithm is that we perform modifications in bulk; we
   * assume @param source has been sorted, e.g. by BTree.update, so the update of each key resumes
   * where the previous left off.
   */
  public <V> Object[] update(
      Object[] btree, Comparator<V> comparator, Iterable<V> source, UpdateFunction<V> updateF) {
    assert updateF != null;

    NodeBuilder current = rootBuilder;
    current.reset(btree, POSITIVE_INFINITY, updateF, comparator);

    for (V key : source) {
      while (true) {
        if (updateF.abortEarly()) {
          rootBuilder.clear();
          return null;
        }
        NodeBuilder next = current.update(key);
        if (next == null) break;
        // we were in a subtree from a previous key that didn't contain this new key;
        // retry against the correct subtree
        current = next;
      }
    }

    // finish copying any remaining keys from the original btree
    while (true) {
      NodeBuilder next = current.finish();
      if (next == null) break;
      current = next;
    }

    // updating with POSITIVE_INFINITY means that current should be back to the root
    assert current.isRoot();

    Object[] r = current.toNode();
    current.clear();
    return r;
  }
 public String create() {
   StringBuilder builder = new StringBuilder();
   builder.append("digraph{\r\nrankdir=BT\r\nnode [shape=record]\r\n");
   Set<ConnectionBuilder> connections = new HashSet<ConnectionBuilder>();
   for (NodeBuilder node : nodes) {
     node.create(builder);
     connections.addAll(node.getConnections());
   }
   for (ConnectionBuilder connection : connections) {
     connection.create(builder);
   }
   builder.append("}");
   return builder.toString();
 }
Esempio n. 7
0
  public <V> Object[] build(Iterable<V> source, UpdateFunction<V> updateF, int size) {
    assert updateF != null;

    NodeBuilder current = rootBuilder;
    // we descend only to avoid wasting memory; in update() we will often descend into existing
    // trees
    // so here we want to descend also, so we don't have lg max(N) depth in both directions
    while ((size >>= FAN_SHIFT) > 0) current = current.ensureChild();

    current.reset(EMPTY_LEAF, POSITIVE_INFINITY, updateF, null);
    for (V key : source) current.addNewKey(key);

    current = current.ascendToRoot();

    Object[] r = current.toNode();
    current.clear();
    return r;
  }
Esempio n. 8
0
  @Override
  protected void initChildren() {
    List<OrderItem> orderItems =
        FacadeContext.getOrderItemFacade().findBy(getOrder(), OrderItemType.first);
    for (OrderItem orderItem : orderItems) {
      AOrderNode node =
          nodeBuilder.build(
              OrderItemNode.class,
              MapUtils.putAll(
                  new HashMap<String, Object>(), new Object[] {"orderItem", orderItem}));
      add(node);
    }
    orderItems = FacadeContext.getOrderItemFacade().findBy(getOrder(), OrderItemType.common);
    for (OrderItem orderItem : orderItems) {
      if (orderItem.getSource() == null) {
        AOrderNode node =
            nodeBuilder.build(
                OrderItemNode.class,
                MapUtils.putAll(
                    new HashMap<String, Object>(), new Object[] {"orderItem", orderItem}));
        add(node);
      }
    }

    if (getOrder() instanceof Order) {
      add(
          nodeBuilder.build(
              TemplatesNode.class,
              MapUtils.putAll(
                  new HashMap<String, Object>(), new Object[] {"nodeBuilder", nodeBuilder})));
      add(nodeBuilder.build(AGTFacadeNode.class, MapUtils.EMPTY_MAP));
      add(nodeBuilder.build(ZFacadeNode.class, MapUtils.EMPTY_MAP));
    } else if (getOrder() instanceof TemplateOrder) {
      add(nodeBuilder.build(TemplateFacadeNode.class, MapUtils.EMPTY_MAP));
    }
  }
  /**
   * Writes this configuration to stream<br>
   * Note: Closes the stream when finished
   *
   * @param stream to write to
   */
  public void saveToStream(OutputStream stream) throws IOException {
    // Get rid of newline characters in text - Bukkit bug prevents proper saving
    for (String key : this.getSource().getKeys(true)) {
      Object value = this.getSource().get(key);
      if (value instanceof String) {
        String text = (String) value;
        if (text.contains("\n")) {
          this.getSource().set(key, Arrays.asList(text.split("\n", -1)));
        }
      }
    }

    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(stream));
    try {
      // Write the top header
      writeHeader(true, writer, this.getHeader(), 0);

      // Write other headers and the nodes
      IntHashMap<String> anchorData = new IntHashMap<String>();
      int indent;
      int anchStart, anchEnd, anchId = -1, anchDepth = 0, anchIndent = 0;
      boolean wasAnchor;
      int refStart, refEnd, refId;
      StringBuilder refData = new StringBuilder();
      NodeBuilder node = new NodeBuilder(this.getIndent());
      for (String line : this.getSource().saveToString().split("\n", -1)) {
        line = StringUtil.colorToAmp(line);
        indent = StringUtil.getSuccessiveCharCount(line, ' ');
        line = line.substring(indent);
        wasAnchor = false;
        // ===== Logic start =====
        // Get rid of the unneeded '-characters around certain common names
        if (line.equals("'*':")) {
          line = "*:";
        }

        // Handle a node
        if (node.handle(line, indent)) {
          // Store old anchor data
          if (anchId >= 0 && node.getDepth() <= anchDepth) {
            anchorData.put(anchId, refData.toString());
            refData.setLength(0);
            anchId = refId = -1;
          }

          // Saving a new node: Write the node header
          writeHeader(false, writer, this.getHeader(node.getPath()), indent);

          // Check if the value denotes a reference
          refStart = line.indexOf("*id", node.getName().length());
          refEnd = line.indexOf(' ', refStart);
          if (refEnd == -1) {
            refEnd = line.length();
          }
          if (refStart > 0 && refEnd > refStart) {
            // This is a reference pointer: get id
            refId = ParseUtil.parseInt(line.substring(refStart + 3, refEnd), -1);
            if (refId >= 0) {
              // Obtain the reference data
              String data = anchorData.get(refId);
              if (data != null) {
                // Replace the line with the new data
                line = StringUtil.trimEnd(line.substring(0, refStart)) + " " + data;
              }
            }
          }

          // Check if the value denotes a data anchor
          anchStart = line.indexOf("&id", node.getName().length());
          anchEnd = line.indexOf(' ', anchStart);
          if (anchEnd == -1) {
            anchEnd = line.length();
          }
          if (anchStart > 0 && anchEnd > anchStart) {
            // This is a reference node anchor: get id
            anchId = ParseUtil.parseInt(line.substring(anchStart + 3, anchEnd), -1);
            anchDepth = node.getDepth();
            anchIndent = indent;
            if (anchId >= 0) {
              // Fix whitespace after anchor identifier
              anchEnd += StringUtil.getSuccessiveCharCount(line.substring(anchEnd), ' ');

              // Store the data of this anchor
              refData.append(line.substring(anchEnd));

              // Remove the variable reference from saved data
              line = StringUtil.replace(line, anchStart, anchEnd, "");
            }
            wasAnchor = true;
          }
        }
        if (!wasAnchor && anchId >= 0) {
          // Not an anchor: append anchor data
          refData
              .append('\n')
              .append(StringUtil.getFilledString(" ", indent - anchIndent))
              .append(line);
        }
        // Write the data
        if (LogicUtil.containsChar('\n', line)) {
          for (String part : line.split("\n", -1)) {
            StreamUtil.writeIndent(writer, indent);
            writer.write(part);
            writer.newLine();
          }
        } else {
          StreamUtil.writeIndent(writer, indent);
          writer.write(line);
          writer.newLine();
        }
      }
    } finally {
      writer.close();
    }
  }