Add a child ``<Override>`` element with attributes set to parameter
        values.
968522
def add_override(self, partname, content_type):
        
        override = CT_Override.new(partname, content_type)
        self.append(override)
238270
def fill_attrs(self, attrs):
        """"""
        for trname, attrname in self.transitions_at.items():

            implem = self.implementations[trname]

            if attrname in attrs:
                conflicting = attrs[attrname]
                if not self._may_override(implem, conflicting):
                    raise ValueError(
                        "Can't override transition implementation %s=%r with %r" %
                        (attrname, conflicting, implem))

            attrs[attrname] = implem
        return attrs
865339
def apply_overrides(request, omap):
        
        if omap:
            for k, v in omap.iteritems():
                o = request.GetElement('overrides').AppendElment()
                o.SetElement('fieldId', k)
                o.SetElement('value', v)
1102029
public static <S extends Node, E extends Event> void installOverride(InputMapTemplate<S, E> imt, S node) {
        Nodes.addInputMap(node, imt.instantiate(node));
    }
792285
def _add_getter(self):
        
        property_ = property(self._getter, None, None)
        # assign unconditionally to overwrite element name definition
        setattr(self._element_cls, self._prop_name, property_)
904174
def _override_options(options, **overrides):
    """"""
    for opt, val in overrides.items():
        passed_value = getattr(options, opt, _Default())
        if opt in ('ignore', 'select') and passed_value:
            value = process_value(opt, passed_value.value)
            value += process_value(opt, val)
            setattr(options, opt, value)
        elif isinstance(passed_value, _Default):
            setattr(options, opt, process_value(opt, val))
1043509
def _set_element_property(parent_to_parse, element_path, prop_name, value):
    

    element = get_element(parent_to_parse)

    if element is None:
        return None

    if element_path and not element_exists(element, element_path):
        element = insert_element(element, 0, element_path)

    if not isinstance(value, string_types):
        value = u''

    setattr(element, prop_name, value)

    return element
1203463
public static Optional<ExecutableElement> override(
      DeclaredType type, Types types, String methodName, TypeMirror... params) {
    return override(asElement(type), types, methodName, params);
  }
89690
def add_child(self, child):
        
        self.children.append(child)
        child.parent = self

        if self.view and self.view.is_loaded:
            self.view.dispatch({
                'name': 'append',
                'html': child.compile(),
                'selector': '#' + str(self.id)
            })
590137
def add(self, name, value):
        ''''''
        normalized_name = normalize_name(name, self._normalize_overrides)
        self._map[normalized_name].append(value)
650254
public static void appendElement(Element parent, Element child) {
        Node tmp = parent.getOwnerDocument().importNode(child, true);
        parent.appendChild(tmp);
    }
1065053
def add_attribute(self, attribute, value):
        
        class_name = self.__class__.__name__
        if class_name.startswith('ItemData'):
            # ItemData* Elements
            class_name = 'ItemData'
        if attribute not in MODMExtensionRegistry[class_name].value:
            raise ValueError("Can't add {} to {}".format(attribute, self.__class__.__name__))
        self.attributes.append(MODMAttribute(attribute, value))
280383
def add(self, child):
        

        if isinstance(child, Assign):
            self.add_assign(child)
        else:
            raise ModelError('Unsupported child element')
1124682
def add(self, child):
        

        if isinstance(child, With):
            self.add_with(child)
        elif isinstance(child, EventConnection):
            self.add_event_connection(child)
        elif isinstance(child, ChildInstance):
            self.add_child_instance(child)
        elif isinstance(child, MultiInstantiate):
            self.add_multi_instantiate(child)
        elif isinstance(child, ForEach):
            self.add_for_each(child)
        else:
            raise ModelError('Unsupported child element')
245850
def replaceWith(self, param):
        """"""
        i = self.parent().children().index(self)
        # TODO: transfer the children:
        p = self.parent()
        self.parent().removeChild(self)
        p.insertChild(i, param)
        self = param
1264290
def extend(self, **kwargs):
    """"""

    props = self.copy()
    props.update(kwargs)
    return TemplateData(**props)
125478
def addInParameter(self, name, type, namespace=None, element_type=0):
        """"""
        parameter = ParameterInfo(name, type, namespace, element_type)
        self.inparams.append(parameter)
        return parameter