Examples of groovy.lang.ExpandoMetaClass

groovy.lang.ExpandoMetaClass
nes or replaces instance method: metaClass.myMethod = { args -> } // defines a new instance method metaClass.myMethod << { args -> } // creates multiple overloaded methods of the same name metaClass.myMethod << { String s -> } << { Integer i -> } // defines or replaces a static method with the 'static' qualifier metaClass.'static'.myMethod = { args -> } // defines a new static method with the 'static' qualifier metaClass.'static'.myMethod << { args -> } // defines a new constructor metaClass.constructor << { String arg -> } // defines or replaces a constructor metaClass.constructor = { String arg -> } // defines a new property with an initial value of "blah" metaClass.myProperty = "blah" By default methods are only allowed to be added before initialize() is called. In other words you create a new ExpandoMetaClass, add some methods and then call initialize(). If you attempt to add new methods after initialize() has been called an error will be thrown. This is to ensure that the MetaClass can operate appropriately in multi threaded environments as it forces you to do all method additions at the beginning, before using the MetaClass. If you need more fine grained control of how a method is matched you can use DynamicMethodsMetaClass WARNING: This MetaClass uses a thread-bound ThreadLocal instance to store and retrieve properties. In addition properties stored use soft references so they are both bound by the life of the Thread and by the soft references. The implication here is you should NEVER use dynamic properties if you want their values to stick around for long periods because as soon as the JVM is running low on memory or the thread dies they will be garbage collected. @author Graeme Rocher @since 1.1

            } else {
                throw new GroovyRuntimeException("Can't mixin methods to meta class: " + self);
            }
        }


        ExpandoMetaClass mc = (ExpandoMetaClass) self;


        List<MetaMethod> arr = new ArrayList<MetaMethod>();
        for (Class categoryClass : categoryClasses) {


            final CachedClass cachedCategoryClass = ReflectionCache.getCachedClass(categoryClass);
            final MixinInMetaClass mixin = new MixinInMetaClass(mc, cachedCategoryClass);


            final MetaClass metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(categoryClass);
            final List<MetaProperty> propList = metaClass.getProperties();
            for (MetaProperty prop : propList)
                if (self.getMetaProperty(prop.getName()) == null) {
                    mc.registerBeanProperty(prop.getName(), new MixinInstanceMetaProperty(prop, mixin));
                }


            for (MetaProperty prop : cachedCategoryClass.getFields())
                if (self.getMetaProperty(prop.getName()) == null) {
                    mc.registerBeanProperty(prop.getName(), new MixinInstanceMetaProperty(prop, mixin));
                }


            for (MetaMethod method : metaClass.getMethods()) {
                final int mod = method.getModifiers();


                if (!Modifier.isPublic(mod))
                    continue;


                if (method instanceof CachedMethod && ((CachedMethod) method).getCachedMethod().isSynthetic())
                    continue;


                if (Modifier.isStatic(mod)) {
                    if (method instanceof CachedMethod)
                        staticMethod(self, arr, (CachedMethod) method);
                } else if (method.getDeclaringClass().getTheClass() != Object.class || method.getName().equals("toString")) {
//                    if (self.pickMethod(method.getName(), method.getNativeParameterTypes()) == null) {
                    final MixinInstanceMetaMethod metaMethod = new MixinInstanceMetaMethod(method, mixin);
                    arr.add(metaMethod);
//                    }
                }
            }
        }


        for (Object res : arr) {
            final MetaMethod metaMethod = (MetaMethod) res;
            if (metaMethod.getDeclaringClass().isAssignableFrom(selfClass))
                mc.registerInstanceMethod(metaMethod);
            else {
                mc.registerSubclassInstanceMethod(metaMethod);
            }
        }
    }

View Full Code Here

    public void doDynamicMethods() {
        checkInitialised();
        Class<?>[] allClasses = application.getAllClasses();
        if (allClasses != null) {
            for (Class<?> c : allClasses) {
                ExpandoMetaClass emc = new ExpandoMetaClass(c, true, true);
                emc.initialize();
            }
            for (GrailsPlugin plugin : pluginList) {
                plugin.doWithDynamicMethods(applicationContext);
            }
        }

View Full Code Here

        else {


            if (cls != null) {
                MetaClassRegistry registry = GroovySystem.getMetaClassRegistry();
                registry.removeMetaClass(cls);
                ExpandoMetaClass newMc = new ExpandoMetaClass(cls, true, true);
                newMc.initialize();
                registry.setMetaClass(cls, newMc);


                Enhanced en = AnnotationUtils.findAnnotation(cls,Enhanced.class);
                if (en != null) {
                    Class<?>[] mixinClasses = en.mixins();

View Full Code Here

    public static ExpandoMetaClass getExpandoMetaClass(Class<?> aClass) {
        MetaClassRegistry registry = getRegistry();


        MetaClass mc = registry.getMetaClass(aClass);
        if (mc instanceof ExpandoMetaClass) {
            ExpandoMetaClass emc = (ExpandoMetaClass) mc;
            registry.setMetaClass(aClass, emc); // make permanent
            return emc;
        }


        registry.removeMetaClass(aClass);
        mc = registry.getMetaClass(aClass);
        if (mc instanceof ExpandoMetaClass) {
            return (ExpandoMetaClass)mc;
        }


        ExpandoMetaClass emc = new ExpandoMetaClass(aClass, true, true);
        emc.initialize();
        registry.setMetaClass(aClass, emc);
        return emc;
    }

View Full Code Here

        MetaClassRegistry registry = getRegistry();


        MetaClass oldMetaClass = registry.getMetaClass(fromClass);


        AdaptingMetaClass adapter = null;
        ExpandoMetaClass emc;


        if (oldMetaClass instanceof AdaptingMetaClass) {
            adapter = ((AdaptingMetaClass)oldMetaClass);
            emc = (ExpandoMetaClass)adapter.getAdaptee();
            if (LOG.isDebugEnabled()) {
                LOG.debug("Obtained adapted MetaClass ["+emc+"] from AdapterMetaClass instance ["+adapter+"]");
            }


            if (removeSource) {
                registry.removeMetaClass(fromClass);
            }
        }
        else {
            emc = (ExpandoMetaClass)oldMetaClass;
            if (LOG.isDebugEnabled()) {
                LOG.debug("No adapter MetaClass found, using original ["+emc+"]");
            }
        }


        ExpandoMetaClass replacement = new ExpandoMetaClass(toClass, true, true);


        for (Object obj : emc.getExpandoMethods()) {
            if (obj instanceof ClosureInvokingMethod) {
                ClosureInvokingMethod cim = (ClosureInvokingMethod) obj;
                Closure callable = cim.getClosure();
                if (!cim.isStatic()) {
                    replacement.setProperty(cim.getName(), callable);
                }
                else {
                    ((GroovyObject)replacement.getProperty(ExpandoMetaClass.STATIC_QUALIFIER)).setProperty(cim.getName(),callable);
                }
            }
        }


        for (Object o : emc.getExpandoProperties()) {
            if (o instanceof ThreadManagedMetaBeanProperty) {
                ThreadManagedMetaBeanProperty mbp = (ThreadManagedMetaBeanProperty)o;
                replacement.setProperty(mbp.getName(), mbp.getInitialValue());
            }
        }
        replacement.initialize();


        if (adapter == null) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Adding MetaClass for class ["+toClass+"] MetaClass ["+replacement+"]");
            }

View Full Code Here

  public void intercept(IMethodInvocation invocation) throws Throwable {
    MetaClassRegistry registry = GroovySystem.getMetaClassRegistry();


    for (Class<?> clazz : classes) {
      originalMetaClasses.add(registry.getMetaClass(clazz));
      MetaClass temporaryMetaClass = new ExpandoMetaClass(clazz, true, true);
      temporaryMetaClass.initialize();
      registry.setMetaClass(clazz, temporaryMetaClass);
    }


    try {
      invocation.proceed();

View Full Code Here

TOP

Related Classes of groovy.lang.ExpandoMetaClass

grails.util.GrailsMetaClassUtils

org.codehaus.groovy.reflection.CachedClass

org.codehaus.groovy.reflection.MixinInMetaClass

org.codehaus.groovy.runtime.callsite.ConstructorMetaMethodSite

org.codehaus.groovy.runtime.callsite.PogoMetaClassSite

org.codehaus.groovy.runtime.callsite.PojoMetaClassSite

org.codehaus.groovy.runtime.callsite.StaticMetaClassSite

org.codehaus.groovy.runtime.DefaultCachedMethodKey

org.codehaus.groovy.runtime.metaclass.ClosureMetaMethod

org.codehaus.groovy.runtime.metaclass.ClosureStaticMetaMethod

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.