Cleanup whitespace

1 files changed, 384 insertions, 384 deletions

diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Functions.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Functions.java
index 2b44633..c8be260 100644
--- a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Functions.java
+++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Functions.java
@@ -48,415 +48,415 @@ import pl.edu.mimuw.cloudatlas.model.ValueSet;
 import pl.edu.mimuw.cloudatlas.model.ValueTime;
 
 class Functions {
-	private static Functions instance = null;
+    private static Functions instance = null;
 
-	private static final UnaryOperation ROUND = new UnaryOperation() {
-		@Override
-		public Value perform(Value v) {
-			if(v.getType().isCompatible(TypePrimitive.DOUBLE)) {
-				if(v.isNull())
-					return new ValueDouble(null);
-				return new ValueDouble((double)Math.round(((ValueDouble)v).getValue()));
-			}
-			throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + ".");
-		}
-	};
+    private static final UnaryOperation ROUND = new UnaryOperation() {
+        @Override
+        public Value perform(Value v) {
+            if(v.getType().isCompatible(TypePrimitive.DOUBLE)) {
+                if(v.isNull())
+                    return new ValueDouble(null);
+                return new ValueDouble((double)Math.round(((ValueDouble)v).getValue()));
+            }
+            throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + ".");
+        }
+    };
 
-	private static final UnaryOperation FLOOR = new UnaryOperation() {
-		@Override
-		public Value perform(Value v) {
-			if(v.getType().isCompatible(TypePrimitive.DOUBLE)) {
-				if(v.isNull())
-					return new ValueDouble(null);
-				return new ValueDouble((double)Math.floor(((ValueDouble)v).getValue()));
-			}
-			throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + ".");
-		}
-	};
+    private static final UnaryOperation FLOOR = new UnaryOperation() {
+        @Override
+        public Value perform(Value v) {
+            if(v.getType().isCompatible(TypePrimitive.DOUBLE)) {
+                if(v.isNull())
+                    return new ValueDouble(null);
+                return new ValueDouble((double)Math.floor(((ValueDouble)v).getValue()));
+            }
+            throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + ".");
+        }
+    };
 
-	private static final UnaryOperation CEIL = new UnaryOperation() {
-		@Override
-		public Value perform(Value v) {
-			if(v.getType().isCompatible(TypePrimitive.DOUBLE)) {
-				if(v.isNull())
-					return new ValueDouble(null);
-				return new ValueDouble((double)Math.ceil(((ValueDouble)v).getValue()));
-			}
-			throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + ".");
-		}
-	};
+    private static final UnaryOperation CEIL = new UnaryOperation() {
+        @Override
+        public Value perform(Value v) {
+            if(v.getType().isCompatible(TypePrimitive.DOUBLE)) {
+                if(v.isNull())
+                    return new ValueDouble(null);
+                return new ValueDouble((double)Math.ceil(((ValueDouble)v).getValue()));
+            }
+            throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + ".");
+        }
+    };
 
-	private static final AggregationOperation COUNT = new AggregationOperation() {
-		@Override
-		public ValueInt perform(ValueList values) {
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null) {
-				return new ValueInt(null);
-			}
-			return new ValueInt((long)nlist.size());
-		}
-	};
+    private static final AggregationOperation COUNT = new AggregationOperation() {
+        @Override
+        public ValueInt perform(ValueList values) {
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null) {
+                return new ValueInt(null);
+            }
+            return new ValueInt((long)nlist.size());
+        }
+    };
 
-	private static final AggregationOperation SUM = new AggregationOperation() {
-		@Override
-		public Value perform(ValueList values) {
-			Type elementType = ((TypeCollection)values.getType()).getElementType();
-			PrimaryType primaryType = elementType.getPrimaryType();
+    private static final AggregationOperation SUM = new AggregationOperation() {
+        @Override
+        public Value perform(ValueList values) {
+            Type elementType = ((TypeCollection)values.getType()).getElementType();
+            PrimaryType primaryType = elementType.getPrimaryType();
 
-			if(primaryType != PrimaryType.INT && primaryType != PrimaryType.DOUBLE && primaryType != PrimaryType.DURATION
-					&& primaryType != PrimaryType.NULL) {
-				throw new IllegalArgumentException("Aggregation doesn't support type: " + elementType + ".");
-			}
+            if(primaryType != PrimaryType.INT && primaryType != PrimaryType.DOUBLE && primaryType != PrimaryType.DURATION
+                    && primaryType != PrimaryType.NULL) {
+                throw new IllegalArgumentException("Aggregation doesn't support type: " + elementType + ".");
+            }
 
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null || nlist.isEmpty()) {
-				return ValueNull.getInstance();
-			}
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null || nlist.isEmpty()) {
+                return ValueNull.getInstance();
+            }
 
-			Value result = nlist.get(0).getDefaultValue();
+            Value result = nlist.get(0).getDefaultValue();
 
-			for(Value v : nlist) {
-				result = result.addValue(v);
-			}
+            for(Value v : nlist) {
+                result = result.addValue(v);
+            }
 
             return result;
-		}
-	};
+        }
+    };
 
-	private static final AggregationOperation AVERAGE = new AggregationOperation() {
-		@Override
-		public Value perform(ValueList values) {
-			Type elementType = ((TypeCollection)values.getType()).getElementType();
-			PrimaryType primaryType = elementType.getPrimaryType();
+    private static final AggregationOperation AVERAGE = new AggregationOperation() {
+        @Override
+        public Value perform(ValueList values) {
+            Type elementType = ((TypeCollection)values.getType()).getElementType();
+            PrimaryType primaryType = elementType.getPrimaryType();
 
-			if(primaryType != PrimaryType.INT && primaryType != PrimaryType.DOUBLE && primaryType != PrimaryType.DURATION
-					&& primaryType != PrimaryType.NULL) {
-				throw new IllegalArgumentException("Aggregation doesn't support type: " + elementType + ".");
-			}
+            if(primaryType != PrimaryType.INT && primaryType != PrimaryType.DOUBLE && primaryType != PrimaryType.DURATION
+                    && primaryType != PrimaryType.NULL) {
+                throw new IllegalArgumentException("Aggregation doesn't support type: " + elementType + ".");
+            }
 
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null || nlist.isEmpty()) {
-				return ValueNull.getInstance();
-			}
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null || nlist.isEmpty()) {
+                return ValueNull.getInstance();
+            }
 
-			Value result = nlist.get(0).getDefaultValue();
+            Value result = nlist.get(0).getDefaultValue();
 
-			for(Value v : nlist) {
-				result = result.addValue(v);
-			}
-			Value size = primaryType == PrimaryType.DOUBLE? new ValueDouble((double)nlist.size()) : new ValueInt(
-					(long)nlist.size());
-			return result.divide(size);
-		}
-	};
+            for(Value v : nlist) {
+                result = result.addValue(v);
+            }
+            Value size = primaryType == PrimaryType.DOUBLE? new ValueDouble((double)nlist.size()) : new ValueInt(
+                    (long)nlist.size());
+            return result.divide(size);
+        }
+    };
 
-	private static final AggregationOperation AND = new AggregationOperation() {
-		@Override
-		public ValueBoolean perform(ValueList values) { // lazy
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null) {
-				return new ValueBoolean(null);
-			} else if(values.isEmpty()) {
-				return new ValueBoolean(true);
-			}
-			for(Value v : nlist) {
-				if(v.getType().isCompatible(TypePrimitive.BOOLEAN)) {
-					if(v.isNull() || !((ValueBoolean)v).getValue())
-						return new ValueBoolean(false);
-				} else
-					throw new IllegalArgumentException("Aggregation doesn't support type: " + v.getType() + ".");
-			}
-			return new ValueBoolean(true);
-		}
-	};
+    private static final AggregationOperation AND = new AggregationOperation() {
+        @Override
+        public ValueBoolean perform(ValueList values) { // lazy
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null) {
+                return new ValueBoolean(null);
+            } else if(values.isEmpty()) {
+                return new ValueBoolean(true);
+            }
+            for(Value v : nlist) {
+                if(v.getType().isCompatible(TypePrimitive.BOOLEAN)) {
+                    if(v.isNull() || !((ValueBoolean)v).getValue())
+                        return new ValueBoolean(false);
+                } else
+                    throw new IllegalArgumentException("Aggregation doesn't support type: " + v.getType() + ".");
+            }
+            return new ValueBoolean(true);
+        }
+    };
 
-	private static final AggregationOperation OR = new AggregationOperation() {
-		@Override
-		public ValueBoolean perform(ValueList values) { // lazy
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null) {
-				return new ValueBoolean(null);
-			} else if(values.isEmpty()) {
-				return new ValueBoolean(false);
-			}
-			for(Value v : nlist) {
-				if(v.getType().isCompatible(TypePrimitive.BOOLEAN)) {
-					if(v.isNull() || ((ValueBoolean)v).getValue())
-						return new ValueBoolean(true);
-				} else
-					throw new IllegalArgumentException("Aggregation doesn't support type: " + v.getType() + ".");
-			}
-			return new ValueBoolean(false);
-		}
-	};
+    private static final AggregationOperation OR = new AggregationOperation() {
+        @Override
+        public ValueBoolean perform(ValueList values) { // lazy
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null) {
+                return new ValueBoolean(null);
+            } else if(values.isEmpty()) {
+                return new ValueBoolean(false);
+            }
+            for(Value v : nlist) {
+                if(v.getType().isCompatible(TypePrimitive.BOOLEAN)) {
+                    if(v.isNull() || ((ValueBoolean)v).getValue())
+                        return new ValueBoolean(true);
+                } else
+                    throw new IllegalArgumentException("Aggregation doesn't support type: " + v.getType() + ".");
+            }
+            return new ValueBoolean(false);
+        }
+    };
 
-	private static final AggregationOperation MIN = new AggregationOperation() {
-		@Override
-		public Value perform(ValueList values) {
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null || nlist.isEmpty()) {
-				return ValueNull.getInstance();
-			}
-			Value result = nlist.get(0);
-			for(Value v : nlist) {
-				if(((ValueBoolean)v.isLowerThan(result)).getValue()) {
-					result = v;
-				}
-			}
-			return result;
-		}
-	};
+    private static final AggregationOperation MIN = new AggregationOperation() {
+        @Override
+        public Value perform(ValueList values) {
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null || nlist.isEmpty()) {
+                return ValueNull.getInstance();
+            }
+            Value result = nlist.get(0);
+            for(Value v : nlist) {
+                if(((ValueBoolean)v.isLowerThan(result)).getValue()) {
+                    result = v;
+                }
+            }
+            return result;
+        }
+    };
 
-	private static final AggregationOperation MAX = new AggregationOperation() {
-		@Override
-		public Value perform(ValueList values) {
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null || nlist.isEmpty()) {
-				return ValueNull.getInstance();
-			}
-			Value result = nlist.get(0);
-			for(Value v : nlist) {
-				if(((ValueBoolean)v.isLowerThan(result)).negate().and(v.isEqual(result).negate()).getValue()) {
-					result = v;
-				}
-			}
-			return result;
-		}
-	};
+    private static final AggregationOperation MAX = new AggregationOperation() {
+        @Override
+        public Value perform(ValueList values) {
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null || nlist.isEmpty()) {
+                return ValueNull.getInstance();
+            }
+            Value result = nlist.get(0);
+            for(Value v : nlist) {
+                if(((ValueBoolean)v.isLowerThan(result)).negate().and(v.isEqual(result).negate()).getValue()) {
+                    result = v;
+                }
+            }
+            return result;
+        }
+    };
 
-	private static final TransformOperation UNFOLD = new TransformOperation() {
-		@Override
-		public ValueList perform(ValueList values) {
-			if(!((TypeCollection)values.getType()).getElementType().isCollection()) {
-				throw new IllegalArgumentException("All elements must have a collection compatible type.");
-			}
-			ValueList nlist = Result.filterNullsList(values);
-			if(nlist.getValue() == null) {
-				return new ValueList(null,
-						((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType());
-			} else if(nlist.isEmpty()) {
-				return new ValueList(
-						((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType());
-			}
-			List<Value> ret = new ArrayList<Value>();
-			for(Value v : nlist) {
-				if(v.getType().getPrimaryType() == Type.PrimaryType.SET) {
-					ret.addAll((ValueSet)v);
-				} else if(v.getType().getPrimaryType() == Type.PrimaryType.LIST) {
-					ret.addAll((ValueList)v);
-				}
-			}
-			return new ValueList(ret,
-					((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType());
-		}
-	};
+    private static final TransformOperation UNFOLD = new TransformOperation() {
+        @Override
+        public ValueList perform(ValueList values) {
+            if(!((TypeCollection)values.getType()).getElementType().isCollection()) {
+                throw new IllegalArgumentException("All elements must have a collection compatible type.");
+            }
+            ValueList nlist = Result.filterNullsList(values);
+            if(nlist.getValue() == null) {
+                return new ValueList(null,
+                        ((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType());
+            } else if(nlist.isEmpty()) {
+                return new ValueList(
+                        ((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType());
+            }
+            List<Value> ret = new ArrayList<Value>();
+            for(Value v : nlist) {
+                if(v.getType().getPrimaryType() == Type.PrimaryType.SET) {
+                    ret.addAll((ValueSet)v);
+                } else if(v.getType().getPrimaryType() == Type.PrimaryType.LIST) {
+                    ret.addAll((ValueList)v);
+                }
+            }
+            return new ValueList(ret,
+                    ((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType());
+        }
+    };
 
-	private static final TransformOperation DISTINCT = new TransformOperation() {
-		@Override
-		public ValueList perform(ValueList values) {
-			if(values.isEmpty())
-				return new ValueList(((TypeCollection)values.getType()).getElementType());
-			List<Value> ret = new ArrayList<Value>();
-			for(Value v : values) {
-				if(!ret.contains(v)) {
-					ret.add(v);
-				}
-			}
-			return new ValueList(ret, ((TypeCollection)values.getType()).getElementType());
-		}
-	};
+    private static final TransformOperation DISTINCT = new TransformOperation() {
+        @Override
+        public ValueList perform(ValueList values) {
+            if(values.isEmpty())
+                return new ValueList(((TypeCollection)values.getType()).getElementType());
+            List<Value> ret = new ArrayList<Value>();
+            for(Value v : values) {
+                if(!ret.contains(v)) {
+                    ret.add(v);
+                }
+            }
+            return new ValueList(ret, ((TypeCollection)values.getType()).getElementType());
+        }
+    };
 
-	private static final TransformOperation SORT = new TransformOperation() {
-		@Override
-		public ValueList perform(ValueList values) {
-			if(values.isEmpty())
-				return new ValueList(((TypeCollection)values.getType()).getElementType());
-			List<Value> ret = new ArrayList<Value>();
-			ret.addAll(values);
-			Collections.sort(ret, new Comparator<Value>() {
-				public int compare(Value v1, Value v2) {
-					if(((ValueBoolean)v1.isLowerThan(v2)).getValue()) {
-						return -1;
-					} else if(((ValueBoolean)v1.isEqual(v2)).getValue()) {
-						return 0;
-					} else {
-						return 1;
-					}
-				}
-			});
-			return new ValueList(ret, ((TypeCollection)values.getType()).getElementType());
-		}
-	};
+    private static final TransformOperation SORT = new TransformOperation() {
+        @Override
+        public ValueList perform(ValueList values) {
+            if(values.isEmpty())
+                return new ValueList(((TypeCollection)values.getType()).getElementType());
+            List<Value> ret = new ArrayList<Value>();
+            ret.addAll(values);
+            Collections.sort(ret, new Comparator<Value>() {
+                public int compare(Value v1, Value v2) {
+                    if(((ValueBoolean)v1.isLowerThan(v2)).getValue()) {
+                        return -1;
+                    } else if(((ValueBoolean)v1.isEqual(v2)).getValue()) {
+                        return 0;
+                    } else {
+                        return 1;
+                    }
+                }
+            });
+            return new ValueList(ret, ((TypeCollection)values.getType()).getElementType());
+        }
+    };
 
-	private final ValueTime EPOCH;
+    private final ValueTime EPOCH;
 
-	private Functions() {
-		try {
-			EPOCH = new ValueTime("2000/01/01 00:00:00.000");
-		} catch(ParseException exception) {
-			throw new InternalInterpreterException("Cannot parse time when creating an EPOCH object.\n"
-					+ exception.getMessage());
-		}
-	}
+    private Functions() {
+        try {
+            EPOCH = new ValueTime("2000/01/01 00:00:00.000");
+        } catch(ParseException exception) {
+            throw new InternalInterpreterException("Cannot parse time when creating an EPOCH object.\n"
+                    + exception.getMessage());
+        }
+    }
 
-	public static Functions getInstance() {
-		if(instance == null)
-			instance = new Functions();
-		return instance;
-	}
+    public static Functions getInstance() {
+        if(instance == null)
+            instance = new Functions();
+        return instance;
+    }
 
-	public Result evaluate(String name, List<Result> arguments) {
-		switch(name) {
-			case "round":
-				if(arguments.size() == 1)
-					return arguments.get(0).unaryOperation(ROUND);
-				break;
-			case "floor":
-				if(arguments.size() == 1)
-					return arguments.get(0).unaryOperation(FLOOR);
-				break;
-			case "ceil":
-				if(arguments.size() == 1)
-					return arguments.get(0).unaryOperation(CEIL);
-				break;
-			case "now":
-				if(arguments.size() == 0)
-					return new ResultSingle(new ValueTime(Calendar.getInstance().getTimeInMillis()));
-				break;
-			case "epoch":
-				if(arguments.size() == 0)
-					return new ResultSingle(EPOCH);
-				break;
-			case "count":
-				if(arguments.size() == 1)
-					return arguments.get(0).aggregationOperation(COUNT);
-				break;
-			case "size":
-				if(arguments.size() == 1)
-					return arguments.get(0).valueSize();
-				break;
-			case "sum":
-				if(arguments.size() == 1)
-					return arguments.get(0).aggregationOperation(SUM);
-				break;
-			case "avg":
-				if(arguments.size() == 1)
-					return arguments.get(0).aggregationOperation(AVERAGE);
-				break;
-			case "land":
-				if(arguments.size() == 1)
-					return arguments.get(0).aggregationOperation(AND);
-				break;
-			case "lor":
-				if(arguments.size() == 1)
-					return arguments.get(0).aggregationOperation(OR);
-				break;
-			case "min":
-				if(arguments.size() == 1)
-					return arguments.get(0).aggregationOperation(MIN);
-				break;
-			case "max":
-				if(arguments.size() == 1)
-					return arguments.get(0).aggregationOperation(MAX);
-				break;
-			case "unfold":
-				if(arguments.size() == 1)
-					return arguments.get(0).transformOperation(UNFOLD);
-				break;
-			case "distinct":
-				if(arguments.size() == 1)
-					return arguments.get(0).transformOperation(DISTINCT);
-				break;
-			case "sort":
-				if(arguments.size() == 1)
-					return arguments.get(0).transformOperation(SORT);
-				break;
-			case "filterNulls":
-				if(arguments.size() == 1)
-					return arguments.get(0).filterNulls();
-				break;
-			case "first":
-				if(arguments.size() == 2) {
-					Value size = arguments.get(0).getValue();
-					if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0)
-						return arguments.get(1).first(((ValueInt)size).getValue().intValue());
-					throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER
-							+ " and be >= 0.");
-				}
-				break;
-			case "last":
-				if(arguments.size() == 2) {
-					Value size = arguments.get(0).getValue();
-					if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0)
-						return arguments.get(1).last(((ValueInt)size).getValue().intValue());
-					throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER
-							+ " and be >= 0.");
-				}
-				break;
-			case "random":
-				if(arguments.size() == 2) {
-					Value size = arguments.get(0).getValue();
-					if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0)
-						return arguments.get(1).random(((ValueInt)size).getValue().intValue());
-					throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER
-							+ " and be >= 0.");
-				}
-				break;
-			case "to_boolean":
-				if(arguments.size() == 1)
-					return arguments.get(0).convertTo(TypePrimitive.BOOLEAN);
-				break;
-			case "to_contact":
-				if(arguments.size() == 1)
-					return arguments.get(0).convertTo(TypePrimitive.CONTACT);
-				break;
-			case "to_double":
-				if(arguments.size() == 1)
-					return arguments.get(0).convertTo(TypePrimitive.DOUBLE);
-				break;
-			case "to_duration":
-				if(arguments.size() == 1)
-					return arguments.get(0).convertTo(TypePrimitive.DURATION);
-				break;
-			case "to_integer":
-				if(arguments.size() == 1)
-					return arguments.get(0).convertTo(TypePrimitive.INTEGER);
-				break;
-			case "to_string":
-				if(arguments.size() == 1)
-					return arguments.get(0).convertTo(TypePrimitive.STRING);
-				break;
-			case "to_time":
-				if(arguments.size() == 1)
-					return arguments.get(0).convertTo(TypePrimitive.TIME);
-				break;
-			case "to_set":
-				if(arguments.size() == 1) {
-					Type t = arguments.get(0).getType();
-					if(t.isCollection()) {
-						Type elementType = ((TypeCollection)t).getElementType();
-						return arguments.get(0).convertTo(new TypeCollection(Type.PrimaryType.SET, elementType));
-					}
-					throw new IllegalArgumentException("First argument must be a collection.");
-				}
-				break;
-			case "to_list":
-				if(arguments.size() == 1) {
-					Type t = arguments.get(0).getType();
-					if(t.isCollection()) {
-						Type elementType = ((TypeCollection)t).getElementType();
-						return arguments.get(0).convertTo(new TypeCollection(Type.PrimaryType.LIST, elementType));
-					}
-					throw new IllegalArgumentException("First argument must be a collection.");
-				}
-				break;
-			case "isNull":
-				if(arguments.size() == 1)
-					return arguments.get(0).isNull();
-				break;
-			default:
-				throw new IllegalArgumentException("Illegal function name.");
-		}
-		throw new IllegalArgumentException("Illegal number of arguments.");
-	}
+    public Result evaluate(String name, List<Result> arguments) {
+        switch(name) {
+            case "round":
+                if(arguments.size() == 1)
+                    return arguments.get(0).unaryOperation(ROUND);
+                break;
+            case "floor":
+                if(arguments.size() == 1)
+                    return arguments.get(0).unaryOperation(FLOOR);
+                break;
+            case "ceil":
+                if(arguments.size() == 1)
+                    return arguments.get(0).unaryOperation(CEIL);
+                break;
+            case "now":
+                if(arguments.size() == 0)
+                    return new ResultSingle(new ValueTime(Calendar.getInstance().getTimeInMillis()));
+                break;
+            case "epoch":
+                if(arguments.size() == 0)
+                    return new ResultSingle(EPOCH);
+                break;
+            case "count":
+                if(arguments.size() == 1)
+                    return arguments.get(0).aggregationOperation(COUNT);
+                break;
+            case "size":
+                if(arguments.size() == 1)
+                    return arguments.get(0).valueSize();
+                break;
+            case "sum":
+                if(arguments.size() == 1)
+                    return arguments.get(0).aggregationOperation(SUM);
+                break;
+            case "avg":
+                if(arguments.size() == 1)
+                    return arguments.get(0).aggregationOperation(AVERAGE);
+                break;
+            case "land":
+                if(arguments.size() == 1)
+                    return arguments.get(0).aggregationOperation(AND);
+                break;
+            case "lor":
+                if(arguments.size() == 1)
+                    return arguments.get(0).aggregationOperation(OR);
+                break;
+            case "min":
+                if(arguments.size() == 1)
+                    return arguments.get(0).aggregationOperation(MIN);
+                break;
+            case "max":
+                if(arguments.size() == 1)
+                    return arguments.get(0).aggregationOperation(MAX);
+                break;
+            case "unfold":
+                if(arguments.size() == 1)
+                    return arguments.get(0).transformOperation(UNFOLD);
+                break;
+            case "distinct":
+                if(arguments.size() == 1)
+                    return arguments.get(0).transformOperation(DISTINCT);
+                break;
+            case "sort":
+                if(arguments.size() == 1)
+                    return arguments.get(0).transformOperation(SORT);
+                break;
+            case "filterNulls":
+                if(arguments.size() == 1)
+                    return arguments.get(0).filterNulls();
+                break;
+            case "first":
+                if(arguments.size() == 2) {
+                    Value size = arguments.get(0).getValue();
+                    if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0)
+                        return arguments.get(1).first(((ValueInt)size).getValue().intValue());
+                    throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER
+                            + " and be >= 0.");
+                }
+                break;
+            case "last":
+                if(arguments.size() == 2) {
+                    Value size = arguments.get(0).getValue();
+                    if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0)
+                        return arguments.get(1).last(((ValueInt)size).getValue().intValue());
+                    throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER
+                            + " and be >= 0.");
+                }
+                break;
+            case "random":
+                if(arguments.size() == 2) {
+                    Value size = arguments.get(0).getValue();
+                    if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0)
+                        return arguments.get(1).random(((ValueInt)size).getValue().intValue());
+                    throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER
+                            + " and be >= 0.");
+                }
+                break;
+            case "to_boolean":
+                if(arguments.size() == 1)
+                    return arguments.get(0).convertTo(TypePrimitive.BOOLEAN);
+                break;
+            case "to_contact":
+                if(arguments.size() == 1)
+                    return arguments.get(0).convertTo(TypePrimitive.CONTACT);
+                break;
+            case "to_double":
+                if(arguments.size() == 1)
+                    return arguments.get(0).convertTo(TypePrimitive.DOUBLE);
+                break;
+            case "to_duration":
+                if(arguments.size() == 1)
+                    return arguments.get(0).convertTo(TypePrimitive.DURATION);
+                break;
+            case "to_integer":
+                if(arguments.size() == 1)
+                    return arguments.get(0).convertTo(TypePrimitive.INTEGER);
+                break;
+            case "to_string":
+                if(arguments.size() == 1)
+                    return arguments.get(0).convertTo(TypePrimitive.STRING);
+                break;
+            case "to_time":
+                if(arguments.size() == 1)
+                    return arguments.get(0).convertTo(TypePrimitive.TIME);
+                break;
+            case "to_set":
+                if(arguments.size() == 1) {
+                    Type t = arguments.get(0).getType();
+                    if(t.isCollection()) {
+                        Type elementType = ((TypeCollection)t).getElementType();
+                        return arguments.get(0).convertTo(new TypeCollection(Type.PrimaryType.SET, elementType));
+                    }
+                    throw new IllegalArgumentException("First argument must be a collection.");
+                }
+                break;
+            case "to_list":
+                if(arguments.size() == 1) {
+                    Type t = arguments.get(0).getType();
+                    if(t.isCollection()) {
+                        Type elementType = ((TypeCollection)t).getElementType();
+                        return arguments.get(0).convertTo(new TypeCollection(Type.PrimaryType.LIST, elementType));
+                    }
+                    throw new IllegalArgumentException("First argument must be a collection.");
+                }
+                break;
+            case "isNull":
+                if(arguments.size() == 1)
+                    return arguments.get(0).isNull();
+                break;
+            default:
+                throw new IllegalArgumentException("Illegal function name.");
+        }
+        throw new IllegalArgumentException("Illegal number of arguments.");
+    }
 }