1 /*
   2  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.internal.xjc.reader.xmlschema.bindinfo;
  27 
  28 import javax.xml.bind.DatatypeConverter;
  29 import javax.xml.bind.annotation.XmlAttribute;
  30 import javax.xml.bind.annotation.XmlRootElement;
  31 import javax.xml.bind.annotation.adapters.XmlAdapter;
  32 import javax.xml.namespace.QName;
  33 
  34 import com.sun.codemodel.internal.JClass;
  35 import com.sun.codemodel.internal.JClassAlreadyExistsException;
  36 import com.sun.codemodel.internal.JCodeModel;
  37 import com.sun.codemodel.internal.JDefinedClass;
  38 import com.sun.codemodel.internal.JExpr;
  39 import com.sun.codemodel.internal.JExpression;
  40 import com.sun.codemodel.internal.JMethod;
  41 import com.sun.codemodel.internal.JMod;
  42 import com.sun.codemodel.internal.JPackage;
  43 import com.sun.codemodel.internal.JType;
  44 import com.sun.codemodel.internal.JVar;
  45 import com.sun.codemodel.internal.JConditional;
  46 import com.sun.tools.internal.xjc.ErrorReceiver;
  47 import com.sun.tools.internal.xjc.model.CAdapter;
  48 import com.sun.tools.internal.xjc.model.CBuiltinLeafInfo;
  49 import com.sun.tools.internal.xjc.model.TypeUse;
  50 import com.sun.tools.internal.xjc.model.TypeUseFactory;
  51 import com.sun.tools.internal.xjc.reader.Const;
  52 import com.sun.tools.internal.xjc.reader.Ring;
  53 import com.sun.tools.internal.xjc.reader.TypeUtil;
  54 import com.sun.tools.internal.xjc.reader.xmlschema.ClassSelector;
  55 import com.sun.xml.internal.bind.v2.WellKnownNamespace;
  56 import com.sun.xml.internal.xsom.XSSimpleType;
  57 
  58 import org.xml.sax.Locator;
  59 
  60 /**
  61  * Conversion declaration.
  62  *
  63  * <p>
  64  * A conversion declaration specifies how an XML type gets mapped
  65  * to a Java type.
  66  *
  67  * @author
  68  *     Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com)
  69  */
  70 public abstract class BIConversion extends AbstractDeclarationImpl {
  71     @Deprecated
  72     public BIConversion( Locator loc ) {
  73         super(loc);
  74     }
  75 
  76     protected BIConversion() {
  77     }
  78 
  79     /**
  80      * Gets the {@link TypeUse} object that this conversion represents.
  81      * <p>
  82      * The returned {@link TypeUse} object is properly adapted.
  83      *
  84      * @param owner
  85      *      A {@link BIConversion} is always associated with one
  86      *      {@link XSSimpleType}, but that's not always available
  87      *      when a {@link BIConversion} is built. So we pass this
  88      *      as a parameter to this method.
  89      */
  90     public abstract TypeUse getTypeUse( XSSimpleType owner );
  91 
  92     public QName getName() { return NAME; }
  93 
  94     /** Name of the conversion declaration. */
  95     public static final QName NAME = new QName(
  96         Const.JAXB_NSURI, "conversion" );
  97 
  98     /**
  99      * Implementation that returns a statically-determined constant {@link TypeUse}.
 100      */
 101     public static final class Static extends BIConversion {
 102         /**
 103          * Always non-null.
 104          */
 105         private final TypeUse transducer;
 106 
 107         public Static(Locator loc, TypeUse transducer) {
 108             super(loc);
 109             this.transducer = transducer;
 110         }
 111 
 112         public TypeUse getTypeUse(XSSimpleType owner) {
 113             return transducer;
 114         }
 115     }
 116 
 117     /**
 118      * User-specified &lt;javaType> customization.
 119      *
 120      * The parse/print methods are allowed to be null,
 121      * and their default values are determined based on the
 122      * owner of the token.
 123      */
 124     @XmlRootElement(name="javaType")
 125     public static class User extends BIConversion {
 126         @XmlAttribute
 127         private String parseMethod;
 128         @XmlAttribute
 129         private String printMethod;
 130         @XmlAttribute(name="name")
 131         private String type = "java.lang.String";
 132 
 133         /**
 134          * If null, computed from {@link #type}.
 135          * Sometimes this can be set instead of {@link #type}.
 136          */
 137         private JType inMemoryType;
 138 
 139         public User(Locator loc, String parseMethod, String printMethod, JType inMemoryType) {
 140             super(loc);
 141             this.parseMethod = parseMethod;
 142             this.printMethod = printMethod;
 143             this.inMemoryType = inMemoryType;
 144         }
 145 
 146         public User() {
 147         }
 148 
 149         /**
 150          * Cache used by {@link #getTypeUse(XSSimpleType)} to improve the performance.
 151          */
 152         private TypeUse typeUse;
 153 
 154         public TypeUse getTypeUse(XSSimpleType owner) {
 155             if(typeUse!=null)
 156                 return typeUse;
 157 
 158             JCodeModel cm = getCodeModel();
 159 
 160             if(inMemoryType==null)
 161                 inMemoryType = TypeUtil.getType(cm,type,Ring.get(ErrorReceiver.class),getLocation());
 162 
 163             JDefinedClass adapter = generateAdapter(parseMethodFor(owner),printMethodFor(owner),owner);
 164 
 165             // XmlJavaType customization always converts between string and an user-defined type.
 166             typeUse = TypeUseFactory.adapt(CBuiltinLeafInfo.STRING,new CAdapter(adapter));
 167 
 168             return typeUse;
 169         }
 170 
 171         /**
 172          * generate the adapter class.
 173          */
 174         private JDefinedClass generateAdapter(String parseMethod, String printMethod,XSSimpleType owner) {
 175             JDefinedClass adapter = null;
 176 
 177             int id = 1;
 178             while(adapter==null) {
 179                 try {
 180                     JPackage pkg = Ring.get(ClassSelector.class).getClassScope().getOwnerPackage();
 181                     adapter = pkg._class("Adapter"+id);
 182                 } catch (JClassAlreadyExistsException e) {
 183                     // try another name in search for an unique name.
 184                     // this isn't too efficient, but we expect people to usually use
 185                     // a very small number of adapters.
 186                     id++;
 187                 }
 188             }
 189 
 190             JClass bim = inMemoryType.boxify();
 191 
 192             adapter._extends(getCodeModel().ref(XmlAdapter.class).narrow(String.class).narrow(bim));
 193 
 194             JMethod unmarshal = adapter.method(JMod.PUBLIC, bim, "unmarshal");
 195             JVar $value = unmarshal.param(String.class, "value");
 196 
 197             JExpression inv;
 198 
 199             if( parseMethod.equals("new") ) {
 200                 // "new" indicates that the constructor of the target type
 201                 // will do the unmarshalling.
 202 
 203                 // RESULT: new <type>()
 204                 inv = JExpr._new(bim).arg($value);
 205             } else {
 206                 int idx = parseMethod.lastIndexOf('.');
 207                 if(idx<0) {
 208                     // parseMethod specifies the static method of the target type
 209                     // which will do the unmarshalling.
 210 
 211                     // because of an error check at the constructor,
 212                     // we can safely assume that this cast works.
 213                     inv = bim.staticInvoke(parseMethod).arg($value);
 214                 } else {
 215                     inv = JExpr.direct(parseMethod+"(value)");
 216                 }
 217             }
 218             unmarshal.body()._return(inv);
 219 
 220 
 221             JMethod marshal = adapter.method(JMod.PUBLIC, String.class, "marshal");
 222             $value = marshal.param(bim,"value");
 223 
 224             if(printMethod.startsWith("javax.xml.bind.DatatypeConverter.")) {
 225                 // UGLY: if this conversion is the system-driven conversion,
 226                 // check for null
 227                 marshal.body()._if($value.eq(JExpr._null()))._then()._return(JExpr._null());
 228             }
 229 
 230             int idx = printMethod.lastIndexOf('.');
 231             if(idx<0) {
 232                 // printMethod specifies a method in the target type
 233                 // which performs the serialization.
 234 
 235                 // RESULT: <value>.<method>()
 236                 inv = $value.invoke(printMethod);
 237 
 238                 // check value is not null ... if(value == null) return null;
 239                 JConditional jcon = marshal.body()._if($value.eq(JExpr._null()));
 240                 jcon._then()._return(JExpr._null());
 241             } else {
 242                 // RESULT: <className>.<method>(<value>)
 243                 if(this.printMethod==null) {
 244                     // HACK HACK HACK
 245                     JType t = inMemoryType.unboxify();
 246                     inv = JExpr.direct(printMethod+"(("+findBaseConversion(owner).toLowerCase()+")("+t.fullName()+")value)");
 247                 } else
 248                     inv = JExpr.direct(printMethod+"(value)");
 249             }
 250             marshal.body()._return(inv);
 251 
 252             return adapter;
 253         }
 254 
 255         private String printMethodFor(XSSimpleType owner) {
 256             if(printMethod!=null)   return printMethod;
 257 
 258             if(inMemoryType.unboxify().isPrimitive()) {
 259                 String method = getConversionMethod("print",owner);
 260                 if(method!=null)
 261                     return method;
 262             }
 263 
 264             return "toString";
 265         }
 266 
 267         private String parseMethodFor(XSSimpleType owner) {
 268             if(parseMethod!=null)   return parseMethod;
 269 
 270             if(inMemoryType.unboxify().isPrimitive()) {
 271                 String method = getConversionMethod("parse", owner);
 272                 if(method!=null) {
 273                     // this cast is necessary for conversion between primitive Java types
 274                     return '('+inMemoryType.unboxify().fullName()+')'+method;
 275                 }
 276             }
 277 
 278             return "new";
 279         }
 280 
 281         private static final String[] knownBases = new String[]{
 282             "Float", "Double", "Byte", "Short", "Int", "Long", "Boolean"
 283         };
 284 
 285         private String getConversionMethod(String methodPrefix, XSSimpleType owner) {
 286             String bc = findBaseConversion(owner);
 287             if(bc==null)    return null;
 288 
 289             return DatatypeConverter.class.getName()+'.'+methodPrefix+bc;
 290         }
 291 
 292         private String findBaseConversion(XSSimpleType owner) {
 293             // find the base simple type mapping.
 294             for( XSSimpleType st=owner; st!=null; st = st.getSimpleBaseType() ) {
 295                 if( !WellKnownNamespace.XML_SCHEMA.equals(st.getTargetNamespace()) )
 296                     continue;   // user-defined type
 297 
 298                 String name = st.getName().intern();
 299                 for( String s : knownBases )
 300                     if(name.equalsIgnoreCase(s))
 301                         return s;
 302             }
 303 
 304             return null;
 305         }
 306 
 307         public QName getName() { return NAME; }
 308 
 309         /** Name of the conversion declaration. */
 310         public static final QName NAME = new QName(
 311             Const.JAXB_NSURI, "javaType" );
 312     }
 313 
 314     @XmlRootElement(name="javaType",namespace=Const.XJC_EXTENSION_URI)
 315     public static class UserAdapter extends BIConversion {
 316         @XmlAttribute(name="name")
 317         private String type = null;
 318 
 319         @XmlAttribute
 320         private String adapter = null;
 321 
 322         private TypeUse typeUse;
 323 
 324         public TypeUse getTypeUse(XSSimpleType owner) {
 325             if(typeUse!=null)
 326                 return typeUse;
 327 
 328             JCodeModel cm = getCodeModel();
 329 
 330             JDefinedClass a;
 331             try {
 332                 a = cm._class(adapter);
 333                 a.hide();   // we assume this is given by the user
 334                 a._extends(cm.ref(XmlAdapter.class).narrow(String.class).narrow(
 335                         cm.ref(type)));
 336             } catch (JClassAlreadyExistsException e) {
 337                 a = e.getExistingClass();
 338             }
 339 
 340             // TODO: it's not correct to say that it adapts from String,
 341             // but OTOH I don't think we can compute that.
 342             typeUse = TypeUseFactory.adapt(
 343                     CBuiltinLeafInfo.STRING,
 344                     new CAdapter(a));
 345 
 346             return typeUse;
 347         }
 348     }
 349 }
--- EOF ---