Examples of net.sf.cglib.proxy.Enhancer$EnhancerKey

net.sf.cglib.proxy.Enhancer
Internal interface, only public due to ClassLoader issues.

   * Construct default instances using the CGLIB enhancer object instead.
   * @param enhancer - a CGLIB enhancer to use.
   * @return A default instance generator that uses the CGLIB enhancer.
   */
  public DefaultInstances forEnhancer(Enhancer enhancer) {
    final Enhancer ex = enhancer;
    
    return new DefaultInstances(this) {
      @SuppressWarnings("unchecked")
      @Override
      protected <T> T createInstance(Class<T> type, Constructor<T> constructor, Class<?>[] types, Object[] params) {
        // Use the enhancer instead
        return (T) ex.create(types, params);
      }
    };
  }

View Full Code Here

    this.modifierRest = new WritePacketModifier(reporter, false);
  }
  
  private Class<?> createProxyClass(int packetId) {
    // Construct the proxy object
    Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
    
    // Attempt to share callback filter 
    if (filter == null) {
      filter = new CallbackFilter() {
        @Override
        public int accept(Method method) {
          // Skip methods defined in Object
          if (WRITE_PACKET.isMatch(MethodInfo.fromMethod(method), null)) {
            writePacketIntercepted = true;
            return 0;
          } else {
            return 1;
          }
        }
      };
    }
    
    // Subclass the generic packet class
    ex.setSuperclass(MinecraftReflection.getPacketClass());
    ex.setCallbackFilter(filter);
    ex.setUseCache(false);
    
    ex.setCallbackTypes( new Class[] { WritePacketModifier.class, WritePacketModifier.class });
    Class<?> proxyClass = ex.createClass();
    
    // Register write modifiers too
    Enhancer.registerStaticCallbacks(proxyClass, new Callback[] { modifierWrite, modifierRest });


    if (proxyClass != null) {

View Full Code Here

    final int packetID = type.getLegacyId();
    
    if (hasPacketHandler(type))
      return false;
    
    Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
    
    // Unfortunately, we can't easily distinguish between these two functions:
    //   * Object lookup(int par1)
    //   * Object removeObject(int par1)
    
    // So, we'll use the classMapToInt registry instead.
    Map<Integer, Class> overwritten = PacketRegistry.getOverwrittenPackets();
    Map<Integer, Class> previous = PacketRegistry.getPreviousPackets();
    Map<Class, Integer> registry = PacketRegistry.getPacketToID();
    Class old = PacketRegistry.getPacketClassFromType(type);
    
    // If this packet is not known
    if (old == null) {
      throw new IllegalStateException("Packet ID " + type + " is not a valid packet type in this version.");
    }
    // Check for previous injections
    if (Factory.class.isAssignableFrom(old)) {
      throw new IllegalStateException("Packet " + type + " has already been injected.");
    }
    
    if (filter == null) {
      readPacketIntercepted = false;
      
      filter = new CallbackFilter() {
        @Override
        public int accept(Method method) {
          // Skip methods defined in Object
          if (method.getDeclaringClass().equals(Object.class)) {
            return 0;
          } else if (READ_PACKET.isMatch(MethodInfo.fromMethod(method), null)) {
            readPacketIntercepted = true;
            return 1;
          } else {
            return 2;
          }
        }
      };
    }
    
    // Subclass the specific packet class
    ex.setSuperclass(old);
    ex.setCallbackFilter(filter);
    ex.setCallbackTypes(new Class<?>[] { NoOp.class, ReadPacketModifier.class, ReadPacketModifier.class });
    Class proxy = ex.createClass();
    
    // Create the proxy handlers
    ReadPacketModifier modifierReadPacket = new ReadPacketModifier(packetID, this, reporter, true);
    ReadPacketModifier modifierRest = new ReadPacketModifier(packetID, this, reporter, false);

View Full Code Here

  /**
   * Create a new CGLib enhancer.
   * @return The new enhancer.
   */
  public Enhancer createEnhancer() {
    Enhancer enhancer = new Enhancer();
    enhancer.setClassLoader(loader);
    return enhancer;
  }

View Full Code Here

    //      public int size() {
    //         return -super.size();
    //      }
    //   ect.
    //   }
    Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
    ex.setSuperclass(MinecraftReflection.getPacketClass());
    ex.setInterfaces(new Class[] { FakePacket.class } );
    ex.setUseCache(true);
    ex.setCallbackType(InvertedIntegerCallback.class);


    Class<?> proxyClass = ex.createClass();
    Enhancer.registerCallbacks(proxyClass, new Callback[] { callback });
    
    try {
      // Temporarily associate the fake packet class
      invoker.registerPacketClass(proxyClass, type.getLegacyId());

View Full Code Here

          }
        };
      }
      
      // Create our proxy object
      Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
      ex.setSuperclass(networkInterface);
      ex.setCallbacks(new Callback[] { queueFilter, dispatch });
      ex.setCallbackFilter(callbackFilter);
      
      // Inject it, if we can.
      networkManagerRef.setValue(ex.create());
    }
  }

View Full Code Here

   */
  private static void initializePacket() {
    // Initialize the methods
    if (packetReadByteBuf == null || packetWriteByteBuf == null) {
      // This object will allow us to detect which methods were called
      Enhancer enhancer = EnhancerFactory.getInstance().createEnhancer();
      enhancer.setSuperclass(MinecraftReflection.getPacketDataSerializerClass());
      enhancer.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable {
          if (method.getName().contains("read"))
            throw new ReadMethodException();
          if (method.getName().contains("write"))
            throw new WriteMethodException();
          return proxy.invokeSuper(obj, args);
        }
      });
      
      // Create our proxy object
      Object javaProxy = enhancer.create(
        new Class<?>[] { ByteBuf.class }, 
        new Object[]   { UnpooledByteBufAllocator.DEFAULT.buffer() }
      );
      
      Object lookPacket = new PacketContainer(PacketType.Play.Client.BLOCK_PLACE).getHandle();

View Full Code Here

      
      // Find the register event method
      Method registerEvent = FuzzyReflection.fromObject(manager).getMethodByParameters("registerEvent", 
          eventTypes, Listener.class, eventPriority, Plugin.class);
      
      Enhancer playerLow = EnhancerFactory.getInstance().createEnhancer();
      Enhancer playerEx = EnhancerFactory.getInstance().createEnhancer();
      Enhancer serverEx = EnhancerFactory.getInstance().createEnhancer();
      
      playerLow.setSuperclass(playerListener);
      playerLow.setClassLoader(classLoader);
      playerLow.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable {
          // Must have a parameter
          if (args.length == 1) {
            Object event = args[0];


            if (event instanceof PlayerJoinEvent) {
              onPrePlayerJoin((PlayerJoinEvent) event);
            }
          }
          return null;
        }
      });
      
      playerEx.setSuperclass(playerListener);
      playerEx.setClassLoader(classLoader);
      playerEx.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
          if (args.length == 1) {
            Object event = args[0];
            
            // Check for the correct event
            if (event instanceof PlayerJoinEvent) {
              onPlayerJoin((PlayerJoinEvent) event);
            } else if (event instanceof PlayerQuitEvent) {
              onPlayerQuit((PlayerQuitEvent) event);
            }
          }
          return null;
        }
      });
      
      serverEx.setSuperclass(serverListener);
      serverEx.setClassLoader(classLoader);
      serverEx.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
          // Must have a parameter
          if (args.length == 1) {
            Object event = args[0];
            
            if (event instanceof PluginDisableEvent)
              onPluginDisabled((PluginDisableEvent) event, plugin);
          }
          return null;
        }
      });
      
      // Create our listener
      Object playerProxyLow = playerLow.create();
      Object playerProxy = playerEx.create();
      Object serverProxy = serverEx.create();
      
      registerEvent.invoke(manager, playerJoinType, playerProxyLow, priorityLowest, plugin);
      registerEvent.invoke(manager, playerJoinType, playerProxy, priorityMonitor, plugin);
      registerEvent.invoke(manager, playerQuitType, playerProxy, priorityMonitor, plugin);
      registerEvent.invoke(manager, pluginDisabledType, serverProxy, priorityMonitor, plugin);

View Full Code Here

    };
    
    // Don't care for everything else
    callbacks[2] = NoOp.INSTANCE;
    
    Enhancer enhancer = EnhancerFactory.getInstance().createEnhancer();
    enhancer.setSuperclass(getSpigotListenerClass());
    enhancer.setCallbacks(callbacks);
    enhancer.setCallbackFilter(new CallbackFilter() {
      @Override
      public int accept(Method method) {
        // We'll be pretty stringent
        if (matchMethod("packetReceived", method)) {
          found[0] = true;
          return 0;
        } else if (matchMethod("packetQueued", method)) {
          found[1] = true;
          return 1;
        } else {
          found[2] = true;
          return 2;
        }
      }
    });
    dynamicListener = enhancer.create();
    
    // Verify methods
    if (!found[0])
      throw new IllegalStateException("Unable to find a valid packet receiver in Spigot.");
    if (!found[1])

View Full Code Here

     */
    public Object create(Class realMpClass, MessageProcessorId id, Map<String, String> attributes, String fileName, String lineNumber)
    {
        try
        {
            Enhancer e = createEnhancer(realMpClass, id, attributes, fileName, lineNumber);
            return e.create();
        }
        catch (Throwable e)
        {
            logger.warn("The message processor " + id.getFullName() + " could not be mocked");
            try

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of net.sf.cglib.proxy.Enhancer$EnhancerKey

bitronix.tm.resource.jdbc.proxy.JdbcCglibProxyFactory

br.com.caelum.vraptor.proxy.DefaultProxifier

br.com.objectos.way.io.TableProxy

ch.bbv.fsm.impl.internal.aop.CallInterceptorBuilder

co.paralleluniverse.actors.behaviors.ProxyServerActor

com.alibaba.citrus.springext.util.SpringExtUtil

com.alibaba.citrus.util.internal.InterfaceImplementorBuilder

com.alibaba.citrus.util.internal.StaticFunctionDelegatorBuilder

com.avast.syringe.aop.cglib.CglibProxyFactory

com.cloud.utils.db.GenericDaoBase

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.