RealLiteralEvaluator.java

package com.drawbridge.jsengine.ast;

import java.util.LinkedList;

import com.drawbridge.jsengine.Scope;
import com.drawbridge.jsengine.jsobjects.JSNumber;
import com.drawbridge.jsengine.jsobjects.JSType;
import com.drawbridge.text.TextPanel;
import com.drawbridge.utils.Utils;
import com.drawbridge.vl.blocks.BlockPrimitive;
import com.google.caja.parser.js.RealLiteral;

public class RealLiteralEvaluator extends NumberLiteralEvaluator<Double>
{

	private RealLiteral			mRealLiteral;
	private Double 				max	= Double.MAX_VALUE;
	private Double				min	= Double.MIN_VALUE;

	public RealLiteralEvaluator(Evaluator parent, Scope scope, RealLiteral realLiteral) {
		super(parent, scope, realLiteral.getFilePosition());
		mRealLiteral = realLiteral;
		Utils.out.println(this.getClass(), ">>>>" + mRealLiteral);
	}

	@Override
	public JSType evaluate() throws EvaluatorException
	{
		return new JSNumber(mRealLiteral.doubleValue());
	}

	@Override
	public LinkedList<com.drawbridge.vl.blocks.Block> getBlocks()
	{
		LinkedList<com.drawbridge.vl.blocks.Block> results = new LinkedList<com.drawbridge.vl.blocks.Block>();
		results.add(new BlockPrimitive(getFilePosition(), this, "" + mRealLiteral.doubleValue()));
		return results;
	}

	@Override
	public boolean compare(Evaluator e)
	{
		if (!e.getClass().equals(getClass()))
			return false;
		RealLiteralEvaluator rle = (RealLiteralEvaluator) e;
		if (rle.mRealLiteral == mRealLiteral && e.getFilePosition().equals(getFilePosition()))
			return true;
		else
			return false;
	}
	
	public Double getValidValue(Double newVal)
	{
		if ((Double)newVal > max)
			return max;
		else if ((Double)newVal < min)
			return min;
		else
			return newVal;
	}
	
	@Override
	public boolean isValidValue(Double newVal)
	{
		return !(newVal > max ||newVal < min);
	
	}
	

	public void modifyValue(ParserListener listener, Double newVal, boolean updateSnapshot)
	{
		double newValidValue = getValidValue((Double)newVal);

		// Apply a valid value
		mRealLiteral = new RealLiteral(getFilePosition(), newValidValue);

		// Update TextPanel based on modifiedValue
		if (TextPanel.hasInstance() && updateSnapshot) {
			String before = "";
			String after = "";
			try {
				int line = getFilePosition().startLineNo()-1;
				String text = DBParser.getInstance().getSnapshot();
				String [] lines = text.split("\n");
				if(line < lines.length){
					before = lines[line].substring(0, getFilePosition().startCharInLine()-1);
					after = lines[line].substring(getFilePosition().startCharInLine()-1 + getFilePosition().length(), lines[line].length());
				}
				String finalText = "";
				for(int i = 0; i < lines.length;i++){
					if(i != line){
						finalText += lines[i];
					}
					else{
						finalText += before + newValidValue + after;
					}
					if(i < lines.length -1)
						finalText += "\n";
				}
				DBParser.getInstance().setSnapshot(finalText);
				
				
			} catch (StringIndexOutOfBoundsException e) {
				Utils.out.println("String index exception");
				e.printStackTrace();
			}
		}

		// Make the parser aware
		DBParser.getInstance().notifyOfEvalChange(listener);
		// if (oldValue != newValidValue && !DBParser.getInstance().mRecentlyChangedEvaluators.contains(this))
		DBParser.getInstance().mRecentlyChangedEvaluators.add(this);
	}
	
	
	
	@Override
	public String toString()
	{
		return "RealLiteralEvaluator (" + mRealLiteral + ")";
	}


	public Double getMaxValue()
	{
		return max;
	}

	public Double getMinValue()
	{
		return min;
	}
	

	public boolean hasCustomMax(){
		return (max != Double.MAX_VALUE);
	}
	

	public boolean hasCustomMin(){
		return (min != Double.MIN_VALUE);
	}

	public int getFPDiff(Double newVal)
	{
		int integerLength =  ("" + mRealLiteral.getValue().intValue()).length();
		int newValLength = ("" + newVal).length();
		Utils.out.println("Length of " + mRealLiteral.getValue().intValue() + " is " + integerLength + ", Length of new value " + newVal + " is " + newValLength + " diff:" + (newValLength - integerLength));
		return newValLength - integerLength;
	}

	@Override
	public void setMaximum(Double max)
	{
		this.max = max;
	}

	@Override
	public void setMinimum(Double min)
	{
		this.min = min;
	}











}