Gets a new syntactic category identical to this one, except that
all features have been removed from atomic categories in
{@code atomicCategoriesToStrip}.

@param atomicCategoriesToStrip
@return
166834
public SyntacticCategory stripFeatures(Set<String> atomicCategoriesToStrip) {
    if (isAtomic()) {
      if (atomicCategoriesToStrip.contains(value) && !featureValue.equals(DEFAULT_FEATURE_VALUE)) {
        return SyntacticCategory.createAtomic(value, DEFAULT_FEATURE_VALUE, -1);
      } else {
        return this;
      }
    } else {
      return SyntacticCategory.createFunctional(direction, returnType.stripFeatures(atomicCategoriesToStrip), 
          argumentType.stripFeatures(atomicCategoriesToStrip), featureValue, featureVariable);
    }
  }
716529
public HeadedSyntacticCategory getArgumentType() {
    SyntacticCategory argumentSyntax = syntacticCategory.getArgument();
    int[] argumentSemantics = ArrayUtils.copyOfRange(semanticVariables, rootIndex + 1, semanticVariables.length);
    int argumentRoot = argumentSyntax.getNumReturnSubcategories();
    return new HeadedSyntacticCategory(argumentSyntax, argumentSemantics, argumentRoot);
  }
1364386
public Set<Category> getSiblings() {
        Set<Category> siblings = new HashSet<Category>();

        // add siblings
        for (Category parent : this.getParents()) {
            siblings.addAll(parent.getChildren());
        }

        // remove this category from list
        siblings.remove(this);

        return siblings;
    }
169843
private <T> CategoryRegistry<T> getRegistry(final Class<T> pCategory) {
        @SuppressWarnings({"unchecked"})
        CategoryRegistry<T> registry = categoryMap.get(pCategory);
        if (registry == null) {
            throw new IllegalArgumentException("No such category: " + pCategory.getName());
        }
        return registry;
    }
794545
public Category loadSelectedCategory() {
    String breadcrumb = storageHandler.loadSelectedCategory();
    Category defaultCategory = getCategories().get(DEFAULT_CATEGORY);
    if (breadcrumb == null) {
      return defaultCategory;
    }
    return flatCategoriesLst.stream()
        .filter(category -> category.getBreadcrumb().equals(breadcrumb))
        .findAny().orElse(defaultCategory);
  }
372042
@Nonnull
    public static ItemCategory getCategory(TopLevelItemDescriptor descriptor) {
        int order = 0;
        ExtensionList<ItemCategory> categories = ExtensionList.lookup(ItemCategory.class);
        for (ItemCategory category : categories) {
            if (category.getId().equals(descriptor.getCategoryId())) {
                category.setOrder(++order);
                return category;
            }
            order++;
        }
        return new UncategorizedCategory();
    }
99732
public String getClassificationId(ScopCategory category) {
		if(classificationId == null || classificationId.isEmpty()) {
			return null;
		}

		int numParts = 0;
		switch(category) {
		case Family:      numParts++;
		case Superfamily: numParts++;
		case Fold:        numParts++;
		case Class:       numParts++; break;
		default:
			throw new IllegalArgumentException("Only Class, Fold, Superfamily, and Family are supported.");
		}

		int endChar = -1;
		for(int i = 0;i<numParts-1;i++) {
			endChar = classificationId.indexOf('.', endChar+1);
			if(endChar<0) {
				// Not enough items in the classification for this category
				return null;
			}
		}
		endChar = classificationId.indexOf('.', endChar+1);
		if(endChar<0) {
			// category goes to the end
			return classificationId;
		}
		else {
			return classificationId.substring(0, endChar);
		}

	}
829239
public static IUnitizingAnnotationUnit findNextUnit(
			final Iterator<IUnitizingAnnotationUnit> units, int raterIdx,
			final Object category) {
		while (units.hasNext()) {
			IUnitizingAnnotationUnit result = units.next();
			if (category != null && !category.equals(result.getCategory())) {
                continue;
            }
			if (raterIdx < 0 || result.getRaterIdx() == raterIdx) {
                return result;
            }
		}
		return null;
	}
482392
public AtomicCounter newCounter(final String label, final int typeId)
    {
        return new AtomicCounter(valuesBuffer, allocate(label, typeId), this);
    }
880842
public com.google.api.ads.admanager.axis.v201902.DeviceCategoryTargeting getDeviceCategoryTargeting() {
        return deviceCategoryTargeting;
    }
705334
public static Set<String> handleBugCategories(String categories) {
        // Parse list of bug categories
        Set<String> categorySet = new HashSet<>();
        StringTokenizer tok = new StringTokenizer(categories, ",");
        while (tok.hasMoreTokens()) {
            categorySet.add(tok.nextToken());
        }

        return categorySet;
    }
305954
@Override
    public Categories getCategories(final AtomRequest areq) throws AtomException {
        LOG.debug("getCollection");
        final String[] pathInfo = StringUtils.split(areq.getPathInfo(), "/");
        final String handle = pathInfo[0];
        final String collection = pathInfo[1];
        final FileBasedCollection col = service.findCollectionByHandle(handle, collection);
        return col.getCategories(true).get(0);
    }
255000
public CmsCategory getCategory(CmsObject cms, String categoryRootPath) throws CmsException {

        CmsResource resource = cms.readResource(cms.getRequestContext().removeSiteRoot(categoryRootPath));
        return getCategory(cms, resource);
    }
621091
public FSArray getCategories() {
    if (Descriptor_Type.featOkTst && ((Descriptor_Type)jcasType).casFeat_categories == null)
      jcasType.jcas.throwFeatMissing("categories", "de.julielab.jules.types.wikipedia.Descriptor");
    return (FSArray)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((Descriptor_Type)jcasType).casFeatCode_categories)));}
635103
public com.google.api.ads.admanager.axis.v201811.DeviceCategoryTargeting getDeviceCategorySegment() {
        return deviceCategorySegment;
    }
873271
public List<SyntacticCategory> getAllSpannedLexiconEntries() {
    List<SyntacticCategory> categories = Lists.newArrayList();
    getAllSpannedLexiconEntriesHelper(categories);
    return categories;
  }
401647
protected Set<Integer> __getCategories() {

        // TODO this should be replaced with the buffered category iterator, as it might produce an HeapSpace Overflow, if there are too many categories.
        Session session = this.__getHibernateSession();
        session.beginTransaction();
        List<Integer> idList = session.createQuery(
                "select cat.pageId from Category as cat", Integer.class).list();
        Set<Integer> categorySet = new HashSet<Integer>(idList);
        session.getTransaction().commit();

        return categorySet;
    }