public void handle(MethodCallExpression methodCall, TypeResolutionContext context) {
if (methodCall.getArguments().size() == 1) { // there should only be one argument
CollectionType targetType =
(CollectionType)
methodCall
.getTarget()
.getResolvedType(); // obtain target type, at this stage, preliminary examination
// should already have the conclusion that the type is of type
// Collection
Type contentType = targetType.getContentType(); // obtain content type from the collection
if (contentType == null) {
// this means the operation is performed on a collection of any, so no need for further
// actions
} else {
LiteralExpression argument =
(LiteralExpression) methodCall.getArguments().get(0); // get the argument
Type argumentType = argument.getResolvedType(); // get the type of the argument
if (contentType.getClass() == argumentType.getClass()) {
// match, no further actions
} else {
// handle type mismatch
}
}
methodCall.setResolvedType(null); // in either case, remove() does not have a return type
} else {
// handle arguments number incorrect
}
}
private JavaType _collectionType(Class<?> rawClass) {
JavaType[] typeParams = findParameterTypes(rawClass, Collection.class);
// ok to have no types ("raw")
if (typeParams == null) {
return CollectionType.construct(rawClass, _unknownType());
}
// but exactly 2 types if any found
if (typeParams.length != 1) {
throw new IllegalArgumentException(
"Strange Collection type " + rawClass.getName() + ": can not determine type parameters");
}
return CollectionType.construct(rawClass, typeParams[0]);
}
private void linkMembers(Entry from, Entry parent, CollectionType collectionType) {
// In the case of choice and unordered, the siblings are not linked to
// each other in any way. Therefore this leaves us with the link to
// parent alone.
if (parent != null) {
switch (from.linking) {
case NORMAL:
case SOURCE_ONLY:
{
Element topic = from.topic;
assert (topic != null);
Document doc = topic.getOwnerDocument();
assert (doc != null);
String linkpoolType = collectionType.toString() + "-members";
Element linkpool = addLinkpool(topic, /*prepend*/ true, linkpoolType, doc);
addLink(linkpool, parent, "parent", doc);
}
break;
}
}
}
private void processHierarchy(
Element topicrefOrMap, LoadedDocuments loadedDocs, List<Entry> childList) {
CollectionType collectionType = null;
String type = DITAUtil.getNonEmptyAttribute(topicrefOrMap, null, "collection-type");
if (type != null) {
collectionType = CollectionType.fromString(type);
}
if (collectionType == null) {
collectionType = CollectionType.UNORDERED;
}
processCollection(topicrefOrMap, collectionType, loadedDocs, childList);
// Recurse ---
// LIMITATION: @collection-type is ignored inside reltables.
Node child = topicrefOrMap.getFirstChild();
while (child != null) {
if (child.getNodeType() == Node.ELEMENT_NODE) {
Element childElement = (Element) child;
if (DITAUtil.hasClass(childElement, "map/topicref")
&&
// Does not make sense inside frontmatter/backmatter.
// For example, inside a glossary.
!DITAUtil.hasClass(childElement, "bookmap/frontmatter", "bookmap/backmatter")) {
processHierarchy(childElement, loadedDocs, childList);
}
}
child = child.getNextSibling();
}
}
/** Method used by {@link TypeParser} when generics-aware version is constructed. */
protected JavaType _fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes) {
if (clz.isArray()) { // ignore generics (should never have any)
return ArrayType.construct(_fromType(clz.getComponentType(), null));
}
if (clz.isEnum()) { // ditto for enums
return new SimpleType(clz);
}
if (Map.class.isAssignableFrom(clz)) {
// First: if we do have param types, use them
JavaType keyType, contentType;
if (paramTypes.size() > 0) {
keyType = paramTypes.get(0);
contentType = (paramTypes.size() >= 2) ? paramTypes.get(1) : _unknownType();
return MapType.construct(clz, keyType, contentType);
}
return _mapType(clz);
}
if (Collection.class.isAssignableFrom(clz)) {
if (paramTypes.size() >= 1) {
return CollectionType.construct(clz, paramTypes.get(0));
}
return _collectionType(clz);
}
if (paramTypes.size() == 0) {
return new SimpleType(clz);
}
JavaType[] pt = paramTypes.toArray(new JavaType[paramTypes.size()]);
return _constructSimple(clz, pt);
}
/**
* Factory method for constructing {@link JavaType} that represents a parameterized type. For
* example, to represent type <code>List<Set<Integer>></code>, you could call
*
* <pre>
* JavaType inner = TypeFactory.parametricType(Set.class, Integer.class);
* TypeFactory.parametricType(List.class, inner);
* </pre>
*
* @since 1.5
*/
public static JavaType parametricType(Class<?> parametrized, JavaType... parameterTypes) {
// Need to check kind of class we are dealing with...
if (parametrized.isArray()) {
// 19-Jan-2010, tatus: should we support multi-dimensional arrays directly?
if (parameterTypes.length != 1) {
throw new IllegalArgumentException(
"Need exactly 1 parameter type for arrays (" + parametrized.getName() + ")");
}
return ArrayType.construct(parameterTypes[0]);
}
if (Map.class.isAssignableFrom(parametrized)) {
if (parameterTypes.length != 2) {
throw new IllegalArgumentException(
"Need exactly 2 parameter types for Map types (" + parametrized.getName() + ")");
}
return MapType.construct(parametrized, parameterTypes[0], parameterTypes[1]);
}
if (Collection.class.isAssignableFrom(parametrized)) {
if (parameterTypes.length != 1) {
throw new IllegalArgumentException(
"Need exactly 1 parameter type for Collection types (" + parametrized.getName() + ")");
}
return CollectionType.construct(parametrized, parameterTypes[0]);
}
return _constructSimple(parametrized, parameterTypes);
}
private static ValueType newValueType(
Map<Type, ValueType> typeMap, Type type, Class declaringClass, Class compositeType) {
ValueType valueType = null;
if (CollectionType.isCollection(type)) {
if (type instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) type;
Type collectionType = pt.getActualTypeArguments()[0];
if (collectionType instanceof TypeVariable) {
TypeVariable collectionTypeVariable = (TypeVariable) collectionType;
collectionType =
Classes.resolveTypeVariable(collectionTypeVariable, declaringClass, compositeType);
}
ValueType collectedType =
newValueType(typeMap, collectionType, declaringClass, compositeType);
valueType = new CollectionType(nameOf(type), collectedType);
} else {
valueType =
new CollectionType(
nameOf(type), newValueType(typeMap, Object.class, declaringClass, compositeType));
}
} else if (ValueCompositeType.isValueComposite(type)) {
if (typeMap != null) {
valueType = typeMap.get(type);
}
if (valueType == null) {
Class valueTypeClass = Classes.getRawClass(type);
List<PropertyType> types = new ArrayList<PropertyType>();
valueType = new ValueCompositeType(nameOf(valueTypeClass), types);
if (typeMap == null) {
typeMap = new HashMap<Type, ValueType>();
}
typeMap.put(type, valueType);
addProperties(typeMap, valueTypeClass, compositeType, types);
Collections.sort(types); // Sort by property name
}
} else if (EnumType.isEnum(type)) {
valueType = new EnumType(nameOf(type));
} else if (StringType.isString(type)) {
valueType = new StringType();
} else if (NumberType.isNumber(type)) {
valueType = new NumberType(nameOf(type));
} else if (BooleanType.isBoolean(type)) {
valueType = new BooleanType();
} else if (DateType.isDate(type)) {
valueType = new DateType();
} else if (EntityReferenceType.isEntityReference(type)) {
valueType = new EntityReferenceType(nameOf(type));
} else {
// TODO: shouldn't we check that the type is a Serializable?
valueType = new SerializableType(nameOf(type));
}
return valueType;
}
public int timePrefixSearching(int reps) {
int dummy = 0;
for (int i = 0; i < reps; i++) {
for (Entry<String, String> entry : type.entriesWithPrefix(elements, "100")) {
if (entry != null) {
dummy++;
}
}
}
return dummy;
}
@Override
protected void setUp() throws Exception {
HashMap<String, String> elementMap = Maps.newHashMapWithExpectedSize(nrOfElements);
for (int i = 1; i <= nrOfElements; i++) {
String s = "" + i;
elementMap.put(s, s);
}
elements = type.createMap(elementMap);
first = "1";
last = "" + nrOfElements;
middle = "" + (nrOfElements / 2);
}
public void afterPropertiesSet() {
if (!StringUtils.hasText(key)) {
key = beanName;
}
Assert.hasText(key, "Collection key is required - no key or bean name specified");
Assert.notNull(template, "Redis template is required");
DataType dt = template.type(key);
// can't create store
Assert.isTrue(!DataType.STRING.equals(dt), "Cannot create store on keys of type 'string'");
store = createStore(dt);
if (store == null) {
if (type == null) {
type = CollectionType.LIST;
}
store = createStore(type.dataType());
}
}
private void linkParentToChildren(
Entry parent, List<Entry> childList, int childCount, CollectionType collectionType) {
switch (parent.linking) {
case NORMAL:
case SOURCE_ONLY:
{
Element topic = parent.topic;
assert (topic != null);
Document doc = topic.getOwnerDocument();
assert (doc != null);
String linkpoolType = collectionType.toString() + "-parent";
Element linkpool = addLinkpool(topic, /*prepend*/ true, linkpoolType, doc);
for (int i = 0; i < childCount; ++i) {
addLink(linkpool, childList.get(i), "child", doc);
}
}
break;
}
}
/**
* This method deals with parameterized types, that is, first class generic classes.
*
* <p>Since version 1.2, this resolves all parameterized types, not just Maps or Collections.
*/
protected JavaType _fromParamType(ParameterizedType type, TypeBindings context) {
/* First: what is the actual base type? One odd thing
* is that 'getRawType' returns Type, not Class<?> as
* one might expect. But let's assume it is always of
* type Class: if not, need to add more code to resolve
* it to Class.
*/
Class<?> rawType = (Class<?>) type.getRawType();
Type[] args = type.getActualTypeArguments();
// Ok: Map or Collection?
if (Map.class.isAssignableFrom(rawType)) {
if (args.length != 2) {
throw new IllegalArgumentException(
"Could not find 2 type parameters for class "
+ rawType.getName()
+ " (found "
+ args.length
+ ")");
}
JavaType keyType = _fromType(args[0], context);
JavaType valueType = _fromType(args[1], context);
return MapType.construct(rawType, keyType, valueType);
}
if (Collection.class.isAssignableFrom(rawType)) {
JavaType valueType = _fromType(args[0], context);
return CollectionType.construct(rawType, valueType);
}
int len = (args == null) ? 0 : args.length;
if (len == 0) { // no generics
return new SimpleType(rawType);
}
JavaType[] pt = new JavaType[len];
for (int i = 0; i < len; ++i) {
pt[i] = _fromType(args[i], context);
}
return _constructSimple(rawType, pt);
}
/**
* Convenience factory method for constructing {@link JavaType} that represent Collection of
* specified type and contains elements of specified type
*
* @since 1.3
*/
@SuppressWarnings("unchecked")
public static JavaType collectionType(
Class<? extends Collection> collectionType, JavaType elementType) {
return CollectionType.construct(collectionType, elementType);
}
public DatasetEditor() {
JTabbedPane tabs = new JTabbedPane();
metadataPP = new PrefPanel("Edit Catalog Dataset", null, null);
tabs.add("metadata", metadataPP);
int row = 0;
metadataPP.addHeading("Basic", row++);
// row 0
metadataPP.addTextField(NAME, "Name", "", 0, row++, "8,1");
// row 1
metadataPP.addTextField(ID, "ID", "", 0, row, null);
addPopups(metadataPP.addTextField(AUTHORITY, "Authority", "", 2, row, null));
addPopups(metadataPP.addTextField(SERVICE_NAME, "Service", "", 4, row, null));
row++;
// row 2
addPopups(
metadataPP.addEnumComboField(
FORMAT_TYPE, "Data format", DataFormatType.getAllTypes(), true, 0, row, null));
addPopups(
metadataPP.addEnumComboField(
DATA_TYPE, "Data type", Arrays.asList(FeatureType.values()), true, 2, row, null));
metadataPP.addEnumComboField(
COLLECTION_TYPE, "Collection type", CollectionType.getAllTypes(), true, 4, row++, null);
////////////
metadataPP.addHeading("GeoSpatial Coverage", row++);
// addCheckBoxField("localMetadata.geospatialCoverage.global", "Global", false, 0, row);
gc_type = metadataPP.addEnumComboField(GC_TYPE, "type", inherit_types, false, 0, row, null);
gc_type.addPropertyChangeListener(
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
String mode = (String) gc_type.getValue();
setGCmode(getMode(mode));
}
});
extractGCButton = makeButton("Extract Geospatial");
extractGCButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
extractGeospatial();
}
});
metadataPP.addComponent(extractGCButton, 2, row, "left, center");
metadataPP.addCheckBoxField(ZPOSITIVE_UP, "Z positive up", false, 4, row);
row++;
/* JPanel geoPanel = new JPanel();
Field.CheckBox global = new Field.CheckBox( "localMetadata.geospatialCoverage.global", "Global", false, persBean);
geoPanel.add( new JLabel("Global: "));
geoPanel.add( global.getEditComponent());
geoPanel.add( new JButton("Read Dataset"));
pp.addComponent(geoPanel, 0, row++, "left, center"); */
// 4 columns in 3 rows
metadataPP.addDoubleField(LAT_START, "Starting Latitude", 0.0, 5, 0, row, null);
metadataPP.addDoubleField(LAT_EXTENT, "Size", 0.0, 5, 2, row, null);
metadataPP.addDoubleField(LAT_RESOLUTION, "Resolution", 0.0, 5, 4, row, null);
metadataPP.addTextField(LAT_UNITS, "Units", "", 6, row, null);
metadataPP.addDoubleField(LON_START, "Starting Longitude", 0.0, 5, 0, row + 1, null);
metadataPP.addDoubleField(LON_EXTENT, "Size", 0.0, 5, 2, row + 1, null);
metadataPP.addDoubleField(LON_RESOLUTION, "Resolution", 0.0, 5, 4, row + 1, null);
metadataPP.addTextField(LON_UNITS, "Units", "", 6, row + 1, null);
metadataPP.addDoubleField(HEIGHT_START, "Starting Height", 0.0, 5, 0, row + 2, null);
metadataPP.addDoubleField(HEIGHT_EXTENT, "Size", 0.0, 5, 2, row + 2, null);
metadataPP.addDoubleField(HEIGHT_RESOLUTION, "Resolution", 0.0, 5, 4, row + 2, null);
metadataPP.addTextField(HEIGHT_UNITS, "Units", "", 6, row + 2, null);
// addTextField("localMetadata.geospatialCoverage.ZPositive", "Z is Positive", "up", 6, row+3,
// null);
row += 3;
//////
metadataPP.addHeading("Temporal Coverage", row++);
tc_type = metadataPP.addEnumComboField(TC_TYPE, "type", inherit_types, false, 0, row++, null);
tc_type.addPropertyChangeListener(
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
String mode = (String) tc_type.getValue();
setTCmode(getMode(mode));
}
});
DateRange range = null;
try {
range = new DateRange();
} catch (Exception e) {
e
.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
dateRangeSelector = new RangeDateSelector("", range, false, false, null, false, false);
DateField minDateField = dateRangeSelector.getMinDateField();
DateField maxDateField = dateRangeSelector.getMaxDateField();
DurationField durationField = dateRangeSelector.getDurationField();
DurationField resolutionField = dateRangeSelector.getResolutionField();
metadataPP.addField(minDateField, 0, row, null);
metadataPP.addField(maxDateField, 2, row, null);
metadataPP.addField(durationField, 4, row, null);
metadataPP.addField(resolutionField, 6, row++, null);
////
metadataPP.addHeading("Digital Library Info", row++);
metadataPP.addCheckBoxField(HARVEST, "Harvest", false, 0, row++);
addPopups(metadataPP.addTextAreaField(SUMMARY, "Summary", null, 7, 0, row, "3,1"));
addPopups(metadataPP.addTextAreaField(RIGHTS, "Rights", null, 2, 0, row + 1, "3,1"));
addPopups(metadataPP.addTextAreaField(HISTORY, "History", null, 7, 4, row, "3,1"));
addPopups(metadataPP.addTextAreaField(PROCESSING, "Process", null, 2, 4, row + 1, "3,1"));
row += 2;
metadataPP.addEmptyRow(row++, 10);
JTabbedPane tabPane = new JTabbedPane();
metadataPP.addComponent(tabPane, 0, row, "8,1");
ArrayList<Field.BeanTableField> tables = new ArrayList<>();
tabPane.addTab("Variables", makeVariablesPanel());
tables.add(variablesFld);
creatorsFld =
new Field.BeanTableField(
CREATORS, "Creators", null, ThreddsMetadata.Source.class, null, null);
tabPane.addTab("Creators", creatorsFld.getEditComponent());
tables.add(creatorsFld);
publishersFld =
new Field.BeanTableField(
PUBLISHERS, "Publishers", null, ThreddsMetadata.Source.class, null, null);
tabPane.addTab("Publishers", publishersFld.getEditComponent());
tables.add(publishersFld);
projectsFld =
new Field.BeanTableField(
PROJECTS, "Projects", null, ThreddsMetadata.Vocab.class, null, null);
tabPane.addTab("Projects", projectsFld.getEditComponent());
tables.add(projectsFld);
keywordsFld =
new Field.BeanTableField(
KEYWORDS, "Keywords", null, ThreddsMetadata.Vocab.class, null, null);
tabPane.addTab("Keywords", keywordsFld.getEditComponent());
tables.add(keywordsFld);
datesFld = new Field.BeanTableField(DATES, "Dates", null, DateType.class, null, null);
tabPane.addTab("Dates", datesFld.getEditComponent());
tables.add(datesFld);
contributorsFld =
new Field.BeanTableField(
CONTRIBUTORS, "Contributors", null, ThreddsMetadata.Contributor.class, null, null);
tabPane.addTab("Contributors", contributorsFld.getEditComponent());
tables.add(contributorsFld);
docsFld =
new Field.BeanTableField(
DOCUMENTATION, "Documentation", null, InvDocumentation.class, null, null);
tabPane.addTab("Documentation", docsFld.getEditComponent());
tables.add(docsFld);
for (Field.BeanTableField table : tables) addPopups(table);
metadataPP.finish(false);
makeDscanPanel();
tabs.add("datasetScan", dscanPP);
setLayout(new BorderLayout());
add(tabs, BorderLayout.CENTER);
}
