/**
* Returns the first entity under a point of the map, in the specified layer.
*
* @param layer the layer
* @param x x of the point
* @param y y of the point
* @return the entity found, or null if there is no entity here
*/
public MapEntity getEntityAt(Layer layer, int x, int y) {
MapEntities entities = allEntities[layer.getId()];
ListIterator<MapEntity> iterator = entities.listIterator(entities.size());
while (iterator.hasPrevious()) {
MapEntity entity = iterator.previous();
if (entity.containsPoint(x, y)) {
return entity;
}
}
return null;
}
/**
* Brings the specified entities to the back, keeping their layer. The order of the specified
* entities in the map is unchanged.
*
* @param entities the entities to move
*/
public void bringToBack(List<MapEntity> entities) {
List<MapEntity> sortedEntities = getSortedEntities(entities);
// bring to back each entity from sortedEntities
ListIterator<MapEntity> iterator = sortedEntities.listIterator(sortedEntities.size());
while (iterator.hasPrevious()) {
MapEntity entity = iterator.previous();
Layer layer = entity.getLayer();
allEntities[layer.getId()].remove(entity);
allEntities[layer.getId()].addFirst(entity);
}
setChanged();
notifyObservers();
}
/**
* Insert the list of <code>newPasses</code> into <code>passes</code> immediately before the pass
* named <code>id</code>.
*/
public void beforePass(List passes, Pass.ID id, List newPasses) {
for (ListIterator i = passes.listIterator(); i.hasNext(); ) {
Pass p = (Pass) i.next();
if (p.id() == id) {
// Backup one position.
i.previous();
for (Iterator j = newPasses.iterator(); j.hasNext(); ) {
i.add(j.next());
}
return;
}
}
throw new InternalCompilerError("Pass " + id + " not found.");
}
public static void runPhraseSpellCheck() throws Exception {
String S, collocatedString = "";
Scanner enable = new Scanner(new File("/home/tanmay/workspace/SpellCheck/src/enable1.txt"));
while (enable.hasNext()) {
S = enable.next();
// a = input.nextLong();
// System.out.print(S+"\t"+ a+"\t");
correctWords.add(S);
}
enable = new Scanner(new File("/home/tanmay/workspace/SpellCheck/src/stop.txt"));
while (enable.hasNext()) {
S = enable.next();
// a = input.nextLong();
// System.out.print(S+"\t"+ a+"\t");
stopWords.add(S);
}
ArrayList<String> misspeltWords = new ArrayList<String>();
ArrayList<Integer> misspeltWordsIndex = new ArrayList<Integer>();
ArrayList<String> corrections = new ArrayList<String>();
ArrayList<String> finalCorrections = new ArrayList<String>();
ArrayList<String> phraseWords = new ArrayList<String>();
int count;
WordCheck w = new WordCheck();
w.createDictionary();
w.createConfusionMatrix();
double candidateScore = 0;
PhraseCheck p = new PhraseCheck();
p.createNgrams();
System.out.println("Preprocessing Done");
String input = null;
String phrase = null;
BufferedReader br =
new BufferedReader(
new FileReader(new File("/home/tanmay/workspace/SpellCheck/src/phrases.txt")));
while ((input = br.readLine()) != null) {
long t1 = System.currentTimeMillis();
misspeltWords.clear();
misspeltWordsIndex.clear();
// phrase = input.toLowerCase();
phrase = input;
// String[] words = null;
ArrayList<String> words = new ArrayList<String>();
String[] words1 = phrase.split(" ");
/* for(int i=0;i<words1.length;i++)
{
System.out.print(words1[i] + " ");
}*/
for (int wordc = 0; wordc < words1.length / 2; wordc++) {
words.add(words1[wordc]);
}
/*
for(int wordCount=0;wordCount<words.length;wordCount++)
{
phraseWords.add(words[wordCount]);
}
for (String word : phraseWords)
{
if(!correctWords.contains(word)&&!stopWords.contains(word))
{
misspeltWords.add(word);
misspeltWordsIndex.add(phraseWords.indexOf(word));
}
}*/
int wordc1 = 0;
for (String word : words) {
// System.out.println("Wordc = " + wordc1);
if (!correctWords.contains(word) && !stopWords.contains(word)) {
misspeltWords.add(word);
// System.out.println("Word is "+word);
misspeltWordsIndex.add(wordc1);
}
wordc1++;
}
wordc1 = 0;
// System.out.println(misspeltWords);
/*Collocation Based*/
/*
int misspeltWordCount = 0;
for (String misspeltWord : misspeltWords)
{
w.getCandidates(misspeltWord);
corrections = w.candidates;
candidateScores.clear();
for(String correction : corrections)
{
for(int collocSizeLeft = 1;collocSizeLeft<MAXCONTEXTSIZE;collocSizeLeft++)
{
for(int collocSizeRight = 1;collocSizeRight<MAXCONTEXTSIZE;collocSizeRight++)
{
collocatedString= "";
for(int size = 0;size<collocSizeLeft;size++)
{
if(!(misspeltWordsIndex.get(misspeltWordCount)-size<0))
collocatedString += phraseWords.get(misspeltWordsIndex.get(misspeltWordCount)-size)+" ";
}
collocatedString +=correction;
for(int size = 0;size<collocSizeRight;size++)
{
if(misspeltWordsIndex.get(misspeltWordCount)+size<phraseWords.size())
collocatedString += phraseWords.get(misspeltWordsIndex.get(misspeltWordCount)-size)+" ";
}
collocatedString = collocatedString.substring(0,collocatedString.length());
}
if(collocatedString.length()<6 && collocatedString.length()>1)
{
candidateScore += p.NgramsFull[collocatedString.length()-2].get(collocatedString);
}
}
candidateScores.put(correction, candidateScore);
candidateScore = 0.0;
}
misspeltWordCount++;
}
*/
/* Context Based*/
// System.out.println(words1.length);
for (String misspeltword : misspeltWords) {
float score = 0;
// System.out.println(words1.length);
// System.out.println("wordc =" + wordc1 + "words1.length/2 " + words1.length/2 +
// "misspeltwordindex " +misspeltWordsIndex.get(wordc1) );
int total = misspeltWordsIndex.get(wordc1) + words1.length / 2;
// System.out.println("Total = " + total );
String correctWord = words1[misspeltWordsIndex.get(wordc1) + words1.length / 2];
// System.out.println("Correct Word " + correctWord);
wordc1++;
finalCorrections.clear();
candidateScores.clear();
w.getCandidates(misspeltword);
corrections = w.candidates;
// System.out.println(corrections);
// System.out.println("Over");
/* System.out.println(p.Ngrams[0].get("ground turmeric"));
System.out.println(p.Ngrams[1].get("baby carriage"));
System.out.println(p.Ngrams[2].get("moon earth"));
System.out.println(p.Ngrams[3].get("perspective society"));*/
for (String correction : corrections) {
if (!stopWords.contains(correction)) {
candidateScore = 0;
candidateScores.put(correction, 0.0);
for (String word : words) {
if (!stopWords.contains(word)) {
for (int i = 0; i < 4; i++) {
if (p.Ngrams[i].containsKey(correction + " " + word))
candidateScore += p.Ngrams[i].get(correction + " " + word);
else candidateScore += 0;
}
}
}
candidateScores.put(correction, candidateScore);
}
}
LinkedHashMap<String, Double> map = w.sortByValues(candidateScores);
// System.out.println(map);
ListIterator<String> iter = new ArrayList(map.keySet()).listIterator(map.size());
while (iter.hasPrevious()) {
String key = iter.previous();
// System.out.println(key);
if (map.get(key) != 0.0) {
finalCorrections.add(key);
} else break;
if (finalCorrections.size() == 3) break;
}
// Interpolation
while (finalCorrections.size() < 3) {
for (int q = 0; q < corrections.size(); q++) {
if (!finalCorrections.contains(corrections.get(q))
&& !stopWords.contains(corrections.get(q)))
finalCorrections.add(corrections.get(q));
if (finalCorrections.size() == 3) break;
}
}
System.out.println(System.currentTimeMillis() - t1);
int wc1 = 0;
for (String word : finalCorrections) {
if (word.equals(correctWord)) score = 1 / (float) (wc1 + 1);
}
System.out.println(misspeltword + " " + finalCorrections + "Score = " + score);
}
}
}
/**
* Process the specified HTTP request, and create the corresponding HTTP response (or forward to
* another web component that will create it). Return an <code>ActionForward</code> instance
* describing where and how control should be forwarded, or <code>null</code> if the response has
* already been completed.
*
* @param mapping The ActionMapping used to select this instance
* @param form The optional ActionForm bean for this request (if any)
* @param request The HTTP request we are processing
* @param response The HTTP response we are creating
* @exception Exception if business logic throws an exception
*/
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
// Extract attributes we will need
MessageResources messages = getResources(request);
// save errors
ActionMessages errors = new ActionMessages();
// START check for login (security)
if (!SecurityService.getInstance().checkForLogin(request.getSession(false))) {
return (mapping.findForward("welcome"));
}
// END check for login (security)
// START get id of current project from either request, attribute, or cookie
// id of project from request
String projectId = null;
projectId = request.getParameter("projectViewId");
// check attribute in request
if (projectId == null) {
projectId = (String) request.getAttribute("projectViewId");
}
// id of project from cookie
if (projectId == null) {
projectId = StandardCode.getInstance().getCookie("projectViewId", request.getCookies());
}
// default project to last if not in request or cookie
if (projectId == null) {
java.util.List results = ProjectService.getInstance().getProjectList();
ListIterator iterScroll = null;
for (iterScroll = results.listIterator(); iterScroll.hasNext(); iterScroll.next()) {}
iterScroll.previous();
Project p = (Project) iterScroll.next();
projectId = String.valueOf(p.getProjectId());
}
Integer id = Integer.valueOf(projectId);
// END get id of current project from either request, attribute, or cookie
// get project
Project p = ProjectService.getInstance().getSingleProject(id);
// get user (project manager)
User u =
UserService.getInstance()
.getSingleUserRealName(
StandardCode.getInstance().getFirstName(p.getPm()),
StandardCode.getInstance().getLastName(p.getPm()));
// START process pdf
try {
PdfReader reader = new PdfReader("C://templates/CL01_001.pdf"); // the template
// save the pdf in memory
ByteArrayOutputStream pdfStream = new ByteArrayOutputStream();
// the filled-in pdf
PdfStamper stamp = new PdfStamper(reader, pdfStream);
// stamp.setEncryption(true, "pass", "pass", PdfWriter.AllowCopy | PdfWriter.AllowPrinting);
AcroFields form1 = stamp.getAcroFields();
Date cDate = new Date();
Integer month = cDate.getMonth();
Integer day = cDate.getDate();
Integer year = cDate.getYear() + 1900;
String[] monthName = {
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
};
// set the field values in the pdf form
// form1.setField("", projectId)
form1.setField("currentdate", monthName[month] + " " + day + ", " + year);
form1.setField(
"firstname", StandardCode.getInstance().noNull(p.getContact().getFirst_name()));
form1.setField("pm", p.getPm());
form1.setField("emailpm", u.getWorkEmail1());
if (u.getWorkPhoneEx() != null && u.getWorkPhoneEx().length() > 0) { // ext present
form1.setField(
"phonepm",
StandardCode.getInstance().noNull(u.getWorkPhone())
+ " ext "
+ StandardCode.getInstance().noNull(u.getWorkPhoneEx()));
} else { // no ext present
form1.setField("phonepm", StandardCode.getInstance().noNull(u.getWorkPhone()));
}
form1.setField("faxpm", StandardCode.getInstance().noNull(u.getLocation().getFax_number()));
form1.setField("postalpm", StandardCode.getInstance().printLocation(u.getLocation()));
// START add images
// if(u.getPicture() != null && u.getPicture().length() > 0) {
// PdfContentByte over;
// Image img = Image.getInstance("C:/Program Files (x86)/Apache Software
// Foundation/Tomcat 7.0/webapps/logo/images/" + u.getPicture());
// img.setAbsolutePosition(200, 200);
// over = stamp.getOverContent(1);
// over.addImage(img, 54, 0,0, 65, 47, 493);
// }
// END add images
form1.setField("productname", StandardCode.getInstance().noNull(p.getProduct()));
form1.setField("project", p.getNumber() + p.getCompany().getCompany_code());
form1.setField("description", StandardCode.getInstance().noNull(p.getProductDescription()));
form1.setField("additional", p.getProjectRequirements());
// get sources and targets
StringBuffer sources = new StringBuffer("");
StringBuffer targets = new StringBuffer("");
if (p.getSourceDocs() != null) {
for (Iterator iterSource = p.getSourceDocs().iterator(); iterSource.hasNext(); ) {
SourceDoc sd = (SourceDoc) iterSource.next();
sources.append(sd.getLanguage() + " ");
if (sd.getTargetDocs() != null) {
for (Iterator iterTarget = sd.getTargetDocs().iterator(); iterTarget.hasNext(); ) {
TargetDoc td = (TargetDoc) iterTarget.next();
if (!td.getLanguage().equals("All")) targets.append(td.getLanguage() + " ");
}
}
}
}
form1.setField("source", sources.toString());
form1.setField("target", targets.toString());
form1.setField(
"start",
(p.getStartDate() != null)
? DateFormat.getDateInstance(DateFormat.SHORT).format(p.getStartDate())
: "");
form1.setField(
"due",
(p.getDueDate() != null)
? DateFormat.getDateInstance(DateFormat.SHORT).format(p.getDueDate())
: "");
if (p.getCompany().getCcurrency().equalsIgnoreCase("USD")) {
form1.setField(
"cost",
(p.getProjectAmount() != null)
? "$ " + StandardCode.getInstance().formatDouble(p.getProjectAmount())
: "");
} else {
form1.setField(
"cost",
(p.getProjectAmount() != null)
? "€ "
+ StandardCode.getInstance()
.formatDouble(p.getProjectAmount() / p.getEuroToUsdExchangeRate())
: "");
}
// stamp.setFormFlattening(true);
stamp.close();
// write to client (web browser)
response.setHeader(
"Content-disposition",
"attachment; filename="
+ p.getNumber()
+ p.getCompany().getCompany_code()
+ "-Order-Confirmation"
+ ".pdf");
OutputStream os = response.getOutputStream();
pdfStream.writeTo(os);
os.flush();
} catch (Exception e) {
System.err.println("PDF Exception:" + e.getMessage());
throw new RuntimeException(e);
}
// END process pdf
// Forward control to the specified success URI
return (mapping.findForward("Success"));
}
/**
* Inserts residency/update/swizzle checks into a method. Iterates over the bytecodes in the
* method and inserts the appropriate residency opcode.
*
* @param method The method to which to add checks.
* @see MethodEditor#code
*/
private static void transform(final MethodEditor method) {
if (Main.VERBOSE > 1) {
System.out.println("Decorating method " + method);
}
// Optimize initialization of arrays to speed things up.
CompactArrayInitializer.transform(method);
final ListIterator iter = method.code().listIterator();
// Go through the code (Instructions and Labels) in the method
INST:
while (iter.hasNext()) {
final Object ce = iter.next();
if (Main.VERBOSE > 2) {
System.out.println("Examining " + ce);
}
if (ce instanceof Instruction) {
final Instruction inst = (Instruction) ce;
int uctype = Main.NONE; // Type of update check (POINTER or
// SCALAR)
boolean insert_sc = false; // Insert swizzle check (aaload
// only)?
final int opc = inst.opcodeClass();
int depth;
switch (opc) {
case opcx_arraylength:
case opcx_athrow:
case opcx_getfield:
case opcx_instanceof:
{
depth = 0;
break;
}
case opcx_iaload:
case opcx_laload:
case opcx_faload:
case opcx_daload:
case opcx_baload:
case opcx_caload:
case opcx_saload:
{
depth = 1;
break;
}
case opcx_aaload:
{
depth = 1;
insert_sc = true;
break;
}
case opcx_iastore:
case opcx_fastore:
case opcx_aastore:
case opcx_bastore:
case opcx_castore:
case opcx_sastore:
{
depth = 2;
break;
}
case opcx_lastore:
case opcx_dastore:
{
depth = 3;
break;
}
case opcx_putfield:
{
final MemberRef ref = (MemberRef) inst.operand();
depth = ref.type().stackHeight();
if (ref.type().isReference()) {
uctype = Main.POINTER;
} else {
uctype = Main.SCALAR;
}
break;
}
case opcx_invokevirtual:
case opcx_invokespecial:
case opcx_invokeinterface:
{
final MemberRef ref = (MemberRef) inst.operand();
depth = ref.type().stackHeight();
break;
}
case opcx_rc:
{
// Skip any existing residency checks.
iter.remove();
continue INST;
}
case opcx_aupdate:
{
// Skip any existing update checks.
iter.remove();
continue INST;
}
case opcx_supdate:
{
// Skip any existing update checks.
iter.remove();
continue INST;
}
default:
{
continue INST;
}
}
Instruction addInst;
// Insert a residency check...
if (Main.RC) {
Object t;
// //////////////////////////////////
// Before...
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
//
// After...
// +-----+----+------+-----------+
// | ... | RC | inst | afterInst |
// +-----+----+------+-----------+
// ^prev ^next
// //////////////////////////////////
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
t = iter.previous();
Assert.isTrue(t == inst, t + " != " + inst);
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
addInst = new Instruction(Opcode.opcx_rc, new Integer(depth));
iter.add(addInst);
// +-----+----+------+-----------+
// | ... | RC | inst | afterInst |
// +-----+----+------+-----------+
// ^prev ^next
t = iter.previous();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+----+------+-----------+
// | ... | RC | inst | afterInst |
// +-----+----+------+-----------+
// ^prev ^next
t = iter.next();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+----+------+-----------+
// | ... | RC | inst | afterInst |
// +-----+----+------+-----------+
// ^prev ^next
t = iter.next();
Assert.isTrue(t == inst, t + " != " + inst);
// +-----+----+------+-----------+
// | ... | RC | inst | afterInst |
// +-----+----+------+-----------+
// ^prev ^next
if (Main.VERBOSE > 2) {
System.out.println("Inserting " + addInst + " before " + inst);
}
} else {
if (Main.VERBOSE > 2) {
System.out.println("Not inserting rc before " + inst);
}
}
// Insert a swizzle check...
if (insert_sc) {
if (Main.SC) {
Object t;
// ////////////////////////////////////////////
// Before...
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
//
// After...
// +-----+------+----------+------+-----------+
// | ... | dup2 | aswizzle | inst | afterInst |
// +-----+------+----------+------+-----------+
// ^prev ^next
// /////////////////////////////////////////////
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
t = iter.previous();
Assert.isTrue(t == inst, t + " != " + inst);
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
addInst = new Instruction(Opcode.opcx_dup2);
iter.add(addInst);
// +-----+------+------+-----------+
// | ... | dup2 | inst | afterInst |
// +-----+------+------+-----------+
// ^prev ^next
t = iter.previous();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+------+------+-----------+
// | ... | dup2 | inst | afterInst |
// +-----+------+------+-----------+
// ^prev ^next
t = iter.next();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+------+------+-----------+
// | ... | dup2 | inst | afterInst |
// +-----+------+------+-----------+
// ^prev ^next
addInst = new Instruction(Opcode.opcx_aswizzle);
iter.add(addInst);
// +-----+------+----------+------+-----------+
// | ... | dup2 | aswizzle | inst | afterInst |
// +-----+------+----------+------+-----------+
// ^prev ^next
t = iter.previous();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+------+----------+------+-----------+
// | ... | dup2 | aswizzle | inst | afterInst |
// +-----+------+----------+------+-----------+
// ^prev ^next
t = iter.next();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+------+----------+------+-----------+
// | ... | dup2 | aswizzle | inst | afterInst |
// +-----+------+----------+------+-----------+
// ^prev ^next
t = iter.next();
Assert.isTrue(t == inst, t + " != " + inst);
// +-----+------+----------+------+-----------+
// | ... | dup2 | aswizzle | inst | afterInst |
// +-----+------+----------+------+-----------+
// ^prev ^next
if (Main.VERBOSE > 2) {
System.out.println("Inserting dup2,aswizzle before " + inst);
}
} else {
if (Main.VERBOSE > 2) {
System.out.println("Not inserting aswizzle before " + inst);
}
}
}
// Insert an update check...
if (uctype != Main.NONE) {
if (Main.UC) {
Object t;
// ////////////////////////////////////////////
// Before...
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
//
// After...
// +-----+---------+------+-----------+
// | ... | aupdate | inst | afterInst |
// +-----+---------+------+-----------+
// ^prev ^next
// /////////////////////////////////////////////
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
t = iter.previous();
Assert.isTrue(t == inst, t + " != " + inst);
// +-----+------+-----------+
// | ... | inst | afterInst |
// +-----+------+-----------+
// ^prev ^next
addInst = new Instruction(Opcode.opcx_aupdate, new Integer(depth));
/*
* if (uctype == POINTER) { addInst = new
* Instruction(opcx_aupdate, new Integer(depth)); } else {
* addInst = new Instruction(opcx_supdate, new
* Integer(depth)); }
*/
iter.add(addInst);
// +-----+---------+------+-----------+
// | ... | aupdate | inst | afterInst |
// +-----+---------+------+-----------+
// ^prev ^next
t = iter.previous();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+---------+------+-----------+
// | ... | aupdate | inst | afterInst |
// +-----+---------+------+-----------+
// ^prev ^next
t = iter.next();
Assert.isTrue(t == addInst, t + " != " + addInst);
// +-----+---------+------+-----------+
// | ... | aupdate | inst | afterInst |
// +-----+---------+------+-----------+
// ^prev ^next
t = iter.next();
Assert.isTrue(t == inst, t + " != " + inst);
// +-----+---------+------+-----------+
// | ... | aupdate | inst | afterInst |
// +-----+---------+------+-----------+
// ^prev ^next
if (Main.VERBOSE > 2) {
System.out.println("Inserting " + addInst + " before " + inst);
}
} else if (Main.VERBOSE > 2) {
System.out.println("Not inserting uc before " + inst);
}
}
}
}
}
