@Override
public Type getFieldTypes() {
if (hasFieldNames()) {
return TypeFactory.getInstance().tupleType(fKeyType, fKeyLabel, fValueType, fValueLabel);
} else {
return TypeFactory.getInstance().tupleType(fKeyType, fValueType);
}
}
// for [databind#1301]
public void testJavaTypeToString() throws Exception {
TypeFactory tf = objectMapper().getTypeFactory();
String desc = tf.constructType(DataDefinition.class).toString();
assertNotNull(desc);
// could try comparing exact message, but since it's informational try looser:
if (!desc.contains("map type")) {
fail("Description should contain 'map type', did not: " + desc);
}
if (!desc.contains("recursive type")) {
fail("Description should contain 'recursive type', did not: " + desc);
}
}
@Override
public Type instantiate(Map<Type, Type> bindings) {
if (fKeyLabel != null) {
return TypeFactory.getInstance()
.mapType(
getKeyType().instantiate(bindings),
fKeyLabel,
getValueType().instantiate(bindings),
fValueLabel);
} else {
return TypeFactory.getInstance()
.mapType(getKeyType().instantiate(bindings), getValueType().instantiate(bindings));
}
}
String getContent(String identifier) throws Exception {
logger.trace("Searching for '{}' in cache.", identifier);
ResourceWrapper wrapper = resources.get(identifier);
// If not in cache yet, load it
if (wrapper == null) {
long start = System.currentTimeMillis();
logger.debug("'{}' not in cache. Loading and processing...", identifier);
String extension = FilenameUtils.getExtension(identifier);
Type type = TypeFactory.getType(extension);
if (type == null) {
logger.warn("No type available for the specified resource: {}", extension);
throw new UnknownTypeException(
"No type available for the specified resource: " + extension);
}
String content = processContent(loader.loadResource(identifier), type);
wrapper = new ResourceWrapper(identifier, type, content);
resources.put(identifier, wrapper);
logger.debug("Resource loaded and processed in {} ms.", System.currentTimeMillis() - start);
} else {
// If in cache, check last modified
if (wrapper.getLastLoaded() < loader.lastModified(identifier)) {
// If last loaded was before last modified, load it again
wrapper.setContent(loader.loadResource(identifier));
}
}
return wrapper.getContent();
}
protected JavaType parseType(MyTokenizer tokens) throws IllegalArgumentException {
if (!tokens.hasMoreTokens()) {
throw _problem(tokens, "Unexpected end-of-string");
}
Class<?> base = findClass(tokens.nextToken(), tokens);
// either end (ok, non generic type), or generics
if (tokens.hasMoreTokens()) {
String token = tokens.nextToken();
if ("<".equals(token)) {
return _factory._fromParameterizedClass(base, parseTypes(tokens));
}
// can be comma that separates types, or closing '>'
tokens.pushBack(token);
}
return _factory._fromClass(base, null);
}
/** @see jaskell.compiler.JaskellVisitor#visit(ConstructorPattern) */
public Object visit(ConstructorPattern a) {
String cname = a.getConstructor().getName();
/* retrieve parameter types of constructor */
ConstructorDefinition ctor = (ConstructorDefinition) a.getConstructor().lookup(cname);
if (ctor == null) throw new TypeError("Undefined constructor pattern " + a);
/* type of data constructed by constructor */
TypeInstantiator ti = new TypeInstantiator(ctor.getDataType());
Type rtype = ti.instance();
Map map = ti.getMap();
TypeSubstitution ts = new TypeSubstitution(map);
Iterator ittypes = ctor.getParameters().iterator();
/* retrieve type of patterns */
Iterator it = a.getSubPatterns();
while (it.hasNext()) {
try {
Pattern p = (Pattern) it.next();
Type actual = TypeFactory.freshBinding();
Type formal = ts.substitute((Type) ittypes.next());
/* unify both types */
p.setType(tu.unify(formal, actual, typeVariablesMap));
} catch (NoSuchElementException nex) {
throw new TypeError("Wrong number of arguments to pattern " + a);
}
}
a.setType(rtype);
return a.getType();
}
public AddElementDialog(MapFilterModel model) {
super(
tufts.vue.VUE.getDialogParentAsFrame(),
VueResources.getString("dialog.addkey.title"),
true);
this.model = model;
allTypes = (Vector) TypeFactory.getAllTypes();
keyLabel = new JLabel(VueResources.getString("nodefilter.field.label"));
typeLabel = new JLabel(VueResources.getString("nodefilter.type.label"));
keyEditor = new JTextField();
typeEditor = new JComboBox(allTypes);
keyEditor.setPreferredSize(new Dimension(80, 20));
JPanel keyPanel = new JPanel();
keyPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
keyPanel.setBorder(BorderFactory.createEmptyBorder(6, 6, 6, 6));
keyPanel.add(keyLabel);
keyPanel.add(keyEditor);
JPanel typePanel = new JPanel();
typePanel.setLayout(new FlowLayout(FlowLayout.CENTER));
typePanel.setBorder(BorderFactory.createEmptyBorder(6, 6, 6, 6));
typePanel.add(typeLabel);
typePanel.add(typeEditor);
// SOUTH: southPanel(cancelButton, okButton)
JButton okButton = new JButton(VueResources.getString("button.ok.label"));
okButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
updateModelAndNotify();
setVisible(false);
}
});
JButton cancelButton = new JButton(VueResources.getString("button.cancel.lable"));
cancelButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
setVisible(false);
}
});
JPanel southPanel = new JPanel();
southPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
southPanel.add(okButton);
southPanel.add(cancelButton);
BoxLayout layout = new BoxLayout(getContentPane(), BoxLayout.Y_AXIS);
getContentPane().setLayout(layout);
getContentPane().add(keyPanel);
getContentPane().add(typePanel);
getContentPane().add(southPanel);
pack();
setLocation(NodeFilterEditor.this.getLocationOnScreen());
setVisible(true);
}
private Type getType(Class<?> cl, String propertyName) throws NoSuchMethodException {
try {
Field field = cl.getDeclaredField(propertyName);
return typeFactory.create(field.getType(), field.getGenericType());
} catch (NoSuchFieldException e) {
String getter = "get" + BeanUtils.capitalize(propertyName);
String bgetter = "is" + BeanUtils.capitalize(propertyName);
for (Method method : cl.getDeclaredMethods()) {
if ((method.getName().equals(getter) || method.getName().equals(bgetter))
&& method.getParameterTypes().length == 0) {
return typeFactory.create(method.getReturnType(), method.getGenericReturnType());
}
}
if (cl.getSuperclass().equals(Object.class)) {
throw new IllegalArgumentException(
"No property found for " + cl.getName() + "." + propertyName);
} else {
return getType(cl.getSuperclass(), propertyName);
}
}
}
/** @see jaskell.compiler.JaskellVisitor#visit(Application) */
public Object visit(Application a) {
try {
/* get type of function */
Expression fun = a.getFunction();
/* get type deduced from arguments */
LinkedList l = new LinkedList();
Iterator it = a.getArgs().iterator();
while (it.hasNext()) {
Expression e = (Expression) it.next();
l.add((Type) e.visit(this));
}
Type vt = TypeFactory.freshBinding();
Type ft = Types.fun(l, vt);
log.finer("TypeChecker => In application " + a + ", type is " + ft);
/* apply substitution on both types */
ft = subst.substitute(ft);
/* try to unify function type and constructed types */
Type t = (Type) fun.visit(this);
log.finer("In application, function " + fun + " :: " + t);
t = subst.substitute(t);
log.finer("In application, trying to unify function type " + t + " with body " + ft);
/*
* TODO : problem with unification of constrained types
*/
TypeApplication uni = (TypeApplication) tu.unify(t, ft, typeVariablesMap);
/* sets type of functional expression - this allows
* polymorphic functions to receive several types
* in the same code */
// fun.setType(uni);
/* apply arguments type to compute return type */
log.finer("Done unify application :" + uni);
it = PrimitiveType.functionIterator(uni);
Iterator it2 = l.iterator();
TypeApplication ut = uni;
while (it2.hasNext()) {
/* type of argument */
Type at = (Type) it2.next();
ut = (TypeApplication) it.next();
/* try unification */
tu.unify(((TypeApplication) ut.getDomain()).getRange(), at, new HashMap(typeVariablesMap));
}
ft = subst.substitute(ft);
fun.setType(ft);
log.finer("Setting type of functional element [" + fun + "] to :" + ft);
a.setType(ut.getRange());
return ut.getRange();
} catch (TypeError te) {
if (te.getLineCol() == null) te.setLineCol(a.getTag("source"));
throw te;
}
}
/** @see jaskell.compiler.JaskellVisitor#visit(Abstraction) */
public Object visit(Abstraction a) {
try {
Type t = a.getType();
if (t != null) return subst.substitute(t);
log.finest("Visiting abstraction : " + a);
Expression body = a.getBody();
/* duplicate bindings map to assign types to variables */
pushContext(a.getBindings());
/* create fresh type variables as type for each bound
* variable */
Iterator it = namesMap.values().iterator();
LinkedList tl = new LinkedList();
while (it.hasNext()) {
LocalBinding name = (LocalBinding) it.next();
Type vt = TypeFactory.freshBinding();
name.setType(vt);
tl.add(vt);
}
Type tv = TypeFactory.freshBinding();
/* create type with all variables for function */
Type ft = Types.fun(tl, tv);
log.finer("In abstraction, setting type to " + ft);
a.setType(ft);
/* analyze body */
Type bt = (Type) body.visit(this);
/* unify return type of function with type of body */
Type ret = tu.unify(PrimitiveType.getReturnType(ft), bt, typeVariablesMap);
TyvarSubstitution tys = new TyvarSubstitution(typeVariablesMap);
tys.visit(a);
log.finer("Done abstraction, setting type from " + ft + " to " + a.getType());
popContext();
return a.getType();
} catch (TypeError te) {
if (te.getLineCol() == null) te.setLineCol(a.getTag("source"));
throw te;
}
}
public static Type createType(
String baseTypeStr,
List<Type> typeParams,
List<Integer> valueParams,
List<Field> fieldParams) {
final TajoDataTypes.Type baseType;
try {
baseType = TajoDataTypes.Type.valueOf(baseTypeStr);
} catch (Throwable t) {
throw new TajoInternalError(new UnsupportedException(baseTypeStr));
}
return TypeFactory.create(baseType, typeParams, valueParams, fieldParams);
}
/**
* Wenn <code>true</code> zurueckgegeben wird ist das zeichen vor dem offset ein : und das Zeichen
* davor kein Whitespace.
*/
private boolean isQualifiedSymbolProposal(final IDocument doc, final int offset)
throws BadLocationException {
int wordOffset = skipWhitespace(doc, offset);
String word = computePreviousWord(doc, wordOffset);
if (word == null || word.equals("")) {
return false;
}
Symbol sym = TypeFactory.createSymbol(word, null);
if (sym.isQualified()) {
fContextPackage = sym.getQualifier();
fContextWord = sym.getSymbolName();
return true;
}
return false;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String[] files = request.getParameterValues("file");
if (logger.isDebugEnabled()) {
logger.debug("Resource servlet received request to load files: {}", Arrays.toString(files));
}
if (files == null || files.length == 0) {
logger.warn("No resource specified, 'file' parameter is empty.");
response.sendError(
HttpServletResponse.SC_BAD_REQUEST, "No resource specified, 'file' parameter is empty.");
return;
}
try {
String requestedExtension = FilenameUtils.getExtension(request.getRequestURI());
logger.trace("Request done with extension {}", requestedExtension);
String answer = null;
if ("json".equals(requestedExtension)) {
/* If extension was .json, then it will return all resources as
* a JSON object.
*/
response.setContentType(CONTENT_TYPE_JSON);
answer = renderContentAsJson(files);
} else {
// Any other extension will set content type for the type of the first file requested
response.setContentType(
TypeFactory.getType(FilenameUtils.getExtension(files[0])).getContentType());
answer = renderContentAsText(files);
}
logger.trace("--- Sending response to client ---\n{}", answer);
response.getWriter().write(answer);
} catch (ResourceNotFoundException ex) {
response.sendError(
HttpServletResponse.SC_NOT_FOUND, "Resource not found: " + ex.getMessage());
logger.warn("Resource not found.", ex);
} catch (Exception ex) {
response.sendError(
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Error while loading resource: " + ex.getMessage());
logger.error("Error while loading resoruce.", ex);
}
}
public HibernateDomainExporter(
String namePrefix,
String nameSuffix,
File targetFolder,
SerializerConfig serializerConfig,
Configuration configuration) {
this.targetFolder = targetFolder;
this.serializerConfig = serializerConfig;
this.configuration = configuration;
CodegenModule module = new CodegenModule();
module.bind(CodegenModule.PREFIX, namePrefix);
module.bind(CodegenModule.SUFFIX, nameSuffix);
module.bind(CodegenModule.KEYWORDS, Constants.keywords);
this.queryTypeFactory = module.get(QueryTypeFactory.class);
this.typeMappings = module.get(TypeMappings.class);
this.embeddableSerializer = module.get(EmbeddableSerializer.class);
this.entitySerializer = module.get(EntitySerializer.class);
this.supertypeSerializer = module.get(SupertypeSerializer.class);
typeFactory.setUnknownAsEntity(true);
}
/** Returns the set of all supertypes (including this type). */
public Set<Type> allSupertypes() {
Set<Type> res = new HashSet<Type>(2);
res.add(TypeFactory.mkOclAny());
res.add(this);
return res;
}
/**
* Begin a new mapping for the specified type and class.
*
* @param aType
* @param bType
* @return a new ClassMapBuilder instance for the specified types
*/
public <A, B> ClassMapBuilder<A, B> map(Type<A> aType, Class<B> bType) {
return getNewClassMapBuilder(aType, TypeFactory.<B>valueOf(bType));
}
/**
* Begin a new mapping for the specified class and type.
*
* @param aType
* @param bType
* @return a new ClassMapBuilder instance for the specified types
*/
public <A, B> ClassMapBuilder<A, B> map(Class<A> aType, Type<B> bType) {
return getNewClassMapBuilder(TypeFactory.<A>valueOf(aType), bType);
}
@Test
public void HidaBezGruppe() {
TypeFactory typeFactory = new TypeFactory();
Type type = typeFactory.createEntityType(HidaBezGruppe.class);
System.out.println(type.getGenericName(true));
}
@Override
public Type select(int... fields) {
return TypeFactory.getInstance().setType(getFieldTypes().select(fields));
}
public JavaType resolveType(Class<?> cls) {
return _typeFactory._constructType(cls, this);
}
public static ActivityObjectType comment() {
return standardTypes.newType("comment");
}
@Override
public Type getTypeParameters() {
return TypeFactory.getInstance().voidType();
}
protected void _resolveBindings(Type t) {
if (t == null) return;
Class<?> raw;
if (t instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) t;
Type[] args = pt.getActualTypeArguments();
if (args != null && args.length > 0) {
Class<?> rawType = (Class<?>) pt.getRawType();
TypeVariable<?>[] vars = rawType.getTypeParameters();
if (vars.length != args.length) {
throw new IllegalArgumentException(
"Strange parametrized type (in class "
+ rawType.getName()
+ "): number of type arguments != number of type parameters ("
+ args.length
+ " vs "
+ vars.length
+ ")");
}
for (int i = 0, len = args.length; i < len; ++i) {
TypeVariable<?> var = vars[i];
String name = var.getName();
if (_bindings == null) {
_bindings = new LinkedHashMap<String, JavaType>();
} else {
/* 24-Mar-2010, tatu: Better ensure that we do not overwrite something
* collected earlier (since we descend towards super-classes):
*/
if (_bindings.containsKey(name)) continue;
}
// first: add a placeholder to prevent infinite loops
_addPlaceholder(name);
// then resolve type
_bindings.put(name, _typeFactory._constructType(args[i], this));
}
}
raw = (Class<?>) pt.getRawType();
} else if (t instanceof Class<?>) {
raw = (Class<?>) t;
/* [JACKSON-677]: If this is an inner class then the generics are defined on the
* enclosing class so we have to check there as well. We don't
* need to call getEnclosingClass since anonymous classes declare
* generics
*/
_resolveBindings(raw.getDeclaringClass());
/* 24-Mar-2010, tatu: Can not have true generics definitions, but can
* have lower bounds ("<T extends BeanBase>") in declaration itself
*/
TypeVariable<?>[] vars = raw.getTypeParameters();
if (vars != null && vars.length > 0) {
JavaType[] typeParams = null;
if (_contextType != null && raw.isAssignableFrom(_contextType.getRawClass())) {
typeParams = _typeFactory.findTypeParameters(_contextType, raw);
}
for (int i = 0; i < vars.length; i++) {
TypeVariable<?> var = vars[i];
String name = var.getName();
Type varType = var.getBounds()[0];
if (varType != null) {
if (_bindings == null) {
_bindings = new LinkedHashMap<String, JavaType>();
} else { // and no overwriting...
if (_bindings.containsKey(name)) continue;
}
_addPlaceholder(name); // to prevent infinite loops
if (typeParams != null) {
_bindings.put(name, typeParams[i]);
} else {
_bindings.put(name, _typeFactory._constructType(varType, this));
}
}
}
}
} else { // probably can't be any of these... so let's skip for now
// if (type instanceof GenericArrayType) {
// if (type instanceof TypeVariable<?>) {
// if (type instanceof WildcardType) {
return;
}
// but even if it's not a parameterized type, its super types may be:
_resolveBindings(raw.getGenericSuperclass());
for (Type intType : raw.getGenericInterfaces()) {
_resolveBindings(intType);
}
}
/** For encoding an external value as an ADT we need a representative type */
public Type asAbstractDataType() {
return TypeFactory.getInstance().abstractDataType(store, getName());
}
public static ActivityObjectType status() {
return standardTypes.newType("status");
}
@Override
public Type select(String... names) {
return TypeFactory.getInstance().setType(getFieldTypes().select(names));
}
public AddDialog(NodeFilter model) {
super(
tufts.vue.VUE.getDialogParentAsFrame(),
VueResources.getString("dialog.addkey.title"),
true);
this.model = model;
allTypes = (Vector) TypeFactory.getAllTypes();
keyLabel = new JLabel(VueResources.getString("button.key.label"));
typeLabel = new JLabel(VueResources.getString("nodefilter.type.label"));
operatorLabel = new JLabel(VueResources.getString("nodefilter.operator.label"));
valueLabel = new JLabel(VueResources.getString("nodefilter.value.label"));
keyEditor = new JComboBox(tufts.vue.VUE.getActiveMap().getMapFilterModel().getKeyVector());
operatorEditor = new JComboBox();
valueEditor = new JTextField();
typeEditor = new JTextField();
typeEditor.setEditable(false);
keyEditor.setPreferredSize(new Dimension(80, 20));
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
c.insets = new Insets(2, 2, 2, 2);
JPanel panel = new JPanel();
panel.setLayout(gridbag);
c.anchor = GridBagConstraints.EAST;
c.gridwidth = GridBagConstraints.RELATIVE;
gridbag.setConstraints(keyLabel, c);
panel.add(keyLabel);
c.anchor = GridBagConstraints.WEST;
c.gridwidth = GridBagConstraints.REMAINDER;
gridbag.setConstraints(keyEditor, c);
panel.add(keyEditor);
c.anchor = GridBagConstraints.EAST;
c.gridwidth = GridBagConstraints.RELATIVE;
gridbag.setConstraints(operatorLabel, c);
panel.add(operatorLabel);
c.anchor = GridBagConstraints.WEST;
c.gridwidth = GridBagConstraints.REMAINDER;
gridbag.setConstraints(operatorEditor, c);
panel.add(operatorEditor);
c.anchor = GridBagConstraints.EAST;
c.gridwidth = GridBagConstraints.RELATIVE;
gridbag.setConstraints(valueLabel, c);
panel.add(valueLabel);
c.anchor = GridBagConstraints.WEST;
c.gridwidth = GridBagConstraints.REMAINDER;
c.fill = GridBagConstraints.HORIZONTAL;
gridbag.setConstraints(valueEditor, c);
panel.add(valueEditor);
c.anchor = GridBagConstraints.EAST;
c.fill = GridBagConstraints.NONE;
c.gridwidth = GridBagConstraints.RELATIVE;
gridbag.setConstraints(typeLabel, c);
panel.add(typeLabel);
c.anchor = GridBagConstraints.WEST;
c.gridwidth = GridBagConstraints.REMAINDER;
c.fill = GridBagConstraints.HORIZONTAL;
gridbag.setConstraints(typeEditor, c);
panel.add(typeEditor);
// SOUTH: southPanel(cancelButton, okButton)
JButton okButton = new JButton(VueResources.getString("button.ok.label"));
okButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
updateModelAndNotify();
setVisible(false);
}
});
JButton cancelButton = new JButton(VueResources.getString("button.cancel.lable"));
cancelButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
setVisible(false);
}
});
JPanel southPanel = new JPanel();
southPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
southPanel.add(okButton);
southPanel.add(cancelButton);
c.gridwidth = GridBagConstraints.REMAINDER;
gridbag.setConstraints(southPanel, c);
panel.add(southPanel);
getContentPane().setLayout(new BorderLayout());
getContentPane().add(panel, BorderLayout.CENTER);
pack();
setLocation(500, 300);
setVisible(true);
}
public JavaType resolveType(Type type) {
return _typeFactory._constructType(type, this);
}
public static ActivityObjectType file() {
return standardTypes.newType("file");
}
@Override
public Type carrier() {
TypeFactory tf = TypeFactory.getInstance();
return tf.setType(fKeyType.lub(fValueType));
}
