Package ch.epfl.labos.iu.orm.queryll2.path

Examples of ch.epfl.labos.iu.orm.queryll2.path.PathAnalysisSimplifier

33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
            SymbExToColumns translator = new SymbExToColumns(metamodel,
                  new SelectFromWhereLambdaArgumentHandler(where, fromList));
            Condition methodExpr = null;
            for (int n = 0; n < where.symbolicAnalysis.paths.size(); n++)
            {
               PathAnalysis path = where.symbolicAnalysis.paths.get(n);

               TypedValue returnVal = PathAnalysisSimplifier.simplifyBoolean(path.getReturnValue(), Collections.emptyMap());
               ColumnExpressions<?> returnColumns = translator.transform(returnVal);
               if (!returnColumns.isSingleColumn()) throw new IllegalArgumentException("Where lambda should only return a single column of data");
               QueryPart returnExpr = returnColumns.getOnlyColumn();

               if (returnVal instanceof ConstantValue.BooleanConstant)
               {
                  if (((ConstantValue.BooleanConstant)returnVal).val)
                  {
                     // This path returns true, so it's redundant to actually
                     // put true into the final code.
                     returnExpr = null;
                  }
                  else
                  {
                     // This path returns false, so we can ignore it
                     continue;
                  }
               }
              
               // Handle where path conditions
               Condition conditionExpr = null;
               for (TypedValue cmp: path.getConditions())
               {
                  ColumnExpressions<?> col = translator.transform(cmp);
                  if (!col.isSingleColumn()) throw new IllegalArgumentException("Expecting a single column");
                  Condition expr = (Condition)col.getOnlyColumn();
                  if (conditionExpr != null)
View Full Code Here
214
215
216
217
218
219
220
221
222
223
224
   }

   private static MethodAnalysisResults analyzeLambda(MetamodelUtil metamodel, ClassLoader alternateClassLoader, boolean isObjectEqualsSafe, String className, String methodName, String methodSignature) throws IOException, AnalyzerException
   {
      // Open up the corresponding class to analyze
      PathAnalysisFactory pathAnalysisFactory = new PathAnalysisFactory(
            metamodel.getMethodChecker(isObjectEqualsSafe));
      TransformationClassAnalyzer classAnalyzer =
            new TransformationClassAnalyzer(className, alternateClassLoader);
      MethodAnalysisResults analysis = classAnalyzer.analyzeLambdaMethod(methodName, methodSignature, pathAnalysisFactory);
      PathAnalysisSimplifier.cleanAndSimplify(analysis, metamodel.getComparisonMethods(isObjectEqualsSafe));
View Full Code Here
231
232
233
234
235
236
237
238
239
240
241
      TransformationClassAnalyzer classAnalyzer =
            new TransformationClassAnalyzer(lambdaClass.getName(), alternateClassLoader);
      Method matchingMethod = lambdaAsClass.findLambdaMethod(lambdaClass);
      if (matchingMethod == null)
         throw new AnalyzerException(null, "Could not find a lambda method with the expected name in the class");
      PathAnalysisFactory pathAnalysisFactory = new PathAnalysisFactory(
            metamodel.getMethodChecker(isObjectEqualsSafe));
      MethodAnalysisResults analysis = classAnalyzer.analyzeLambdaMethod(matchingMethod.getName(), Type.getMethodDescriptor(matchingMethod), pathAnalysisFactory);
      PathAnalysisSimplifier.cleanAndSimplify(analysis, metamodel.getComparisonMethods(isObjectEqualsSafe));
      return analysis;
   }
View Full Code Here
50
51
52
53
54
55
56
57
58
59
60
  
   private static MethodAnalysisResults analyzeLambda(MetamodelUtil metamodel, String className, String methodName, String methodSignature)
   {
      try {
         // Open up the corresponding class to analyze
         PathAnalysisFactory pathAnalysisFactory = new PathAnalysisFactory(
               new MethodChecker(metamodel));
         TransformationClassAnalyzer classAnalyzer =
               new TransformationClassAnalyzer(className);
         MethodAnalysisResults analysis = classAnalyzer.analyzeLambdaMethod(methodName, methodSignature, pathAnalysisFactory);
         PathAnalysisSimplifier.cleanAndSimplify(analysis, Collections.emptyMap());
View Full Code Here
216
217
218
219
220
221
222
223
224
225
226
   private static MethodAnalysisResults analyzeLambda(MetamodelUtil metamodel, ClassLoader alternateClassLoader, boolean isObjectEqualsSafe, String className, String methodName, String methodSignature) throws IOException, AnalyzerException
   {
      // Open up the corresponding class to analyze
      PathAnalysisFactory pathAnalysisFactory = new PathAnalysisFactory(
            metamodel.getMethodChecker(isObjectEqualsSafe));
      TransformationClassAnalyzer classAnalyzer =
            new TransformationClassAnalyzer(className, alternateClassLoader);
      MethodAnalysisResults analysis = classAnalyzer.analyzeLambdaMethod(methodName, methodSignature, pathAnalysisFactory);
      PathAnalysisSimplifier.cleanAndSimplify(analysis, metamodel.getComparisonMethods(isObjectEqualsSafe));
      return analysis;
   }
View Full Code Here
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
   }

   private static MethodAnalysisResults analyzeLambdaClass(Class<?> lambdaClass, MetamodelUtil metamodel, LambdaAsClassAnalysisConfig lambdaAsClass, ClassLoader alternateClassLoader, boolean isObjectEqualsSafe) throws IOException, AnalyzerException
   {
      // Open up the corresponding class to analyze
      TransformationClassAnalyzer classAnalyzer =
            new TransformationClassAnalyzer(lambdaClass.getName(), alternateClassLoader);
      Method matchingMethod = lambdaAsClass.findLambdaMethod(lambdaClass);
      if (matchingMethod == null)
         throw new AnalyzerException(null, "Could not find a lambda method with the expected name in the class");
      PathAnalysisFactory pathAnalysisFactory = new PathAnalysisFactory(
            metamodel.getMethodChecker(isObjectEqualsSafe));
      MethodAnalysisResults analysis = classAnalyzer.analyzeLambdaMethod(matchingMethod.getName(), Type.getMethodDescriptor(matchingMethod), pathAnalysisFactory);
      PathAnalysisSimplifier.cleanAndSimplify(analysis, metamodel.getComparisonMethods(isObjectEqualsSafe));
      return analysis;
   }
View Full Code Here
52
53
54
55
56
57
58
59
60
61
62
63
64
   {
      try {
         // Open up the corresponding class to analyze
         PathAnalysisFactory pathAnalysisFactory = new PathAnalysisFactory(
               new MethodChecker(metamodel));
         TransformationClassAnalyzer classAnalyzer =
               new TransformationClassAnalyzer(className);
         MethodAnalysisResults analysis = classAnalyzer.analyzeLambdaMethod(methodName, methodSignature, pathAnalysisFactory);
         PathAnalysisSimplifier.cleanAndSimplify(analysis, Collections.emptyMap());
         return analysis;
      } catch (IOException e)
      {
         e.printStackTrace();
View Full Code Here
116
117
118
119
120
121
122
123
124
125
126
127
   public void registerORMSimpleLink(String entityPackage, String map,
                                     String fromEntityName, String fromField, String fromCol,
                                     String toEntityName, String toField, String toCol)
   {
      ORMEntity fromEntity = entityFor(fromEntityName);
      ORMEntity toEntity = entityFor(toEntityName);
      String fromInternalName = makeInternalName(fromEntity.entityPackage, fromEntity.name);
      String toInternalName = makeInternalName(toEntity.entityPackage, toEntity.name);
      MethodSignature from1Signature =
         makeMethodSignature(entityPackage,
                             fromEntity.name,
View Full Code Here
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
      }
      final List<MethodSignature> transformConstructorsCalled = new ArrayList<MethodSignature>();
      final DBSetSourceChecker checkDBSets = new DBSetSourceChecker(entityInfo);
      final Set<TypedValue> unresolvedDBSets = new HashSet<TypedValue>();
      ConditionRecorder pathConditions = new ConditionRecorder();
      BasicSymbolicInterpreter interpreter = new SymbolicInterpreterWithFieldAccess(Opcodes.ASM5);
      FrameWithHelpers frame = new FrameWithHelpers(cl, m, interpreter);
      interpreter.setFrameForAliasingFixups(frame);
      interpreter.setBranchHandler(pathConditions);
      interpreter.setMethodChecker(new BasicSymbolicInterpreter.MethodChecker() {
            public boolean isStaticMethodSafe(MethodSignature m)
               { return safeStaticMethods.contains(m); }
            public boolean isMethodSafe(MethodSignature m, TypedValue base, List<TypedValue> args)
               {
                  if (m.name.equals("<init>") && otherTransformClasses.contains(m.owner))
View Full Code Here
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
            else
               conditions.add(ifTrueValue.inverseValue());
         }
      }
      ConditionRecorder pathConditions = new ConditionRecorder();
      BasicSymbolicInterpreter interpreter = new SymbolicInterpreterWithFieldAccess(Opcodes.ASM5);
      FrameWithHelpers frame = new FrameWithHelpers(cl, m, interpreter);
      interpreter.setFrameForAliasingFixups(frame);
      interpreter.setBranchHandler(pathConditions);
      interpreter.setMethodChecker(methodChecker);
     
      for (PathInstruction instruction: path)
      {
         // Skip "fake" instructions like Frame, LineNumber, and Label
         if (instruction.node.getOpcode() < 0) continue;
View Full Code Here
TOP

Related Classes of ch.epfl.labos.iu.orm.queryll2.path.PathAnalysisSimplifier

  • ch.epfl.labos.iu.orm.query2.EntityManagerBackdoor
  • ch.epfl.labos.iu.orm.query2.ParameterLocation
  • ch.epfl.labos.iu.orm.query2.SQLFragment
  • ch.epfl.labos.iu.orm.query2.SQLFrom
  • ch.epfl.labos.iu.orm.query2.SQLQuery
  • ch.epfl.labos.iu.orm.query2.SQLReader
  • ch.epfl.labos.iu.orm.queryll2.CodePath
  • ch.epfl.labos.iu.orm.queryll2.DBSetSourceChecker
  • ch.epfl.labos.iu.orm.queryll2.ORMInformation
  • ch.epfl.labos.iu.orm.queryll2.path.CodePath
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.