Creates a new selection of all vertices NOT currently selected.
@return itself
9500
function() {
        var newSel = [];
        var vertices = this.mesh.getVertices();
        var l = vertices.length;
        for (var i=0;i<l;i++) {
			var v = vertices[i];
            if (this.selection.indexOf(v) < 0 ) {
                newSel.push(v);
            }
        }
        this.selection = newSel;
        return this;
    }
1228644
@Override
    public final Scene draw()
    {
        final NFastArrayList<Layer> layers = getChildNodes();

        if (null != layers)
        {
            final int size = layers.size();

            for (int i = 0; i < size; i++)
            {
                final Layer layer = layers.get(i);

                if (null != layer)
                {
                    layer.draw();
                }
            }
        }
        return this;
    }
583322
public FieldList makeSelectedRowCurrent()
    {
        FieldList record = null;
        int iRow = m_jTableScreen.getSelectedRow();
        if (iRow != -1)
            record = m_thinTableModel.makeRowCurrent(iRow, false);
        if (record == null)
        {
            record = this.getFieldList();
            try   {
                record.getTable().addNew();
            } catch (DBException ex)    {
                ex.printStackTrace(); // Never.
            }
        }
        return record;
    }
928242
public int numVertices() {
	if(CACHING && (cachedNumVertices != -1)) {
	    return cachedNumVertices;
	}	
	int numVertices = vertices().size();       
	if(CACHING) {
	    cachedNumVertices = numVertices;
	}
	return numVertices;
    }
1336756
public Index<SecondaryTable<T>> getOrCreateIndex()
   {
      List<Node> nodeList = childNode.get("index");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new IndexImpl<SecondaryTable<T>>(this, "index", childNode, nodeList.get(0));
      }
      return createIndex();
   }
1224296
public List<String> getSelected() {

        List<String> result = new ArrayList<String>();
        result.add(m_singleResult);
        return result;
    }
146843
public IslandSelection createNonConflictingVersion() {
        List<Island> possibleIslands;
        do {
            possibleIslands = selection.getPossibleIslands();
            // check the possible islands of a certain size against each other.
            if (possibleIslands.size() == 1) {
                selection.addIsland(possibleIslands.get(0));
            } else if (possibleIslands.size() > 1) {
                Map<IslandCompetition, List<Island>> analysis = analyzeConflictsBetweenPossibleIslands(possibleIslands);
                resolveConflictsBySelectingPreferredIslands(selection, analysis);
            }
        }
        while (!possibleIslands.isEmpty());
        return selection;
    }
26414
public List<VertexT> topologicalSort() {
    Preconditions.checkState(!wasSorted);
    wasSorted = true;

    Queue<VertexT> queue = new ArrayDeque<>();

    for (Map.Entry<VertexT, Integer> entry : vertices.entrySet()) {
      if (entry.getValue() == 0) {
        queue.add(entry.getKey());
      }
    }

    List<VertexT> result = Lists.newArrayList();
    while (!queue.isEmpty()) {
      VertexT vertex = queue.remove();
      result.add(vertex);
      for (VertexT successor : adjacencyList.get(vertex)) {
        if (decrementAndGetCount(successor) == 0) {
          queue.add(successor);
        }
      }
    }

    if (result.size() != vertices.size()) {
      throw new IllegalArgumentException("failed to perform topological sort, graph has a cycle");
    }

    return result;
  }
614553
def SetSelected( self, node, point=None, propagate=True ):
        """"""
        if node == self.selectedNode:
            return
        self.selectedNode = node
        self.UpdateDrawing()
        if node:
            wx.PostEvent( self, SquareSelectionEvent( node=node, point=point, map=self ) )
1282950
public static SimpleGraph<String, DefaultEdge> getSimpleGraphFromUser() {
        Scanner sc = new Scanner(System.in);
        SimpleGraph<String, DefaultEdge> graph = new SimpleGraph<String, DefaultEdge>(DefaultEdge.class);

        // input number of vertices
        int verticeAmount;
        do {
            System.out.print("Enter the number of vertices (more than one): ");
            verticeAmount = sc.nextInt();
        } while (verticeAmount <= 1);

        // input vertices
        for (int i = 1; i <= verticeAmount; i++) {
            System.out.print("Enter vertex name " + i + ": ");
            String input = sc.next();
            if (graph.vertexSet().contains(input)) {
                System.err.println("vertex with that name already exists");
                i--;
            } else {
                graph.addVertex(input);
            }
        }

        // input edges
        System.out.println("\nEnter edge (name => name)");
        String userWantsToContinue;
        do {
            String e1, e2;
            
            do {
                System.out.print("Edge from: ");
                e1 = sc.next();
            } while (!graph.vertexSet().contains(e1));
            do {
                System.out.print("Edge to: ");
                e2 = sc.next();
            } while (!graph.vertexSet().contains(e2));

            graph.addEdge(e1, e2);

            // add another edge?
            System.out.print("Add more edges? (y/n): ");
            userWantsToContinue = sc.next();
        }while (userWantsToContinue.equals("y") || userWantsToContinue.equals("yes") || userWantsToContinue.equals("1"));

        return graph;
    }
94690
def vertices
      vertices = Array.new(4)
      vertices[0] = base_point
      vertices[1] = base_point+u_vector
      vertices[2] = base_point+u_vector+v_vector
      vertices[3] = base_point+v_vector
      return vertices
    end
423804
public Versioned<E> previous() {
        if(hasPrevious()) {
            E resultValue = _previousNode.getValue().getValue();
            _lastId = _previousNode.getValue().getId();
            _lastCall = LastCall.PREVIOUS;
            _nextNode = _previousNode;
            _isNextSet = true;
            _isPreviousSet = false;
            return new Versioned<E>(resultValue, _previousNode.getVersion());
        } else {
            throw new NoSuchElementException();
        }
    }
1091662
protected BindingFactory createWebBindings() {
		final BindingFactory factory = new BindingFactory(getClass().getName());
		for (final AbstractSubCodeBuilderFragment subFragment : this.subFragments) {
			subFragment.generateWebBindings(factory);
		}
		return factory;
	}
236356
function () {
      if (!selection.isSelected()) {
        return;
      }
      var corners = grid.getCornerCoords([priv.selStart, selection.end()]);
      var r, c, changes = [];
      for (r = corners.TL.row; r <= corners.BR.row; r++) {
        for (c = corners.TL.col; c <= corners.BR.col; c++) {
          if (self.getCellMeta(r, c).isWritable) {
            changes.push([r, datamap.colToProp(c), '']);
          }
        }
      }
      self.setDataAtCell(changes);
    }
748295
public FluentSelect deselectAll() {
        executeAndWrapReThrowIfNeeded(new DeselectAll(), Context.singular(context, "deselectAll"), true);
        return new FluentSelect(super.delegate, currentElement.getFound(), this.context, monitor, booleanInsteadOfNotFoundException);
    }
850551
private StateUpdater createSelection(Viewer viewer, Cursor cursor, SelectorModel model, StateUpdater reset)
    {
        return (extrp, current) ->
        {
            computeSelection(viewer, cursor, model);

            if (model.getSelectionClick() != cursor.getClick())
            {
                collidable.setEnabled(true);
                final Rectangle sel = model.getSelectionArea();
                final Area done = Geom.createArea(sel.getX(), sel.getY(), sel.getWidthReal(), sel.getHeightReal());
                for (final SelectorListener listener : listeners)
                {
                    listener.notifySelectionDone(done);
                }
                sel.set(-1, -1, 0, 0);
                model.setSelecting(false);

                return reset;
            }
            return current;
        };
    }
580541
GeometryIndex[] getSelection() {
		List<GeometryIndex> indices = delegate.getSelection();
		return indices.toArray(new GeometryIndex[indices.size()]);
	}