001: /*
002: * JFolder, Copyright 2001-2006 Gary Steinmetz
003: *
004: * Distributable under LGPL license.
005: * See terms of license at gnu.org.
006: */
007:
008: package org.jfolder.common.tagging;
009:
010: //base classes
011: import java.util.Arrays;
012: import java.util.HashSet;
013: import java.util.List;
014:
015: //project specific classes
016: import org.jfolder.common.StandardDataTypes;
017:
018: //other classes
019:
020: public class SelectionCriteriaForReturnableConceptTag extends
021: SelectionCriteriaForConceptTag {
022:
023: //
024: private final static int FORMAT__UNKNOWN = 1;
025: public final static int FORMAT__PLAIN = 2;
026: public final static int FORMAT__INHERIT = 3;
027: public final static int FORMAT__HTML = 4;
028: //
029: private Class possibleReturnClasses[] = null;
030: private Class impossibleReturnClasses[] = null;
031: //
032: private int declaredFormat = 0;
033:
034: protected SelectionCriteriaForReturnableConceptTag(ConceptTag inCt) {
035: super (inCt);
036: this .declaredFormat = FORMAT__UNKNOWN;
037: }
038:
039: //
040: public int hashCode() {
041:
042: int outValue = 0;
043:
044: outValue += fromArrayToHashSet(this .possibleReturnClasses)
045: .hashCode();
046: outValue += fromArrayToHashSet(this .impossibleReturnClasses)
047: .hashCode();
048: outValue += this .declaredFormat;
049: outValue += super .hashCode();
050:
051: return outValue;
052: }
053:
054: public boolean equals(Object inObj) {
055:
056: boolean outValue = true;
057:
058: if (inObj instanceof SelectionCriteriaForReturnableConceptTag) {
059: SelectionCriteriaForReturnableConceptTag scfrct2 = ((SelectionCriteriaForReturnableConceptTag) inObj);
060: //
061: HashSet prc1 = fromArrayToHashSet(this .possibleReturnClasses);
062: HashSet prc2 = fromArrayToHashSet(scfrct2.possibleReturnClasses);
063: outValue &= (prc1.equals(prc2));
064: //
065: HashSet irc1 = fromArrayToHashSet(this .impossibleReturnClasses);
066: HashSet irc2 = fromArrayToHashSet(scfrct2.impossibleReturnClasses);
067: outValue &= (irc1.equals(irc2));
068: //
069: outValue &= (this .declaredFormat == scfrct2.declaredFormat);
070: //
071: outValue &= (super .equals(scfrct2));
072: } else {
073: outValue &= false;
074: }
075:
076: return outValue;
077: }
078:
079: //
080: private final static HashSet fromArrayToHashSet(Class inClass[]) {
081:
082: HashSet outValue = null;
083:
084: if (inClass == null) {
085: inClass = new Class[0];
086: }
087: List l = Arrays.asList(inClass);
088: outValue = new HashSet(l);
089:
090: return outValue;
091: }
092:
093: //
094: //
095: public boolean isInitialized() {
096:
097: boolean outValue = true;
098:
099: outValue &= super .isInitialized();
100:
101: //
102: //template interface does not declare itself html/non-html
103: //template interface does not declare what it does/does-not return
104: //
105: if (!isAutoValidateForTemplateInterface()) {
106: //
107: outValue &= (this .possibleReturnClasses != null && this .impossibleReturnClasses != null);
108: //
109: outValue &= (this .declaredFormat != FORMAT__UNKNOWN);
110: }
111:
112: return outValue;
113: }
114:
115: //
116: public void canReturnAnythingExceptNothing() {
117: setPossibleReturnClasses(StandardDataTypes.getAnyClass());
118: setImpossibleReturnClasses(StandardDataTypes.getNothingClass());
119: }
120:
121: public void canReturnAnythingIncludingNothing() {
122: setPossibleReturnClasses(StandardDataTypes.getAnyClass());
123: setImpossibleReturnClasses(new Class[] {});
124: }
125:
126: public void canReturnNothing() {
127: setPossibleReturnClasses(StandardDataTypes.getNothingClass());
128: setImpossibleReturnClasses(new Class[] {});
129: }
130:
131: public void canReturnBinary() {
132: setPossibleReturnClasses(StandardDataTypes.getBinaryClass());
133: setImpossibleReturnClasses(new Class[] {});
134: }
135:
136: public void canReturnTimestamp() {
137: setPossibleReturnClasses(StandardDataTypes.getTimestampClass());
138: setImpossibleReturnClasses(new Class[] {});
139: }
140:
141: public void canReturnBoolean() {
142: setPossibleReturnClasses(StandardDataTypes.getBooleanClass());
143: setImpossibleReturnClasses(new Class[] {});
144: }
145:
146: public void canReturnDecimal() {
147: setPossibleReturnClasses(StandardDataTypes.getDecimalClass());
148: setImpossibleReturnClasses(new Class[] {});
149: }
150:
151: public void canReturnDecimalOrString() {
152: //
153: Class c[] = new Class[] { StandardDataTypes.getStringClass(),
154: StandardDataTypes.getDecimalClass() };
155: //
156: setPossibleReturnClasses(c);
157: setImpossibleReturnClasses(new Class[] {});
158: }
159:
160: public void canReturnString() {
161: setPossibleReturnClasses(StandardDataTypes.getStringClass());
162: setImpossibleReturnClasses(new Class[] {});
163: }
164:
165: public void canReturnList() {
166: setPossibleReturnClasses(StandardDataTypes.getListClass());
167: setImpossibleReturnClasses(new Class[] {});
168: }
169:
170: public void canReturnMap() {
171: setPossibleReturnClasses(StandardDataTypes.getMapClass());
172: setImpossibleReturnClasses(new Class[] {});
173: }
174:
175: //
176: private void setPossibleReturnClasses(Class inClass) {
177: this .possibleReturnClasses = new Class[] { inClass };
178: }
179:
180: private void setPossibleReturnClasses(Class inClasses[]) {
181: this .possibleReturnClasses = inClasses;
182: }
183:
184: public Class[] getPossibleReturnClasses() {
185: return this .possibleReturnClasses;
186: }
187:
188: //
189: private void setImpossibleReturnClasses(Class inClass) {
190: this .impossibleReturnClasses = new Class[] { inClass };
191: }
192:
193: private void setImpossibleReturnClasses(Class inClasses[]) {
194: this .impossibleReturnClasses = inClasses;
195: }
196:
197: public Class[] getImpossibleReturnClasses() {
198: return this .impossibleReturnClasses;
199: }
200:
201: //
202: public void setPossibleAndImpossibleReturnClasses(Class inPossible,
203: Class inImpossible) {
204: //
205: setPossibleReturnClasses(inPossible);
206: setImpossibleReturnClasses(inImpossible);
207: }
208:
209: public void setPossibleAndImpossibleReturnClasses(
210: Class inPossible[], Class inImpossible) {
211: //
212: setPossibleReturnClasses(inPossible);
213: setImpossibleReturnClasses(inImpossible);
214: }
215:
216: public void setPossibleAndImpossibleReturnClasses(Class inPossible,
217: Class inImpossible[]) {
218: //
219: setPossibleReturnClasses(inPossible);
220: setImpossibleReturnClasses(inImpossible);
221: }
222:
223: public void setPossibleAndImpossibleReturnClasses(
224: Class inPossible[], Class inImpossible[]) {
225: //
226: setPossibleReturnClasses(inPossible);
227: setImpossibleReturnClasses(inImpossible);
228: }
229:
230: //
231: public void declareFormatAsPlain() {
232: this .declaredFormat = FORMAT__PLAIN;
233: }
234:
235: public void declareFormatAsInherit() {
236: this .declaredFormat = FORMAT__INHERIT;
237: }
238:
239: public void declareFormatAsHtml() {
240: this .declaredFormat = FORMAT__HTML;
241: }
242:
243: //
244: public boolean isFormatPlain() {
245: return (this .declaredFormat == FORMAT__PLAIN);
246: }
247:
248: public boolean isFormatInherit() {
249: return (this .declaredFormat == FORMAT__INHERIT);
250: }
251:
252: public boolean isFormatHtml() {
253: return (this .declaredFormat == FORMAT__HTML);
254: }
255:
256: //public void configureToReturnAllExceptVoid() {
257: // setPossibleReturnClasses(Object.class);
258: // setImpossibleReturnClasses(Void.TYPE);
259: //}
260: //public void configureToReturnOnlyVoid() {
261: // setPossibleReturnClasses(Void.TYPE);
262: //}
263:
264: //public static ReturnableConceptTagInfoContext newInstance() {
265: // return new StudioConceptTagInstanceInfoContext();
266: //}
267:
268: }
|