Map a class name to the current compiled class bytes.
435970
void setCurrentBytes(String className, byte[] bytes) {
        ClassInfo ci = get(className);
        ci.setCurrentBytes(bytes);
    }
225521
def _update_classmethod(self, oldcm, newcm):
        """"""
        # While we can't modify the classmethod object itself (it has no
        # mutable attributes), we *can* extract the underlying function
        # (by calling __get__(), which returns a method object) and update
        # it in-place.  We don't have the class available to pass to
        # __get__() but any object except None will do.
        self._update(None, None, oldcm.__get__(0), newcm.__get__(0))
1329428
def qualified_class_name(o):
    """"""
    module = o.__class__.__module__
    if module is None or module == str.__class__.__module__:
        return o.__class__.__name__
    return module + '.' + o.__class__.__name__
615273
public Class<?> addClassBytes(String name, byte[] classBytes) {
        Class<?> newClass = defineClass(name, classBytes, 0, classBytes.length);
        resolveClass(newClass);
        localClassCache.put(newClass.getName(), newClass);
        return newClass;
    }
243503
private void loadProtoClassToCache(String key, Class clazz, String methodName) {
        Method pbMethod = null;
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            if (methodName.equals(method.getName())) {
                pbMethod = method;
                break;
            }
        }
        if (pbMethod == null) {
            throw new SofaRpcRuntimeException("Cannot found protobuf method: " + clazz.getName() + "." + methodName);
        }
        Class[] parameterTypes = pbMethod.getParameterTypes();
        if (parameterTypes == null
            || parameterTypes.length != 1
            || isProtoBufMessageObject(parameterTypes[0])) {
            throw new SofaRpcRuntimeException("class based protobuf: " + clazz.getName()
                + ", only support one protobuf parameter!");
        }
        Class reqClass = parameterTypes[0];
        requestClassCache.put(key, reqClass);
        Class resClass = pbMethod.getReturnType();
        if (resClass == void.class || !isProtoBufMessageClass(resClass)) {
            throw new SofaRpcRuntimeException("class based protobuf: " + clazz.getName()
                + ", only support return protobuf message!");
        }
        responseClassCache.put(key, resClass);
    }
449660
def get_class(cls, name_or_sl):
        """"""
        try:
            return cls.sl_map[int(name_or_sl)]

        except TypeError as e:
            raise TypeError("Bad name or sl: {} : {}".format(name_or_sl, e))
        except ValueError:
            try:
                return cls.class_map[name_or_sl.lower()]
            except (KeyError, ValueError):
                raise NotASummaryName("Value '{}' is not a valid summary level".format(name_or_sl))
252182
private static String relationalMapperName(Class<?> configuredClass, String resource){
		
		String className = configuredClass.getName().replaceAll("\\.","");
		
		if(isEmpty(resource)) 
			return className;
		
		if(!isPath(resource))
			return write(className, String.valueOf(resource.hashCode()));
		
		String[]dep = resource.split("\\\\");
		if(dep.length<=1)dep = resource.split("/");
		String xml = dep[dep.length-1];
		return write(className, xml.replaceAll("\\.","").replaceAll(" ",""));
	}
866140
def class_register(cls):
    """"""
    cls.handler_registry = {}
    for method_name in dir(cls):
        method = getattr(cls, method_name)
        if hasattr(method, '_handle'):
            cls.handler_registry.update({method._handle: method_name})
    return cls
935503
private synchronized void addToMap(Class clazz, byte id) {
    if (classToIdMap.containsKey(clazz)) {
      byte b = classToIdMap.get(clazz);
      if (b != id) {
        throw new IllegalArgumentException ("Class " + clazz.getName() +
          " already registered but maps to " + b + " and not " + id);
      }
    }
    if (idToClassMap.containsKey(id)) {
      Class c = idToClassMap.get(id);
      if (!c.equals(clazz)) {
        throw new IllegalArgumentException("Id " + id + " exists but maps to " +
            c.getName() + " and not " + clazz.getName());
      }
    }
    classToIdMap.put(clazz, id);
    idToClassMap.put(id, clazz);
  }
816167
def _iparam_classname(classname, arg_name):
        

        if isinstance(classname, CIMClassName):
            classname = classname.copy()
            classname.host = None
            classname.namespace = None
        elif isinstance(classname, six.string_types):
            classname = CIMClassName(classname)
        elif classname is None:
            pass
        else:
            raise TypeError(
                _format("The {0!A} argument of the WBEMConnection operation "
                        "has invalid type {1} (must be None, a string, or a "
                        "CIMClassName)",
                        arg_name, type(classname)))
        return classname
271856
byte[] transformBytes(byte[] bytes) {
        ClassCollector visitor = new ClassCollector();
        visitVerbose(bytes, visitor);
        ClassInfo classInfo = visitor.getClassInfo();
        boolean instrumented = false;

        for (ClassGenerator gen : generators) {
            if (!gen.canInstrument(classInfo)) {
                continue;
            }
            ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            gen.init(writer, classInfo);
            visitVerbose(bytes, gen);
            if (gen.hasInstrumented()) {
                bytes = writer.toByteArray();
                instrumented = true;
                System.out.println(gen.getClass().getSimpleName() + " instrumented "
                        + classInfo.getName().replace('/', '.'));
            }
        }

        // If any generators instrumented the class bytes, return the
        // instrumented bytes. Otherwise, return null.
        return instrumented ? bytes : null;
    }
507594
def class_name(self):
    """"""
    if not self._registry_key and self._registry:
      self._GetKeyFromRegistry()

    if not self._registry_key:
      return None

    return self._registry_key.class_name
932171
function map(classMap) {
		if (typeof classMap === 'function') {
			options.classMap = classMap;
		} else {
			options.classMap = function (className) {
				return classMap[className] || className;
			};
		}
	}
873766
def getClassInPackageFromName(className, pkg):
    
    # TODO: more efficiency!
    n = getAvClassNamesInPackage(pkg)
    i = n.index(className)
    c = getAvailableClassesInPackage(pkg)
    return c[i]
1154144
def _update_const_classes():
    """"""
    klasses = (bool, int, float, complex, str, bytes)
    for kls in klasses:
        CONST_CLS[kls] = Const
712383
def processModule(module_name):
  
  """
  Module = sys.modules[module_name]
  MembersTarget = []
  ClassQ = []
  Cls = None
  ClsGroup = None
  ClsGrpMembers = []

  for Member in ModuleMembers[module_name]:
    Underlying = Member.Underlying
    member_name = Member.Config['name']
    member_alias = Member.Config.get('alias', None)

    if ClassQ:
      ClsGroup = ClassQ[-1]
      Cls = ClsGroup.Underlying

      if getattr(Cls, Underlying.__name__, None) is Underlying: # we got a member tht is a child of the previous class
        if isclass(Underlying):
          ClassQ.append(Underlying.__ec_member__)

        elif not isunderlying(Underlying):
          continue

        if member_alias:
          ClsGrpMembers.insert(0, (member_alias, Member))

        ClsGrpMembers.insert(0, (member_name, Member))
        continue

      elif Cls: # we've finished adding children to the previous class
        ClsGroup.Members = OrderedDict(ClsGrpMembers)
        ClsGrpMembers = []
        ClassQ.pop()
        Cls = None
        ClsGroup = None

    if isunderlying(Underlying):
      if member_alias:
        MembersTarget.insert(0, (member_alias, Member))

      MembersTarget.insert(0, (member_name, Member))

      if isclass(Underlying):
        ClassQ.append(Underlying.__ec_member__)

  if ClsGroup:
    ClsGroup.Members = OrderedDict(ClsGrpMembers)

  ModuleMembers[module_name] = []  # remove the existing members from the cache so that they won't be processed again

  if not hasattr(Module.__ec_member__, 'Members'):
    Module.__ec_member__.Members = OrderedDict(MembersTarget)
695072
private Map<String, InnerClassAccess> getAccessMapForClass(String className) throws ClassNotFoundException {

        Map<String, InnerClassAccess> map = classToAccessMap.get(className);
        if (map == null) {
            map = new HashMap<>(3);

            if (!className.startsWith("[")) {
                JavaClass javaClass = Repository.lookupClass(className);

                Method[] methodList = javaClass.getMethods();
                for (Method method : methodList) {
                    String methodName = method.getName();
                    if (!methodName.startsWith("access$")) {
                        continue;
                    }

                    Code code = method.getCode();
                    if (code == null) {
                        continue;
                    }

                    if (DEBUG) {
                        System.out.println("Analyzing " + className + "." + method.getName()
                                + " as an inner-class access method...");
                    }

                    byte[] instructionList = code.getCode();
                    String methodSig = method.getSignature();
                    InstructionCallback callback = new InstructionCallback(javaClass, methodName, methodSig, instructionList);
                    //                    try {
                    new BytecodeScanner().scan(instructionList, callback);
                    //                    } catch (LookupFailure lf) {
                    //                        throw lf.getException();
                    //                    }
                    InnerClassAccess access = callback.getAccess();
                    if (DEBUG) {
                        System.out.println((access != null ? "IS" : "IS NOT") + " an inner-class access method");
                    }
                    if (access != null) {
                        map.put(methodName, access);
                    }
                }
            }

            if (map.size() == 0) {
                map = Collections.emptyMap();
            } else {
                map = new HashMap<>(map);
            }

            classToAccessMap.put(className, map);
        }

        return map;
    }