Specialized child classes
975365
function WebRtcPeerRecvonly(options, callback) {
  if (!(this instanceof WebRtcPeerRecvonly)) {
    return new WebRtcPeerRecvonly(options, callback)
  }

  WebRtcPeerRecvonly.super_.call(this, 'recvonly', options, callback)
}
1135130
def expand_specializations(session, class_names):
    
    result = []
    for class_name in class_names:
        specialization = SpecializationV1.create(session, class_name)
        if specialization is None:
            result.append(class_name)
        else:
            result.extend(specialization.children)
            logging.info('Expanded specialization "%s" into the following'
                         ' classes: %s',
                         class_name, ' '.join(specialization.children))

    return result
155054
def generate_classes(self, items):
        ""
        classes = super().generate_classes([o[1] for o in items])
        classes = ['background'] + list(classes)
        return classes
374948
def inherited(child_klass)
      inherited_config_klass = Class.new(@__qonfig_config_klass__)

      child_klass.instance_variable_set(:@__qonfig_definition_lock__, Mutex.new)
      child_klass.instance_variable_set(:@__qonfig_access_lock__, Mutex.new)
      child_klass.instance_variable_set(:@__qonfig_config_klass__, inherited_config_klass)
      child_klass.instance_variable_set(:@__qonfig_config__, nil)

      super
    end
126930
function(ChildClass, ParentClass, methods) {
            var childMethods = ChildClass.prototype;
            ChildClass.prototype = Object.create(ParentClass.prototype);
            ChildClass.prototype.constructor = ChildClass; // restoring proper constructor for child class
            angular.forEach(Object.keys(childMethods), function(k) {
              ChildClass.prototype[k] = childMethods[k];
            });
            if( angular.isObject(methods) ) {
              angular.extend(ChildClass.prototype, methods);
            }
            return ChildClass;
          }
1205844
def classes(
            self,
            name=None,
            function=None,
            header_dir=None,
            header_file=None,
            recursive=None,
            allow_empty=None):
        """"""
        return (
            self._find_multiple(
                self._impl_matchers[scopedef_t.class_],
                name=name,
                function=function,
                decl_type=self._impl_decl_types[
                    scopedef_t.class_],
                header_dir=header_dir,
                header_file=header_file,
                recursive=recursive,
                allow_empty=allow_empty)
        )
520594
def children_with_values(self):
        
        childs = []
        for attribute in self._get_all_c_children_with_order():
            member = getattr(self, attribute)
            if member is None or member == []:
                pass
            elif isinstance(member, list):
                for instance in member:
                    childs.append(instance)
            else:
                childs.append(member)
        return childs
717424
def instantiate_subclasses(klass)
      klass.descendants.select { |c| !safe || c.safe }.sort.map do |c|
        c.new(config)
      end
    end
120477
def iter_children(graph, node: BaseEntity) -> Iterable[BaseEntity]:
    """"""
    return (
        node
        for node, _, d in graph.in_edges(node, data=True)
        if d[RELATION] == IS_A
    )
130695
def superclasses(self, inherited=False):
        
        data = clips.data.DataObject(self._env)

        lib.EnvClassSuperclasses(
            self._env, self._cls, data.byref, int(inherited))

        for klass in classes(self._env, data.value):
            yield klass
455082
def get_recursive_subclasses(cls):
    """"""
    return cls.__subclasses__() + [g for s in cls.__subclasses__() for g in get_recursive_subclasses(s)]
474769
def get_children(self):
        """"""
        if self.is_leaf():
            return get_result_class(self.__class__).objects.none()
        return get_result_class(self.__class__).objects.filter(
            depth=self.depth + 1,
            path__range=self._get_children_path_interval(self.path)
        ).order_by(
            'path'
        )
1284138
function xmultipleClasses(parents) {
    // A dummy constructor because a class can only extend something constructible
    function ConstructibleProxyTarget() {}

    // Replace prototype with a forwarding proxy to parents' prototypes
    ConstructibleProxyTarget.prototype = xmultipleObjects(parents.map(parent => parent.prototype));

    // Forward static calls to parents
    const ClassForwardingProxy = xmultipleObjects(parents, ConstructibleProxyTarget);

    return ClassForwardingProxy;
}
216234
function(e, props, targets) {
				var children, i, child, type;
				if (e.slice) {
					i = e.length;
					while (--i > -1) {
						_getChildStyles(e[i], props, targets);
					}
					return;
				}
				children = e.childNodes;
				i = children.length;
				while (--i > -1) {
					child = children[i];
					type = child.type;
					if (child.style) {
						props.push(_getAllStyles(child));
						if (targets) {
							targets.push(child);
						}
					}
					if ((type === 1 || type === 9 || type === 11) && child.childNodes.length) {
						_getChildStyles(child, props, targets);
					}
				}
			}
663650
def get_module_classes(node):
    
    return [
        child
        for child in ast.walk(node)
        if isinstance(child, ast.ClassDef)
    ]
686765
def iterchildren(self):
        
        handle = self.handle
        index = 0
        while 1:
            subkey = win32.RegEnumKey(handle, index)
            if subkey is None:
                break
            yield self.child(subkey)
            index += 1
522329
def _subclassed(base, *classes):
        
        return all(map(lambda obj: isinstance(obj, base), classes))