/**
* Store given Table instance to the schema
*
* @param table The Table instance to store
* @throws IllegalArgumentException if Table is already stored
*/
public void storeTableInstance(Table table) {
if (tableInstances.containsKey(table.name))
throw new IllegalArgumentException(
String.format("Table %s was already initialized.", table.name));
tableInstances.put(table.name, table);
}
private Map<String, Tag> findLastParent(final String[] parts) {
Map<String, Tag> map = NBTStorage.this.root;
for (int i = 0; i < parts.length - 1; ++i) {
if (!map.containsKey(parts[i]) || !(map.get(parts[i]) instanceof CompoundTag)) {
return null;
}
map = map.get(parts[i]).getValue();
}
return map;
}
@NotNull
private ClassifierDescriptor modifyTypeClassifier(
@NotNull JetType autoType, @NotNull List<TypeAndVariance> typesFromSuper) {
ClassifierDescriptor classifier = autoType.getConstructor().getDeclarationDescriptor();
if (!(classifier instanceof ClassDescriptor)) {
assert classifier != null : "no declaration descriptor for type " + autoType;
if (classifier instanceof TypeParameterDescriptor
&& autoTypeParameterToModified.containsKey(classifier)) {
return autoTypeParameterToModified.get(classifier);
}
return classifier;
}
ClassDescriptor klass = (ClassDescriptor) classifier;
CollectionClassMapping collectionMapping = CollectionClassMapping.getInstance();
boolean someSupersMutable = false;
boolean someSupersCovariantReadOnly = false;
boolean someSupersNotCovariantReadOnly = false;
for (TypeAndVariance typeFromSuper : typesFromSuper) {
ClassifierDescriptor classifierFromSuper =
typeFromSuper.type.getConstructor().getDeclarationDescriptor();
if (classifierFromSuper instanceof ClassDescriptor) {
ClassDescriptor classFromSuper = (ClassDescriptor) classifierFromSuper;
if (collectionMapping.isMutableCollection(classFromSuper)) {
someSupersMutable = true;
} else if (collectionMapping.isReadOnlyCollection(classFromSuper)) {
if (typeFromSuper.varianceOfPosition == Variance.OUT_VARIANCE) {
someSupersCovariantReadOnly = true;
} else {
someSupersNotCovariantReadOnly = true;
}
}
}
}
if (someSupersMutable && someSupersNotCovariantReadOnly) {
reportError("Incompatible types in superclasses: " + typesFromSuper);
return classifier;
} else if (someSupersMutable) {
if (collectionMapping.isReadOnlyCollection(klass)) {
return collectionMapping.convertReadOnlyToMutable(klass);
}
} else if (someSupersNotCovariantReadOnly || someSupersCovariantReadOnly) {
if (collectionMapping.isMutableCollection(klass)) {
return collectionMapping.convertMutableToReadOnly(klass);
}
}
ClassifierDescriptor fixed =
PropagationHeuristics.tryToFixOverridingTWithRawType(this, typesFromSuper);
return fixed != null ? fixed : classifier;
}
/** extracts index definitions as well */
@SuppressWarnings("unchecked")
private void internalExtractColumnDefinitions(
ColumnIdent columnIdent, Map<String, Object> propertiesMap) {
if (propertiesMap == null) {
return;
}
for (Map.Entry<String, Object> columnEntry : propertiesMap.entrySet()) {
Map<String, Object> columnProperties = (Map) columnEntry.getValue();
DataType columnDataType = getColumnDataType(columnProperties);
ColumnIdent newIdent = childIdent(columnIdent, columnEntry.getKey());
columnProperties = furtherColumnProperties(columnProperties);
ReferenceInfo.IndexType columnIndexType = getColumnIndexType(columnProperties);
if (columnDataType == DataTypes.OBJECT
|| (columnDataType.id() == ArrayType.ID
&& ((ArrayType) columnDataType).innerType() == DataTypes.OBJECT)) {
ColumnPolicy columnPolicy = ColumnPolicy.of(columnProperties.get("dynamic"));
add(newIdent, columnDataType, columnPolicy, ReferenceInfo.IndexType.NO, false);
if (columnProperties.get("properties") != null) {
// walk nested
internalExtractColumnDefinitions(
newIdent, (Map<String, Object>) columnProperties.get("properties"));
}
} else if (columnDataType != DataTypes.NOT_SUPPORTED) {
List<String> copyToColumns = getNested(columnProperties, "copy_to");
// extract columns this column is copied to, needed for indices
if (copyToColumns != null) {
for (String copyToColumn : copyToColumns) {
ColumnIdent targetIdent = ColumnIdent.fromPath(copyToColumn);
IndexReferenceInfo.Builder builder = getOrCreateIndexBuilder(targetIdent);
builder.addColumn(
newInfo(newIdent, columnDataType, ColumnPolicy.DYNAMIC, columnIndexType));
}
}
// is it an index?
if (indicesMap.containsKey(newIdent.fqn())) {
IndexReferenceInfo.Builder builder = getOrCreateIndexBuilder(newIdent);
builder
.indexType(columnIndexType)
.ident(new ReferenceIdent(ident, newIdent))
.analyzer((String) columnProperties.get("analyzer"));
} else {
add(newIdent, columnDataType, columnIndexType);
}
}
}
}
private void putTag(final String key, final Tag tag) {
final String[] parts =
(String[])
Iterables.toArray(
Splitter.on('.').split((CharSequence) this.createRelativeKey(key)),
(Class) String.class);
Map<String, Tag> parent = NBTStorage.this.root;
for (int i = 0; i < parts.length - 1; ++i) {
if (!parent.containsKey(parts[i]) || !(parent.get(parts[i]) instanceof CompoundTag)) {
parent.put(parts[i], new CompoundTag(parts[i]));
}
parent = parent.get(parts[i]).getValue();
}
parent.put(tag.getName(), tag);
}
private static Instruction copyInstruction(
@NotNull Instruction instruction, @NotNull Map<Label, Label> originalToCopy) {
if (instruction instanceof AbstractJumpInstruction) {
Label originalTarget = ((AbstractJumpInstruction) instruction).getTargetLabel();
if (originalToCopy.containsKey(originalTarget)) {
return ((AbstractJumpInstruction) instruction).copy(originalToCopy.get(originalTarget));
}
}
if (instruction instanceof NondeterministicJumpInstruction) {
List<Label> originalTargets =
((NondeterministicJumpInstruction) instruction).getTargetLabels();
List<Label> copyTargets = copyLabels(originalTargets, originalToCopy);
return ((NondeterministicJumpInstruction) instruction).copy(copyTargets);
}
return ((InstructionImpl) instruction).copy();
}
private Tag findLastTag(final String key, final boolean relative) {
final String[] parts =
(String[])
Iterables.toArray(
Splitter.on('.')
.omitEmptyStrings()
.split((CharSequence) (relative ? this.createRelativeKey(key) : key)),
(Class) String.class);
if (parts.length == 0) {
return new CompoundTag(NBTStorage.this.name, NBTStorage.this.root);
}
final Map<String, Tag> map = this.findLastParent(parts);
if (!map.containsKey(parts[parts.length - 1])) {
return null;
}
return map.get(parts[parts.length - 1]);
}
/**
* extract dataType from given columnProperties
*
* @param columnProperties map of String to Object containing column properties
* @return dataType of the column with columnProperties
*/
public static DataType getColumnDataType(Map<String, Object> columnProperties) {
DataType type;
String typeName = (String) columnProperties.get("type");
if (typeName == null) {
if (columnProperties.containsKey("properties")) {
type = DataTypes.OBJECT;
} else {
return DataTypes.NOT_SUPPORTED;
}
} else if (typeName.equalsIgnoreCase("array")) {
Map<String, Object> innerProperties = getNested(columnProperties, "inner");
DataType innerType = getColumnDataType(innerProperties);
type = new ArrayType(innerType);
} else {
typeName = typeName.toLowerCase(Locale.ENGLISH);
type = MoreObjects.firstNonNull(dataTypeMap.get(typeName), DataTypes.NOT_SUPPORTED);
}
return type;
}
@Override
public boolean containsType(String name) {
verifyOpen();
return (typeCache.containsKey(name)
|| !Iterables.isEmpty(getVertices(SystemKey.TypeName, name)));
}
public boolean isRemovedRelation(Long relationId) {
return deletedRelations.containsKey(relationId);
}
/**
* Parse the given array of arguments.
*
* <p>Empty arguments are removed from the list of arguments.
*
* @param args an array with arguments
* @param expectedValueFlags a set containing all value flags (pass null to disable value flag
* parsing)
* @param allowHangingFlag true if hanging flags are allowed
* @param namespace the locals, null to create empty one
* @throws CommandException thrown on a parsing error
*/
public CommandContext(
String[] args,
Set<Character> expectedValueFlags,
boolean allowHangingFlag,
Namespace namespace)
throws CommandException {
if (expectedValueFlags == null) {
expectedValueFlags = Collections.emptySet();
}
originalArgs = args;
command = args[0];
this.namespace = namespace != null ? namespace : new Namespace();
boolean isHanging = false;
SuggestionContext suggestionContext = SuggestionContext.hangingValue();
// Eliminate empty args and combine multiword args first
List<Integer> argIndexList = new ArrayList<Integer>(args.length);
List<String> argList = new ArrayList<String>(args.length);
for (int i = 1; i < args.length; ++i) {
isHanging = false;
String arg = args[i];
if (arg.isEmpty()) {
isHanging = true;
continue;
}
argIndexList.add(i);
switch (arg.charAt(0)) {
case '\'':
case '"':
final StringBuilder build = new StringBuilder();
final char quotedChar = arg.charAt(0);
int endIndex;
for (endIndex = i; endIndex < args.length; ++endIndex) {
final String arg2 = args[endIndex];
if (arg2.charAt(arg2.length() - 1) == quotedChar && arg2.length() > 1) {
if (endIndex != i) build.append(' ');
build.append(arg2.substring(endIndex == i ? 1 : 0, arg2.length() - 1));
break;
} else if (endIndex == i) {
build.append(arg2.substring(1));
} else {
build.append(' ').append(arg2);
}
}
if (endIndex < args.length) {
arg = build.toString();
i = endIndex;
}
// In case there is an empty quoted string
if (arg.isEmpty()) {
continue;
}
// else raise exception about hanging quotes?
}
argList.add(arg);
}
// Then flags
List<Integer> originalArgIndices = Lists.newArrayListWithCapacity(argIndexList.size());
List<String> parsedArgs = Lists.newArrayListWithCapacity(argList.size());
Map<Character, String> valueFlags = Maps.newHashMap();
List<Character> booleanFlags = Lists.newArrayList();
for (int nextArg = 0; nextArg < argList.size(); ) {
// Fetch argument
String arg = argList.get(nextArg++);
suggestionContext = SuggestionContext.hangingValue();
// Not a flag?
if (arg.charAt(0) != '-' || arg.length() == 1 || !arg.matches("^-[a-zA-Z\\?]+$")) {
if (!isHanging) {
suggestionContext = SuggestionContext.lastValue();
}
originalArgIndices.add(argIndexList.get(nextArg - 1));
parsedArgs.add(arg);
continue;
}
// Handle flag parsing terminator --
if (arg.equals("--")) {
while (nextArg < argList.size()) {
originalArgIndices.add(argIndexList.get(nextArg));
parsedArgs.add(argList.get(nextArg++));
}
break;
}
// Go through the flag characters
for (int i = 1; i < arg.length(); ++i) {
char flagName = arg.charAt(i);
if (expectedValueFlags.contains(flagName)) {
if (valueFlags.containsKey(flagName)) {
throw new CommandException("Value flag '" + flagName + "' already given");
}
if (nextArg >= argList.size()) {
if (allowHangingFlag) {
suggestionContext = SuggestionContext.flag(flagName);
break;
} else {
throw new CommandException("No value specified for the '-" + flagName + "' flag.");
}
}
// If it is a value flag, read another argument and add it
valueFlags.put(flagName, argList.get(nextArg++));
if (!isHanging) {
suggestionContext = SuggestionContext.flag(flagName);
}
} else {
booleanFlags.add(flagName);
}
}
}
ImmutableMap.Builder<Character, String> allFlagsBuilder =
new ImmutableMap.Builder<Character, String>().putAll(valueFlags);
for (Character flag : booleanFlags) {
allFlagsBuilder.put(flag, "true");
}
this.parsedArgs = ImmutableList.copyOf(parsedArgs);
this.originalArgIndices = ImmutableList.copyOf(originalArgIndices);
this.booleanFlags = ImmutableSet.copyOf(booleanFlags);
this.valueFlags = ImmutableMap.copyOf(valueFlags);
this.allFlags = allFlagsBuilder.build();
this.suggestionContext = suggestionContext;
}
public boolean hasFlag(char ch) {
return booleanFlags.contains(ch) || valueFlags.containsKey(ch);
}
public boolean hasMapping(String mappingType) {
return mappers.containsKey(mappingType);
}
