YUI.add('attribute-extras', function (Y, NAME) {

    /**

     * The attribute module provides an augmentable Attribute implementation, which

     * adds configurable attributes and attribute change events to the class being

     * augmented. It also provides a State class, which is used internally by Attribute,

     * but can also be used independently to provide a name/property/value data structure to

     * store state.

     *

     * @module attribute

     */

    /**

     * The attribute-extras submodule provides less commonly used attribute methods, and can

     * be augmented/mixed into an implemention which used attribute-core.

     *

     * @module attribute

     * @submodule attribute-extras

     */

    var BROADCAST = "broadcast",

        PUBLISHED = "published",

        INIT_VALUE = "initValue",

        MODIFIABLE = {

            readOnly:1,

            writeOnce:1,

            getter:1,

            broadcast:1

        };

    /**

     * A augmentable implementation for AttributeCore, providing less frequently used

     * methods for Attribute management such as modifyAttrs(), removeAttr and reset()

     *

     * @class AttributeExtras

     * @extensionfor AttributeCore

     */

    function AttributeExtras() {}

    AttributeExtras.prototype = {

        /**

         * Updates the configuration of an attribute which has already been added.

         * <p>

         * The properties which can be modified through this interface are limited

         * to the following subset of attributes, which can be safely modified

         * after a value has already been set on the attribute: readOnly, writeOnce,

         * broadcast and getter.

         * </p>

         * @method modifyAttr

         * @param {String} name The name of the attribute whose configuration is to be updated.

         * @param {Object} config An object with configuration property/value pairs, specifying the configuration properties to modify.

         */

        modifyAttr: function(name, config) {

            var host = this, // help compression

                prop, state;

            if (host.attrAdded(name)) {

                if (host._isLazyAttr(name)) {

                    host._addLazyAttr(name);

                }

                state = host._state;

                for (prop in config) {

                    if (MODIFIABLE[prop] && config.hasOwnProperty(prop)) {

                        state.add(name, prop, config[prop]);

                        // If we reconfigured broadcast, need to republish

                        if (prop === BROADCAST) {

                            state.remove(name, PUBLISHED);

                        }

                    }

                }

            }

            /*jshint maxlen:200*/

            if (!host.attrAdded(name)) {Y.log('Attribute modifyAttr:' + name + ' has not been added. Use addAttr to add the attribute', 'warn', 'attribute');}

            /*jshint maxlen:150 */

        },

        /**

         * Removes an attribute from the host object

         *

         * @method removeAttr

         * @param {String} name The name of the attribute to be removed.

         */

        removeAttr: function(name) {

            this._state.removeAll(name);

        },

        /**

         * Resets the attribute (or all attributes) to its initial value, as long as

         * the attribute is not readOnly, or writeOnce.

         *

         * @method reset

         * @param {String} name Optional. The name of the attribute to reset.  If omitted, all attributes are reset.

         * @return {Object} A reference to the host object.

         * @chainable

         */

        reset : function(name) {

            var host = this;  // help compression

            if (name) {

                if (host._isLazyAttr(name)) {

                    host._addLazyAttr(name);

                }

                host.set(name, host._state.get(name, INIT_VALUE));

            } else {

                Y.Object.each(host._state.data, function(v, n) {

                    host.reset(n);

                });

            }

            return host;

        },

        /**

         * Returns an object with the configuration properties (and value)

         * for the given attribute. If attrName is not provided, returns the

         * configuration properties for all attributes.

         *

         * @method _getAttrCfg

         * @protected

         * @param {String} name Optional. The attribute name. If not provided, the method will return the configuration for all attributes.

         * @return {Object} The configuration properties for the given attribute, or all attributes.

         */

        _getAttrCfg : function(name) {

            var o,

                state = this._state;

            if (name) {

                o = state.getAll(name) || {};

            } else {

                o = {};

                Y.each(state.data, function(v, n) {

                    o[n] = state.getAll(n);

                });

            }

            return o;

        }

    };

    Y.AttributeExtras = AttributeExtras;

}, '@VERSION@', {"requires": ["oop"]});