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;
}
}
/**
* Calculator
*
* @version 1.0
* @author Manuel Mausz (manuel at mausz.at)
* @author http://manuel.mausz.at/
*/
public class Calculator
{
private static Complex val1;
private static Complex val2;
private static CalcOperator op;
/**
* read values and operator from src
* only allow syntax: "op real1 img1 real2 img2 ..."
*
* @param src input stream
* @return boolean true on success, false otherwise
* @throws InputMismatchException
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
public static boolean parse(InputStream src)
throws InputMismatchException, NoSuchMethodException, InvocationTargetException
{
int real, img;
/* get first line only */
Scanner scanner = new Scanner(System.in);
if (!scanner.hasNextLine())
return false;
String line1 = scanner.nextLine();
scanner.close();
/* parse first line */
scanner = new Scanner(line1);
/* scan operator */
if (!scanner.hasNext())
throw new InputMismatchException("Invalid operator");
op = new CalcOperator(scanner.next());
/* scan first complex value */
if (!scanner.hasNextInt())
throw new InputMismatchException("Invalid real part. No integer");
real = scanner.nextInt();
if (!scanner.hasNextInt())
throw new InputMismatchException("Invalid imaginary param. No integer");
img = scanner.nextInt();
val1 = new Complex(real, img);
/* check operator. this will also be done implicitly in calc() */
if (!val1.isSupported(op))
throw new NoSuchMethodException("Method for operator '" + op.get() + "' not found");
/* scan other complex values */
while(scanner.hasNext())
{
if (!scanner.hasNextInt())
throw new InputMismatchException("Invalid real param. No integer");
real = scanner.nextInt();
if (!scanner.hasNextInt())
throw new InputMismatchException("Invalid imaginary param. No integer");
img = scanner.nextInt();
val2 = new Complex(real, img);
/* do calculation */
val1.calc(val2, op);
}
scanner.close();
return true;
}
/**
* main method
*
* @param args not used
*/
public static void main(String[] args)
{
val1 = new Complex(0, 0);
try
{
/* parse stdin */
parse(System.in);
/* print result to stdout */
System.out.println(((Complex) val1).toString());
}
catch(Throwable e)
{
System.out.println("FALSCHE EINGABE");
}
}
}