olabini / ioke

ioke is a new language for the JVM, based on Io and other languages.

This URL has Read+Write access

ioke / src / main / ioke / lang / TypeCheckingArgumentsDefinition.java
raw normal view history
45c88026 » melwin 2009-01-18 Add type checking arguments... 1 package ioke.lang;
2
3 import ioke.lang.exceptions.ControlFlow;
4
5 import java.util.ArrayList;
6 import java.util.Collection;
7 import java.util.List;
8 import java.util.Map;
9
10 public class TypeCheckingArgumentsDefinition extends DefaultArgumentsDefinition {
11 private List<Object> mustMimic = new ArrayList<Object>();
12 private Object receiverMustMimic;
13 private List<Argument> arguments;
14
15 private TypeCheckingArgumentsDefinition(List<Argument> arguments,
16 Collection<String> keywords, String rest, String krest, int min,
17 int max, boolean restUneval, List<Object> mustMimic,
18 Object receiverMustMimic) {
19 super(arguments, keywords, rest, krest, min, max, restUneval);
20 this.arguments = arguments;
21 this.mustMimic = mustMimic;
22 this.receiverMustMimic = receiverMustMimic;
23 }
24
25 private Object convertToMimic(Object mimic, Object on, IokeObject message,
26 IokeObject context) throws ControlFlow {
27 if (mimic == null) {
28 return on;
29 } else {
30 return IokeObject.as(mimic).convertToThis(on, message, context);
31 }
32
33 }
34
35 public Object getValidatedArgumentsAndReceiver(IokeObject context,
36 IokeObject message, Object on,
37 List<Object> argumentsWithoutKeywords,
38 Map<String, Object> givenKeywords) throws ControlFlow {
39
40 getEvaluatedArguments(context, message, on,
41 argumentsWithoutKeywords, givenKeywords);
42
43 int ix = 0;
44 for (int i = 0, j = this.arguments.size(); i < j; i++) {
45 Argument a = this.arguments.get(i);
46
47 if (a instanceof KeywordArgument) {
48 String name = a.getName() + ":";
49 Object given = givenKeywords.get(name);
50 if (given != null) {
51 givenKeywords.put(name, convertToMimic(
52 mustMimic.get(i), given, message, context));
53 }
54 } else {
55 argumentsWithoutKeywords.set(ix, convertToMimic(mustMimic.get(i),
56 argumentsWithoutKeywords.get(ix), message,
57 context));
58 ix++;
59 }
60 }
61
62 return convertToMimic(receiverMustMimic, on, message, context);
63 }
64
3f249e5d » melwin 2009-01-18 Type checking java method a... 65 public static TypeCheckingArgumentsDefinition empty() {
66 return emptyButReceiverMustMimic(null);
67 }
68
69 public static TypeCheckingArgumentsDefinition emptyButReceiverMustMimic(Object mimic) {
70 return new TypeCheckingArgumentsDefinition(new ArrayList<Argument>(), new ArrayList<String>(), null, null, 0, 0, false, new ArrayList<Object>(), mimic);
71 }
72
45c88026 » melwin 2009-01-18 Add type checking arguments... 73 public static class Builder extends DefaultArgumentsDefinition.Builder {
74 private List<Object> mustMimic = new ArrayList<Object>();
75 private Object receiverMustMimic;
76
77 private boolean setMimic = true;
78
79 private void next() {
80 if (!setMimic)
81 mustMimic.add(null);
82 else
83 setMimic = false;
84 }
85
86 public Builder whichMustMimic(Object mimic) {
87 mustMimic.add(mimic);
88 return this;
89 }
90
91 public Builder receiverMustMimic(Object mimic) {
92 this.receiverMustMimic = mimic;
93 return this;
94 }
95
96 @Override
97 public Builder withKeyword(String name) {
98 super.withKeyword(name);
99 next();
100 return this;
101 }
102
103 @Override
104 public Builder withKeywordRest(String name) {
105 super.withKeywordRest(name);
106 next();
107 return this;
108 }
109
110 @Override
111 public Builder withOptionalPositional(String name, String defaultValue) {
112 super.withOptionalPositional(name, defaultValue);
113 next();
114 return this;
115 }
116
117 @Override
118 public Builder withOptionalPositionalUnevaluated(String name) {
119 super.withOptionalPositionalUnevaluated(name);
120 next();
121 return this;
122 }
123
124 @Override
125 public Builder withRequiredPositional(String name) {
126 super.withRequiredPositional(name);
127 next();
128 return this;
129 }
130
131 @Override
132 public Builder withRequiredPositionalUnevaluated(String name) {
133 super.withRequiredPositionalUnevaluated(name);
134 next();
135 return this;
136 }
137
138 @Override
139 public Builder withRest(String name) {
140 super.withRest(name);
141 next();
142 return this;
143 }
144
145 @Override
146 public Builder withRestUnevaluated(String name) {
147 super.withRestUnevaluated(name);
148 next();
149 return this;
150 }
151
152 @Override
153 public TypeCheckingArgumentsDefinition getArguments() {
154 next();
155 return new TypeCheckingArgumentsDefinition(arguments, keywords,
156 rest, krest, min, max, restUneval, mustMimic,
157 receiverMustMimic);
158 }
159 }
160
161 public static Builder builder() {
162 return new Builder();
163 }
164 }