Esempio n. 1
0
    private void processSimpleType(SimpleType simpleType, SGStateInfo sInfo) {

        if (simpleType == null) return;

        String packageName = sInfo.packageName;

        //-- Right now the only time we actually
        //-- generate source for a simpletype is
        //-- when it's an enumeration
        //if (! (simpleType instanceof BuiltInType) ) {
        if (simpleType.hasFacet(Facet.ENUMERATION)) {

            ClassInfo classInfo = sInfo.resolve(simpleType);

            if (classInfo == null) {

                JClass jClass
                    = sourceFactory.createSourceCode(simpleType, sInfo);

                processJClass(jClass, sInfo);
            }
            else {
                JClass jClass = classInfo.getJClass();
                if (!sInfo.processed(jClass)) {
                    processJClass(jClass, sInfo);
                }
            }
        }
    } //-- processSimpleType
Esempio n. 2
0
  /**
   * @param logging
   * @param origin origin source
   * @param ident unique identity for this cached source, used in filename
   * @param descr description of the source, used in logging
   * @param logging if true, log cache access
   * @return new source
   */
  public ResourceModelSource createCachingSource(
      ResourceModelSource origin,
      String ident,
      String descr,
      SourceFactory.CacheType type,
      final boolean logging) {
    final File file = getResourceModelSourceFileCacheForType(ident);
    final ResourceModelSourceService nodesSourceService = getResourceModelSourceService();
    final ResourceFormatGeneratorService resourceFormatGeneratorService =
        getResourceFormatGeneratorService();
    final Properties fileSourceConfig =
        generateFileSourceConfigurationProperties(
            file.getAbsolutePath(), ResourceXMLFormatGenerator.SERVICE_PROVIDER_TYPE, false, false);
    try {
      ResourceModelSource fileSource =
          nodesSourceService.getSourceForConfiguration("file", fileSourceConfig);

      ResourceFormatGenerator generatorForFormat =
          resourceFormatGeneratorService.getGeneratorForFormat(
              ResourceXMLFormatGenerator.SERVICE_PROVIDER_TYPE);

      String ident1 =
          "[ResourceModelSource: " + descr + ", project: " + projectConfig.getName() + "]";
      StoreExceptionHandler handler = new StoreExceptionHandler(ident);
      ResourceModelSourceCache cache =
          new FileResourceModelSourceCache(file, generatorForFormat, fileSource);
      if (logging) {
        cache = new LoggingResourceModelSourceCache(cache, ident1);
      }
      return SourceFactory.cachedSource(origin, ident1, handler, cache, type);
    } catch (UnsupportedFormatException | ExecutionServiceException e) {
      e.printStackTrace();
    }
    return null;
  }
Esempio n. 3
0
    private void createClasses(Group group, SGStateInfo sInfo) {

		if (sInfo.verbose()) {
		    System.out.print("Creating classes for group: ");
		    System.out.println(group.getName());
            if (group.getName() == null) {
                System.out.println("cannot create classes for unnamed nested groups");
                return;
            }
		}

		JClass[] classes = sourceFactory.createSourceCode(group, sInfo);
        processContentModel(group, sInfo);
        for (int i = 0; i < classes.length; i++)
            processJClass(classes[i], sInfo);

    } //-- createClasses
Esempio n. 4
0
    /**
     * Processes the given ComplexType and creates all necessary class
     * to support it
     * @param complexType the ComplexType to process
    **/
    private void processComplexType(ComplexType complexType, SGStateInfo sInfo) {

        if (complexType == null) return;

        ClassInfo classInfo = sInfo.resolve(complexType);

        if (classInfo == null) {

            //-- handle top-leve complextypes
            if (complexType.isTopLevel()) {

                JClass[] classes
                    = sourceFactory.createSourceCode(complexType, sInfo);

                for (int i = 0; i < classes.length; i++)
                    processJClass(classes[i], sInfo);
            }

            //-- process base complextype if necessary
            XMLType baseType= complexType.getBaseType();
            if (baseType != null &&
				baseType.getSchema() == complexType.getSchema()) {

				if (baseType.isComplexType())
                    processComplexType((ComplexType)baseType, sInfo);
            }

            //-- process AttributeDecl
            processAttributes(complexType, sInfo);

            //-- process ContentModel
            processContentModel(complexType, sInfo);

        }
        else {
            JClass jClass = classInfo.getJClass();
            if (!sInfo.processed(jClass)) {
                //-- process AttributeDecl
                processAttributes(complexType, sInfo);
                //-- process ContentModel
                processContentModel(complexType, sInfo);
                processJClass(jClass, sInfo);
            }
        }
    } //-- processComplexType
Esempio n. 5
0
    private void createClasses(ElementDecl elementDecl, SGStateInfo sInfo) {

		//-- when mapping schema types, only interested in producing classes
		//-- for elements with anonymous complex types
		if (SourceGenerator.mappingSchemaType2Java())
			if (elementDecl.isReference() ||
				(elementDecl.getType()!=null &&
				 elementDecl.getType().getName()!=null))
				return;

		if (sInfo.verbose()) {
		    System.out.print("Creating classes for element: ");
		    System.out.println(elementDecl.getName());
		}
        //-- create classes for sub-elements if necessary
        XMLType xmlType = elementDecl.getType();

        //-- No type definition
        if (xmlType == null) {
            System.out.print("Type not found for element: ");
            System.out.println(elementDecl.getName());
            return;
        }
        //-- ComplexType
        else if (xmlType.isComplexType()) {

			JClass[] classes = sourceFactory.createSourceCode(elementDecl,
                                                        sInfo);

            processComplexType((ComplexType)xmlType, sInfo);

            for (int i = 0; i < classes.length; i++)
                 processJClass(classes[i], sInfo);

        }
        //-- SimpleType
        else {
            processSimpleType((SimpleType)xmlType, sInfo);
        }

    }  //-- createClasses
 private Generator<Object[]> createXLSSourceGenerator(
     ArrayTypeDescriptor arrayType, BeneratorContext context, String sourceName) {
   logger.debug("createXLSSourceGenerator({})", arrayType);
   boolean rowBased = (arrayType.isRowBased() != null ? arrayType.isRowBased() : true);
   String emptyMarker = arrayType.getEmptyMarker();
   String nullMarker = arrayType.getNullMarker();
   boolean formatted = isFormatted(arrayType);
   DataSourceProvider<Object[]> factory =
       new XLSArraySourceProvider(
           formatted, new ScriptConverterForObjects(context), emptyMarker, nullMarker, rowBased);
   Generator<Object[]> generator =
       SourceFactory.createRawSourceGenerator(
           arrayType.getNesting(),
           arrayType.getDataset(),
           sourceName,
           factory,
           Object[].class,
           context);
   generator = WrapperFactory.applyConverter(generator, new ArrayElementTypeConverter(arrayType));
   return generator;
 }
 private Generator<Object[]> createCSVSourceGenerator(
     ArrayTypeDescriptor arrayType, BeneratorContext context, String sourceName) {
   logger.debug("createCSVSourceGenerator({})", arrayType);
   String encoding = arrayType.getEncoding();
   if (encoding == null) encoding = context.getDefaultEncoding();
   char separator = DescriptorUtil.getSeparator(arrayType, context);
   boolean rowBased = (arrayType.isRowBased() != null ? arrayType.isRowBased() : true);
   DataSourceProvider<Object[]> factory =
       new CSVArraySourceProvider(
           arrayType.getName(),
           new ScriptConverterForStrings(context),
           rowBased,
           separator,
           encoding);
   Generator<Object[]> generator =
       SourceFactory.createRawSourceGenerator(
           arrayType.getNesting(),
           arrayType.getDataset(),
           sourceName,
           factory,
           Object[].class,
           context);
   return WrapperFactory.applyConverter(generator, new ArrayElementTypeConverter(arrayType));
 }
Esempio n. 8
0
   /**
     * Sets whether or not to create the XML marshalling framework specific
     * methods (marshall, unmarshall, validate) in the generated classes.
	 * By default, these methods are generated.
	 *
     * @param createMarshall a boolean, when true indicates
     * to generated the marshalling framework methods
     *
     */
    public void setTestable(boolean testable) {
        if (sourceFactory != null)
		   sourceFactory.setTestable(testable);
    } //-- setTestable
Esempio n. 9
0
    /**
     * Sets whether or not to create the XML marshalling framework specific
     * methods (marshall, unmarshall, validate) in the generated classes.
	 * By default, these methods are generated.
	 *
     * @param createMarshalMethods a boolean, when true indicates
     * to generated the marshalling framework methods
     *
     */
    public void setCreateMarshalMethods(boolean createMarshalMethods) {
        if (sourceFactory != null)
		   sourceFactory.setCreateMarshalMethods(createMarshalMethods);
    } //-- setCreateMarshalMethods