Get classes for the given column index & element.
507633
function getClasses(index$$1, element, row) {
      var _this$typedColumns$in = this.typedColumns[index$$1],
          typeDef = _this$typedColumns$in.typeDef,
          custom = _this$typedColumns$in["".concat(element, "Class")];

      var isRight = typeDef.isRight;
      if (this.rtl) isRight = true;
      var classes = {
        'vgt-right-align': isRight,
        'vgt-left-align': !isRight
      }; // for td we need to check if value is
      // a function.

      if (typeof custom === 'function') {
        classes[custom(row)] = true;
      } else if (typeof custom === 'string') {
        classes[custom] = true;
      }

      return classes;
    }
35919
function getColSelectors(table) {
      var cols = this.getCols(table);
      var selectors = cols.map(function (col) {
        return table.getCellSelector(col);
      });
      return selectors;
    }
783905
function getClassIndex(element, className) {
  assertType(element, Node, false, 'Invalid element specified');
  assertType(className, 'string', false, `Invalid class name: ${className}`);
  let classList = element.className.split(' ');
  return classList.indexOf(className);
}
105045
def get_index_of_column(cls, column, file_path):
        
        columns = cls.get_column_names_from_file(file_path)
        if column in columns:
            return columns.index(column)
884919
def get_cell(row_index, column_index)
      if within_range?(row_index, column_index)
        @rows[row_index][column_index].v
      else
        raise RangeError, "row_index and column_index MUST be < @rows.size and @cols.size", caller
      end
    end
640547
function(column){
			var index = -1;
			var j = 0;
			for(var i=0;i < this.gridCompColumnArr.length;i++){
				if(this.gridCompColumnArr[i] == column){
					if(!($('#' + this.options.id + '_header').find('th').eq(i).css('display') == 'none')){
						index = j;
					}
					break;
				}
				if(!($('#' + this.options.id + '_header').find('th').eq(i).css('display') == 'none')){
					j++;
				}
			}
			return index;
		}
1164612
protected function getClassesForIndex(SolrIndex $index, $filterClasses = null)
    {
        // Get base classes
        $classes = $index->getClasses();
        if (!$filterClasses) {
            return $classes;
        }

        // Apply filter
        if (!is_array($filterClasses)) {
            $filterClasses = explode(',', $filterClasses);
        }
        return array_intersect_key($classes, array_combine($filterClasses, $filterClasses));
    }
484143
function sortedColumnClasses(classes) {
        // extract column classes
        var colClasses = [];
        while (true) {
            var match = COL_REGEX.exec(classes);
            if (!match) {
                break;
            }
            var colClass = match[0];
            colClasses.push(colClass);
            classes = withoutClass(classes, colClass);
        }

        colClasses.sort(compareColumnClasses);
        return classes + ' ' + colClasses.join(' ');
    }
1287121
function() {
      var array = [],
          i, j, ilen, jlen;
      for(i = 0, ilen = this.elements.length; i < ilen; i++) {
        var row = [];
        for(j = 0, jlen = this.column_names.length; j < jlen ; j++) {
          row.push( this.elements[i][ this.column_names[j] ] );
        }
        array.push(row);
      }
      return array;
    }
901699
def classes(self):
        
        p = lambda o: isinstance(o, Class) and self._docfilter(o)
        return sorted(filter(p, self.doc.values()))
1229033
def loaded_columns(obj: BaseModel):
    """"""
    for column in sorted(obj.Meta.columns, key=lambda c: c.name):
        value = getattr(obj, column.name, missing)
        if value is not missing:
            yield column.name, value
270469
Index getIndexForColumns(int[] cols) {

        int i = bestIndexForColumn[cols[0]];

        if (i > -1) {
            return indexList[i];
        }

        switch (tableType) {

            case TableBase.SYSTEM_SUBQUERY :
            case TableBase.SYSTEM_TABLE :
            case TableBase.VIEW_TABLE :
            case TableBase.TEMP_TABLE : {
                Index index = createIndexForColumns(cols);

                return index;
            }
        }

        return null;
    }
884564
def _index_classes(self) -> Dict[Text, Type[Platform]]:
        

        out = {}

        for p in get_platform_settings():
            cls: Type[Platform] = import_class(p['class'])

            if 'name' in p:
                out[p['name']] = cls
            else:
                out[cls.NAME] = cls

        return out
214848
protected String[] getColumnClasses(PanelGrid panelGrid, int[] colSpans) {
		String columnsCSV = panelGrid.getColumnClasses();
		String[] columnClasses;

		if (null == columnsCSV || columnsCSV.trim().length()==0)
			columnClasses = null;
		else {
			columnClasses = columnsCSV.split(",");
			if (columnClasses.length > colSpans.length) {
				throw new FacesException("PanelGrid: You defined more columnClasses than columns or colSpans");
			}
		}

		String size = panelGrid.getSize();
		if (null == size || size.trim().equals("")) {
			size = "lg";
		} else {
			size = Responsive.translateSize(size, true);
		}
		

		String[] result = new String[colSpans.length];

		for (int i = 0; i < colSpans.length; i++) {
			if (columnClasses == null) {
				result[i] = "col-" + size + "-" + colSpans[i];
			} else {
				String current = columnClasses[i % columnClasses.length];
				if (current.contains("col-")) {
					result[i] = current;
				} else {
					result[i] = "col-" + size + "-" + colSpans[i] + " " + current;
				}

			}
		}
		return result;
	}
225680
private <E> List<E> findAllColumns(Class<E> entityClass, byte[][] columns, Object... keys)
    {
        Object connection = getConnection();
        // connection.co
        List results = new ArrayList();
        try
        {
            for (Object key : keys)
            {
                Object result = fetch(entityClass, key, connection, columns);
                if (result != null)
                {
                    results.add(result);
                }
            }
        }
        catch (InstantiationException e)
        {
            logger.error("Error during find by key:", e);
            throw new PersistenceException(e);
        }
        catch (IllegalAccessException e)
        {
            logger.error("Error during find by key:", e);
            throw new PersistenceException(e);
        }
        return results;
    }
1350708
def columns(self):
        
        from .column import Column

        if self.url is None or self.post_num == 0:
            return
        soup = BeautifulSoup(self._session.get(self.url + 'posts').text)
        column_list = soup.find('div', class_='column-list')
        column_tags = column_list.find_all('div', class_='item')
        for column_tag in column_tags:
            name = column_tag['title']
            url = column_tag['data-href']
            numbers = column_tag.find('span', class_='des').text.split('•')
            follower_num = int(re_get_number.match(numbers[0]).group(1))
            if len(numbers) == 1:
                post_num = 0
            else:
                post_num = int(
                    re_get_number.match(numbers[1]).group(1))
            yield Column(url, name, follower_num, post_num,
                         session=self._session)
1061637
def optional(cls):
        
        columns = []
        for column in cls.__table__.columns:  # pylint: disable=no-member
            if column.nullable:
                columns.append(column.name)
        return columns