Loads the data from the disk into this object.

<p>
The constructor of the derived class must call this method.
(If we do that in the base class, the derived class won't
get a chance to set default values.)
9506
public synchronized void load() {
        XmlFile file = getConfigFile();
        if(!file.exists())
            return;

        try {
            file.unmarshal(this);
        } catch (IOException e) {
            LOGGER.log(Level.WARNING, "Failed to load "+file, e);
        }
    }
32498
@Override
    public <T extends Assignable> T load(Class<T> extensionClass, Archive<?> baseArchive)
        throws UnknownExtensionTypeException {
        if (isCached(extensionClass)) {
            return createFromCache(extensionClass, baseArchive);
        }
        T object = createFromLoadExtension(extensionClass, baseArchive);

        addToCache(extensionClass, object.getClass());

        return object;
    }
747133
def _load_data_and_files(self):
        
        if not _hasattr(self, '_data'):
            self._data, self._files = self._parse()
            if self._files:
                self._full_data = self._data.copy()
                self._full_data.update(self._files)
            else:
                self._full_data = self._data
666905
public static void load() {
        if (!isLoaded()) {
//            ScriptInjector.fromString(OpenLayersV3Resources.INSTANCE.proj4js().getText()).setWindow(ScriptInjector.TOP_WINDOW).inject();
//            ScriptInjector.fromString(OpenLayersV3Resources.INSTANCE.supercluster().getText()).setWindow(ScriptInjector.TOP_WINDOW).inject();
            ScriptInjector.fromString(OpenLayersV3Resources.INSTANCE.js().getText()).setWindow(ScriptInjector.TOP_WINDOW).inject();
            StyleInjector.injectStylesheetAtStart(OpenLayersV3Resources.INSTANCE.css().getText());
        }
    }
1245855
protected void loadDataFromFile(InputStream is) throws IOException {
		PHPFileParser fp = new PHPFileParser(is);
		createInternalDataStructre(fp.getSections());
	}
70851
public void initialize(final BaseJavaFileObject javaSourceFileObject,
		final BaseJavaFileObject compiledJavaFileObject)
	{
		this.javaSourceFileObject = javaSourceFileObject;
		this.compiledJavaFileObject = compiledJavaFileObject;
		this.runtimeCompilerClassLoader.setCompiledJavaFileObject(this.compiledJavaFileObject);
	}
376610
public void initialize() {
		if (dataClass == null) {
			throw new IllegalStateException("dataClass was never set on " + getClass().getSimpleName());
		}
		if (tableName == null) {
			tableName = extractTableName(databaseType, dataClass);
		}
	}
419442
private byte[] loadClassBytes(File classFile) throws IOException
	{

		int size = (int) classFile.length();
		byte buff[] = new byte[size];

		FileInputStream fis = new FileInputStream(classFile);
		DataInputStream dis = null;

		try
		{
			dis = new DataInputStream(fis);
			dis.readFully(buff);
		}
		finally
		{
			if(dis != null)
				dis.close();
		}

		return buff;
	}
125072
private void loadFromFile() {
    // load from disk if the caller gave us a file
    if (file_location != null && !file_location.isEmpty()) {
      final File file = new File(file_location);
      if (!file.exists()) {
        LOG.warn("Query override file " + file_location + " does not exist");
        return;
      }
      try {
        final String raw_json = Files.toString(file, Const.UTF8_CHARSET);
        if (raw_json != null && !raw_json.isEmpty()) {
          final Set<QueryLimitOverrideItem> cached_items = 
              JSON.parseToObject(raw_json, TR_OVERRIDES);
          
          // iterate so we only change bits that are different.
          for (final QueryLimitOverrideItem override : cached_items) {
            QueryLimitOverrideItem existing = overrides.get(override.getRegex());
            if (existing == null || !existing.equals(override)) {
              overrides.put(override.getRegex(), override);
            }
          }
          
          // reverse quadratic, woot! Ugly but if the limit file is so big that
          // this takes over 60 seconds or starts blocking queries on modifications
          // to the map then something is really wrong.
          final Iterator<Entry<String, QueryLimitOverrideItem>> iterator = 
              overrides.entrySet().iterator();
          while (iterator.hasNext()) {
            final Entry<String, QueryLimitOverrideItem> entry = iterator.next();
            boolean matched = false;
            for (final QueryLimitOverrideItem override : cached_items) {
              if (override.getRegex().equals(entry.getKey())) {
                matched = true;
                break;
              }
            }
            if (!matched) {
              iterator.remove();
            }
          }
        }
        LOG.info("Successfully loaded query overrides: " + this);
      } catch (Exception e) {
        LOG.error("Failed to read cache file for query limit override: " + 
            this, e);
      }
    }
  }
559428
@SuppressWarnings("checkstyle:emptyblock")
	private void load() {
		recordMessage("Loading parameters");
		File cwd = new File(".");
		String workingDir;

		try {
			workingDir = cwd.getCanonicalPath();
		} catch (IOException ex) {
			workingDir = "UNKNOWN";
		}

		recordMessage("Working directory is " + workingDir);

		for (String resourceName : PARAMETER_LOAD_ORDER) {
			loadTop(resourceName);
		}

		if (getBoolean(USE_SYSTEM_PROPERTIES)) {
			recordMessage("Loading from system properties");
			load(System.getProperties(), "System Properties", true);
		}

		// Now perform variable substitution.
		do {
			// Do nothing while loop
		} while (substitute());

		if (getBoolean(DUMP)) {
			// Can't use logging infrastructure here, so dump to console
			log(getDebuggingInfo());
			log(getMessages());
		}

		// We don't want the StringBuffer hanging around after 'DUMP'.
		clearMessages();

		// Now move any parameters with the system parameters prefix into the real system parameters.
		Properties systemProperties = getSubProperties(SYSTEM_PARAMETERS_PREFIX, true);
		System.getProperties().putAll(systemProperties);
	}
905506
private synchronized void loadExistingData() {
        for (ChildData childData : _pathCache.getCurrentData()) {
            addNode(childData.getPath(), parseChildData(childData));
        }
    }
1051095
@PostConstruct
	protected void init() throws IOException {
		// base configuration from XML file
		if (null != configurationFile) {
			log.debug("Get base configuration from {}", configurationFile);
			manager = new DefaultCacheManager(configurationFile);
		} else {
			GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder();
			builder.globalJmxStatistics().allowDuplicateDomains(true);
			manager = new DefaultCacheManager(builder.build());
		}

		if (listener == null) {
			listener = new InfinispanCacheListener();
		}
		manager.addListener(listener);

		// cache for caching the cache configurations (hmmm, sounds a bit strange)
		Map<String, Map<CacheCategory, CacheService>> cacheCache = 
				new HashMap<String, Map<CacheCategory, CacheService>>();

		// build default configuration
		if (null != defaultConfiguration) {
			setCaches(cacheCache, null, defaultConfiguration);
		}

		// build layer specific configurations
		for (Layer layer : layerMap.values()) {
			CacheInfo ci = configurationService.getLayerExtraInfo(layer.getLayerInfo(), CacheInfo.class);
			if (null != ci) {
				setCaches(cacheCache, layer, ci);
			}
		}
	}
480227
protected byte[] loadClassDataFromFile(String fileName) {
        byte[] classBytes = null;
        try {
            InputStream in = getResourceAsStream(fileName);
            if (in == null) {
                return null;
            }
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte buf[] = new byte[1024];
            for (int i = 0;(i = in.read(buf)) != -1;)
                baos.write(buf, 0, i);
            in.close();
            baos.close();
            classBytes = baos.toByteArray();
        }
        catch (Exception ex) {
            return null;
        }
        return classBytes;
    }
1016101
@Override
  public void initialize() {
    TreeIndexHeader header = createHeader();
    if(this.file.initialize(header)) {
      initializeFromFile(header, file);
    }
    rootEntry = createRootEntry();
  }
1233096
private function load()
    {
        $decoder = new JsonDecoder();
        $decoder->setObjectDecoding(JsonDecoder::ASSOC_ARRAY);

        $this->json = file_exists($this->path)
            ? $decoder->decodeFile($this->path)
            : array();

        if (!isset($this->json['keysByTypeName'])) {
            $this->json['keysByTypeName'] = array();
            $this->json['typesByKey'] = array();
            $this->json['bindingsByKey'] = array();
            $this->json['nextKey'] = 0;
        }
    }
245393
private void readObject(java.io.ObjectInputStream in)
        throws IOException, ClassNotFoundException
    {
        in.defaultReadObject();
        _cache=new HashMap();
    }
730730
private void initStream() throws IOException {

        if (m_out == null) {
            if (!m_writeOnlyToBuffer) {
                // we can use the parents output stream
                if (m_cachingRequired || (m_controller.getResponseStackSize() > 1)) {
                    // we are allowed to cache our results (probably to construct a new cache entry)
                    m_out = new CmsFlexResponse.CmsServletOutputStream(m_res.getOutputStream());
                } else {
                    // we are not allowed to cache so we just use the parents output stream
                    m_out = (CmsFlexResponse.CmsServletOutputStream)m_res.getOutputStream();
                }
            } else {
                // construct a "buffer only" output stream
                m_out = new CmsFlexResponse.CmsServletOutputStream();
            }
        }
        if (m_writer == null) {
            // create a PrintWriter that uses the encoding required for the request context
            m_writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(m_out, m_encoding)), false);
        }
    }