Miscellany

/*
 * pascalPlugin.java
 *
 * Created on February 25, 2007, 12:18 AM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package processing;

import java.lang.reflect.Field;
import java.util.ArrayList;
import pascalTypes.Int;
import pascalTypes.Char;
import pascalTypes.VarChar;
import pascalTypes.VarInt;
import pascalTypes.VarString;
import pascalTypes.pString;
import pascalTypes.pascalType;
import pascalTypes.types;

/**
 *
 * @author lardmaster
 */
public abstract class pascalPlugin {
    public abstract String getName();
    public abstract class argsObject {
        public boolean argsMatch(ArrayList<types> typesList) {
            if(typesList.size()!=this.getClass().getFields().length)
                return false;
            for(int i=0; i<typesList.size(); i++) {
                Class type;
                switch(typesList.get(i)) {
                    case Char:
                        type=Char.class;
                    case Int:
                        type=Int.class;
                    case pString:
                        type=pString.class;
                    case VarString:
                        type=VarString.class;
                    case VarInt:
                        type=VarInt.class;
                    case VarChar:
                        type=VarChar.class;
                    default:
                        type=null;
                }
                if(type==null)
                    continue;
                if(!type.equals(this.getClass().getFields()[i].getClass()))
                    return false;                                
            }
            return true;
        }
        
        private ArrayList<types> getTypesList(ArrayList<pascalType> argsList) {
            ArrayList<types> result=new ArrayList<types>();
            for(pascalType p:argsList) {
                result.add(p.getType());
            }
            return result;
        }
        public argsObject(ArrayList<pascalType> arrayOfArgs) {
            Class thisClass=this.getClass();
            Field[] fields=thisClass.getFields();
            if(!argsMatch(getTypesList(arrayOfArgs))) {
                throw new IllegalArgumentException("Args array does not match");
            }
            for(int i=0; i<arrayOfArgs.size(); i++) {
                boolean foundMatch=false;
                switch(arrayOfArgs.get(i).getType()) {
                    case Char:
                        if(fields[i].getType().equals(char.class))
                            
                            try {
                                fields[i].setChar(this,((Char)arrayOfArgs.get(i)).get());
                                foundMatch=true;
                            } catch (IllegalArgumentException ex) {
                                ex.printStackTrace();
                            } catch (IllegalAccessException ex) {
                                ex.printStackTrace();
                            }
                    case Int:
                        if(fields[i].getType().equals(int.class))
                            
                            try {
                                fields[i].setInt(this,((Int)arrayOfArgs.get(i)).get());
                                foundMatch=true;
                            } catch (IllegalArgumentException ex) {
                                ex.printStackTrace();
                            } catch (IllegalAccessException ex) {
                                ex.printStackTrace();
                            }
                    case pString:
                        if(fields[i].getType().equals(String.class))
                            
                            try {
                                fields[i].set(this,((pString)arrayOfArgs.get(i)).get());
                                foundMatch=true;
                            } catch (IllegalArgumentException ex) {
                                ex.printStackTrace();
                            } catch (IllegalAccessException ex) {
                                ex.printStackTrace();
                            }
                    case VarChar:
                        
                        try {
                            fields[i].set(this,((VarChar)arrayOfArgs.get(i)).get());
                        } catch (IllegalArgumentException ex) {
                            ex.printStackTrace();
                        } catch (IllegalAccessException ex) {
                            ex.printStackTrace();
                        }
                    case VarString:
                        
                        try {
                            fields[i].set(this,((VarString)arrayOfArgs.get(i)).get());
                        } catch (IllegalArgumentException ex) {
                            ex.printStackTrace();
                        } catch (IllegalAccessException ex) {
                            ex.printStackTrace();
                        }
                    case VarInt:
                        
                        try {
                            fields[i].set(this,((VarInt)arrayOfArgs.get(i)).get());
                        } catch (IllegalArgumentException ex) {
                            ex.printStackTrace();
                        } catch (IllegalAccessException ex) {
                            ex.printStackTrace();
                        }
                }
                if(!foundMatch)
                    throw new IllegalArgumentException("Wrong Types of Variables in array.");
            }
        }
    };
    public argsObject argsObject(ArrayList<pascalType> arrayOfArgs) {
        return new argsObject(arrayOfArgs);
    }
    public abstract String getPascalName();
    public abstract pascalType process(argsObject args);
}