sub class helpers
7704
protected void setIntegerProperty(UIComponent component, String propName,
            ValueExpression value)
    {
        UIComponentELTagUtils.setIntegerProperty(component, propName, value);
    }
310337
function generateClassNameSubstitutions(tokens, substitutionPattern, substitutions) {
  tokens.forEach((tokenList)=> {
    var token = tokenList[0];
    generateSubstitution(token, substitutionPattern, substitutions);
  });
}
675167
def _onClass(self, name, line, pos, absPosition,
                 keywordLine, keywordPos,
                 colonLine, colonPos, level):
        """"""
        self.__flushLevel(level)
        c = Class(name, line, pos, absPosition, keywordLine, keywordPos,
                  colonLine, colonPos)
        if self.__lastDecorators is not None:
            c.decorators = self.__lastDecorators
            self.__lastDecorators = None
        self.objectsStack.append(c)
1143814
function injectSubClasses (_object) {
  var object = _object
  for (var key in object) {
    if (~key.indexOf('__')) {
      var keySplit = key.split('__')
      var parentkey = keySplit[0]
      var newKey = keySplit.slice(1).join('__')

      object[parentkey] = object[parentkey] || {}
      object[parentkey][newKey] = object[key]

      if (~newKey.indexOf('__')) {
        // do it recursively
        object[parentkey] = injectSubClasses(object[parentkey])
      }

      delete object[key]
    }
  }
  return object
}
522329
def _subclassed(base, *classes):
        
        return all(map(lambda obj: isinstance(obj, base), classes))
883920
def _add_numeric_methods_add_sub_disabled(cls):
        
        cls.__add__ = make_invalid_op('__add__')
        cls.__radd__ = make_invalid_op('__radd__')
        cls.__iadd__ = make_invalid_op('__iadd__')
        cls.__sub__ = make_invalid_op('__sub__')
        cls.__rsub__ = make_invalid_op('__rsub__')
        cls.__isub__ = make_invalid_op('__isub__')
719257
def get_subassistants(self):
        
        if not hasattr(self, '_subassistants'):
            self._subassistants = []
            # we want to know, if type(self) defines 'get_subassistant_classes',
            # we don't want to inherit it from superclass (would cause recursion)
            if 'get_subassistant_classes' in vars(type(self)):
                for a in self.get_subassistant_classes():
                    self._subassistants.append(a())
        return self._subassistants
1106373
function subParse(parser, pos, extensions,parens) {
    var p = new parser.constructor(parser.options, parser.input, pos);
    if (extensions)
        for (var k in extensions)
            p[k] = extensions[k] ;

    var src = parser ;
    var dest = p ;
    ['inFunction','inAsyncFunction','inAsync','inGenerator','inModule'].forEach(function(k){
        if (k in src)
            dest[k] = src[k] ;
    }) ;
    if (parens)
        p.options.preserveParens = true ;
    p.nextToken();
    return p;
}
160280
private void addSuperClasses(Integer directSuperClass,
			ClassRecord subClassRecord) {
		if (subClassRecord.superClasses.contains(directSuperClass)) {
			return;
		}
		subClassRecord.superClasses.add(directSuperClass);
		ClassRecord superClassRecord = getClassRecord(directSuperClass);
		if (superClassRecord == null) {
			return;
		}

		for (Integer superClass : superClassRecord.directSuperClasses) {
			addSuperClasses(superClass, subClassRecord);
		}
	}
1073923
def subclass(self, klass):
        """"""
        return bool(lib.EnvSubclassP(self._env, self._cls, klass._cls))
1087158
def from_defn(cls, defn):
        ""
        instances = (subcl(defn) for subcl in cls.__subclasses__())
        return next(filter(None, instances))
740025
def sub(pat, rep)
      inject(self.class.new) { |res, fn| res << fn.sub(pat, rep) }
    end
989013
def _list_superclasses(class_def):
    """"""
    superclasses = class_def.get('superClasses', [])
    if superclasses:
        # Make sure to duplicate the list
        return list(superclasses)

    sup = class_def.get('superClass', None)
    if sup:
        return [sup]
    else:
        return []
434229
def sub(self):
        '''
        
        '''

        if self.__fields:
            return _Template(self.raw).substitute(self.__fields)
        return self.raw
1087642
function makeSubfieldPairs(subfields1, subfields2, fn_comparator) {
      
      var pairs = [];

      if (subfields1.length === subfields2.length) {

        subfields2.forEach(function(subfield2) {          
          return subfields1.some(function(subfield1) {
            if (fn_comparator(subfield1, subfield2)) {
              
              pairs.push([subfield1, subfield2]);
              return true;
              
            }
          });
        });

      } else {
        throw new Error('Number of subfields are not equal');
      }

      return pairs;
      
    }
643521
private Collection<TypeElement> subclasses(TypeElement te) {
        Collection<TypeElement> ret = classToSubclass.get(te);
        if (ret == null) {
            ret = new TreeSet<>(utils.makeClassUseComparator());
            Set<TypeElement> subs = classtree.subClasses(te);
            if (subs != null) {
                ret.addAll(subs);
                for (TypeElement sub : subs) {
                    ret.addAll(subclasses(sub));
                }
            }
            addAll(classToSubclass, te, ret);
        }
        return ret;
    }
935455
function Dispatcher(req, res, next) {
            _classCallCheck(this, Dispatcher);

            this.req = req;
            this.res = res;
            this.next = next;
         }