import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
/**
 * Execute an operation with the store.
 *
 * This method enforces thread safety based on the store factory.
 *
 * @param storeOperation The store.
 * @param rootModule     The root module to use for store initialization.
 * @throws MojoExecutionException On execution errors.
 * @throws MojoFailureException   On execution failures.
 */
protected void execute(StoreOperation storeOperation, MavenProject rootModule, Set<MavenProject> executedModules) throws MojoExecutionException, MojoFailureException {
    if (skip) {
        getLog().info("Skipping execution.");
    } else {
        synchronized (storeFactory) {
            Store store = getStore(rootModule);
            if (isResetStoreBeforeExecution() && executedModules.isEmpty()) {
                store.reset();
            }
            try {
                storeOperation.run(rootModule, store);
            } finally {
                releaseStore(rootModule, store);
            }
        }
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
protected void aggregate(MavenProject rootModule, List<MavenProject> projects, Store store) throws MojoExecutionException, MojoFailureException {
    File file = ProjectResolver.getOutputFile(rootModule, exportFile, EXPORT_FILE);
    getLog().info("Exporting database to '" + file.getAbsolutePath() + "'");
    EmbeddedGraphStore graphStore = (EmbeddedGraphStore) store;
    store.beginTransaction();
    try {
        GraphDatabaseService databaseService = graphStore.getGraphDatabaseService();
        SubGraph graph = DatabaseSubGraph.from(databaseService);
        new SubGraphExporter(graph).export(new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8")));
    } catch (IOException e) {
        throw new MojoExecutionException("Cannot export database.", e);
    } finally {
        store.commitTransaction();
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public void execute(MavenProject mavenProject, Store store) throws MojoExecutionException, MojoFailureException {
    ScannerConfiguration configuration = new ScannerConfiguration();
    configuration.setContinueOnError(continueOnError);
    ScannerContext scannerContext = new ScannerContextImpl(store);
    ScannerPluginRepository scannerPluginRepository = pluginRepositoryProvider.getScannerPluginRepository();
    Map<String, ScannerPlugin<?, ?>> scannerPlugins;
    try {
        scannerPlugins = scannerPluginRepository.getScannerPlugins(scannerContext, getPluginProperties());
    } catch (PluginRepositoryException e) {
        throw new MojoExecutionException("Cannot determine scanner plugins.", e);
    }
    ScopePluginRepository scopePluginRepository = pluginRepositoryProvider.getScopePluginRepository();
    Scanner scanner = new ScannerImpl(configuration, scannerContext, scannerPlugins, scopePluginRepository.getScopes());
    store.beginTransaction();
    try {
        scanner.scan(mavenProject, mavenProject.getFile().getAbsolutePath(), MavenScope.PROJECT);
    } finally {
        store.commitTransaction();
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public void run() throws CliExecutionException {
    List<Class<?>> descriptorTypes;
    final Store store = getStore();
    try {
        descriptorTypes = pluginRepository.getModelPluginRepository().getDescriptorTypes();
    } catch (PluginRepositoryException e) {
        throw new CliExecutionException("Cannot get model.", e);
    }
    ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(pluginRepository.getClassLoader());
    try {
        store.start(descriptorTypes);
        executeTask(store);
    } finally {
        store.stop();
        Thread.currentThread().setContextClassLoader(oldClassLoader);
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public ManifestFileDescriptor scan(FileResource item, String path, Scope scope, Scanner scanner) throws IOException {
    try (InputStream stream = item.createStream()) {
        Manifest manifest = new Manifest(stream);
        ScannerContext context = scanner.getContext();
        Store store = context.getStore();
        FileDescriptor fileDescriptor = context.getCurrentDescriptor();
        ManifestFileDescriptor manifestFileDescriptor = store.addDescriptorType(fileDescriptor, ManifestFileDescriptor.class);
        ManifestSectionDescriptor mainSectionDescriptor = store.create(ManifestSectionDescriptor.class);
        mainSectionDescriptor.setName(SECTION_MAIN);
        manifestFileDescriptor.setMainSection(mainSectionDescriptor);
        readSection(manifest.getMainAttributes(), mainSectionDescriptor, store);
        for (Map.Entry<String, Attributes> sectionEntry : manifest.getEntries().entrySet()) {
            ManifestSectionDescriptor sectionDescriptor = store.create(ManifestSectionDescriptor.class);
            sectionDescriptor.setName(sectionEntry.getKey());
            readSection(sectionEntry.getValue(), sectionDescriptor, store);
            manifestFileDescriptor.getManifestSections().add(sectionDescriptor);
        }
        return manifestFileDescriptor;
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public PropertyFileDescriptor scan(FileResource item, String path, Scope scope, Scanner scanner) throws IOException {
    ScannerContext context = scanner.getContext();
    Store store = context.getStore();
    FileDescriptor fileDescriptor = context.getCurrentDescriptor();
    PropertyFileDescriptor propertyFileDescriptor = store.addDescriptorType(fileDescriptor, PropertyFileDescriptor.class);
    Properties properties = new Properties();
    try (InputStream stream = item.createStream()) {
        properties.load(stream);
    } catch (IllegalArgumentException e) {
        LOGGER.warn("Cannot load properties from '" + path + "': " + e.getMessage());
    }
    for (String name : properties.stringPropertyNames()) {
        String value = properties.getProperty(name);
        PropertyDescriptor propertyDescriptor = store.create(PropertyDescriptor.class);
        propertyDescriptor.setName(name);
        propertyDescriptor.setValue(value);
        propertyFileDescriptor.getProperties().add(propertyDescriptor);
    }
    return propertyFileDescriptor;
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public PropertyFileDescriptor scan(FileResource item, String path, Scope scope, Scanner scanner) throws IOException {
    ScannerContext context = scanner.getContext();
    Store store = context.getStore();
    FileDescriptor fileDescriptor = context.getCurrentDescriptor();
    Class<XmlPropertyFileDescriptor> descriptorType = XmlPropertyFileDescriptor.class;
    PropertyFileDescriptor propertyFileDescriptor = store.addDescriptorType(fileDescriptor, descriptorType);
    Properties properties = new Properties();
    try (InputStream stream = item.createStream()) {
        properties.loadFromXML(stream);
    } catch (IllegalArgumentException e) {
        LOGGER.warn("Cannot load properties from '" + path + "': " + e.getMessage());
    }

    for (String name : properties.stringPropertyNames()) {
        String value = properties.getProperty(name);
        PropertyDescriptor propertyDescriptor = store.create(PropertyDescriptor.class);
        propertyDescriptor.setName(name);
        propertyDescriptor.setValue(value);
        propertyFileDescriptor.getProperties().add(propertyDescriptor);
    }
    return propertyFileDescriptor;
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public PlaintextFileDescriptor scan(final FileResource item, final String path, final Scope scope, final Scanner scanner) throws IOException {
    final Store store = scanner.getContext().getStore();
    final PlaintextFileDescriptor plaintextFileDescriptor = store.create(PlaintextFileDescriptor.class);
    plaintextFileDescriptor.setFileName(path);

    try (BufferedReader reader = new BufferedReader(new InputStreamReader(item.createStream()))) {
        final PlaintextLineParser pumlLineParser = new PlaintextLineParser(store, plaintextFileDescriptor);
        String line;
        while ((line = reader.readLine()) != null) {
            pumlLineParser.parseLine(line);
        }
    }

    return plaintextFileDescriptor;
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public PlantUmlFileDescriptor scan(final FileResource item, final String path, final Scope scope, final Scanner scanner) throws IOException {
    final Store store = scanner.getContext().getStore();
    final PlantUmlFileDescriptor plantUmlFileDescriptor = store.create(PlantUmlFileDescriptor.class);
    plantUmlFileDescriptor.setFileName(path);

    try (BufferedReader reader = new BufferedReader(new InputStreamReader(item.createStream()))) {
        final PumlLineParser pumlLineParser = new PumlLineParser(store, plantUmlFileDescriptor, path.endsWith(".puml") ? ParsingState.ACCEPTING : ParsingState.IGNORING);
        String line;
        while ((line = reader.readLine()) != null) {
            pumlLineParser.parseLine(line);
        }
    }

    return plantUmlFileDescriptor;
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
private void readViolations(final Store store, final FileType fileType, final PmdFileDescriptor pmdFileDescriptor) {
     for (ViolationType vioType : fileType.getViolation()) {
         final PmdViolationDescriptor vioDescriptor = store.create(PmdViolationDescriptor.class);
vioDescriptor.setBeginLine(vioType.getBeginline());
vioDescriptor.setEndLine(vioType.getEndline());
vioDescriptor.setBeginColumn(vioType.getBegincolumn());
vioDescriptor.setEndColumn(vioType.getEndcolumn());
         vioDescriptor.setRule(vioType.getRule());
         vioDescriptor.setRuleSet(vioType.getRuleset());
         vioDescriptor.setPackage(vioType.get_package());
         vioDescriptor.setClassName(vioType.getClazz());
vioDescriptor.setMethod(vioType.getMethod());
vioDescriptor.setVariable(vioType.getVariable());
vioDescriptor.setExternalInfoUrl(vioType.getExternalInfoUrl());
vioDescriptor.setPriority(vioType.getPriority());
vioDescriptor.setMessage(vioType.getValue());
         pmdFileDescriptor.getViolations().add(vioDescriptor);
     }
 }
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
/**
 * Release a store instance.
 *
 * @param rootModule The root module
 * @param store      The store instance.
 */
private void releaseStore(MavenProject rootModule, Store store) {
    switch (storeLifecycle) {
        case MODULE:
            storeFactory.closeStore(store);
            break;
        case REACTOR:
            rootModule.setContextValue(Store.class.getName(), store);
            break;
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public void aggregate(MavenProject rootModule, List<MavenProject> projects, Store store) throws MojoExecutionException, MojoFailureException {
    getLog().info("Available rules for '" + rootModule.getName() + "'.");
    RuleSet ruleSet = readRules(rootModule);
    RuleHelper ruleHelper = new RuleHelper(LOGGER);
    try {
        ruleHelper.printRuleSet(ruleSet);
    } catch (RuleException e) {
        throw new MojoExecutionException("Cannot print available rules.", e);
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
protected void aggregate(MavenProject rootModule, List<MavenProject> projects, Store store) throws MojoExecutionException, MojoFailureException {
    Server server = new EmbeddedNeoServer((EmbeddedGraphStore) store, serverAddress,
            serverPort != null ? serverPort : Server.DEFAULT_PORT);
    server.start();
    getLog().info("Running server for module " + rootModule.getGroupId() + ":" + rootModule.getArtifactId() + ":" + rootModule.getVersion());
    getLog().info("Press <Enter> to finish.");
    try {
        System.in.read();
    } catch (IOException e) {
        throw new MojoExecutionException("Cannot read from System.in.", e);
    } finally {
        server.stop();
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public void aggregate(MavenProject rootModule, List<MavenProject> projects, Store store) throws MojoExecutionException, MojoFailureException {
    getLog().info("Available scopes for '" + rootModule.getName() + "'.");
    ScopeHelper scopeHelper = new ScopeHelper(logger);
    ScopePluginRepository scopePluginRepository = pluginRepositoryProvider.getScopePluginRepository();
    scopeHelper.printScopes(scopePluginRepository.getScopes());
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
public void aggregate(MavenProject rootModule, List<MavenProject> projects, Store store) throws MojoExecutionException, MojoFailureException {
    getLog().info("Effective rules for '" + rootModule.getName() + "'.");
    RuleSet ruleSet = readRules(rootModule);
    RuleSelection ruleSelection = RuleSelection.Builder.select(ruleSet, groups, constraints, concepts);
    RuleHelper ruleHelper = new RuleHelper(LOGGER);
    try {
        ruleHelper.printRuleSet(ruleSet, ruleSelection);
    } catch (RuleException e) {
        throw new MojoExecutionException("Cannot print effective rules.", e);
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
protected void executeTask(Store store) throws CliExecutionException {
    ScopeHelper scopeHelper = new ScopeHelper(LOGGER);
    try {
        scopeHelper.printScopes(pluginRepository.getScopePluginRepository().getScopes());
    } catch (PluginRepositoryException e) {
        throw new CliExecutionException("Cannot get scope plugin repository.", e);
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
protected void executeTask(Store store) throws CliExecutionException {
    RuleSet availableRules = getAvailableRules();
    try {
        ruleHelper.printRuleSet(availableRules);
    } catch (RuleException e) {
        throw new CliExecutionException("Cannot print available rules.", e);
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
protected void executeTask(final Store store) throws CliExecutionException {
    Server server;
    server = new EmbeddedNeoServer((EmbeddedGraphStore) store, serverAddress, serverPort);
    server.start();
    LOGGER.info("Running server");
    LOGGER.info("Press <Enter> to finish.");
    try {
        System.in.read();
    } catch (IOException e) {
        throw new CliExecutionException("Cannot read from console.", e);
    } finally {
        server.stop();
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
@Override
protected void executeTask(Store store) throws CliExecutionException {
    try {
        RuleSet availableRules = getAvailableRules();
        ruleHelper.printRuleSet(availableRules, getRuleSelection(availableRules));
    } catch (RuleException e) {
        throw new CliExecutionException("Cannot print rules.", e);
    }
}
 

import com.buschmais.jqassistant.core.store.api.Store; //导入依赖的package包/类
private void readSection(Attributes attributes, ManifestSectionDescriptor sectionDescriptor, Store store) {
    for (Map.Entry<Object, Object> entry : attributes.entrySet()) {
        Object key = entry.getKey();
        Object value = entry.getValue();
        ManifestEntryDescriptor entryDescriptor = store.create(ManifestEntryDescriptor.class);
        entryDescriptor.setName(key != null ? key.toString() : null);
        entryDescriptor.setValue(value != null ? value.toString() : null);
        sectionDescriptor.getManifestEntries().add(entryDescriptor);
    }
}