Call this during initialization of
 objects that have a self_service subset
 and the self_service attributes will be populated
 (as primary attributes) from @init_data

 @return [void]
162344
def parse_self_service
      @self_service_data_config = SELF_SERVICE_CLASSES[self.class]

      subset_key = @self_service_data_config[:self_service_subset] ? @self_service_data_config[:self_service_subset] : :self_service

      ss_data = @init_data[subset_key]
      ss_data ||= {}

      @in_self_service = in_self_service_at_init?

      @self_service_description = ss_data[:self_service_description]

      @icon = JSS::Icon.new(ss_data[:self_service_icon]) if ss_data[:self_service_icon]

      @self_service_feature_on_main_page = ss_data[:feature_on_main_page]

      @self_service_categories = ss_data[:self_service_categories]
      @self_service_categories ||= []

      parse_self_service_profile ss_data

      return unless self_service_targets.include? :macos

      # Computers only...
      @self_service_display_name = ss_data[:self_service_display_name]
      @self_service_display_name ||= name
      @self_service_install_button_text = ss_data[:install_button_text]
      @self_service_reinstall_button_text = ss_data[:reinstall_button_text]
      @self_service_force_users_to_view_description = ss_data[:force_users_to_view_description]

      parse_self_service_notifications ss_data
    end
1150437
protected function init()
    {
        $structure = $this->imapFetchstructure();
        $this->structure = $structure;
        if (isset($structure->parts)) {
            $countSection = count($structure->parts);
            $this->countAttachment = $countSection - 1;
        }
        $this->getCountSection();
        $this->getHeader();
        $this->getAttachments();
        $this->getBody();
        if ($this->_decode === self::DECODE) {
            $this->decode();
        }
    }
1175818
def initialize_attributes(parent, inetwork)
      # Set the parent and interface
      write_attribute(:parent, parent)
      write_attribute(:interface, inetwork)

      # Load the interface attributes
      load_interface_attributes(inetwork)

      # Clear dirtiness, since this should only be called initially and
      # therefore shouldn't affect dirtiness
      clear_dirty!

      # But this is an existing record
      existing_record!
    end
733177
def _initialize_attributes(model_class, name, bases, attrs):
    """"""
    model_class._attributes = {}
    for k, v in attrs.iteritems():
        if isinstance(v, Attribute):
            model_class._attributes[k] = v
            v.name = v.name or k
702966
def init_contents
      self[:Contents] = self[:Contents][:referenced_object][:indirect_without_dictionary] if self[:Contents].is_a?(Hash) && self[:Contents][:referenced_object] && self[:Contents][:referenced_object].is_a?(Hash) && self[:Contents][:referenced_object][:indirect_without_dictionary]
      self[:Contents] = [self[:Contents]] unless self[:Contents].is_a?(Array)
      self[:Contents].delete(is_reference_only: true, referenced_object: { indirect_reference_id: 0, raw_stream_content: '' })
      # un-nest any referenced arrays
      self[:Contents].map! { |s| actual_value(s).is_a?(Array) ? actual_value(s) : s }
      self[:Contents].flatten!
      self[:Contents].compact!
      # wrap content streams
      insert_content 'q', 0
      insert_content 'Q'

      # Prep content
      @contents = ''
      insert_content @contents
      @contents
    end
1006902
def marshal_load(data)
      values, opts = data
      initialize(values[:id])
      initialize_from(values, opts)
    end
332433
public function initialise()
    {
        $this->lti_context_id = null;
        $this->lti_resource_id = null;
        $this->title = '';
        $this->settings = [];
        $this->groupSets = null;
        $this->groups = null;
        $this->primary_consumer_key = null;
        $this->primary_resource_link_id = null;
        $this->share_approved = null;
        $this->created = null;
        $this->updated = null;
    }
665086
protected function onInit()
    {
        foreach ($this->params as $cName => $cParams) {
            if (gettype($cParams) == "array") {
                $bucket = Utility::get($cParams, "bucket");
                $formatString = Utility::get($cParams, "formatString");
                $this->params[$cName] = array(
                    "bucket" => $bucket,
                    "formatString" => $formatString ? $formatString : $this->defaultFormatString($bucket),
                );
            } else {
                //cParams now is bucket
                $this->params[$cName] = array(
                    "bucket" => $cParams,
                    "formatString" => $this->defaultFormatString($cParams),
                );

            }
        }
    }
1177040
def attributes(instance)
      definitions.values.each_with_object({}) do |item, obj|
        key = item.target
        val = instance.send(:instance_variable_get, item.ivar)
        obj[key] = val unless null == val
      end
    end
824172
protected void initServices() {
    initService(repositoryService);
    initService(runtimeService);
    initService(historyService);
    initService(identityService);
    initService(taskService);
    initService(formService);
    initService(managementService);
    initService(authorizationService);
    initService(caseService);
    initService(filterService);
    initService(externalTaskService);
    initService(decisionService);
    initService(optimizeService);
  }
357411
public function init()
    {
        // TODO: remove this when deprecated $replicators property is removed
        if ($this->replication_ids === null && $this->replicators !== null) {
            $this->replication_ids = array_keys($this->replicators);
        }

        if ($this->replication_ids === null) {
            $this->replication_ids = array(0);
        }

        // Remove children, these are now the prototype widgets
        foreach ($this->children as $child_widget) {
            $this->prototype_widgets[] = $this->remove($child_widget);
        }

        foreach ($this->replication_ids as $id) {
            $this->addReplication($id);
        }

        parent::init();
    }
1134408
@JRubyMethod
    public static IRubyObject initialize(IRubyObject self, IRubyObject type_id, IRubyObject val, IRubyObject style) {
        Ruby runtime = self.getRuntime();
        ThreadContext ctx = runtime.getCurrentContext();
        ((RubyObject)self).fastSetInstanceVariable("@kind", ((Node)self).x.scalar);
        self.callMethod(ctx, "type_id=", type_id);
        self.callMethod(ctx, "value=", val);
        self.callMethod(ctx, "style=", style);
        return self;
    }
207140
def init ( method )
      raise TypeError, error_message(method, __method__) unless method.instance_of? Method
      @init = method
    end
1096991
protected function initData()
    {
        parent::initData();
        array_walk($this->_data, function (&$indexConfigData, $indexName) {
            $indexConfigData = $this->initIndexConfig($indexName, $indexConfigData);
        });
    }
869168
def initialize(self):
    

    # Retrieve the necessary extra arguments that were handled automatically
    autoArgs = {name: getattr(self, name) for name in self._poolerArgNames}
    autoArgs["inputDimensions"] = [self._inputWidth]
    autoArgs["columnDimensions"] = [self._columnCount]
    autoArgs["potentialRadius"] = self._inputWidth
    autoArgs["historyLength"] = self._historyLength
    autoArgs["minHistory"] = self._minHistory

    # Allocate the pooler
    self._pooler = self._poolerClass(**autoArgs)
939604
def initialize_attributes(parent, inat)
      write_attribute(:parent, parent)
      write_attribute(:interface, inat)

      # Load the interface attributes associated with this model
      load_interface_attributes(inat)
      populate_relationships(inat)

      # Clear dirty and set as existing
      clear_dirty!
      existing_record!
    end
551658
def attributes
      (@original_attributes||{}).merge(@attributes).keys.inject({}) do |hash, key|
        hash[key] = read_attribute(key)
        hash
      end
    end