Sets the row name.

        :param index: the 0-based row index
        :type index: int
        :param name: the name of the row
        :type name: str
328694
def set_row_name(self, index, name):
        
        javabridge.call(self.jobject, "setRowName", "(ILjava/lang/String;)V", index, name)
391117
def set_default_names(data):
    """"""
    if com._all_not_none(*data.index.names):
        nms = data.index.names
        if len(nms) == 1 and data.index.name == 'index':
            warnings.warn("Index name of 'index' is not round-trippable")
        elif len(nms) > 1 and any(x.startswith('level_') for x in nms):
            warnings.warn("Index names beginning with 'level_' are not "
                          "round-trippable")
        return data

    data = data.copy()
    if data.index.nlevels > 1:
        names = [name if name is not None else 'level_{}'.format(i)
                 for i, name in enumerate(data.index.names)]
        data.index.names = names
    else:
        data.index.name = data.index.name or 'index'
    return data
918608
def create_index(index_name, index_config, client):
    
    client.create(index=index_name, body=index_config)
1371761
def build_index(self, idx_name, _type='default'):
        ""
        indexes = {}
        has_non_string_values = False
        for key, item in self.data.items():
            if idx_name in item:
                value = item[idx_name]
                # A non-string index value switches it into a lazy one.
                if not isinstance(value, six.string_types):
                    has_non_string_values = True
                if value not in indexes:
                    indexes[value] = set([])
                indexes[value].add(key)
        self.indexes[idx_name] = indexes
        if self._meta.lazy_indexes or has_non_string_values:
            # Every index is lazy
            _type = 'lazy'
        self.index_defs[idx_name] = {'type': _type}
1287371
def set_name(self,name=None):
        
        if name:
            self.name = name[:254]
        else:
            self.name = self.extract_name()[:254]

        self.save()

        return self.name
348427
def _SetRow(self, new_values, row=0):
        

        if not row:
            row = self._row_index

        if row > self.size:
            raise TableError("Entry %s beyond table size %s." % (row, self.size))

        self._table[row].values = new_values
680051
def get_index(self, name):
        
        name = self._normalize_identifier(name)
        if not self.has_index(name):
            raise IndexDoesNotExist(name, self._name)

        return self._indexes[name]
65298
public final void nameArgument(String name, int index)
    {
        VariableElement lv = getLocalVariable(index);
        if (lv instanceof UpdateableElement)
        {
            UpdateableElement ue = (UpdateableElement) lv;
            ue.setSimpleName(El.getName(name));
        }
        else
        {
            throw new IllegalArgumentException("local variable at index "+index+" cannot be named");
        }
    }
521978
def rename_index(self, old_name, new_name=None):
        
        old_name = self._normalize_identifier(old_name)
        normalized_new_name = self._normalize_identifier(new_name)

        if old_name == normalized_new_name:
            return self

        if not self.has_index(old_name):
            raise IndexDoesNotExist(old_name, self._name)

        if self.has_index(normalized_new_name):
            raise IndexAlreadyExists(normalized_new_name, self._name)

        old_index = self._indexes[old_name]

        if old_index.is_primary():
            self.drop_primary_key()

            return self.set_primary_key(old_index.get_columns(), new_name)

        del self._indexes[old_name]

        if old_index.is_unique():
            return self.add_unique_index(old_index.get_columns(), new_name)

        return self.add_index(old_index.get_columns(), new_name, old_index.get_flags())
296184
public void setIndex(String indexName) throws CmsException {

        if (CmsStringUtil.isEmpty(indexName)) {
            throw new CmsException(Messages.get().container(Messages.ERR_INDEXSOURCE_CREATE_MISSING_NAME_0));
        }
        CmsSolrIndex index = OpenCms.getSearchManager().getIndexSolr(indexName);
        if (index == null) {
            throw new CmsException(Messages.get().container(Messages.ERR_INDEX_NOT_FOUND_1, indexName));
        }

        m_index = index;

    }
4659
private void updateIndexTermTargetName() {
        if (defaultTitle == null) {
            defaultTitle = targetFile;
        }
        for (final IndexTerm indexterm : indexTermList) {
            updateIndexTermTargetName(indexterm);
        }
    }
1238655
def setParameter(self, parameterName, index, parameterValue):
    
    if hasattr(self, parameterName):
      setattr(self, parameterName, parameterValue)
    else:
      raise Exception("Unknown parameter: " + parameterName)
621068
public void setIndex(String indexName) {

        CmsSearchIndex index;
        if (CmsStringUtil.isNotEmpty(indexName)) {
            try {
                I_CmsSearchIndex idx = OpenCms.getSearchManager().getIndex(indexName);
                index = idx instanceof CmsSearchIndex ? (CmsSearchIndex)idx : null;
                if (index == null) {
                    throw new CmsException(Messages.get().container(Messages.ERR_INDEX_NOT_FOUND_1, indexName));
                }
                setSearchIndex(index);
            } catch (Exception exc) {
                if (LOG.isErrorEnabled()) {
                    LOG.error(Messages.get().getBundle().key(Messages.LOG_INDEX_ACCESS_FAILED_1, indexName), exc);
                }
            }
        }
    }
810529
def add_index_operation(self, name, operations):
        
        if name not in self._index_operations:
            self._add_io(name, operations)
        else:
            raise AttributeError("An index operation with the name {} was already taken".format(name))
1072101
def set_cell(self, index, value):
        
        if self._sort:
            exists, i = sorted_exists(self._index, index)
            if not exists:
                self._insert_row(i, index)
        else:
            try:
                i = self._index.index(index)
            except ValueError:
                i = len(self._index)
                self._add_row(index)
        self._data[i] = value
15173
def addIndex(self, index):
        
        index.setSchema(self)
        self.__indexes[index.name()] = index
1290329
def make_index(name, localname):
    
    return type("BB%sIndex" % (name.capitalize(),),
                (BBIndex,),
                dict(name=name, localname=localname))