// jquery1.2.3
var expando = 'jQuery'+(new Date()).getTime(),
  uuid = 0,
  windowData = {};

jQuery.extend({
  cache: {},
  data: function(elem, name, data){
    elem = elem == window ? windowData : elem; // 对window对象进行处理
    var id = elem[expando];
    if(!id){ // 若没有UUID，则新建一个
      id = elem[expando] = ++uuid;
    }
    // 若没有在$.cache中，则先新建
    if(name && !jQuery.cache[id]){
      jQuery.cache[id] = {};
    }
    // 第三个参数不为undefined时为写操作
    if(data != undefined){
      jQuery.cache[id][name] = data;
    }
    // 若只有一个参数，则返回缓存对象，两个参数则返回目标数据
    return name ? jQuery.cache[id][name] : id;
  },

  removeData: function(elem, name){
    elem = elem == window ? windowData : elem;
    var id = elem[expando];
    if(name){// 移除目标数据
      if(jQuery.cache[id]){
        delete jQuery.cache[id][id];
        name = '';

        for(name in jQuery.cache[id]){
          break;
        }
        // 遍历缓存体，若不为空则改写name，若没有被改写，则!name为true
        // 从而引发再次调用此方法，此时只传入一个参数，移除缓存体
        if(!name){
          jQuery.removeData(elem);
        }
      }else{
        // 移除UUID，但IE下对元素使用delete会抛错
        try{
          delete elem[expando];
        }catch(e){
          if(elem.removeAttribute){
            elem.removeAttribute(expando);
          }
        }
        // 注销cache
        delete jQuery.cache[id];
      }
    }
  }
})

function Data(){
    this.cache = {};
}

Data.uid = 1;

Data.prototype = {
    locker: function(owner){ // owner为元素节点、文档对象、window对象
        // 首先检查它们的valueOf方法是否被重写过
        // 对构造器进行原型重写成本太大，转而为每一个实例的valueOf方法进行重写
        // 检测方式为传入Data类，若返回object说明没有被重写，返回string则已被重写
        // 这个字符串就是UUID，用于在缓存仓库创建缓存体
        var ovalueOf,
            unlock = owner.valueOf(Data);

        // 重写使用Object.defineProperty方法
        // 其第三个参数为对象，若不显示设置enumerable、writable、configurable
        // 则默认设置false，这个过程被jquery称为开锁
        if(typeof unlock !== 'string'){
            unlock = jQuery.expando + Data.uid++;
            ovalueOf = owner.valueOf;

            Object.defineProperty(owner, 'valueOf', {
                value: function(pick){
                    if(pick === Data){
                        return unlock;
                    }
                    return ovalueOf.apply(owner);
                }
            });
        }

        // 接下来开辟缓存体
        if(!this.cache[unlock]){
            this.cache[unlock] = {};
        }

        return unlock;
    },

    set: function(owner, data, value){
        // 写方法
        var prop, cache, unlock;
        // UUID和缓存体
        unlock = this.locker(owner);
        cache = this.cache[unlock];
        // 若传入value，第2个为从字符串，则表示添加新键值对
        if(typeof data === 'string'){
            cache[data] = value;
        }else{
            // 传入2个参数，第二个为对象
            // 若缓存体没有添加过任何对象，则直接赋值，否则使用for in循环添加
            if(jQuery.isEmptyObject(cache)){
                cache = data;
            }else{
                for(prop in data){
                    cache[prop] = data[prop];
                }
            }
        }
        this.cache[unlock] = cache;
        return this;
    },

    get: function(owner, key){
        // 读方法
        var cache = this.cache[this.locker(owner)];
        // 若只有一个参数，则返回整个缓存体
        return key === undefined ? cache : cache[key];
    },

    access: function(owner, key, value){
        // 决定是读还是写
        if(key === undefined || ((key && typeof key === 'string') && value === undefined)){
            return this.get(owner, key);
        }
        this.set(owner, key, value);
        return value !== undefined ? value : key;
    },

    remove: function(owner, key){
        // 删除和第一代类似，略
    },

    hasData: function(owner){
        // 判断是否缓存了数据
        return !jQuery.isEmptyObject(this.cache[this.locker(owner)]);
    },

    discard: function(owner){
        // 删除owner相关的用户数据和私有数据
        delete this.cache[this.locker(owner)];
    }
};

var data_user = new Data(),
    data_priv = new Data();

function data_discard(owner){
    data_user.discard(owner);
    data_priv.discard(owner);
}

// 接下来暴露给用户调用的都是空壳，用来转交给data_user、data_priv这两个实例对象处理，
// 并且私有数据的处理也不通过用户数据的渠道了
jQuery.extend({
    // UUID
    expando: 'jQuery'+(core_version+Math.random()).replace(/\D/g, ''),
    // 用于向前兼容
    acceptData: function(){
        return true;
    },
    hasData: function(elem){
        return data_user.hasData(elem) || data_priv.hasData(elem);
    },
    data: function(elem, name, data){
        return data_user.access(elem, name, data);
    },
    removeData: function(elem, name){
        return data_user.remove(elem, name);
    },
    _data: function(elem, name, data){
        return data_priv.access(elem, name, data);
    },
    _removeData: function(elem, name){
        return data_priv.remove(elem, name);
    }
});