BaseBuild.js revision 52e73635546b2ee315b3d99cc7145a73ebc5b30e
/**
* The base-build submodule provides Base.build functionality, which
* can be used to create custom classes, by aggregating extensions onto
* a main class.
*
* @module base
* @submodule base-build
* @for Base
*/
L = Y.Lang,
INITIALIZER = "initializer",
DESTRUCTOR = "destructor",
extClass = extensions[i];
delete extProto[INITIALIZER];
delete extProto[DESTRUCTOR];
// Prototype, old non-displacing augment
// Custom Statics
if (initializer) {
}
if (destructor) {
}
}
if (px) {
}
if (sx) {
}
if (dynamic) {
}
return builtClass;
};
var aggregates,
aggr,
l,
i;
if (cfg) {
}
if (statics) {
}
if (aggregates) {
aggr = aggregates[i];
}
}
}
if (custom) {
for (i in custom) {
if (custom.hasOwnProperty(i)) {
custom[i](i, r, s);
}
}
}
},
function BuiltClass() {
}
return BuiltClass;
},
for (j = 0; j < ll; j++) {
return true;
}
}
}
}
return false;
},
if (!buildCfg) {
}
return builtClass;
},
var aggr = [],
cust = {},
statics = [],
c = main,
i,
l;
// Prototype Chain
while (c && c.prototype) {
if (buildCfg) {
if (buildCfg.aggregates) {
}
}
}
}
}
// Exts
if (exts) {
c = exts[i];
if (buildCfg) {
if (buildCfg.aggregates) {
}
}
}
}
}
}
if (cfgAggr) {
}
if (cfgCustBuild) {
}
if (cfgStatics) {
}
return {
};
},
}
}
prop = aggregates[i];
}
}
return sxclone;
}
});
/**
* <p>
* Builds a custom constructor function (class) from the
* main function, and array of extension functions (classes)
* provided. The NAME field for the constructor function is
* defined by the first argument passed in.
* </p>
* <p>
* The cfg object supports the following properties
* </p>
* <dl>
* <dt>dynamic <boolean></dt>
* <dd>
* <p>If true (default), a completely new class
* is created which extends the main class, and acts as the
* host on which the extension classes are augmented.</p>
* <p>If false, the extensions classes are augmented directly to
* the main class, modifying the main class' prototype.</p>
* </dd>
* <dt>aggregates <String[]></dt>
* <dd>An array of static property names, which will get aggregated
* on to the built class, in addition to the default properties build
* will always aggregate as defined by the main class' static _buildCfg
* property.
* </dd>
* </dl>
*
* @method build
* @deprecated Use the more convenient Base.create and Base.mix methods instead
* @static
* @param {Function} name The name of the new class. Used to defined the NAME property for the new class.
* @param {Function} main The main class on which to base the built class
* @param {Function[]} extensions The set of extension classes which will be
* augmented/aggregated to the built class.
* @param {Object} cfg Optional. Build configuration for the class (see description).
* @return {Function} A custom class, created from the provided main and extension classes
*/
};
/**
* <p>Creates a new class (constructor function) which extends the base class passed in as the second argument,
* and mixes in the array of extensions provided.</p>
* <p>Prototype properties or methods can be added to the new class, using the px argument (similar to Y.extend).</p>
* <p>Static properties or methods can be added to the new class, using the sx argument (similar to Y.extend).</p>
* <p>
*
* </p>
* @method create
* @static
* @param {Function} name The name of the newly created class. Used to defined the NAME property for the new class.
* @param {Function} main The base class which the new class should extend. This class needs to be Base or a class derived from base (e.g. Widget).
* @param {Function[]} extensions The list of extensions which will be mixed into the built class.
* @param {Object} px The set of prototype properties/methods to add to the built class.
* @param {Object} sx The set of static properties/methods to add to the built class.
* @return {Function} The newly created class.
*/
};
/**
* <p>Mixes in a list of extensions to an existing class.</p>
* @method mix
* @static
* @param {Function} main The existing class into which the extensions should be mixed. The class needs to be Base or a class derived from Base (e.g. Widget)
* @param {Function[]} extensions The set of extension classes which will mixed into the existing main class.
* @return {Function} The modified main class, with extensions mixed in.
*/
};
/**
* The build configuration for the Base class.
*
* Defines the static fields which need to be aggregated
* when the Base class is used as the main class passed to
* the <a href="#method_Base.build">Base.build</a> method.
*
* @property _buildCfg
* @type Object
* @static
* @final
* @private
*/
custom : {
if (s.ATTRS) {
a;
for (a in sAttrs) {
if (sAttrs.hasOwnProperty(a)) {
}
}
}
}
},
};