org.apache.olingo.odata2.api.edm.EdmLiteral Java Examples

@Override
public Object visitLiteral(LiteralExpression literal, EdmLiteral edm_literal)
{
   try
   {
      // A literal is a Provider<?> (Functional Java)
      // Returns a Node<?> (Expression Tree)
      Object o = edm_literal.getType().valueOfString(
            edm_literal.getLiteral(),
            EdmLiteralKind.DEFAULT,
            null,
            edm_literal.getType().getDefaultType());
      return ExecutableExpressionTree.Node.createLeave(ConstantFactory.constantFactory(o));
   }
   catch (EdmException ex)
   {
      throw new RuntimeException(ex);
   }
}
 

@Override
public ODataResponse executeFunctionImport(GetFunctionImportUriInfo uri_info, String content_type)
      throws ODataException
{
   EdmFunctionImport function_import = uri_info.getFunctionImport();
   Map<String, EdmLiteral> params = uri_info.getFunctionImportParameters();
   EntityProviderWriteProperties entry_props =
         EntityProviderWriteProperties.serviceRoot(makeLink()).build();

   AbstractOperation op = Model.getServiceOperation(function_import.getName());

   fr.gael.dhus.database.object.User current_user =
         ApplicationContextProvider.getBean(SecurityService.class).getCurrentUser();
   if (!op.canExecute(current_user))
   {
      throw new NotAllowedException();
   }

   Object res = op.execute(params);

   return EntityProvider.writeFunctionImport(content_type, function_import, res, entry_props);
}
 

private Object[] getArguments() throws EdmException {
  Map<String, EdmLiteral> edmArguments = functionView.getFunctionImportParameters();

  if (edmArguments == null) {
    return null;
  } else {
    Collection<String> paramNames = functionImport.getParameterNames();
    Object[] args = new Object[paramNames.size()];
    int i = 0;
    for (String paramName : functionImport.getParameterNames()) {
      EdmLiteral literal = edmArguments.get(paramName);
      EdmParameter parameter = functionImport.getParameter(paramName);
      JPAEdmMapping mappingValue = (JPAEdmMapping) parameter.getMapping();
      args[i++] = convertArgument(literal, parameter.getFacets(), mappingValue.getJPAType());
    }
    return args;
  }

}
 

private void handleOtherQueryParameters() throws UriSyntaxException, EdmException {
  final EdmFunctionImport functionImport = uriResult.getFunctionImport();
  if (functionImport != null) {
    for (final String parameterName : functionImport.getParameterNames()) {
      final EdmParameter parameter = functionImport.getParameter(parameterName);
      final String value = otherQueryParameters.remove(parameterName);

      if (value == null) {
        if (parameter.getFacets() == null || parameter.getFacets().isNullable() == null
            || parameter.getFacets().isNullable()) {
          continue;
        } else {
          throw new UriSyntaxException(UriSyntaxException.MISSINGPARAMETER);
        }
      }

      EdmLiteral uriLiteral = parseLiteral(value, (EdmSimpleType) parameter.getType(), parameter.getFacets());
      uriResult.addFunctionImportParameter(parameterName, uriLiteral);
    }
  }

  uriResult.setCustomQueryOptions(otherQueryParameters);
}
 

private EdmLiteral parseLiteral(final String value, final EdmSimpleType expectedType) throws UriSyntaxException {
  EdmLiteral literal;
  try {
    literal = simpleTypeFacade.parseUriLiteral(value);
  } catch (EdmLiteralException e) {
    throw convertEdmLiteralException(e);
  }

  if (expectedType.isCompatible(literal.getType())) {
    return literal;
  } else {
    throw new UriSyntaxException(UriSyntaxException.INCOMPATIBLELITERAL.addContent(value, expectedType));
  }
}
 

@Override
public Object visitLiteral(LiteralExpression literal, EdmLiteral edmLiteral) {
    try {
        final EdmSimpleType type = edmLiteral.getType();

        final Object value = type.valueOfString(edmLiteral.getLiteral(),
            EdmLiteralKind.DEFAULT, null, type.getDefaultType());

        return new TypedValue(type.getDefaultType(), edmLiteral.getLiteral(), value);
    } catch (EdmSimpleTypeException ex) {
        throw new SearchParseException("Failed to convert literal to a typed form: " + literal, ex);
    }
}
 

private static Map<String, Object> mapFunctionParameters(final Map<String, EdmLiteral> functionImportParameters)
    throws EdmSimpleTypeException {
  if (functionImportParameters == null) {
    return Collections.emptyMap();
  } else {
    Map<String, Object> parameterMap = new HashMap<String, Object>();
    for (final String parameterName : functionImportParameters.keySet()) {
      final EdmLiteral literal = functionImportParameters.get(parameterName);
      final EdmSimpleType type = literal.getType();
      parameterMap.put(parameterName, type.valueOfString(literal.getLiteral(), EdmLiteralKind.DEFAULT, null, type
          .getDefaultType()));
    }
    return parameterMap;
  }
}
 

public static void parse(final String literal, final EdmSimpleType expectedType) throws EdmLiteralException {
  final EdmLiteral uriLiteral = EdmSimpleTypeKind.parseUriLiteral(literal);
  assertNotNull(uriLiteral);
  if (!expectedType.equals(EdmNull.getInstance())) {
    assertNotNull(uriLiteral.getLiteral());
    assertTrue(uriLiteral.getLiteral().length() > 0);
  }
  assertNotNull(uriLiteral.getType());
  assertEquals(expectedType, uriLiteral.getType());
}
 

public void addFunctionImportParameter(final String name, final EdmLiteral value) {
  if (functionImportParameters.equals(Collections.EMPTY_MAP)) {
    functionImportParameters = new HashMap<String, EdmLiteral>();
  }

  functionImportParameters.put(name, value);
}
 

private EdmLiteral parseLiteral(String value, EdmSimpleType expectedType, EdmFacets facets) 
    throws UriSyntaxException {
  EdmLiteral literal;
  try {
    literal = simpleTypeFacade.parseUriLiteral(value, facets);
  } catch (EdmLiteralException e) {
    throw convertEdmLiteralException(e);
  }

  if (expectedType.isCompatible(literal.getType())) {
    return literal;
  } else {
    throw new UriSyntaxException(UriSyntaxException.INCOMPATIBLELITERAL.addContent(value, expectedType));
  }
}
 

public PropertyExpressionImpl(final String uriLiteral, final EdmLiteral edmLiteral) {
  this.uriLiteral = uriLiteral;

  this.edmLiteral = edmLiteral;
  if (edmLiteral != null) {
    edmType = edmLiteral.getType();
  }
}
 

private boolean checkForBoolean(final int oldPosition, final String rem_expr) {
  boolean isBoolean = false;
  if ("true".equals(rem_expr) || "false".equals(rem_expr)) {
    curPosition = curPosition + rem_expr.length();
    tokens.appendEdmTypedToken(oldPosition, TokenKind.SIMPLE_TYPE, rem_expr, new EdmLiteral(EdmSimpleTypeFacadeImpl
        .getEdmSimpleType(EdmSimpleTypeKind.Boolean), rem_expr));
    isBoolean = true;
  }
  return isBoolean;
}
 

private boolean checkForLiteral(final int oldPosition, final char curCharacter, final String rem_expr) {
  final Matcher matcher = OTHER_LIT.matcher(rem_expr);
  boolean isLiteral = false;
  if (matcher.lookingAt()) {
    String token = matcher.group();
    try {
      EdmLiteral edmLiteral = typeDectector.parseUriLiteral(token);
      curPosition = curPosition + token.length();
      // It is a simple type.
      tokens.appendEdmTypedToken(oldPosition, TokenKind.SIMPLE_TYPE, token, edmLiteral);
      isLiteral = true;
    } catch (EdmLiteralException e) {
      // We treat it as normal untyped literal.

      // The '-' is checked here (and not in the switch statement) because it may be
      // part of a negative number.
      if (curCharacter == '-') {
        curPosition = curPosition + 1;
        tokens.appendToken(oldPosition, TokenKind.SYMBOL, curCharacter);
        isLiteral = true;
      } else {
        curPosition = curPosition + token.length();
        tokens.appendToken(oldPosition, TokenKind.LITERAL, token);
        isLiteral = true;
      }
    }
  }
  return isLiteral;
}
 

/**
 * Append UriLiteral Token to tokens parameter
 * @param position Position of parsed token
 * @param kind Kind of parsed token
 * @param javaLiteral EdmLiteral of parsed token containing type and value of UriLiteral
 */
public void appendEdmTypedToken(final int position, final TokenKind kind, final String uriLiteral,
    final EdmLiteral javaLiteral) {
  Token token = new Token(kind, position, uriLiteral, javaLiteral);
  tokens.add(token);
  return;
}
 

@Override
public Object visitLiteral(final LiteralExpression literal, final EdmLiteral edmLiteral) {
  try {
    StringWriter writer = new StringWriter();
    JsonStreamWriter jsonStreamWriter = new JsonStreamWriter(writer);
    jsonStreamWriter.beginObject().namedStringValueRaw("nodeType", literal.getKind().toString()).separator()
        .namedStringValueRaw("type", getType(literal)).separator().namedStringValue("value", edmLiteral.getLiteral())
        .endObject();
    writer.flush();
    return writer.toString();
  } catch (final IOException e) {
    return null;
  }
}
 

private static EdmLiteral createEdmLiteral(final EdmSimpleTypeKind typeKind, final String literal,
    final int prefixLength, final int suffixLength) throws EdmLiteralException {
  final EdmSimpleType type = getEdmSimpleType(typeKind);
  if (type.validate(literal, EdmLiteralKind.URI, null)) {
    return new EdmLiteral(type, literal.substring(prefixLength, literal.length() - suffixLength));
  } else {
    throw new EdmLiteralException(EdmLiteralException.LITERALFORMAT.addContent(literal));
  }
}
 

@Override
public ODataResponse executeFunctionImportValue(GetFunctionImportUriInfo uri_info, String content_type)
      throws ODataException
{
   EdmFunctionImport function_import = uri_info.getFunctionImport();
   Map<String, EdmLiteral> params = uri_info.getFunctionImportParameters();

   // FIXME: returned type might not be a simple type ...
   EdmSimpleType type = (EdmSimpleType) function_import.getReturnType().getType();

   AbstractOperation op = Model.getServiceOperation(function_import.getName());

   fr.gael.dhus.database.object.User current_user =
         ApplicationContextProvider.getBean(SecurityService.class).getCurrentUser();
   if (!op.canExecute(current_user))
   {
      throw new NotAllowedException();
   }

   Object res = op.execute(params);

   /* To handle binary results (NYI):
   if (type == EdmSimpleTypeKind.Binary.getEdmSimpleTypeInstance()) {
      response = EntityProvider.writeBinary(
         ((BinaryData) data).getMimeType(),    // BinaryData is an meta-object holding the data
         ((BinaryData) data).getData()         // and its mime type
       );
   }//*/
   final String value = type.valueToString(res, EdmLiteralKind.DEFAULT, null);

   return EntityProvider.writeText(value == null ? "" : value);
}
 

private Object convertArgument(final EdmLiteral edmLiteral, final EdmFacets facets, final Class<?> targetType)
    throws EdmSimpleTypeException {
  Object value = null;
  if (edmLiteral != null) {
    EdmSimpleType edmType = edmLiteral.getType();
    value = edmType.valueOfString(edmLiteral.getLiteral(), EdmLiteralKind.DEFAULT, facets, targetType);
  }
  return value;
}
 

private static Map<String, Object> mapFunctionParameters(final Map<String, EdmLiteral> functionImportParameters)
    throws EdmSimpleTypeException {
  if (functionImportParameters == null) {
    return Collections.emptyMap();
  } else {
    Map<String, Object> parameterMap = new HashMap<String, Object>();
    for (final Entry<String, EdmLiteral> parameter : functionImportParameters.entrySet()) {
      final EdmLiteral literal = parameter.getValue();
      final EdmSimpleType type = literal.getType();
      parameterMap.put(parameter.getKey(), type.valueOfString(literal.getLiteral(), EdmLiteralKind.DEFAULT, null, type
          .getDefaultType()));
    }
    return parameterMap;
  }
}
 

public LiteralExpressionImpl(final String uriLiteral, final EdmLiteral javaLiteral) {
  this.uriLiteral = uriLiteral;
  edmLiteral = javaLiteral;
  edmType = edmLiteral.getType();
}
 

@Override
public Object visitLiteral(LiteralExpression literal, EdmLiteral edm_literal)
{
   Object result;
   Class type = edm_literal.getType().getDefaultType();

   if (type.equals(Boolean.class))
   {
      result = Boolean.valueOf(edm_literal.getLiteral());
   }
   else if (type.equals(Byte.class)    || type.equals(Short.class) ||
            type.equals(Integer.class) || type.equals(Long.class))
   {
      result = Long.valueOf(edm_literal.getLiteral());
   }
   else if (type.equals(Double.class) || type.equals(BigDecimal.class))
   {
      result = Double.valueOf(edm_literal.getLiteral());
   }
   else if (type.equals(String.class))
   {
      result = edm_literal.getLiteral();
   }
   else if (type.equals(Calendar.class))
   {
      SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
      SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");
      try
      {
         result = sdf1.parse(edm_literal.getLiteral());
      }
      catch (ParseException e)
      {
         try
         {
            result = sdf2.parse(edm_literal.getLiteral());
         }
         catch (ParseException e1)
         {
            throw new IllegalArgumentException("Invalid date format");
         }
      }
   }
   else
   {
      throw new IllegalArgumentException("Type " + edm_literal.getType() +
            " is not supported by the service");
   }

   return result;
}
 

@Override
public Object visitLiteral(final LiteralExpression literal, final EdmLiteral edmLiteral) {
  return "" + literal.getUriLiteral() + "";
}
 

private void parseIncompatibleLiteralContent(final String literal, final EdmSimpleTypeKind typeKind)
    throws EdmLiteralException {
  final EdmLiteral uriLiteral = EdmSimpleTypeKind.parseUriLiteral(literal);
  assertFalse(typeKind.getEdmSimpleTypeInstance().isCompatible(uriLiteral.getType()));
}
 

@Override
public Object execute(Map<String, EdmLiteral> parameters) throws ODataException
{
   EdmLiteral query_lit = parameters.remove("query");
   // Olingo2 checks for presence of non-nullable parameters for us!
   String query_s = query_lit.getLiteral();
   Query query = QueryFactory.create(query_s);
   if (!(query.isSelectType() || query.isDescribeType()))
   {
      throw new InvalidOperationException(query.getQueryType());
   }

   DrbCortexModel cortexmodel;
   try
   {
      cortexmodel = DrbCortexModel.getDefaultModel();
   }
   catch (IOException ex)
   {
      throw new RuntimeException(ex);
   }

   Model model = cortexmodel.getCortexModel().getOntModel();

   QueryExecution qexec = null;
   // FIXME: QueryExecution in newer versions of Jena (post apache incubation) implement AutoClosable.
   try
   {
      qexec = QueryExecutionFactory.create(query, model);
      if (query.isSelectType())
      {
         ResultSet results = qexec.execSelect();
         return ResultSetFormatter.asXMLString(results);
      }
      else
      {
         Model description = qexec.execDescribe();
         // newer version of Jena have the RIOT package for I/O
         StringWriter strwrt = new StringWriter();
         Abbreviated abb = new Abbreviated();
         abb.write(description, strwrt, null);
         return strwrt.toString();
      }
   }
   finally
   {
      if (qexec != null)
      {
         qexec.close();
      }
   }
}
 

@Override
public Map<String, EdmLiteral> getFunctionImportParameters() {
  return functionImportParameters;
}
 

@Override
public Map<String, EdmLiteral> getFunctionImportParameters()
{
   return Map.class.cast(get("getFunctionImportParameters"));
}
 

public EdmLiteral getJavaLiteral() {
  return javaLiteral;
}
 

@Override
public EdmLiteral parseUriLiteral(String uriLiteral, EdmFacets facets) throws EdmLiteralException {
  this.facets = facets;
  return parseUriLiteral(uriLiteral);
}
 

/**
 * Read up to single ' and move pointer to the following char and tries a type detection
 * @param curCharacter
 * @param token
 * @throws ExpressionParserException
 * @throws TokenizerException
 */
private void readLiteral(char curCharacter, String token) throws ExpressionParserException, TokenizerException {
  int offsetPos = -token.length();
  int oldPosition = curPosition;
  token = token + Character.toString(curCharacter);
  curPosition = curPosition + 1;

  boolean wasApostroph = false; // leading ' does not count
  while (curPosition < expressionLength) {
    curCharacter = expression.charAt(curPosition);

    if (curCharacter != '\'') {
      if (wasApostroph == true) {
        break;
      }

      token = token + curCharacter;
      wasApostroph = false;
    } else {
      if (wasApostroph) {
        wasApostroph = false; // a double ' is a normal character '
      } else {
        wasApostroph = true;
      }
      token = token + curCharacter;
    }
    curPosition = curPosition + 1;
  }

  if (!wasApostroph) {
    // Exception tested within TestPMparseFilterString
    throw FilterParserExceptionImpl.createTOKEN_UNDETERMINATED_STRING(oldPosition, expression);
  }

  try {
    EdmLiteral edmLiteral = typeDectector.parseUriLiteral(token);
    tokens.appendEdmTypedToken(oldPosition + offsetPos, TokenKind.SIMPLE_TYPE, token, edmLiteral);
  } catch (EdmLiteralException ex) {
    throw TokenizerException.createTYPEDECTECTION_FAILED_ON_STRING(ex, oldPosition, token);
  }
}
 

private Map<String, EdmLiteral> getFunctionImportParameters() {
  Map<String, EdmLiteral> paramMap = new HashMap<String, EdmLiteral>();
  paramMap.put(PARAMNAME, new EdmLiteral(EdmSimpleTypeKind.String.getEdmSimpleTypeInstance(), PARAMVALUE));
  return paramMap;
}