Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  // Copyright 2008 Google Inc.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  // http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package com.google.gwtorm.server;
 
 
 
 import java.util.List;

Generates a concrete implementation of a Schema extension.
 
 public class SchemaGen<S extends AbstractSchemaimplements Opcodes {
   public interface AccessGenerator {
     Class<?> create(GeneratedClassLoader loaderRelationModel rm)
         throws OrmException;
   }
 
   private final GeneratedClassLoader classLoader;
   private final SchemaModel schema;
   private final Class<?> databaseClass;
   private final Class<S> schemaSuperClass;
   private final AccessGenerator accessGen;
   private List<RelationGenrelations;
   private ClassWriter cw;
   private String implClassName;
   private String implTypeName;
 
   public SchemaGen(final GeneratedClassLoader loader,
       final SchemaModel schemaModelfinal Class<?> databaseType,
       final Class<S> superTypefinal AccessGenerator ag) {
      = loader;
      = schemaModel;
      = databaseType;
      = superType;
      = ag;
   }
 
   public Class<Schemacreate() throws OrmException {
 
     init();
 
     .visitEnd();
     return loadClass();
   }
 
   @SuppressWarnings("unchecked")
   private Class<SchemaloadClass() throws OrmException {
     try {
       final Class<?> c = Class.forName(getImplClassName(), false);
       return (Class<Schema>) c;
     } catch (ClassNotFoundException err) {
       throw new OrmException("Cannot load generated class"err);
     }
   }
 
     return .getSchemaClassName();
   }
 
     return ;
   }
 
     return ;
   }
 
   private void defineRelationClasses() throws OrmException {
      = new ArrayList<RelationGen>();
     for (final RelationModel rel : .getRelations()) {
       final Class<?> a = .create(rel);
      .add(new RelationGen(rela));
    }
    Collections.sort(new Comparator<RelationGen>() {
      @Override
      public int compare(RelationGen aRelationGen b) {
        int cmp = a.model.getRelationID() - b.model.getRelationID();
        if (cmp == 0) {
          cmp = a.model.getRelationName().compareTo(b.model.getRelationName());
        }
        return cmp;
      }
    });
  }
  private void init() {
     = getSchemaClassName() + "_Schema_" + Util.createRandomName();
     = .replace('.''/');
    .visit( |  | null, Type
        .replace('.''/')});
  }
  private void implementRelationFields() {
    for (final RelationGen info : ) {
      info.implementField();
    }
  }
  private void implementConstructor() {
    final String consName = "<init>";
    final Type superType = Type.getType();
    final Type dbType = Type.getType();
    final MethodVisitor mv =
        .visitMethod(consName, Type.getMethodDescriptor(
            .new Type[] {dbType}), nullnull);
    mv.visitCode();
    mv.visitVarInsn(, 0);
    mv.visitVarInsn(, 1);
    mv.visitMethodInsn(superType.getInternalName(), consName,
        Type.getMethodDescriptor(.new Type[] {Type
                .getParameterTypes()[0])}));
    for (final RelationGen info : ) {
      mv.visitVarInsn(, 0);
      mv.visitTypeInsn(info.accessType.getInternalName());
      mv.visitInsn();
      mv.visitVarInsn(, 0);
      mv.visitMethodInsn(info.accessType.getInternalName(),
          consName, Type.getMethodDescriptor(.,
              new Type[] {superType}));
      mv.visitFieldInsn(info
          .getAccessInstanceFieldName(), info.accessType.getDescriptor());
    }
    mv.visitInsn();
    mv.visitMaxs(-1, -1);
    mv.visitEnd();
  }
  private void implementSequenceMethods() {
    for (final SequenceModel seq : .getSequences()) {
      final Type retType = Type.getType(seq.getResultType());
      final MethodVisitor mv =
          
              .visitMethod(seq.getMethodName(), Type
                  .getMethodDescriptor(retTypenew Type[] {}), null,
                  new String[] {Type.getType(OrmException.class)
                      .getInternalName()});
      mv.visitCode();
      mv.visitVarInsn(, 0);
      mv.visitLdcInsn(seq.getSequenceName());
          "nextLong", Type.getMethodDescriptor(Type.getType(.),
              new Type[] {Type.getType(String.class)}));
      if (retType.getSize() == 1) {
        mv.visitInsn();
        mv.visitInsn();
      } else {
        mv.visitInsn();
      }
      mv.visitMaxs(-1, -1);
      mv.visitEnd();
    }
  }
  private void implementRelationMethods() {
    for (final RelationGen info : ) {
      info.implementMethod();
    }
  }
  private void implementAllRelationsMethod() {
    final MethodVisitor mv =
        .visitMethod( | "allRelations", Type
            .getMethodDescriptor(Type.getType(Access[].class), new Type[] {}),
            nullnull);
    mv.visitCode();
    final int r = 1;
    CodeGenSupport cgs = new CodeGenSupport(mv);
    cgs.push(.size());
    mv.visitVarInsn(r);
    int index = 0;
    for (RelationGen info : ) {
      mv.visitVarInsn(r);
      cgs.push(index++);
      mv.visitVarInsn(, 0);
      mv.visitMethodInsn(getImplTypeName(), info.model
          .getMethodName(), info.getDescriptor());
      mv.visitInsn();
    }
    mv.visitVarInsn(r);
    mv.visitInsn();
    mv.visitMaxs(-1, -1);
    mv.visitEnd();
  }
  private class RelationGen {
    final RelationModel model;
    final Type accessType;
    RelationGen(final RelationModel modelfinal Class<?> accessClass) {
      this. = model;
      this. = Type.getType(accessClass);
    }
    void implementField() {
          .getDescriptor(), nullnull).visitEnd();
    }
      return "access_" + .getMethodName();
    }
    void implementMethod() {
      final MethodVisitor mv =
              getDescriptor(), nullnull);
      mv.visitCode();
      mv.visitVarInsn(, 0);
          .getDescriptor());
      mv.visitInsn();
      mv.visitMaxs(-1, -1);
      mv.visitEnd();
    }
    String getDescriptor() {
      return Type.getMethodDescriptor(Type.getObjectType(
          .getAccessInterfaceName().replace('.''/')), new Type[] {});
    }
  }
New to GrepCode? Check out our FAQ X