/**
* Find all Spring bean definitions in application context for given bean type.
*
* @param project
* @param beanType
* @return
*/
public List<String> getBeanNames(File configFile, Project project, String beanType) {
List<SpringBean> beanDefinitions =
getBeanDefinitions(
configFile, project, SpringBean.class, Collections.singletonMap("class", beanType));
List<String> beanNames = new ArrayList<String>();
for (SpringBean beanDefinition : beanDefinitions) {
beanNames.add(beanDefinition.getId());
}
return beanNames;
}
/**
* A pool of precompiled XSLT stylesheets ({@link Templates}). Caching can be disabled via
* constructor parameter or via setting a system property:
*
* <pre>
* template.caching
* </pre>
*
* to <code>false</code>.
*/
public final class TemplatesPool {
private static final Logger logger = org.slf4j.LoggerFactory.getLogger(TemplatesPool.class);
/**
* Global system property disabling template caching. This property can also be set at runtime
* (after the pool is initialized).
*/
public static final String TEMPLATE_CACHING_PROPERTY = "template.caching";
/** A set of used XSLT processors. */
private static final Set<String> reportedProcessors =
Collections.synchronizedSet(new HashSet<String>());
/** A map of precompiled stylesheets ({@link Templates} objects). */
private volatile HashMap<String, Templates> stylesheets = new HashMap<String, Templates>();
/**
* If <code>true</code> the templates will not be cached until the application shuts down. This
* speeds up the application, but may be annoying, especially during development.
*/
private final boolean templateCaching;
/** {@link SAXTransformerFactory} capable of producing SAX-based transformers. */
public final SAXTransformerFactory tFactory;
/** Creates a {@link TemplatesPool} with caching enabled. */
public TemplatesPool() throws Exception {
this(true);
}
/** Check for required facilities. If not available, an exception will be thrown. */
public TemplatesPool(boolean templateCaching) throws Exception {
final TransformerFactory tFactory = TransformerFactory.newInstance();
final String processorClass = tFactory.getClass().getName();
/*
* Only report XSLT processor class once.
*/
if (!reportedProcessors.contains(processorClass)) {
logger.info("XSLT transformer factory: " + processorClass);
reportedProcessors.add(processorClass);
}
if (!tFactory.getFeature(SAXSource.FEATURE) || !tFactory.getFeature(SAXResult.FEATURE)) {
throw new Exception("Required source types not supported by the transformer factory.");
}
if (!tFactory.getFeature(SAXResult.FEATURE) || !tFactory.getFeature(StreamResult.FEATURE)) {
throw new Exception("Required result types not supported by the transformer factory.");
}
if (!(tFactory instanceof SAXTransformerFactory)) {
throw new Exception(
"TransformerFactory not an instance of SAXTransformerFactory: "
+ tFactory.getClass().getName());
}
this.tFactory = ((SAXTransformerFactory) tFactory);
this.tFactory.setErrorListener(new StylesheetErrorListener());
this.templateCaching = templateCaching;
}
/** @return returns the identity transformer handler. */
public TransformerHandler getIdentityTransformerHandler()
throws TransformerConfigurationException {
return tFactory.newTransformerHandler();
}
/** Retrieves a previously stored template, if available. */
public Templates getTemplate(String key) {
if (!isCaching()) {
return null;
}
return stylesheets.get(key);
}
/**
* Add a new template to the pool. Addition is quite costly as it replaces the internal {@link
* #stylesheets} {@link HashMap}.
*/
public void addTemplate(String key, Templates template) {
if (!isCaching()) {
return;
}
/*
* Copy-on-write.
*/
synchronized (this) {
final HashMap<String, Templates> newMap = new HashMap<String, Templates>(this.stylesheets);
newMap.put(key, template);
this.stylesheets = newMap;
}
}
/** @return <code>true</code> if template caching is enabled. */
private boolean isCaching() {
/*
* Global override takes precedence.
*/
final String global = System.getProperty(TEMPLATE_CACHING_PROPERTY);
if (global != null) {
return Boolean.parseBoolean(global);
}
return templateCaching;
}
/**
* Compile a {@link Templates} from a given system identifier. The template is not added to the
* pool, a manual call to {@link #addTemplate(String, Templates)} is required.
*/
public Templates compileTemplate(String systemId) throws SAXException {
final StreamSource source = new StreamSource(systemId);
try {
return tFactory.newTemplates(source);
} catch (Exception e) {
throw new SAXException("Could not compile stylesheet: " + systemId, e);
}
}
/**
* Compile a {@link Templates} from a given stream. The template is not added to the pool
* automatically.
*/
public Templates compileTemplate(InputStream stream) throws SAXException {
final StreamSource source = new StreamSource(stream);
try {
return tFactory.newTemplates(source);
} catch (Exception e) {
throw new SAXException("Could not compile stylesheet.", e);
}
}
/**
* Return a new {@link TransformerHandler} based on a given precompiled {@link Templates}. The
* handler {@link Transformer}'s {@link ErrorListener} is set to {@link TransformerErrorListener}
* to raise exceptions and give proper warnings.
*/
public TransformerHandler newTransformerHandler(Templates template)
throws TransformerConfigurationException {
final TransformerHandler handler = this.tFactory.newTransformerHandler(template);
/*
* We want to raise transformer exceptions on <xml:message terminate="true">, so
* we add a custom listener. Also, various XSLT processors react in different ways
* to transformation errors -- some of them report error as recoverable, some of
* them report error as unrecoverable.
*/
handler.getTransformer().setErrorListener(new TransformerErrorListener());
return handler;
}
/**
* Return a new {@link Transformer}.
*
* @see #newTransformerHandler(Templates)
*/
public Transformer newTransformer(Templates t) throws TransformerConfigurationException {
return newTransformerHandler(t).getTransformer();
}
}
public void CrawlRT(String RTPage) throws IOException {
ArrayList<String> t = new ArrayList<String>();
String crawlData;
String crawlData2;
String crawlData3;
FileReader freader = new FileReader("Crawl.txt");
BufferedReader br = new BufferedReader(freader);
FileReader freader2 = new FileReader("Tocrawl.txt");
BufferedReader br2 = new BufferedReader(freader2);
FileWriter fwriter2 = new FileWriter("Tocrawl.txt", true);
BufferedWriter bw2 = new BufferedWriter(fwriter2);
FileWriter fwriter = new FileWriter("Crawl.txt", true);
BufferedWriter bw = new BufferedWriter(fwriter);
/*while(null != (crawlData2 = br.readLine()))
{
if(crawlData2 !=null)
Crawl.add(crawlData2);
}
t = collectLinks(RTPage);
Iterator<String> e3= t.iterator();
while(e3.hasNext())
{
String ee = e3.next();
if(!Crawl.contains(ee))
{
bw2.write(ee+"\r\n");
}
}
br.close();
br2.close();
bw.close();
bw2.close();*/
if (null == (crawlData = br.readLine()))
// if(true)
{
// initial iteration
bw.write(RTPage + "\r\n");
Crawl.add(RTPage);
t = collectLinks(RTPage);
ToCrawl.addAll(t);
} else {
// collect data from files and load to array lists
while (null != (crawlData2 = br.readLine())) {
if (crawlData2 != null) Crawl.add(crawlData2);
}
while (null != (crawlData3 = br2.readLine())) {
if (crawlData3 != null) ToCrawl.add(crawlData3);
}
}
System.out.println("Crawlled");
// Number of movies to be crawled
for (int i = 0; i < 1000; i++) {
if (ToCrawl.size() > 0) {
Crawl.removeAll(Collections.singleton(null));
ToCrawl.removeAll(Collections.singleton(null));
String c = ToCrawl.get(0);
if (Crawl.contains(c)) ToCrawl.remove(c);
else {
// collect links and collect data from a particular link
Crawl.add(c);
t = collectLinks(c);
CollectData(c);
ToCrawl.remove(c);
Iterator<String> e3 = t.iterator();
while (e3.hasNext()) {
String ee = e3.next();
if (!ToCrawl.contains(ee)) {
if (!Crawl.contains(ee)) {
ToCrawl.add(ee);
}
}
}
bw.write(c + "\r\n");
}
}
}
System.out.println("To Be Crawlled");
Iterator<String> e2 = ToCrawl.iterator();
while (e2.hasNext()) {
// write to file the movies still to be crawled.
bw2.write(e2.next() + "\r\n");
}
prop.setProperty("Id", Integer.toString(n));
prop.store(new FileOutputStream("config.properties"), null);
br.close();
br2.close();
bw.close();
bw2.close();
}
/**
* Unmarshall a Chromosome instance from a given XML Element representation.
*
* @param a_activeConfiguration current Configuration object
* @param a_xmlElement the XML Element representation of the Chromosome
* @return a new Chromosome instance setup with the data from the XML Element representation
* @throws ImproperXMLException if the given Element is improperly structured or missing data
* @throws UnsupportedRepresentationException if the actively configured Gene implementation does
* not support the string representation of the alleles used in the given XML document
* @throws GeneCreationException if there is a problem creating or populating a Gene instance
* @author Neil Rotstan
* @since 1.0
*/
public static Gene[] getGenesFromElement(
Configuration a_activeConfiguration, Element a_xmlElement)
throws ImproperXMLException, UnsupportedRepresentationException, GeneCreationException {
// Do some sanity checking. Make sure the XML Element isn't null and
// that it in fact represents a set of genes.
// -----------------------------------------------------------------
if (a_xmlElement == null || !(a_xmlElement.getTagName().equals(GENES_TAG))) {
throw new ImproperXMLException(
"Unable to build Chromosome instance from XML Element: "
+ "given Element is not a 'genes' element.");
}
List genes = Collections.synchronizedList(new ArrayList());
// Extract the nested gene elements.
// ---------------------------------
NodeList geneElements = a_xmlElement.getElementsByTagName(GENE_TAG);
if (geneElements == null) {
throw new ImproperXMLException(
"Unable to build Gene instances from XML Element: "
+ "'"
+ GENE_TAG
+ "'"
+ " sub-elements not found.");
}
// For each gene, get the class attribute so we know what class
// to instantiate to represent the gene instance, and then find
// the child text node, which is where the string representation
// of the allele is located, and extract the representation.
// -------------------------------------------------------------
int numberOfGeneNodes = geneElements.getLength();
for (int i = 0; i < numberOfGeneNodes; i++) {
Element thisGeneElement = (Element) geneElements.item(i);
thisGeneElement.normalize();
// Fetch the class attribute and create an instance of that
// class to represent the current gene.
// --------------------------------------------------------
String geneClassName = thisGeneElement.getAttribute(CLASS_ATTRIBUTE);
Gene thisGeneObject;
Class geneClass = null;
try {
geneClass = Class.forName(geneClassName);
try {
Constructor constr = geneClass.getConstructor(new Class[] {Configuration.class});
thisGeneObject = (Gene) constr.newInstance(new Object[] {a_activeConfiguration});
} catch (NoSuchMethodException nsme) {
// Try it by calling method newGeneInternal.
// -----------------------------------------
Constructor constr = geneClass.getConstructor(new Class[] {});
thisGeneObject = (Gene) constr.newInstance(new Object[] {});
thisGeneObject =
(Gene)
PrivateAccessor.invoke(
thisGeneObject, "newGeneInternal", new Class[] {}, new Object[] {});
}
} catch (Throwable e) {
throw new GeneCreationException(geneClass, e);
}
// Find the text node and fetch the string representation of
// the allele.
// ---------------------------------------------------------
NodeList children = thisGeneElement.getChildNodes();
int childrenSize = children.getLength();
String alleleRepresentation = null;
for (int j = 0; j < childrenSize; j++) {
Element alleleElem = (Element) children.item(j);
if (alleleElem.getTagName().equals(ALLELE_TAG)) {
alleleRepresentation = alleleElem.getAttribute("value");
}
if (children.item(j).getNodeType() == Node.TEXT_NODE) {
// We found the text node. Extract the representation.
// ---------------------------------------------------
alleleRepresentation = children.item(j).getNodeValue();
break;
}
}
// Sanity check: Make sure the representation isn't null.
// ------------------------------------------------------
if (alleleRepresentation == null) {
throw new ImproperXMLException(
"Unable to build Gene instance from XML Element: "
+ "value (allele) is missing representation.");
}
// Now set the value of the gene to that reflect the
// string representation.
// -------------------------------------------------
try {
thisGeneObject.setValueFromPersistentRepresentation(alleleRepresentation);
} catch (UnsupportedOperationException e) {
throw new GeneCreationException(
"Unable to build Gene because it does not support the "
+ "setValueFromPersistentRepresentation() method.");
}
// Finally, add the current gene object to the list of genes.
// ----------------------------------------------------------
genes.add(thisGeneObject);
}
return (Gene[]) genes.toArray(new Gene[genes.size()]);
}