// Allow new AV.Object("ClassName") as a shortcut to _create.

if (_.isString(attributes)) {

return AV.Object._create.apply(this, arguments);

}

attributes = attributes || {};

if (options && options.parse) {

attributes = this.parse(attributes);

}

var defaults = AV._getValue(this, 'defaults');

if (defaults) {

attributes = _.extend({}, defaults, attributes);

}

if (options && options.collection) {

this.collection = options.collection;

}

this._serverData = {}; // The last known data for this object from cloud.

this._opSetQueue = [{}]; // List of sets of changes to the data.

this.attributes = {}; // The best estimate of this's current data.

this._hashedJSON = {}; // Hash of values of containers at last save.

this._escapedAttributes = {};

this.cid = _.uniqueId('c');

this.changed = {};

this._silent = {};

this._pending = {};

if (!this.set(attributes, {silent: true})) {

throw new Error("Can't create an invalid AV.Object");

}

this.changed = {};

this._silent = {};

this._pending = {};

this._hasData = true;

this._previousAttributes = _.clone(this.attributes);

this.initialize.apply(this, arguments);

console.warn('AV.Object#fetchWhenSave is deprecated, use AV.Object#save with options.fetchWhenSave instead.');

if (!_.isBoolean(enable)) {

throw "Expect boolean value for fetchWhenSave";

}

this._fetchWhenSave = enable;

var json = this._toFullJSON();

AV._arrayEach(["__type", "className"],

function(key) { delete json[key]; });

return json;

var json = _.clone(this.attributes);

AV._objectEach(json, function(val, key) {

json[key] = AV._encode(val, seenObjects);

});

AV._objectEach(this._operations, function(val, key) {

json[key] = val;

});

if (_.has(this, "id")) {

json.objectId = this.id;

}

if (_.has(this, "createdAt")) {

if (_.isDate(this.createdAt)) {

json.createdAt = this.createdAt.toJSON();

} else {

json.createdAt = this.createdAt;

}

}

if (_.has(this, "updatedAt")) {

if (_.isDate(this.updatedAt)) {

json.updatedAt = this.updatedAt.toJSON();

} else {

json.updatedAt = this.updatedAt;

}

}

json.__type = "Object";

json.className = this.className;

return json;

var self = this;

if (self._refreshingCache) {

return;

}

self._refreshingCache = true;

AV._objectEach(this.attributes, function(value, key) {

if (value instanceof AV.Object) {

value._refreshCache();

} else if (_.isObject(value)) {

if (self._resetCacheForKey(key)) {

self.set(key, new AV.Op.Set(value), { silent: true });

}

}

});

delete self._refreshingCache;

this._refreshCache();

var currentChanges = _.last(this._opSetQueue);

if (attr) {

return (currentChanges[attr] ? true : false);

}

if (!this.id) {

return true;

}

if (_.keys(currentChanges).length > 0) {

return true;

}

return false;

// if (!this.id) {

// throw new Error("Can't serialize an unsaved AV.Object");

// }

return { __type: "Pointer",

className: this.className,

objectId: this.id };

switch (attr) {

case 'objectId':

// 兼容 objectId

return this.id;

default:

// 兼容 createdAt、updatedAt

if (this.attributes[attr] === undefined) {

return this[attr];

} else {

return this.attributes[attr];

}

}

var value = this.get(attr);

if (value) {

if (!(value instanceof AV.Relation)) {

throw "Called relation() on non-relation field " + attr;

}

value._ensureParentAndKey(this, attr);

return value;

} else {

return new AV.Relation(this, attr);

}

var html = this._escapedAttributes[attr];

if (html) {

return html;

}

var val = this.attributes[attr];

var escaped;

if (AV._isNullOrUndefined(val)) {

escaped = '';

} else {

escaped = _.escape(val.toString());

}

this._escapedAttributes[attr] = escaped;

return escaped;

// Check for changes of magic fields.

var model = this;

var specialFields = ["id", "objectId", "createdAt", "updatedAt"];

AV._arrayEach(specialFields, function(attr) {

if (attrs[attr]) {

if (attr === "objectId") {

model.id = attrs[attr];

} else if ((attr === "createdAt" || attr === "updatedAt") &&

!_.isDate(attrs[attr])) {

model[attr] = AV._parseDate(attrs[attr]);

} else {

model[attr] = attrs[attr];

}

delete attrs[attr];

}

});

var self = this;

var failedChanges = _.first(this._opSetQueue);

this._opSetQueue = _.rest(this._opSetQueue);

var nextChanges = _.first(this._opSetQueue);

AV._objectEach(failedChanges, function(op, key) {

var op1 = failedChanges[key];

var op2 = nextChanges[key];

if (op1 && op2) {

nextChanges[key] = op2._mergeWithPrevious(op1);

} else if (op1) {

nextChanges[key] = op1;

}

});

this._saving = this._saving - 1;

// Grab a copy of any object referenced by this object. These instances

// may have already been fetched, and we don't want to lose their data.

// Note that doing it like this means we will unify separate copies of the

// same object, but that's a risk we have to take.

var fetchedObjects = {};

AV._traverse(this.attributes, function(object) {

if (object instanceof AV.Object && object.id && object._hasData) {

fetchedObjects[object.id] = object;

}

});

var savedChanges = _.first(this._opSetQueue);

this._opSetQueue = _.rest(this._opSetQueue);

this._applyOpSet(savedChanges, this._serverData);

this._mergeMagicFields(serverData);

var self = this;

AV._objectEach(serverData, function(value, key) {

self._serverData[key] = AV._decode(key, value);

// Look for any objects that might have become unfetched and fix them

// by replacing their values with the previously observed values.

var fetched = AV._traverse(self._serverData[key], function(object) {

if (object instanceof AV.Object && fetchedObjects[object.id]) {

return fetchedObjects[object.id];

}

});

if (fetched) {

self._serverData[key] = fetched;

}

});

this._rebuildAllEstimatedData();

this._saving = this._saving - 1;

// Clear out any changes the user might have made previously.

this._opSetQueue = [{}];

// Bring in all the new server data.

this._mergeMagicFields(serverData);

var self = this;

AV._objectEach(serverData, function(value, key) {

self._serverData[key] = AV._decode(key, value);

});

// Refresh the attributes.

this._rebuildAllEstimatedData();

// Clear out the cache of mutable containers.

this._refreshCache();

this._opSetQueue = [{}];

this._hasData = hasData;

var self = this;

AV._objectEach(opSet, function(change, key) {

target[key] = change._estimate(target[key], self, key);

if (target[key] === AV.Op._UNSET) {

delete target[key];

}

});

var value = this.attributes[key];

if (_.isObject(value) &&

!(value instanceof AV.Object) &&

!(value instanceof AV.File)) {

value = value.toJSON ? value.toJSON() : value;

var json = JSON.stringify(value);

if (this._hashedJSON[key] !== json) {

var wasSet = !! this._hashedJSON[key];

this._hashedJSON[key] = json;

return wasSet;

}

}

return false;

var self = this;

delete this.attributes[key];

if (this._serverData[key]) {

this.attributes[key] = this._serverData[key];

}

AV._arrayEach(this._opSetQueue, function(opSet) {

var op = opSet[key];

if (op) {

self.attributes[key] = op._estimate(self.attributes[key], self, key);

if (self.attributes[key] === AV.Op._UNSET) {

delete self.attributes[key];

} else {

self._resetCacheForKey(key);

}

}

});

var self = this;

var previousAttributes = _.clone(this.attributes);

this.attributes = _.clone(this._serverData);

AV._arrayEach(this._opSetQueue, function(opSet) {

self._applyOpSet(opSet, self.attributes);

AV._objectEach(opSet, function(op, key) {

self._resetCacheForKey(key);

});

});

// Trigger change events for anything that changed because of the fetch.

AV._objectEach(previousAttributes, function(oldValue, key) {

if (self.attributes[key] !== oldValue) {

self.trigger('change:' + key, self, self.attributes[key], {});

}

});

AV._objectEach(this.attributes, function(newValue, key) {

if (!_.has(previousAttributes, key)) {

self.trigger('change:' + key, self, newValue, {});

}

});

var attrs, attr;

if (_.isObject(key) || AV._isNullOrUndefined(key)) {

attrs = key;

AV._objectEach(attrs, function(v, k) {

attrs[k] = AV._decode(k, v);

});

options = value;

} else {

attrs = {};

attrs[key] = AV._decode(key, value);

}

// Extract attributes and options.

options = options || {};

if (!attrs) {

return this;

}

if (attrs instanceof AV.Object) {

attrs = attrs.attributes;

}

// If the unset option is used, every attribute should be a Unset.

if (options.unset) {

AV._objectEach(attrs, function(unused_value, key) {

attrs[key] = new AV.Op.Unset();

});

}

// Apply all the attributes to get the estimated values.

var dataToValidate = _.clone(attrs);

var self = this;

AV._objectEach(dataToValidate, function(value, key) {

if (value instanceof AV.Op) {

dataToValidate[key] = value._estimate(self.attributes[key],

self, key);

if (dataToValidate[key] === AV.Op._UNSET) {

delete dataToValidate[key];

}

}

});

// Run validation.

if (!this._validate(attrs, options)) {

return false;

}

this._mergeMagicFields(attrs);

options.changes = {};

var escaped = this._escapedAttributes;

var prev = this._previousAttributes || {};

// Update attributes.

AV._arrayEach(_.keys(attrs), function(attr) {

var val = attrs[attr];

// If this is a relation object we need to set the parent correctly,

// since the location where it was parsed does not have access to

// this object.

if (val instanceof AV.Relation) {

val.parent = self;

}

if (!(val instanceof AV.Op)) {

val = new AV.Op.Set(val);

}

// See if this change will actually have any effect.

var isRealChange = true;

if (val instanceof AV.Op.Set &&

_.isEqual(self.attributes[attr], val.value)) {

isRealChange = false;

}

if (isRealChange) {

delete escaped[attr];

if (options.silent) {

self._silent[attr] = true;

} else {

options.changes[attr] = true;

}

}

var currentChanges = _.last(self._opSetQueue);

currentChanges[attr] = val._mergeWithPrevious(currentChanges[attr]);

self._rebuildEstimatedDataForKey(attr);

if (isRealChange) {

self.changed[attr] = self.attributes[attr];

if (!options.silent) {

self._pending[attr] = true;

}

} else {

delete self.changed[attr];

delete self._pending[attr];

}

});

if (!options.silent) {

this.change(options);

}

return this;

options = options || {};

options.unset = true;

return this.set(attr, null, options);

if (_.isUndefined(amount) || _.isNull(amount)) {

amount = 1;

}

return this.set(attr, new AV.Op.Increment(amount));

options = options || {};

options.unset = true;

var keysToClear = _.extend(this.attributes, this._operations);

return this.set(keysToClear, options);

var json = _.clone(_.first(this._opSetQueue));

AV._objectEach(json, function(op, key) {

json[key] = op.toJSON();

});

return json;

var options = null;

var fetchOptions = {};

if(arguments.length === 1) {

options = arguments[0];

} else if(arguments.length === 2) {

fetchOptions = arguments[0];

options = arguments[1];

}

var self = this;

var request = AV._request('classes', this.className, this.id, 'GET',

fetchOptions, options.sessionToken);

return request.then(function(response) {

self._finishFetch(self.parse(response), true);

return self;

})._thenRunCallbacks(options, this);

var i, attrs, current, options, saved;

if (_.isObject(arg1) || AV._isNullOrUndefined(arg1)) {

attrs = arg1;

options = arg2;

} else {

attrs = {};

attrs[arg1] = arg2;

options = arg3;

}

// Make save({ success: function() {} }) work.

if (!options && attrs) {

var extra_keys = _.reject(attrs, function(value, key) {

return _.include(["success", "error", "wait"], key);

});

if (extra_keys.length === 0) {

var all_functions = true;

if (_.has(attrs, "success") && !_.isFunction(attrs.success)) {

all_functions = false;

}

if (_.has(attrs, "error") && !_.isFunction(attrs.error)) {

all_functions = false;

}

if (all_functions) {

// This attrs object looks like it's really an options object,

// and there's no other options object, so let's just use it.

return this.save(null, attrs);

}

}

}

options = _.clone(options) || {};

if (options.wait) {

current = _.clone(this.attributes);

}

var setOptions = _.clone(options) || {};

if (setOptions.wait) {

setOptions.silent = true;

}

var setError;

setOptions.error = function(model, error) {

setError = error;

};

if (attrs && !this.set(attrs, setOptions)) {

return AV.Promise.error(setError)._thenRunCallbacks(options, this);

}

var model = this;

// If there is any unsaved child, save it first.