Constructor for FlagValues
515851
def FlagValues(*params)
      if params.size==1 && params.first.kind_of?(FlagValues)
        params.first
      else
        FlagValues.new(*params)
      end
    end
397291
private final void setFlagValue(byte flagBit, boolean value) {
        if (value) {
            flags = (byte) (getFlags() | flagBit);
        }
        else {
            flags = (byte) (getFlags() & (~flagBit));
        }
    }
665796
public RoutesMetadataPlugin flag(String flagValue)
	{
		for (RouteBuilder routeBuilder : routeBuilders)
		{
			routeBuilder.flag(flagValue);
		}

		return this;
	}
363685
@Deprecated
    @Override
    public boolean getFlag(int flagType) {
        boolean val = false;
        boolean leftFlag = left.getFlag(flagType);
        if (right != null) {
            if ("and".equals(operator) && leftFlag) {
                boolean rightFlag = right.getFlag(flagType);
                val = leftFlag && rightFlag;
            } else if ("or".equals(operator)) {
                boolean rightFlag = right.getFlag(flagType);
                val = leftFlag || rightFlag;
            }
        } else {
            if ("not".equals(operator)) {
                val = (!leftFlag);
            } else {
                val = leftFlag;
            }
        }
        return val;
    }
1213896
function value(utils) {
  const target = this._obj,
        value = target.value || null;
  isValidation(target);
  this.assert(null !== value,
      '#{this} should have value',
      '#{this} should not have value'
  );
  utils.flag(this, 'object', value);
}
371530
function getValidValues() {
    var typeSpec = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    var valueStr = void 0;

    if (typeSpec.value) {
        var values = Array.isArray(typeSpec.value) ? typeSpec.value : [typeSpec.value];

        var validValues = values.map(function (value) {
            var valueName = value.name;
            var valueValue = value.value;

            if (valueValue) {
                if ((typeof valueValue === 'undefined' ? 'undefined' : _typeof(valueValue)) === 'object') {
                    return getValidValues(value);
                }

                return valueValue;
            } else if (valueName && valueName !== 'custom') {
                return '<' + valueName + '>';
            }
        });

        valueStr = validValues.join(', ');

        if (typeSpec.name === 'arrayOf') {
            valueStr = 'array[' + valueStr + ']';
        }
    } else if (typeSpec.name) {
        valueStr = '<' + typeSpec.name + '>';
    }

    return valueStr;
}
1070471
Set<ExportsFlag> readExportsFlags(int flags) {
        Set<ExportsFlag> set = EnumSet.noneOf(ExportsFlag.class);
        for (ExportsFlag f: ExportsFlag.values()) {
            if ((flags & f.value) != 0)
                set.add(f);
        }
        return set;
    }
1130233
def flags
      fs = FRAME_FLAGS[type]
      [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80]
        .select { |v| @flags_value & v > 0 }
        .map { |val| fs && fs.key(val) || ("unknown_%02x" % val).to_sym }
    end
1366999
def get_flag_value(self, name, default):  # pylint: disable=invalid-name
    

    value = self.__getattr__(name)
    if value is not None:  # Can't do if not value, b/c value might be '0' or ""
      return value
    else:
      return default
1127436
function (memberValue, visibility) {
        _gpfAsserts({
            "Constructor must be a function": "function" === typeof memberValue,
            "Own constructor can't be overridden": null === this._definitionConstructor
        });
        if (_gpfUsesSuper(memberValue)) {
            memberValue = _gpfGenSuperMember(this._Super, memberValue);
        }
        _gpfIgnore(visibility); // TODO Handle constructor visibility
        this._definitionConstructor = memberValue;
    }
761580
private VarSymbol makeSyntheticVar(long flags, Name name, Type type, Symbol owner) {
        return new VarSymbol(flags | SYNTHETIC, name, type, owner);
    }
1025344
function(_set1, _set2) {
        var flagEquals,
            newSet = [];
        for (var i = 0; i < _set1.length; i++) {
            flagEquals = false;
            for(var j = 0; j < _set2.length; j++) {
                if (_set1[i].asString == _set2[j].asString) {
                    flagEquals = true;
                    break;
                }
            }
            if (!flagEquals) {
                newSet.push(_set1[i]);
            }
        }

        return newSet;
    }
353661
function setFlags() {
		flagN = !!( P & 0x80 );
		flagV = !!( P & 0x40 );
		flagB = !!( P & 0x10 );
		flagD = !!( P & 0x08 );
		flagI = !!( P & 0x04 );
		flagZ = !!( P & 0x02 );
		flagC = !!( P & 0x01 );
	}
150558
function checkValue(i) {
  const start = i;
  let l;
  let s;
  let _i;

  while (i < tokensLength) {
    if (checkDeclDelim(i)) break;

    if (l = checkBlock(i)) {
      i += l;
      break;
    }

    s = checkS(i);
    _i = i + s;

    if (l = _checkValue(_i)) i += l + s;
    if (!l || checkBlock(i - l)) break;
  }

  return i - start;
}
1260048
def flag_to_list(flagval, flagtype):
    """"""
    if flagtype == 'int':
        return [int(_) for _ in flagval.split(',') if _]

    elif flagtype == 'float':
        return [float(_) for _ in flagval.split(',') if _]

    elif flagtype == 'str':
        return [_ for _ in flagval.split(',') if _]

    else:
        raise Exception("incorrect type")
1104127
def flags(self, index):
        """"""
        if not index.isValid():
            return Qt.ItemIsEnabled
        column = index.column()
        if column in [0, 1, 2, 3]:
            return Qt.ItemFlags(Qt.ItemIsEnabled)
        else:
            return Qt.ItemFlags(Qt.NoItemFlags)
105461
def add_flag_values(self, entry, flag):
        '''  '''
        if flag in self.flags:
            self.flags[flag].append(entry)