Initializes the plugin using the specified JSON configuration

@param jsonFile JSON configuration file
@throws SubscriberException if there was an error in initialization
422334
@Override
    public void init(File jsonFile) throws SubscriberException {
        try {
            setConfig(new JsonSimpleConfig(jsonFile));
        } catch (IOException ioe) {
            throw new SubscriberException(ioe);
        }
    }
751207
public function loadJSON(string $JSONfile): void
    {
        $file = new FileManager();
        $this->jsonData = $file->loadLittleFile($JSONfile);
    }
106715
@Override
    public void initModule() throws ModuleInitializationException {

        String dsMediation = getParameter("doMediateDatastreams");
        if (dsMediation == null) {
            throw new ModuleInitializationException("doMediateDatastreams parameter must be specified.",
                                                    getRole());
        }
    }
745974
public void loadPropertyFile(File propertyFile) throws IOException {
        userSettings.load(new FileReader(propertyFile));
        loadDataSource(obdaModel, userSettings);
    }
306335
private void intialize(File sourceDirectory) throws IOException {
    getLog().debug("Initializing i18n plugin...");

    // resource
    if (!getI18nSourceFiles(sourceDirectory).isEmpty()) {
      File myGeneratedResourcesFolder = getGeneratedResourcesFolder();
      addResource(myGeneratedResourcesFolder.getPath(), target);
    }

  }
838304
public static <I> JMFileSubscriber<I> buildJsonStringFileSubscriber(
            String filePath, Function<Object, String> toStringFunction) {
        return new JMFileSubscriber<>(filePath, toStringFunction);
    }
712899
public function init($file, array $data = null)
    {
        if ($data === null) {
            $data = $this->setJsonDefaults([]);
        }
        $this->app['filesystem']->write($file, Json::dump($data, Json::HUMAN));
    }
104637
private function init()
    {
        // Define Default Config:
        
        $this->setConfig(self::$default_config);
        
        // Load JSON Config File:
        
        $file = new JsonFile(self::CONFIG_FILE);
        
        // Merge JSON Config (if file exists):
        
        if ($file->exists()) {
            $this->mergeConfig($file->read());
        }
    }
913510
private void init(JSONTokener x) {
		if (x.nextClean() != '[') {
			throw x.syntaxError("A JSONArray text must start with '['");
		}
		if (x.nextClean() != ']') {
			x.back();
			for (;;) {
				if (x.nextClean() == ',') {
					x.back();
					this.rawList.add(JSONNull.NULL);
				} else {
					x.back();
					this.rawList.add(x.nextValue());
				}
				switch (x.nextClean()) {
				case ',':
					if (x.nextClean() == ']') {
						return;
					}
					x.back();
					break;
				case ']':
					return;
				default:
					throw x.syntaxError("Expected a ',' or ']'");
				}
			}
		}
	}
1035293
public void initialize(Framework framework) {
        setFramework(framework);
        //plugin manager service inited first.  any pluggable services will then be
        //able to try to load providers via the plugin manager
        NodeStepExecutionService.getInstanceForFramework(getFramework());
        NodeExecutorService.getInstanceForFramework(getFramework());
        FileCopierService.getInstanceForFramework(getFramework());
        NodeDispatcherService.getInstanceForFramework(getFramework());
        getExecutionService();
        WorkflowExecutionService.getInstanceForFramework(getFramework());
        StepExecutionService.getInstanceForFramework(getFramework());
        ResourceModelSourceService.getInstanceForFramework(getFramework());
        ResourceFormatParserService.getInstanceForFramework(getFramework());
        ResourceFormatGeneratorService.getInstanceForFramework(getFramework());
    }
1340170
public void initialize() {
		
        final JSONObject params = new JSONObject();
        params.put("page", page);
        params.put("size", size);
        
        getPage(params);     
	}
166579
public void setMetaData(int jsonFileNo, Configuration configuration) {
        for (Element element : elements) {
            element.setMetaData(this);

            if (element.isScenario()) {
                scenarios.add(element);
            }
        }

        reportFileName = calculateReportFileName(jsonFileNo);
        featureStatus = calculateFeatureStatus();

        calculateSteps();
    }
1330877
function init(pluginInterface) {
    const pi = pluginInterface;

    // Static contents call
    pi.http.endpoint('get', '*', (req, res, next) => {
        let path = req.path;
        if (path.charAt(path.length-1)=='/') path += 'index.html';

        const pt = pathm.join(pathm.dirname(__filename), 'htdocs', path);
        fs.readFile(pt, (err, data)=>{
            if (err) {
                res.status(404).send('No such resource');
                return;
            }
            if (path==='/js/customize.js') {
                data = data.toString();
                data = data.split('__%%RSA_PUB_KEY%%__')
                    .join('"'+pi.crypt.getPubKey()+'"');
            }
            res.set('Content-Type', mime.getType(path)); // 'text/html; charset=UTF-8'
            res.status(200);

            res.send(data);
        });
    });
}
288729
private void setConfig(JsonSimpleConfig config) throws IOException {
        // Get the basics
        user_object = new InternalUser();
        file_path = config.getString(null, "authentication", "internal",
                "path");
        loadUsers();
    }
1016849
function loadJSONConfigFile(filePath) {
    try {
        return JSON.parse(stripComments(readFile(filePath)));
    }
    catch (e) {
        e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
        throw e;
    }
}
431344
public void loadConfiguration() {
		System.out.println("CONFIGURATION_DIR: " + CONFIGURATION_DIR);
		File f = new File(CONFIGURATION_DIR);

		if (f.isDirectory()) {
			String[] files = f.list();
			for (String s : files) {
				if (s.endsWith(".json")) {
					System.out.println("Registering: " + s.toLowerCase());
					this.registerServiceConfiguration(s.split(".json")[0], s);
				}
			}
		}
	}
183158
protected void initJsonReader() {
		String readerList = config.getJsonReaders();
		if (readerList != null) {
			String[] readers = readerList.split(",");
			Set<String> supportedReaders = TreeReaderRegistry.getReadersByFormat("json");
			TreeReader selectedReader = null;
			for (String reader : readers) {
				reader = reader.trim().toLowerCase();
				if (!reader.isEmpty()) {
					for (String supportedReader : supportedReaders) {
						int i = supportedReader.lastIndexOf('.');
						if (i > -1) {
							supportedReader = supportedReader.substring(i + 1);
						}
						if (supportedReader.toLowerCase().contains(reader)) {
							selectedReader = TreeReaderRegistry.getReader(supportedReader);
							logger.info("Default JSON deserializer/reader is \"" + selectedReader.getClass() + "\".");
							TreeReaderRegistry.setReader("json", selectedReader);
							break;
						}
					}
					if (selectedReader != null) {
						break;
					}
				}
			}
		}
	}