congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
CtLiteral.setValue
Code IndexAdd Tabnine to your IDE (free)

How to use
setValue
method
in
spoon.reflect.code.CtLiteral

Best Java code snippets using spoon.reflect.code.CtLiteral.setValue (Showing top 20 results out of 315)

origin: INRIA/spoon

  @Override
  public <T, U> void setValue(T element, U value) {
    castTarget(element).setValue(castValue(value));
  }
}
origin: INRIA/spoon

public <T> void visitCtLiteral(spoon.reflect.code.CtLiteral<T> e) {
  ((spoon.reflect.code.CtLiteral<T>) (other)).setValue(e.getValue());
  super.visitCtLiteral(e);
}
origin: INRIA/spoon

switch (operator.getKind()) {
case AND:
  res.setValue((Boolean) leftObject && (Boolean) rightObject);
  break;
case OR:
  res.setValue((Boolean) leftObject || (Boolean) rightObject);
  break;
case EQ:
  if (leftObject == null) {
    res.setValue(leftObject == rightObject);
  } else {
    res.setValue(leftObject.equals(rightObject));
    res.setValue(leftObject != rightObject);
  } else {
    res.setValue(!leftObject.equals(rightObject));
  res.setValue(((Number) leftObject).doubleValue() >= ((Number) rightObject).doubleValue());
  break;
case LE:
  res.setValue(((Number) leftObject).doubleValue() <= ((Number) rightObject).doubleValue());
  break;
case GT:
  res.setValue(((Number) leftObject).doubleValue() > ((Number) rightObject).doubleValue());
  break;
case LT:
  res.setValue(((Number) leftObject).doubleValue() < ((Number) rightObject).doubleValue());
  break;
case MINUS:
origin: INRIA/spoon

/**
 * Creates a one-dimension array that must only contain literals.
 */
@SuppressWarnings("unchecked")
public <T> CtNewArray<T[]> createLiteralArray(T[] value) {
  if (!value.getClass().isArray()) {
    throw new RuntimeException("value is not an array");
  }
  if (value.getClass().getComponentType().isArray()) {
    throw new RuntimeException("can only create one-dimension arrays");
  }
  final CtTypeReference<T> componentTypeRef = factory.Type().createReference((Class<T>) value.getClass().getComponentType());
  final CtArrayTypeReference<T[]> arrayReference = factory.Type().createArrayReference(componentTypeRef);
  CtNewArray<T[]> array = factory.Core().<T[]>createNewArray().setType(arrayReference);
  for (T e : value) {
    CtLiteral<T> l = factory.Core().createLiteral();
    l.setValue(e);
    array.addElement(l);
  }
  return array;
}
origin: INRIA/spoon

/**
 * Creates a literal with a given value.
 *
 * @param <T>
 *         the type of the literal
 * @param value
 *         the value of the literal
 * @return a new literal
 */
public <T> CtLiteral<T> createLiteral(T value) {
  CtLiteral<T> literal = factory.Core().<T>createLiteral();
  literal.setValue(value);
  if (value != null) {
    literal.setType((CtTypeReference<T>) factory.Type().<T>createReference((Class<T>) value.getClass()).unbox());
  } else {
    literal.setType((CtTypeReference<T>) factory.Type().nullType());
  }
  return literal;
}
origin: INRIA/spoon

@Override
public <T> void visitCtUnaryOperator(CtUnaryOperator<T> operator) {
  CtExpression<?> operand = evaluate(operator.getOperand());
  if (operand instanceof CtLiteral) {
    Object object = ((CtLiteral<?>) operand).getValue();
    CtLiteral<Object> res = operator.getFactory().Core().createLiteral();
    switch (operator.getKind()) {
    case NOT:
      res.setValue(!(Boolean) object);
      break;
    default:
      throw new RuntimeException("unsupported operator " + operator.getKind());
    }
    setResult(res);
    return;
  }
  setResult(operator.clone());
}
origin: INRIA/spoon

if (actualClass != null) {
  CtLiteral<Class<?>> literal = fieldAccess.getFactory().Core().createLiteral();
  literal.setValue(actualClass);
  setResult(literal);
  return;
  .isSubtypeOf(fieldAccess.getVariable().getDeclaringType())) {
CtLiteral<CtFieldReference<?>> l = fieldAccess.getFactory().Core().createLiteral();
l.setValue(fieldAccess.getVariable());
setResult(l);
return;
origin: SpoonLabs/astor

@Override
public void apply() {
  previousValue = affected.getValue();
  affected.setValue(placeholder_name);
}
origin: SpoonLabs/astor

@Override
public void apply() {
  previousValue = target.getValue();
  target.setValue(newValue);
}
origin: INRIA/spoon

if (isLiteralType(r)) {
  CtLiteral<T> l = invocation.getFactory().Core().createLiteral();
  l.setValue(r);
  setResult(l);
  return;
origin: SpoonLabs/nopol

public static <T> CtLiteral<T> newLiteral(Factory factory, T value) {
  CtLiteral<T> newLiteral = factory.Core().createLiteral();
  newLiteral.setValue(value);
  return newLiteral;
}
origin: net.openhft/spoon-core

/**
 * Creates a literal with a given value.
 *
 * @param <T>
 *         the type of the literal
 * @param value
 *         the value of the literal
 * @return a new literal
 */
public <T> CtLiteral<T> createLiteral(T value) {
  return factory.Core().<T>createLiteral().setValue(value);
}
origin: net.openhft/spoon-core

@Override
public boolean visit(TrueLiteral trueLiteral, BlockScope scope) {
  CtLiteral<Boolean> l = factory.Core().createLiteral();
  l.setValue(true);
  context.enter(l, trueLiteral);
  return true;
}
origin: net.openhft/spoon-core

@Override
public boolean visit(ExtendedStringLiteral extendedStringLiteral, BlockScope scope) {
  CtLiteral<String> l = factory.Core().createLiteral();
  l.setValue(new String(extendedStringLiteral.source()));
  context.enter(l, extendedStringLiteral);
  return true;
}
origin: net.openhft/spoon-core

@Override
public boolean visit(CharLiteral charLiteral, BlockScope scope) {
  CtLiteral<Character> l = factory.Core().createLiteral();
  l.setValue(charLiteral.constant.charValue());
  context.enter(l, charLiteral);
  return true;
}
origin: net.openhft/spoon-core

@Override
public boolean visit(QualifiedTypeReference arg0, BlockScope arg1) {
  if (skipTypeInAnnotation) {
    return true;
  }
  CtLiteral<CtTypeReference<?>> l = factory.Core().createLiteral();
  l.setValue(references.getTypeReference(arg0.resolvedType));
  context.enter(l, arg0);
  return true; // do nothing by default, keep traversing
}
origin: net.openhft/spoon-core

@Override
public boolean visit(ArrayTypeReference arrayTypeReference, BlockScope scope) {
  CtLiteral<CtTypeReference<?>> l = factory.Core().createLiteral();
  l.setValue(references.getTypeReference(arrayTypeReference.resolvedType));
  context.enter(l, arrayTypeReference);
  return true;
}
origin: net.openhft/spoon-core

@Override
public boolean visit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, BlockScope scope) {
  if (skipTypeInAnnotation) {
    return true;
  }
  CtLiteral<CtTypeReference<?>> l = factory.Core().createLiteral();
  l.setValue(references.getBoundedTypeReference(parameterizedSingleTypeReference.resolvedType));
  context.enter(l, parameterizedSingleTypeReference);
  return true;
}
origin: net.openhft/spoon-core

@Override
public boolean visit(IntLiteral intLiteral, BlockScope scope) {
  CtLiteral<Integer> l = factory.Core().createLiteral();
  CtTypeReference<Integer> r = references.getTypeReference(intLiteral.resolvedType);
  l.setType(r);
  if (intLiteral.constant != null) { // check required for noclasspath mode
    l.setValue(intLiteral.constant.intValue());
  }
  context.enter(l, intLiteral);
  return true;
}
origin: net.openhft/spoon-core

@Override
public boolean visit(LongLiteral longLiteral, BlockScope scope) {
  CtLiteral<Long> l = factory.Core().createLiteral();
  l.setValue(longLiteral.constant.longValue());
  CtTypeReference<Long> r = references.getTypeReference(longLiteral.resolvedType);
  l.setType(r);
  context.enter(l, longLiteral);
  return true;
}
spoon.reflect.codeCtLiteralsetValue

Javadoc

Sets the actual value of the literal.

Popular methods of CtLiteral

  • getValue
    Gets the actual value of the literal (statically known).
  • getType
  • getTypeCasts
  • replace
  • getAnnotations
  • getFactory
  • getParent
  • setFactory
  • setType
  • setTypeCasts
  • addTypeCast
  • clone
  • addTypeCast,
  • clone,
  • getComments,
  • getPosition,
  • setAnnotations,
  • setComments

Popular in Java

  • Finding current android device location
  • onCreateOptionsMenu (Activity)
  • requestLocationUpdates (LocationManager)
  • addToBackStack (FragmentTransaction)
  • InputStreamReader (java.io)
    A class for turning a byte stream into a character stream. Data read from the source input stream is
  • Permission (java.security)
    Legacy security code; do not use.
  • NumberFormat (java.text)
    The abstract base class for all number formats. This class provides the interface for formatting and
  • JFrame (javax.swing)
  • Location (org.springframework.beans.factory.parsing)
    Class that models an arbitrary location in a Resource.Typically used to track the location of proble
  • SAXParseException (org.xml.sax)
    Encapsulate an XML parse error or warning.> This module, both source code and documentation, is in t
  • Sublime Text for Python
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now