How to use org.apache.asterix.om.types

@Override
public void generateNestedDerivedTypeNames() {
  if (itemType.getTypeTag().isDerivedType() && itemType.getTypeName() == null) {
    AbstractComplexType nestedType = ((AbstractComplexType) itemType);
    nestedType.setTypeName(getTypeName() + "_Item");
    nestedType.generateNestedDerivedTypeNames();
  }
}

@Override
public void generateNestedDerivedTypeNames() {
  for (int i = 0; i < fieldTypes.length; i++) {
    IAType fieldType = fieldTypes[i];
    if (fieldType.getTypeTag().isDerivedType() && (fieldType.getTypeName() == null)) {
      AbstractComplexType nestedType = (AbstractComplexType) fieldType;
      nestedType.setTypeName(getTypeName() + "_" + fieldNames[i]);
      nestedType.generateNestedDerivedTypeNames();
    }
  }
}

@Override
public void generateNestedDerivedTypeNames() {
  if (isUnknownableType()) {
    IAType nullableType = getActualType();
    if (nullableType.getTypeTag().isDerivedType() && nullableType.getTypeName() == null) {
      AbstractComplexType derivedType = (AbstractComplexType) nullableType;
      derivedType.setTypeName(getTypeName());
      derivedType.generateNestedDerivedTypeNames();
    }
  }
}

  @Override
  protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException {
    IAType argType = strippedInputTypes[0];
    switch (argType.getTypeTag()) {
      case ARRAY:
        return argType;
      case MULTISET:
        return new AOrderedListType(((AUnorderedListType) argType).getItemType(), null);
      default:
        return new AOrderedListType(argType, null);
    }
  }
}

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}

  @Override
  protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException {
    IAType type = strippedInputTypes[0];
    if (type.getTypeTag().isListType()) {
      return AUnionType.createNullableType(((AbstractCollectionType) type).getItemType());
    }
    return BuiltinType.ANY;
  }
}

public static boolean isClosed(IAType t) {
  switch (t.getTypeTag()) {
    case MISSING:
    case ANY:
      return false;
    case UNION:
      return isClosed(((AUnionType) t).getActualType());
    default:
      return true;
  }
}

@Override
protected IAType getResultType(ILogicalExpression expr, IAType... strippedInputTypes) throws AlgebricksException {
  IAType type = strippedInputTypes[0];
  if (type.getTypeTag() == ATypeTag.ANY) {
    return BuiltinType.ANY;
  }
  IAType itemType = ((AbstractCollectionType) type).getItemType();
  if (itemType.getTypeTag() == ATypeTag.ANY) {
    return itemType;
  }
  // Could have out-of-bound access or null elements.
  return AUnionType.createUnknownableType(itemType);
}

private IAType getActualType(IAType definedType) {
  if (definedType.getTypeTag() == ATypeTag.UNION) {
    return ((AUnionType) definedType).getActualType();
  }
  return definedType;
}

/**
 * Maintains the {@code updatedRecordType} as nullable/missable (?) in case it was originally nullable/missable
 * @param originalRecordType the original record type
 * @param updatedRecordType the original record type being enforced/modified with new non-declared fields included
 * @return {@code updatedRecordType}
 */
private static IAType keepUnknown(IAType originalRecordType, ARecordType updatedRecordType) {
  if (originalRecordType.getTypeTag() == ATypeTag.UNION) {
    return AUnionType.createUnknownableType(updatedRecordType, updatedRecordType.getTypeName());
  }
  return updatedRecordType;
}

public static IAType createMissableType(IAType t) {
  if (t != null && t.getTypeTag() == ATypeTag.MISSING) {
    return t;
  }
  String s = t != null ? t.getTypeName() : null;
  return createMissableType(t, s == null ? null : s + "?");
}

/**
 * Decide whether a type is an optional type
 *
 * @param type
 * @return true if it is optional; false otherwise
 */
public static boolean isOptional(IAType type) {
  return type.getTypeTag() == ATypeTag.UNION && ((AUnionType) type).isUnknownableType();
}

public UnorderedListConstructorEvaluatorFactory(IScalarEvaluatorFactory[] args, AUnorderedListType type) {
  this.args = args;
  this.unorderedlistType = type;
  if (type == null || type.getItemType() == null || type.getItemType().getTypeTag() == ATypeTag.ANY) {
    this.selfDescList = true;
  } else {
    this.homoList = true;
  }
}

@Override
public IAType computeType(ILogicalExpression expression, IVariableTypeEnvironment env,
    IMetadataProvider<?, ?> metadataProvider) throws AlgebricksException {
  return new AUnorderedListType(((AUnorderedListType) type).getItemType(), type.getTypeName());
}

protected boolean isNullableType(IAType definedType) {
  if (definedType.getTypeTag() != ATypeTag.UNION) {
    return false;
  }
  return ((AUnionType) definedType).isNullableType();
}

@Override
public boolean deepEqual(IAObject obj) {
  if (obj == this) {
    return true;
  }
  if (!(obj instanceof BuiltinType)) {
    return false;
  }
  return ((BuiltinType) obj).getTypeTag().equals(getTypeTag());
}

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}

public static AOrderedListType extractOrderedListType(IAType t) {
  if (t.getTypeTag() == ATypeTag.ARRAY) {
    return (AOrderedListType) t;
  }
  if (t.getTypeTag() == ATypeTag.UNION) {
    IAType innerType = ((AUnionType) t).getActualType();
    if (innerType.getTypeTag() == ATypeTag.ARRAY) {
      return (AOrderedListType) innerType;
    }
  }
  return null;
}

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}