Loads the entities.
436105
public function load()
    {
        // Even though we can't confirm the entity has
        // been loaded, we should still inform the user.
        $this->logAutoloadedEntities();

        $configuration = $this->getConfiguration();
        if (count($configuration)) {
            foreach ($configuration as $cpt => $config) {
                $obj = CustomPostType::factory($cpt);

                $this->addWordpressRegisteringAction($obj);

                if ($this->shouldAddAdminMenus($obj)) {
                    $this->addWordpressMenusRegisteringAction($obj);
                }

                if ($this->shouldAddRoutes($obj)) {
                    $this->addResourceRoute($obj);
                }
            }

            // The second we register an internal CPT it becomes worth
            // looking for additional model routes.
            add_action('wp_loaded', array(new ModelRewriteRegistrar(), "onModelsActivated"), 5);
        }
    }
552530
def __get_entities(self, etype):
        """"""
        r = fapi.get_entities(self.namespace, self.name,
                              etype, self.api_url)
        fapi._check_response_code(r, 200)
        return [Entity(e['entityType'], e['name'], e['attributes'])
                for e in r.json()]
374472
public function loadFromSession()
    {
        $this->session = Instance::ensure($this->session, Session::className());
        if (isset($this->session[$this->cartId]))
            $this->setSerialized($this->session[$this->cartId]);
    }
148588
public function load()
    {
        $path = $this->manifestPath.'/collections.json';

        if ($this->files->exists($path) and is_array($manifest = json_decode($this->files->get($path), true)))
        {
            foreach ($manifest as $key => $entry)
            {
                $entry = new Entry($entry['fingerprints'], $entry['development']);

                $this->entries->put($key, $entry);
            }
        }
    }
544412
public function load()
    {
        $this->initialize();

        foreach ($this->dataSources as $name => $dataSource) {
            $dataSource->load();

            $this->processItems($dataSource->getItems(), $name);
            $this->processLayouts($dataSource->getLayouts(), $name);
            $this->processIncludes($dataSource->getIncludes(), $name);
        }
    }
586673
protected function loadAnnotatedModels()
    {
        if ($this->app->environment('local') && $this->scanWhenLocal) {
            $this->scanModels();
        }

        $scans = $this->modelScans();

        if (!empty($scans) && $this->finder->modelsAreScanned()) {
            $this->loadScannedModels();
        }
    }
841078
def load_entities(entity)
      Dir[globs[entity]].map do |file|
        require file
        klass_name =
          case namespace
          when String
            AutoRegistrationStrategies::CustomNamespace.new(
              namespace: namespace, file: file, directory: directory
            ).call
          when TrueClass
            AutoRegistrationStrategies::WithNamespace.new(
              file: file, directory: directory
            ).call
          when FalseClass
            AutoRegistrationStrategies::NoNamespace.new(
              file: file, directory: directory, entity: component_dirs.fetch(entity)
            ).call
          end

        Inflector.constantize(klass_name)
      end
    end
740126
private static EntityMetadata loadMetadata(Class<?> entityClass) {
    synchronized (entityClass) {
      EntityMetadata metadata = cache.get(entityClass);
      if (metadata == null) {
        EntityIntrospector introspector = new EntityIntrospector(entityClass);
        introspector.process();
        metadata = introspector.entityMetadata;
        cache.put(entityClass, metadata);
      }
      return metadata;
    }
  }
620443
def add_entity(self, entity):
        
        self._ensure_loaded()
        self.entities[str(entity)] = entity
1357974
@Override
	public void load(UnitDaoFactory unitDaoFactory) {
		for (String query : queries) {
			unitDaoFactory.getUnitDao().execute(query);
		}
	}
1210550
protected function load()
    {
        $tables = $this->fetchTables($this->schema);
        foreach ($tables as $table) {
            $blueprint = new Blueprint($this->connection->getName(), $this->schema, $table);
            $this->fillColumns($blueprint);
            $this->fillConstraints($blueprint);
            $this->tables[$table] = $blueprint;
        }
    }
498635
private function loadNativeServices(): void
    {
        // initialize memory and properties controllers
        self::$Memory = MemoryObject::instance();
        self::$Properties = new Properties();
        // initialize debugger
        if (isset($this->_services['Debug']) && $this->_services['Debug'] === true && Debug::isEnabled()) {
            self::$Debug = new Debug();
            $this->startMeasure(__METHOD__);
        }
        // prepare request data
        self::$Request = Request::createFromGlobals();
        // initialize response, securty translate and other workers
        self::$Security = new Security();
        self::$Response = new Response();
        self::$View = new View();
        self::$Translate = new Translate();
        self::$Alias = new Alias();
        self::$Event = new EventManager();
        self::$Cron = new CronManager();
        // stop debug timeline
        if (self::$Debug) {
            $this->stopMeasure(__METHOD__);
        }
    }
834685
private static void loadClientProperties(String propertiesPath, String clazzName,
            Map<?, Map<String, String>> clientProperties, Map<String, Map<String, String>> entityConfigurations)
    {

        InputStream inputStream = PropertyReader.class.getClassLoader().getResourceAsStream(propertiesPath);
        clientProperties = JsonUtil.readJson(inputStream, Map.class);

        if (clientProperties != null)
        {
            if (clientProperties.get("all") != null)
            {
                entityConfigurations.put(clazzName, clientProperties.get("all"));
            }
            else
            {

                Iterator iter = clientProperties.keySet().iterator();

                while (iter.hasNext())
                {
                    Object key = iter.next();
                    if (((String) key).indexOf(',') > 0)
                    {
                        StringTokenizer tokenizer = new StringTokenizer((String) key, ",");
                        while (tokenizer.hasMoreElements())
                        {
                            String token = tokenizer.nextToken();
                            entityConfigurations.put(token, clientProperties.get(key));
                        }
                    }
                    else
                    {
                        entityConfigurations.put((String) key, clientProperties.get(key));
                    }
                }
            }
        }

    }
28645
protected function loadFinalType()
	{
		foreach($this->databaseMapping as $entityMapping)
		{
			foreach($entityMapping['columns'] as $pos => $column)
			{
				if(!isset($this->finalTypes[$pos]))
				{
					if(isset($column['type']))
					{
						$this->finalTypes[$pos] = $column['type'];
					}
					else
					{
						$this->finalTypes[$pos] = null;
					}
				}
				elseif(isset($column['type']) && $this->finalTypes[$pos] != $column['type'])
				{
					$this->finalTypes[$pos] = Type::STRING;
				}
			}
		}
	}
1363833
def _load_entities(self):
        
        if not self._chat_peer:
            return True  # Nothing to load (e.g. MessageDeleted)

        self._chat, self._input_chat = self._get_entity_pair(self.chat_id)
        return self._input_chat is not None
1336542
private function load()
    {
        $this->locales->loadFromArray($this->getConfig('locales'));
        $this->setSupportedLocales($this->getConfig('supported-locales'));
        $this->setDefaultLocale();
    }
685147
private function loadIndexes(): void
    {
        if (null !== $this->gsi) {
            return;
        }

        $this->gsi = [];
        foreach ($this->getIndexes() as $gsi) {
            $this->gsi[$gsi->getAlias()] = $gsi;
        }
    }