diff --git a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/BeanMapTest.java b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/BeanMapTest.java
index 9cbe297..1f45b27 100755
--- a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/BeanMapTest.java
+++ b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/BeanMapTest.java
@@ -1858,6 +1858,60 @@
 		}
 	}
 
+	@Test
+	public void testHiddenProperties_usingConfig() throws Exception {
+		JsonSerializer s = SimpleJsonSerializer.DEFAULT.builder().applyAnnotations(Uc.class).build();
+		BeanMeta bm = s.getBeanMeta(U.class);
+		assertNotNull(bm.getPropertyMeta("a"));
+		assertNotNull(bm.getPropertyMeta("b"));
+		assertNull(bm.getPropertyMeta("c"));
+		assertNull(bm.getPropertyMeta("d"));
+
+		Uc t = new Uc();
+		t.a = "a";
+		t.b = "b";
+		String r = s.serialize(t);
+		assertEquals("{a:'a',b:'b'}", r);
+
+		// Make sure setters are used if present.
+		t = JsonParser.DEFAULT.builder().applyAnnotations(Uc.class).build().parse(r, Uc.class);
+		assertEquals("b(setter)", t.b);
+	}
+
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="Uc.getB,Uc.c,Uc.getD,Uc.setD"))
+	public static class Uc {
+		public String a, b;
+
+		public String getA() {
+			return a;
+		}
+
+		public void setA(String a) {
+			this.a = a;
+		}
+
+		@BeanIgnore
+		public String getB() {
+			return b;
+		}
+
+		public void setB(String b) {
+			this.b = b+"(setter)";
+		}
+
+		@BeanIgnore
+		public String c;
+
+		@BeanIgnore
+		public String getD() {
+			return null;
+		}
+
+		@BeanIgnore
+		public void setD(String d) {
+		}
+	}
+
 	//====================================================================================================
 	// testBeanPropertyOrder
 	//====================================================================================================
diff --git a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/annotation/BeanIgnoreTest.java b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/annotation/BeanIgnoreTest.java
index 97ae0f1..1893314 100644
--- a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/annotation/BeanIgnoreTest.java
+++ b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/annotation/BeanIgnoreTest.java
@@ -14,10 +14,15 @@
 
 import static org.apache.juneau.testutils.TestUtils.*;
 
+import org.apache.juneau.json.*;
 import org.junit.*;
 
 public class BeanIgnoreTest {
 
+	//------------------------------------------------------------------------------------------------------------------
+	// Test @BeanIgnore on properties
+	//------------------------------------------------------------------------------------------------------------------
+
 	public static class A {
 		public String getA() {
 			return "a";
@@ -34,15 +39,39 @@
 	}
 
 	@Test
-	public void test() throws Exception {
+	public void testBeanIgnoreOnProperties() throws Exception {
 		assertObjectEquals("{c:'c',a:'a'}", new A());
 	}
 
-	@Test
-	public void testBeanIgnoreOnBean() throws Exception {
-		assertObjectEquals("{f2:2,f3:'xxx',f4:'xxx'}", new B());
+	@BeanConfig(
+		annotateBeanIgnore={
+			@BeanIgnore(on="Ac.getB"),
+			@BeanIgnore(on="Ac.d")
+		}
+	)
+	public static class Ac {
+		public String getA() {
+			return "a";
+		}
+
+		public String getB() {
+			return "b";
+		}
+
+		public String c = "c";
+
+		public String d = "d";
 	}
 
+	@Test
+	public void testBeanIgnoreOnProperties_usingConfig() throws Exception {
+		assertObjectEquals("{c:'c',a:'a'}", new Ac(), SimpleJsonSerializer.DEFAULT.builder().applyAnnotations(Ac.class).build());
+	}
+
+	//------------------------------------------------------------------------------------------------------------------
+	// Test @BeanIgnore on classes
+	//------------------------------------------------------------------------------------------------------------------
+
 	@BeanIgnore
 	public static class B1 {
 		public int f = 1;
@@ -61,5 +90,34 @@
 			return new B1();
 		}
 	}
+
+	@Test
+	public void testBeanIgnoreOnBean() throws Exception {
+		assertObjectEquals("{f2:2,f3:'xxx',f4:'xxx'}", new B());
+	}
+
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="B1c"))
+	public static class B1c {
+		public int f = 1;
+
+		@Override
+		public String toString() {
+			return "xxx";
+		}
+	}
+
+	public static class Bc {
+		public int f2 = 2;
+		public B1c f3 = new B1c();
+
+		public B1c getF4() {
+			return new B1c();
+		}
+	}
+
+	@Test
+	public void testBeanIgnoreOnBean_usingConfig() throws Exception {
+		assertObjectEquals("{f2:2,f3:'xxx',f4:'xxx'}", new Bc(), SimpleJsonSerializer.DEFAULT.builder().applyAnnotations(B1c.class).build());
+	}
 }
 
diff --git a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoListSwapTest.java b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoListSwapTest.java
index 3655367..a5c51d7 100644
--- a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoListSwapTest.java
+++ b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoListSwapTest.java
@@ -34,7 +34,15 @@
 	private static final ObjectList OBJECTLIST = new ObjectList().append("foo");
 
 	private static PojoSwap find(Class<?> c) {
-		return AutoListSwap.find(ClassInfo.of(c));
+		return AutoListSwap.find(BeanContext.DEFAULT, ClassInfo.of(c));
+	}
+
+	private static PojoSwap find(BeanContext bc, Class<?> c) {
+		return AutoListSwap.find(bc, ClassInfo.of(c));
+	}
+
+	private static BeanContext bc(Class<?> applyAnnotations) {
+		return BeanContext.DEFAULT.builder().applyAnnotations(applyAnnotations).build();
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
@@ -186,6 +194,30 @@
 		assertNull(find(D02.D02A.class));
 	}
 
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="D01c"))
+	public static class D01c {
+		public List<String> toList() {
+			return STRINGLIST;
+		}
+	}
+	public static class D02c {
+		public class D02Ac {
+			public List<String> toList() {
+				return STRINGLIST;
+			}
+		}
+	}
+
+	@Test
+	public void d03_ignoreClass_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(bc(D01c.class), D01c.class));
+	}
+
+	@Test
+	public void d04_ignoreClass_memberClass_usingConfig() throws Exception {
+		assertNull(find(bc(D01c.class), D02c.D02Ac.class));
+	}
+
 	//------------------------------------------------------------------------------------------------------------------
 	// Ignore swap method
 	//------------------------------------------------------------------------------------------------------------------
@@ -196,6 +228,12 @@
 			return STRINGLIST;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="E01c.toList"))
+	public static class E01c {
+		public List<String> toList() {
+			return STRINGLIST;
+		}
+	}
 	public static class E02 {
 		@Deprecated
 		public List<String> toList() {
@@ -224,6 +262,11 @@
 	}
 
 	@Test
+	public void e01c_ignoreSwapMethod_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(BeanContext.DEFAULT.builder().applyAnnotations(E01c.class).build(), E01c.class));
+	}
+
+	@Test
 	public void e02_ignoreSwapMethod_deprecated() throws Exception {
 		assertNull(find(E02.class));
 	}
@@ -256,6 +299,15 @@
 			return null;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="F01c.create"))
+	public static class F01c {
+		public List<String> toList() {
+			return STRINGLIST;
+		}
+		public static F01c create(List<String> o) {
+			return null;
+		}
+	}
 	public static class F02 {
 		public List<String> toList() {
 			return STRINGLIST;
@@ -304,6 +356,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void f01c_ignoreUnswapMethod_beanIgnore_applyConfig() throws Exception {
+		find(bc(F01c.class), F01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void f02_ignoreUnswapMethod_deprecated() throws Exception {
 		find(F02.class).unswap(null, null, null);
 	}
@@ -340,6 +397,14 @@
 		}
 	}
 
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="G01c(List)"))
+	public static class G01c {
+		public G01c(List<String> o) {}
+		public List<String> toList() {
+			return STRINGLIST;
+		}
+	}
+
 	public static class G02 {
 		@Deprecated
 		public G02(List<String> o) {}
@@ -354,6 +419,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void g01c_ignoreUnswapConstructor_beanIgnore_usingConfig() throws Exception {
+		find(bc(G01c.class), G01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void g02_ignoreUnswapConstructor_deprecated() throws Exception {
 		find(G02.class).unswap(null, null, null);
 	}
diff --git a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoMapSwapTest.java b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoMapSwapTest.java
index c32fa0f..2761e11 100644
--- a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoMapSwapTest.java
+++ b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoMapSwapTest.java
@@ -34,7 +34,15 @@
 	private static final ObjectMap OBJECTMAP = new ObjectMap().append("foo","bar");
 
 	private static PojoSwap find(Class<?> c) {
-		return AutoMapSwap.find(ClassInfo.of(c));
+		return AutoMapSwap.find(BeanContext.DEFAULT, ClassInfo.of(c));
+	}
+
+	private static PojoSwap find(BeanContext bc, Class<?> c) {
+		return AutoMapSwap.find(bc, ClassInfo.of(c));
+	}
+
+	private static BeanContext bc(Class<?> applyAnnotations) {
+		return BeanContext.DEFAULT.builder().applyAnnotations(applyAnnotations).build();
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
@@ -168,6 +176,12 @@
 			return STRINGMAP;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="D01c"))
+	public static class D01c {
+		public Map<String,String> toMap() {
+			return STRINGMAP;
+		}
+	}
 	public static class D02 {
 		public class D02A {
 			public Map<String,String> toMap() {
@@ -182,6 +196,11 @@
 	}
 
 	@Test
+	public void d01c_ignoreClass_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(bc(D01c.class), D01c.class));
+	}
+
+	@Test
 	public void d02_ignoreClass_memberClass() throws Exception {
 		assertNull(find(D02.D02A.class));
 	}
@@ -196,6 +215,12 @@
 			return STRINGMAP;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="E01c.toMap"))
+	public static class E01c {
+		public Map<String,String> toMap() {
+			return STRINGMAP;
+		}
+	}
 	public static class E02 {
 		@Deprecated
 		public Map<String,String> toMap() {
@@ -224,6 +249,11 @@
 	}
 
 	@Test
+	public void e01c_ignoreSwapMethod_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(bc(E01c.class), E01c.class));
+	}
+
+	@Test
 	public void e02_ignoreSwapMethod_deprecated() throws Exception {
 		assertNull(find(E02.class));
 	}
@@ -256,6 +286,15 @@
 			return null;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="F01c.create(Map)"))
+	public static class F01c {
+		public Map<String,String> toMap() {
+			return STRINGMAP;
+		}
+		public static F01c create(Map<String,String> o) {
+			return null;
+		}
+	}
 	public static class F02 {
 		public Map<String,String> toMap() {
 			return STRINGMAP;
@@ -304,6 +343,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void f01c_ignoreUnswapMethod_beanIgnore_usingConfig() throws Exception {
+		find(bc(F01c.class), F01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void f02_ignoreUnswapMethod_deprecated() throws Exception {
 		find(F02.class).unswap(null, null, null);
 	}
@@ -340,6 +384,14 @@
 		}
 	}
 
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="G01c(Map)"))
+	public static class G01c {
+		public G01c(Map<String,String> o) {}
+		public Map<String,String> toMap() {
+			return STRINGMAP;
+		}
+	}
+
 	public static class G02 {
 		@Deprecated
 		public G02(Map<String,String> o) {}
@@ -354,6 +406,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void g01c_ignoreUnswapConstructor_beanIgnore_usingConfig() throws Exception {
+		find(bc(G01c.class), G01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void g02_ignoreUnswapConstructor_deprecated() throws Exception {
 		find(G02.class).unswap(null, null, null);
 	}
diff --git a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoNumberSwapTest.java b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoNumberSwapTest.java
index 4415e78..099a644 100644
--- a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoNumberSwapTest.java
+++ b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoNumberSwapTest.java
@@ -17,6 +17,7 @@
 
 import java.util.*;
 
+import org.apache.juneau.*;
 import org.apache.juneau.annotation.*;
 import org.apache.juneau.parser.*;
 import org.apache.juneau.reflect.*;
@@ -29,7 +30,15 @@
 public class AutoNumberSwapTest {
 
 	private static PojoSwap find(Class<?> c) {
-		return AutoNumberSwap.find(ClassInfo.of(c));
+		return AutoNumberSwap.find(BeanContext.DEFAULT, ClassInfo.of(c));
+	}
+
+	private static PojoSwap find(BeanContext bc, Class<?> c) {
+		return AutoNumberSwap.find(bc, ClassInfo.of(c));
+	}
+
+	private static BeanContext bc(Class<?> applyAnnotations) {
+		return BeanContext.DEFAULT.builder().applyAnnotations(applyAnnotations).build();
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
@@ -593,6 +602,12 @@
 			return 1;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="D01c"))
+	public static class D01c {
+		public Integer toInteger() {
+			return 1;
+		}
+	}
 	public static class D02 {
 		public class D02A {
 			public Integer toInteger() {
@@ -607,6 +622,11 @@
 	}
 
 	@Test
+	public void d01c_ignoreClass_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(bc(D01c.class), D01c.class));
+	}
+
+	@Test
 	public void d02_ignoreClass_memberClass() throws Exception {
 		assertNull(find(D02.D02A.class));
 	}
@@ -633,6 +653,12 @@
 			return 1;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="E01c.toInteger"))
+	public static class E01c {
+		public Integer toInteger() {
+			return 1;
+		}
+	}
 	public static class E02 {
 		@Deprecated
 		public Integer toInteger() {
@@ -661,6 +687,11 @@
 	}
 
 	@Test
+	public void e01c_ignoreSwapMethod_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(bc(E01c.class), E01c.class));
+	}
+
+	@Test
 	public void e02_ignoreSwapMethod_deprecated() throws Exception {
 		assertNull(find(E02.class));
 	}
@@ -693,6 +724,15 @@
 			return null;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="F01c.create(java.lang.Integer)"))
+	public static class F01c {
+		public Integer toInteger() {
+			return 1;
+		}
+		public static F01 create(Integer o) {
+			return null;
+		}
+	}
 	public static class F02 {
 		public Integer toInteger() {
 			return 1;
@@ -741,6 +781,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void f01c_ignoreUnswapMethod_beanIgnore_usingConfig() throws Exception {
+		find(bc(F01c.class), F01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void f02_ignoreUnswapMethod_deprecated() throws Exception {
 		find(F02.class).unswap(null, null, null);
 	}
@@ -777,6 +822,14 @@
 		}
 	}
 
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="G01c(java.lang.Integer)"))
+	public static class G01c {
+		public G01c(Integer o) {}
+		public Integer toInteger() {
+			return 1;
+		}
+	}
+
 	public static class G02 {
 		@Deprecated
 		public G02(Integer o) {}
@@ -791,6 +844,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void g01c_ignoreUnswapConstructor_beanIgnore_usingConfig() throws Exception {
+		find(bc(G01c.class), G01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void g02_ignoreUnswapConstructor_deprecated() throws Exception {
 		find(G02.class).unswap(null, null, null);
 	}
diff --git a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoObjectSwapTest.java b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoObjectSwapTest.java
index a0eda02..6fa75d9 100644
--- a/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoObjectSwapTest.java
+++ b/juneau-core/juneau-core-utest/src/test/java/org/apache/juneau/transform/AutoObjectSwapTest.java
@@ -35,7 +35,15 @@
 	private static final ObjectMap OBJECTMAP = new ObjectMap().append("foo","bar");
 
 	private static PojoSwap find(Class<?> c) {
-		return AutoObjectSwap.find(ClassInfo.of(c));
+		return AutoObjectSwap.find(BeanContext.DEFAULT, ClassInfo.of(c));
+	}
+
+	private static PojoSwap find(BeanContext bc, Class<?> c) {
+		return AutoObjectSwap.find(bc, ClassInfo.of(c));
+	}
+
+	private static BeanContext bc(Class<?> applyAnnotations) {
+		return BeanContext.DEFAULT.builder().applyAnnotations(applyAnnotations).build();
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
@@ -171,6 +179,12 @@
 			return STRINGMAP;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="D01c"))
+	public static class D01c {
+		public Map<String,String> swap() {
+			return STRINGMAP;
+		}
+	}
 	public static class D02 {
 		public class D02A {
 			public Map<String,String> swap() {
@@ -185,6 +199,11 @@
 	}
 
 	@Test
+	public void d01c_ignoreClass_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(bc(D01c.class), D01c.class));
+	}
+
+	@Test
 	public void d02_ignoreClass_memberClass() throws Exception {
 		assertNull(find(D02.D02A.class));
 	}
@@ -199,6 +218,12 @@
 			return STRINGMAP;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="E01c.swap"))
+	public static class E01c {
+		public Map<String,String> swap() {
+			return STRINGMAP;
+		}
+	}
 	public static class E02 {
 		@Deprecated
 		public Map<String,String> swap() {
@@ -222,6 +247,11 @@
 	}
 
 	@Test
+	public void e01c_ignoreSwapMethod_beanIgnore_usingConfig() throws Exception {
+		assertNull(find(bc(E01c.class), E01c.class));
+	}
+
+	@Test
 	public void e02_ignoreSwapMethod_deprecated() throws Exception {
 		assertNull(find(E02.class));
 	}
@@ -249,6 +279,15 @@
 			return null;
 		}
 	}
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="F01c.create(java.util.Map)"))
+	public static class F01c {
+		public Map<String,String> swap() {
+			return STRINGMAP;
+		}
+		public static F01 create(Map<String,String> o) {
+			return null;
+		}
+	}
 	public static class F02 {
 		public Map<String,String> swap() {
 			return STRINGMAP;
@@ -297,6 +336,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void f01c_ignoreUnswapMethod_beanIgnore_usingConfig() throws Exception {
+		find(bc(F01c.class), F01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void f02_ignoreUnswapMethod_deprecated() throws Exception {
 		find(F02.class).unswap(null, null, null);
 	}
@@ -333,6 +377,14 @@
 		}
 	}
 
+	@BeanConfig(annotateBeanIgnore=@BeanIgnore(on="G01c(Map)"))
+	public static class G01c {
+		public G01c(Map<String,String> o) {}
+		public Map<String,String> swap() {
+			return STRINGMAP;
+		}
+	}
+
 	public static class G02 {
 		@Deprecated
 		public G02(Map<String,String> o) {}
@@ -347,6 +399,11 @@
 	}
 
 	@Test(expected = ParseException.class)
+	public void g01c_ignoreUnswapConstructor_beanIgnore_usingConfig() throws Exception {
+		find(bc(G01c.class), G01c.class).unswap(null, null, null);
+	}
+
+	@Test(expected = ParseException.class)
 	public void g02_ignoreUnswapConstructor_deprecated() throws Exception {
 		find(G02.class).unswap(null, null, null);
 	}
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java
index 71cf6a1..3758c7a 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/BeanMeta.java
@@ -205,7 +205,7 @@
 				if (! (cVis.isVisible(c.getModifiers()) || c.isAnonymousClass()))
 					return "Class is not public";
 
-				if (c.isAnnotationPresent(BeanIgnore.class))
+				if (ctx.hasAnnotation(BeanIgnore.class, c))
 					return "Class is annotated with @BeanIgnore";
 
 				// Make sure it's serializable.
@@ -383,7 +383,7 @@
 					BeanPropertyMeta.Builder p = i.next();
 					try {
 						if (p.field == null)
-							p.setInnerField(findInnerBeanField(c, stopClass, p.name));
+							p.setInnerField(findInnerBeanField(ctx, c, stopClass, p.name));
 
 						if (p.validate(ctx, beanRegistry, typeVarImpls, bpro, bpwo)) {
 
@@ -752,7 +752,7 @@
 			for (FieldInfo f : c2.getDeclaredFields()) {
 				if (f.isAny(STATIC, TRANSIENT))
 					continue;
-				if (f.hasAnnotation(BeanIgnore.class))
+				if (ctx.hasAnnotation(BeanIgnore.class, f))
 					continue;
 
 				@SuppressWarnings("deprecation")
@@ -773,12 +773,12 @@
 		return l;
 	}
 
-	static final Field findInnerBeanField(Class<?> c, Class<?> stopClass, String name) {
+	static final Field findInnerBeanField(BeanContext bc, Class<?> c, Class<?> stopClass, String name) {
 		for (ClassInfo c2 : findClasses(c, stopClass)) {
 			for (FieldInfo f : c2.getDeclaredFields()) {
 				if (f.isAny(STATIC, TRANSIENT))
 					continue;
-				if (f.hasAnnotation(BeanIgnore.class))
+				if (f.hasAnnotation(BeanIgnore.class, bc))
 					continue;
 				if (f.hasName(name))
 					return f.inner();
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java
index c0cd6f4..9a3a7bf 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java
@@ -458,13 +458,13 @@
 			}
 
 			for (FieldInfo f : ci.getAllFieldsParentFirst()) {
-				if (f.hasAnnotation(ParentProperty.class)) {
+				if (bc.hasAnnotation(ParentProperty.class, f)) {
 					if (f.isStatic())
 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid field ''{0}''.  Must be static.", f);
 					f.setAccessible();
 					parentPropertyMethod = new Setter.FieldSetter(f.inner());
 				}
-				if (f.hasAnnotation(NameProperty.class)) {
+				if (bc.hasAnnotation(NameProperty.class, f)) {
 					if (f.isStatic())
 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid field ''{0}''.  Must be static.", f);
 					f.setAccessible();
@@ -473,7 +473,7 @@
 			}
 
 			for (FieldInfo f : ci.getDeclaredFields()) {
-				if (f.hasAnnotation(Example.class)) {
+				if (bc.hasAnnotation(Example.class, f)) {
 					if (! (f.isStatic() && ci.isParentOf(f.getType().inner())))
 						throw new ClassMetaRuntimeException(c, "@Example used on invalid field ''{0}''.  Must be static and an instance of the type.", f);
 					f.setAccessible();
@@ -483,13 +483,13 @@
 
 			// Find @NameProperty and @ParentProperty methods if present.
 			for (MethodInfo m : ci.getAllMethodsParentFirst()) {
-				if (m.hasAnnotation(ParentProperty.class)) {
+				if (bc.hasAnnotation(ParentProperty.class, m)) {
 					if (m.isStatic() || ! m.hasNumParams(1))
 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid method ''{0}''.  Must not be static and have one argument.", m);
 					m.setAccessible();
 					parentPropertyMethod = new Setter.MethodSetter(m.inner());
 				}
-				if (m.hasAnnotation(NameProperty.class)) {
+				if (bc.hasAnnotation(NameProperty.class, m)) {
 					if (m.isStatic() || ! m.hasNumParams(1))
 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid method ''{0}''.  Must not be static and have one argument.", m);
 					m.setAccessible();
@@ -498,7 +498,7 @@
 			}
 
 			for (MethodInfo m : ci.getDeclaredMethods()) {
-				if (m.hasAnnotation(Example.class)) {
+				if (bc.hasAnnotation(Example.class, m)) {
 					if (! (m.isStatic() && m.hasFuzzyParamTypes(BeanSession.class) && ci.isParentOf(m.getReturnType().inner())))
 						throw new ClassMetaRuntimeException(c, "@Example used on invalid method ''{0}''.  Must be static and return an instance of the declaring class.", m);
 					m.setAccessible();
@@ -541,7 +541,7 @@
 				this.pojoSwaps.addAll(Arrays.asList(pojoSwaps));
 
 			if (bc != null)
-				this.builderSwap = BuilderSwap.findSwapFromPojoClass(c, bc.getBeanConstructorVisibility(), bc.getBeanMethodVisibility());
+				this.builderSwap = BuilderSwap.findSwapFromPojoClass(bc, c, bc.getBeanConstructorVisibility(), bc.getBeanMethodVisibility());
 
 			findPojoSwaps(this.pojoSwaps, bc);
 
@@ -701,13 +701,13 @@
 
 			PojoSwap defaultSwap = DefaultSwaps.find(ci);
 			if (defaultSwap == null)
-				defaultSwap = AutoObjectSwap.find(ci);
+				defaultSwap = AutoObjectSwap.find(bc, ci);
 			if (defaultSwap == null)
-				defaultSwap = AutoNumberSwap.find(ci);
+				defaultSwap = AutoNumberSwap.find(bc, ci);
 			if (defaultSwap == null)
-				defaultSwap = AutoMapSwap.find(ci);
+				defaultSwap = AutoMapSwap.find(bc, ci);
 			if (defaultSwap == null)
-				defaultSwap = AutoListSwap.find(ci);
+				defaultSwap = AutoListSwap.find(bc, ci);
 			if (defaultSwap != null)
 				l.add(defaultSwap);
 		}
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Bean.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Bean.java
index 436291b..ac8f525 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Bean.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Bean.java
@@ -227,6 +227,51 @@
 	Class<?> interfaceClass() default Object.class;
 
 	/**
+	 * Dynamically apply this annotation to the specified classes.
+	 *
+	 * <p>
+	 * Used in conjunction with the {@link BeanConfig#annotateBean()}.
+	 * It is ignored when the annotation is applied directly to classes.
+	 *
+	 * <p>
+	 * The following example shows the equivalent methods for applying the {@link Bean @Bean} annotation to REST methods:
+	 * <p class='bpcode w800'>
+	 * 	<jc>// Class with explicit annotation.</jc>
+	 * 	<ja>@Bean</ja>(bpi=<jk>"street,city,state"</js>)
+	 * 	<jk>public class</jk> A {...}
+	 *
+	 * 	<jc>// Class with annotation applied via @BeanConfig</jc>
+	 * 	<jk>public class</jk> B {...}
+	 *
+	 * 	<jc>// Java REST method with @BeanConfig annotation.</jc>
+	 * 	<ja>@RestMethod</ja>(...)
+	 * 	<ja>@BeanConfig</ja>(
+	 * 		annotateBean={
+	 * 			<ja>@Bean</ja>(on=<js>"B"</js>, bpi=<jk>"street,city,state"</js>)
+	 * 		}
+	 * 	)
+	 * 	<jk>public void</jk> doFoo() {...}
+	 * </p>
+	 *
+	 * The valid pattern matches are:
+	 * <ul>
+	 * 	<li>Classes:
+	 * 		<ul>
+	 * 			<li>Fully qualified: <js>"com.foo.MyClass"</js>
+	 * 			<li>Fully qualified inner class: <js>"com.foo.MyClass$Inner1$Inner2"</js>
+	 * 			<li>Simple: <js>"MyClass"</js>
+	 * 			<li>Simple inner: <js>"MyClass$Inner1$Inner2"</js> or <js>"Inner1$Inner2"</js> or <js>"Inner2"</js>
+	 * 		</ul>
+	 * 	<li>A comma-delimited list of anything on this list.
+	 * </ul>
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	String on() default "";
+
+	/**
 	 * The set and order of names of properties associated with a bean class.
 	 *
 	 * @deprecated Use {@link #bpi()}
@@ -265,48 +310,6 @@
 	Class<? extends PropertyNamer> propertyNamer() default PropertyNamerDefault.class;
 
 	/**
-	 * Defines which classes/methods this annotation applies to.
-	 *
-	 * <p>
-	 * Used in conjunction with the {@link BeanConfig#annotateBean()}.
-	 * It is ignored when the annotation is applied directly to classes and methods.
-	 *
-	 * <p>
-	 * The following example shows the equivalent methods for applying the {@link Bean @Bean} annotation:
-	 * <p class='bpcode w800'>
-	 * 	<jc>// Class with explicit annotation.</jc>
-	 * 	<ja>@Bean</ja>(bpi=<jk>"street,city,state"</js>)
-	 * 	<jk>public class</jk> A {...}
-	 *
-	 * 	<jc>// Class with annotation applied via @BeanConfig</jc>
-	 * 	<jk>public class</jk> B {...}
-	 *
-	 * 	<jc>// Java REST method with @BeanConfig annotation.</jc>
-	 * 	<ja>@RestMethod</ja>(...)
-	 * 	<ja>@BeanConfig</ja>(
-	 * 		annotateBean={
-	 * 			<ja>@Bean</ja>(on=<js>"B"</js>, bpi=<jk>"street,city,state"</js>)
-	 * 		}
-	 * 	)
-	 * 	<jk>public void</jk> doFoo() {...}
-	 * </p>
-	 *
-	 * The format can be any of the following:
-	 * <ul>
-	 * 	<li>Full class name (e.g. <js>"com.foo.MyClass"</js>).
-	 * 	<li>Simple class name (e.g. <js>"MyClass"</js>).
-	 * 	<li>Full method name (e.g. <js>"com.foo.MyClass.myMethod"</js>).
-	 * 	<li>Simple method name (e.g. <js>"MyClass.myMethod"</js>).
-	 * 	<li>A comma-delimited list of anything on this list.
-	 * </ul>
-	 *
-	 * <ul class='seealso'>
-	 * 	<li class='link'>{@doc juneau-marshall.ClassMethodAnnotations}
-	 * </ul>
-	 */
-	String on() default "";
-
-	/**
 	 * Sort bean properties in alphabetical order.
 	 *
 	 * <p>
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfig.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfig.java
index edc06f9..3a59ac8 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfig.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfig.java
@@ -50,45 +50,136 @@
 	//-----------------------------------------------------------------------------------------------------------------
 
 	/**
-	 * Indirectly applies {@link Bean @Bean} annotations to classes/methods.
+	 * Dynamically applies {@link Bean @Bean} annotations to specified classes.
 	 *
 	 * <p>
-	 * Provides an alternate approach for applying annotations to classes/methods annotations using the {@link Bean#on() @Bean.on}
-	 * annotation to specify the class/method names to apply the annotation to.
+	 * Provides an alternate approach for applying annotations using {@link Bean#on() @Bean.on} to specify the names
+	 * to apply the annotation to.
 	 *
 	 * <ul class='seealso'>
-	 * 	<li class='link'>{@doc juneau-marshall.ClassMethodAnnotations}
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
 	 * </ul>
 	 */
 	Bean[] annotateBean() default {};
 
 	/**
-	 * Indirectly applies {@link Beanc @Beanc} annotations to constructors.
+	 * Dynamically applies {@link Beanc @Beanc} annotations to specified constructors.
 	 *
 	 * <p>
-	 * Provides an alternate approach for applying annotations to constructor annotations using the {@link Beanc#on() @Beanc.on}
-	 * annotation to specify the constructor names to apply the annotation to.
+	 * Provides an alternate approach for applying annotations using {@link Beanc#on() @Beanc.on} to specify the names
+	 * to apply the annotation to.
 	 *
 	 * <ul class='seealso'>
-	 * 	<li class='link'>{@doc juneau-marshall.ClassMethodAnnotations}
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
 	 * </ul>
 	 */
 	Beanc[] annotateBeanc() default {};
 
 	/**
-	 * Indirectly applies {@link Beanp @Beanp} annotations to classes/methods.
+	 * Dynamically applies {@link Beanp @Beanp} annotations to specified methods.
 	 *
 	 * <p>
-	 * Provides an alternate approach for applying annotations to classes/methods annotations using the {@link Beanp#on() @Beanp.on}
-	 * annotation to specify the class/method names to apply the annotation to.
+	 * Provides an alternate approach for applying annotations using {@link Beanp#on() @Beanp.on} to specify the names
+	 * to apply the annotation to.
 	 *
 	 * <ul class='seealso'>
-	 * 	<li class='link'>{@doc juneau-marshall.ClassMethodAnnotations}
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
 	 * </ul>
 	 */
 	Beanp[] annotateBeanp() default {};
 
 	/**
+	 * Dynamically applies {@link BeanIgnore @BeanIgnore} annotations to specified classes/methods/fields/constructors.
+	 *
+	 * <p>
+	 * Provides an alternate approach for applying annotations using {@link BeanIgnore#on() @BeanIgnore.on} to specify the names
+	 * to apply the annotation to.
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	BeanIgnore[] annotateBeanIgnore() default {};
+
+	/**
+	 * Dynamically applies {@link Example @Example} annotations to specified classes/methods/fields.
+	 *
+	 * <p>
+	 * Provides an alternate approach for applying annotations using {@link Example#on() @Example.on} to specify the names
+	 * to apply the annotation to.
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	Example[] annotateExample() default {};
+
+	/**
+	 * Dynamically applies {@link Name @Name} annotations to specified methods/fields.
+	 *
+	 * <p>
+	 * Provides an alternate approach for applying annotations using {@link Name#on() @Name.on} to specify the names
+	 * to apply the annotation to.
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	Name[] annotateName() default {};
+
+	/**
+	 * Dynamically applies {@link NameProperty @NameProperty} annotations to specified methods/fields.
+	 *
+	 * <p>
+	 * Provides an alternate approach for applying annotations using {@link NameProperty#on() @NameProperty.on} to specify the names
+	 * to apply the annotation to.
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	NameProperty[] annotateNameProperty() default {};
+
+	/**
+	 * Dynamically applies {@link ParentProperty @ParentProperty} annotations to specified methods/fields.
+	 *
+	 * <p>
+	 * Provides an alternate approach for applying annotations using {@link ParentProperty#on() @ParentProperty.on} to specify the names
+	 * to apply the annotation to.
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	ParentProperty[] annotateParentProperty() default {};
+
+	/**
+	 * Dynamically applies {@link Swap @Swap} annotations to specified classes/methods/fields.
+	 *
+	 * <p>
+	 * Provides an alternate approach for applying annotations using {@link Swap#on() @Swap.on} to specify the names
+	 * to apply the annotation to.
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	Swap[] annotateSwap() default {};
+
+	/**
+	 * Dynamically applies {@link URI @URI} annotations to specified classes/methods/fields.
+	 *
+	 * <p>
+	 * Provides an alternate approach for applying annotations using {@link URI#on() @URI.on} to specify the names
+	 * to apply the annotation to.
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
+	URI[] annotateURI() default {};
+
+	/**
 	 * Configuration property:  Minimum bean class visibility.
 	 *
 	 * <p>
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfigApply.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfigApply.java
index 06be70e..c78993c 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfigApply.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanConfigApply.java
@@ -172,6 +172,20 @@
 			psb.addTo(BEAN_annotations, a.annotateBeanp());
 		if (a.annotateBeanc().length > 0)
 			psb.addTo(BEAN_annotations, a.annotateBeanc());
+		if (a.annotateBeanIgnore().length > 0)
+			psb.addTo(BEAN_annotations, a.annotateBeanIgnore());
+		if (a.annotateExample().length > 0)
+			psb.addTo(BEAN_annotations, a.annotateExample());
+		if (a.annotateName().length > 0)
+			psb.addTo(BEAN_annotations, a.annotateName());
+		if (a.annotateNameProperty().length > 0)
+			psb.addTo(BEAN_annotations, a.annotateNameProperty());
+		if (a.annotateParentProperty().length > 0)
+			psb.addTo(BEAN_annotations, a.annotateParentProperty());
+		if (a.annotateURI().length > 0)
+			psb.addTo(BEAN_annotations, a.annotateURI());
+		if (a.annotateSwap().length > 0)
+			psb.addTo(BEAN_annotations, a.annotateSwap());
 	}
 
 	private Locale locale(String in) {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanIgnore.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanIgnore.java
index f9caeb4..b01afbd 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanIgnore.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/BeanIgnore.java
@@ -40,6 +40,49 @@
 @Retention(RUNTIME)
 @Inherited
 public @interface BeanIgnore {
+	/**
+	 * Dynamically apply this annotation to the specified classes/methods/fields/constructors.
+	 *
+	 * <p>
+	 * Used in conjunction with the {@link BeanConfig#annotateBeanIgnore()}.
+	 * It is ignored when the annotation is applied directly to classes/methods/fields/constructors.
+	 *
+	 * The valid pattern matches are:
+	 * <ul>
+	 * 	<li>Classes:
+	 * 		<ul>
+	 * 			<li>Fully qualified: <js>"com.foo.MyClass"</js>
+	 * 			<li>Fully qualified inner class: <js>"com.foo.MyClass$Inner1$Inner2"</js>
+	 * 			<li>Simple: <js>"MyClass"</js>
+	 * 			<li>Simple inner: <js>"MyClass$Inner1$Inner2"</js> or <js>"Inner1$Inner2"</js> or <js>"Inner2"</js>
+	 * 		</ul>
+	 * 	<li>Methods:
+	 * 		<ul>
+	 * 			<li>Fully qualified with args: <js>"com.foo.MyClass.myMethod(String,int)"</js> or <js>"com.foo.MyClass.myMethod(java.lang.String,int)"</js> or <js>"com.foo.MyClass.myMethod()"</js>
+	 * 			<li>Fully qualified: <js>"com.foo.MyClass.myMethod"</js>
+	 * 			<li>Simple with args: <js>"MyClass.myMethod(String,int)"</js> or <js>"MyClass.myMethod(java.lang.String,int)"</js> or <js>"MyClass.myMethod()"</js>
+	 * 			<li>Simple: <js>"MyClass.myMethod"</js>
+	 * 			<li>Simple inner class: <js>"MyClass$Inner1$Inner2.myMethod"</js> or <js>"Inner1$Inner2.myMethod"</js> or <js>"Inner2.myMethod"</js>
+	 * 		</ul>
+	 * 	<li>Fields:
+	 * 		<ul>
+	 * 			<li>Fully qualified: <js>"com.foo.MyClass.myField"</js>
+	 * 			<li>Simple: <js>"MyClass.muyField"</js>
+	 * 			<li>Simple inner class: <js>"MyClass$Inner1$Inner2.myField"</js> or <js>"Inner1$Inner2.myField"</js> or <js>"Inner2.myField"</js>
+	 * 		</ul>
+	 * 	<li>Constructors:
+	 * 		<ul>
+	 * 			<li>Fully qualified with args: <js>"com.foo.MyClass(String,int)"</js> or <js>"com.foo.MyClass(java.lang.String,int)"</js> or <js>"com.foo.MyClass()"</js>
+	 * 			<li>Simple with args: <js>"MyClass(String,int)"</js> or <js>"MyClass(java.lang.String,int)"</js> or <js>"MyClass()"</js>
+	 * 			<li>Simple inner class: <js>"MyClass$Inner1$Inner2()"</js> or <js>"Inner1$Inner2()"</js> or <js>"Inner2()"</js>
+	 * 		</ul>
+	 * 	<li>A comma-delimited list of anything on this list.
+	 * </ul>
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
 	String on() default "";
 }
 
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Beanc.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Beanc.java
index 2e4a65b..bec5ca5 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Beanc.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Beanc.java
@@ -52,20 +52,78 @@
 @Inherited
 public @interface Beanc {
 
+	/**
+	 * Dynamically apply this annotation to the specified constructors.
+	 *
+	 * <p>
+	 * Used in conjunction with the {@link BeanConfig#annotateBeanc()}.
+	 * It is ignored when the annotation is applied directly to constructors.
+	 *
+	 * <p>
+	 * The following example shows this annotation in use:
+	 * <p class='bpcode w800'>
+	 *		<jc>// Our read-only bean.</jc>
+	 *		<jk>public class</jk> Person {
+	 *			<jk>private final</jk> String <jf>name</jf>;
+	 *			<jk>private final int</jk> <jf>age</jf>;
+	 *
+	 *			<jk>public</jk> Person(String name, <jk>int</jk> age) {
+	 *				<jk>this</jk>.<jf>name</jf> = name;
+	 *				<jk>this</jk>.<jf>age</jf> = age;
+	 *			}
+	 *
+	 *			<jc>// Read only properties.</jc>
+	 *			<jc>// Getters, but no setters.</jc>
+	 *
+	 *			<jk>public</jk> String getName() {
+	 *				<jk>return</jk> <jf>name</jf>;
+	 *			}
+	 *
+	 *			<jk>public int</jk> getAge() {
+	 *				<jk>return</jk> <jf>age</jf>;
+	 *			}
+	 *		}
+	 *
+	 *		<ja>@BeanConfig</ja>(annotateBeanc=<ja>@Beanc</ja>(on="Person(String,int)", properties=<js>"name,age"</js>))
+	 *		public static class X {}
+	 * </p>
+	 * <p class='bpcode w800'>
+	 *		<jc>// Parsing into a read-only bean.</jc>
+	 *		String json = <js>"{name:'John Smith',age:45}"</js>;
+	 *		Person p = JsonParser.<jsf>DEFAULT</jsf>.builder().applyAnnotations(X.<jk>class</jk>).build().parse(json);
+	 *		String name = p.getName();  <jc>// "John Smith"</jc>
+	 *		<jk>int</jk> age = p.getAge();   <jc>// 45</jc>
+	 * </p>
+	 *
+	 * The valid pattern matches are:
+	 * <ul>
+	 * 	<li>Constructors:
+	 * 		<ul>
+	 * 			<li>Fully qualified with args: <js>"com.foo.MyClass(String,int)"</js> or <js>"com.foo.MyClass(java.lang.String,int)"</js> or <js>"com.foo.MyClass()"</js>
+	 * 			<li>Simple with args: <js>"MyClass(String,int)"</js> or <js>"MyClass(java.lang.String,int)"</js> or <js>"MyClass()"</js>
+	 * 			<li>Simple inner class: <js>"MyClass$Inner1$Inner2()"</js> or <js>"Inner1$Inner2()"</js> or <js>"Inner2()"</js>
+	 * 		</ul>
+	 * 	<li>A comma-delimited list of anything on this list.
+	 * </ul>
+	 *
+	 * <ul class='seealso'>
+	 * 	<li class='link'>{@doc juneau-marshall.DynamicallyAppliedAnnotations}
+	 * </ul>
+	 */
 	String on() default "";
 
 	/**
 	 * The names of the properties of the constructor arguments.
+	 *
 	 * <p>
-	 *	The {@link org.apache.juneau.annotation.Beanc @Beanc} annotation is used to
-	 *	map constructor arguments to property names on bean with read-only properties.
-	 * 	<br>Since method parameter names are lost during compilation, this annotation essentially redefines
-	 *	them so that they are available at runtime.
-	 *	</p>
-	 * 	<p>
-	 *	The definition of a read-only bean is a bean with properties with only getters, like shown below:
-	 *	</p>
-	 *	<p class='bpcode w800'>
+	 * The {@link org.apache.juneau.annotation.Beanc @Beanc} annotation is used to map constructor arguments to property
+	 * names on bean with read-only properties.
+	 * <br>Since method parameter names are lost during compilation, this annotation essentially redefines them so that
+	 * they are available at runtime.
+	 *
+	 * <p>
+	 * The definition of a read-only bean is a bean with properties with only getters, like shown below:
+	 * <p class='bpcode w800'>
 	 *		<jc>// Our read-only bean.</jc>
 	 *		<jk>public class</jk> Person {
 	 *			<jk>private final</jk> String <jf>name</jf>;
@@ -88,14 +146,14 @@
 	 *				<jk>return</jk> <jf>age</jf>;
 	 *			}
 	 *		}
-	 *	</p>
-	 *	<p class='bpcode w800'>
+	 * </p>
+	 * <p class='bpcode w800'>
 	 *		<jc>// Parsing into a read-only bean.</jc>
 	 *		String json = <js>"{name:'John Smith',age:45}"</js>;
 	 *		Person p = JsonParser.<jsf>DEFAULT</jsf>.parse(json);
 	 *		String name = p.getName();  <jc>// "John Smith"</jc>
 	 *		<jk>int</jk> age = p.getAge();   <jc>// 45</jc>
-	 *	</p>
+	 * </p>
 	 * <p>
 	 * 	Note that the {@link Name @Name} annotation can also be used to identify bean property names on constructor
 	 * 	arguments.  If neither this annotation or {@link Name @Name} is used, then we try to get the property names
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Swap.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Swap.java
index 4c44af8..b02edc1 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Swap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/annotation/Swap.java
@@ -40,6 +40,8 @@
 @Inherited
 public @interface Swap {
 
+	String on() default "";
+
 	/**
 	 * The {@link PojoSwap} and {@link Surrogate} class.
 	 *
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/FieldInfo.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/FieldInfo.java
index 3a39b0a..9cce182 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/FieldInfo.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/reflect/FieldInfo.java
@@ -122,6 +122,17 @@
 		return f.isAnnotationPresent(a);
 	}
 
+	/**
+	 * Returns <jk>true</jk> if the specified annotation is present.
+	 *
+	 * @param a The annotation to check for.
+	 * @param mp The meta provider for looking up annotations on reflection objects (classes, methods, fields, constructors).
+	 * @return <jk>true</jk> if the specified annotation is present.
+	 */
+	public boolean hasAnnotation(Class<? extends Annotation> a, MetaProvider mp) {
+		return mp.getAnnotation(a, f) != null;
+	}
+
 	//-----------------------------------------------------------------------------------------------------------------
 	// Characteristics
 	//-----------------------------------------------------------------------------------------------------------------
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoListSwap.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoListSwap.java
index 2602c4f..23d06c1 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoListSwap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoListSwap.java
@@ -82,27 +82,28 @@
 	/**
 	 * Look for constructors and methods on this class and construct a dynamic swap if it's possible to do so.
 	 *
+	 * @param bc The bean context to use for looking up annotations.
 	 * @param ci The class to try to constructor a dynamic swap on.
 	 * @return A POJO swap instance, or <jk>null</jk> if one could not be created.
 	 */
 	@SuppressWarnings({ "rawtypes" })
-	public static PojoSwap<?,?> find(ClassInfo ci) {
+	public static PojoSwap<?,?> find(BeanContext bc, ClassInfo ci) {
 
-		if (shouldIgnore(ci))
+		if (shouldIgnore(bc, ci))
 			return null;
 
 		// Find swap() method if present.
 		for (MethodInfo m : ci.getPublicMethods()) {
-			if (isSwapMethod(m)) {
+			if (isSwapMethod(bc, m)) {
 
 				ClassInfo rt = m.getReturnType();
 
 				for (MethodInfo m2 : ci.getPublicMethods())
-					if (isUnswapMethod(m2, ci, rt))
+					if (isUnswapMethod(bc, m2, ci, rt))
 						return new AutoListSwap(ci, m, m2, null);
 
 				for (ConstructorInfo cs : ci.getPublicConstructors())
-					if (isUnswapConstructor(cs, rt))
+					if (isUnswapConstructor(bc, cs, rt))
 						return new AutoListSwap(ci, m, null, cs);
 
 				return new AutoListSwap(ci, m, null, null);
@@ -112,37 +113,37 @@
 		return null;
 	}
 
-	private static boolean shouldIgnore(ClassInfo ci) {
+	private static boolean shouldIgnore(BeanContext bc, ClassInfo ci) {
 		return
-			ci.hasAnnotation(BeanIgnore.class)
+			bc.hasAnnotation(BeanIgnore.class, ci)
 			|| ci.isNonStaticMemberClass();
 	}
 
-	private static boolean isSwapMethod(MethodInfo mi) {
+	private static boolean isSwapMethod(BeanContext bc, MethodInfo mi) {
 		return
 			mi.isNotDeprecated()
 			&& mi.isNotStatic()
 			&& mi.hasName(SWAP_METHOD_NAMES)
 			&& mi.hasReturnTypeParent(List.class)
 			&& mi.hasFuzzyParamTypes(BeanSession.class)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapMethod(MethodInfo mi, ClassInfo ci, ClassInfo rt) {
+	private static boolean isUnswapMethod(BeanContext bc, MethodInfo mi, ClassInfo ci, ClassInfo rt) {
 		return
 			mi.isNotDeprecated()
 			&& mi.isStatic()
 			&& mi.hasName(UNSWAP_METHOD_NAMES)
 			&& mi.hasFuzzyParamTypes(BeanSession.class, rt.inner())
 			&& mi.hasReturnTypeParent(ci)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapConstructor(ConstructorInfo cs, ClassInfo rt) {
+	private static boolean isUnswapConstructor(BeanContext bc, ConstructorInfo cs, ClassInfo rt) {
 		return
 			cs.isNotDeprecated()
 			&& cs.hasParamTypeParents(rt)
-			&& ! cs.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, cs);
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoMapSwap.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoMapSwap.java
index 53dace1..ba1b813 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoMapSwap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoMapSwap.java
@@ -82,27 +82,28 @@
 	/**
 	 * Look for constructors and methods on this class and construct a dynamic swap if it's possible to do so.
 	 *
+	 * @param bc The bean context to use for looking up annotations.
 	 * @param ci The class to try to constructor a dynamic swap on.
 	 * @return A POJO swap instance, or <jk>null</jk> if one could not be created.
 	 */
 	@SuppressWarnings({ "rawtypes" })
-	public static PojoSwap<?,?> find(ClassInfo ci) {
+	public static PojoSwap<?,?> find(BeanContext bc, ClassInfo ci) {
 
-		if (shouldIgnore(ci))
+		if (shouldIgnore(bc, ci))
 			return null;
 
 		// Find swap() method if present.
 		for (MethodInfo m : ci.getPublicMethods()) {
-			if (isSwapMethod(m)) {
+			if (isSwapMethod(bc, m)) {
 
 				ClassInfo rt = m.getReturnType();
 
 				for (MethodInfo m2 : ci.getPublicMethods())
-					if (isUnswapMethod(m2, ci, rt))
+					if (isUnswapMethod(bc, m2, ci, rt))
 						return new AutoMapSwap(ci, m, m2, null);
 
 				for (ConstructorInfo cs : ci.getPublicConstructors())
-					if (isUnswapConstructor(cs, rt))
+					if (isUnswapConstructor(bc, cs, rt))
 						return new AutoMapSwap(ci, m, null, cs);
 
 				return new AutoMapSwap(ci, m, null, null);
@@ -112,37 +113,37 @@
 		return null;
 	}
 
-	private static boolean shouldIgnore(ClassInfo ci) {
+	private static boolean shouldIgnore(BeanContext bc, ClassInfo ci) {
 		return
-			ci.hasAnnotation(BeanIgnore.class)
+			bc.hasAnnotation(BeanIgnore.class, ci)
 			|| ci.isNonStaticMemberClass();
 	}
 
-	private static boolean isSwapMethod(MethodInfo mi) {
+	private static boolean isSwapMethod(BeanContext bc, MethodInfo mi) {
 		return
 			mi.isNotDeprecated()
 			&& mi.isNotStatic()
 			&& mi.hasName(SWAP_METHOD_NAMES)
 			&& mi.hasReturnTypeParent(Map.class)
 			&& mi.hasFuzzyParamTypes(BeanSession.class)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapMethod(MethodInfo mi, ClassInfo ci, ClassInfo rt) {
+	private static boolean isUnswapMethod(BeanContext bc, MethodInfo mi, ClassInfo ci, ClassInfo rt) {
 		return
 			mi.isNotDeprecated()
 			&& mi.isStatic()
 			&& mi.hasName(UNSWAP_METHOD_NAMES)
 			&& mi.hasFuzzyParamTypes(BeanSession.class, rt.inner())
 			&& mi.hasReturnTypeParent(ci)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapConstructor(ConstructorInfo cs, ClassInfo rt) {
+	private static boolean isUnswapConstructor(BeanContext bc, ConstructorInfo cs, ClassInfo rt) {
 		return
 			cs.isNotDeprecated()
 			&& cs.hasParamTypeParents(rt)
-			&& ! cs.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, cs);
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoNumberSwap.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoNumberSwap.java
index 80ae1cc..ebb89d6 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoNumberSwap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoNumberSwap.java
@@ -105,27 +105,28 @@
 	/**
 	 * Look for constructors and methods on this class and construct a dynamic swap if it's possible to do so.
 	 *
+	 * @param bc The bean context to use for looking up annotations.
 	 * @param ci The class to try to constructor a dynamic swap on.
 	 * @return A POJO swap instance, or <jk>null</jk> if one could not be created.
 	 */
 	@SuppressWarnings({ "rawtypes" })
-	public static PojoSwap<?,?> find(ClassInfo ci) {
+	public static PojoSwap<?,?> find(BeanContext bc, ClassInfo ci) {
 
-		if (shouldIgnore(ci))
+		if (shouldIgnore(bc, ci))
 			return null;
 
 		// Find swap() method if present.
 		for (MethodInfo m : ci.getPublicMethods()) {
-			if (isSwapMethod(m)) {
+			if (isSwapMethod(bc, m)) {
 
 				ClassInfo rt = m.getReturnType();
 
 				for (MethodInfo m2 : ci.getPublicMethods())
-					if (isUnswapMethod(m2, ci, rt))
+					if (isUnswapMethod(bc, m2, ci, rt))
 						return new AutoNumberSwap(ci, m, m2, null);
 
 				for (ConstructorInfo cs : ci.getPublicConstructors())
-					if (isUnswapConstructor(cs, rt))
+					if (isUnswapConstructor(bc, cs, rt))
 						return new AutoNumberSwap(ci, m, null, cs);
 
 				return new AutoNumberSwap(ci, m, null, null);
@@ -135,15 +136,15 @@
 		return null;
 	}
 
-	private static boolean shouldIgnore(ClassInfo ci) {
+	private static boolean shouldIgnore(BeanContext bc, ClassInfo ci) {
 		return
-			ci.hasAnnotation(BeanIgnore.class)
+			bc.hasAnnotation(BeanIgnore.class, ci)
 			|| ci.isNonStaticMemberClass()
 			|| ci.isPrimitive()
 			|| ci.isChildOf(Number.class);
 	}
 
-	private static boolean isSwapMethod(MethodInfo mi) {
+	private static boolean isSwapMethod(BeanContext bc, MethodInfo mi) {
 		ClassInfo rt = mi.getReturnType();
 		return
 			mi.isNotDeprecated()
@@ -151,24 +152,24 @@
 			&& (rt.isChildOf(Number.class) || (rt.isPrimitive() && rt.isAny(int.class, short.class, long.class, float.class, double.class, byte.class)))
 			&& mi.hasName(SWAP_METHOD_NAMES)
 			&& mi.hasFuzzyParamTypes(BeanSession.class)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapMethod(MethodInfo mi, ClassInfo ci, ClassInfo rt) {
+	private static boolean isUnswapMethod(BeanContext bc, MethodInfo mi, ClassInfo ci, ClassInfo rt) {
 		return
 			mi.isNotDeprecated()
 			&& mi.isStatic()
 			&& mi.hasName(UNSWAP_METHOD_NAMES)
 			&& mi.hasFuzzyParamTypes(BeanSession.class, rt.inner())
 			&& mi.hasReturnTypeParent(ci)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapConstructor(ConstructorInfo cs, ClassInfo rt) {
+	private static boolean isUnswapConstructor(BeanContext bc, ConstructorInfo cs, ClassInfo rt) {
 		return
 			cs.isNotDeprecated()
 			&& cs.hasParamTypeParents(rt)
-			&& ! cs.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, cs);
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoObjectSwap.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoObjectSwap.java
index a55f700..aea43c4 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoObjectSwap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/AutoObjectSwap.java
@@ -84,27 +84,28 @@
 	/**
 	 * Inspects the specified class and returns a swap of this type if possible.
 	 *
+	 * @param bc The bean context to use for looking up annotations.
 	 * @param ci The class to return a swap on.
 	 * @return A POJO swap instance, or <jk>null</jk> if one could not be created.
 	 */
 	@SuppressWarnings({ "rawtypes" })
-	public static PojoSwap<?,?> find(ClassInfo ci) {
+	public static PojoSwap<?,?> find(BeanContext bc, ClassInfo ci) {
 
-		if (shouldIgnore(ci))
+		if (shouldIgnore(bc, ci))
 			return null;
 
 		// Find swap() method if present.
 		for (MethodInfo m : ci.getPublicMethods()) {
-			if (isSwapMethod(m)) {
+			if (isSwapMethod(bc, m)) {
 
 				ClassInfo rt = m.getReturnType();
 
 				for (MethodInfo m2 : ci.getPublicMethods())
-					if (isUnswapMethod(m2, ci, rt))
+					if (isUnswapMethod(bc, m2, ci, rt))
 						return new AutoObjectSwap(ci, m, m2, null);
 
 				for (ConstructorInfo cs : ci.getPublicConstructors())
-					if (isUnswapConstructor(cs, rt))
+					if (isUnswapConstructor(bc, cs, rt))
 						return new AutoObjectSwap(ci, m, null, cs);
 
 				return new AutoObjectSwap(ci, m, null, null);
@@ -114,36 +115,36 @@
 		return null;
 	}
 
-	private static boolean shouldIgnore(ClassInfo ci) {
+	private static boolean shouldIgnore(BeanContext bc, ClassInfo ci) {
 		return
-			ci.hasAnnotation(BeanIgnore.class)
+			bc.hasAnnotation(BeanIgnore.class, ci)
 			|| ci.isNonStaticMemberClass();
 	}
 
-	private static boolean isSwapMethod(MethodInfo mi) {
+	private static boolean isSwapMethod(BeanContext bc, MethodInfo mi) {
 		return
 			mi.isNotDeprecated()
 			&& mi.isNotStatic()
 			&& mi.hasName(SWAP_METHOD_NAMES)
 			&& mi.hasFuzzyParamTypes(BeanSession.class)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapMethod(MethodInfo mi, ClassInfo ci, ClassInfo rt) {
+	private static boolean isUnswapMethod(BeanContext bc, MethodInfo mi, ClassInfo ci, ClassInfo rt) {
 		return
 			mi.isNotDeprecated()
 			&& mi.isStatic()
 			&& mi.hasName(UNSWAP_METHOD_NAMES)
 			&& mi.hasFuzzyParamTypes(BeanSession.class, rt.inner())
 			&& mi.hasReturnTypeParent(ci)
-			&& ! mi.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, mi);
 	}
 
-	private static boolean isUnswapConstructor(ConstructorInfo cs, ClassInfo rt) {
+	private static boolean isUnswapConstructor(BeanContext bc, ConstructorInfo cs, ClassInfo rt) {
 		return
 			cs.isNotDeprecated()
 			&& cs.hasParamTypeParents(rt)
-			&& ! cs.hasAnnotation(BeanIgnore.class);
+			&& ! bc.hasAnnotation(BeanIgnore.class, cs);
 	}
 
 	//------------------------------------------------------------------------------------------------------------------
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/BuilderSwap.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/BuilderSwap.java
index 35c0674..d6269c2 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/BuilderSwap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/transform/BuilderSwap.java
@@ -175,19 +175,20 @@
 	/**
 	 * Creates a BuilderSwap from the specified POJO class if it has one.
 	 *
+	 * @param bc The bean context to use to look up annotations.
 	 * @param pojoClass The POJO class to check.
 	 * @param cVis Minimum constructor visibility.
 	 * @param mVis Minimum method visibility.
 	 * @return A new swap instance, or <jk>null</jk> if class didn't have a builder class.
 	 */
 	@SuppressWarnings("rawtypes")
-	public static BuilderSwap<?,?> findSwapFromPojoClass(Class<?> pojoClass, Visibility cVis, Visibility mVis) {
+	public static BuilderSwap<?,?> findSwapFromPojoClass(BeanContext bc, Class<?> pojoClass, Visibility cVis, Visibility mVis) {
 		Class<?> builderClass = null;
 		MethodInfo pojoCreateMethod, builderCreateMethod;
 		ConstructorInfo pojoConstructor = null;
 		ConstructorInfo builderConstructor;
 
-		org.apache.juneau.annotation.Builder b = pojoClass.getAnnotation(org.apache.juneau.annotation.Builder.class);
+		org.apache.juneau.annotation.Builder b = bc.getAnnotation(org.apache.juneau.annotation.Builder.class, pojoClass);
 
 		if (b != null && b.value() != Null.class)
 			builderClass = b.value();
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/utils/ReflectionMap.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/utils/ReflectionMap.java
index 4b803b9..d0bbc17 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/utils/ReflectionMap.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/utils/ReflectionMap.java
@@ -52,9 +52,9 @@
  * 			<li>Simple with args: <js>"MyClass(String,int)"</js> or <js>"MyClass(java.lang.String,int)"</js> or <js>"MyClass()"</js>
  * 			<li>Simple inner class: <js>"MyClass$Inner1$Inner2()"</js> or <js>"Inner1$Inner2()"</js> or <js>"Inner2()"</js>
  * 		</ul>
+ * 	<li>A comma-delimited list of anything on this list.
  * </ul>
  *
- *
  * @param <V> The type of object in this map.
  */
 public class ReflectionMap<V> {