public Map<String, List<Type>> getTypeMapForDocumentType(
String typeName, DocumentModel currentDoc) {
Type type = getType(typeName);
if (type != null) {
Map<String, List<Type>> docTypesMap = new HashMap<String, List<Type>>();
Map<String, SubType> allowedSubTypes = type.getAllowedSubTypes();
allowedSubTypes = filterSubTypesFromConfiguration(allowedSubTypes, currentDoc);
for (Map.Entry<String, SubType> entry : allowedSubTypes.entrySet()) {
if (canCreate(entry.getValue())) {
Type subType = getType(entry.getKey());
if (subType != null) {
String key = subType.getCategory();
if (key == null) {
key = DEFAULT_CATEGORY;
}
if (!docTypesMap.containsKey(key)) {
docTypesMap.put(key, new ArrayList<Type>());
}
docTypesMap.get(key).add(subType);
}
}
}
return docTypesMap;
}
return new HashMap<String, List<Type>>();
}
public static void main(String[] args) throws IOException {
PGF gr = null;
try {
gr =
PGF.readPGF(
"/home/krasimir/www.grammaticalframework.org/examples/phrasebook/Phrasebook.pgf");
} catch (FileNotFoundException e) {
e.printStackTrace();
return;
} catch (PGFError e) {
e.printStackTrace();
return;
}
Type typ = gr.getFunctionType("Bulgarian");
System.out.println(typ.getCategory());
System.out.println(gr.getAbstractName());
for (Map.Entry<String, Concr> entry : gr.getLanguages().entrySet()) {
System.out.println(
entry.getKey() + " " + entry.getValue() + " " + entry.getValue().getName());
}
Concr eng = gr.getLanguages().get("SimpleEng");
try {
for (ExprProb ep : eng.parse(gr.getStartCat(), "persons who work with Malmö")) {
System.out.println("[" + ep.getProb() + "] " + ep.getExpr());
}
} catch (ParseError e) {
System.out.println("Parsing failed at token \"" + e.getToken() + "\"");
}
}
@Override
public Type getCommonSupertype(Type t) {
if (t == this) return this;
switch (t.getCategory()) {
case BASIC:
return extendedBaseType.getCommonSupertype(t);
case EXTENSION:
Extension e = (Extension) t;
if (e.extendedBaseType != extendedBaseType)
return e.extendedBaseType.getCommonSupertype(extendedBaseType);
return getCommonInternal(t, ((Extension) t).hierarchyLevel);
}
throw new Error("Common supertype error");
}
public Extension(TypeExtension def, Type extendedType) {
super(def.getName());
isDistinct = def.getDisjoint();
switch (extendedType.getCategory()) {
case BASIC:
extendedBaseType = (BasicType) extendedType;
hierarchyLevel = 0;
break;
case EXTENSION:
Extension e = ((Extension) extendedType);
extendedBaseType = e.extendedBaseType;
hierarchyLevel = e.hierarchyLevel + 1;
if (isDistinct)
throw new CompilationError(
def,
"The base type of a disjoint type extension must be a native type, but it is a "
+ extendedType.getDescription());
break;
default:
throw new CompilationError(
def,
"The type "
+ extendedType.getFullName()
+ " cannot be extended. Only basic types and extensions can be extended.");
}
definition = def;
this.extendedType = extendedType;
this.isKey = def.getIsKey();
if (extendedType.isKeyType()) {
throw new CompilationError(def, "Cannot create an extension based on a key type");
}
if (isKey) {
if (extendedBaseType != BasicType.INT && extendedBaseType != BasicType.STRING) {
throw new CompilationError(
def, "Only int and string are allowed to be used as base types for key types.");
}
}
}
