The underline type corresponding to the ``w:val`` attribute value.
163368
def val(self):
        
        val = self.get(qn('w:val'))
        underline = WD_UNDERLINE.from_xml(val)
        if underline == WD_UNDERLINE.SINGLE:
            return True
        if underline == WD_UNDERLINE.NONE:
            return False
        return underline
1351205
def wrap(self, value):
        ''' '''
        self.validate_wrap(value)
        return self.computed_type.wrap(value)
56173
function formatValue(value) {
		
		var out;
		var type = util.sType(value);
		
		// if there is a type, check all sub items for types
		if (_.has(value, 'attributes.type') && _.has(value, '$value') && _.keys(value).length === 2) {
			out = util.moRef(value);
		}
		else if (type) {
			if (util.isArray(value)) {
				out = [];
				
				var subtype = type;
				
				if (subtype.match(/^ArrayOf/)) {
					subtype = subtype.replace(/^ArrayOf/, '');

					if (!Array.isArray(_.get(value, subtype)) && value[subtype]) {
						value[subtype] = [value[subtype]];
					}
				}
				
				_.forEach(value[_.keys(value)[1]], function(obj) {
					out.push(formatValue(obj));
				});
			}
			else if (util.isBoolean(value)) {
				
				// check for valid true values, otherwise false
				if (_.includes(['1', 'true'], _.lowerCase(value.$value))) {
					out = true;
				}
				else {
					out = false;
				}
			}
			else if (util.isInt(value)) {
				out = Number(value.$value);
			}
			else if (_.has(value, '$value')) {
				out = value.$value;
			}
			else {
				out = formatValue(_.omit(value, 'attributes'));
			}
			
		}
		else if (Array.isArray(value)) {
			out = [];
			_.forEach(value, function(val) {
				if (util.sType(val) || util.isArray(val) || util.hasKeys(val)) {
					out.push(formatValue(val));
				}
				else {
					out.push(cast(val));
				}
			});
		}
		else if (util.hasKeys(value)) {
			out = {};
			_.forEach(value, function(val, key) {
				if (util.sType(val) || util.isArray(val) || util.hasKeys(val)) {
					out[key] = formatValue(val);
				}
				else {
					out[key] = cast(val);
				}
			});
		}
		else {
			out = cast(value);
		}
		return out;
	}
749477
def pwa(self, val, wa='WARN'):
        
        self.pstd(self.color.yellow('{}: {}'.format(val, wa)))
1016888
def widgetValue( widget ):
    
    for wtype in reversed(_widgetValueTypes):
        if isinstance(widget, wtype[0]):
            try:
                return (wtype[1](widget), True)
            except:
                return (None, False)
    return (None, False)
251382
def opacity(self, value):
        

        if value is not None:
            assert type(value) in (int, float), "'{0}' attribute: '{1}' type is not 'int' or 'float'!".format("opacity",
                                                                                                              value)
        if value > 1:
            value = 1
        elif value < 0:
            value = 0

        self.__opacity = float(value)
        self.__set_style_sheet()
637621
def _value_is_type_text(val):
    
    if ((u'type' in val.keys()) and
            (val['type'].lower() == u"text")):
        return True
    return False
1141496
def format_property_value(attr, type)
      return unless send(attr.to_sym).present?

      case type.to_sym
      when :integer
        send("#{attr.to_sym}=", send(attr.to_sym).to_i)
      when :float
        send("#{attr.to_sym}=", send(attr.to_sym).to_f)
      when :boolean
        send("#{attr.to_sym}=", ActiveModel::Type::Boolean.new.cast(send(attr.to_sym)))
      else
        raise ArgumentError, 'Supported types are :boolean, :integer, :float'
      end
    end
203165
function renderInlines(val, indent) {
  const indentStr = Array(indent + 1).join(' ');
  return '\n' + map(orderBy(val, first), (pair) =>
    [
      `${indentStr}${pair[0]} {
${exports.renderDefinition(pair[1], indent + 2)}
${indentStr}}`,
    ].join('\n')
  ).join('\n\n');
}
171047
def pattern(self, value):
        

        if value is not None:
            assert type(value) in (unicode, QString), \
                "'{0}' attribute: '{1}' type is not 'unicode' or 'QString'!".format("pattern", value)
        self.__pattern = value
323278
def underline_style_attribute(styles={})
      return nil if styles.nil?
      value = styles[:underline_style]
      return underline_style_value(value) if value.is_a? Symbol
      if value.is_a? Array
        bitsauce = 0
        value.each { |s| bitsauce |= underline_style_value(s) }
        bitsauce
      else
        nil
      end
    end
874354
def pretty_value(value, starting_col = 0, indent_wrapped_lines = 6, width = Terminal.width)
      # inspected = value.inspect

      # note that if the first line overflows due to the starting column then pp won't wrap it right
      inspected = PP.pp(value, "", width - starting_col).chomp

      # this bit might be redundant with the pp call now
      indented = indent_all(6, inspected)
      if width
        wrap_and_indent(indented, starting_col, indent_wrapped_lines, width)
      else
        indented
      end
    end
195441
private String getValueTypeDotString() {
        PlanNodeType pnt = getPlanNodeType();
        if (isInline()) {
            return "fontcolor=\"white\" style=\"filled\" fillcolor=\"red\"";
        }
        if (pnt == PlanNodeType.SEND || pnt == PlanNodeType.RECEIVE || pnt == PlanNodeType.MERGERECEIVE) {
            return "fontcolor=\"white\" style=\"filled\" fillcolor=\"black\"";
        }
        return "";
    }
1231839
def looks_like_implicit_value(v):
    """"""
    assert isinstance(v, basestring)
    if feature.is_implicit_value(v):
        return 1
    else:
        split = v.split("-")
        if feature.is_implicit_value(split[0]):
            return 1

    return 0
876831
def line(self, value):
        
        if value == self._defaults['line'] and 'line' in self._values:
            del self._values['line']
        else:
            self._values['line'] = value
270231
def _guess_type(val):
        """"""
        if isinstance(val, bool):
            return "choice"
        elif isinstance(val, int):
            return "number"
        elif isinstance(val, float):
            return "number"
        elif isinstance(val, str):
            return "text"
        elif hasattr(val, 'read'):
            return "file"
        else:
            return "text"
27096
def wrap(self, value):
        ''' 
        '''
        self.validate_wrap(value)
        return self.item_type.wrap(value)