获取CGLib处理过后的实体的原Class.
338774
public static Class<?> unwrapCglib(Object instance) {
		Validate.notNull(instance, "Instance must not be null");
		Class<?> clazz = instance.getClass();
		if ((clazz != null) && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
			Class<?> superClass = clazz.getSuperclass();
			if ((superClass != null) && !Object.class.equals(superClass)) {
				return superClass;
			}
		}
		return clazz;
	}
570987
private void initJavaClassCache(Class clazz) {
        String clazzName = clazz.getName();
        Class cl = classCache.get(clazzName);
        if (null == cl) {
            synchronized (clazz) { // 进行锁控制
                cl = classCache.get(clazzName); // double check
                if (cl != null) {
                    return;
                }
                Method[] methods = clazz.getMethods();
                for (Method m : methods) {
                    String key = buildMethodKey(clazzName, m.getName(), m.getParameterTypes());
                    methodCache.put(key, m);
                }
                allMethodCache.put(clazzName, methods);
            }
        }
    }
61122
def DatabaseEnabled(cls):
    
    if not issubclass(cls, Storable):
        raise ValueError(
            "%s is not a subclass of gludb.datab.Storage" % repr(cls)
        )

    cls.ensure_table = classmethod(_ensure_table)
    cls.find_one = classmethod(_find_one)
    cls.find_all = classmethod(_find_all)
    cls.find_by_index = classmethod(_find_by_index)
    cls.save = _save
    cls.delete = _delete

    return cls
246328
public static Class<?> getUserClass(Class<?> clazz) {
        if (clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
            Class<?> superclass = clazz.getSuperclass();
            if (superclass != null && Object.class != superclass) {
                return superclass;
            }
        }
        return clazz;
    }
1333813
def cg(output,
       show,
       verbose,
       classname,
       methodname,
       descriptor,
       accessflag,
       no_isolated,
       apk):
    
    androcg_main(verbose=verbose,
                 APK=apk,
                 classname=classname,
                 methodname=methodname,
                 descriptor=descriptor,
                 accessflag=accessflag,
                 no_isolated=no_isolated,
                 show=show,
                 output=output)
105776
public static <F, T> Copier<F, T> createCglib(Class<F> sourceClass, Class<T> targetClass) {
        return CopierFactory.getOrCreateCglibCopier(sourceClass, targetClass);
    }
717229
def c_func(funcname, reverse=False, nans=False, scalar=False):
    
    varnames = ['group_idx', 'a', 'ret', 'counter']
    codebase = c_base_reverse if reverse else c_base
    iteration = c_iter_scalar[funcname] if scalar else c_iter[funcname]
    if scalar:
        varnames.remove('a')
    return codebase % dict(init=c_init(varnames), iter=iteration,
                           finish=c_finish.get(funcname, ''),
                           ri_redir=(c_ri_redir if nans else c_ri))
465269
function parseCompoundGlyf(reader, glyf) {
            glyf.compound = true;
            glyf.glyfs = [];

            var flags;
            var g;

            // 读取复杂字形
            do {
                flags = reader.readUint16();
                g = {};
                g.flags = flags;
                g.glyphIndex = reader.readUint16();

                var arg1 = 0;
                var arg2 = 0;
                var scaleX = 16384;
                var scaleY = 16384;
                var scale01 = 0;
                var scale10 = 0;

                if (componentFlag.ARG_1_AND_2_ARE_WORDS & flags) {
                    arg1 = reader.readInt16();
                    arg2 = reader.readInt16();

                }
                else {
                    arg1 = reader.readInt8();
                    arg2 = reader.readInt8();
                }

                if (componentFlag.ROUND_XY_TO_GRID & flags) {
                    arg1 = Math.round(arg1);
                    arg2 = Math.round(arg2);
                }

                if (componentFlag.WE_HAVE_A_SCALE & flags) {
                    scaleX = reader.readInt16();
                    scaleY = scaleX;
                }
                else if (componentFlag.WE_HAVE_AN_X_AND_Y_SCALE & flags) {
                    scaleX = reader.readInt16();
                    scaleY = reader.readInt16();
                }
                else if (componentFlag.WE_HAVE_A_TWO_BY_TWO & flags) {
                    scaleX = reader.readInt16();
                    scale01 = reader.readInt16();
                    scale10 = reader.readInt16();
                    scaleY = reader.readInt16();
                }

                if (componentFlag.ARGS_ARE_XY_VALUES & flags) {
                    g.useMyMetrics = !!flags & componentFlag.USE_MY_METRICS;
                    g.overlapCompound = !!flags & componentFlag.OVERLAP_COMPOUND;

                    g.transform = {
                        a: Math.round(10000 * scaleX / 16384) / 10000,
                        b: Math.round(10000 * scale01 / 16384) / 10000,
                        c: Math.round(10000 * scale10 / 16384) / 10000,
                        d: Math.round(10000 * scaleY / 16384) / 10000,
                        e: arg1,
                        f: arg2
                    };
                }
                else {
                    error.raise(10202);
                }

                glyf.glyfs.push(g);

            } while (componentFlag.MORE_COMPONENTS & flags);

            if (componentFlag.WE_HAVE_INSTRUCTIONS & flags) {
                var length = reader.readUint16();
                if (length < MAX_INSTRUCTION_LENGTH) {
                    var instructions = [];
                    for (var i = 0; i < length; ++i) {
                        instructions.push(reader.readUint8());
                    }
                    glyf.instructions = instructions;
                }
                else {
                    console.warn(length);
                }
            }

            return glyf;
        }
940658
public static String getByteCodeType(Class<?> clazz) {
        Assert.notNull(clazz);
        if (byte.class == clazz) {
            return "B";
        } else if (short.class == clazz) {
            return "S";
        } else if (int.class == clazz) {
            return "I";
        } else if (long.class == clazz) {
            return "J";
        } else if (double.class == clazz) {
            return "D";
        } else if (float.class == clazz) {
            return "F";
        } else if (boolean.class == clazz) {
            return "Z";
        } else if (char.class == clazz) {
            return "C";
        } else if (void.class == clazz) {
            // void只有在返回值中才会有
            return "V";
        } else if (StringUtils.trim(clazz.getName(), "[").startsWith("L")) {
            // 是对象数组（这里的对象指的是非原生类型）
            return clazz.getName().replace(".", "/");
        } else if (!JavaTypeUtil.isGeneralType(clazz)) {
            // 是对象（这里的对象指的是非原生类型）
            return "L" + clazz.getName().replace(".", "/") + ";";
        } else {
            return clazz.getName().replace(".", "/");
        }
    }
819644
public List<Class<?>> directSuperclasses(Class<?> c)
    {
        if(c.isPrimitive()) {
            return primitiveSuperclasses(c);
        }
        else if(c.isArray()) {
            return arrayDirectSuperclasses(0, c);
        }
        else {
            Class<?> [] interfaces = c.getInterfaces();
            Class<?> superclass = c.getSuperclass();

            List<Class<?>> classes = new LinkedList<Class<?>>();
            classes.addAll(Arrays.asList(interfaces));
            if(superclass == null) {
                if(interfaces.length == 0 &&
                   c != Object.class)
                    classes.add(Object.class);
            }
            else {
                classes.add(superclass);
            }

            return classes;
        }
    }
885898
function C(dbCursor) {
        var chain = dbCursor;

        _.each(['sort', 'skip', 'limit', 'projection'], function(fName) {
            this[fName] = function() {
                chain = chain[fName].apply(chain, arguments);
                return this;
            }
        }.bind(this));

        this.exec = function(){
            return convertToPromise(chain, 'exec', [], function(data) {
                if(_.isArray(data)) return dbCallbacks.find(data);
                if(_.isObject(data)) return dbCallbacks.findOne(data);
                return data;
            });
        };
    }
610427
private static Class<?> box(Class<?> clazz) {
        if (clazz == int.class) {
            return Integer.class;
        } else
            if (clazz == float.class) {
                return Float.class;
            } else
                if (clazz == long.class) {
                    return Long.class;
                } else
                    if (clazz == double.class) {
                        return double.class;
                    } else
                        if (clazz == boolean.class) {
                            return Boolean.class;
                        } else
                            if (clazz == char.class) {
                                return Character.class;
                            } else
                                if (clazz == byte.class) {
                                    return Byte.class;
                                }
        return clazz;
    }
768208
public static Class<?> getLoggingClass(Object object) {
        Class<?> result = object.getClass();
        if (result.getSimpleName().matches(".*[$].*CGLIB.*")) {
            result = result.getSuperclass();
        }
        return result;
    }
49249
function className(g) {
    g
      .attr("id", function(d){
        return "d3plus_group_" + d.d3plus.id;
      })
      .attr("class", function(d){
        var c = vars.class.value ? " " + fetchValue(vars, d, vars.class.value) : "";
        return "d3plus_" + shape + c;
      });
  }
541691
def cublasStrsm(handle, side, uplo, trans, diag, m, n, alpha, A, lda, B, ldb):
    
    
    status = _libcublas.cublasStrsm_v2(handle, 
                                       _CUBLAS_SIDE_MODE[side], 
                                       _CUBLAS_FILL_MODE[uplo], 
                                       _CUBLAS_OP[trans], 
                                       _CUBLAS_DIAG[diag], 
                                       m, n, ctypes.byref(ctypes.c_float(alpha)),
                                       int(A), lda, int(B), ldb)
    cublasCheckStatus(status)
32937
private static void getDescriptor(final StringBuffer buf, final Class<?> c) {
        Class<?> d = c;
        while (true) {
            if (d.isPrimitive()) {
                char car;
                if (d == Integer.TYPE) {
                    car = 'I';
                } else if (d == Void.TYPE) {
                    car = 'V';
                } else if (d == Boolean.TYPE) {
                    car = 'Z';
                } else if (d == Byte.TYPE) {
                    car = 'B';
                } else if (d == Character.TYPE) {
                    car = 'C';
                } else if (d == Short.TYPE) {
                    car = 'S';
                } else if (d == Double.TYPE) {
                    car = 'D';
                } else if (d == Float.TYPE) {
                    car = 'F';
                } else /* if (d == Long.TYPE) */{
                    car = 'J';
                }
                buf.append(car);
                return;
            } else if (d.isArray()) {
                buf.append('[');
                d = d.getComponentType();
            } else {
                buf.append('L');
                String name = d.getName();
                int len = name.length();
                for (int i = 0; i < len; ++i) {
                    char car = name.charAt(i);
                    buf.append(car == '.' ? '/' : car);
                }
                buf.append(';');
                return;
            }
        }
    }
1054276
private static boolean isPrimitive(Class<? extends Object> c) {
		return (null == c) || (Class.class == c) || (String.class == c) || c.isPrimitive() || (Integer.class == c) || (Long.class == c)
				|| (Short.class == c) || (Byte.class == c) || (Character.class == c) || (Float.class == c) || (Double.class == c)
				|| (Void.class == c) || (Boolean.class == c);
	}