if (!dojo._hasResource["dojox.data.FlickrRestStore"]) { // _hasResource checks
														// added by build. Do
														// not use _hasResource
														// directly in your
														// code.
	dojo._hasResource["dojox.data.FlickrRestStore"] = true;
	dojo.provide("dojox.data.FlickrRestStore");

	dojo.require("dojox.data.FlickrStore");

	dojo.declare("dojox.data.FlickrRestStore", dojox.data.FlickrStore, {
		constructor : function(/* Object */args) {
			// summary:
			// Initializer for the FlickrRestStore store.
			// description:
			// The FlickrRestStore is a Datastore interface to one of the basic
			// services
			// of the Flickr service, the public photo feed. This does not
			// provide
			// access to all the services of Flickr.
			// This store cannot do * and ? filtering as the flickr service
			// provides no interface for wildcards.
			if (args && args.label) {
				if (args.label) {
					this.label = args.label;
				}
				if (args.apikey) {
					this._apikey = args.apikey;
				}
			}
			this._cache = [];
			this._prevRequests = {};
			this._handlers = {};
			this._prevRequestRanges = [];
			this._maxPhotosPerUser = {};
			this._id = dojox.data.FlickrRestStore.prototype._id++;
		},

		// _id: Integer
		// A unique identifier for this store.
		_id : 0,

		// _requestCount: Integer
		// A counter for the number of requests made. This is used to define
		// the callback function that Flickr will use.
		_requestCount : 0,

		// _flickrRestUrl: String
		// The URL to the Flickr REST services.
		_flickrRestUrl : "http://www.flickr.com/services/rest/",

		// _apikey: String
		// The users API key to be used when accessing Flickr REST services.
		_apikey : null,

		// _storeRef: String
		// A key used to mark an data store item as belonging to this store.
		_storeRef : "_S",

		// _cache: Array
		// An Array of all previously downloaded picture info.
		_cache : null,

		// _prevRequests: Object
		// A HashMap used to record the signature of a request to prevent
		// duplicate
		// request being made.
		_prevRequests : null,

		// _handlers: Object
		// A HashMap used to record the handlers registered for a single remote
		// request. Multiple
		// requests may be made for the same information before the first
		// request has finished.
		// Each element of this Object is an array of handlers to call back when
		// the request finishes.
		// This prevents multiple requests being made for the same information.
		_handlers : null,

		// _sortAttributes: Object
		// A quick lookup of valid attribute names in a sort query.
		_sortAttributes : {
			"date-posted" : true,
			"date-taken" : true,
			"interestingness" : true
		},

		_fetchItems : function(request, fetchHandler, errorHandler) {
			// summary: Fetch flickr items that match to a query
			// request:
			// A request object
			// fetchHandler:
			// A function to call for fetched items
			// errorHandler:
			// A function to call on error
			var query = {};
			if (!request.query) {
				request.query = query = {};
			} else {
				dojo.mixin(query, request.query);
			}

			var primaryKey = [];
			var secondaryKey = [];

			// Generate a unique function to be called back
			var callbackFn = "FlickrRestStoreCallback_" + this._id + "_"
					+ (++this._requestCount);
			// Build up the content to send the request for.
			var content = {
				format : "json",
				method : "flickr.photos.search",
				api_key : this._apikey,
				extras : "owner_name,date_upload,date_taken",
				jsoncallback : callbackFn
			};
			var isRest = false;
			if (query.userid) {
				isRest = true;
				content.user_id = request.query.userid;
				primaryKey.push("userid" + request.query.userid);
			}
			if (query.apikey) {
				isRest = true;
				content.api_key = request.query.apikey;
				secondaryKey.push("api" + request.query.apikey);
			} else {
				throw Error("dojox.data.FlickrRestStore: An API key must be specified.");
			}
			request._curCount = request.count;
			if (query.page) {
				content.page = request.query.page;
				secondaryKey.push("page" + content.page);
			} else if (typeof(request.start) != "undefined"
					&& request.start != null) {
				if (!request.count) {
					request.count = 20;
				}
				var diff = request.start % request.count;
				var start = request.start, count = request.count;
				// If the count does not divide cleanly into the start number,
				// more work has to be done to figure out the best page to
				// request
				if (diff != 0) {
					if (start < count / 2) {
						// If the first record requested is less than half the
						// amount requested,
						// then request from 0 to the count record
						count = start + count;
						start = 0;
					} else {
						var divLimit = 20, div = 2;
						for (var i = divLimit; i > 0; i--) {
							if (start % i == 0 && (start / i) >= count) {
								div = i;
								break;
							}
						}
						count = start / div;
					}
					request._realStart = request.start;
					request._realCount = request.count;
					request._curStart = start;
					request._curCount = count;
				} else {
					request._realStart = request._realCount = null;
					request._curStart = request.start;
					request._curCount = request.count;
				}

				content.page = (start / count) + 1;
				secondaryKey.push("page" + content.page);
			}
			if (request._curCount) {
				content.per_page = request._curCount;
				secondaryKey.push("count" + request._curCount);
			}

			if (query.lang) {
				content.lang = request.query.lang;
				primaryKey.push("lang" + request.lang);
			}
			var url = this._flickrRestUrl;

			if (query.setid) {
				content.method = "flickr.photosets.getPhotos";
				content.photoset_id = request.query.set;
				primaryKey.push("set" + request.query.set);
			}

			if (query.tags) {
				if (query.tags instanceof Array) {
					content.tags = query.tags.join(",");
				} else {
					content.tags = query.tags;
				}
				primaryKey.push("tags" + content.tags);

				if (query["tag_mode"]
						&& (query.tag_mode.toLowerCase() == "any" || query.tag_mode
								.toLowerCase() == "all")) {
					content.tag_mode = query.tag_mode;
				}
			}
			if (query.text) {
				content.text = query.text;
				primaryKey.push("text:" + query.text);
			}

			// The store only supports a single sort attribute, even though the
			// Read API technically allows multiple sort attributes
			if (query.sort && query.sort.length > 0) {
				// The default sort attribute is 'date-posted'
				if (!query.sort[0].attribute) {
					query.sort[0].attribute = "date-posted";
				}

				// If the sort attribute is valid, check if it is ascending or
				// descending.
				if (this._sortAttributes[query.sort[0].attribute]) {
					if (query.sort[0].descending) {
						content.sort = query.sort[0].attribute + "-desc";
					} else {
						content.sort = query.sort[0].attribute + "-asc";
					}
				}
			} else {
				// The default sort in the Dojo Data API is ascending.
				content.sort = "date-posted-asc";
			}
			primaryKey.push("sort:" + content.sort);

			// Generate a unique key for this request, so the store can
			// detect duplicate requests.
			primaryKey = primaryKey.join(".");
			secondaryKey = secondaryKey.length > 0 ? "."
					+ secondaryKey.join(".") : "";
			var requestKey = primaryKey + secondaryKey;

			// Make a copy of the request, in case the source object is modified
			// before the request completes
			request = {
				query : query,
				count : request._curCount,
				start : request._curStart,
				_realCount : request._realCount,
				_realStart : request._realStart,
				onBegin : request.onBegin,
				onComplete : request.onComplete,
				onItem : request.onItem
			};

			var thisHandler = {
				request : request,
				fetchHandler : fetchHandler,
				errorHandler : errorHandler
			};

			// If the request has already been made, but not yet completed,
			// then add the callback handler to the list of handlers
			// for this request, and finish.
			if (this._handlers[requestKey]) {
				this._handlers[requestKey].push(thisHandler);
				return;
			}

			this._handlers[requestKey] = [thisHandler];

			// Linking this up to Flickr is a PAIN!
			var self = this;
			var handle = null;
			var getArgs = {
				url : this._flickrRestUrl,
				preventCache : true,
				content : content
			};

			var doHandle = function(processedData, data, handler) {
				var onBegin = handler.request.onBegin;
				handler.request.onBegin = null;
				var maxPhotos;
				var req = handler.request;

				if (typeof(req._realStart) != undefined
						&& req._realStart != null) {
					req.start = req._realStart;
					req.count = req._realCount;
					req._realStart = req._realCount = null;
				}

				// If the request contains an onBegin method, the total number
				// of photos must be calculated.
				if (onBegin) {
					if (data && typeof(data.photos.perpage) != "undefined"
							&& typeof(data.photos.pages) != "undefined") {
						if (data.photos.perpage * data.photos.pages <= handler.request.start
								+ handler.request.count) {
							// If the final page of results has been received,
							// it is possible to
							// know exactly how many photos there are
							maxPhotos = handler.request.start
									+ data.photos.photo.length;
						} else {
							// If the final page of results has not yet been
							// received,
							// it is not possible to tell exactly how many
							// photos exist, so
							// return the number of pages multiplied by the
							// number of photos per page.
							maxPhotos = data.photos.perpage * data.photos.pages;
						}
						self._maxPhotosPerUser[primaryKey] = maxPhotos;
						onBegin(maxPhotos, handler.request);
					} else if (self._maxPhotosPerUser[primaryKey]) {
						onBegin(self._maxPhotosPerUser[primaryKey],
								handler.request);
					}
				}
				// Call whatever functions the caller has defined on the request
				// object, except for onBegin
				handler.fetchHandler(processedData, handler.request);
				if (onBegin) {
					// Replace the onBegin function, if it existed.
					handler.request.onBegin = onBegin;
				}
			};

			// Define a callback for the script that iterates through a list of
			// handlers for this piece of data. Multiple requests can come into
			// the store for the same data.
			var myHandler = function(data) {
				// The handler should not be called more than once, so
				// disconnect it.
				// if(handle !== null){ dojo.disconnect(handle); }
				if (data.stat != "ok") {
					errorHandler(null, request);
				} else { // Process the items...
					var handlers = self._handlers[requestKey];
					if (!handlers) {
						console.log("FlickrRestStore: no handlers for data",
								data);
						return;
					}

					self._handlers[requestKey] = null;
					self._prevRequests[requestKey] = data;

					// Process the data once.
					var processedData = self._processFlickrData(data, request,
							primaryKey);
					if (!self._prevRequestRanges[primaryKey]) {
						self._prevRequestRanges[primaryKey] = [];
					}
					self._prevRequestRanges[primaryKey].push({
								start : request.start,
								end : request.start + data.photos.photo.length
							});

					// Iterate through the array of handlers, calling each one.
					for (var i = 0; i < handlers.length; i++) {
						doHandle(processedData, data, handlers[i]);
					}
				}
			};

			var data = this._prevRequests[requestKey];

			// If the data was previously retrieved, there is no need to fetch
			// it again.
			if (data) {
				this._handlers[requestKey] = null;
				doHandle(this._cache[primaryKey], data, thisHandler);
				return;
			} else if (this._checkPrevRanges(primaryKey, request.start,
					request.count)) {
				// If this range of data has already been retrieved, reuse it.
				this._handlers[requestKey] = null;
				doHandle(this._cache[primaryKey], null, thisHandler);
				return;
			}

			dojo.global[callbackFn] = function(data) {
				myHandler(data);
				// Clean up the function, it should never be called again
				dojo.global[callbackFn] = null;
			};

			var deferred = dojo.io.script.get(getArgs);

			// We only set up the errback, because the callback isn't ever
			// really used because we have
			// to link to the jsonFlickrFeed function....
			deferred.addErrback(function(error) {
						dojo.disconnect(handle);
						errorHandler(error, request);
					});
		},

		getAttributes : function(item) {
			// summary:
			// See dojo.data.api.Read.getAttributes()
			return ["title", "author", "imageUrl", "imageUrlSmall",
					"imageUrlMedium", "imageUrlThumb", "link", "dateTaken",
					"datePublished"];
		},

		getValues : function(item, attribute) {
			// summary:
			// See dojo.data.api.Read.getValue()
			this._assertIsItem(item);
			this._assertIsAttribute(attribute);
			if (attribute === "title") {
				return [this._unescapeHtml(item.title)]; // String
			} else if (attribute === "author") {
				return [item.ownername]; // String
			} else if (attribute === "imageUrlSmall") {
				return [item.media.s]; // String
			} else if (attribute === "imageUrl") {
				return [item.media.l]; // String
			} else if (attribute === "imageUrlMedium") {
				return [item.media.m]; // String
			} else if (attribute === "imageUrlThumb") {
				return [item.media.t]; // String
			} else if (attribute === "link") {
				return ["http://www.flickr.com/photos/" + item.owner + "/"
						+ item.id]; // String
			} else if (attribute === "dateTaken") {
				return item.datetaken;
			} else if (attribute === "datePublished") {
				return item.datepublished;
			}

			return undefined;
		},

		_processFlickrData : function(/* Object */data, /* Object */request, /* String */
				cacheKey) {
			// summary: Processes the raw data from Flickr and updates the
			// internal cache.
			// data:
			// Data returned from Flickr
			// request:
			// The original dojo.data.Request object passed in by the user.

			// If the data contains an 'item' object, it has not come from the
			// REST services,
			// so process it using the FlickrStore.
			if (data.items) {
				return dojox.data.FlickrStore.prototype._processFlickrData
						.apply(this, arguments);
			}

			var template = ["http://farm", null, ".static.flickr.com/", null,
					"/", null, "_", null];

			var items = [];
			if (data.stat == "ok" && data.photos && data.photos.photo) {
				items = data.photos.photo;

				// Add on the store ref so that isItem can work.
				for (var i = 0; i < items.length; i++) {
					var item = items[i];
					item[this._storeRef] = this;

					template[1] = item.farm;
					template[3] = item.server;
					template[5] = item.id;
					template[7] = item.secret;

					var base = template.join("");
					item.media = {
						s : base + "_s.jpg",
						m : base + "_m.jpg",
						l : base + ".jpg",
						t : base + "_t.jpg"
					};
				}
			}
			var start = request.start ? request.start : 0;
			var arr = this._cache[cacheKey];
			if (!arr) {
				this._cache[cacheKey] = arr = [];
			}
			for (var count = 0; count < items.length; count++) {
				arr[count + start] = items[count];
			}

			return arr; // Array
		},

		_checkPrevRanges : function(primaryKey, start, count) {
			var end = start + count;
			var arr = this._prevRequestRanges[primaryKey];
			if (!arr) {
				return false;
			}
			for (var i = 0; i < arr.length; i++) {
				if (start >= arr[i].start && end <= arr[i].end) {
					return true;
				}
			}
			return false;
		}
	});

}