Determines the int type of the current access control entry.<p>

@param flags the value of the current flags
@return int representation of the ace type as int
507436
protected int getEntryTypeInt(int flags) {

        for (int i = 0; i < getTypesInt().length; i++) {
            if ((flags & getTypesInt()[i]) > 0) {
                return i;
            }
        }
        return -1;
    }
158001
public final void setSideEffectFlags(int flags) {
    checkState(
        this.isCall() || this.isNew() || this.isTaggedTemplateLit(),
        "Side-effect flags can only be set on invocation nodes; got %s",
        this);

    // We invert the flags before setting because we also invert the them when getting; they go
    // full circle.
    //
    // We apply the mask after inversion so that if all flags are being set (all 1s), it's
    // equivalent to storing a 0, the default value of an int-prop, which has no memory cost.
    putIntProp(Prop.SIDE_EFFECT_FLAGS, ~flags & SideEffectFlags.USED_BITS_MASK);
  }
105320
public static <E extends Enum<E> & ByteEnum> int setToInt (Set<E> set)
    {
        int flags = 0;
        for (E value : set) {
            flags |= toIntFlag(value);
        }
        return flags;
    }
182780
public int getRelationFlags(Interval<E> other)
  {
    if (other == null) return 0;
    int flags = 0;
    int comp11 = this.first.compareTo(other.first());   // 3 choices
    flags |= toRelFlags(comp11, REL_FLAGS_SS_SHIFT);
    int comp22 = this.second.compareTo(other.second());   // 3 choices
    flags |= toRelFlags(comp22, REL_FLAGS_EE_SHIFT);
    int comp12 = this.first.compareTo(other.second());   // 3 choices
    flags |= toRelFlags(comp12, REL_FLAGS_SE_SHIFT);
    int comp21 = this.second.compareTo(other.first());   // 3 choices
    flags |= toRelFlags(comp21, REL_FLAGS_ES_SHIFT);
    flags = addIntervalRelationFlags(flags, false);
    return flags;
  }
1074269
public CodeType getType(final Bits bits) {
    if (null != this.bitDepth) {
      if (bits.bitLength == this.bitDepth) {
        return CodeType.Terminal;
      }
      if (bits.bitLength < this.bitDepth) {
        return CodeType.Prefix;
      }
      throw new IllegalArgumentException();
    }
    return CodeType.Unknown;
  }
1066028
public com.google.api.ads.admanager.axis.v201808.SecurityPolicyType getSecurityPolicyType() {
        return securityPolicyType;
    }
206727
protected String flagsToRegexOptions(int flags) {
		StringBuilder options = new StringBuilder();
		if ((flags & Pattern.CASE_INSENSITIVE) != 0) {
			options.append("i");
		}
		if ((flags & Pattern.MULTILINE) != 0) {
			options.append("m");
		}
		if ((flags & Pattern.DOTALL) != 0) {
			options.append("s");
		}
		if ((flags & Pattern.UNICODE_CASE) != 0) {
			options.append("u");
		}
		return options.toString();
	}
47156
@Override
    public int getIntHeader(String arg0) {
        try {
            collaborator.preInvoke(componentMetaData);
            return request.getIntHeader(arg0);
        } finally {
            collaborator.postInvoke();
        }
    }
1152511
public void setAceFlags(String aceFlags) {

        try {
            m_aceFlags = Integer.parseInt(aceFlags);
        } catch (Throwable e) {
            m_throwable = e;
        }
    }
850103
public void setAutoAcceptBootstrapSigner(boolean flag) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "setAutoAcceptBootstrapSigner -> " + flag);
        this.autoAcceptBootstrapSigner = flag;
    }
516577
def get_access_flags_string(value):
    
    buff = ""
    for i in ACCESS_FLAGS:
        if (i[0] & value) == i[0]:
            buff += i[1] + " "

    if buff != "":
        return buff[:-1]
    return buff
986263
public Type type() {
    if (type == null) {
      synchronized (this) {
        if (type == null) {
          type = address() instanceof Inet6Address ? Type.IPV6 : Type.IPV4;
        }
      }
    }
    return type;
  }
935005
public static <E extends Enum<E>> EnumSet<E> getSet(Class<E> elementType, int flag)
    {
        EnumSet<E> set = EnumSet.noneOf(elementType);
        E[] enumConstants = elementType.getEnumConstants();
        if (enumConstants.length > Integer.SIZE)
        {
            throw new IllegalArgumentException(elementType+" contains too many enums for int");
        }
        for (int ii=0;ii<enumConstants.length;ii++)
        {
            if ((flag & (1<<ii)) != 0)
            {
                set.add(enumConstants[ii]);
            }
        }
        return set;
    }
475899
@Override
    public NumberType getNumberType() throws IOException {
        Object n = currentNode();
        if (n instanceof Integer) {
            return NumberType.INT;
        } else if (n instanceof BigInteger) {
            return NumberType.BIG_INTEGER;
        } else if (n instanceof BigDecimal) {
            return NumberType.BIG_DECIMAL;
        } else if (n instanceof Double) {
            return NumberType.DOUBLE;
        } else if (n instanceof Float) {
            return NumberType.FLOAT;
        } else if (n instanceof Long) {
            return NumberType.LONG;
        } else {
            throw _constructError(n + " is not a number");
        }
    }
575706
public int getVirtualGroupFlags() {

        int flags = I_CmsPrincipal.FLAG_GROUP_VIRTUAL;
        flags += I_CmsPrincipal.FLAG_GROUP_VIRTUAL * 2 * getSystemRoles().indexOf(forOrgUnit(null));
        return flags;
    }
235762
public static <E extends Enum<E> & ByteEnum> EnumSet<E> intToSet (Class<E> eclass, int flags)
    {
        EnumSet<E> set = EnumSet.noneOf(eclass);
        for (E value : eclass.getEnumConstants()) {
            if ((flags & toIntFlag(value)) != 0) {
                set.add(value);
            }
        }
        return set;
    }
421011
public int getFlags() {
        int flags = 32;    // Use Adobe Standard charset
        if (italicAngle != 0) {
            flags = flags | 64;
        }
        if (isFixedPitch != 0) {
            flags = flags | 2;
        }
        if (hasSerifs) {
            flags = flags | 1;
        }
        return flags;
    }