Download | Plain Text | Line Numbers
/*
* Copyright (c) 2008, Manuel Mausz <manuel at mausz.at>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the copyright holders nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
import java.io.InputStream;
import java.util.HashMap;
import java.util.Scanner;
import java.lang.Class;
import java.lang.Boolean;
import java.lang.reflect.*;
import java.util.InputMismatchException;
import java.lang.NoSuchMethodException;
/**
* CalcOperator encapsulate an Operator
* NOTE: This class isn't public due to EPROG limitations.
* EPROG doesn't allow shipping files not specified
*
* @version 1.0
* @author Manuel Mausz (manuel at mausz.at)
* @author http://manuel.mausz.at/
*/
class CalcOperator
{
private String op;
/**
* Constructor
*
* @param value init value
*/
CalcOperator(String op)
{
this.op = op;
}
/**
* @return encapsulated operator
*/
public String get()
{
return op;
}
/**
* Indicates whether some other object is "equal to" this one
*
* @param obj the reference object with which to compare
* @return true if this object is the same as the obj argument; false otherwise
*/
public boolean equals(Object op2)
{
if (op2 == null)
return false;
else if (op2 instanceof CalcOperator)
return this.op.equals(((CalcOperator) op2).get());
else
return false;
}
/**
* Returns a hash code value for the object
*
* @return string
*/
public int hashCode()
{
return op.hashCode();
}
/**
* Converts instance to string
*
* @return string
*/
public String toString()
{
return op;
}
}
/**
* Abstract for CalcValue
*
* @version 1.0
* @author Manuel Mausz (manuel at mausz.at)
* @author http://manuel.mausz.at/
*/
abstract class CalcValue
{
protected static HashMap<CalcOperator, String> operators = new HashMap<CalcOperator, String>();
/**
* Assigns an operator to a method
*
* @param op operator
* @param func method name
*/
protected void addOp(CalcOperator op, String func)
{
operators.put(op, func);
}
/**
* Checks if instance has an method assigned to operater
*
* @param op operator
* @return boolean
*/
public boolean isSupported(CalcOperator op)
{
return operators.containsKey(op);
}
/**
* Invokes the method assigned to operator
* passes value as argument
*
* @param value argument passed to the invoked method
* @param op operator
* @return object return by invoked method
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
public Object calc(CalcValue value, CalcOperator op)
throws NoSuchMethodException, InvocationTargetException
{
Object ret = null;
String methodname = operators.get(op);
if (methodname == null)
throw new NoSuchMethodException("Method for operator '" + op.get() + "' not found");
try
{
Method method = this.getClass().getMethod(methodname, new Class[] { value.getClass() });
ret = method.invoke(this, new Object[] { value } );
}
catch(IllegalAccessException e)
{
throw new NoSuchMethodException(e.getMessage());
}
return ret;
}
}
/**
* CalcInteger encapsulate an Integer value
* NOTE: This class isn't public due to EPROG limitations.
* EPROG doesn't allow shipping files not specified
*
* @version 1.0
* @author Manuel Mausz (manuel at mausz.at)
* @author http://manuel.mausz.at/
*/
class CalcInteger extends CalcValue
{
private int value;
/**
* Constructor
*
* @param value init value
*/
CalcInteger(int value)
{
addOps();
this.value = value;
}
/**
* Add supported operations
*/
private void addOps()
{
addOp(new CalcOperator("+"), "add");
addOp(new CalcOperator("-"), "sub");
addOp(new CalcOperator("*"), "mul");
addOp(new CalcOperator("/"), "div");
}
/**
* @return encapsulated integer
*/
public int get()
{
return value;
}
/**
* Converts instance to string
*
* @return string
*/
public String toString()
{
return Integer.toString(value);
}
/**
* Addition
*
* @param val
* @return new CalcInteger instance
*/
public CalcInteger add(CalcInteger val)
{
return new CalcInteger(value + val.get());
}
/**
* Subtraction
*
* @param val
* @return new CalcInteger instance
*/
public CalcInteger sub(CalcInteger val)
{
return new CalcInteger(value - val.get());
}
/**
* Multiplication
*
* @param val
* @return new CalcInteger instance
*/
public CalcInteger mul(CalcInteger val)
{
return new CalcInteger(value * val.get());
}
/**
* Division
*
* @param val
* @return new CalcInteger instance
*/
public CalcInteger div(CalcInteger val)
{
return new CalcInteger(value / val.get());
}
}
/**
* Calculator
*
* @version 1.0
* @author Manuel Mausz (manuel at mausz.at)
* @author http://manuel.mausz.at/
*/
public class Calculator
{
private static CalcInteger val1;
private static CalcInteger val2;
private static CalcOperator op;
/**
* read values and operator from src
* only allow syntax: "int int op"
*
* @param src input stream
* @return boolean always true
* @throws InputMismatchException
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
public static boolean parse(InputStream src)
throws InputMismatchException, NoSuchMethodException, InvocationTargetException
{
/* get first line only */
Scanner scanner = new Scanner(System.in);
String line1 = scanner.nextLine();
scanner.close();
/* parse first line */
scanner = new Scanner(line1);
if (!scanner.hasNextInt())
throw new InputMismatchException("Invalid first param. No integer");
val1 = new CalcInteger(scanner.nextInt());
if (!scanner.hasNextInt())
throw new InputMismatchException("Invalid second param. No integer");
val2 = new CalcInteger(scanner.nextInt());
if (!scanner.hasNext())
throw new InputMismatchException("Invalid operator");
op = new CalcOperator(scanner.next());
/* check for additional chars */
if (scanner.hasNext())
throw new InputMismatchException("Invalid chars at the end of line");
scanner.close();
return true;
}
/**
* main method
*
* @param args not used
*/
public static void main(String[] args)
{
try
{
/* parse stdin */
parse(System.in);
/* do calculation */
Object newval = val1.calc(val2, op);
if (!(newval instanceof CalcInteger))
throw new InputMismatchException("Unrecognized classtype returned from operation");
/* print result to stdout */
System.out.println(((CalcInteger) newval).get());
}
catch(Throwable e)
{
System.out.println("FALSCHE EINGABE");
}
}
}