/** * Returns a list of the next possible masters. */ public DiscoveryNode[] nextPossibleMasters(ObjectContainer<DiscoveryNode> nodes, int numberOfPossibleMasters) { List<DiscoveryNode> sortedNodes = sortedMasterNodes(Arrays.asList(nodes.toArray(DiscoveryNode.class))); if (sortedNodes == null) { return new DiscoveryNode[0]; } List<DiscoveryNode> nextPossibleMasters = new ArrayList<>(numberOfPossibleMasters); int counter = 0; for (DiscoveryNode nextPossibleMaster : sortedNodes) { if (++counter >= numberOfPossibleMasters) { break; } nextPossibleMasters.add(nextPossibleMaster); } return nextPossibleMasters.toArray(new DiscoveryNode[nextPossibleMasters.size()]); }
public Iterator<Mapper> iterator() { return StreamSupport.stream(mappers.values().spliterator(), false).map((p) -> (Mapper)p.value).iterator(); }
if (other.size() >= size() && other instanceof ObjectLookupContainer<?>) { if (hasEmptyKey) { if (other.contains(null)) { hasEmptyKey = false; values[mask + 1] = null; for (int slot = 0, max = this.mask; slot <= max;) { KType existing; if (!((existing = keys[slot]) == null) && other.contains(existing)) {
/** * Creates a new list from the elements of another container in its * iteration order. */ public ObjectArrayList(ObjectContainer<? extends KType> container) { this(container.size()); addAll(container); }
public Iterator<T> valuesIterator() { final Iterator<ObjectCursor<T>> it = myMap.values().iterator(); return new Iterator<T>() { @Override public boolean hasNext() { return it.hasNext(); } @Override public T next() { return it.next().value; } @Override public void remove() { throw new UnsupportedOperationException(); } }; }
@Override public boolean contains(Object o) { return valuesContainer.contains((T) o); } };
/** * Creates a new deque from elements of another container, appending elements at * the end of the deque in the iteration order. */ public ObjectArrayDeque(ObjectContainer<? extends KType> container) { this(container.size()); addLast(container); }
public Iterator<T> valuesIterator() { final Iterator<ObjectCursor<T>> it = myMap.values().iterator(); return new Iterator<T>() { @Override public boolean hasNext() { return it.hasNext(); } @Override public T next() { return it.next().value; } @Override public void remove() { throw new UnsupportedOperationException(); } }; }
@Override public boolean contains(Object o) { return valuesContainer.contains((T) o); } };
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { if (!mappers.isEmpty()) { // sort the mappers so we get consistent serialization format Mapper[] sortedMappers = mappers.values().toArray(Mapper.class); Arrays.sort(sortedMappers, new Comparator<Mapper>() { @Override public int compare(Mapper o1, Mapper o2) { return o1.name().compareTo(o2.name()); } }); builder.startObject("fields"); for (Mapper mapper : sortedMappers) { mapper.toXContent(builder, params); } builder.endObject(); } return builder; } }
if (other.size() >= size() && other instanceof ObjectLookupContainer<?>) { if (hasEmptyKey) { if (other.contains(null)) { hasEmptyKey = false; values[mask + 1] = 0L; for (int slot = 0, max = this.mask; slot <= max;) { KType existing; if (!((existing = keys[slot]) == null) && other.contains(existing)) {
/** * New instance copying elements from another {@link ObjectContainer}. */ public ObjectHashSet(ObjectContainer<? extends KType> container) { this(container.size()); addAll(container); }
public Iterator<Mapper> iterator() { return StreamSupport.stream(mappers.values().spliterator(), false).map((p) -> (Mapper)p.value).iterator(); }
public Iterator<Mapper> iterator() { return Iterators.transform(mappers.values().iterator(), new Function<ObjectCursor<FieldMapper>, Mapper>() { @Override public Mapper apply(@Nullable ObjectCursor<FieldMapper> cursor) { return cursor.value; } }); }
@Override public void applyClusterState(ClusterChangedEvent event) { ingestNodes = event.state().getNodes().getIngestNodes().values().toArray(DiscoveryNode.class); } }
if (other.size() >= size() && other instanceof ObjectLookupContainer<?>) { if (hasEmptyKey) { if (other.contains(null)) { hasEmptyKey = false; values[mask + 1] = 0d; for (int slot = 0, max = this.mask; slot <= max;) { KType existing; if (!((existing = keys[slot]) == null) && other.contains(existing)) {
/** * New instance copying elements from another {@link ObjectContainer}. */ public ObjectIdentityHashSet(ObjectContainer<? extends KType> container) { this(container.size()); addAll(container); }
public Iterator<Mapper> iterator() { return StreamSupport.stream(mappers.values().spliterator(), false).map((p) -> (Mapper)p.value).iterator(); }
@Override public boolean mappingExists(String indexName, String type) { GetMappingsResponse mappings = client.admin().indices().prepareGetMappings(indexName).execute().actionGet(); if (mappings == null || mappings.getMappings().isEmpty()) { return false; } // The real index might have another name if indexName is an alias so we check the mapping of the first item. return mappings.getMappings().values().iterator().next().value.containsKey(type); }
@Override protected void masterOperation(GetIndexTemplatesRequest request, ClusterState state, ActionListener<GetIndexTemplatesResponse> listener) { List<IndexTemplateMetaData> results; // If we did not ask for a specific name, then we return all templates if (request.names().length == 0) { results = Arrays.asList(state.metaData().templates().values().toArray(IndexTemplateMetaData.class)); } else { results = new ArrayList<>(); } for (String name : request.names()) { if (Regex.isSimpleMatchPattern(name)) { for (ObjectObjectCursor<String, IndexTemplateMetaData> entry : state.metaData().templates()) { if (Regex.simpleMatch(name, entry.key)) { results.add(entry.value); } } } else if (state.metaData().templates().containsKey(name)) { results.add(state.metaData().templates().get(name)); } } listener.onResponse(new GetIndexTemplatesResponse(results)); } }