Loads all data for layouts related to provided shared layout.
334610
public function loadRelatedLayoutsData(Layout $sharedLayout): array
    {
        $query = $this->getLayoutSelectQuery();

        $query->innerJoin(
            'l',
            'ngbm_zone',
            'z',
            $query->expr()->andX(
                $query->expr()->eq('z.layout_id', 'l.id'),
                $query->expr()->eq('z.status', 'l.status'),
                $query->expr()->eq('z.linked_layout_id', ':linked_layout_id')
            )
        )
        ->where(
            $query->expr()->andX(
                $query->expr()->eq('l.shared', ':shared'),
                $query->expr()->eq('l.status', ':status')
            )
        )
        ->setParameter('shared', false, Type::BOOLEAN)
        ->setParameter('status', Value::STATUS_PUBLISHED, Type::INTEGER)
        ->setParameter('linked_layout_id', $sharedLayout->id, Type::INTEGER);

        $query->orderBy('l.name', 'ASC');

        return $query->execute()->fetchAll(PDO::FETCH_ASSOC);
    }
576651
protected RawData __getSection() {
        return S.raw(S.isEmpty(layoutContent) ? layoutSections.get("__CONTENT__") : layoutContent);
    }
175111
public boolean equalLayouts(Layout layout) throws FetchException {
        if (this == layout) {
            return true;
        }
        return getStorableTypeName().equals(layout.getStorableTypeName())
            && getAllProperties().equals(layout.getAllProperties())
            && Arrays.equals(mStoredLayout.getExtraData(), layout.mStoredLayout.getExtraData());
    }
1145985
def load_shared_data(path: typing.Union[str, None]) -> dict:
    """"""

    if path is None:
        return dict()

    if not os.path.exists(path):
        raise FileNotFoundError('No such shared data file "{}"'.format(path))

    try:
        with open(path, 'r') as fp:
            data = json.load(fp)
    except Exception:
        raise IOError('Unable to read shared data file "{}"'.format(path))

    if not isinstance(data, dict):
        raise ValueError('Shared data must load into a dictionary object')

    return data
961577
private void loadFiles() {
		m_filesMap = new HashMap<String, FileInfo>();
		List<ColumnValue> list = m_helper.get(m_storeName, m_row, "File/");
		for(ColumnValue v : list) {
			FileInfo fi = new FileInfo(v.columnName, v.getString());
			m_filesMap.put(fi.getName(), fi); 
		}
	}
1243877
def load_data(self, idx):
        """"""
        for subseqs in self:
            if isinstance(subseqs, abctools.InputSequencesABC):
                subseqs.load_data(idx)
433078
def set_layout(wlayout, callback):
    ''''''
    global display_size
    global window_list
    global loaded_layout
    global pending_load
    global vehiclename
    #if not wlayout.name in window_list:
    #    print("layout %s" % wlayout)
    if not wlayout.name in window_list and loaded_layout is not None and wlayout.name in loaded_layout:
        callback(loaded_layout[wlayout.name])
    window_list[wlayout.name] = ManagedWindow(wlayout, callback)
    display_size = wlayout.dsize
    if pending_load:
        pending_load = False
        load_layout(vehiclename)
604377
public function loadLayoutsData(array $layoutIds, bool $includeDrafts): array
    {
        $query = $this->getLayoutSelectQuery();

        if ($includeDrafts) {
            $query->leftJoin(
                'l',
                'ngbm_layout',
                'l2',
                $query->expr()->andX(
                    $query->expr()->eq('l.id', 'l2.id'),
                    $query->expr()->eq('l2.status', ':status')
                )
            );
        }

        $query->where(
            $query->expr()->in('l.id', [':layout_ids'])
        );

        $statusExpr = $query->expr()->eq('l.status', ':status');
        if ($includeDrafts) {
            $statusExpr = $query->expr()->orX(
                $statusExpr,
                $query->expr()->isNull('l2.id')
            );
        }

        $query->andWhere($statusExpr);

        $query->setParameter('layout_ids', $layoutIds, Connection::PARAM_INT_ARRAY);
        $query->setParameter('status', Value::STATUS_PUBLISHED, Type::INTEGER);

        $query->orderBy('l.name', 'ASC');

        return $query->execute()->fetchAll(PDO::FETCH_ASSOC);
    }
891028
protected function loadRelatedData()
    {
        $settings = [];
        $contextSettings = [];
        if (is_object($this->xPDOSimpleObject)) {
            /** @var array of \modContextSetting $contextSettings */
            $contextSettings = $this->xPDOSimpleObject->getMany('ContextSettings');
        }
        /** @var \modContextSetting $setting */
        foreach ($contextSettings as $setting) {
            $settings[] = $this->makePortableData($setting->toArray());
        }

        $this->related_data = [
            'settings' => $settings
        ];

        // Calls on the event: OnBlendLoadRelatedData
        parent::loadRelatedData();
    }
821953
private function loadLayouts(array $layoutIds): Generator
    {
        foreach ($layoutIds as $layoutId) {
            try {
                yield $this->layoutService->loadLayout($layoutId);
            } catch (NotFoundException $e) {
                continue;
            }
        }
    }
30926
protected function load()
    {
        $tables = $this->fetchTables($this->schema);
        foreach ($tables as $table) {
            $this->loadTable($table);
        }
        $views = $this->fetchViews($this->schema);
        foreach ($views as $table) {
            $this->loadTable($table, true);
        }
    }
1130637
def store_layout(self, name, *args):
        

        layout = self.__layouts.get(name)
        if not layout:
            raise umbra.exceptions.LayoutExistError("{0} | '{1}' layout isn't registered!".format(
                self.__class__.__name__, name))

        LOGGER.debug("> Storing layout '{0}'.".format(name))

        self.__current_layout = name
        self.__settings.set_key("Layouts", "{0}_geometry".format(name), self.__container.saveGeometry())
        self.__settings.set_key("Layouts", "{0}_window_state".format(name), self.__container.saveState())
        self.__settings.set_key("Layouts", "{0}_central_widget".format(
            name), self.__container.centralWidget().isVisible())
        self.layout_stored.emit(self.__current_layout)
        return True
1183340
public function loadLayoutIds(bool $includeDrafts, ?bool $shared = null, int $offset = 0, ?int $limit = null): array
    {
        $query = $this->connection->createQueryBuilder();

        $query->select('DISTINCT l.id, l.name')
            ->from('ngbm_layout', 'l');

        if ($includeDrafts) {
            $query->leftJoin(
                'l',
                'ngbm_layout',
                'l2',
                $query->expr()->andX(
                    $query->expr()->eq('l.id', 'l2.id'),
                    $query->expr()->eq('l2.status', ':status')
                )
            );
        }

        if ($shared !== null) {
            $query->where(
                $query->expr()->eq('l.shared', ':shared')
            );
        }

        $statusExpr = $query->expr()->eq('l.status', ':status');
        if ($includeDrafts) {
            $statusExpr = $query->expr()->orX(
                $statusExpr,
                $query->expr()->isNull('l2.id')
            );
        }

        $query->andWhere($statusExpr);

        if ($shared !== null) {
            $query->setParameter('shared', $shared, Type::BOOLEAN);
        }

        $query->setParameter('status', Value::STATUS_PUBLISHED, Type::INTEGER);

        $this->applyOffsetAndLimit($query, $offset, $limit);
        $query->orderBy('l.name', 'ASC');

        $result = $query->execute()->fetchAll(PDO::FETCH_ASSOC);

        return array_column($result, 'id');
    }
1004754
public List<LayoutProperty> getDataProperties() throws FetchException {
        List<LayoutProperty> all = getAllProperties();
        List<LayoutProperty> data = new ArrayList<LayoutProperty>(all.size() - 1);
        for (LayoutProperty property : all) {
            if (!property.isPrimaryKeyMember()) {
                data.add(property);
            }
        }
        return Collections.unmodifiableList(data);
    }
490893
function loadLayouts (options) {
    // return cached layouts if caching enabled
    if (options.cache && GLOBAL.layouts) {
        return GLOBAL.layouts
    }
    // load layouts
    GLOBAL.layouts = loadTemplates(GLOBAL.layoutDirs, options)
    // return promise that will be resolved with layouts
    return GLOBAL.layouts
}
189437
private void loadChildren() throws CmsException {

        for (CmsResource resource : new ArrayList<CmsResource>(m_knownResources)) {
            if (resource.isFolder()) {
                if (!m_mustLoadChildren.contains(resource)) {
                    continue;
                }
                List<CmsResource> children = getChildren(resource);
                for (CmsResource child : children) {
                    m_knownResources.add(child);
                    m_childMap.put(resource, child);
                }
            }
        }
    }
107717
def _load_entries(self, root):
        """"""
        mdict = {
            "comments": self._comment,
            "line": self._line,
            "group": self._group
        }
        for entry in root:
            mdict[entry.tag](entry)