Returns <code>true</code> if any column is sorteable.<p>

@return <code>true</code> if any column is sorteable
325010
public boolean isSorteable() {

        Iterator<CmsListColumnDefinition> itCols = m_columns.elementList().iterator();
        while (itCols.hasNext()) {
            CmsListColumnDefinition col = itCols.next();
            if (col.isSorteable()) {
                return true;
            }
        }
        return false;
    }
1009075
private boolean isRoleEditable() {

        CmsObject cms = getCms();
        String path = getParamResource();
        return CmsWorkplace.canEditPermissionsForRoles(cms, path);

    }
253767
public static boolean hasSameComparator(Comparator<?> comparator, Iterable<?> elements) {
    checkNotNull(comparator);
    checkNotNull(elements);
    Comparator<?> comparator2;
    if (elements instanceof SortedSet) {
      comparator2 = comparator((SortedSet<?>) elements);
    } else if (elements instanceof SortedIterable) {
      comparator2 = ((SortedIterable<?>) elements).comparator();
    } else {
      return false;
    }
    return comparator.equals(comparator2);
  }
672769
public boolean containsColumn(String columnName) {
        return columns.stream()
            .map(DbColumn::getName)
            .anyMatch(listColName -> listColName.equals(columnName));
    }
1350043
protected function getSortableColumns()
    {
        if ($this->sortableColumns !== null) {
            return $this->sortableColumns;
        }

        $columns = $this->getColumns();
        $sortable = array_filter($columns, function ($column) {
            return $column->sortable;
        });

        return $this->sortableColumns = $sortable;
    }
991433
private function isTable(){
        try {
            if($table = $this->GetTable()){
                $sql = 'SHOW COLUMNS FROM '.$table;
                return $res = $this->query($sql)->all();
            }
        }catch(\Exception $e){
            echo $e->getMessage();
        }
        return false;
    }
223617
public boolean isUpdatableColumn(final String columnName)
   {
      // Use index iteration to avoid generating an Iterator as side-effect
      final FieldColumnInfo[] fcInfos = getUpdatableFcInfos();
      for (int i = 0; i < fcInfos.length; i++) {
         if (fcInfos[i].getCaseSensitiveColumnName().equals(columnName)) {
            return true;
         }
      }
      return false;
   }
74248
public boolean isShardingColumn(final String columnName, final String tableName) {
        for (TableRule each : tableRules) {
            if (each.getLogicTable().equalsIgnoreCase(tableName) && isShardingColumn(each, columnName)) {
                return true;
            }
        }
        return false;
    }
1092697
def sort(self, column, order=Qt.AscendingOrder):
        """"""
        ascending = order == Qt.AscendingOrder
        self.model.sort(self.COLUMN_INDEX, order=ascending)
        return True
74678
public boolean isSharable() {
        /**
         * Cache the result of {@link Sharable} annotation detection to workaround a condition. We use a
         * {@link ThreadLocal} and {@link WeakHashMap} to eliminate the volatile write/reads. Using different
         * {@link WeakHashMap} instances per {@link Thread} is good enough for us and the number of
         * {@link Thread}s are quite limited anyway.
         *
         * See <a href="https://github.com/netty/netty/issues/2289">#2289</a>.
         */
        Class<?> clazz = getClass();
        Map<Class<?>, Boolean> cache = InternalThreadLocalMap.get().handlerSharableCache();
        Boolean sharable = cache.get(clazz);
        if (sharable == null) {
            sharable = clazz.isAnnotationPresent(Sharable.class);
            cache.put(clazz, sharable);
        }
        return sharable;
    }
624393
public static boolean checkIndicesSorted( DMatrixSparseCSC A ) {
        for (int j = 0; j < A.numCols; j++) {
            int idx0 = A.col_idx[j];
            int idx1 = A.col_idx[j+1];

            if( idx0 != idx1 && A.nz_rows[idx0] >= A.numRows )
                return false;

            for (int i = idx0+1; i < idx1; i++) {
                int row = A.nz_rows[i];
                if( A.nz_rows[i-1] >= row)
                    return false;
                if( row >= A.numRows )
                    return false;
            }
        }
        return true;
    }
1314388
public boolean isNullable() {
        if (mPrime.isNullable()) {
            return true;
        }
        if (mChain != null) {
            for (StorableProperty<?> prop : mChain) {
                if (prop.isNullable()) {
                    return true;
                }
            }
        }
        return false;
    }
1036721
protected function _isSortEnabled()
    {
        if (!isset($this->controller->sortFields)) {
            return false;
        }

        foreach ($this->controller->sortFields as $field) {
            if (isset($field['actions']) &&
                is_array($field['actions']) &&
                in_array($this->action, $field['actions'])
            ) {
                return true;
            }
        }

        return false;
    }
438270
public boolean indexShareable() {
      TypedProperties properties = properties();
      boolean hasRamDirectoryProvider = false;
      for (Object objKey : properties.keySet()) {
         String key = (String) objKey;
         if (key.endsWith(DIRECTORY_PROVIDER_KEY)) {
            String directoryImplementationName = String.valueOf(properties.get(key)).trim();
            if (LOCAL_HEAP_DIRECTORY_PROVIDER.equalsIgnoreCase(directoryImplementationName)
                  || RAM_DIRECTORY_PROVIDER.equalsIgnoreCase(directoryImplementationName)
                  || LOCAL_HEAP_DIRECTORY_PROVIDER_FQN.equals(directoryImplementationName)) {
               hasRamDirectoryProvider = true;
            } else {
               return true;
            }
         }
      }
      return !hasRamDirectoryProvider;
   }
698353
private Set<String> getColumnsOfEmbeddableAndComputeEmbeddableNullness(String embeddable) {
		Set<String> columnsOfEmbeddable = new HashSet<String>();
		boolean hasOnlyNullColumns = true;

		for ( String selectableColumn : columns ) {
			if ( !isColumnPartOfEmbeddable( embeddable, selectableColumn ) ) {
				continue;
			}

			columnsOfEmbeddable.add( selectableColumn );

			if ( hasOnlyNullColumns && tuple.get( selectableColumn ) != null ) {
				hasOnlyNullColumns = false;
			}
		}

		if ( hasOnlyNullColumns ) {
			nullEmbeddables.add( embeddable );
		}

		return columnsOfEmbeddable;
	}
1189903
public boolean isAssignableFrom(JClass cl)
  {
    if (getName().equals(cl.getName()))
      return true;

    JClass []ifc = cl.getInterfaces();

    for (int i = 0; i < ifc.length; i++) {
      if (isAssignableFrom(ifc[i]))
        return true;
    }

    if (cl.getSuperClass() != null)
      return isAssignableFrom(cl.getSuperClass());
    else
      return false;
  }
1077720
public boolean isNullable() {

        boolean isNullable = super.isNullable();

        if (isNullable) {
            if (dataType.isDomainType()) {
                return dataType.userTypeModifier.isNullable();
            }
        }

        return isNullable;
    }