Creates new contact filter for this light with given parameters

@param categoryBits - see {@link Filter#categoryBits}
@param groupIndex   - see {@link Filter#groupIndex}
@param maskBits     - see {@link Filter#maskBits}
186041
public void setContactFilter(short categoryBits, short groupIndex,
			short maskBits) {
		filterA = new Filter();
		filterA.categoryBits = categoryBits;
		filterA.groupIndex = groupIndex;
		filterA.maskBits = maskBits;
	}
68987
public void setMaskBits(int mask) throws IllegalArgumentException {

    if ((mask > MASK_MAX) || (mask < 0)) {
      throw new IllegalArgumentException("File mode mask out of range: " + mask);
    }
    this.maskBits = mask;
  }
191265
public static void defineMask() {
		GL.glDepthMask(true);
		GL.glClearDepth(1);
		GL.glClear(SGL.GL_DEPTH_BUFFER_BIT);
		GL.glDepthFunc(SGL.GL_ALWAYS);
		GL.glEnable(SGL.GL_DEPTH_TEST);
		GL.glDepthMask(true);
		GL.glColorMask(false, false, false, false);
	}
1156385
public T updateMask(List<AclEntry> entries) {
    boolean needToUpdateACL = false;
    boolean needToUpdateDefaultACL = false;

    for (AclEntry entry : entries) {
      if (entry.getType().equals(AclEntryType.NAMED_USER)
          || entry.getType().equals(AclEntryType.NAMED_GROUP)
          || entry.getType().equals(AclEntryType.OWNING_GROUP)) {
        if (entry.isDefault()) {
          needToUpdateDefaultACL = true;
        } else {
          needToUpdateACL = true;
        }
      }
      if (entry.getType().equals(AclEntryType.MASK)) {
        // If mask is explicitly set or removed then we don't need to update the mask
        return getThis();
      }
    }
    if (needToUpdateACL) {
      mAcl.updateMask();
    }

    if (needToUpdateDefaultACL) {
      getDefaultACL().updateMask();
    }
    return getThis();
  }
1350198
public static BloomFilter create(long expectedNumItems, long numBits) {
    if (expectedNumItems <= 0) {
      throw new IllegalArgumentException("Expected insertions must be positive");
    }

    if (numBits <= 0) {
      throw new IllegalArgumentException("Number of bits must be positive");
    }

    return new BloomFilterImpl(optimalNumOfHashFunctions(expectedNumItems, numBits), numBits);
  }
795614
private function buildSectionFilterParameters(ParameterBuilderInterface $builder, array $groups = []): void
    {
        $builder->add(
            'filter_by_section',
            ParameterType\Compound\BooleanType::class,
            [
                'groups' => $groups,
            ]
        );

        $builder->get('filter_by_section')->add(
            'sections',
            EzParameterType\SectionType::class,
            [
                'multiple' => true,
                'groups' => $groups,
            ]
        );
    }
1254065
public void setCPDefinitionGroupedEntryLocalService(
		com.liferay.commerce.product.type.grouped.service.CPDefinitionGroupedEntryLocalService cpDefinitionGroupedEntryLocalService) {
		this.cpDefinitionGroupedEntryLocalService = cpDefinitionGroupedEntryLocalService;
	}
886035
public static void addGlobalMappingFilters(String filterSpec, String ... filterSpecs) {
        addGlobalMappingFilter(filterSpec);
        for (String s : filterSpecs) {
            addGlobalMappingFilter(s);
        }
    }
1257158
public static boolean isValidNetmask(byte[] segments)
	{
		boolean mustBeZero = false;
		for (int i = 0; i < segments.length; i++)
		{

			// Valid segments: 0, 128, 192, 224, 240, 248, 252, 254, 255
			switch (segments[i])
			{
				case -1:
					if (mustBeZero)
						return false;
					break;
				case 0:
					if (mustBeZero)
					{
						break;
					}
				case -2:
				case -4:
				case -8:
				case -16:
				case -32:
				case -64:
				case -128:
					if (!mustBeZero)
						mustBeZero = true;
					else
					{
						return false;
					}
					break;
				default:
					return false;
			}
		}

		return true;
	}
648662
public void setCategoryList(java.util.Collection<Category> categoryList) {
        if (categoryList == null) {
            this.categoryList = null;
            return;
        }

        this.categoryList = new java.util.ArrayList<Category>(categoryList);
    }
996018
private void calculate(String mask) {
        Matcher matcher = cidrPattern.matcher(mask);

        if (matcher.matches()) {
            matchAddress(matcher);

            /* Create a binary netmask from the number of bits specification /x */
            rangeCheck(Integer.parseInt(matcher.group(5)), 0, NBITS);
        } else {
            throw new IllegalArgumentException("Could not parse [" + mask + "]");
        }
    }
1232692
protected void setGroups(List<CmsPublishGroup> groups, boolean newData) {

        m_model = new CmsPublishDataModel(groups, this);
        m_model.setSelectionChangeAction(new Runnable() {

            public void run() {

                onChangePublishSelection();
            }
        });
        m_currentGroupIndex = 0;
        m_currentGroupPanel = null;
        m_problemsPanel.clear();
        if (newData) {
            m_showProblemsOnly = false;
            m_checkboxProblems.setChecked(false);
            m_checkboxProblems.setVisible(false);
            m_problemsPanel.setVisible(false);
        }
        m_groupPanels.clear();
        m_groupPanelContainer.clear();
        m_scrollPanel.onResizeDescendant();
        enableActions(false);

        int numGroups = groups.size();
        setResourcesVisible(numGroups > 0);

        if (numGroups == 0) {
            return;
        }
        enableActions(true);
        addMoreListItems();
        showProblemCount(m_model.countProblems());
    }
114254
def list_categories(self, package_keyname, **kwargs):
        
        get_kwargs = {}
        get_kwargs['mask'] = kwargs.get('mask', CATEGORY_MASK)

        if 'filter' in kwargs:
            get_kwargs['filter'] = kwargs['filter']

        package = self.get_package_by_key(package_keyname, mask='id')
        categories = self.package_svc.getConfiguration(id=package['id'], **get_kwargs)
        return categories
120535
public IPv4AddressSection mask(IPv4AddressSection mask, boolean retainPrefix) throws IncompatibleAddressException, PrefixLenException, SizeMismatchException {
		checkMaskSectionCount(mask);
		return getSubnetSegments(
				this,
				retainPrefix ? getPrefixLength() : null,
				getAddressCreator(),
				true,
				this::getSegment,
				i -> mask.getSegment(i).getSegmentValue(),
				false);
	}
1140341
static FilterTable create(int bitsPerTag, long numBuckets) {
		// why would this ever happen?
		checkArgument(bitsPerTag < 48, "tagBits (%s) should be less than 48 bits", bitsPerTag);
		// shorter fingerprints don't give us a good fill capacity
		checkArgument(bitsPerTag > 4, "tagBits (%s) must be > 4", bitsPerTag);
		checkArgument(numBuckets > 1, "numBuckets (%s) must be > 1", numBuckets);
		// checked so our implementors don't get too.... "enthusiastic" with
		// table size
		long bitsPerBucket = IntMath.checkedMultiply(CuckooFilter.BUCKET_SIZE, bitsPerTag);
		long bitSetSize = LongMath.checkedMultiply(bitsPerBucket, numBuckets);
		LongBitSet memBlock = new LongBitSet(bitSetSize);
		return new FilterTable(memBlock, bitsPerTag, numBuckets);
	}
399009
def kpl_set_on_mask(self, address, group, mask):
        """"""
        addr = Address(address)
        device = self.plm.devices[addr.id]
        device.states[group].set_on_mask(mask)
1002610
private void categories(RouteMeta routeMete) {
        if (routeVerify(routeMete)) {
            logger.info(">>> Start categories, group = " + routeMete.getGroup() + ", path = " + routeMete.getPath() + " <<<");
            Set<RouteMeta> routeMetas = groupMap.get(routeMete.getGroup());
            if (CollectionUtils.isEmpty(routeMetas)) {
                Set<RouteMeta> routeMetaSet = new TreeSet<>(new Comparator<RouteMeta>() {
                    @Override
                    public int compare(RouteMeta r1, RouteMeta r2) {
                        try {
                            return r1.getPath().compareTo(r2.getPath());
                        } catch (NullPointerException npe) {
                            logger.error(npe.getMessage());
                            return 0;
                        }
                    }
                });
                routeMetaSet.add(routeMete);
                groupMap.put(routeMete.getGroup(), routeMetaSet);
            } else {
                routeMetas.add(routeMete);
            }
        } else {
            logger.warning(">>> Route meta verify error, group is " + routeMete.getGroup() + " <<<");
        }
    }