Sets the list of indexed lookups for this schema to the inputted list.
        
        :param      indexes     | [<orb.Index>, ..]
551173
def setIndexes(self, indexes):
        
        self.__indexes = {}
        for name, index in indexes.items():
            self.__indexes[name] = index
            index.setSchema(self)
683784
def y_indexes(self, indexes):
        
        self._assert_shape(self._data, self._x_indexes, indexes)
        self._y_indexes = indexes
        self.y_index = len(indexes) / 2
1318197
def set_index(self, index):
        
        for df in self.get_DataFrame(data=True, with_population=False):
            df.index = index
120779
def set_index(self, index):
        
        self.index = index
        self.reftrack = index.model().index(index.row(), 18, index.parent()).data(REFTRACK_OBJECT_ROLE)
        self.set_maintext(self.index)
        self.set_identifiertext(self.index)
        self.set_type_icon(self.index)
        self.disable_restricted()
        self.hide_restricted()
        self.set_top_bar_color(self.index)
        self.set_status_buttons()
        self.set_menu()
432057
def iteritems(self):
        
        for m in self.mappings:
            yield self.indexes[m.clause][m.target], m
669573
public static INDArrayIndex[] adjustIndices(int[] originalShape, INDArrayIndex... indexes) {
        if (Shape.isVector(originalShape) && indexes.length == 1)
            return indexes;

        if (indexes.length < originalShape.length)
            indexes = fillIn(originalShape, indexes);
        if (indexes.length > originalShape.length) {
            INDArrayIndex[] ret = new INDArrayIndex[originalShape.length];
            System.arraycopy(indexes, 0, ret, 0, originalShape.length);
            return ret;
        }

        if (indexes.length == originalShape.length)
            return indexes;
        for (int i = 0; i < indexes.length; i++) {
            if (indexes[i].end() >= originalShape[i] || indexes[i] instanceof NDArrayIndexAll)
                indexes[i] = NDArrayIndex.interval(0, originalShape[i] - 1);
        }

        return indexes;
    }
918409
public void setIndexNames(java.util.Collection<String> indexNames) {
        if (indexNames == null) {
            this.indexNames = null;
            return;
        }

        this.indexNames = new java.util.ArrayList<String>(indexNames);
    }
380630
public void setSchemas(java.util.Collection<String> schemas) {
        if (schemas == null) {
            this.schemas = null;
            return;
        }

        this.schemas = new java.util.ArrayList<String>(schemas);
    }
898431
public void setDBIDs(DBIDs ids) {
    this.idrep.setDBIDs(ids);
    // Update relations.
    for (Relation<?> orel : this.relations) {
      if (orel instanceof ProxyView) {
        ((ProxyView<?>) orel).setDBIDs(this.idrep.getDBIDs());
      }
    }
  }
1164130
def get_queryset(self, index_models=[]):
        
        if self.queryset is not None and isinstance(self.queryset, self.object_class):
            queryset = self.queryset.all()
        else:
            queryset = self.object_class()._clone()
            if len(index_models):
                queryset = queryset.models(*index_models)
            elif len(self.index_models):
                queryset = queryset.models(*self.index_models)
        return queryset
716540
public static void updateForNewAxes(INDArray arr, INDArrayIndex... indexes) {
        int numNewAxes = NDArrayIndex.numNewAxis(indexes);
        if (numNewAxes >= 1 && (indexes[0].length() > 1 || indexes[0] instanceof NDArrayIndexAll)) {
            List<Long> newShape = new ArrayList<>();
            List<Long> newStrides = new ArrayList<>();
            int currDimension = 0;
            for (int i = 0; i < indexes.length; i++) {
                if (indexes[i] instanceof NewAxis) {
                    newShape.add(1L);
                    newStrides.add(0L);
                } else {
                    newShape.add(arr.size(currDimension));
                    newStrides.add(arr.size(currDimension));
                    currDimension++;
                }
            }

            while (currDimension < arr.rank()) {
                newShape.add((long) currDimension);
                newStrides.add((long) currDimension);
                currDimension++;
            }

            long[] newShapeArr = Longs.toArray(newShape);
            long[] newStrideArr = Longs.toArray(newStrides);

            // FIXME: this is wrong, it breaks shapeInfo immutability
            arr.setShape(newShapeArr);
            arr.setStride(newStrideArr);


        } else {
            if (numNewAxes > 0) {
                long[] newShape = Longs.concat(ArrayUtil.toLongArray(ArrayUtil.nTimes(numNewAxes, 1)), arr.shape());
                long[] newStrides = Longs.concat(new long[numNewAxes], arr.stride());
                arr.setShape(newShape);
                arr.setStride(newStrides);
            }
        }

    }
331319
public void setIndexAttachments(java.util.Collection<IndexAttachment> indexAttachments) {
        if (indexAttachments == null) {
            this.indexAttachments = null;
            return;
        }

        this.indexAttachments = new java.util.ArrayList<IndexAttachment>(indexAttachments);
    }
116915
public void setIndexedAttributes(java.util.Collection<AttributeKeyAndValue> indexedAttributes) {
        if (indexedAttributes == null) {
            this.indexedAttributes = null;
            return;
        }

        this.indexedAttributes = new java.util.ArrayList<AttributeKeyAndValue>(indexedAttributes);
    }
1176158
public void setLookupAttributes(java.util.Collection<LookupAttribute> lookupAttributes) {
        if (lookupAttributes == null) {
            this.lookupAttributes = null;
            return;
        }

        this.lookupAttributes = new com.amazonaws.internal.SdkInternalList<LookupAttribute>(lookupAttributes);
    }
1110861
public static <T> List<T> slice(List<T> list, int... indexes) {
		List<T> slice = new ArrayList<>(indexes.length);
		for (int i : indexes) {
			slice.add(list.get(i));
		}
		return slice;
	}
430311
public void setIndexStats(Map<String, LocalIndexStatsImpl> indexStats) {
        this.mutableIndexStats.clear();
        if (indexStats != null) {
            this.mutableIndexStats.putAll(indexStats);
        }
    }
432716
@InterfaceAudience.Private
    protected Status updateIndexes(List<View> views) throws CouchbaseLiteException {
        List<ViewStore> storages = new ArrayList<ViewStore>();
        for (View view : views) {
            storages.add(view.viewStore);
        }
        return viewStore.updateIndexes(storages);
    }