Adds a guarded object to be guarded by this FormGuard

@param newGuarded
object to be guarded
@param mask
indicating which state of the formModel should enable the guarded obhject
339428
public void addGuarded(Guarded newGuarded, int mask) {
        this.guardedEntries.put(newGuarded, new Integer(mask));
        newGuarded.setEnabled(stateMatchesMask(getFormModelState(), mask));
    }
340406
private void add(MethodFilter filter) {
        switch(operator) {
        case NOT:
            filters.add(new NegationMethodFilter(filter));
            operator = Operator.NONE;
            break;
        case OR:
            filters.set(filters.size() - 1, 
                        new OrMethodFilter(filters.get(filters.size() - 1), filter));
            operator = Operator.NONE;
            break;
        default:
            filters.add(filter);
            break;
        }
    }
414170
public final void splitByMask(AbstractNode<E> newNode, long[] assignment) {
    assert (isLeaf() == newNode.isLeaf());
    int dest = BitsUtil.nextSetBit(assignment, 0);
    if(dest < 0) {
      throw new AbortException("No bits set in splitting mask.");
    }
    // FIXME: use faster iteration/testing
    int pos = dest;
    while(pos < numEntries) {
      if(BitsUtil.get(assignment, pos)) {
        // Move to new node
        newNode.addEntry(getEntry(pos));
      }
      else {
        // Move to new position
        entries[dest] = entries[pos];
        dest++;
      }
      pos++;
    }
    final int rm = numEntries - dest;
    while(dest < numEntries) {
      entries[dest] = null;
      dest++;
    }
    numEntries -= rm;
  }
963938
private void protectSideEffects() {
    if (!problemNodes.isEmpty()) {
      if (!preserveFunctionInjected) {
        addExtern(compiler);
      }
      for (Node n : problemNodes) {
        Node name = IR.name(PROTECTOR_FN).srcref(n);
        name.putBooleanProp(Node.IS_CONSTANT_NAME, true);
        Node replacement = IR.call(name).srcref(n);
        replacement.putBooleanProp(Node.FREE_CALL, true);
        n.replaceWith(replacement);
        replacement.addChildToBack(n);
        compiler.reportChangeToEnclosingScope(replacement);
      }
    }
  }
1368067
public function addGuard(GuardInterface $guard)
    {
        $this->loaded && $this->loaded->__invoke();

        $this->guards[] = $guard;

        if ($guard instanceof ResourceProvider) {
            $this->addResourceProvider($guard);
        }

        if ($guard instanceof RuleProvider) {
            $this->addRuleProvider($guard);
        }

        return $this;
    }
961400
public void setNull(long mask) {
		for (int i = 0; i < this.numFields; i++, mask >>>= 1) {
			if ((mask & 0x1) != 0) {
				internallySetField(i, null);
			}
		}
	}
31089
def set_non_toggle_mask(self, non_toggle_mask):
        """"""
        set_cmd = self._create_set_property_msg("_non_toggle_mask", 0x08,
                                                non_toggle_mask)
        self._send_method(set_cmd, self._property_set)
860017
public static boolean isFieldProtected(FormModel formModel, String fieldName) {
        FieldMetadata metaData = formModel.getFieldMetadata(fieldName);
        return Boolean.TRUE.equals(metaData.getUserMetadata(UserMetadata.PROTECTED_FIELD));
    }
1017971
public static void checkGuardedBy(boolean condition, String formatString, Object... formatArgs) {
    if (!condition) {
      throw new IllegalGuardedBy(String.format(formatString, formatArgs));
    }
  }
778243
private function resolveMask($masks, $object)
    {
        $integerMask = 0;

        if (is_integer($masks)) {
            $integerMask = $masks;
        } elseif (is_string($masks)) {
            $permission = $this->permissionMap->getMasks($masks, $object);
            $integerMask = $this->resolveMask($permission, $object);
        } elseif (is_array($masks)) {
            foreach ($masks as $mask) {
                $integerMask += $this->resolveMask($mask, $object);
            }
        } else {
            throw new \RuntimeException('Not a valid mask type');
        }

        return $integerMask;
    }
1346486
def add(self, name, value, bitmask=DEFMASK):
        
        _add_enum_member(self._eid, name, value, bitmask)
194542
public void load(String mask) {
        options.onComplete = object -> CompleteEvent.fire(this, object);
        options.onKeyPress = object -> KeyPressEvent.fire(this, object);
        options.onChange = object -> ChangeEvent.fire(this, object);
        options.onInvalid = (object, event, function, error) -> InvalidEvent.fire(this, object, error[0]);
        $(valueBoxBase.getElement()).mask(mask, options);
    }
165479
public void putMsgfunc(MsgListener listener, Object userhandle, int mask) throws LpSolveException {
		msgListener = listener;
		msgUserhandle = (listener != null) ? userhandle : null;
		addLp(this);
		registerMsgfunc(mask);
	}
1092190
function _enableMasking(ctx, data, params) {
	if (params.mask) {
		// If jCanvas autosave is enabled
		if (params.autosave) {
			// Automatically save transformation state by default
			_saveCanvas(ctx, data);
		}
		// Clip the current path
		ctx.clip();
		// Keep track of current masks
		data.transforms.masks.push(params._args);
	}
}
1371370
protected void addConstructedGuardToMethodBody(final ClassMethod classMethod, String className) {
        if (!useConstructedFlag()) {
            return;
        }
        // now create the conditional
        final CodeAttribute cond = classMethod.getCodeAttribute();
        cond.aload(0);
        cond.getfield(classMethod.getClassFile().getName(), CONSTRUCTED_FLAG_NAME, BytecodeUtils.BOOLEAN_CLASS_DESCRIPTOR);

        // jump if the proxy constructor has finished
        BranchEnd jumpMarker = cond.ifne();
        // generate the invokespecial call to the super class method
        // this is run when the proxy is being constructed
        cond.aload(0);
        cond.loadMethodParameters();
        cond.invokespecial(className, classMethod.getName(), classMethod.getDescriptor());
        cond.returnInstruction();
        cond.branchEnd(jumpMarker);
    }
209355
public function modifyMask($mask): self
    {
        if (is_array($mask)) {
            $this->attributes['mask'] = json_encode($mask);
        }

        return $this;
    }
974908
private void newBlock(String m)
    {
        if (row==null)
            newRow();
        else
            row.unnest();
        row.nest(cell=new Block(m));

        if (cellNestFactory!=null)
            cell.nest(cellNestFactory.newComposite());  
    }