Assign *value* to the boolean child *name* of `w:rPr`.
558490
def _set_bool_prop(self, name, value):
        
        rPr = self._element.get_or_add_rPr()
        rPr._set_bool_val(name, value)
691508
def _set(self, value):
    """"""
    if self.__is_parent_node():
      for child in self.__sub_counters.itervalues():
        child._set(value)
    else:
      self.__counter = value
1004349
def conditional_assignment(variable, value, bool = true)
      variable.reference_amount += 1

      if current_scope.has_definition?(variable.type, variable.name) == bool
        variable.value = value

        current_scope.add_definition(variable)

        buffer_assignment_value(variable.value)
      end
    end
113991
def set(self, value, parse=False):
        
        self.value = self.parse(value) if parse else value
891183
def DEFINE_boolean(flag_name, default_value, docstring):  # pylint: disable=invalid-name
    

    # Register a custom function for 'bool' so --flag=True works.
    def str2bool(bool_str):
        """Return a boolean value from a give string."""
        return bool_str.lower() in ('true', 't', '1')

    get_context_parser().add_argument(
        '--' + flag_name,
        nargs='?',
        const=True,
        help=docstring,
        default=default_value,
        type=str2bool)

    # Add negated version, stay consistent with argparse with regard to
    # dashes in flag names.
    get_context_parser().add_argument(
        '--no' + flag_name,
        action='store_false',
        dest=flag_name.replace('-', '_'))
266376
def visit_Assign(self, node):
        
        value_deps = self.visit(node.value)
        for target in node.targets:
            name = get_variable(target)
            if isinstance(name, ast.Name):
                self.naming[name.id] = value_deps
1279915
def set(self, name, value=True):
        ""
        setattr(self, name.lower(), value)
644145
def on_boolop(self, node):    # ('op', 'values')
        """"""
        val = self.run(node.values[0])
        is_and = ast.And == node.op.__class__
        if (is_and and val) or (not is_and and not val):
            for n in node.values[1:]:
                val = op2func(node.op)(val, self.run(n))
                if (is_and and not val) or (not is_and and val):
                    break
        return val
859079
def assert_bool(dist, attr, value):
    """"""
    if bool(value) != value:
        tmpl = "{attr!r} must be a boolean value (got {value!r})"
        raise DistutilsSetupError(tmpl.format(attr=attr, value=value))
394926
public void setFormValue(Object value) {

        if (value instanceof Boolean) {
            Boolean boolValue = (Boolean)value;
            setChecked(boolValue.booleanValue());
        }
    }
817539
def _cast_boolean(self, value):
        
        if value.lower() not in self._BOOLEANS:
            raise ValueError('Not a boolean: %s' % value)

        return self._BOOLEANS[value.lower()]
1103342
function Boolean(value) {
	spec.Asn1Spec.call(this, new spec.Asn1Tag(spec.TagClass.Universal, spec.TagFormat.Primitive, UniversalTag.Boolean));
	this.value = value || false;
}
1308041
def newNsProp(self, ns, name, value):
        
        if ns is None: ns__o = None
        else: ns__o = ns._o
        ret = libxml2mod.xmlNewNsProp(self._o, ns__o, name, value)
        if ret is None:raise treeError('xmlNewNsProp() failed')
        __tmp = xmlAttr(_obj=ret)
        return __tmp
475284
def loop(self, value):
		
		if not type(value) == bool:
			raise TypeError("can only be True or False")
		self._loop = value
792466
def false_repr(self, value):
        """"""
        if isinstance(value, str):
            if not (value.lower().startswith('f') or
                    value.lower().startswith('.f')):
                raise ValueError("Logical false representation must start "
                                 "with 'F' or '.F'.")
            else:
                self._logical_repr[0] = value
        else:
            raise TypeError('Logical false representation must be a string.')
27878
def parse_bool(name, value)
      if ['1', 'true', 'enabled'].include?(value.downcase)
        true
      elsif ['0', 'false'].include?(value.downcase)
        false
      else
        raise ArgumentError.new("#{value} is not a valid boolean for #{name.to_s.upcase}")
      end
    end
1014529
def set_runtime_value_bool(self, resourceid: int, value: bool) -> bool:
        """"""
        if value:
            boolvalue = "true"
        else:
            boolvalue = "false"

        payload = """
            <setResourceValue1 xmlns=\"utcs\"
            xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">
            <value i:type=\"a:WSBooleanValue\" xmlns:a=\"utcs.values\">
            <a:value>{value}</a:value></value>
            <typeString/>
            <resourceID>{id}</resourceID>
            <isValueRuntime>true</isValueRuntime>
            </setResourceValue1>
            """.format(id=resourceid, value=boolvalue)
        xdoc = self.connection.soap_action('/ws/ResourceInteractionService',
                                           'setResourceValue', payload)
        if xdoc:
            result = xdoc.find(r'./SOAP-ENV:Body/ns1:setResourceValue2',
                               IHCSoapClient.ihcns).text
            return result == "true"
        return False