Warning: invoked by the constructor. Registers known default attributes. Since processors registration might
override previous settings, this method - if overridden - should call super BEFORE registering new attributes (or
replacing the old ones).
185821
protected void registerAttributes() {
        // Building attributes. Parsed before actor creation.
        registerBuildingAttributes();

        // Regular attributes. Parsed after the actor is constructed.
        registerCommonAttributes();
        registerListenerAttributes();

        registerAnimatedImageAttributes();
        registerButtonAttributes();
        registerButtonGroupAttributes();
        registerContainerAttributes();
        registerDialogAttributes();
        registerHorizontalGroupAttributes();
        registerImageAttributes();
        registerLabelAttributes();
        registerListAttributes();
        registerProgressBarAttributes();
        registerScrollBarAttributes();
        registerSplitPaneAttributes();
        registerSelectBoxAttributes();
        registerTableAttributes();
        registerTextFieldAttributes();
        registerTooltipAttributes();
        registerTouchpadAttributes();
        registerTreeAttributes();
        registerVerticalGroupAttributes();
        registerWindowAttributes();
    }
161120
public SerializerRegistry registerDefault(Class<?> baseType, Class<? extends TypeSerializer> serializer) {
    return registerDefault(baseType, new DefaultTypeSerializerFactory(serializer));
  }
1328904
private void init(){
	
		if(!Annotation.isInheritedMapped(configuredClass))
			Error.classNotMapped(configuredClass);
		
		for (Class<?> classe :getClasses()){
			relationalManyToOneMapper.put(classe.getName(), new JMapper(configuredClass, classe,ChooseConfig.DESTINATION));
			relationalOneToManyMapper.put(classe.getName(), new JMapper(classe, configuredClass,ChooseConfig.SOURCE));
		}
	}
1163562
private void addAttributes(ConfiguratorRegistration configuratorRegistration, String group) {
        // if group == null; group = "DEFAULT_GROUP"
        if (StringUtils.isNotEmpty(group)) {
            configuratorRegistration.setGroup(group);
        }

    }
666839
def _attribute_default(attribute_name)
      default = self.class.attributes[attribute_name][:default]

      case
      when default.respond_to?(:call) then instance_exec(&default)
      when default.duplicable? then default.dup
      else default
      end
    end
665620
function Attribute(config) {
        var self = this, c = self.constructor;    // save user config
        // save user config
        self.userConfig = config;    // define
        // define
        while (c) {
            addAttrs(self, c.ATTRS);
            c = c.superclass ? c.superclass.constructor : null;
        }    // initial attr
        // initial attr
        initAttrs(self, config);
    }
422378
def register(self, klass, callback, name="default"):
        
        if klass not in self._definitions:
            self._definitions[klass] = {}

        self._definitions[klass][name] = callback
1119716
def _init(self, *args, **kwargs):
        
        self._init_attr('_deps', None)

        self._init_attr('_ban_optimize', False)
        self._init_attr('_engine', None)
        self._init_attr('_Expr__execution', None)

        self._init_attr('_need_cache', False)
        self._init_attr('_mem_cache', False)

        if '_id' not in kwargs:
            kwargs['_id'] = new_id()

        super(Expr, self)._init(*args, **kwargs)
274124
def initialize_attributes(attributes)
      @_attributes = attributes
      attributes.each do |key, value|
        send("#{key}=", value) if respond_to? key
      end
    end
983796
def assign_attributes(attrs, initial_setup = false, skip_changes = false)
      attrs = wrap_values(attrs)

      if attrs
        # When doing a mass-assign, we don't validate or save until the end.
        if initial_setup || skip_changes
          Model.no_change_tracking do
            assign_all_attributes(attrs, skip_changes)
          end
        else
          assign_all_attributes(attrs)
        end
      else
        # Assign to empty
        @attributes = {}
      end

      # Trigger and change all
      @deps.changed_all!
      @deps = HashDependency.new

      run_initial_setup(initial_setup)
    end
766697
def new_registry(attribute=None):
    
    registry = {}

    def register(key):
        def decorator(func):
            registry[key] = func
            if attribute:
                setattr(func, attribute, key)
            return func
        return decorator

    return registry, register
880403
def set_default(self_,param_name,value):
        
        cls = self_.cls
        setattr(cls,param_name,value)
815958
protected function registerDefaultProviders() {

		array_map( function( $provider ) {
			$this->provider( $provider );
		}, [
			AttrServiceProvider::class,
			LanguageServiceProvider::class,
			MetaServiceProvider::class,
			TemplatesServiceProvider::class,
			HierarchyServiceProvider::class,
			ViewServiceProvider::class
		] );
	}
1372166
def initialize_attributes(caller, raw)
      # Save the interface and parent
      write_attribute(:parent, caller)
      write_attribute(:interface, raw)

      # Load the attributes from the interface
      load_interface_attributes(interface)

      # Get the relationships setup
      populate_relationship(:network_interfaces, interface)

      # Clear dirty and mark as existing
      clear_dirty!
      existing_record!
    end
880653
function(attributes, options){
      var t = this;

      // Override instance level constants
      t.CONST = CONST;

      // This is the same as a PagesProbe except for the constants (above)
      PagesProbe.prototype.initialize.apply(t, arguments);
    }
630062
@PostConstruct
	public void initialize() {
		logger.debug("Initializing " + this.getClass().getSimpleName() + "(" + System.identityHashCode(this) + ")");

		attributesMap = Collections.synchronizedMap(new HashMap<String, Object>());
	}
1073911
@PostConstruct
	@SuppressWarnings("unchecked")
	protected void configure() {

		// scan all fields
		for (Field field : getClass().getDeclaredFields()) {

			// if it's a preprocessor, register it
			if (IModifier.class.isAssignableFrom(field.getType())) {

				try {
					field.setAccessible(true);
					final IModifier processor = (IModifier) field.get(this);
					processorsCache.put(processor.getAnnotationType(), processor);
				} catch (IllegalArgumentException | IllegalAccessException ex) {
					LoggerFactory.getLogger(ModifiersPreprocessor.class) .error("Could not register pre-processor for field " + field.getName());
				}
			}
		}
	}