Examples with DEdgeList org.openntf.domino.graph2.DEdgeList used on opensource projects

Example 1 with DEdgeList

use of org.openntf.domino.graph2.DEdgeList in project org.openntf.domino by OpenNTF.

the class FramedEdgeList method applyFilter.

public FramedEdgeList<T> applyFilter(final String key, final Object value) {
    if ("lookup".equals(key) && list_ instanceof DEdgeEntryList && value instanceof List) {
        // System.out.println("TEMP DEBUG dealing with DEdgeEntryList");
        ((DEdgeEntryList) list_).initEntryList((List<CharSequence>) value);
        return this;
    }
    if ("filter".equals(key) && list_ instanceof DEdgeEntryList && value instanceof List) {
        ((DEdgeEntryList) list_).filterEntryList((List<CharSequence>) value);
        return this;
    }
    DEdgeList edgeList = new DEdgeList((DVertex) sourceVertex_);
    if (this.size() > 0) {
        for (EdgeFrame edge : this) {
            try {
                if ("@type".equals(key)) {
                    if (isType(edge, TypeUtils.toString(value))) {
                        edgeList.add(edge.asEdge());
                    }
                } else {
                    Object edgeVal = null;
                    Method crystal = getGetters(edge).get(new CaseInsensitiveString(key));
                    if (crystal != null) {
                        try {
                            edgeVal = crystal.invoke(edge, (Object[]) null);
                        } catch (Exception e) {
                            edgeVal = edge.asEdge().getProperty(key);
                        }
                    } else {
                        System.err.println("No method found for key " + key);
                    }
                    if (value.equals(TypeUtils.toString(edgeVal))) {
                        edgeList.add(edge.asEdge());
                    }
                }
            } catch (Throwable t) {
                t.printStackTrace();
            }
        }
    }
    FramedEdgeList<T> result = new FramedEdgeList<T>(framedGraph, sourceVertex_, edgeList, this.kind);
    return result;
}

Example 2 with DEdgeList

use of org.openntf.domino.graph2.DEdgeList in project org.openntf.domino by OpenNTF.

the class JsonSearchAdapter method getJsonProperty.

@SuppressWarnings("unlikely-arg-type")
@Override
public Object getJsonProperty(final String paramKey) {
    Object result = null;
    Object frame = getFrame();
    if (frame != null) {
        CaseInsensitiveString key = new CaseInsensitiveString(paramKey);
        if (key.equals("@id")) {
            if (frame instanceof VertexFrame) {
                result = ((VertexFrame) frame).asVertex().getId().toString();
            } else if (frame instanceof EdgeFrame) {
                result = ((EdgeFrame) frame).asEdge().getId().toString();
            }
        } else if (key.equals("@proxyid")) {
            if (frame instanceof VertexFrame) {
                Vertex v = ((VertexFrame) frame).asVertex();
                if (v instanceof DProxyVertex) {
                    result = ((DProxyVertex) v).getProperty(DProxyVertex.PROXY_ITEM, String.class);
                }
            }
        } else if (key.equals("@debug")) {
            Map<String, String> debugMap = new LinkedHashMap<String, String>();
            debugMap.put("frameIdentity", String.valueOf(System.identityHashCode(this)));
            if (frame instanceof VertexFrame) {
                Vertex v = ((VertexFrame) frame).asVertex();
                debugMap.put("vertexIdentity", String.valueOf(System.identityHashCode(v)));
            } else if (frame instanceof EdgeFrame) {
                Edge e = ((EdgeFrame) frame).asEdge();
                debugMap.put("edgeIdentity", String.valueOf(System.identityHashCode(e)));
            }
            result = debugMap;
        } else if (key.equals("@type")) {
            if (frame instanceof VertexFrame) {
                result = type_;
            } else if (frame instanceof EdgeFrame) {
                result = type_;
            }
        } else if (key.equals("@in") && frame instanceof EdgeFrame) {
            if (getInProperties() == null) {
                // why not just make a frame adapter with the vertex?
                // because that's another I/O operation. We already have the
                // information needed to
                DEdge dedge = (DEdge) ((EdgeFrame) frame).asEdge();
                Map<String, String> minProps = new LinkedHashMap<String, String>();
                minProps.put("@id", dedge.getVertexId(Direction.IN).toString());
                Class<?> inType = graph_.getTypeRegistry().getInType(type_);
                if (inType == null) {
                    minProps.put("@type", "Vertex");
                } else {
                    minProps.put("@type", inType.getName());
                }
                result = minProps;
            } else {
                ParamMap inMap = new ParamMap();
                inMap.put(Parameters.PROPS, CaseInsensitiveString.toStrings(getInProperties()));
                if (getIncludeEdges()) {
                    inMap.put(Parameters.EDGES, EMPTY_STRINGS);
                }
                if (getIncludeCounts()) {
                    inMap.put(Parameters.COUNTS, EMPTY_STRINGS);
                }
                Method inMethod = graph_.getTypeRegistry().getIn(type_);
                if (inMethod != null) {
                    try {
                        Object raw = inMethod.invoke(frame, (Object[]) null);
                        if (raw instanceof Term) {
                            result = new JsonSearchAdapter(graph_, (Term) raw, inMap, isCollectionRoute_);
                        } else if (raw instanceof Value) {
                            result = new JsonSearchAdapter(graph_, (Value) raw, inMap, isCollectionRoute_);
                        } else if (raw instanceof RichTextReference) {
                            result = new JsonSearchAdapter(graph_, (RichTextReference) raw, inMap, isCollectionRoute_);
                        } else if (raw instanceof VertexFrame) {
                            result = new JsonFrameAdapter(graph_, (VertexFrame) raw, inMap, isCollectionRoute_);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        } else if (key.equals("@out") && frame instanceof EdgeFrame) {
            if (getOutProperties() == null) {
                // why not just make a frame adapter with the vertex?
                // because that's another I/O operation. We already have the
                // information needed to
                DEdge dedge = (DEdge) ((EdgeFrame) frame).asEdge();
                Map<String, String> minProps = new LinkedHashMap<String, String>();
                minProps.put("@id", dedge.getVertexId(Direction.OUT).toString());
                Class<?> outType = graph_.getTypeRegistry().getOutType(type_);
                if (outType == null) {
                    minProps.put("@type", "Vertex");
                } else {
                    minProps.put("@type", outType.getName());
                }
                result = minProps;
            } else {
                ParamMap outMap = new ParamMap();
                outMap.put(Parameters.PROPS, CaseInsensitiveString.toStrings(getOutProperties()));
                if (getIncludeEdges()) {
                    outMap.put(Parameters.EDGES, EMPTY_STRINGS);
                }
                if (getIncludeCounts()) {
                    outMap.put(Parameters.COUNTS, EMPTY_STRINGS);
                }
                Method outMethod = graph_.getTypeRegistry().getOut(type_);
                if (outMethod != null) {
                    try {
                        Object raw = outMethod.invoke(frame, (Object[]) null);
                        if (raw instanceof Term) {
                            result = new JsonSearchAdapter(graph_, (Term) raw, outMap, isCollectionRoute_);
                        } else if (raw instanceof Value) {
                            result = new JsonSearchAdapter(graph_, (Value) raw, outMap, isCollectionRoute_);
                        } else if (raw instanceof RichTextReference) {
                            result = new JsonSearchAdapter(graph_, (RichTextReference) raw, outMap, isCollectionRoute_);
                        } else if (raw instanceof VertexFrame) {
                            result = new JsonFrameAdapter(graph_, (VertexFrame) raw, outMap, isCollectionRoute_);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        } else if (key.equals("@edges")) {
            Map<String, Integer> edgeCounts = new LinkedHashMap<String, Integer>();
            Set<CaseInsensitiveString> counterKeys = getCounters().keySet();
            for (CaseInsensitiveString label : counterKeys) {
                Method crystal = getCounters().get(label);
                if (crystal != null) {
                    try {
                        Object raw = crystal.invoke(getFrame(), (Object[]) null);
                        if (raw instanceof Integer) {
                            edgeCounts.put(label.toString(), (Integer) raw);
                        } else {
                        }
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                } else {
                }
            }
            result = edgeCounts;
        } else if (key.equals("@actions")) {
            List<CaseInsensitiveString> actionList = new ArrayList<CaseInsensitiveString>();
            Set<CaseInsensitiveString> actionNames = getActions().keySet();
            for (CaseInsensitiveString name : actionNames) {
                actionList.add(name);
            }
            result = actionList;
        } else if (key.startsWith("@counts")) {
            String label = key.toString().substring("@counts".length());
            Method crystal = getCounters().get(new CaseInsensitiveString(label));
            if (crystal != null) {
                try {
                    Object raw = crystal.invoke(getFrame(), (Object[]) null);
                    if (raw instanceof Integer) {
                        result = raw;
                    } else {
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            } else {
            }
        } else if (key.equals("@columninfo")) {
            if (frame instanceof ViewVertex) {
                Map<String, String> columnInfo = new LinkedHashMap<String, String>();
                if (frame instanceof ViewVertex) {
                    View view = ((ViewVertex) frame).asView();
                    for (ViewColumn column : view.getColumns()) {
                        String progName = column.getItemName();
                        String title = column.getTitle();
                        columnInfo.put(progName, title);
                    }
                } else {
                    System.err.println("Frame is not a ViewVertex. It is " + DGraphUtils.findInterface(frame));
                }
                return columnInfo;
            }
        } else if (key.equals("@viewinfo")) {
            if (frame instanceof DbInfoVertex) {
                List viewInfo = ((DbInfoVertex) frame).getViewInfo();
                return viewInfo;
            }
        } else if (key.startsWith("#") && frame instanceof VertexFrame) {
            CharSequence label = key.subSequence(1, key.length());
            Method crystal = getIncidences().get(label);
            if (crystal != null) {
                try {
                    result = crystal.invoke(frame, (Object[]) null);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                if (result != null) {
                    if (!(result instanceof Iterable)) {
                        if (result instanceof EdgeFrame) {
                            Vertex v = ((VertexFrame) frame).asVertex();
                            List<Edge> edges = new org.openntf.domino.graph2.impl.DEdgeList((DVertex) v);
                            edges.add(((EdgeFrame) result).asEdge());
                            result = new FramedEdgeList(getGraph(), ((VertexFrame) frame).asVertex(), edges, crystal.getReturnType());
                        }
                    }
                    if (getIncludeVertices()) {
                        if (result instanceof DEdgeList) {
                            result = ((DEdgeList) result).toVertexList();
                        } else if (result instanceof FramedEdgeList) {
                            result = ((FramedEdgeList<?>) result).toVertexList();
                        } else {
                            System.err.println("TEMP DEBUG: Expected a DEdgeList but got a " + result.getClass().getName());
                        }
                    }
                    if (getFilterKeys() != null && !isCollectionRoute_) {
                        List<CharSequence> filterKeys = getFilterKeys();
                        List<CharSequence> filterValues = getFilterValues();
                        Map<CharSequence, Set<CharSequence>> filterMap = new HashMap<CharSequence, Set<CharSequence>>();
                        for (int i = 0; i < filterKeys.size(); i++) {
                            String curkey = filterKeys.get(i).toString();
                            String curvalue = filterValues.get(i).toString();
                            if (Value.REPLICA_KEY.equalsIgnoreCase(curkey)) {
                                Set<CharSequence> replicas = filterMap.get(Value.REPLICA_KEY);
                                if (replicas == null) {
                                    replicas = new HashSet<CharSequence>();
                                    filterMap.put(Value.REPLICA_KEY, replicas);
                                }
                                replicas.add(new CaseInsensitiveString(curvalue));
                            } else if (Value.FORM_KEY.equalsIgnoreCase(curkey)) {
                                Set<CharSequence> forms = filterMap.get(Value.FORM_KEY);
                                if (forms == null) {
                                    forms = new HashSet<CharSequence>();
                                    filterMap.put(Value.FORM_KEY, forms);
                                }
                                forms.add(new CaseInsensitiveString(curvalue));
                            } else if (Value.FIELD_KEY.equalsIgnoreCase(curkey)) {
                                Set<CharSequence> forms = filterMap.get(Value.FIELD_KEY);
                                if (forms == null) {
                                    forms = new HashSet<CharSequence>();
                                    filterMap.put(Value.FIELD_KEY, forms);
                                }
                                forms.add(new CaseInsensitiveString(curvalue));
                            }
                        }
                        if (result instanceof FramedVertexList) {
                            // this should always be the case
                            FramedVertexList fvl = (FramedVertexList) result;
                            List<Vertex> vertList = new ArrayList<Vertex>();
                            FramedVertexList filterList = new FramedVertexList<VertexFrame>(fvl.getGraph(), fvl.getSourceVertex(), vertList, null);
                            for (Object raw : fvl) {
                                if (raw instanceof Value) {
                                    Map hits = ((Value) raw).getHits(filterMap);
                                    if (hits.size() > 0) {
                                        filterList.add((Value) raw);
                                    }
                                } else if (raw instanceof RichTextReference) {
                                    if (((RichTextReference) raw).isFilterMatch(filterMap)) {
                                        filterList.add((RichTextReference) raw);
                                    }
                                }
                            }
                            result = filterList;
                        }
                    }
                    if (getStartsValues() != null) {
                        if (result instanceof DEdgeEntryList) {
                            ((DEdgeEntryList) result).initEntryList(getStartsValues());
                        } else if (result instanceof FramedEdgeList) {
                            ((FramedEdgeList) result).applyFilter("lookup", getStartsValues());
                        }
                    }
                    if (getFilterValues() != null && getFilterKeys() == null) {
                        if (result instanceof DEdgeEntryList) {
                            ((DEdgeEntryList) result).filterEntryList(getFilterValues());
                        } else if (result instanceof FramedEdgeList) {
                            ((FramedEdgeList) result).applyFilter("filter", getFilterValues());
                        }
                    }
                    if (getOrderBys() != null) {
                        if (result instanceof FramedEdgeList) {
                            result = ((FramedEdgeList<?>) result).sortBy(getOrderBys(), getDescending());
                        } else if (result instanceof FramedVertexList) {
                            result = ((FramedVertexList<?>) result).sortBy(getOrderBys(), getDescending());
                        }
                    }
                    if (getStart() >= 0) {
                        if (getCount() > 0) {
                            int end = getStart() + getCount();
                            if (result instanceof FramedEdgeList) {
                                // System.out.println("TEMP DEBUG Sublisting
                                // a FramedEdgeList...");
                                int size = ((FramedEdgeList<?>) result).size();
                                result = ((FramedEdgeList<?>) result).subList(getStart(), (end > size ? size : end));
                            } else if (result instanceof FramedVertexList) {
                                int size = ((FramedVertexList<?>) result).size();
                                result = ((FramedVertexList<?>) result).subList(getStart(), (end > size ? size : end));
                            } else if (result instanceof DEdgeEntryList) {
                                // System.out.println("TEMP DEBUG Sublisting
                                // a DEdgeEntryList...");
                                int size = ((DEdgeEntryList) result).size();
                                result = ((DEdgeEntryList) result).subList(getStart() + 1, (end > size ? size : end));
                            }
                        } else {
                            if (result instanceof FramedEdgeList) {
                                result = ((FramedEdgeList<?>) result).subList(getStart(), ((FramedEdgeList<?>) result).size());
                            } else if (result instanceof FramedVertexList) {
                                result = ((FramedVertexList<?>) result).subList(getStart(), ((FramedVertexList<?>) result).size());
                            } else if (result instanceof DEdgeEntryList) {
                                // System.out.println("TEMP DEBUG Sublisting
                                // a DEdgeEntryList...");
                                result = ((DEdgeEntryList) result).subList(getStart() + 1, ((DEdgeEntryList) result).size());
                            }
                        }
                    }
                    if (result instanceof FramedVertexList) {
                        ParamMap listMap = new ParamMap();
                        if (getIncludeEdges()) {
                            listMap.put(Parameters.EDGES, EMPTY_STRINGS);
                        }
                        if (getIncludeCounts()) {
                            listMap.put(Parameters.COUNTS, EMPTY_STRINGS);
                        }
                        listMap.put(Parameters.PROPS, CaseInsensitiveString.toStrings(this.getProperties()));
                        listMap.put(Parameters.HIDEPROPS, CaseInsensitiveString.toStrings(this.getHideProperties()));
                        result = new JsonFrameListAdapter(getGraph(), (FramedVertexList<?>) result, listMap, isCollectionRoute_);
                    }
                }
            } else {
            // NTF actually, this is a perfectly normal outcome.
            }
        } else {
            Method crystal = getGetters().get(key);
            if (crystal != null) {
                try {
                    result = crystal.invoke(frame, (Object[]) null);
                } catch (UserAccessException uae) {
                    throw uae;
                } catch (Throwable t) {
                    if (frame instanceof EdgeFrame) {
                        result = ((EdgeFrame) frame).asEdge().getProperty(paramKey);
                    } else if (frame instanceof VertexFrame) {
                        result = ((VertexFrame) frame).asVertex().getProperty(paramKey);
                    } else {
                        System.err.println("Trying to get property " + paramKey + " from an object " + frame.getClass().getName());
                    }
                }
            } else {
                if (frame instanceof ViewVertex.Contains) {
                    result = ((EdgeFrame) frame).asEdge().getProperty(paramKey);
                } else if (frame instanceof VertexFrame) {
                    result = ((VertexFrame) frame).asVertex().getProperty(paramKey);
                } else if (frame instanceof EdgeFrame) {
                    result = ((EdgeFrame) frame).asEdge().getProperty(paramKey);
                } else {
                    System.err.println("No method found for key " + paramKey);
                }
            }
        }
    } else {
        System.err.println("Unable to get property " + paramKey + " on a null object");
    }
    return result;
}

Example 3 with DEdgeList

use of org.openntf.domino.graph2.DEdgeList in project org.openntf.domino by OpenNTF.

the class DVertex method getOutEdgeCache.

protected DEdgeList getOutEdgeCache(final String label) {
    Map<String, DEdgeList> outCache = getOutEdgeCache();
    DEdgeList result = null;
    result = outCache.get(label);
    if (result == null) {
        NoteList list = getOutEdgesSet(label);
        int count = getOutEdgeCount(label);
        if (count != list.size()) {
            setProperty("_COUNT" + DVertex.OUT_PREFIX + label, list.size());
            applyChanges();
        }
        result = new DFastEdgeList(this, getParent(), list, label);
        outCache.put(label, result);
    }
    return result.atomic();
}

Example 4 with DEdgeList

use of org.openntf.domino.graph2.DEdgeList in project org.openntf.domino by OpenNTF.

the class DVertex method getInEdgeCache.

protected DEdgeList getInEdgeCache(final String label) {
    Map<String, DEdgeList> inCache = getInEdgeCache();
    DEdgeList result = null;
    result = inCache.get(label);
    if (result == null) {
        NoteList list = getInEdgesSet(label);
        int count = getInEdgeCount(label);
        if (count != list.size()) {
            setProperty("_COUNT" + DVertex.IN_PREFIX + label, list.size());
            applyChanges();
        }
        result = new DFastEdgeList(this, getParent(), list, label);
        inCache.put(label, result);
    // System.out.println("TEMP DEBUG Cache MISS for edge list " + label + " size " + result.size() + " for "
    // + result.getClass().getSimpleName() + ": " + System.identityHashCode(result) + " into inCache: "
    // + System.identityHashCode(inCache) + " from Vertex: " + System.identityHashCode(this));
    } else {
    // System.out.println("TEMP DEBUG Cache hit for edge list " + label + " size " + result.size() + " for "
    // + result.getClass().getSimpleName() + ": " + System.identityHashCode(result) + " from inCache: "
    // + System.identityHashCode(inCache) + " from Vertex: " + System.identityHashCode(this));
    }
    return result.atomic();
}

Example 5 with DEdgeList

use of org.openntf.domino.graph2.DEdgeList in project org.openntf.domino by OpenNTF.

the class DVertex method getOutEdgeObjects.

protected DEdgeList getOutEdgeObjects(final String... labels) {
    DEdgeList result = null;
    if (labels == null || labels.length == 0) {
        Set<String> labelSet = getOutEdgeLabels();
        for (String label : labelSet) {
            if (result == null) {
                result = getOutEdgeObjects(label);
            } else {
                result.addAll(getOutEdgeObjects(label));
            }
        }
    } else if (labels.length == 1) {
        String label = labels[0];
        // if (label == null) {
        // return getOutEdgeObjects().unmodifiable();
        // }
        result = getOutEdgeCache(label);
        if ((result == null || result.isEmpty()) && label.equalsIgnoreCase("contents")) {
            if (getDelegateType().equals(View.class)) {
                DEdgeList edges = new DEdgeEntryList(this, (org.openntf.domino.graph2.impl.DElementStore) getStore());
                edges.setLabel(label);
                result = edges.unmodifiable();
            } else if (this instanceof DCategoryVertex || String.valueOf(getId()).startsWith("VC")) {
                DEdgeList edges = new DEdgeEntryList(this, (org.openntf.domino.graph2.impl.DElementStore) getStore());
                edges.setLabel(label);
                result = edges.unmodifiable();
            } else {
            // System.out.println("TEMP DEBUG unable to get contents edgelist from a " + this.getClass().getName() + " with id "
            // + String.valueOf(this.getId()));
            }
        }
        if ((result == null || result.isEmpty()) && label.equalsIgnoreCase("doccontents")) {
            if (getDelegateType().equals(View.class)) {
                DEdgeList edges = new DEdgeEntryList(this, (org.openntf.domino.graph2.impl.DElementStore) getStore(), true);
                edges.setLabel(label);
                result = edges.unmodifiable();
            } else if (this instanceof DCategoryVertex || String.valueOf(getId()).startsWith("VC")) {
                DEdgeList edges = new DEdgeEntryList(this, (org.openntf.domino.graph2.impl.DElementStore) getStore(), true);
                edges.setLabel(label);
                result = edges.unmodifiable();
            } else {
            // System.out.println("TEMP DEBUG unable to get contents edgelist from a " + this.getClass().getName() + " with id "
            // + String.valueOf(this.getId()));
            }
        }
    } else {
        result = new org.openntf.domino.graph2.impl.DEdgeList(this);
        for (String label : labels) {
            result.addAll(getOutEdgeObjects(label));
        }
    }
    return result == null ? null : result.unmodifiable();
}