Returns an {@link Iterable} over all plugins which can be resolved from
the current classpath.

@return The plugins which can be resolved from the current classpath.
492111
@Override
    public List<JqassistantPlugin> getPlugins() {
        if (this.plugins == null) {
            final Enumeration<URL> resources;
            try {
                resources = pluginClassLoader.getResources(PLUGIN_RESOURCE);
            } catch (IOException e) {
                throw new IllegalStateException("Cannot get plugin resources.", e);
            }
            this.plugins = new ArrayList<>();
            while (resources.hasMoreElements()) {
                URL url = resources.nextElement();
                LOGGER.debug("Reading plugin descriptor from '{}'.", url);
                this.plugins.add(readPlugin(url));
            }
            SortedSet<String> pluginNames = new TreeSet<>();
            for (JqassistantPlugin plugin : plugins) {
                pluginNames.add(plugin.getName());
            }
            LOGGER.info("Loaded jQAssistant plugins {}.", pluginNames);
        }
        return this.plugins;
    }
937008
public ResourceList getAllResources() {
        if (allWhitelistedResourcesCached == null) {
            // Index Resource objects by path
            final ResourceList whitelistedResourcesList = new ResourceList();
            for (final ClasspathElement classpathElt : classpathOrder) {
                if (classpathElt.whitelistedResources != null) {
                    whitelistedResourcesList.addAll(classpathElt.whitelistedResources);
                }
            }
            // Set atomically for thread safety
            allWhitelistedResourcesCached = whitelistedResourcesList;
        }
        return allWhitelistedResourcesCached;
    }
994874
public List<MoskitoPlugin> getPlugins() {
		ArrayList<MoskitoPlugin> ret = new ArrayList<MoskitoPlugin>(plugins.values());
		return ret;
	}
207775
public synchronized Map<String, Dependency> getPluginDependencies() throws MojoExecutionException {
		if (this.pluginDependencies == null) {
			final String groupId = getConfig("plugin.groupId"); //$NON-NLS-1$
			final String artifactId = getConfig("plugin.artifactId"); //$NON-NLS-1$
			final String pluginArtifactKey = ArtifactUtils.versionlessKey(groupId, artifactId);

			final Set<Artifact> dependencies = resolveDependencies(pluginArtifactKey, true);

			final Map<String, Dependency> deps = new TreeMap<>();

			for (final Artifact artifact : dependencies) {
				final Dependency dep = toDependency(artifact);
				deps.put(ArtifactUtils.versionlessKey(artifact), dep);
			}

			this.pluginDependencies = deps;
		}
		return this.pluginDependencies;
	}
1138328
def get_plugins(modules, classobj):
    
    for module in modules:
        for plugin in get_module_plugins(module, classobj):
            yield plugin
216154
def plugins(self):
        
        from fluent_contents import extensions   # Avoid circular reference because __init__.py imports subfolders too
        if self._plugins is None:
            return extensions.plugin_pool.get_plugins()
        else:
            return extensions.plugin_pool.get_plugins_by_name(*self._plugins)
707790
def get_plugins(cls, *args, **kwargs):
        
        return [plugin(*args, **kwargs) for plugin in cls.plugins]
32668
def plugins(self):
        

        if self._plugins is None:
            self._plugins = {}

            for _, plugin in self.load_extensions('iotile.plugin'):
                links = plugin()
                for name, value in links:
                    self._plugins[name] = value

        return self._plugins
54159
public ArrayList<PathImpl> getResources()
  {
    ArrayList<PathImpl> list = new ArrayList<PathImpl>();

    //if (exists())
    list.add(this);

    return list;
  }
235631
public Set<ClassModel> getAllClassDependencies() {
		HashSet<ClassModel> result = new HashSet<>();

		for (ModuleModel module : allModuleDependencies) {
			for (ClassModel clazz : module.classes) {
				ClassModel.getAllClassDependencies(result, clazz);
			}
		}

		return result;
	}
645952
public List<JSTypeExpression> getImplementedInterfaces() {
    if (info == null || info.implementedInterfaces == null) {
      return ImmutableList.of();
    }
    return Collections.unmodifiableList(info.implementedInterfaces);
  }
340402
public List<IfClassNotAvailable<Exclude<T>>> getAllIfClassNotAvailable()
   {
      List<IfClassNotAvailable<Exclude<T>>> list = new ArrayList<IfClassNotAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-not-available");
      for(Node node: nodeList)
      {
         IfClassNotAvailable<Exclude<T>>  type = new IfClassNotAvailableImpl<Exclude<T>>(this, "if-class-not-available", childNode, node);
         list.add(type);
      }
      return list;
   }
1232032
public PluginRegistry load() throws PluginException {

        List<Path> pluginFiles = getPluginsProvider().provide(getPluginsDirectory());

        PluginRegistry pluginRegistry = new PluginRegistryContainer();

        // Loading information about all plugins first
        for (Path pluginFile : pluginFiles) {
            PluginMetadata pluginMetadata = getManifestReader().read(pluginFile);
            pluginRegistry.addPlugin(pluginMetadata);
        }

        // Iterating over the entire plugin set, checking for dependency resolution problems and loading classes
        for (String pluginName : pluginRegistry.getPluginNames()) {
            Optional<PluginMetadata> pluginMetadata = pluginRegistry.getPlugin(pluginName);
            if (pluginMetadata.isPresent()) {
                getDependencyChecker().check(pluginRegistry, pluginMetadata.get());

                ScanResult scanResult = getClassesScanner().scan(
                        pluginMetadata.get().getPath(),
                        getExtensionPoints()
                );
                for (Class extensionPoint : scanResult.getContents().getExtensionPoints()) {
                    pluginRegistry.addImplementations(
                            pluginMetadata.get(),
                            extensionPoint,
                            scanResult.getContents().getImplementations(extensionPoint)
                    );
                }
                pluginRegistry.addClassLoader(pluginMetadata.get(), scanResult.getClassLoader());

                List<Path> resources = getResourcesScanner().scan(pluginMetadata.get().getPath());
                pluginRegistry.addResources(pluginMetadata.get(), resources);
            }
        }
        return pluginRegistry;
    }
251877
public List<String> getPluginNames() {
		ArrayList<String> ret = new ArrayList<String>(plugins.keySet());
		return ret;
	}
38724
public List<MappedSuperclass<EntityMappings<T>>> getAllMappedSuperclass()
   {
      List<MappedSuperclass<EntityMappings<T>>> list = new ArrayList<MappedSuperclass<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("mapped-superclass");
      for(Node node: nodeList)
      {
         MappedSuperclass<EntityMappings<T>>  type = new MappedSuperclassImpl<EntityMappings<T>>(this, "mapped-superclass", childNode, node);
         list.add(type);
      }
      return list;
   }
1305870
@Override
	public Iterator<Class> getClassesToDeleteIterator() {
		if (fixture instanceof CleanableFixture) {
			return cleanableFixture().getClassesToDeleteIterator();
		}

		return Collections.<Class>emptyList().iterator();
	}
511039
public Iterable<Row> resolve()
    {
        ArrayList<RowIterator> iters = new ArrayList<RowIterator>(responses.size());
        int n = 0;
        for (MessageIn<RangeSliceReply> response : responses)
        {
            RangeSliceReply reply = response.payload;
            n = Math.max(n, reply.rows.size());
            iters.add(new RowIterator(reply.rows.iterator(), response.from));
        }
        // for each row, compute the combination of all different versions seen, and repair incomplete versions
        // TODO do we need to call close?
        CloseableIterator<Row> iter = MergeIterator.get(iters, pairComparator, new Reducer());

        List<Row> resolvedRows = new ArrayList<Row>(n);
        while (iter.hasNext())
            resolvedRows.add(iter.next());

        return resolvedRows;
    }