Loads all the existing restrictions to the attribute class.
491578
private static void loadRestrictionsToAttribute(XsdAttribute attribute, MethodVisitor mVisitor, String javaType, boolean hasEnum) {
        getAttributeRestrictions(attribute).forEach(restriction -> loadRestrictionToAttribute(mVisitor, restriction, javaType, hasEnum ? 1 : 0));

        mVisitor.visitInsn(RETURN);
        mVisitor.visitMaxs(4, hasEnum ? 2 : 1);
        mVisitor.visitEnd();
    }
1025544
def _load_base_class_fields(new_class, bases, attrs):
        
        for base in reversed(bases):
            if hasattr(base, 'meta_') and \
                    hasattr(base.meta_, 'declared_fields'):
                base_class_fields = {
                    field_name: field_obj for (field_name, field_obj)
                    in base.meta_.declared_fields.items()
                    if field_name not in attrs and not field_obj.identifier
                }
                new_class._load_fields(base_class_fields)
271470
private void setRestrictedAttributes(Map<String, String> attributes) {

        // Translate disabled attribute
        getModel().setDisabled("true".equals(attributes.get(DISABLED_ATTRIBUTE_NAME)));

        // Translate password expired attribute
        getModel().setExpired("true".equals(attributes.get(EXPIRED_ATTRIBUTE_NAME)));

        // Translate access window start time
        try { getModel().setAccessWindowStart(parseTime(attributes.get(ACCESS_WINDOW_START_ATTRIBUTE_NAME))); }
        catch (ParseException e) {
            logger.warn("Not setting start time of user access window: {}", e.getMessage());
            logger.debug("Unable to parse time attribute.", e);
        }

        // Translate access window end time
        try { getModel().setAccessWindowEnd(parseTime(attributes.get(ACCESS_WINDOW_END_ATTRIBUTE_NAME))); }
        catch (ParseException e) {
            logger.warn("Not setting end time of user access window: {}", e.getMessage());
            logger.debug("Unable to parse time attribute.", e);
        }

        // Translate account validity start date
        try { getModel().setValidFrom(parseDate(attributes.get(VALID_FROM_ATTRIBUTE_NAME))); }
        catch (ParseException e) {
            logger.warn("Not setting user validity start date: {}", e.getMessage());
            logger.debug("Unable to parse date attribute.", e);
        }

        // Translate account validity end date
        try { getModel().setValidUntil(parseDate(attributes.get(VALID_UNTIL_ATTRIBUTE_NAME))); }
        catch (ParseException e) {
            logger.warn("Not setting user validity end date: {}", e.getMessage());
            logger.debug("Unable to parse date attribute.", e);
        }

        // Translate timezone attribute
        getModel().setTimeZone(TimeZoneField.parse(attributes.get(TIMEZONE_ATTRIBUTE_NAME)));

    }
109516
protected function initializeAttributes() {

		parent::initializeAttributes();

		$this->attributes['subtype'] = self::SUBTYPE;
		$this->attributes['access_id'] = ACCESS_PUBLIC;
	}
399791
def load(attributes)
      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
      @prefix_options, attributes = split_options(attributes)
      attributes.each do |key, value|
        @attributes[key.to_s] = typecast_attribute_value(key, value)
      end
      self
    end
856538
protected void registerContainerAttributes() {
        addAttributeProcessor(new ContainerAdjustPaddingLmlAttribute(), "adjustPadding");
        addAttributeProcessor(new ContainerAlignLmlAttribute(), "align");
        addAttributeProcessor(new ContainerBackgroundLmlAttribute(), "bg", "background");
        addAttributeProcessor(new ContainerClipLmlAttribute(), "clip");
        addAttributeProcessor(new ContainerFillLmlAttribute(), "fill");
        addAttributeProcessor(new ContainerFillXLmlAttribute(), "fillX");
        addAttributeProcessor(new ContainerFillYLmlAttribute(), "fillY");
        addAttributeProcessor(new ContainerHeightLmlAttribute(), "height");
        addAttributeProcessor(new ContainerMaxHeightLmlAttribute(), "maxHeight");
        addAttributeProcessor(new ContainerMaxSizeLmlAttribute(), "maxSize");
        addAttributeProcessor(new ContainerMaxWidthLmlAttribute(), "maxWidth");
        addAttributeProcessor(new ContainerMinHeightLmlAttribute(), "minHeight");
        addAttributeProcessor(new ContainerMinSizeLmlAttribute(), "minSize");
        addAttributeProcessor(new ContainerMinWidthLmlAttribute(), "minWidth");
        addAttributeProcessor(new ContainerPrefHeightLmlAttribute(), "prefHeight");
        addAttributeProcessor(new ContainerPrefSizeLmlAttribute(), "prefSize");
        addAttributeProcessor(new ContainerPrefWidthLmlAttribute(), "prefWidth");
        addAttributeProcessor(new ContainerRoundLmlAttribute(), "round");
        addAttributeProcessor(new ContainerSizeLmlAttribute(), "size");
        addAttributeProcessor(new ContainerWidthLmlAttribute(), "width");
    }
173053
def load(self):
        """"""
        module = importlib.import_module(self.import_path)
        if self.attr:
            return getattr(module, self.attr)
        return module
1142731
public void addAll(Attributes incoming) {
        if (incoming.size() == 0)
            return;
        checkCapacity(size + incoming.size);

        for (Attribute attr : incoming) {
            // todo - should this be case insensitive?
            put(attr);
        }

    }
99690
protected void initializeAttributeIndices() {
    //m_AttributeIndices.setUpper(m_Data.numAttributes() - 1);
    m_ActiveIndices = new boolean[m_Data.numAttributes()];
    for (int i = 0; i < m_ActiveIndices.length; i++)
      m_ActiveIndices[i] = true; //m_AttributeIndices.isInRange(i);
  }
813006
def _load_all(self):
        '''
        
        '''
        with self._lock:
            for name in self.file_mapping:
                if name in self.loaded_files or name in self.missing_modules:
                    continue
                self._load_module(name)

            self.loaded = True
1055480
protected void loadAttributes()
    {
        try {
            if (!HTMLNorm.getAttribute(el, "span").equals(""))
                span = Integer.parseInt(HTMLNorm.getAttribute(el, "span"));
            else
                span = 1;
        } catch (NumberFormatException e) {
            log.warn("Invalid span value: " + HTMLNorm.getAttribute(el, "span"));
        }
        setSpecifiedWidth(HTMLNorm.getAttribute(el, "width"));
    }
168930
def load(attributes)
      self.class.reload_fields_definition(false)
      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
      @associations ||= {}
      @attributes ||= {}
      @loaded_associations = {}
      attributes.each do |key, value|
        self.send "#{key}=", value if self.respond_to?("#{key}=")
      end
      self
    end
1320063
private function fill()
    {
        foreach ($this->attributes as $key => $value) {
            $key = $this->camelCase($key);

            $this->{$key} = $value;
        }
    }
1128599
protected final void load()throws Exception
	{
		synchronized (this) {
			Set<Class<?>> classes=classProvider.getLoadedClasses();
			initScriptClasses(classes);
			onScriptLoaded(classes);
		}
	}
784052
def _load(self):
        """"""
        for attr_name, config_prop in self._iter_config_props():
            found = False
            for loader in self._loaders:
                if loader.exists(config_prop.property_key):
                    raw_value = loader.get(config_prop.property_key)
                    converted_value = config_prop.load(raw_value)

                    self._set_instance_prop(attr_name, config_prop, converted_value)
                    found = True
                    break

            if not found:
                if not config_prop.required or config_prop.default is not None:
                    self._set_instance_prop(attr_name, config_prop, config_prop.default)
                else:
                    raise ValueError('Missing required ConfigProperty {}'.format(attr_name))
1303809
def _loadChildRules(context, xmlElement, attributeToFormatMap):
    
    rules = []
    for ruleElement in xmlElement.getchildren():
        if not ruleElement.tag in _ruleClassDict:
            raise ValueError("Not supported rule '%s'" % ruleElement.tag)
        rule = _ruleClassDict[ruleElement.tag](context, ruleElement, attributeToFormatMap)
        rules.append(rule)
    return rules
210117
def _init_optional_attrs(optional_attrs):
        """"""
        if optional_attrs is None:
            return None
        opts = OboOptionalAttrs.get_optional_attrs(optional_attrs)
        if opts:
            return OboOptionalAttrs(opts)