olingo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kobl...@apache.org
Subject [5/8] olingo-odata4-js git commit: [OLINGO-442] Cleanup bevore release II and beta-name removal
Date Mon, 23 Mar 2015 13:54:02 GMT
http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/27f830e6/lib/store/dom.js
----------------------------------------------------------------------
diff --git a/lib/store/dom.js b/lib/store/dom.js
new file mode 100644
index 0000000..e14bb6b
--- /dev/null
+++ b/lib/store/dom.js
@@ -0,0 +1,332 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+'use strict';
+
+/** @module store/dom */
+
+
+
+var utils = require('./../utils.js');
+
+// Imports.
+var throwErrorCallback = utils.throwErrorCallback;
+var delay = utils.delay;
+
+var localStorage = null;
+
+/** This method is used to override the Date.toJSON method and is called only by
+ * JSON.stringify.  It should never be called directly.
+ * @summary Converts a Date object into an object representation friendly to JSON serialization.
+ * @returns {Object} Object that represents the Date.
+ */
+function domStoreDateToJSON() {
+    var newValue = { v: this.valueOf(), t: "[object Date]" };
+    // Date objects might have extra properties on them so we save them.
+    for (var name in this) {
+        newValue[name] = this[name];
+    }
+    return newValue;
+}
+
+/** This method is used during JSON parsing and invoked only by the reviver function.
+ * It should never be called directly.
+ * @summary JSON reviver function for converting an object representing a Date in a JSON stream to a Date object
+ * @param value _
+ * @param value - Object to convert.
+ * @returns {Date} Date object.
+ */
+function domStoreJSONToDate(_, value) {
+    if (value && value.t === "[object Date]") {
+        var newValue = new Date(value.v);
+        for (var name in value) {
+            if (name !== "t" && name !== "v") {
+                newValue[name] = value[name];
+            }
+        }
+        value = newValue;
+    }
+    return value;
+}
+
+/** Qualifies the key with the name of the store.
+ * @param {Object} store - Store object whose name will be used for qualifying the key.
+ * @param {String} key - Key string.
+ * @returns {String} Fully qualified key string.
+ */
+function qualifyDomStoreKey(store, key) {
+    return store.name + "#!#" + key;
+}
+
+/** Gets the key part of a fully qualified key string.
+ * @param {Object} store - Store object whose name will be used for qualifying the key.
+ * @param {String} key - Fully qualified key string.
+ * @returns {String} Key part string
+ */
+function unqualifyDomStoreKey(store, key) {
+    return key.replace(store.name + "#!#", "");
+}
+
+/** Constructor for store objects that use DOM storage as the underlying mechanism.
+ * @class DomStore
+ * @constructor
+ * @param {String} name - Store name.
+ */
+function DomStore(name) {
+    this.name = name;
+}
+
+/** Creates a store object that uses DOM Storage as its underlying mechanism.
+ * @method module:store/dom~DomStore.create
+ * @param {String} name - Store name.
+ * @returns {Object} Store object.
+ */
+DomStore.create = function (name) {
+
+    if (DomStore.isSupported()) {
+        localStorage = localStorage || window.localStorage;
+        return new DomStore(name);
+    }
+
+    throw { message: "Web Storage not supported by the browser" };
+};
+
+/** Checks whether the underlying mechanism for this kind of store objects is supported by the browser.
+ * @method DomStore.isSupported
+ * @returns {Boolean} - True if the mechanism is supported by the browser; otherwise false.
+*/
+DomStore.isSupported = function () {
+    return !!window.localStorage;
+};
+
+/** Adds a new value identified by a key to the store.
+ * @method module:store/dom~DomStore#add
+ * @param {String} key - Key string.
+ * @param value - Value that is going to be added to the store.
+ * @param {Function} success - Callback for a successful add operation.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+ * This method errors out if the store already contains the specified key.
+ */
+DomStore.prototype.add = function (key, value, success, error) {
+    error = error || this.defaultError;
+    var store = this;
+    this.contains(key, function (contained) {
+        if (!contained) {
+            store.addOrUpdate(key, value, success, error);
+        } else {
+            delay(error, { message: "key already exists", key: key });
+        }
+    }, error);
+};
+
+/** This method will overwrite the key's current value if it already exists in the store; otherwise it simply adds the new key and value.
+ * @summary Adds or updates a value identified by a key to the store.
+ * @method module:store/dom~DomStore#addOrUpdate
+ * @param {String} key - Key string.
+ * @param value - Value that is going to be added or updated to the store.
+ * @param {Function} success - Callback for a successful add or update operation.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+ */
+DomStore.prototype.addOrUpdate = function (key, value, success, error) {
+    error = error || this.defaultError;
+
+    if (key instanceof Array) {
+        error({ message: "Array of keys not supported" });
+    } else {
+        var fullKey = qualifyDomStoreKey(this, key);
+        var oldDateToJSON = Date.prototype.toJSON;
+        try {
+            var storedValue = value;
+            if (storedValue !== undefined) {
+                // Dehydrate using json
+                Date.prototype.toJSON = domStoreDateToJSON;
+                storedValue = window.JSON.stringify(value);
+            }
+            // Save the json string.
+            localStorage.setItem(fullKey, storedValue);
+            delay(success, key, value);
+        }
+        catch (e) {
+            if (e.code === 22 || e.number === 0x8007000E) {
+                delay(error, { name: "QUOTA_EXCEEDED_ERR", error: e });
+            } else {
+                delay(error, e);
+            }
+        }
+        finally {
+            Date.prototype.toJSON = oldDateToJSON;
+        }
+    }
+};
+
+/** In case of an error, this method will not restore any keys that might have been deleted at that point.
+ * @summary Removes all the data associated with this store object.
+ * @method module:store/dom~DomStore#clear
+ * @param {Function} success - Callback for a successful clear operation.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+ */
+DomStore.prototype.clear = function (success, error) {
+
+    error = error || this.defaultError;
+    try {
+        var i = 0, len = localStorage.length;
+        while (len > 0 && i < len) {
+            var fullKey = localStorage.key(i);
+            var key = unqualifyDomStoreKey(this, fullKey);
+            if (fullKey !== key) {
+                localStorage.removeItem(fullKey);
+                len = localStorage.length;
+            } else {
+                i++;
+            }
+        }
+        delay(success);
+    }
+    catch (e) {
+        delay(error, e);
+    }
+};
+
+/** This function does nothing in DomStore as it does not have a connection model
+ * @method module:store/dom~DomStore#close
+ */
+DomStore.prototype.close = function () {
+};
+
+/** Checks whether a key exists in the store.
+ * @method module:store/dom~DomStore#contains
+ * @param {String} key - Key string.
+ * @param {Function} success - Callback indicating whether the store contains the key or not.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+*/
+DomStore.prototype.contains = function (key, success, error) {
+    error = error || this.defaultError;
+    try {
+        var fullKey = qualifyDomStoreKey(this, key);
+        var value = localStorage.getItem(fullKey);
+        delay(success, value !== null);
+    } catch (e) {
+        delay(error, e);
+    }
+};
+
+DomStore.prototype.defaultError = throwErrorCallback;
+
+/** Gets all the keys that exist in the store.
+ * @method module:store/dom~DomStore#getAllKeys
+ * @param {Function} success - Callback for a successful get operation.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+ */
+DomStore.prototype.getAllKeys = function (success, error) {
+
+    error = error || this.defaultError;
+
+    var results = [];
+    var i, len;
+
+    try {
+        for (i = 0, len = localStorage.length; i < len; i++) {
+            var fullKey = localStorage.key(i);
+            var key = unqualifyDomStoreKey(this, fullKey);
+            if (fullKey !== key) {
+                results.push(key);
+            }
+        }
+        delay(success, results);
+    }
+    catch (e) {
+        delay(error, e);
+    }
+};
+
+/** Identifies the underlying mechanism used by the store.*/
+DomStore.prototype.mechanism = "dom";
+
+/** Reads the value associated to a key in the store.
+ * @method module:store/dom~DomStore#read
+ * @param {String} key - Key string.
+ * @param {Function} success - Callback for a successful reads operation.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+ */
+DomStore.prototype.read = function (key, success, error) {
+
+    error = error || this.defaultError;
+
+    if (key instanceof Array) {
+        error({ message: "Array of keys not supported" });
+    } else {
+        try {
+            var fullKey = qualifyDomStoreKey(this, key);
+            var value = localStorage.getItem(fullKey);
+            if (value !== null && value !== "undefined") {
+                // Hydrate using json
+                value = window.JSON.parse(value, domStoreJSONToDate);
+            }
+            else {
+                value = undefined;
+            }
+            delay(success, key, value);
+        } catch (e) {
+            delay(error, e);
+        }
+    }
+};
+
+/** Removes a key and its value from the store.
+ * @method module:store/dom~DomStore#remove
+ * @param {String} key - Key string.
+ * @param {Function} success - Callback for a successful remove operation.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+ */
+DomStore.prototype.remove = function (key, success, error) {
+    error = error || this.defaultError;
+
+    if (key instanceof Array) {
+        error({ message: "Batches not supported" });
+    } else {
+        try {
+            var fullKey = qualifyDomStoreKey(this, key);
+            localStorage.removeItem(fullKey);
+            delay(success);
+        } catch (e) {
+            delay(error, e);
+        }
+    }
+};
+
+/** Updates the value associated to a key in the store.
+ * @method module:store/dom~DomStore#update
+ * @param {String} key - Key string.
+ * @param value - New value.
+ * @param {Function} success - Callback for a successful update operation.
+ * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked
+ * This method errors out if the specified key is not found in the store.
+ */
+DomStore.prototype.update = function (key, value, success, error) {
+    error = error || this.defaultError;
+    var store = this;
+    this.contains(key, function (contained) {
+        if (contained) {
+            store.addOrUpdate(key, value, success, error);
+        } else {
+            delay(error, { message: "key not found", key: key });
+        }
+    }, error);
+};
+
+module.exports = DomStore;
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/27f830e6/lib/store/indexeddb.js
----------------------------------------------------------------------
diff --git a/lib/store/indexeddb.js b/lib/store/indexeddb.js
new file mode 100644
index 0000000..d7527c1
--- /dev/null
+++ b/lib/store/indexeddb.js
@@ -0,0 +1,447 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+'use strict';
+
+/** @module store/indexeddb */
+var utils = require('./../utils.js');
+
+// Imports.
+var throwErrorCallback = utils.throwErrorCallback;
+var delay = utils.delay;
+
+
+var indexedDB = utils.inBrowser() ? window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB || window.indexedDB : undefined;
+var IDBKeyRange = utils.inBrowser() ? window.IDBKeyRange || window.webkitIDBKeyRange : undefined;
+var IDBTransaction = utils.inBrowser() ? window.IDBTransaction || window.webkitIDBTransaction || {} : {} ;
+
+var IDBT_READ_ONLY = IDBTransaction.READ_ONLY || "readonly";
+var IDBT_READ_WRITE = IDBTransaction.READ_WRITE || "readwrite";
+
+/** Returns either a specific error handler or the default error handler
+ * @param {Function} error - The specific error handler
+ * @param {Function} defaultError - The default error handler
+ * @returns {Function} The error callback
+ */
+function getError(error, defaultError) {
+
+    return function (e) {
+        var errorFunc = error || defaultError;
+        if (!errorFunc) {
+            return;
+        }
+
+        // Old api quota exceeded error support.
+        if (Object.prototype.toString.call(e) === "[object IDBDatabaseException]") {
+            if (e.code === 11 /* IndexedDb disk quota exceeded */) {
+                errorFunc({ name: "QuotaExceededError", error: e });
+                return;
+            }
+            errorFunc(e);
+            return;
+        }
+
+        var errName;
+        try {
+            var errObj = e.target.error || e;
+            errName = errObj.name;
+        } catch (ex) {
+            errName = (e.type === "blocked") ? "IndexedDBBlocked" : "UnknownError";
+        }
+        errorFunc({ name: errName, error: e });
+    };
+}
+
+/** Opens the store object's indexed db database.
+ * @param {IndexedDBStore} store - The store object
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+function openStoreDb(store, success, error) {
+
+    var storeName = store.name;
+    var dbName = "_odatajs_" + storeName;
+
+    var request = indexedDB.open(dbName);
+    request.onblocked = error;
+    request.onerror = error;
+
+    request.onupgradeneeded = function () {
+        var db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+            db.createObjectStore(storeName);
+        }
+    };
+
+    request.onsuccess = function (event) {
+        var db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+            // Should we use the old style api to define the database schema?
+            if ("setVersion" in db) {
+                var versionRequest = db.setVersion("1.0");
+                versionRequest.onsuccess = function () {
+                    var transaction = versionRequest.transaction;
+                    transaction.oncomplete = function () {
+                        success(db);
+                    };
+                    db.createObjectStore(storeName, null, false);
+                };
+                versionRequest.onerror = error;
+                versionRequest.onblocked = error;
+                return;
+            }
+
+            // The database doesn't have the expected store.
+            // Fabricate an error object for the event for the schema mismatch
+            // and error out.
+            event.target.error = { name: "DBSchemaMismatch" };
+            error(event);
+            return;
+        }
+
+        db.onversionchange = function(event) {
+            event.target.close();
+        };
+        success(db);
+    };
+}
+
+/** Opens a new transaction to the store
+ * @param {IndexedDBStore} store - The store object
+ * @param {Integer} mode - The read/write mode of the transaction (constants from IDBTransaction)
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+function openTransaction(store, mode, success, error) {
+
+    var storeName = store.name;
+    var storeDb = store.db;
+    var errorCallback = getError(error, store.defaultError);
+
+    if (storeDb) {
+        success(storeDb.transaction(storeName, mode));
+        return;
+    }
+
+    openStoreDb(store, function (db) {
+        store.db = db;
+        success(db.transaction(storeName, mode));
+    }, errorCallback);
+}
+
+/** Creates a new IndexedDBStore.
+ * @class IndexedDBStore
+ * @constructor
+ * @param {String} name - The name of the store.
+ * @returns {Object} The new IndexedDBStore.
+ */
+function IndexedDBStore(name) {
+    this.name = name;
+}
+
+/** Creates a new IndexedDBStore.
+ * @method module:store/indexeddb~IndexedDBStore.create
+ * @param {String} name - The name of the store.
+ * @returns {Object} The new IndexedDBStore.
+ */
+IndexedDBStore.create = function (name) {
+    if (IndexedDBStore.isSupported()) {
+        return new IndexedDBStore(name);
+    }
+
+    throw { message: "IndexedDB is not supported on this browser" };
+};
+
+/** Returns whether IndexedDB is supported.
+ * @method module:store/indexeddb~IndexedDBStore.isSupported
+ * @returns {Boolean} True if IndexedDB is supported, false otherwise.
+ */
+IndexedDBStore.isSupported = function () {
+    return !!indexedDB;
+};
+
+/** Adds a key/value pair to the store
+ * @method module:store/indexeddb~IndexedDBStore#add
+ * @param {String} key - The key
+ * @param {Object} value - The value
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+*/
+IndexedDBStore.prototype.add = function (key, value, success, error) {
+    var name = this.name;
+    var defaultError = this.defaultError;
+    var keys = [];
+    var values = [];
+
+    if (key instanceof Array) {
+        keys = key;
+        values = value;
+    } else {
+        keys = [key];
+        values = [value];
+    }
+
+    openTransaction(this, IDBT_READ_WRITE, function (transaction) {
+        transaction.onabort = getError(error, defaultError, key, "add");
+        transaction.oncomplete = function () {
+            if (key instanceof Array) {
+                success(keys, values);
+            } else {
+                success(key, value);
+            }
+        };
+
+        for (var i = 0; i < keys.length && i < values.length; i++) {
+            transaction.objectStore(name).add({ v: values[i] }, keys[i]);
+        }
+    }, error);
+};
+
+/** Adds or updates a key/value pair in the store
+ * @method module:store/indexeddb~IndexedDBStore#addOrUpdate
+ * @param {String} key - The key
+ * @param {Object} value - The value
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+IndexedDBStore.prototype.addOrUpdate = function (key, value, success, error) {
+    var name = this.name;
+    var defaultError = this.defaultError;
+    var keys = [];
+    var values = [];
+
+    if (key instanceof Array) {
+        keys = key;
+        values = value;
+    } else {
+        keys = [key];
+        values = [value];
+    }
+
+    openTransaction(this, IDBT_READ_WRITE, function (transaction) {
+        transaction.onabort = getError(error, defaultError);
+        transaction.oncomplete = function () {
+            if (key instanceof Array) {
+                success(keys, values);
+            } else {
+                success(key, value);
+            }
+        };
+
+        for (var i = 0; i < keys.length && i < values.length; i++) {
+            var record = { v: values[i] };
+            transaction.objectStore(name).put(record, keys[i]);
+        }
+    }, error);
+};
+
+/** Clears the store
+ * @method module:store/indexeddb~IndexedDBStore#clear
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+IndexedDBStore.prototype.clear = function (success, error) {
+    var name = this.name;
+    var defaultError = this.defaultError;
+    openTransaction(this, IDBT_READ_WRITE, function (transaction) {
+        transaction.onerror = getError(error, defaultError);
+        transaction.oncomplete = function () {
+            success();
+        };
+
+        transaction.objectStore(name).clear();
+    }, error);
+};
+
+/** Closes the connection to the database
+ * @method module:store/indexeddb~IndexedDBStore#close
+*/
+IndexedDBStore.prototype.close = function () {
+    
+    if (this.db) {
+        this.db.close();
+        this.db = null;
+    }
+};
+
+/** Returns whether the store contains a key
+ * @method module:store/indexeddb~IndexedDBStore#contains
+ * @param {String} key - The key
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+IndexedDBStore.prototype.contains = function (key, success, error) {
+    var name = this.name;
+    var defaultError = this.defaultError;
+    openTransaction(this, IDBT_READ_ONLY, function (transaction) {
+        var objectStore = transaction.objectStore(name);
+        var request = objectStore.get(key);
+
+        transaction.oncomplete = function () {
+            success(!!request.result);
+        };
+        transaction.onerror = getError(error, defaultError);
+    }, error);
+};
+
+IndexedDBStore.prototype.defaultError = throwErrorCallback;
+
+/** Gets all the keys from the store
+ * @method module:store/indexeddb~IndexedDBStore#getAllKeys
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+IndexedDBStore.prototype.getAllKeys = function (success, error) {
+    var name = this.name;
+    var defaultError = this.defaultError;
+    openTransaction(this, IDBT_READ_WRITE, function (transaction) {
+        var results = [];
+
+        transaction.oncomplete = function () {
+            success(results);
+        };
+
+        var request = transaction.objectStore(name).openCursor();
+
+        request.onerror = getError(error, defaultError);
+        request.onsuccess = function (event) {
+            var cursor = event.target.result;
+            if (cursor) {
+                results.push(cursor.key);
+                // Some tools have issues because continue is a javascript reserved word.
+                cursor["continue"].call(cursor);
+            }
+        };
+    }, error);
+};
+
+/** Identifies the underlying mechanism used by the store.
+*/
+IndexedDBStore.prototype.mechanism = "indexeddb";
+
+/** Reads the value for the specified key
+ * @method module:store/indexeddb~IndexedDBStore#read
+ * @param {String} key - The key
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ * If the key does not exist, the success handler will be called with value = undefined
+ */
+IndexedDBStore.prototype.read = function (key, success, error) {
+    var name = this.name;
+    var defaultError = this.defaultError;
+    var keys = (key instanceof Array) ? key : [key];
+
+    openTransaction(this, IDBT_READ_ONLY, function (transaction) {
+        var values = [];
+
+        transaction.onerror = getError(error, defaultError, key, "read");
+        transaction.oncomplete = function () {
+            if (key instanceof Array) {
+                success(keys, values);
+            } else {
+                success(keys[0], values[0]);
+            }
+        };
+
+        for (var i = 0; i < keys.length; i++) {
+            // Some tools have issues because get is a javascript reserved word. 
+            var objectStore = transaction.objectStore(name);
+            var request = objectStore.get.call(objectStore, keys[i]);
+            request.onsuccess = function (event) {
+                var record = event.target.result;
+                values.push(record ? record.v : undefined);
+            };
+        }
+    }, error);
+};
+
+/** Removes the specified key from the store
+ * @method module:store/indexeddb~IndexedDBStore#remove
+ * @param {String} key - The key
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+IndexedDBStore.prototype.remove = function (key, success, error) {
+
+    var name = this.name;
+    var defaultError = this.defaultError;
+    var keys = (key instanceof Array) ? key : [key];
+
+    openTransaction(this, IDBT_READ_WRITE, function (transaction) {
+        transaction.onerror = getError(error, defaultError);
+        transaction.oncomplete = function () {
+            success();
+        };
+
+        for (var i = 0; i < keys.length; i++) {
+            // Some tools have issues because continue is a javascript reserved word.
+            var objectStore = transaction.objectStore(name);
+            objectStore["delete"].call(objectStore, keys[i]);
+        }
+    }, error);
+};
+
+/** Updates a key/value pair in the store
+ * @method module:store/indexeddb~IndexedDBStore#update
+ * @param {String} key - The key
+ * @param {Object} value - The value
+ * @param {Function} success - The success callback
+ * @param {Function} error - The error callback
+ */
+IndexedDBStore.prototype.update = function (key, value, success, error) {
+    var name = this.name;
+    var defaultError = this.defaultError;
+    var keys = [];
+    var values = [];
+
+    if (key instanceof Array) {
+        keys = key;
+        values = value;
+    } else {
+        keys = [key];
+        values = [value];
+    }
+
+    openTransaction(this, IDBT_READ_WRITE, function (transaction) {
+        transaction.onabort = getError(error, defaultError);
+        transaction.oncomplete = function () {
+            if (key instanceof Array) {
+                success(keys, values);
+            } else {
+                success(key, value);
+            }
+        };
+
+        for (var i = 0; i < keys.length && i < values.length; i++) {
+            var request = transaction.objectStore(name).openCursor(IDBKeyRange.only(keys[i]));
+            var record = { v: values[i] };
+            request.pair = { key: keys[i], value: record };
+            request.onsuccess = function (event) {
+                var cursor = event.target.result;
+                if (cursor) {
+                    cursor.update(event.target.pair.value);
+                } else {
+                    transaction.abort();
+                }
+            }
+        }
+    }, error);
+};
+
+
+module.exports = IndexedDBStore;
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/27f830e6/lib/store/memory.js
----------------------------------------------------------------------
diff --git a/lib/store/memory.js b/lib/store/memory.js
new file mode 100644
index 0000000..a9c69d4
--- /dev/null
+++ b/lib/store/memory.js
@@ -0,0 +1,247 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+'use strict';
+
+/** @module store/memory */
+
+
+var utils = require('./../utils.js');
+
+// Imports.
+var throwErrorCallback = utils.throwErrorCallback;
+var delay = utils.delay;
+
+/** Constructor for store objects that use a sorted array as the underlying mechanism.
+ * @class MemoryStore
+ * @constructor
+ * @param {String} name - Store name.
+ */
+function MemoryStore(name) {
+
+    var holes = [];
+    var items = [];
+    var keys = {};
+
+    this.name = name;
+
+    var getErrorCallback = function (error) {
+        return error || this.defaultError;
+    };
+
+    /** Validates that the specified key is not undefined, not null, and not an array
+     * @param key - Key value.
+     * @param {Function} error - Error callback.
+     * @returns {Boolean} True if the key is valid. False if the key is invalid and the error callback has been queued for execution.
+     */
+    function validateKeyInput(key, error) {
+
+        var messageString;
+
+        if (key instanceof Array) {
+            messageString = "Array of keys not supported";
+        }
+
+        if (key === undefined || key === null) {
+            messageString = "Invalid key";
+        }
+
+        if (messageString) {
+            delay(error, { message: messageString });
+            return false;
+        }
+        return true;
+    }
+
+    /** This method errors out if the store already contains the specified key.
+     * @summary Adds a new value identified by a key to the store.
+     * @method module:store/memory~MemoryStore#add
+     * @param {String} key - Key string.
+     * @param value - Value that is going to be added to the store.
+     * @param {Function} success - Callback for a successful add operation.
+     * @param {Function} error - Callback for handling errors. If not specified then store.defaultError is invoked.
+     */
+    this.add = function (key, value, success, error) {
+        error = getErrorCallback(error);
+
+        if (validateKeyInput(key, error)) {
+            if (!keys.hasOwnProperty(key)) {
+                this.addOrUpdate(key, value, success, error);
+            } else {
+                error({ message: "key already exists", key: key });
+            }
+        }
+    };
+
+    /** This method will overwrite the key's current value if it already exists in the store; otherwise it simply adds the new key and value.
+     * @summary Adds or updates a value identified by a key to the store.
+     * @method module:store/memory~MemoryStore#addOrUpdate
+     * @param {String} key - Key string.
+     * @param value - Value that is going to be added or updated to the store.
+     * @param {Function} success - Callback for a successful add or update operation.
+     * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+    */
+    this.addOrUpdate = function (key, value, success, error) {
+        
+        error = getErrorCallback(error);
+
+        if (validateKeyInput(key, error)) {
+            var index = keys[key];
+            if (index === undefined) {
+                if (holes.length > 0) {
+                    index = holes.splice(0, 1);
+                } else {
+                    index = items.length;
+                }
+            }
+            items[index] = value;
+            keys[key] = index;
+            delay(success, key, value);
+        }
+    };
+
+    /** Removes all the data associated with this store object.
+     * @method module:store/memory~MemoryStore#clear
+     * @param {Function} success - Callback for a successful clear operation.
+     */
+    this.clear = function (success) {
+        items = [];
+        keys = {};
+        holes = [];
+        delay(success);
+    };
+
+    /** Checks whether a key exists in the store.
+     * @method module:store/memory~MemoryStore#contains
+     * @param {String} key - Key string.
+     * @param {Function} success - Callback indicating whether the store contains the key or not.
+     */
+    this.contains = function (key, success) {
+        var contained = keys.hasOwnProperty(key);
+        delay(success, contained);
+    };
+
+    /** Gets all the keys that exist in the store.
+     * @method module:store/memory~MemoryStore#getAllKeys
+     * @param {Function} success - Callback for a successful get operation.
+     */
+    this.getAllKeys = function (success) {
+
+        var results = [];
+        for (var name in keys) {
+            results.push(name);
+        }
+        delay(success, results);
+    };
+
+    /** Reads the value associated to a key in the store.
+     * @method module:store/memory~MemoryStore#read
+     * @param {String} key - Key string.
+     * @param {Function} success - Callback for a successful reads operation.
+     * @param {Function} error - Callback for handling errors. If not specified then store.defaultError is invoked.
+     */
+    this.read = function (key, success, error) {
+        error = getErrorCallback(error);
+
+        if (validateKeyInput(key, error)) {
+            var index = keys[key];
+            delay(success, key, items[index]);
+        }
+    };
+
+    /** Removes a key and its value from the store.
+     * @method module:store/memory~MemoryStore#remove
+     * @param {String} key - Key string.
+     * @param {Function} success - Callback for a successful remove operation.
+     * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+     */
+    this.remove = function (key, success, error) {
+        error = getErrorCallback(error);
+
+        if (validateKeyInput(key, error)) {
+            var index = keys[key];
+            if (index !== undefined) {
+                if (index === items.length - 1) {
+                    items.pop();
+                } else {
+                    items[index] = undefined;
+                    holes.push(index);
+                }
+                delete keys[key];
+
+                // The last item was removed, no need to keep track of any holes in the array.
+                if (items.length === 0) {
+                    holes = [];
+                }
+            }
+
+            delay(success);
+        }
+    };
+
+    /** Updates the value associated to a key in the store.
+     * @method module:store/memory~MemoryStore#update
+     * @param {String} key - Key string.
+     * @param value - New value.
+     * @param {Function} success - Callback for a successful update operation.
+     * @param {Function} [error] - Callback for handling errors. If not specified then store.defaultError is invoked.
+     * This method errors out if the specified key is not found in the store.
+     */
+    this.update = function (key, value, success, error) {
+        error = getErrorCallback(error);
+        if (validateKeyInput(key, error)) {
+            if (keys.hasOwnProperty(key)) {
+                this.addOrUpdate(key, value, success, error);
+            } else {
+                error({ message: "key not found", key: key });
+            }
+        }
+    };
+}
+
+/** Creates a store object that uses memory storage as its underlying mechanism.
+ * @method MemoryStore.create
+ * @param {String} name - Store name.
+ * @returns {Object} Store object.
+ */
+MemoryStore.create = function (name) {
+    return new MemoryStore(name);
+};
+
+/** Checks whether the underlying mechanism for this kind of store objects is supported by the browser.
+ * @method MemoryStore.isSupported
+ * @returns {Boolean} True if the mechanism is supported by the browser; otherwise false.
+ */
+MemoryStore.isSupported = function () {
+    return true;
+};
+
+/** This function does nothing in MemoryStore as it does not have a connection model.
+*/
+MemoryStore.prototype.close = function () {
+};
+
+MemoryStore.prototype.defaultError = throwErrorCallback;
+
+/** Identifies the underlying mechanism used by the store.
+*/
+MemoryStore.prototype.mechanism = "memory";
+
+
+/** MemoryStore (see {@link MemoryStore}) */
+module.exports = MemoryStore;
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/27f830e6/lib/utils.js
----------------------------------------------------------------------
diff --git a/lib/utils.js b/lib/utils.js
new file mode 100644
index 0000000..429a56a
--- /dev/null
+++ b/lib/utils.js
@@ -0,0 +1,581 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+'use strict';
+
+/** @module odatajs/utils */
+
+
+function inBrowser() {
+    return typeof window !== 'undefined';
+}
+
+/** Creates a new ActiveXObject from the given progId.
+ * @param {String} progId - ProgId string of the desired ActiveXObject.
+ * @returns {Object} The ActiveXObject instance. Null if ActiveX is not supported by the browser.
+ * This function throws whatever exception might occur during the creation
+ * of the ActiveXObject.
+*/
+var activeXObject = function (progId) {
+    
+    if (window.ActiveXObject) {
+        return new window.ActiveXObject(progId);
+    }
+    return null;
+};
+
+/** Checks whether the specified value is different from null and undefined.
+ * @param [value] Value to check ( may be null)
+ * @returns {Boolean} true if the value is assigned; false otherwise.
+*/     
+function assigned(value) {
+    return value !== null && value !== undefined;
+}
+
+/** Checks whether the specified item is in the array.
+ * @param {Array} [arr] Array to check in.
+ * @param item - Item to look for.
+ * @returns {Boolean} true if the item is contained, false otherwise.
+*/
+function contains(arr, item) {
+    var i, len;
+    for (i = 0, len = arr.length; i < len; i++) {
+        if (arr[i] === item) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/** Given two values, picks the first one that is not undefined.
+ * @param a - First value.
+ * @param b - Second value.
+ * @returns a if it's a defined value; else b.
+ */
+function defined(a, b) {
+    return (a !== undefined) ? a : b;
+}
+
+/** Delays the invocation of the specified function until execution unwinds.
+ * @param {Function} callback - Callback function.
+ */
+function delay(callback) {
+
+    if (arguments.length === 1) {
+        window.setTimeout(callback, 0);
+        return;
+    }
+
+    var args = Array.prototype.slice.call(arguments, 1);
+    window.setTimeout(function () {
+        callback.apply(this, args);
+    }, 0);
+}
+
+/** Throws an exception in case that a condition evaluates to false.
+ * @param {Boolean} condition - Condition to evaluate.
+ * @param {String} message - Message explaining the assertion.
+ * @param {Object} data - Additional data to be included in the exception.
+ */
+function djsassert(condition, message, data) {
+
+
+    if (!condition) {
+        throw { message: "Assert fired: " + message, data: data };
+    }
+}
+
+/** Extends the target with the specified values.
+ * @param {Object} target - Object to add properties to.
+ * @param {Object} values - Object with properties to add into target.
+ * @returns {Object} The target object.
+*/
+function extend(target, values) {
+    for (var name in values) {
+        target[name] = values[name];
+    }
+
+    return target;
+}
+
+function find(arr, callback) {
+    /** Returns the first item in the array that makes the callback function true.
+     * @param {Array} [arr] Array to check in. ( may be null)
+     * @param {Function} callback - Callback function to invoke once per item in the array.
+     * @returns The first item that makes the callback return true; null otherwise or if the array is null.
+    */
+
+    if (arr) {
+        var i, len;
+        for (i = 0, len = arr.length; i < len; i++) {
+            if (callback(arr[i])) {
+                return arr[i];
+            }
+        }
+    }
+    return null;
+}
+
+function isArray(value) {
+    /** Checks whether the specified value is an array object.
+     * @param value - Value to check.
+     * @returns {Boolean} true if the value is an array object; false otherwise.
+     */
+
+    return Object.prototype.toString.call(value) === "[object Array]";
+}
+
+/** Checks whether the specified value is a Date object.
+ * @param value - Value to check.
+ * @returns {Boolean} true if the value is a Date object; false otherwise.
+ */
+function isDate(value) {
+    return Object.prototype.toString.call(value) === "[object Date]";
+}
+
+/** Tests whether a value is an object.
+ * @param value - Value to test.
+ * @returns {Boolean} True is the value is an object; false otherwise.
+ * Per javascript rules, null and array values are objects and will cause this function to return true.
+ */
+function isObject(value) {
+    return typeof value === "object";
+}
+
+/** Parses a value in base 10.
+ * @param {String} value - String value to parse.
+ * @returns {Number} The parsed value, NaN if not a valid value.
+*/   
+function parseInt10(value) {
+    return parseInt(value, 10);
+}
+
+/** Renames a property in an object.
+ * @param {Object} obj - Object in which the property will be renamed.
+ * @param {String} oldName - Name of the property that will be renamed.
+ * @param {String} newName - New name of the property.
+ * This function will not do anything if the object doesn't own a property with the specified old name.
+ */
+function renameProperty(obj, oldName, newName) {
+    if (obj.hasOwnProperty(oldName)) {
+        obj[newName] = obj[oldName];
+        delete obj[oldName];
+    }
+}
+
+/** Default error handler.
+ * @param {Object} error - Error to handle.
+ */
+function throwErrorCallback(error) {
+    throw error;
+}
+
+/** Removes leading and trailing whitespaces from a string.
+ * @param {String} str String to trim
+ * @returns {String} The string with no leading or trailing whitespace.
+ */
+function trimString(str) {
+    if (str.trim) {
+        return str.trim();
+    }
+
+    return str.replace(/^\s+|\s+$/g, '');
+}
+
+/** Returns a default value in place of undefined.
+ * @param [value] Value to check (may be null)
+ * @param defaultValue - Value to return if value is undefined.
+ * @returns value if it's defined; defaultValue otherwise.
+ * This should only be used for cases where falsy values are valid;
+ * otherwise the pattern should be 'x = (value) ? value : defaultValue;'.
+ */
+function undefinedDefault(value, defaultValue) {
+    return (value !== undefined) ? value : defaultValue;
+}
+
+// Regular expression that splits a uri into its components:
+// 0 - is the matched string.
+// 1 - is the scheme.
+// 2 - is the authority.
+// 3 - is the path.
+// 4 - is the query.
+// 5 - is the fragment.
+var uriRegEx = /^([^:\/?#]+:)?(\/\/[^\/?#]*)?([^?#:]+)?(\?[^#]*)?(#.*)?/;
+var uriPartNames = ["scheme", "authority", "path", "query", "fragment"];
+
+/** Gets information about the components of the specified URI.
+ * @param {String} uri - URI to get information from.
+ * @return  {Object} An object with an isAbsolute flag and part names (scheme, authority, etc.) if available.
+ */
+function getURIInfo(uri) {
+    var result = { isAbsolute: false };
+
+    if (uri) {
+        var matches = uriRegEx.exec(uri);
+        if (matches) {
+            var i, len;
+            for (i = 0, len = uriPartNames.length; i < len; i++) {
+                if (matches[i + 1]) {
+                    result[uriPartNames[i]] = matches[i + 1];
+                }
+            }
+        }
+        if (result.scheme) {
+            result.isAbsolute = true;
+        }
+    }
+
+    return result;
+}
+
+/** Builds a URI string from its components.
+ * @param {Object} uriInfo -  An object with uri parts (scheme, authority, etc.).
+ * @returns {String} URI string.
+ */
+function getURIFromInfo(uriInfo) {
+    return "".concat(
+        uriInfo.scheme || "",
+        uriInfo.authority || "",
+        uriInfo.path || "",
+        uriInfo.query || "",
+        uriInfo.fragment || "");
+}
+
+// Regular expression that splits a uri authority into its subcomponents:
+// 0 - is the matched string.
+// 1 - is the userinfo subcomponent.
+// 2 - is the host subcomponent.
+// 3 - is the port component.
+var uriAuthorityRegEx = /^\/{0,2}(?:([^@]*)@)?([^:]+)(?::{1}(\d+))?/;
+
+// Regular expression that matches percentage enconded octects (i.e %20 or %3A);
+var pctEncodingRegEx = /%[0-9A-F]{2}/ig;
+
+/** Normalizes the casing of a URI.
+ * @param {String} uri - URI to normalize, absolute or relative.
+ * @returns {String} The URI normalized to lower case.
+*/
+function normalizeURICase(uri) {
+    var uriInfo = getURIInfo(uri);
+    var scheme = uriInfo.scheme;
+    var authority = uriInfo.authority;
+
+    if (scheme) {
+        uriInfo.scheme = scheme.toLowerCase();
+        if (authority) {
+            var matches = uriAuthorityRegEx.exec(authority);
+            if (matches) {
+                uriInfo.authority = "//" +
+                (matches[1] ? matches[1] + "@" : "") +
+                (matches[2].toLowerCase()) +
+                (matches[3] ? ":" + matches[3] : "");
+            }
+        }
+    }
+
+    uri = getURIFromInfo(uriInfo);
+
+    return uri.replace(pctEncodingRegEx, function (str) {
+        return str.toLowerCase();
+    });
+}
+
+/** Normalizes a possibly relative URI with a base URI.
+ * @param {String} uri - URI to normalize, absolute or relative
+ * @param {String} base - Base URI to compose with (may be null)
+ * @returns {String} The composed URI if relative; the original one if absolute.
+ */
+function normalizeURI(uri, base) {
+    if (!base) {
+        return uri;
+    }
+
+    var uriInfo = getURIInfo(uri);
+    if (uriInfo.isAbsolute) {
+        return uri;
+    }
+
+    var baseInfo = getURIInfo(base);
+    var normInfo = {};
+    var path;
+
+    if (uriInfo.authority) {
+        normInfo.authority = uriInfo.authority;
+        path = uriInfo.path;
+        normInfo.query = uriInfo.query;
+    } else {
+        if (!uriInfo.path) {
+            path = baseInfo.path;
+            normInfo.query = uriInfo.query || baseInfo.query;
+        } else {
+            if (uriInfo.path.charAt(0) === '/') {
+                path = uriInfo.path;
+            } else {
+                path = mergeUriPathWithBase(uriInfo.path, baseInfo.path);
+            }
+            normInfo.query = uriInfo.query;
+        }
+        normInfo.authority = baseInfo.authority;
+    }
+
+    normInfo.path = removeDotsFromPath(path);
+
+    normInfo.scheme = baseInfo.scheme;
+    normInfo.fragment = uriInfo.fragment;
+
+    return getURIFromInfo(normInfo);
+}
+
+/** Merges the path of a relative URI and a base URI.
+ * @param {String} uriPath - Relative URI path.
+ * @param {String} basePath - Base URI path.
+ * @returns {String} A string with the merged path.
+ */
+function mergeUriPathWithBase(uriPath, basePath) {
+    var path = "/";
+    var end;
+
+    if (basePath) {
+        end = basePath.lastIndexOf("/");
+        path = basePath.substring(0, end);
+
+        if (path.charAt(path.length - 1) !== "/") {
+            path = path + "/";
+        }
+    }
+
+    return path + uriPath;
+}
+
+/** Removes the special folders . and .. from a URI's path.
+ * @param {string} path - URI path component.
+ * @returns {String} Path without any . and .. folders.
+ */
+function removeDotsFromPath(path) {
+    var result = "";
+    var segment = "";
+    var end;
+
+    while (path) {
+        if (path.indexOf("..") === 0 || path.indexOf(".") === 0) {
+            path = path.replace(/^\.\.?\/?/g, "");
+        } else if (path.indexOf("/..") === 0) {
+            path = path.replace(/^\/\..\/?/g, "/");
+            end = result.lastIndexOf("/");
+            if (end === -1) {
+                result = "";
+            } else {
+                result = result.substring(0, end);
+            }
+        } else if (path.indexOf("/.") === 0) {
+            path = path.replace(/^\/\.\/?/g, "/");
+        } else {
+            segment = path;
+            end = path.indexOf("/", 1);
+            if (end !== -1) {
+                segment = path.substring(0, end);
+            }
+            result = result + segment;
+            path = path.replace(segment, "");
+        }
+    }
+    return result;
+}
+
+function convertByteArrayToHexString(str) {
+    var arr = [];
+    if (window.atob === undefined) {
+        arr = decodeBase64(str);
+    } else {
+        var binaryStr = window.atob(str);
+        for (var i = 0; i < binaryStr.length; i++) {
+            arr.push(binaryStr.charCodeAt(i));
+        }
+    }
+    var hexValue = "";
+    var hexValues = "0123456789ABCDEF";
+    for (var j = 0; j < arr.length; j++) {
+        var t = arr[j];
+        hexValue += hexValues[t >> 4];
+        hexValue += hexValues[t & 0x0F];
+    }
+    return hexValue;
+}
+
+function decodeBase64(str) {
+    var binaryString = "";
+    for (var i = 0; i < str.length; i++) {
+        var base65IndexValue = getBase64IndexValue(str[i]);
+        var binaryValue = "";
+        if (base65IndexValue !== null) {
+            binaryValue = base65IndexValue.toString(2);
+            binaryString += addBase64Padding(binaryValue);
+        }
+    }
+    var byteArray = [];
+    var numberOfBytes = parseInt(binaryString.length / 8, 10);
+    for (i = 0; i < numberOfBytes; i++) {
+        var intValue = parseInt(binaryString.substring(i * 8, (i + 1) * 8), 2);
+        byteArray.push(intValue);
+    }
+    return byteArray;
+}
+
+function getBase64IndexValue(character) {
+    var asciiCode = character.charCodeAt(0);
+    var asciiOfA = 65;
+    var differenceBetweenZanda = 6;
+    if (asciiCode >= 65 && asciiCode <= 90) {           // between "A" and "Z" inclusive
+        return asciiCode - asciiOfA;
+    } else if (asciiCode >= 97 && asciiCode <= 122) {   // between 'a' and 'z' inclusive
+        return asciiCode - asciiOfA - differenceBetweenZanda;
+    } else if (asciiCode >= 48 && asciiCode <= 57) {    // between '0' and '9' inclusive
+        return asciiCode + 4;
+    } else if (character == "+") {
+        return 62;
+    } else if (character == "/") {
+        return 63;
+    } else {
+        return null;
+    }
+}
+
+function addBase64Padding(binaryString) {
+    while (binaryString.length < 6) {
+        binaryString = "0" + binaryString;
+    }
+    return binaryString;
+
+}
+
+function getJsonValueArraryLength(data) {
+    if (data && data.value) {
+        return data.value.length;
+    }
+
+    return 0;
+}
+
+function sliceJsonValueArray(data, start, end) {
+    if (data === undefined || data.value === undefined) {
+        return data;
+    }
+
+    if (start < 0) {
+        start = 0;
+    }
+
+    var length = getJsonValueArraryLength(data);
+    if (length < end) {
+        end = length;
+    }
+
+    var newdata = {};
+    for (var property in data) {
+        if (property == "value") {
+            newdata[property] = data[property].slice(start, end);
+        } else {
+            newdata[property] = data[property];
+        }
+    }
+
+    return newdata;
+}
+
+function concatJsonValueArray(data, concatData) {
+    if (concatData === undefined || concatData.value === undefined) {
+        return data;
+    }
+
+    if (data === undefined || Object.keys(data).length === 0) {
+        return concatData;
+    }
+
+    if (data.value === undefined) {
+        data.value = concatData.value;
+        return data;
+    }
+
+    data.value = data.value.concat(concatData.value);
+
+    return data;
+}
+
+function endsWith(input, search) {
+    return input.indexOf(search, input.length - search.length) !== -1;
+}
+
+function startsWith (input, search) {
+    return input.indexOf(search) === 0;
+}
+
+function getFormatKind(format, defaultFormatKind) {
+    var formatKind = defaultFormatKind;
+    if (!assigned(format)) {
+        return formatKind;
+    }
+
+    var normalizedFormat = format.toLowerCase();
+    switch (normalizedFormat) {
+        case "none":
+            formatKind = 0;
+            break;
+        case "minimal":
+            formatKind = 1;
+            break;
+        case "full":
+            formatKind = 2;
+            break;
+        default:
+            break;
+    }
+
+    return formatKind;
+}
+
+
+    
+    
+exports.inBrowser = inBrowser;
+exports.activeXObject = activeXObject;
+exports.assigned = assigned;
+exports.contains = contains;
+exports.defined = defined;
+exports.delay = delay;
+exports.djsassert = djsassert;
+exports.extend = extend;
+exports.find = find;
+exports.getURIInfo = getURIInfo;
+exports.isArray = isArray;
+exports.isDate = isDate;
+exports.isObject = isObject;
+exports.normalizeURI = normalizeURI;
+exports.normalizeURICase = normalizeURICase;
+exports.parseInt10 = parseInt10;
+exports.renameProperty = renameProperty;
+exports.throwErrorCallback = throwErrorCallback;
+exports.trimString = trimString;
+exports.undefinedDefault = undefinedDefault;
+exports.decodeBase64 = decodeBase64;
+exports.convertByteArrayToHexString = convertByteArrayToHexString;
+exports.getJsonValueArraryLength = getJsonValueArraryLength;
+exports.sliceJsonValueArray = sliceJsonValueArray;
+exports.concatJsonValueArray = concatJsonValueArray;
+exports.startsWith = startsWith;
+exports.endsWith = endsWith;
+exports.getFormatKind = getFormatKind;
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/27f830e6/lib/xml.js
----------------------------------------------------------------------
diff --git a/lib/xml.js b/lib/xml.js
new file mode 100644
index 0000000..194b4ba
--- /dev/null
+++ b/lib/xml.js
@@ -0,0 +1,824 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+'use strict';
+ 
+
+/** @module odatajs/xml */
+
+var utils    = require('./utils.js');
+
+var activeXObject = utils.activeXObject;
+var djsassert = utils.djsassert;
+var extend = utils.extend;
+var isArray = utils.isArray;
+var normalizeURI = utils.normalizeURI;
+
+// URI prefixes to generate smaller code.
+var http = "http://";
+var w3org = http + "www.w3.org/";               // http://www.w3.org/
+
+var xhtmlNS = w3org + "1999/xhtml";             // http://www.w3.org/1999/xhtml
+var xmlnsNS = w3org + "2000/xmlns/";            // http://www.w3.org/2000/xmlns/
+var xmlNS = w3org + "XML/1998/namespace";       // http://www.w3.org/XML/1998/namespace
+
+var mozillaParserErroNS = http + "www.mozilla.org/newlayout/xml/parsererror.xml";
+
+/** Checks whether the specified string has leading or trailing spaces.
+ * @param {String} text - String to check.
+ * @returns {Boolean} true if text has any leading or trailing whitespace; false otherwise.
+ */
+function hasLeadingOrTrailingWhitespace(text) {
+    var re = /(^\s)|(\s$)/;
+    return re.test(text);
+}
+
+/** Determines whether the specified text is empty or whitespace.
+ * @param {String} text - Value to inspect.
+ * @returns {Boolean} true if the text value is empty or all whitespace; false otherwise.
+ */
+function isWhitespace(text) {
+
+
+    var ws = /^\s*$/;
+    return text === null || ws.test(text);
+}
+
+/** Determines whether the specified element has xml:space='preserve' applied.
+ * @param domElement - Element to inspect.
+ * @returns {Boolean} Whether xml:space='preserve' is in effect.
+ */
+function isWhitespacePreserveContext(domElement) {
+
+
+    while (domElement !== null && domElement.nodeType === 1) {
+        var val = xmlAttributeValue(domElement, "space", xmlNS);
+        if (val === "preserve") {
+            return true;
+        } else if (val === "default") {
+            break;
+        } else {
+            domElement = domElement.parentNode;
+        }
+    }
+
+    return false;
+}
+
+/** Determines whether the attribute is a XML namespace declaration.
+ * @param domAttribute - Element to inspect.
+ * @return {Boolean} True if the attribute is a namespace declaration (its name is 'xmlns' or starts with 'xmlns:'; false otherwise.
+ */
+function isXmlNSDeclaration(domAttribute) {
+    var nodeName = domAttribute.nodeName;
+    return nodeName == "xmlns" || nodeName.indexOf("xmlns:") === 0;
+}
+
+/** Safely set as property in an object by invoking obj.setProperty.
+ * @param obj - Object that exposes a setProperty method.
+ * @param {String} name - Property name
+ * @param value - Property value.
+ */
+function safeSetProperty(obj, name, value) {
+
+
+    try {
+        obj.setProperty(name, value);
+    } catch (_) { }
+}
+
+/** Creates an configures new MSXML 3.0 ActiveX object.
+ * @returns {Object} New MSXML 3.0 ActiveX object.
+ * This function throws any exception that occurs during the creation
+ * of the MSXML 3.0 ActiveX object.
+ */
+function msXmlDom3() {
+    var msxml3 = activeXObject("Msxml2.DOMDocument.3.0");
+    if (msxml3) {
+        safeSetProperty(msxml3, "ProhibitDTD", true);
+        safeSetProperty(msxml3, "MaxElementDepth", 256);
+        safeSetProperty(msxml3, "AllowDocumentFunction", false);
+        safeSetProperty(msxml3, "AllowXsltScript", false);
+    }
+    return msxml3;
+}
+
+/** Creates an configures new MSXML 6.0 or MSXML 3.0 ActiveX object.
+ * @returns {Object} New MSXML 3.0 ActiveX object.
+ * This function will try to create a new MSXML 6.0 ActiveX object. If it fails then
+ * it will fallback to create a new MSXML 3.0 ActiveX object. Any exception that
+ * happens during the creation of the MSXML 6.0 will be handled by the function while
+ * the ones that happend during the creation of the MSXML 3.0 will be thrown.
+ */
+function msXmlDom() {
+    try {
+        var msxml = activeXObject("Msxml2.DOMDocument.6.0");
+        if (msxml) {
+            msxml.async = true;
+        }
+        return msxml;
+    } catch (_) {
+        return msXmlDom3();
+    }
+}
+
+/** Parses an XML string using the MSXML DOM.
+ * @returns {Object} New MSXML DOMDocument node representing the parsed XML string.
+ * This function throws any exception that occurs during the creation
+ * of the MSXML ActiveX object.  It also will throw an exception
+ * in case of a parsing error.
+ */
+function msXmlParse(text) {
+    var dom = msXmlDom();
+    if (!dom) {
+        return null;
+    }
+
+    dom.loadXML(text);
+    var parseError = dom.parseError;
+    if (parseError.errorCode !== 0) {
+        xmlThrowParserError(parseError.reason, parseError.srcText, text);
+    }
+    return dom;
+}
+
+/** Throws a new exception containing XML parsing error information.
+ * @param exceptionOrReason - String indicating the reason of the parsing failure or Object detailing the parsing error.
+ * @param {String} srcText -     String indicating the part of the XML string that caused the parsing error.
+ * @param {String} errorXmlText - XML string for wich the parsing failed.
+ */
+function xmlThrowParserError(exceptionOrReason, srcText, errorXmlText) {
+
+    if (typeof exceptionOrReason === "string") {
+        exceptionOrReason = { message: exceptionOrReason };
+    }
+    throw extend(exceptionOrReason, { srcText: srcText || "", errorXmlText: errorXmlText || "" });
+}
+
+/** Returns an XML DOM document from the specified text.
+ * @param {String} text - Document text.
+ * @returns XML DOM document.
+ * This function will throw an exception in case of a parse error
+ */
+function xmlParse(text) {
+    var domParser = undefined;
+    if (utils.inBrowser()) {
+        domParser = window.DOMParser && new window.DOMParser();
+    } else {
+        domParser = new (require('xmldom').DOMParser)();
+    }
+    var dom;
+
+    if (!domParser) {
+        dom = msXmlParse(text);
+        if (!dom) {
+            xmlThrowParserError("XML DOM parser not supported");
+        }
+        return dom;
+    }
+
+    try {
+        dom = domParser.parseFromString(text, "text/xml");
+    } catch (e) {
+        xmlThrowParserError(e, "", text);
+    }
+
+    var element = dom.documentElement;
+    var nsURI = element.namespaceURI;
+    var localName = xmlLocalName(element);
+
+    // Firefox reports errors by returing the DOM for an xml document describing the problem.
+    if (localName === "parsererror" && nsURI === mozillaParserErroNS) {
+        var srcTextElement = xmlFirstChildElement(element, mozillaParserErroNS, "sourcetext");
+        var srcText = srcTextElement ? xmlNodeValue(srcTextElement) : "";
+        xmlThrowParserError(xmlInnerText(element) || "", srcText, text);
+    }
+
+    // Chrome (and maybe other webkit based browsers) report errors by injecting a header with an error message.
+    // The error may be localized, so instead we simply check for a header as the
+    // top element or descendant child of the document.
+    if (localName === "h3" && nsURI === xhtmlNS || xmlFirstDescendantElement(element, xhtmlNS, "h3")) {
+        var reason = "";
+        var siblings = [];
+        var cursor = element.firstChild;
+        while (cursor) {
+            if (cursor.nodeType === 1) {
+                reason += xmlInnerText(cursor) || "";
+            }
+            siblings.push(cursor.nextSibling);
+            cursor = cursor.firstChild || siblings.shift();
+        }
+        reason += xmlInnerText(element) || "";
+        xmlThrowParserError(reason, "", text);
+    }
+
+    return dom;
+}
+
+/** Builds a XML qualified name string in the form of "prefix:name".
+ * @param {String} prefix - Prefix string (may be null)
+ * @param {String} name - Name string to qualify with the prefix.
+ * @returns {String} Qualified name.
+ */
+function xmlQualifiedName(prefix, name) {
+    return prefix ? prefix + ":" + name : name;
+}
+
+/** Appends a text node into the specified DOM element node.
+ * @param domNode - DOM node for the element.
+ * @param {String} textNode - Text to append as a child of element.
+*/
+function xmlAppendText(domNode, textNode) {
+    if (hasLeadingOrTrailingWhitespace(textNode.data)) {
+        var attr = xmlAttributeNode(domNode, xmlNS, "space");
+        if (!attr) {
+            attr = xmlNewAttribute(domNode.ownerDocument, xmlNS, xmlQualifiedName("xml", "space"));
+            xmlAppendChild(domNode, attr);
+        }
+        attr.value = "preserve";
+    }
+    domNode.appendChild(textNode);
+    return domNode;
+}
+
+/** Iterates through the XML element's attributes and invokes the callback function for each one.
+ * @param element - Wrapped element to iterate over.
+ * @param {Function} onAttributeCallback - Callback function to invoke with wrapped attribute nodes.
+*/
+function xmlAttributes(element, onAttributeCallback) {
+    var attributes = element.attributes;
+    var i, len;
+    for (i = 0, len = attributes.length; i < len; i++) {
+        onAttributeCallback(attributes.item(i));
+    }
+}
+
+/** Returns the value of a DOM element's attribute.
+ * @param domNode - DOM node for the owning element.
+ * @param {String} localName - Local name of the attribute.
+ * @param {String} nsURI - Namespace URI of the attribute.
+ * @returns {String} - The attribute value, null if not found (may be null)
+ */
+function xmlAttributeValue(domNode, localName, nsURI) {
+
+    var attribute = xmlAttributeNode(domNode, localName, nsURI);
+    return attribute ? xmlNodeValue(attribute) : null;
+}
+
+/** Gets an attribute node from a DOM element.
+ * @param domNode - DOM node for the owning element.
+ * @param {String} localName - Local name of the attribute.
+ * @param {String} nsURI - Namespace URI of the attribute.
+ * @returns The attribute node, null if not found.
+ */
+function xmlAttributeNode(domNode, localName, nsURI) {
+
+    var attributes = domNode.attributes;
+    if (attributes.getNamedItemNS) {
+        return attributes.getNamedItemNS(nsURI || null, localName);
+    }
+
+    return attributes.getQualifiedItem(localName, nsURI) || null;
+}
+
+/** Gets the value of the xml:base attribute on the specified element.
+ * @param domNode - Element to get xml:base attribute value from.
+ * @param [baseURI] - Base URI used to normalize the value of the xml:base attribute ( may be null)
+ * @returns {String} Value of the xml:base attribute if found; the baseURI or null otherwise.
+ */
+function xmlBaseURI(domNode, baseURI) {
+
+    var base = xmlAttributeNode(domNode, "base", xmlNS);
+    return (base ? normalizeURI(base.value, baseURI) : baseURI) || null;
+}
+
+
+/** Iterates through the XML element's child DOM elements and invokes the callback function for each one.
+ * @param domNode - DOM Node containing the DOM elements to iterate over.
+ * @param {Function} onElementCallback - Callback function to invoke for each child DOM element.
+*/
+function xmlChildElements(domNode, onElementCallback) {
+
+    xmlTraverse(domNode, /*recursive*/false, function (child) {
+        if (child.nodeType === 1) {
+            onElementCallback(child);
+        }
+        // continue traversing.
+        return true;
+    });
+}
+
+/** Gets the descendant element under root that corresponds to the specified path and namespace URI.
+ * @param root - DOM element node from which to get the descendant element.
+ * @param {String} namespaceURI - The namespace URI of the element to match.
+ * @param {String} path - Path to the desired descendant element.
+ * @return The element specified by path and namespace URI.
+ * All the elements in the path are matched against namespaceURI.
+ * The function will stop searching on the first element that doesn't match the namespace and the path.
+ */
+function xmlFindElementByPath(root, namespaceURI, path) {
+    var parts = path.split("/");
+    var i, len;
+    for (i = 0, len = parts.length; i < len; i++) {
+        root = root && xmlFirstChildElement(root, namespaceURI, parts[i]);
+    }
+    return root || null;
+}
+
+/** Gets the DOM element or DOM attribute node under root that corresponds to the specified path and namespace URI.
+ * @param root - DOM element node from which to get the descendant node.
+ * @param {String} namespaceURI - The namespace URI of the node to match.
+ * @param {String} path - Path to the desired descendant node.
+ * @return The node specified by path and namespace URI.
+
+* This function will traverse the path and match each node associated to a path segement against the namespace URI.
+* The traversal stops when the whole path has been exahusted or a node that doesn't belogong the specified namespace is encountered.
+* The last segment of the path may be decorated with a starting @ character to indicate that the desired node is a DOM attribute.
+*/
+function xmlFindNodeByPath(root, namespaceURI, path) {
+    
+
+    var lastSegmentStart = path.lastIndexOf("/");
+    var nodePath = path.substring(lastSegmentStart + 1);
+    var parentPath = path.substring(0, lastSegmentStart);
+
+    var node = parentPath ? xmlFindElementByPath(root, namespaceURI, parentPath) : root;
+    if (node) {
+        if (nodePath.charAt(0) === "@") {
+            return xmlAttributeNode(node, nodePath.substring(1), namespaceURI);
+        }
+        return xmlFirstChildElement(node, namespaceURI, nodePath);
+    }
+    return null;
+}
+
+/** Returns the first child DOM element under the specified DOM node that matches the specified namespace URI and local name.
+ * @param domNode - DOM node from which the child DOM element is going to be retrieved.
+ * @param {String} [namespaceURI] - 
+ * @param {String} [localName] - 
+ * @return The node's first child DOM element that matches the specified namespace URI and local name; null otherwise.
+ */
+function xmlFirstChildElement(domNode, namespaceURI, localName) {
+
+    return xmlFirstElementMaybeRecursive(domNode, namespaceURI, localName, /*recursive*/false);
+}
+
+/** Returns the first descendant DOM element under the specified DOM node that matches the specified namespace URI and local name.
+ * @param domNode - DOM node from which the descendant DOM element is going to be retrieved.
+ * @param {String} [namespaceURI] - 
+ * @param {String} [localName] - 
+ * @return The node's first descendant DOM element that matches the specified namespace URI and local name; null otherwise.
+*/
+function xmlFirstDescendantElement(domNode, namespaceURI, localName) {
+    if (domNode.getElementsByTagNameNS) {
+        var result = domNode.getElementsByTagNameNS(namespaceURI, localName);
+        return result.length > 0 ? result[0] : null;
+    }
+    return xmlFirstElementMaybeRecursive(domNode, namespaceURI, localName, /*recursive*/true);
+}
+
+/** Returns the first descendant DOM element under the specified DOM node that matches the specified namespace URI and local name.
+ * @param domNode - DOM node from which the descendant DOM element is going to be retrieved.
+ * @param {String} [namespaceURI] - 
+ * @param {String} [localName] - 
+ * @param {Boolean} recursive 
+ * - True if the search should include all the descendants of the DOM node.  
+ * - False if the search should be scoped only to the direct children of the DOM node.
+ * @return The node's first descendant DOM element that matches the specified namespace URI and local name; null otherwise.
+ */
+function xmlFirstElementMaybeRecursive(domNode, namespaceURI, localName, recursive) {
+
+    var firstElement = null;
+    xmlTraverse(domNode, recursive, function (child) {
+        if (child.nodeType === 1) {
+            var isExpectedNamespace = !namespaceURI || xmlNamespaceURI(child) === namespaceURI;
+            var isExpectedNodeName = !localName || xmlLocalName(child) === localName;
+
+            if (isExpectedNamespace && isExpectedNodeName) {
+                firstElement = child;
+            }
+        }
+        return firstElement === null;
+    });
+    return firstElement;
+}
+
+/** Gets the concatenated value of all immediate child text and CDATA nodes for the specified element.
+ * @param xmlElement - Element to get values for.
+ * @returns {String} Text for all direct children.
+ */
+function xmlInnerText(xmlElement) {
+
+    var result = null;
+    var root = (xmlElement.nodeType === 9 && xmlElement.documentElement) ? xmlElement.documentElement : xmlElement;
+    var whitespaceAlreadyRemoved = root.ownerDocument.preserveWhiteSpace === false;
+    var whitespacePreserveContext;
+
+    xmlTraverse(root, false, function (child) {
+        if (child.nodeType === 3 || child.nodeType === 4) {
+            // isElementContentWhitespace indicates that this is 'ignorable whitespace',
+            // but it's not defined by all browsers, and does not honor xml:space='preserve'
+            // in some implementations.
+            //
+            // If we can't tell either way, we walk up the tree to figure out whether
+            // xml:space is set to preserve; otherwise we discard pure-whitespace.
+            //
+            // For example <a>  <b>1</b></a>. The space between <a> and <b> is usually 'ignorable'.
+            var text = xmlNodeValue(child);
+            var shouldInclude = whitespaceAlreadyRemoved || !isWhitespace(text);
+            if (!shouldInclude) {
+                // Walk up the tree to figure out whether we are in xml:space='preserve' context
+                // for the cursor (needs to happen only once).
+                if (whitespacePreserveContext === undefined) {
+                    whitespacePreserveContext = isWhitespacePreserveContext(root);
+                }
+
+                shouldInclude = whitespacePreserveContext;
+            }
+
+            if (shouldInclude) {
+                if (!result) {
+                    result = text;
+                } else {
+                    result += text;
+                }
+            }
+        }
+        // Continue traversing?
+        return true;
+    });
+    return result;
+}
+
+/** Returns the localName of a XML node.
+ * @param domNode - DOM node to get the value from.
+ * @returns {String} localName of domNode.
+ */
+function xmlLocalName(domNode) {
+
+    return domNode.localName || domNode.baseName;
+}
+
+/** Returns the namespace URI of a XML node.
+ * @param domNode - DOM node to get the value from.
+ * @returns {String} Namespace URI of domNode.
+ */
+function xmlNamespaceURI(domNode) {
+
+    return domNode.namespaceURI || null;
+}
+
+/** Returns the value or the inner text of a XML node.
+ * @param domNode - DOM node to get the value from.
+ * @return Value of the domNode or the inner text if domNode represents a DOM element node.
+ */
+function xmlNodeValue(domNode) {
+    
+    if (domNode.nodeType === 1) {
+        return xmlInnerText(domNode);
+    }
+    return domNode.nodeValue;
+}
+
+/** Walks through the descendants of the domNode and invokes a callback for each node.
+ * @param domNode - DOM node whose descendants are going to be traversed.
+ * @param {Boolean} recursive
+ * - True if the traversal should include all the descenants of the DOM node.
+ * - False if the traversal should be scoped only to the direct children of the DOM node.
+ * @param {Boolean} onChildCallback - Called for each child
+ * @returns {String} Namespace URI of node.
+ */
+function xmlTraverse(domNode, recursive, onChildCallback) {
+
+    var subtrees = [];
+    var child = domNode.firstChild;
+    var proceed = true;
+    while (child && proceed) {
+        proceed = onChildCallback(child);
+        if (proceed) {
+            if (recursive && child.firstChild) {
+                subtrees.push(child.firstChild);
+            }
+            child = child.nextSibling || subtrees.shift();
+        }
+    }
+}
+
+/** Returns the next sibling DOM element of the specified DOM node.
+ * @param domNode - DOM node from which the next sibling is going to be retrieved.
+ * @param {String} [namespaceURI] - 
+ * @param {String} [localName] - 
+ * @return The node's next sibling DOM element, null if there is none.
+ */
+function xmlSiblingElement(domNode, namespaceURI, localName) {
+
+    var sibling = domNode.nextSibling;
+    while (sibling) {
+        if (sibling.nodeType === 1) {
+            var isExpectedNamespace = !namespaceURI || xmlNamespaceURI(sibling) === namespaceURI;
+            var isExpectedNodeName = !localName || xmlLocalName(sibling) === localName;
+
+            if (isExpectedNamespace && isExpectedNodeName) {
+                return sibling;
+            }
+        }
+        sibling = sibling.nextSibling;
+    }
+    return null;
+}
+
+/** Creates a new empty DOM document node.
+ * @return New DOM document node.
+ *
+ * This function will first try to create a native DOM document using
+ * the browsers createDocument function.  If the browser doesn't
+ * support this but supports ActiveXObject, then an attempt to create
+ * an MSXML 6.0 DOM will be made. If this attempt fails too, then an attempt
+ * for creating an MXSML 3.0 DOM will be made.  If this last attemp fails or
+ * the browser doesn't support ActiveXObject then an exception will be thrown.
+ */
+function xmlDom() {
+    var implementation = window.document.implementation;
+    return (implementation && implementation.createDocument) ?
+       implementation.createDocument(null, null, null) :
+       msXmlDom();
+}
+
+/** Appends a collection of child nodes or string values to a parent DOM node.
+ * @param parent - DOM node to which the children will be appended.
+ * @param {Array} children - Array containing DOM nodes or string values that will be appended to the parent.
+ * @return The parent with the appended children or string values.
+ *  If a value in the children collection is a string, then a new DOM text node is going to be created
+ *  for it and then appended to the parent.
+ */
+function xmlAppendChildren(parent, children) {
+    if (!isArray(children)) {
+        return xmlAppendChild(parent, children);
+    }
+
+    var i, len;
+    for (i = 0, len = children.length; i < len; i++) {
+        children[i] && xmlAppendChild(parent, children[i]);
+    }
+    return parent;
+}
+
+/** Appends a child node or a string value to a parent DOM node.
+ * @param parent - DOM node to which the child will be appended.
+ * @param child - Child DOM node or string value to append to the parent.
+ * @return The parent with the appended child or string value.
+ * If child is a string value, then a new DOM text node is going to be created
+ * for it and then appended to the parent.
+ */
+function xmlAppendChild(parent, child) {
+
+    djsassert(parent !== child, "xmlAppendChild() - parent and child are one and the same!");
+    if (child) {
+        if (typeof child === "string") {
+            return xmlAppendText(parent, xmlNewText(parent.ownerDocument, child));
+        }
+        if (child.nodeType === 2) {
+            parent.setAttributeNodeNS ? parent.setAttributeNodeNS(child) : parent.setAttributeNode(child);
+        } else {
+            parent.appendChild(child);
+        }
+    }
+    return parent;
+}
+
+/** Creates a new DOM attribute node.
+ * @param dom - DOM document used to create the attribute.
+ * @param {String} namespaceURI - Namespace URI.
+ * @param {String} qualifiedName - Qualified OData name
+ * @param {String} value - Value of the new attribute
+ * @return DOM attribute node for the namespace declaration.
+ */
+function xmlNewAttribute(dom, namespaceURI, qualifiedName, value) {
+
+    var attribute =
+        dom.createAttributeNS && dom.createAttributeNS(namespaceURI, qualifiedName) ||
+        dom.createNode(2, qualifiedName, namespaceURI || undefined);
+
+    attribute.value = value || "";
+    return attribute;
+}
+
+/** Creates a new DOM element node.
+ * @param dom - DOM document used to create the DOM element.
+ * @param {String} namespaceURI - Namespace URI of the new DOM element.
+ * @param {String} qualifiedName - Qualified name in the form of "prefix:name" of the new DOM element.
+ * @param {Array} [children] Collection of child DOM nodes or string values that are going to be appended to the new DOM element.
+ * @return New DOM element.
+ * If a value in the children collection is a string, then a new DOM text node is going to be created
+ * for it and then appended to the new DOM element.
+ */
+function xmlNewElement(dom, namespaceURI, qualifiedName, children) {
+    var element =
+        dom.createElementNS && dom.createElementNS(nampespaceURI, qualifiedName) ||
+        dom.createNode(1, qualifiedName, nampespaceURI || undefined);
+
+    return xmlAppendChildren(element, children || []);
+}
+
+/** Creates a namespace declaration attribute.
+ * @param dom - DOM document used to create the attribute.
+ * @param {String} namespaceURI - Namespace URI.
+ * @param {String} prefix - Namespace prefix.
+ * @return DOM attribute node for the namespace declaration.
+ */
+function xmlNewNSDeclaration(dom, namespaceURI, prefix) {
+    return xmlNewAttribute(dom, xmlnsNS, xmlQualifiedName("xmlns", prefix), namespaceURI);
+}
+
+/** Creates a new DOM document fragment node for the specified xml text.
+ * @param dom - DOM document from which the fragment node is going to be created.
+ * @param {String} text XML text to be represented by the XmlFragment.
+ * @return New DOM document fragment object.
+ */
+function xmlNewFragment(dom, text) {
+
+    var value = "<c>" + text + "</c>";
+    var tempDom = xmlParse(value);
+    var tempRoot = tempDom.documentElement;
+    var imported = ("importNode" in dom) ? dom.importNode(tempRoot, true) : tempRoot;
+    var fragment = dom.createDocumentFragment();
+
+    var importedChild = imported.firstChild;
+    while (importedChild) {
+        fragment.appendChild(importedChild);
+        importedChild = importedChild.nextSibling;
+    }
+    return fragment;
+}
+
+/** Creates new DOM text node.
+ * @param dom - DOM document used to create the text node.
+ * @param {String} text - Text value for the DOM text node.
+ * @return DOM text node.
+ */ 
+function xmlNewText(dom, text) {
+    return dom.createTextNode(text);
+}
+
+/** Creates a new DOM element or DOM attribute node as specified by path and appends it to the DOM tree pointed by root.
+ * @param dom - DOM document used to create the new node.
+ * @param root - DOM element node used as root of the subtree on which the new nodes are going to be created.
+ * @param {String} namespaceURI - Namespace URI of the new DOM element or attribute.
+ * @param {String} prefix - Prefix used to qualify the name of the new DOM element or attribute.
+ * @param {String} path - Path string describing the location of the new DOM element or attribute from the root element.
+ * @return DOM element or attribute node for the last segment of the path.
+
+ * This function will traverse the path and will create a new DOM element with the specified namespace URI and prefix
+ * for each segment that doesn't have a matching element under root.
+ * The last segment of the path may be decorated with a starting @ character. In this case a new DOM attribute node
+ * will be created.
+ */
+function xmlNewNodeByPath(dom, root, namespaceURI, prefix, path) {
+    var name = "";
+    var parts = path.split("/");
+    var xmlFindNode = xmlFirstChildElement;
+    var xmlNewNode = xmlNewElement;
+    var xmlNode = root;
+
+    var i, len;
+    for (i = 0, len = parts.length; i < len; i++) {
+        name = parts[i];
+        if (name.charAt(0) === "@") {
+            name = name.substring(1);
+            xmlFindNode = xmlAttributeNode;
+            xmlNewNode = xmlNewAttribute;
+        }
+
+        var childNode = xmlFindNode(xmlNode, namespaceURI, name);
+        if (!childNode) {
+            childNode = xmlNewNode(dom, namespaceURI, xmlQualifiedName(prefix, name));
+            xmlAppendChild(xmlNode, childNode);
+        }
+        xmlNode = childNode;
+    }
+    return xmlNode;
+}
+
+/** Returns the text representation of the document to which the specified node belongs.
+ * @param domNode - Wrapped element in the document to serialize.
+ * @returns {String} Serialized document.
+*/
+function xmlSerialize(domNode) {
+    var xmlSerializer = window.XMLSerializer;
+    if (xmlSerializer) {
+        var serializer = new xmlSerializer();
+        return serializer.serializeToString(domNode);
+    }
+
+    if (domNode.xml) {
+        return domNode.xml;
+    }
+
+    throw { message: "XML serialization unsupported" };
+}
+
+/** Returns the XML representation of the all the descendants of the node.
+ * @param domNode - Node to serialize.
+ * @returns {String} The XML representation of all the descendants of the node.
+ */
+function xmlSerializeDescendants(domNode) {
+    var children = domNode.childNodes;
+    var i, len = children.length;
+    if (len === 0) {
+        return "";
+    }
+
+    // Some implementations of the XMLSerializer don't deal very well with fragments that
+    // don't have a DOMElement as their first child. The work around is to wrap all the
+    // nodes in a dummy root node named "c", serialize it and then just extract the text between
+    // the <c> and the </c> substrings.
+
+    var dom = domNode.ownerDocument;
+    var fragment = dom.createDocumentFragment();
+    var fragmentRoot = dom.createElement("c");
+
+    fragment.appendChild(fragmentRoot);
+    // Move the children to the fragment tree.
+    for (i = 0; i < len; i++) {
+        fragmentRoot.appendChild(children[i]);
+    }
+
+    var xml = xmlSerialize(fragment);
+    xml = xml.substr(3, xml.length - 7);
+
+    // Move the children back to the original dom tree.
+    for (i = 0; i < len; i++) {
+        domNode.appendChild(fragmentRoot.childNodes[i]);
+    }
+
+    return xml;
+}
+
+/** Returns the XML representation of the node and all its descendants.
+ * @param domNode - Node to serialize
+ * @returns {String} The XML representation of the node and all its descendants.
+ */
+function xmlSerializeNode(domNode) {
+
+    var xml = domNode.xml;
+    if (xml !== undefined) {
+        return xml;
+    }
+
+    if (window.XMLSerializer) {
+        var serializer = new window.XMLSerializer();
+        return serializer.serializeToString(domNode);
+    }
+
+    throw { message: "XML serialization unsupported" };
+}
+
+exports.http = http;
+exports.w3org = w3org;
+exports.xmlNS = xmlNS;
+exports.xmlnsNS = xmlnsNS;
+
+exports.hasLeadingOrTrailingWhitespace = hasLeadingOrTrailingWhitespace;
+exports.isXmlNSDeclaration = isXmlNSDeclaration;
+exports.xmlAppendChild = xmlAppendChild;
+exports.xmlAppendChildren = xmlAppendChildren;
+exports.xmlAttributeNode = xmlAttributeNode;
+exports.xmlAttributes = xmlAttributes;
+exports.xmlAttributeValue = xmlAttributeValue;
+exports.xmlBaseURI = xmlBaseURI;
+exports.xmlChildElements = xmlChildElements;
+exports.xmlFindElementByPath = xmlFindElementByPath;
+exports.xmlFindNodeByPath = xmlFindNodeByPath;
+exports.xmlFirstChildElement = xmlFirstChildElement;
+exports.xmlFirstDescendantElement = xmlFirstDescendantElement;
+exports.xmlInnerText = xmlInnerText;
+exports.xmlLocalName = xmlLocalName;
+exports.xmlNamespaceURI = xmlNamespaceURI;
+exports.xmlNodeValue = xmlNodeValue;
+exports.xmlDom = xmlDom;
+exports.xmlNewAttribute = xmlNewAttribute;
+exports.xmlNewElement = xmlNewElement;
+exports.xmlNewFragment = xmlNewFragment;
+exports.xmlNewNodeByPath = xmlNewNodeByPath;
+exports.xmlNewNSDeclaration = xmlNewNSDeclaration;
+exports.xmlNewText = xmlNewText;
+exports.xmlParse = xmlParse;
+exports.xmlQualifiedName = xmlQualifiedName;
+exports.xmlSerialize = xmlSerialize;
+exports.xmlSerializeDescendants = xmlSerializeDescendants;
+exports.xmlSiblingElement = xmlSiblingElement;

http://git-wip-us.apache.org/repos/asf/olingo-odata4-js/blob/27f830e6/package.json
----------------------------------------------------------------------
diff --git a/package.json b/package.json
index e48ba0a..044cb81 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "odatajs",
   "version": "4.0.0",
-  "postfix": "beta-01",
+  "postfix": "",
   "releaseCandidate": "",
   "title": "Olingo OData Client for JavaScript",
   "description": "the Olingo OData Client for JavaScript library is a new cross-browser JavaScript library that enables data-centric web applications by leveraging modern protocols such as JSON and OData and HTML5-enabled browser features. It's designed to be small, fast and easy to use.",


Mime
View raw message