full_name => class
2392
def name2class(name)
      klass = Kernel
      name.to_s.split(%r{/}).each do |part|
        klass = klass.const_get(
          part.capitalize.gsub(/[_-](.)/) { |match| match[1].upcase }
        )
      end
      klass
    end
1246923
def convert_name(name, _class)
    name_index = get_name_index(name)

    # The ptg value depends on the class of the ptg.
    if _class == 0
      ptgName = @ptg['ptgName']
    elsif _class == 1
      ptgName = @ptg['ptgNameV']
    elsif _class == 2
      ptgName = @ptg['ptgNameA']
    end

    [ptgName, name_index].pack('CV')
  end
313272
def get_name(cls):
        
        if not hasattr(cls.Meta, 'name'):
            class_name = getattr(cls.get_model(), '__name__', None)
            setattr(
                cls.Meta,
                'name',
                inflection.underscore(class_name) if class_name else None
            )

        return cls.Meta.name
366415
def FindEnumTypeByName(self, full_name):
    

    full_name = _NormalizeFullyQualifiedName(full_name)
    if full_name not in self._enum_descriptors:
      self._FindFileContainingSymbolInDb(full_name)
    return self._enum_descriptors[full_name]
638982
def load_class_by_name(name: str):
    """"""
    mod_path, _, cls_name = name.rpartition('.')
    mod = importlib.import_module(mod_path)
    cls = getattr(mod, cls_name)
    return cls
1352264
def loads(cls, name):
        
        if not isinstance(name, six.string_types):
            raise TypeError(u'arguments to {classname} must be of type {string_types}'.format(
                classname=cls.__name__, string_types=repr(six.string_types)
            ))
        if not name or name.isspace():
            raise ValueError('name must not be empty')

        return cls(name)
696245
def parse_name_string(full_name):
    
    name = Name()
    if "," in full_name:
        toks = full_name.split(",")
        name.family = toks[0]
        name.given = ",".join(toks[1:]).strip()
    else:
        toks = full_name.split()
        name.given = toks[0]
        name.family = " ".join(toks[1:]).strip()
    return name
1359801
def mk_class_name(*parts):
    """"""
    cap = lambda s: s and (s[0].capitalize() + s[1:])
    return "".join(["".join([cap(i)
                             for i in re.split("[\ \-\_\.]", str(p))])
                    for p in parts])
1261573
def cls_get_by_name(cls, name):
    
    try:
        val = getattr(cls, name)
    except AttributeError:
        for attr in (a for a in dir(cls) if not a.startswith('_')):
            try:
                val = getattr(cls, attr)
            except AttributeError:
                # Is known to happen.
                continue
            valname = getattr(val, 'name', None)
            if valname == name:
                return val
        else:
            raise ValueError('No {} with that name: {}'.format(
                cls.__name__,
                name,
            ))
    else:
        return val
565591
def getFullName(obj):
    '''
    
    '''
    if hasattr(obj, 'firstName') and hasattr(obj, 'lastName'):
        return ' '.join([obj.firstName or '', obj.lastName or ''])
    return ' '.join([getattr(obj, 'first_name', ''),getattr(obj, 'last_name', '')])
807810
public static String getSimpleName(Class<?> klass) {
      String simpleName = klass.getSimpleName();
      if (simpleName.isEmpty()) {
         String fullName = klass.getName();
         int index = fullName.lastIndexOf('.');
         simpleName = (index < 0) ? fullName : fullName.substring(index + 1);
      }
      return simpleName;
   }
1076246
def object_symbol
      class_name = self.class.name
      index = class_name.rindex(/::/)
      class_name[index + 2 .. -1].underscore.to_sym
    end
1288937
def full_name(self):
        
        if not self.view_func:
            return None

        prefix = self.view_func.__module__
        if self._controller_cls:
            prefix = f'{prefix}.{self._controller_cls.__name__}'
        return f'{prefix}.{self.method_name}'
280393
def p_class_name(p):
    ''''''
    if len(p) == 2:
        p[0] = p[1]
    elif len(p) == 3:
        p[0] = p[1] + p[2]
    else:
        p[0] = p[1] + p[2] + p[3]
981169
@Override
    public String getFullClassName() {
        if (StringUtils.isEmpty(getPackage())) {
            return getClassName();
        }

        return getPackage() + ClassHelper.PACKAGE_SEPARATOR + getClassName();
    }
1129179
def lookup_class(fully_qualified_name):
    
    module_name, class_name = str(fully_qualified_name).rsplit(".", 1)
    module = __import__(module_name, globals(), locals(), [class_name], 0)
    Class = getattr(module, class_name)

    if not inspect.isclass(Class):
        raise TypeError(
            "%s is not of type class: %s" % (class_name, type(Class)))

    return Class
840795
def p_fully_qualified_class_name(p):
    ''''''
    if len(p) == 2:
        p[0] = p[1]
    elif len(p) == 3:
        p[0] = p[1] + p[2]
    else:
        p[0] = p[1] + p[2] + p[3]