Parses <DerivedParameter>

        @param node: Node containing the <DerivedParameter> element
        @type node: xml.etree.Element
5769
def parse_derived_parameter(self, node):
        

        #if self.current_context.context_type != Context.COMPONENT_TYPE:
        #    self.raise_error('Dynamics must be defined inside a ' +
        #                     'component type')

        if 'name' in node.lattrib:
            name = node.lattrib['name']
        else:
            self.raise_error('A derived parameter must have a name')

        if 'dimension' in node.lattrib:
            dimension = node.lattrib['dimension']
        else:
            dimension = None

        if 'value' in node.lattrib:
            value = node.lattrib['value']
        else:
            value = None

        if 'select' in node.lattrib:
            select = node.lattrib['select']
        else:
            select = None

        self.current_component_type.add_derived_parameter(DerivedParameter(name, value,
                                                                    dimension, select))
1357521
def parse_xml(self, node):
        
        self._set_properties(node)
        self.name = node.get('name', None)
        self.opacity = node.get('opacity', self.opacity)
        self.visible = node.get('visible', self.visible)
        image_node = node.find('image')
        self.source = image_node.get('source', None)
        self.trans = image_node.get('trans', None)
        return self
1224809
def parse_xml_node(self, node):
        '''

        '''
        self.connector_id = node.getAttributeNS(RTS_NS, 'connectorId')
        self.name = node.getAttributeNS(RTS_NS, 'name')
        self.data_type = node.getAttributeNS(RTS_NS, 'dataType')
        self.interface_type = node.getAttributeNS(RTS_NS, 'interfaceType')
        self.data_flow_type = node.getAttributeNS(RTS_NS, 'dataflowType')
        if node.hasAttributeNS(RTS_NS, 'subscriptionType'):
            self.subscription_type = node.getAttributeNS(RTS_NS,
                                                         'subscriptionType')
        else:
            self.subscription_type = ''
        if node.hasAttributeNS(RTS_NS, 'pushInterval'):
            self.push_interval = float(node.getAttributeNS(RTS_NS,
                                                           'pushInterval'))
        else:
            self.push_interval = 0.0
        self.comment = node.getAttributeNS(RTS_EXT_NS, 'comment')
        if node.hasAttributeNS(RTS_EXT_NS, 'visible'):
            visible = node.getAttributeNS(RTS_EXT_NS, 'visible')
            if visible == 'true' or visible == '1':
                self.visible = True
            else:
                self.visible = False

        if node.getElementsByTagNameNS(RTS_NS, 'sourceDataPort').length != 1:
            raise InvalidDataPortConnectorNodeError
        self.source_data_port = TargetPort().parse_xml_node(\
                node.getElementsByTagNameNS(RTS_NS, 'sourceDataPort')[0])
        if node.getElementsByTagNameNS(RTS_NS, 'targetDataPort').length != 1:
            raise InvalidDataPortConnectorNodeError
        self.target_data_port = TargetPort().parse_xml_node(\
                node.getElementsByTagNameNS(RTS_NS, 'targetDataPort')[0])
        for c in get_direct_child_elements_xml(node, prefix=RTS_EXT_NS,
                                               local_name='Properties'):
            name, value = parse_properties_xml(c)
            self._properties[name] = value
        return self
930682
def parse(node)
      node.attributes.each do |key, value|
        case key
        when 'relativeFrom'
          @relative_from = value_to_symbol(value)
        end
      end

      node.xpath('*').each do |preset_geometry_child|
        case preset_geometry_child.name
        when 'pctHeight'
          @height = PictureDimension.new(parent: self).parse(preset_geometry_child)
        end
      end

      self
    end
1169546
def parse_xml_node(self, node):
        '''

        '''
        self.id = node.getAttributeNS(RTS_NS, 'id')
        self._config_data = []
        for d in node.getElementsByTagNameNS(RTS_NS, 'ConfigurationData'):
            self._config_data.append(ConfigurationData().parse_xml_node(d))
        return self
462267
protected void parse(Node node) {
		parsed = true;
		NodeList childNodes = node.getChildNodes();
		for (int i = 0; i < childNodes.getLength(); i++) {
			Node child = childNodes.item(i);
			String nodeName = child.getNodeName();
			if ("Name".equalsIgnoreCase(nodeName)) {
				name = getValueRecursive(child);
			} else if ("Title".equalsIgnoreCase(nodeName)) {
				title = getValueRecursive(child);
			} else if ("Abstract".equalsIgnoreCase(nodeName)) {
				abstractt = getValueRecursive(child);
			} else if ("Keywords".equalsIgnoreCase(nodeName)) {
				addKeyWords(child);
			} else if ("SRS".equalsIgnoreCase(nodeName)) {
				defaultCrs = getValueRecursive(child);
			} else if ("LatLongBoundingBox".equalsIgnoreCase(nodeName)) {
				addLatLonBoundingBox(child);
			}
		}
	}
739666
@Override
	protected void parse(Node node) {
		NamedNodeMap attributes = node.getAttributes();
		order = getValueRecursiveAsInteger(attributes.getNamedItem("order"));
		unitsPerPixel = getValueRecursiveAsDouble(attributes.getNamedItem("units-per-pixel"));
		href = getValueRecursive(attributes.getNamedItem("href"));
		setParsed(true);
	}
865753
def parse(node)
      node.xpath('*').each do |node_child|
        case node_child.name
        when 'alias'
          @alias = ValuedChild.new(:string, parent: self).parse(node_child)
        when 'tag'
          @tag = ValuedChild.new(:string, parent: self).parse(node_child)
        when 'lock'
          @lock = ValuedChild.new(:symbol, parent: self).parse(node_child)
        end
      end
      self
    end
1257712
@Override
	protected void parse(Node node) {
		NamedNodeMap attributes = node.getAttributes();
		width = getValueRecursiveAsInteger(attributes.getNamedItem("width"));
		height = getValueRecursiveAsInteger(attributes.getNamedItem("height"));
		mimeType = getValueRecursive(attributes.getNamedItem("mime-type"));
		extension = getValueRecursive(attributes.getNamedItem("extension"));
		setParsed(true);
	}
219155
def parse(node)
      node.xpath('*').each do |node_child|
        case node_child.name
        when 'blip'
          @blip = Blip.new(parent: self).parse(node_child)
        when 'stretch'
          @stretch = Stretch.new(parent: self).parse(node_child)
        end
      end
      self
    end
1050127
protected boolean readFeatureParameters(Element node){
		try{
			NodeList childrent = node.getChildNodes();
			cpnames = new Vector<String>();
			paras = new Vector<Vector<Integer>>();
			
			for (int i = 0; i < childrent.getLength(); i++)
				if (childrent.item(i) instanceof Element) {
					Element child = (Element) childrent.item(i);
					String value = child.getAttribute("value");
					
					//parse the value and get the parameters
					String [] parastr = value.split(":");
					Vector<Integer> para = new Vector<Integer>();
					for (int j = 3; j < parastr.length; ++j){
						para.add(Integer.parseInt(parastr[j]));
					}
					
					cpnames.add(parastr[2]);
					paras.add(para);
				}
			
		}
		catch (Exception e){
			System.out.println(e.getMessage());
			e.printStackTrace();
			return false;
		}
		return true;
	}
1032743
def parse_properties(node):
    
    d = dict()
    for child in node.findall('properties'):
        for subnode in child.findall('property'):
            cls = None
            try:
                if "type" in subnode.keys():
                    module = importlib.import_module('builtins')
                    cls = getattr(module, subnode.get("type"))
            except AttributeError:
                logger.info("Type [} Not a built-in type. Defaulting to string-cast.")
            d[subnode.get('name')] = cls(subnode.get('value')) if cls is not None else subnode.get('value')
    return d
840180
def parse_xml_node(self, node):
        '''

        '''
        super(WaitTime, self).parse_xml_node(node)
        wait_time_nodes = node.getElementsByTagNameNS(RTS_NS, 'WaitTime')
        if wait_time_nodes.length != 1:
            raise InvalidParticipantNodeError
        self.wait_time = int(wait_time_nodes[0].getAttributeNS(RTS_NS,
                'waitTime'))
        return self
79641
def parse(node)
      @file_reference = FileReference.new(parent: self).parse(node)
      @name = node.attribute('name').value
      self
    end
517628
def parse(node)
      node.xpath('*').each do |node_child|
        case node_child.name
        when 'delete'
          @display = false if node_child.attribute('val').value == '1'
        when 'title'
          @title = ChartAxisTitle.new(parent: self).parse(node_child)
        when 'majorGridlines'
          @major_grid_lines = true
        when 'minorGridlines'
          @minor_grid_lines = true
        when 'scaling'
          @scaling = Scaling.new(parent: self).parse(node_child)
        when 'tickLblPos'
          @tick_label_position = ValuedChild.new(:symbol, parent: self).parse(node_child)
        when 'axPos'
          @position = value_to_symbol(node_child.attribute('val'))
        end
      end
      @display = false unless @title.visible?
      self
    end
748579
def parse(node, unit = :dxa)
      node.attributes.each do |key, value|
        case key
        when 'top'
          @top = OoxmlSize.new(value.value.to_f, unit)
        when 'left'
          @left = OoxmlSize.new(value.value.to_f, unit)
        when 'right'
          @right = OoxmlSize.new(value.value.to_f, unit)
        when 'bottom'
          @bottom = OoxmlSize.new(value.value.to_f, unit)
        when 'header'
          @header = OoxmlSize.new(value.value.to_f, unit)
        when 'footer'
          @footer = OoxmlSize.new(value.value.to_f, unit)
        when 'gutter'
          @gutter = OoxmlSize.new(value.value.to_f, unit)
        end
      end
      self
    end
114105
def parse(node)
      node.xpath('*').each do |node_child|
        case node_child.name
        when 'shape'
          @type = :shape
          @data = OldDocxShape.new(parent: self).parse(node_child)
        when 'group'
          @type = :group
          @data = OldDocxGroup.new(parent: self).parse(node_child)
        when 'style'
          @style_number = node_child.attribute('val').value.to_i
        end
      end
      self
    end