001// ***************************************************************************************************************************
002// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements.  See the NOTICE file *
003// * distributed with this work for additional information regarding copyright ownership.  The ASF licenses this file        *
004// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance            *
005// * with the License.  You may obtain a copy of the License at                                                              *
006// *                                                                                                                         *
007// *  http://www.apache.org/licenses/LICENSE-2.0                                                                             *
008// *                                                                                                                         *
009// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an  *
010// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the        *
011// * specific language governing permissions and limitations under the License.                                              *
012// ***************************************************************************************************************************
013package org.apache.juneau.transform;
014
015import static org.apache.juneau.internal.CollectionUtils.*;
016import static org.apache.juneau.internal.ClassUtils.*;
017
018import java.lang.reflect.*;
019import java.util.*;
020
021import org.apache.juneau.*;
022import org.apache.juneau.annotation.*;
023import org.apache.juneau.parser.*;
024import org.apache.juneau.reflect.*;
025import org.apache.juneau.serializer.*;
026
027/**
028 * A dynamic POJO swap based on reflection of a Java class that converts POJOs to Lists.
029 *
030 * <p>
031 * Looks for methods on the class that can be called to swap-in surrogate List objects before serialization and swap-out
032 * surrogate List objects after parsing.
033 *
034 * <h5 class='figure'>Valid surrogate objects</h5>
035 * <ul>
036 *    <li class='jc'>Any subclass of {@link List}
037 * </ul>
038 *
039 * <h5 class='figure'>Valid swap methods (S = Swapped type)</h5>
040 * <ul>
041 *    <li class='jm'><c><jk>public</jk> S toList()</c>
042 *    <li class='jm'><c><jk>public</jk> S toList(BeanSession)</c>
043 *    <li class='jm'><c><jk>public</jk> S toObjectList()</c>
044 *    <li class='jm'><c><jk>public</jk> S toObjectList(BeanSession)</c>
045 * </ul>
046 *
047 * <h5 class='figure'>Valid unswap methods (N = Normal type, S = Swapped type)</h5>
048 * <ul>
049 *    <li class='jm'><c><jk>public static</jk> N fromList(S)</c>
050 *    <li class='jm'><c><jk>public static</jk> N fromList(BeanSession, S)</c>
051 *    <li class='jm'><c><jk>public static</jk> N fromObjectList(S)</c>
052 *    <li class='jm'><c><jk>public static</jk> N fromObjectList(BeanSession, S)</c>
053 *    <li class='jm'><c><jk>public static</jk> N create(S)</c>
054 *    <li class='jm'><c><jk>public static</jk> N create(BeanSession, S)</c>
055 *    <li class='jm'><c><jk>public static</jk> N valueOf(S)</c>
056 *    <li class='jm'><c><jk>public static</jk> N valueOf(BeanSession, S)</c>
057 *    <li class='jm'><c><jk>public</jk> N(S)</c>
058 * </ul>
059 *
060 * <p>
061 * Classes are ignored if any of the following are true:
062 * <ul>
063 *    <li>Classes annotated with {@link BeanIgnore @BeanIgnore}.
064 *    <li>Non-static member classes.
065 * </ul>
066 *
067 * <p>
068 * Members/constructors are ignored if any of the following are true:
069 * <ul>
070 *    <li>Members/constructors annotated with {@link BeanIgnore @BeanIgnore}.
071 *    <li>Deprecated members/constructors.
072 * </ul>
073 *
074 * @param <T> The normal class type.
075 */
076public class AutoListSwap<T> extends PojoSwap<T,List<?>> {
077
078   private static final Set<String>
079      SWAP_METHOD_NAMES = newUnmodifiableHashSet("toList", "toObjectList"),
080      UNSWAP_METHOD_NAMES = newUnmodifiableHashSet("fromList", "fromObjectList", "create", "valueOf");
081
082   /**
083    * Look for constructors and methods on this class and construct a dynamic swap if it's possible to do so.
084    *
085    * @param bc The bean context to use for looking up annotations.
086    * @param ci The class to try to constructor a dynamic swap on.
087    * @return A POJO swap instance, or <jk>null</jk> if one could not be created.
088    */
089   @SuppressWarnings({ "rawtypes" })
090   public static PojoSwap<?,?> find(BeanContext bc, ClassInfo ci) {
091
092      if (shouldIgnore(bc, ci))
093         return null;
094
095      // Find swap() method if present.
096      for (MethodInfo m : ci.getPublicMethods()) {
097         if (isSwapMethod(bc, m)) {
098
099            ClassInfo rt = m.getReturnType();
100
101            for (MethodInfo m2 : ci.getPublicMethods())
102               if (isUnswapMethod(bc, m2, ci, rt))
103                  return new AutoListSwap(ci, m, m2, null);
104
105            for (ConstructorInfo cs : ci.getPublicConstructors())
106               if (isUnswapConstructor(bc, cs, rt))
107                  return new AutoListSwap(ci, m, null, cs);
108
109            return new AutoListSwap(ci, m, null, null);
110         }
111      }
112
113      return null;
114   }
115
116   private static boolean shouldIgnore(BeanContext bc, ClassInfo ci) {
117      return
118         bc.hasAnnotation(BeanIgnore.class, ci)
119         || ci.isNonStaticMemberClass();
120   }
121
122   private static boolean isSwapMethod(BeanContext bc, MethodInfo mi) {
123      return
124         mi.isNotDeprecated()
125         && mi.isNotStatic()
126         && mi.hasName(SWAP_METHOD_NAMES)
127         && mi.hasReturnTypeParent(List.class)
128         && mi.hasFuzzyParamTypes(BeanSession.class)
129         && ! bc.hasAnnotation(BeanIgnore.class, mi);
130   }
131
132   private static boolean isUnswapMethod(BeanContext bc, MethodInfo mi, ClassInfo ci, ClassInfo rt) {
133      return
134         mi.isNotDeprecated()
135         && mi.isStatic()
136         && mi.hasName(UNSWAP_METHOD_NAMES)
137         && mi.hasFuzzyParamTypes(BeanSession.class, rt.inner())
138         && mi.hasReturnTypeParent(ci)
139         && ! bc.hasAnnotation(BeanIgnore.class, mi);
140   }
141
142   private static boolean isUnswapConstructor(BeanContext bc, ConstructorInfo cs, ClassInfo rt) {
143      return
144         cs.isNotDeprecated()
145         && cs.hasParamTypeParents(rt)
146         && ! bc.hasAnnotation(BeanIgnore.class, cs);
147   }
148
149   //------------------------------------------------------------------------------------------------------------------
150
151   private final Method swapMethod, unswapMethod;
152   private final Constructor<?> unswapConstructor;
153
154   private AutoListSwap(ClassInfo ci, MethodInfo swapMethod, MethodInfo unswapMethod, ConstructorInfo unswapConstructor) {
155      super(ci.inner(), swapMethod.getReturnType().inner());
156      this.swapMethod = swapMethod.inner();
157      this.unswapMethod = unswapMethod == null ? null : unswapMethod.inner();
158      this.unswapConstructor = unswapConstructor == null ? null : unswapConstructor.inner();
159   }
160
161   @Override /* PojoSwap */
162   public List<?> swap(BeanSession session, Object o) throws SerializeException {
163      try {
164         return (List<?>)swapMethod.invoke(o, getMatchingArgs(swapMethod.getParameterTypes(), session));
165      } catch (Exception e) {
166         throw SerializeException.create(e);
167      }
168   }
169
170   @SuppressWarnings("unchecked")
171   @Override /* PojoSwap */
172   public T unswap(BeanSession session, List<?> o, ClassMeta<?> hint) throws ParseException {
173      try {
174         if (unswapMethod != null)
175            return (T)unswapMethod.invoke(null, getMatchingArgs(unswapMethod.getParameterTypes(), session, o));
176         if (unswapConstructor != null)
177            return (T)unswapConstructor.newInstance(o);
178         return super.unswap(session, o, hint);
179      } catch (Exception e) {
180         throw ParseException.create(e);
181      }
182   }
183}