for use by the above constructor
325316
private static <L> Map<Name, TypeSet<ResourceType<L>>> buildTypeMapForConstructor(
            Collection<ResourceType<L>> allTypes) {
        TypeSetBuilder<ResourceType<L>> bldr = TypeSet.<ResourceType<L>> builder();
        bldr.enabled(true);
        bldr.name(new Name("all"));
        for (ResourceType<L> type : allTypes) {
            bldr.type(type);
        }
        TypeSet<ResourceType<L>> typeSet = bldr.build();

        return Collections.singletonMap(typeSet.getName(), typeSet);
    }
395413
function(that) {
		var summ = this._bugsummary;
		var name = that.constructor.$classname || String(that);
		console.error([
			"Bad argument " + summ.shift(),
			"for " + name + ":",
			"Expected " + summ.shift() + ",",
			"got " + summ.shift() + ":",
			summ.shift()
		].join(" "));
	}
581424
function constructor(options, error, name) {
    Pagelet.prototype.constructor.call(this, options);

    if (name) this.name = name;
    this.data = error instanceof Error ? error : {};
  }
170812
function() {
        if (!this.ready) return;

        var pos = this.drawVars.pos;
        pos._x = this._x;
        pos._y = this._y;
        pos._w = this._w;
        pos._h = this._h;

        var coord = this.__coord || [0, 0, 0, 0];
        var co = this.drawVars.co;
        co.x = coord[0];
        co.y = coord[1];
        co.w = coord[2];
        co.h = coord[3];

        // Handle flipX, flipY
        // (Just swap the positions of e.g. x and x+w)
        if (this._flipX) {
            co.x = co.x + co.w;
            co.w = -co.w;
        }
        if (this._flipY) {
            co.y = co.y + co.h;
            co.h = -co.h;
        }

        //Draw entity
        var gl = this._drawContext;
        this.drawVars.gl = gl;
        var prog = (this.drawVars.program = this.program);

        // The program might need to refer to the current element's index
        prog.setCurrentEntity(this);

        // Write position; x, y, w, h
        prog.writeVector(
            "aPosition",
            this._x,
            this._y,
            this._x,
            this._y + this._h,
            this._x + this._w,
            this._y,
            this._x + this._w,
            this._y + this._h
        );

        // Write orientation
        prog.writeVector(
            "aOrientation",
            this._origin.x + this._x,
            this._origin.y + this._y,
            (this._rotation * Math.PI) / 180
        );

        // Write z, alpha
        prog.writeVector("aLayer", this._globalZ, this._alpha);

        // This should only need to handle *specific* attributes!
        this.trigger("Draw", this.drawVars);

        // Register the vertex groups to be drawn, referring to this entities position in the big buffer
        prog.addIndices(prog.ent_offset);

        return this;
    }
664361
function ___wrapConstructor(constructorInner, name) {

    var proto = constructorInner.prototype;
    var inner = (function(p) {
        function f() {};
        f.prototype = p.prototype;
        return new f;
    })(proto);

    function Outer() {
        constructorInner.apply(this, arguments);
        let that = this;

        var loop = function(key){
            if (proto.hasOwnProperty(key) && typeof proto[key] === 'function') {
                that[key] = function () { 
                    return ___call(proto[key], name + '.' + key, that, arguments); 
                }
            }
        };

        for (var key in proto) {
            loop(key);
        }
    }

    Outer.prototype = inner;
    return Outer;
}
349763
function construct(constructor) {
            // Create constructor
            var c = function () {
                return constructor.apply(this);
            };
            // Assign prototype
            c.prototype = constructor.prototype;
            // Create new instance
            return service_factory_1.ServiceFactory.export(c, name, context);
        }
352304
@Override
    public void initialise()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "initialise", this);

        createInputHandlersForPtoP();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "initialise");
    }
1041131
function init(config) {
            var property;

            for (property in config) {
                if (config.hasOwnProperty(property)) {
                    this[property] = config[property];
                }
            }

            if(this.processors instanceof Array === false){
                this.processors = [].concat(this.constructor.processors);
            }
			if(this.preprocessors instanceof Array === false){
                this.preprocessors = [].concat(this.constructor.preprocessors);
            }
        }
262560
function init() {
			/* jshint validthis: true */
			// All construction is actually done in the init method.
			if (!initializing) {
				//!steal-remove-start
				if(process.env.NODE_ENV !== 'production') {
					if(!this || (this.constructor !== Constructor) &&
					// We are being called without `new` or we are extending.
					arguments.length && Constructor.constructorExtends) {
						dev.warn('can/construct/construct.js: extending a Construct without calling extend');
					}
				}
				//!steal-remove-end

				return (!this || this.constructor !== Constructor) &&
				// We are being called without `new` or we are extending.
				arguments.length && Constructor.constructorExtends ? Constructor.extend.apply(Constructor, arguments) :
				// We are being called with `new`.
				Constructor.newInstance.apply(Constructor, arguments);
			}
		}
933840
function () {
            var x3 = this.dpop();
            var x2 = this.dpop();
            var x1 = this.dpop();
            this.dpush(x2);
            this.dpush(x3);
            this.dpush(x1);
        }
897213
public static <A, B> These<A, B> a(A a) {
        return new _A<>(a);
    }
1123294
protected function _construct() {
		parent::_construct();
		$this
			->_prop(self::$P__UNITS, DF_V_STRING_NE)
			->_prop(self::$P__VALUE, DF_V_STRING)
		;
	}
1195809
function () {
        var vertex = this.get('vertex');
        this._super();

        // Initialize data members
        this.setProperties({
          id: vertex.get('vertexName') + this.get('name'),
          depth: vertex.get('depth') + 1
        });
      }
1346807
function (out) {
            out.writeln("$constructor: function() { ");
            out.increaseIndent();
            var parentClassName = out.parentClassName;
            if (parentClassName) {
                out.writeln("this.$", parentClassName, ".constructor.call(this);");
            }
            var scriptClassName = out.scriptClassName;
            if (scriptClassName) {
                out.writeln("this.$", scriptClassName, ".constructor.call(this);");
            }
            out.decreaseIndent();
            out.writeln("},");
        }
1153834
function(constructorFn, args) {

		    var newConstructorFn = function () {
			    constructorFn.apply(this, args);
		    };
		    newConstructorFn.prototype = constructorFn.prototype;
		    return new newConstructorFn();
	    }
418973
function() {
		if( this.isInitialised === true ) return;

		var i;
	
		lm.items.AbstractContentItem.prototype._$init.call( this );
		
		for( i = 0; i < this.contentItems.length - 1; i++ ) {
			this.contentItems[ i ].element.after( this._createSplitter( i ).element );
		}
	}
442005
function(data){
  this.top;
  this.size;
  if(typeof data !== 'undefined'){
    this.top = new Node(data);
    this.size = 1;
  }else{
    this.top = null;
    this.size = 0;
  }
}