private FieldDeclaration createDeleteFlagValueField(
     EmitContext context, ModelDeclaration model, AstLiteral deleteFlagValue) {
   assert context != null;
   assert model != null;
   assert deleteFlagValue != null;
   ModelFactory f = context.getModelFactory();
   Type type;
   Expression value;
   switch (deleteFlagValue.kind) {
     case BOOLEAN:
       type = context.resolve(boolean.class);
       value = Models.toLiteral(f, deleteFlagValue.toBooleanValue());
       break;
     case INTEGER:
       type = context.resolve(int.class);
       value = Models.toLiteral(f, deleteFlagValue.toIntegerValue().intValue());
       break;
     case STRING:
       type = context.resolve(Text.class);
       value =
           new TypeBuilder(f, context.resolve(Text.class))
               .newObject(Models.toLiteral(f, deleteFlagValue.toStringValue()))
               .toExpression();
       break;
     default:
       throw new AssertionError(deleteFlagValue);
   }
   return f.newFieldDeclaration(
       null,
       new AttributeBuilder(f).Private().Static().Final().toAttributes(),
       type,
       f.newSimpleName(FIELD_DELETE_FLAG_VALUE),
       value);
 }
예제 #2
0
 @Override
 public List<Annotation> getTypeAnnotations(EmitContext context, ModelDeclaration model)
     throws IOException {
   Type type = generate(context, model);
   ModelFactory f = context.getModelFactory();
   return new AttributeBuilder(f)
       .annotation(
           context.resolve(ModelInputLocation.class), f.newClassLiteral(context.resolve(type)))
       .toAnnotations();
 }
예제 #3
0
 private MethodDeclaration createGetModelType() {
   return createGetter(
       new TypeBuilder(f, context.resolve(Class.class))
           .parameterize(
               f.newWildcard(
                   WildcardBoundKind.UPPER_BOUNDED, context.resolve(model.getSymbol())))
           .toType(),
       "getModelType",
       f.newClassLiteral(context.resolve(model.getSymbol())));
 }
예제 #4
0
 private Type generate(EmitContext context, ModelDeclaration model) throws IOException {
   EmitContext next =
       new EmitContext(
           context.getSemantics(),
           context.getConfiguration(),
           model,
           NameConstants.CATEGORY_IO,
           "{0}Input");
   Generator.emit(next, model);
   return context.resolve(next.getQualifiedTypeName());
 }
예제 #5
0
 private DescriptionGenerator(
     EmitContext context, ModelDeclaration model, Name supportClassName, boolean importer) {
   assert context != null;
   assert model != null;
   assert supportClassName != null;
   this.context = context;
   this.model = model;
   this.f = context.getModelFactory();
   this.importer = importer;
   this.supportClass = context.resolve(supportClassName);
 }
예제 #6
0
 private TypeBodyDeclaration createCloser() {
   return f.newMethodDeclaration(
       null,
       new AttributeBuilder(f)
           .annotation(context.resolve(Override.class))
           .Public()
           .toAttributes(),
       Collections.<TypeParameterDeclaration>emptyList(),
       context.resolve(void.class),
       f.newSimpleName("close"),
       Collections.<FormalParameterDeclaration>emptyList(),
       0,
       Collections.singletonList(context.resolve(IOException.class)),
       f.newBlock(createCloserBody()));
 }
 @Override
 public List<Type> getInterfaces(EmitContext context, ModelDeclaration model) throws IOException {
   if (isTarget(model) == false) {
     return Collections.emptyList();
   }
   return Arrays.asList(context.resolve(ThunderGateCacheSupport.class));
 }
예제 #8
0
 private Generator(EmitContext context, ModelDeclaration model) {
   assert context != null;
   assert model != null;
   this.context = context;
   this.model = model;
   this.f = context.getModelFactory();
 }
예제 #9
0
 private TypeBodyDeclaration createConstructor() {
   return f.newConstructorDeclaration(
       new JavadocBuilder(f)
           .text("インスタンスを生成する。")
           .param(createParserFieldName())
           .text("利用するパーサー")
           .exception(context.resolve(IllegalArgumentException.class))
           .text("引数に<code>null</code>が指定された場合")
           .toJavadoc(),
       new AttributeBuilder(f).Public().toAttributes(),
       context.getTypeName(),
       Collections.singletonList(
           f.newFormalParameterDeclaration(
               context.resolve(RecordParser.class), createParserFieldName())),
       createConstructorBody());
 }
예제 #10
0
 private void emit() throws IOException {
   ClassDeclaration decl =
       f.newClassDeclaration(
           new JavadocBuilder(f)
               .text("An abstract implementation of ")
               .linkType(context.resolve(model.getSymbol()))
               .text(" {0} description using WindGate CSV", importer ? "importer" : "exporter")
               .text(".")
               .toJavadoc(),
           new AttributeBuilder(f).Public().Abstract().toAttributes(),
           context.getTypeName(),
           context.resolve(Models.toName(f, importer ? IMPORTER_TYPE_NAME : EXPORTER_TYPE_NAME)),
           Collections.<com.asakusafw.utils.java.model.syntax.Type>emptyList(),
           createMembers());
   context.emit(decl);
 }
예제 #11
0
 private void emit() throws IOException {
   ClassDeclaration decl =
       f.newClassDeclaration(
           new JavadocBuilder(f)
               .text("TSVファイルなどのレコードを表すファイルを入力として<code>{0}</code>を読み出す", model.getName())
               .toJavadoc(),
           new AttributeBuilder(f).Public().Final().toAttributes(),
           context.getTypeName(),
           Collections.<TypeParameterDeclaration>emptyList(),
           null,
           Collections.singletonList(
               f.newParameterizedType(
                   context.resolve(ModelInput.class), context.resolve(model.getSymbol()))),
           createMembers());
   context.emit(decl);
 }
예제 #12
0
 private TypeBodyDeclaration createParserField() {
   return f.newFieldDeclaration(
       null,
       new AttributeBuilder(f).Private().Final().toAttributes(),
       context.resolve(RecordParser.class),
       createParserFieldName(),
       null);
 }
예제 #13
0
 private FieldDeclaration createPrivateField(Class<?> type, SimpleName name) {
   return f.newFieldDeclaration(
       null,
       new AttributeBuilder(f).Private().Final().toAttributes(),
       context.resolve(type),
       name,
       null);
 }
예제 #14
0
 private MethodDeclaration createReader() {
   return f.newMethodDeclaration(
       null,
       new AttributeBuilder(f)
           .annotation(context.resolve(Override.class))
           .Public()
           .toAttributes(),
       Collections.<TypeParameterDeclaration>emptyList(),
       context.resolve(boolean.class),
       f.newSimpleName("readTo"),
       Collections.singletonList(
           f.newFormalParameterDeclaration(
               context.resolve(model.getSymbol()), createModelParameterName())),
       0,
       Collections.singletonList(context.resolve(IOException.class)),
       f.newBlock(createReaderBody()));
 }
 private MethodDeclaration createTimestampColumnMethod(
     EmitContext context, ModelDeclaration model, PropertySymbol timestamp) {
   assert context != null;
   assert model != null;
   assert timestamp != null;
   ModelFactory f = context.getModelFactory();
   String name = OriginalNameEmitter.getOriginalName(timestamp.findDeclaration());
   List<Statement> statements = Lists.create();
   statements.add(new ExpressionBuilder(f, Models.toLiteral(f, name)).toReturnStatement());
   return f.newMethodDeclaration(
       null,
       new AttributeBuilder(f).annotation(context.resolve(Override.class)).Public().toAttributes(),
       context.resolve(String.class),
       f.newSimpleName("__tgc__TimestampColumn"),
       Collections.<FormalParameterDeclaration>emptyList(),
       statements);
 }
 private MethodDeclaration createModelVersionMethod(
     EmitContext context, ModelDeclaration model, CacheSupportTrait trait) {
   assert context != null;
   assert model != null;
   assert trait != null;
   ModelFactory f = context.getModelFactory();
   List<Statement> statements = Lists.create();
   statements.add(
       new ExpressionBuilder(f, Models.toLiteral(f, computeModelVersion(context, model, trait)))
           .toReturnStatement());
   return f.newMethodDeclaration(
       null,
       new AttributeBuilder(f).annotation(context.resolve(Override.class)).Public().toAttributes(),
       context.resolve(long.class),
       f.newSimpleName("__tgc__DataModelVersion"),
       Collections.<FormalParameterDeclaration>emptyList(),
       statements);
 }
예제 #17
0
 private MethodDeclaration createGetConfiguration() {
   List<Statement> statements = Lists.create();
   List<Expression> arguments = Lists.create();
   arguments.add(
       new TypeBuilder(f, context.resolve(Charset.class))
           .method("forName", Models.toLiteral(f, conf.getCharsetName()))
           .toExpression());
   if (conf.isEnableHeader()) {
     SimpleName headers = f.newSimpleName("headers");
     statements.add(
         new TypeBuilder(f, context.resolve(ArrayList.class))
             .parameterize(context.resolve(String.class))
             .newObject()
             .toLocalVariableDeclaration(
                 new TypeBuilder(f, context.resolve(List.class))
                     .parameterize(context.resolve(String.class))
                     .toType(),
                 headers));
     for (PropertyDeclaration property : model.getDeclaredProperties()) {
       if (isValueField(property)) {
         String fieldName = CsvFieldTrait.getFieldName(property);
         statements.add(
             new ExpressionBuilder(f, headers)
                 .method("add", Models.toLiteral(f, fieldName))
                 .toStatement());
       }
     }
     arguments.add(headers);
   } else {
     arguments.add(
         new TypeBuilder(f, context.resolve(CsvConfiguration.class))
             .field("DEFAULT_HEADER_CELLS")
             .toExpression());
   }
   arguments.add(Models.toLiteral(f, conf.getTrueFormat()));
   arguments.add(Models.toLiteral(f, conf.getFalseFormat()));
   arguments.add(Models.toLiteral(f, conf.getDateFormat()));
   arguments.add(Models.toLiteral(f, conf.getDateTimeFormat()));
   statements.add(
       new TypeBuilder(f, context.resolve(CsvConfiguration.class))
           .newObject(arguments)
           .toReturnStatement());
   return f.newMethodDeclaration(
       new JavadocBuilder(f)
           .text("Returns this CSV format configuration.")
           .returns()
           .text("CSV format configuration")
           .toJavadoc(),
       new AttributeBuilder(f).Protected().toAttributes(),
       context.resolve(CsvConfiguration.class),
       f.newSimpleName(METHOD_CONFIG),
       Collections.<FormalParameterDeclaration>emptyList(),
       statements);
 }
예제 #18
0
 private SupportGenerator(
     EmitContext context, ModelDeclaration model, Configuration configuration) {
   assert context != null;
   assert model != null;
   assert configuration != null;
   this.context = context;
   this.model = model;
   this.conf = configuration;
   this.f = context.getModelFactory();
 }
 private MethodDeclaration createSystemIdMethod(
     EmitContext context, ModelDeclaration model, PropertySymbol sid) {
   assert context != null;
   assert model != null;
   assert sid != null;
   ModelFactory f = context.getModelFactory();
   List<Statement> statements = Lists.create();
   statements.add(
       new ExpressionBuilder(f, f.newThis())
           .method(context.getValueGetterName(sid.findDeclaration()))
           .toReturnStatement());
   return f.newMethodDeclaration(
       null,
       new AttributeBuilder(f).annotation(context.resolve(Override.class)).Public().toAttributes(),
       context.resolve(long.class),
       f.newSimpleName("__tgc__SystemId"),
       Collections.<FormalParameterDeclaration>emptyList(),
       statements);
 }
예제 #20
0
 private void emit() throws IOException {
   ClassDeclaration decl =
       f.newClassDeclaration(
           new JavadocBuilder(f)
               .text("Supports CSV for ")
               .linkType(context.resolve(model.getSymbol()))
               .text(".")
               .toJavadoc(),
           new AttributeBuilder(f).Public().toAttributes(),
           context.getTypeName(),
           Collections.<TypeParameterDeclaration>emptyList(),
           null,
           Collections.singletonList(
               f.newParameterizedType(
                   context.resolve(DataModelStreamSupport.class),
                   context.resolve(model.getSymbol()))),
           createMembers());
   context.emit(decl);
 }
예제 #21
0
 private MethodDeclaration createGetSupportedType() {
   MethodDeclaration decl =
       f.newMethodDeclaration(
           null,
           new AttributeBuilder(f)
               .annotation(context.resolve(Override.class))
               .Public()
               .toAttributes(),
           f.newParameterizedType(
               context.resolve(Class.class), context.resolve(model.getSymbol())),
           f.newSimpleName("getSupportedType"),
           Collections.<FormalParameterDeclaration>emptyList(),
           Arrays.asList(
               new Statement[] {
                 new TypeBuilder(f, context.resolve(model.getSymbol()))
                     .dotClass()
                     .toReturnStatement()
               }));
   return decl;
 }
예제 #22
0
 private Statement createReaderStatement(PropertyDeclaration property) {
   assert property != null;
   SimpleName optionGetterName = context.getOptionGetterName(property);
   Expression option =
       new ExpressionBuilder(f, createModelParameterName())
           .method(optionGetterName)
           .toExpression();
   Statement fill =
       new ExpressionBuilder(f, createParserFieldName()).method("fill", option).toStatement();
   return fill;
 }
예제 #23
0
 private Statement createNullCheck(SimpleName parameter) {
   assert parameter != null;
   return f.newIfStatement(
       new ExpressionBuilder(f, parameter)
           .apply(InfixOperator.EQUALS, Models.toNullLiteral(f))
           .toExpression(),
       f.newBlock(
           new TypeBuilder(f, context.resolve(IllegalArgumentException.class))
               .newObject(
                   Models.toLiteral(
                       f, MessageFormat.format("{0} must not be null", parameter.getToken())))
               .toThrowStatement()));
 }
 private MethodDeclaration createDeletedMethod(
     EmitContext context, ModelDeclaration model, PropertySymbol deleteFlagOrNull) {
   assert context != null;
   assert model != null;
   ModelFactory f = context.getModelFactory();
   List<Statement> statements = Lists.create();
   if (deleteFlagOrNull == null) {
     statements.add(new ExpressionBuilder(f, Models.toLiteral(f, false)).toReturnStatement());
   } else {
     statements.add(
         new ExpressionBuilder(f, f.newThis())
             .method(context.getOptionGetterName(deleteFlagOrNull.findDeclaration()))
             .method("has", f.newSimpleName(FIELD_DELETE_FLAG_VALUE))
             .toReturnStatement());
   }
   return f.newMethodDeclaration(
       null,
       new AttributeBuilder(f).annotation(context.resolve(Override.class)).Public().toAttributes(),
       context.resolve(boolean.class),
       f.newSimpleName("__tgc__Deleted"),
       Collections.<FormalParameterDeclaration>emptyList(),
       statements);
 }
예제 #25
0
    private MethodDeclaration createCreateWriter() {
      SimpleName path = f.newSimpleName("path");
      SimpleName stream = f.newSimpleName("stream");
      List<Statement> statements = Lists.create();
      statements.add(createNullCheck(path));
      statements.add(createNullCheck(stream));

      SimpleName emitter = f.newSimpleName("emitter");
      statements.add(
          new TypeBuilder(f, context.resolve(CsvEmitter.class))
              .newObject(
                  stream,
                  path,
                  new ExpressionBuilder(f, f.newThis()).method(METHOD_CONFIG).toExpression())
              .toLocalVariableDeclaration(context.resolve(CsvEmitter.class), emitter));

      statements.add(
          new TypeBuilder(f, f.newNamedType(f.newSimpleName(NAME_WRITER)))
              .newObject(emitter)
              .toReturnStatement());

      MethodDeclaration decl =
          f.newMethodDeclaration(
              null,
              new AttributeBuilder(f)
                  .annotation(context.resolve(Override.class))
                  .Public()
                  .toAttributes(),
              Collections.<TypeParameterDeclaration>emptyList(),
              context.resolve(
                  f.newParameterizedType(
                      context.resolve(DataModelWriter.class), context.resolve(model.getSymbol()))),
              f.newSimpleName("createWriter"),
              Arrays.asList(
                  f.newFormalParameterDeclaration(context.resolve(String.class), path),
                  f.newFormalParameterDeclaration(context.resolve(OutputStream.class), stream)),
              0,
              Arrays.asList(context.resolve(IOException.class)),
              f.newBlock(statements));
      return decl;
    }
예제 #26
0
 private MethodDeclaration createGetter(
     com.asakusafw.utils.java.model.syntax.Type type, String name, Expression value) {
   assert type != null;
   assert name != null;
   assert value != null;
   return f.newMethodDeclaration(
       null,
       new AttributeBuilder(f)
           .annotation(context.resolve(Override.class))
           .Public()
           .toAttributes(),
       type,
       f.newSimpleName(name),
       Collections.<FormalParameterDeclaration>emptyList(),
       Arrays.asList(new ExpressionBuilder(f, value).toReturnStatement()));
 }
예제 #27
0
 private List<Statement> createConstructorBody() {
   List<Statement> results = new ArrayList<Statement>();
   results.add(
       f.newIfStatement(
           new ExpressionBuilder(f, createParserFieldName())
               .apply(InfixOperator.EQUALS, Models.toNullLiteral(f))
               .toExpression(),
           f.newBlock(
               new TypeBuilder(f, context.resolve(IllegalArgumentException.class))
                   .newObject(Models.toLiteral(f, createParserFieldName().getToken()))
                   .toThrowStatement())));
   results.add(
       new ExpressionBuilder(f, f.newThis(null))
           .field(createParserFieldName())
           .assignFrom(createParserFieldName())
           .toStatement());
   return results;
 }
 private long computeModelVersion(
     EmitContext context, ModelDeclaration model, CacheSupportTrait trait) {
   assert context != null;
   assert model != null;
   assert trait != null;
   long hash = 1;
   final long prime = 31;
   hash = hash * prime + context.getQualifiedTypeName().toNameString().hashCode();
   hash = hash * prime + trait.getSid().getName().identifier.hashCode();
   hash = hash * prime + trait.getTimestamp().getName().identifier.hashCode();
   for (PropertyDeclaration property : model.getDeclaredProperties()) {
     hash = hash * prime + property.getName().identifier.hashCode();
     com.asakusafw.dmdl.semantics.Type type = property.getType();
     assert type instanceof BasicType;
     hash = hash * prime + ((BasicType) type).getKind().name().hashCode();
   }
   return hash;
 }
예제 #29
0
 private Name generateSupport(EmitContext context, ModelDeclaration model) throws IOException {
   assert context != null;
   assert model != null;
   EmitContext next =
       new EmitContext(
           context.getSemantics(),
           context.getConfiguration(),
           model,
           CATEGORY_STREAM,
           "{0}CsvSupport");
   LOG.debug("Generating CSV support for {}", context.getQualifiedTypeName().toNameString());
   SupportGenerator.emit(next, model, model.getTrait(CsvSupportTrait.class).getConfiguration());
   LOG.debug(
       "Generated CSV support for {}: {}",
       context.getQualifiedTypeName().toNameString(),
       next.getQualifiedTypeName().toNameString());
   return next.getQualifiedTypeName();
 }
예제 #30
0
 private Name generateExporter(EmitContext context, ModelDeclaration model, Name supportName)
     throws IOException {
   assert context != null;
   assert model != null;
   assert supportName != null;
   EmitContext next =
       new EmitContext(
           context.getSemantics(),
           context.getConfiguration(),
           model,
           CATEGORY_STREAM,
           "Abstract{0}CsvExporterDescription");
   LOG.debug(
       "Generating CSV exporter description for {}",
       context.getQualifiedTypeName().toNameString());
   DescriptionGenerator.emitExporter(next, model, supportName);
   LOG.debug(
       "Generated CSV exporter description for {}: {}",
       context.getQualifiedTypeName().toNameString(),
       next.getQualifiedTypeName().toNameString());
   return next.getQualifiedTypeName();
 }