Example usage for com.google.common.collect Iterators singletonIterator

List of usage examples for com.google.common.collect Iterators singletonIterator

Introduction

In this page you can find the example usage for com.google.common.collect Iterators singletonIterator.

Prototype

public static <T> UnmodifiableIterator<T> singletonIterator(@Nullable final T value) 

Source Link

Document

Returns an iterator containing only value .

Usage

From source file:org.apache.phoenix.util.ScanUtil.java

public static Iterator<Filter> getFilterIterator(Scan scan) {
    Iterator<Filter> filterIterator;
    Filter topLevelFilter = scan.getFilter();
    if (topLevelFilter == null) {
        filterIterator = Iterators.emptyIterator();
    } else if (topLevelFilter instanceof FilterList) {
        filterIterator = ((FilterList) topLevelFilter).getFilters().iterator();
    } else {//from   w  ww. j a  v a2 s .  c  o m
        filterIterator = Iterators.singletonIterator(topLevelFilter);
    }
    return filterIterator;
}

From source file:ptolemy.vergil.basic.layout.kieler.KielerLayout.java

/**
 * Creates a graph for the KIELER API from a Ptolemy model. Will traverse
 * the low level GraphModel given by the composite and record all found
 * elements in the mapping fields of this object that keep a mapping between
 * Ptolemy/Diva objects and KIELER objects. New KIELER objects (KEdge,
 * KNode, KPort) are created for their respective Ptolemy counterparts and
 * initialized with the initial sizes and positions and are put in a
 * composite KNode (the graph KIELER will perform the layout on later). To
 * obtain the right mappings, multiple abstraction levels of Ptolemy are
 * considered here: Diva, as this was the intended original way to do
 * automatic layout (e.g. by GlobalAbstractLayout) and Ptolemy, since Diva
 * lacks certain concepts that are relevant for a proper layout, such
 * as exact port locations for considering port constraints in the
 * model, which are supported by KIELER.
 *
 * @param composite The GraphModel composite object to retrieve the model
 *            information from//from   w ww  .j a  v a2  s  .  co m
 * @param parentNode KIELER subgraph to receive all connected
 *            model elements
 */
private void _createGraph(Object composite, KNode parentNode) {
    _kieler2ptolemyDivaNodes = HashBiMap.create();
    _ptolemy2KielerPorts = LinkedListMultimap.create();
    _divaEdgeSource = Maps.newHashMap();
    _divaEdgeTarget = Maps.newHashMap();
    _divaLabel = Maps.newHashMap();
    _edgeList = Lists.newLinkedList();
    KShapeLayout parentLayout = parentNode.getData(KShapeLayout.class);

    // Determine whether to include unconnected nodes.
    boolean doBoxLayout = parentLayout.getProperty(Parameters.DECORATIONS);

    // On-the-fly find upper left corner for bounding box of parent node.
    float globalX = Float.MAX_VALUE, globalY = Float.MAX_VALUE;

    // Traverse the ptolemy graph.
    ExternalPortModel externalPortModel = null;
    if (_graphModel instanceof ActorGraphModel) {
        externalPortModel = ((ActorGraphModel) _graphModel).getExternalPortModel();
    }
    List<Link> unprocessedEdges = new LinkedList<Link>();
    List<NamedObj> unprocessedRelatives = new LinkedList<NamedObj>();

    // Process nodes.
    for (Iterator iterator = _graphModel.nodes(composite); iterator.hasNext();) {
        Object node = iterator.next();
        if (!(node instanceof Locatable)) {
            continue;
        }
        Iterator portIter = null;

        // Here we get the corresponding Ptolemy object.
        // This breaks with Ptolemy/Diva abstraction; for now we need
        // the ptolemy actor to get the ports and port positions
        // and to distinguish actors and relation vertices.
        NamedObj semanticNode = (NamedObj) _graphModel.getSemanticObject(node);

        if (doBoxLayout || PtolemyModelUtil._isConnected(semanticNode)) {
            // Temporary variable for the new KNode corresponding to one of
            // the following cases depending on what the semantic object is.
            KNode knode = null;

            // Handle actors, text, and directors.
            if (semanticNode instanceof Actor || semanticNode instanceof Attribute) {

                // Create a KIELER node for a ptolemy node.
                knode = _createKNode(node, semanticNode);

                // Handle the ports of this node.
                if (semanticNode instanceof Actor && semanticNode instanceof Entity) {
                    Actor actor = (Actor) semanticNode;
                    List<Port> inputs = actor.inputPortList();
                    List<Port> outputs = actor.outputPortList();

                    // create ports
                    _createKPorts(knode, inputs);
                    _createKPorts(knode, outputs);
                    portIter = _graphModel.nodes(node);
                } else if (semanticNode instanceof RelativeLocatable) {
                    unprocessedRelatives.add(semanticNode);
                }
            }

            // Handle relation vertices.
            else if (semanticNode instanceof Relation) {
                // Regard a relation vertex as a KIELER KNode.
                knode = _createKNodeForVertex((Vertex) node);
                portIter = Iterators.singletonIterator(node);
            }

            // Handle internal ports.
            else if (semanticNode instanceof ComponentPort) {
                knode = _createKNodeForPort(node, (ComponentPort) semanticNode);
                portIter = Iterators.singletonIterator(node);
            }

            // Handle modal model states.
            else if (semanticNode instanceof State) {
                knode = _createKNodeForState(node, (State) semanticNode);
                portIter = Iterators.singletonIterator(node);
            }

            // Now do some common bookkeeping for all kinds of nodes.
            if (knode != null) {
                // some nodes, such as FSM's ports may already 
                // be assigned to a node other than the parent node
                if (knode.getParent() == null) {
                    knode.setParent(parentNode);
                }
                // Get check bounds for global bounding box.
                KShapeLayout layout = knode.getData(KShapeLayout.class);
                if (layout.getXpos() < globalX) {
                    globalX = layout.getXpos();
                }
                if (layout.getYpos() < globalY) {
                    globalY = layout.getYpos();
                }

                // Store node for later applying layout back.
                _kieler2ptolemyDivaNodes.put(knode, (Locatable) node);
            }
        }

        if (portIter != null) {
            while (portIter.hasNext()) {
                Object divaPort = portIter.next();
                // Iterate all outgoing edges.
                Iterator edgeIterator;
                if (semanticNode instanceof Port && externalPortModel != null) { // internal ports
                    edgeIterator = externalPortModel.outEdges(divaPort);
                } else {
                    edgeIterator = _graphModel.outEdges(divaPort);
                }
                while (edgeIterator.hasNext()) {
                    Object next = edgeIterator.next();
                    if (next instanceof Link) {
                        unprocessedEdges.add((Link) next);
                    }
                }
            }
        }
    }

    // Create KIELER edges for Diva edges.
    if (_graphModel instanceof ActorGraphModel) {
        _storeEndpoints(unprocessedEdges);
    }
    for (Link divaEdge : unprocessedEdges) {
        _createKEdge(divaEdge);
    }

    // Create edges for associations of relative locatables to their reference objects.
    for (NamedObj relativeObj : unprocessedRelatives) {
        _createKEdgeForAttribute(relativeObj);
    }

    // Set graph offset.
    parentLayout.setXpos(globalX);
    parentLayout.setYpos(globalY);
}

From source file:org.pshdl.model.impl.AbstractHDLFunctionParameter.java

@Override
public Iterator<IHDLObject> iterator() {
    return new Iterator<IHDLObject>() {

        private int pos = 0;
        private Iterator<? extends IHDLObject> current;

        @Override//from ww  w  . j  a  va  2 s  .c  om
        public boolean hasNext() {
            if ((current != null) && !current.hasNext()) {
                current = null;
            }
            while (current == null) {
                switch (pos++) {
                case 0:
                    if ((funcSpec != null) && (funcSpec.size() != 0)) {
                        current = funcSpec.iterator();
                    }
                    break;
                case 1:
                    if (funcReturnSpec != null) {
                        current = Iterators.singletonIterator(funcReturnSpec);
                    }
                    break;
                case 2:
                    if (name != null) {
                        current = Iterators.singletonIterator(name);
                    }
                    break;
                case 3:
                    if (width != null) {
                        current = Iterators.singletonIterator(width);
                    }
                    break;
                case 4:
                    if ((dim != null) && (dim.size() != 0)) {
                        current = dim.iterator();
                    }
                    break;
                default:
                    return false;
                }
            }
            return (current != null) && current.hasNext();
        }

        @Override
        public IHDLObject next() {
            return current.next();
        }

        @Override
        public void remove() {
            throw new IllegalArgumentException("Not supported");
        }

    };
}

From source file:org.eclipse.elk.core.util.ElkUtil.java

/**
 * Determines the {@link KEdge KEdges} that are (transitively) connected to {@code kedge} across
 * hierarchy boundaries via common ports. Rational: Multiple {@link KEdge KEdges} that are
 * pairwise connected by means of a {@link KPort} (target port of edge a == source port of edge
 * b or vice versa) may form one logical connection. This kind splitting might be already
 * present in the view model, or is performed by the layout algorithm for decomposing a nested
 * layout input graph into flat sub graphs.
 *
 * @param kedge/*from  w w w. ja v  a 2 s.c  o  m*/
 *            the {@link KEdge} check for connected elements
 * @param sourceIterator
 *            the {@link SelectionIterator} to be used for iterating towards the tail of the
 *            selected edge
 * @param targetIterator
 *            the {@link SelectionIterator} to be used for iterating towards the head of the
 *            selected edge
 * @return an {@link Iterator} visiting the given {@code kedge} and all connected elements
 *         determined by the {@link SelectionIterator SelectionIterators}
 */
public static Iterator<KGraphElement> getConnectedElements(final KEdge kedge,
        final SelectionIterator sourceIterator, final SelectionIterator targetIterator) {

    // get a singleton iterator offering 'kedge'
    final Iterator<KGraphElement> kedgeIt = Iterators.singletonIterator((KGraphElement) kedge);
    // Keep a set of visited elements for the tree iterators
    final Set<KPort> visited = Sets.newHashSet();

    // Grab source iterator if edge has a source
    final SelectionIterator sourceSideIt = kedge.getSourcePort() == null ? null : sourceIterator;
    if (sourceSideIt != null) {
        // Configure the iterator
        sourceSideIt.attachVisitedSet(visited);
    }

    // Grab target iterator if edge has a target
    final SelectionIterator targetSideIt = kedge.getTargetPort() == null ? null : targetIterator;
    if (targetSideIt != null) {
        // Configure the iterator
        targetSideIt.attachVisitedSet(visited);
    }

    // concatenate the source-sidewise and target-sidewise iterators if present ...
    final Iterator<KGraphElement> connectedEdges = sourceSideIt == null ? targetSideIt
            : targetSideIt == null ? sourceSideIt : Iterators.concat(sourceSideIt, targetSideIt);

    // ... and attach them to the input 'kedge' offering iterator, or return just the
    // input 'kedge' iterator in case no ports are configured for 'kedge'
    return connectedEdges == null ? kedgeIt : Iterators.concat(kedgeIt, connectedEdges);
}

From source file:org.eclipse.viatra.query.patternlanguage.emf.validation.PatternLanguageValidator.java

private void checkForImpureJavaCallsInternal(XExpression xExpression) {
    Iterator<EObject> eAllContents = Iterators.concat(Iterators.singletonIterator(xExpression),
            xExpression.eAllContents());
    while (eAllContents.hasNext()) {
        EObject nextEObject = eAllContents.next();
        if (nextEObject instanceof XMemberFeatureCall) {
            XMemberFeatureCall xFeatureCall = (XMemberFeatureCall) nextEObject;
            JvmIdentifiableElement jvmIdentifiableElement = xFeatureCall.getFeature();
            if (jvmIdentifiableElement instanceof JvmOperation) {
                JvmOperation jvmOperation = (JvmOperation) jvmIdentifiableElement;
                if (!jvmOperation.eIsProxy() && !isPure(jvmOperation)) {
                    warning("Impure method call " + jvmOperation.getQualifiedName(), xFeatureCall,
                            XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE,
                            IssueCodes.CHECK_WITH_IMPURE_JAVA_CALLS);
                }/*from  ww w.ja  va2  s  .c  om*/
            }
        }
    }
}

From source file:org.eclipse.ocl.examples.pivot.internal.impl.OperationImpl.java

public Iterator<Operation> iterator() {
    return Iterators.singletonIterator((Operation) this);
}

From source file:org.eclipse.ocl.examples.pivot.internal.impl.PropertyImpl.java

public Iterator<Property> iterator() {
    return Iterators.singletonIterator((Property) this);
}