Ext JS Sencha Docs

Ext.data.identifier.Uuid

Hierarchy

Inherited mixins

Files

This class generates UUID's according to RFC 4122. This class has a default id property. This means that a single instance is shared unless the id property is overridden. Thus, two Ext.data.Model instances configured like the following share one generator:

Ext.define('MyApp.data.MyModelX', {
    extend: 'Ext.data.Model',
    identifier: 'uuid'
});

Ext.define('MyApp.data.MyModelY', {
    extend: 'Ext.data.Model',
    identifier: 'uuid'
});

This allows all models using this class to share a commonly configured instance.

Using Version 1 ("Sequential") UUID's

If a server can provide a proper timestamp and a "cryptographic quality random number" (as described in RFC 4122), the shared instance can be configured as follows:

Ext.data.identifier.Uuid.Global.reconfigure({
    version: 1,
    clockSeq: clock, // 14 random bits
    salt: salt,      // 48 secure random bits (the Node field)
    timestamp: ts    // timestamp per Section 4.1.4
});

// or these values can be split into 32-bit chunks:

Ext.data.identifier.Uuid.Global.reconfigure({
    version: 1,
    clockSeq: clock,
    salt: { lo: saltLow32, hi: saltHigh32 },
    timestamp: { lo: timestampLow32, hi: timestamptHigh32 }
});

This approach improves the generator's uniqueness by providing a valid timestamp and higher quality random data. Version 1 UUID's should not be used unless this information can be provided by a server and care should be taken to avoid caching of this data.

See http://www.ietf.org/rfc/rfc4122.txt for details.

Defined By

Config options

Ext.data.identifier.Uuid
view source
: Number
A clock value to help avoid duplicates. ...

A clock value to help avoid duplicates.

Only applicable when version is set to 1.

Ext.data.identifier.Uuid
view source
: Object
The id for this generator instance. ...

The id for this generator instance. By default all model instances share the same UUID generator instance. By specifying an id other then 'uuid', a unique generator instance will be created for the Model.

Overrides: Ext.data.identifier.Generator.id

Ext.data.identifier.Uuid
view source
: Number/Object
This value is a 48-bit number. ...

This value is a 48-bit number. This can be a number or an object with hi and lo properties where lo is the low 32-bits and hi is the upper 16 bits.

Only applicable when version is set to 1.

Ext.data.identifier.Uuid
view source
: Number/Object
When created, this value is a 60-bit number. ...

When created, this value is a 60-bit number. This can be a number or an object with hi and lo properties where lo is the low 32-bits and hi is the upper 28 bits.

Only applicable when version is set to 1.

Ext.data.identifier.Uuid
view source
: Number
The Version of UUID. ...

The Version of UUID. Supported values are:

  • 1 : Time-based, "sequential" UUID. To use this type of generator, you must also specify the salt, timestamp and clock properties. For details on the values and how a server should produce them, see RFC 4122. Use of this type of generator produces values that are easier to read since they are sequential, but requires some care to initialize properly and still ensure their uniqueness.

  • 4 : Pseudo-random UUID. This is the simplest form and requires no configuration and hence is the default type.

Defaults to: 4

Properties

Defined By

Instance properties

...

Defaults to: 'Ext.Base'

The value true causes config values to be stored on instances using a property name prefixed with an underscore ("_")...

The value true causes config values to be stored on instances using a property name prefixed with an underscore ("_") character. A value of false stores config values as properties using their exact name (no prefix).

Defaults to: false

Available since: 5.0.0

Overrides: Ext.Component.$configPrefixed, Ext.data.AbstractStore.$configPrefixed, Ext.layout.Layout.$configPrefixed, Ext.layout.container.boxOverflow.None.$configPrefixed

The value true instructs the initConfig method to only honor values for properties declared in the config block of a ...

The value true instructs the initConfig method to only honor values for properties declared in the config block of a class. When false, properties that are not declared in a config block will be placed on the instance.

Defaults to: true

Available since: 5.0.0

Overrides: Ext.Component.$configStrict, Ext.data.AbstractStore.$configStrict, Ext.layout.Layout.$configStrict, Ext.layout.container.boxOverflow.None.$configStrict

Ext.data.identifier.Uuid
view source
: Objectprivate
this is used by Factoryable ...

this is used by Factoryable

Defaults to: {defaultType: 'sequential'}

Overrides: Ext.mixin.Factoryable.factoryConfig

This property is set to true during the call to initConfig. ...

This property is set to true during the call to initConfig.

Defaults to: false

Available since: 5.0.0

This property is set to true if this instance is the first of its class. ...

This property is set to true if this instance is the first of its class.

Defaults to: false

Available since: 5.0.0

true in this class to identify an object as an instantiated IdGenerator, or subclass thereof. ...

true in this class to identify an object as an instantiated IdGenerator, or subclass thereof.

Defaults to: true

This value is true and is used to identify plain objects from instances of a defined class. ...

This value is true and is used to identify plain objects from instances of a defined class.

Defaults to: true

Ext.data.identifier.Uuid
view source
: Booleanprivate
Provides a way to determine if this identifier supports creating unique IDs. ...

Provides a way to determine if this identifier supports creating unique IDs. Proxies like Ext.data.proxy.LocalStorage need the identifier to create unique IDs and will check this property.

Defaults to: true

...

Defaults to: 'factoryable'

Overrides: Ext.mixin.Identifiable.mixinId

Get the reference to the current class from which this object was instantiated. ...

Get the reference to the current class from which this object was instantiated. Unlike statics, this.self is scope-dependent and it's meant to be used for dynamic inheritance. See statics for a detailed comparison

Ext.define('My.Cat', {
    statics: {
        speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
    },

    constructor: function() {
        alert(this.self.speciesName); // dependent on 'this'
    },

    clone: function() {
        return new this.self();
    }
});


Ext.define('My.SnowLeopard', {
    extend: 'My.Cat',
    statics: {
        speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
    }
});

var cat = new My.Cat();                     // alerts 'Cat'
var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'

var clone = snowLeopard.clone();
alert(Ext.getClassName(clone));             // alerts 'My.SnowLeopard'
Defined By

Static properties

...

Defaults to: []

Methods

Defined By

Instance methods

Initializes a new instance. ...

Initializes a new instance.

Parameters

  • config : Object (optional)

    Configuration object to be applied to the new instance.

Returns

Fires

    ( deprecations )private
    This method applies a versioned, deprecation declaration to this class. ...

    This method applies a versioned, deprecation declaration to this class. This is typically called by the deprecated config.

    Parameters

    ( args ) : Objectdeprecatedprotected
    Call the original method that was previously overridden with override Ext.define('My.Cat', { constructor: functi...

    Call the original method that was previously overridden with override

    Ext.define('My.Cat', {
        constructor: function() {
            alert("I'm a cat!");
        }
    });
    
    My.Cat.override({
        constructor: function() {
            alert("I'm going to be a cat!");
    
            this.callOverridden();
    
            alert("Meeeeoooowwww");
        }
    });
    
    var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                              // alerts "I'm a cat!"
                              // alerts "Meeeeoooowwww"
    

    This method has been deprecated

    Use callParent instead.

    Parameters

    • args : Array/Arguments

      The arguments, either an array or the arguments object from the current method, for example: this.callOverridden(arguments)

    Returns

    • Object

      Returns the result of calling the overridden method

    Call the "parent" method of the current method. ...

    Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext.define).

     Ext.define('My.Base', {
         constructor: function (x) {
             this.x = x;
         },
    
         statics: {
             method: function (x) {
                 return x;
             }
         }
     });
    
     Ext.define('My.Derived', {
         extend: 'My.Base',
    
         constructor: function () {
             this.callParent([21]);
         }
     });
    
     var obj = new My.Derived();
    
     alert(obj.x);  // alerts 21
    

    This can be used with an override as follows:

     Ext.define('My.DerivedOverride', {
         override: 'My.Derived',
    
         constructor: function (x) {
             this.callParent([x*2]); // calls original My.Derived constructor
         }
     });
    
     var obj = new My.Derived();
    
     alert(obj.x);  // now alerts 42
    

    This also works with static methods.

     Ext.define('My.Derived2', {
         extend: 'My.Base',
    
         statics: {
             method: function (x) {
                 return this.callParent([x*2]); // calls My.Base.method
             }
         }
     });
    
     alert(My.Base.method(10));     // alerts 10
     alert(My.Derived2.method(10)); // alerts 20
    

    Lastly, it also works with overridden static methods.

     Ext.define('My.Derived2Override', {
         override: 'My.Derived2',
    
         statics: {
             method: function (x) {
                 return this.callParent([x*2]); // calls My.Derived2.method
             }
         }
     });
    
     alert(My.Derived2.method(10); // now alerts 40
    

    To override a method and replace it and also call the superclass method, use callSuper. This is often done to patch a method to fix a bug.

    Parameters

    • args : Array/Arguments

      The arguments, either an array or the arguments object from the current method, for example: this.callParent(arguments)

    Returns

    • Object

      Returns the result of calling the parent method

    This method is used by an override to call the superclass method but bypass any overridden method. ...

    This method is used by an override to call the superclass method but bypass any overridden method. This is often done to "patch" a method that contains a bug but for whatever reason cannot be fixed directly.

    Consider:

     Ext.define('Ext.some.Class', {
         method: function () {
             console.log('Good');
         }
     });
    
     Ext.define('Ext.some.DerivedClass', {
         extend: 'Ext.some.Class',
    
         method: function () {
             console.log('Bad');
    
             // ... logic but with a bug ...
    
             this.callParent();
         }
     });
    

    To patch the bug in Ext.some.DerivedClass.method, the typical solution is to create an override:

     Ext.define('App.patches.DerivedClass', {
         override: 'Ext.some.DerivedClass',
    
         method: function () {
             console.log('Fixed');
    
             // ... logic but with bug fixed ...
    
             this.callSuper();
         }
     });
    

    The patch method cannot use callParent to call the superclass method since that would call the overridden method containing the bug. In other words, the above patch would only produce "Fixed" then "Good" in the console log, whereas, using callParent would produce "Fixed" then "Bad" then "Good".

    Parameters

    • args : Array/Arguments

      The arguments, either an array or the arguments object from the current method, for example: this.callSuper(arguments)

    Returns

    • Object

      Returns the result of calling the superclass method

    Create a copy of this identifier. ...

    Create a copy of this identifier.

    Parameters

    Returns

    Fires

      This method is called to cleanup an object and its resources. ...

      This method is called to cleanup an object and its resources. After calling this method, the object should not be used any further.

      Fires

        Overrides: Ext.util.ElementContainer.destroy, Ext.state.Stateful.destroy, Ext.Component.destroy, Ext.mixin.Observable.destroy, Ext.data.AbstractStore.destroy, Ext.Base.destroy, Ext.plugin.Abstract.destroy, Ext.draw.sprite.Sprite.destroy, Ext.app.BaseController.destroy

        Generates and returns the next id. ...

        Generates and returns the next id. This method must be implemented by the derived class.

        Returns

        Returns a specified config property value. ...

        Returns a specified config property value. If the name parameter is not passed, all current configuration options will be returned as key value pairs.

        Parameters

        • name : String (optional)

          The name of the config property to get.

        • peek : Boolean (optional)

          true to peek at the raw value without calling the getter.

          Defaults to: false

        Returns

        • Object

          The config property value.

        Ext.data.identifier.Uuid
        view source
        ( ) : Object
        Returns the value of id. ...

        Returns the value of id.

        Returns

        Overrides: Ext.data.identifier.Generator.getId

        Returns the initial configuration passed to constructor when instantiating this class. ...

        Returns the initial configuration passed to constructor when instantiating this class.

        Parameters

        • name : String (optional)

          Name of the config option to return.

        Returns

        • Object/Mixed

          The full config object or a single config value when name parameter specified.

        ...

        Parameters

        ( config ) : Ext.Basechainableprotected
        Initialize configuration for this class. ...

        Initialize configuration for this class. a typical example:

        Ext.define('My.awesome.Class', {
            // The default config
            config: {
                name: 'Awesome',
                isAwesome: true
            },
        
            constructor: function(config) {
                this.initConfig(config);
            }
        });
        
        var awesome = new My.awesome.Class({
            name: 'Super Awesome'
        });
        
        alert(awesome.getName()); // 'Super Awesome'
        

        Parameters

        Returns

        Fires

          ...

          Parameters

          Ext.data.identifier.Uuid
          view source
          ( config )
          Reconfigures this generator given new config properties. ...

          Reconfigures this generator given new config properties. The only values that this changes are version and, if version is 1, its related config properties.

          Parameters

          ( name, [value] ) : Ext.Basechainable
          Sets a single/multiple configuration options. ...

          Sets a single/multiple configuration options.

          Parameters

          • name : String/Object

            The name of the property to set, or a set of key value pairs to set.

          • value : Object (optional)

            The value to set for the name parameter.

          Returns

          Fires

            Ext.data.identifier.Uuid
            view source
            ( id )
            Sets the value of id. ...

            Sets the value of id.

            Parameters

            Overrides: Ext.data.identifier.Generator.setId

            Get the reference to the class from which this object was instantiated. ...

            Get the reference to the class from which this object was instantiated. Note that unlike self, this.statics() is scope-independent and it always returns the class from which it was called, regardless of what this points to during run-time

            Ext.define('My.Cat', {
                statics: {
                    totalCreated: 0,
                    speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
                },
            
                constructor: function() {
                    var statics = this.statics();
            
                    alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
                                                    // equivalent to: My.Cat.speciesName
            
                    alert(this.self.speciesName);   // dependent on 'this'
            
                    statics.totalCreated++;
                },
            
                clone: function() {
                    var cloned = new this.self();   // dependent on 'this'
            
                    cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName
            
                    return cloned;
                }
            });
            
            
            Ext.define('My.SnowLeopard', {
                extend: 'My.Cat',
            
                statics: {
                    speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
                },
            
                constructor: function() {
                    this.callParent();
                }
            });
            
            var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'
            
            var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
            
            var clone = snowLeopard.clone();
            alert(Ext.getClassName(clone));         // alerts 'My.SnowLeopard'
            alert(clone.groupName);                 // alerts 'Cat'
            
            alert(My.Cat.totalCreated);             // alerts 3
            

            Returns

            Defined By

            Static methods

            ( config, [mixinClass] )privatestatic
            Adds new config properties to this class. ...

            Adds new config properties to this class. This is called for classes when they are declared, then for any mixins that class may define and finally for any overrides defined that target the class.

            Parameters

            • config : Object
            • mixinClass : Class (optional)

              The mixin class if the configs are from a mixin.

            ( members )chainableprivatestatic
            ...

            Parameters

            ( name, member )chainableprivatestatic
            ...

            Parameters

            ( members, [isStatic], [privacy] )chainablestatic
            Add methods / properties to the prototype of this class. ...

            Add methods / properties to the prototype of this class.

            Ext.define('My.awesome.Cat', {
                constructor: function() {
                    ...
                }
            });
            
             My.awesome.Cat.addMembers({
                 meow: function() {
                    alert('Meowww...');
                 }
             });
            
             var kitty = new My.awesome.Cat();
             kitty.meow();
            

            Parameters

            • members : Object

              The members to add to this class.

            • isStatic : Boolean (optional)

              Pass true if the members are static.

              Defaults to: false

            • privacy : Boolean (optional)

              Pass true if the members are private. This only has meaning in debug mode and only for methods.

              Defaults to: false

            ( members ) : Ext.Basechainablestatic
            Add / override static properties of this class. ...

            Add / override static properties of this class.

            Ext.define('My.cool.Class', {
                ...
            });
            
            My.cool.Class.addStatics({
                someProperty: 'someValue',      // My.cool.Class.someProperty = 'someValue'
                method1: function() { ... },    // My.cool.Class.method1 = function() { ... };
                method2: function() { ... }     // My.cool.Class.method2 = function() { ... };
            });
            

            Parameters

            Returns

            ( fromClass, members ) : Ext.Baseprivatestatic
            Borrow another class' members to the prototype of this class. ...

            Borrow another class' members to the prototype of this class.

            Ext.define('Bank', {
                money: '$$$',
                printMoney: function() {
                    alert('$$$$$$$');
                }
            });
            
            Ext.define('Thief', {
                ...
            });
            
            Thief.borrow(Bank, ['money', 'printMoney']);
            
            var steve = new Thief();
            
            alert(steve.money); // alerts '$$$'
            steve.printMoney(); // alerts '$$$$$$$'
            

            Parameters

            • fromClass : Ext.Base

              The class to borrow members from

            • members : Array/String

              The names of the members to borrow

            Returns

            ( args )protectedstatic
            ...

            Parameters

            ( args )protectedstatic
            ...

            Parameters

            Create a new instance of this Class. ...

            Create a new instance of this Class.

            Ext.define('My.cool.Class', {
                ...
            });
            
            My.cool.Class.create({
                someConfig: true
            });
            

            All parameters are passed to the constructor of the class.

            Returns

            ( alias, origin )static
            Create aliases for existing prototype methods. ...

            Create aliases for existing prototype methods. Example:

            Ext.define('My.cool.Class', {
                method1: function() { ... },
                method2: function() { ... }
            });
            
            var test = new My.cool.Class();
            
            My.cool.Class.createAlias({
                method3: 'method1',
                method4: 'method2'
            });
            
            test.method3(); // test.method1()
            
            My.cool.Class.createAlias('method5', 'method3');
            
            test.method5(); // test.method3() -> test.method1()
            

            Parameters

            Ext.data.identifier.Uuid
            view source
            ( )privatestatic
            ...
            Ext.data.identifier.Uuid
            view source
            ( salt, time, clockSeq )privatestatic
            ...

            Parameters

            ( config )privatestatic
            ...

            Parameters

            Returns the Ext.Configurator for this class. ...

            Returns the Ext.Configurator for this class.

            Returns

            Get the current class' name in string format. ...

            Get the current class' name in string format.

            Ext.define('My.cool.Class', {
                constructor: function() {
                    alert(this.self.getName()); // alerts 'My.cool.Class'
                }
            });
            
            My.cool.Class.getName(); // 'My.cool.Class'
            

            Returns

            ( name, mixinClass )privatestatic
            Used internally by the mixins pre-processor ...

            Used internally by the mixins pre-processor

            Parameters

            ( fn, scope )chainableprivatestatic
            ...

            Parameters

            Override members of this class. ...

            Override members of this class. Overridden methods can be invoked via callParent.

            Ext.define('My.Cat', {
                constructor: function() {
                    alert("I'm a cat!");
                }
            });
            
            My.Cat.override({
                constructor: function() {
                    alert("I'm going to be a cat!");
            
                    this.callParent(arguments);
            
                    alert("Meeeeoooowwww");
                }
            });
            
            var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                                      // alerts "I'm a cat!"
                                      // alerts "Meeeeoooowwww"
            

            Direct use of this method should be rare. Use Ext.define instead:

            Ext.define('My.CatOverride', {
                override: 'My.Cat',
                constructor: function() {
                    alert("I'm going to be a cat!");
            
                    this.callParent(arguments);
            
                    alert("Meeeeoooowwww");
                }
            });
            

            The above accomplishes the same result but can be managed by the Ext.Loader which can properly order the override and its target class and the build process can determine whether the override is needed based on the required state of the target class (My.Cat).

            Parameters

            • members : Object

              The properties to add to this class. This should be specified as an object literal containing one or more properties.

            Returns