예제 #1
0
    public void iterateThruContext(String ctxPath, TreeNodeHandler2 handler) {
      String[] path = ctxPath.split("/");
      final String filePath = "/" + path[1];
      int startWith = filePath.startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;
      if (startWith == 1) {
        return;
      }

      TreeNode cycled = null;
      int cnt = 0;
      boolean ret = true;
      for (int i = 2; i < path.length && ret; i++) {
        String encodedName = "/" + path[i];
        if (i == 2) {
          cycled = findChildByEncodedName(encodedName, filePath);
        } else {
          cycled = cycled.findChildByEncodedName(encodedName);
        }

        if (cycled != null) {
          ret = handler.handleNode(cnt++, cycled);
        } else {
          // todo - ctx path looks not valid, handle it?
          return;
        }
      }
    }
예제 #2
0
  public boolean setContextPathAttr(String startCtxPath, String attrName, String value) {
    String[] path = startCtxPath.split("/");
    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;

    TreeNode cycled = root;
    for (int i = startWith; i < path.length; i++) {
      String encodedName = "/" + path[i];
      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        return false;
      }
    }

    TreeNodeImpl nodeImpl = (TreeNodeImpl) cycled;
    int i = 0;
    for (; i < nodeImpl.extAttr.length; i++) {
      String _attrName = decodeAttrName(nodeImpl.extAttr[i]);
      if (_attrName.equals(attrName)) {
        // replace existing attribute with new one
        nodeImpl.extAttr[i] = encodeAttrValue(attrName, value);
        return true;
      }
    }
    nodeImpl.extAttr = increaseArrayByOne(nodeImpl.extAttr);
    // replace existing attribute with new one
    nodeImpl.extAttr[i] = encodeAttrValue(attrName, value);
    return true;
  }
예제 #3
0
  private void addCtxValue(TreeNode cycled, String[] pathParts, String value) {
    boolean pathCreated = false;
    for (int i = 2 + 1; i < pathParts.length; i++) {
      String encodedName = "/" + pathParts[i];
      TreeNode child = cycled.findChildByEncodedName(encodedName);
      if (child == null) {
        int type = ContextPathUtil.prefix2type(encodedName.substring(0, 4));
        cycled = cycled.addNode(type, encodedName);
        pathCreated = true;
      } else {
        cycled = child;
      }
    }

    if (pathCreated) {
      entryCounter++;
    }
    if (value != null) {
      cycled.addValue(value);
      modCount++;
    } else {
      // check whether the path was really created
      modCount = (pathCreated) ? modCount + 1 : modCount;
    }
  }
예제 #4
0
  @NotNull
  public ContextItem[] findCtxItems(String startCtxPath, String name) {
    String[] path = startCtxPath.split("/");
    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;

    TreeNode cycled = root;
    for (int i = startWith; i < path.length; i++) {
      String encodedName = "/" + path[i];
      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        return new ContextItem[0];
      }
    }

    List<ContextItem> out = new ArrayList<ContextItem>();
    TreeNode[] children =
        name == null
            ? cycled.getChildren().toArray(new TreeNode[0])
            : cycled.findChildrenBySuffix(name);
    for (TreeNode n : children) {
      // todo -- revise to replace using value directly with a TreeNode instance
      out.add(new ContextItemImpl(n.getPath(), n.getValue()));
    }

    return out.toArray(new ContextItem[out.size()]);
  }
예제 #5
0
  public TreeNode[] findNodeInRelContext(String startCtxPath, String name) {
    String[] path = startCtxPath.split("/");

    TreeNode cycled = root;
    for (int i = 1; i < path.length; i++) {
      String encodedName = "/" + path[i];
      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        return new TreeNode[0];
      }
    }

    return cycled.findChildrenBySuffix(name);
  }
예제 #6
0
  private boolean updateCtxValue(TreeNode cycled, String[] pathParts, String value) {
    for (int i = 2 + 1; i < pathParts.length; i++) {
      String encodedName = "/" + pathParts[i];
      TreeNode child = cycled.findChildByEncodedName(encodedName);
      if (child == null) {
        return false;
      } else {
        cycled = child;
      }
    }

    cycled.addValue(value);
    return true;
  }
예제 #7
0
  public String getContextPathValue(String ctxPath) {
    // todo -- replace split("/") with Pattern.split("/")
    String[] path = ctxPath.split("/");

    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;
    if (startWith == path.length) {
      FileEntitiesHolder hld = files.get(path[1].substring(6));
      if (hld != null) {
        return hld.value; // Long.toString(hld.timeStamp); //
      }

      return null;
    }

    // expected: startWith == 2
    String filePath = path[1].substring(6);

    // find top nodes the specified name
    // "/" + path[2]
    String encodedName = "/" + path[2];
    String name = path[2].substring(6);
    List<TreeNode> addTo = new ArrayList<TreeNode>();
    root.findChildrenBySuffix(name, addTo);

    for (TreeNode node : addTo) {
      // find among top nodes the one which belongs to the correct file
      final TreeNodeTop top = (TreeNodeTop) node;
      if (encodedName.equals(top.encodedName) && filePath.equals(top.owner.filePath)) {
        // the found top node is considered as a root of target hierarhy
        TreeNode cycled = node;
        for (int i = startWith + 1; i < path.length; i++) {
          encodedName = "/" + path[i];
          cycled = cycled.findChildByEncodedName(encodedName);
          if (cycled == null) {
            return null;
          }
        }

        return cycled.getValue();
      } else {
        // todo -- investige the case
        int hh = 0;
      }
    }

    return null;
  }
예제 #8
0
  public boolean remove(String ctxPath) {
    String[] path = ctxPath.split("/");

    boolean result = false;
    // validate root context
    if (!("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX)) {
      throw new ValidationException("Broken Context Path occurred: FILE CTX Path must be first!");
    } else {
      switch (path.length) {
        case 0:
        case 1:
          throw new ValidationException("Broken Context Path occurred");
        case 2: // remove the file and all its children
          String fileName = path[1].substring(6);
          FileEntitiesHolder fileHolder = files.remove(fileName);
          if (fileHolder != null) {
            fileHolder.removeChildren();
            result = true;
          }
          break;
        default:
          TreeNode parent = root;
          TreeNode target = null;
          int i = 2;
          while (true) {
            target = parent.findChildByEncodedName("/" + path[i]);
            if (++i < path.length && target != null) {
              parent = target;
              target = null;
            } else {
              break;
            }
          }

          if (target != null) {
            result = parent.removeNodeByEncodedName(target.getName());
          } else {
            // todo -- handle internal error
          }
          break;
      }
    }

    // NOTE: do not simplify! modCOunter should be incremented!
    return result ? ++modCount > 0 : false;
  }
예제 #9
0
 public void findNodesInContextCommon(
     String startCtxPath, String name, @NotNull TreeNode.TreeNodeHandler handler) {
   if (startCtxPath != null) {
     String[] path = startCtxPath.split("/");
     int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;
     TreeNode cycled = root;
     for (int i = startWith; i < path.length; i++) {
       String encodedName = "/" + path[i];
       cycled = cycled.findChildByEncodedName(encodedName);
       if (cycled == null) {
         return; // new TreeNode[0];
       }
     }
     cycled.iterateOverChildrenWithSuffix(name, handler);
   } else {
     root.iterateOverChildrenWithSuffix(name, handler);
   }
 }
예제 #10
0
  public void iterateOverChildren(String ctxPath, IndexEntriesWalkerInterruptable iterator) {
    String[] path = ctxPath.split("/");
    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;

    TreeNode cycled = root;
    for (int i = startWith; i < path.length; i++) {
      String encodedName = "/" + path[i];
      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        return;
      }
    }

    for (List<TreeNodeImpl> siblings : ((TreeNodeImpl) cycled).childs.values()) {
      for (TreeNodeImpl n : siblings) {
        if (!iterator.process(n.getPath(), n.value)) {
          return;
        }
      }
    }
  }
예제 #11
0
  public String _getContextPathValue(String ctxPath) {
    String[] path = ctxPath.split("/");

    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;
    if (startWith == path.length) {
      FileEntitiesHolder hld = files.get(path[1].substring(6));
      if (hld != null) {
        return hld.value; // Long.toString(hld.timeStamp); //
      }

      return null;
    }

    TreeNode cycled = root;
    //        List<TreeNode> addTo = new ArrayList<TreeNode>();
    for (int i = startWith; i < path.length; i++) {
      String encodedName = "/" + path[i];
      /*
      todo - should be implemented along with fixing of the addContextPath
                  cycled.findChildByEncodedName(encodedName, addTo);
                  switch(addTo.size()){
                      case 0: return null;
                      case 1:
                          cycled = addTo.get(0);
                          break;
                      default:
                          cycled = addTo.get(0);
                          break;
                  }

                  addTo.clear();
      */
      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        return null;
      }
    }

    return cycled.getValue();
  }
예제 #12
0
  public String getContextPathAttr(String startCtxPath, String attrName) {
    String[] path = startCtxPath.split("/");
    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;

    TreeNode cycled = root;
    for (int i = startWith; i < path.length; i++) {
      String encodedName = "/" + path[i];
      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        return null;
      }
    }

    TreeNodeImpl nodeImpl = (TreeNodeImpl) cycled;
    int i = 0;
    for (; i < nodeImpl.extAttr.length; i++) {
      String _attrName = decodeAttrName(nodeImpl.extAttr[i]);
      if (_attrName.equals(attrName)) {
        // replace existing attribute with new one
        return decodeAttrValue(nodeImpl.extAttr[i]);
      }
    }
    return null;
  }
예제 #13
0
  public void searchContextTree_DownUp(
      String startCtxPath, String name, int refType, TreeNodeHandler handler) {
    String[] path = startCtxPath.split("/");

    int _1st_ctxType = -1;
    int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1;
    List<TreeNode> out = new ArrayList<TreeNode>();

    TreeNode cycled = root;
    for (int i = startWith; i < path.length; i++) {
      String encodedName = "/" + path[i];
      int ctxType = ContextPathUtil.prefix2type(encodedName.substring(0, 4));
      if (i == startWith) {
        // save the type of the first context
        _1st_ctxType = ctxType;
      }

      cycled = cycled.findChildByEncodedName(encodedName);
      if (cycled == null) {
        // todo -- is it suggested?
        break;
      } else {
        if (i == path.length - 1) {
          // check type of the last context
          switch (refType) {
            case ContextPath.NESTED_CALL:
              // search for the name in the context only
              for (TreeNode d : cycled.findChildrenBySuffix(name)) {
                handler.handleNode(d);
              }
              return;
            default:
              switch (ctxType) {
                case ContextPath.COLUMN_DEF:
                case ContextPath.RECORD_ITEM:
                case ContextPath.VARIABLE_DECL:
                case ContextPath.ARGUMENT:
                case ContextPath.REF_CURSOR:
                  // skip search in the context
                  // todo -- more types expected
                  continue;
                default:
                  break;
              }
          }
        } else {
          // intermediate context, add to list
        }

        out.add(cycled);
      }
    }

    for (int i = out.size() - 1; i >= 0; i--) {
      TreeNode n = out.get(i);
      for (TreeNode foundNode : n.findChildrenBySuffix(name)) {
        if (handler.handleNode(foundNode)) {
          // iteration terminated by listener
          return;
        }
      }

      //            switch(n.getType()){
      //                case ContextPath.CURSOR_DECL:
      //                    // Cursor decl: closed scope
      //                    return;
      //            }
    }

    if (_1st_ctxType == ContextPath.PACKAGE_BODY) {
      // search package spec for name
      String spec =
          ContextPath.PACKAGE_SPEC_PRX + path[startWith].substring(3, path[startWith].length());
      for (TreeNode pks : findNodeInRelContext(spec, name)) { // findInContext2(spec, name)) {
        if (handler.handleNode(pks)) {
          // iteration terminated by listener
          return;
        }
      }
    }

    switch (refType) {
      case ContextPath.FUNC_CALL:
      case ContextPath.PROC_CALL:
      case ContextPath.TABLE_REF:
      case ContextPath.TYPE_REF:
      case ContextPath.GENERIC_NAME_REF: // package name (coming from sql code)
      case ContextPath.PLSQL_NAME_REF: // package name (coming from pl/sql code)
        // todo -- do we need to limit target ref types?
        // search in the root context
        for (TreeNode d : findNodeInRootContext(name)) {
          if (handler.handleNode(d)) {
            // iteration terminated by listener
            return;
          }
        }
        break;
    }
  }
예제 #14
0
  //  /FL!..$ota_flow_manager_pkg.pks/PS!..$ota_flow_manager_pkg/Va!..$pc_bs_15m_dflt [Value]
  // 1|INTEGER
  public void _addContextPath(String ctxPath, String value) {
    String[] path = ctxPath.split("/");

    // validate root context
    if (!("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) || ctxPath.indexOf(' ') != -1) {
      throw new ValidationException("Broken Context Path occurred: FILE CTX Path must be first!");
    } else {
      switch (path.length) {
        case 0:
        case 1:
          throw new ValidationException("Broken Context Path occurred");
        case 2: // load file attributes
          String fileName = path[1].substring(6);
          FileEntitiesHolder fileHolder = files.get(fileName);
          if (fileHolder == null) {
            fileHolder = new FileEntitiesHolder(fileName);
            files.put(fileName, fileHolder);
          }
          value = (value == null || value.length() == 0) ? "" : value;
          fileHolder.value = value;
          return;
        default:
          break;
      }
    }

    TreeNode cycled = root;
    boolean pathCreated = false;
    for (int i = 2; i < path.length; i++) {
      String encodedName = "/" + path[i];
      int type = ContextPathUtil.prefix2type(encodedName.substring(0, 4));
      TreeNode child = cycled.findChildByEncodedName(encodedName);
      if (child == null) {
        if (i == 2) {
          // add node level 1 -
          cycled = addTopNode(root, type, encodedName, path[1].substring(6));
        } else {
          cycled = cycled.addNode(type, encodedName);
        }
        pathCreated = true;
      } else {
        cycled = child;
      }
    }

    /*      todo -- entryCounter not correct any longer, FIXME
            if (cycled.getValue() == null) {
                entryCounter++;
            }
            cycled.addValue(value == null ? "" : value);
    */
    if (pathCreated) {
      entryCounter++;
    }
    if (value != null) {
      cycled.addValue(value);
      modCount++;
    } else {
      // check whether the path was really created
      modCount = (pathCreated) ? modCount + 1 : modCount;
    }

    // log adding entry
    println("[Path] " + ctxPath + " [Value] " + value);
  }