API Docs for:
Show:

File: src/triplestore.js

  1. /*
  2.  * $Id: src_triplestore.js.html,v 1.1 2013/06/28 16:10:02 hitoshi Exp $
  3.  * This library enables web applications to easily store triples into Web Storage.
  4.  * See Copyright for the status of this software.
  5.  * uchida@w3.org
  6.  */
  7.  
  8. /**
  9.  * Triplestore wrapper for HTML5 WebStorage.
  10.  * @main Triplestore
  11.  * @class Triplestore
  12.  * @constructor
  13.  * @uses localStorage
  14.  */
  15. var Triplestore = function() {
  16.   this.st = localStorage;
  17.   this.prefixMapping = {};
  18.   this.appPrefix = "<W3C>";
  19.   this.appPrefixLen = this.appPrefix.length;
  20. };
  21.  
  22. (function(){
  23.   resolveQName = function(prefixMapping, qname) {
  24.     if(!qname) {
  25.       return null;
  26.     }
  27.     var resolved = null;
  28.     if(isAbsoluteURI(qname)) {
  29.       resolved = qname;
  30.     } else {
  31.       var index = qname.indexOf(":");
  32.       if(index == -1) {
  33.         resolved = qname;
  34.       } else {
  35.         var prefix = qname.substr(0, index);
  36.         var iri = prefixMapping[prefix];
  37.         if(iri) {
  38.           resolved = iri + qname.substr(index + 1);
  39.         } else {
  40.           resolved = qname;
  41.         }
  42.       }
  43.     }
  44.     return resolved;
  45.   };
  46.   isAbsoluteURI = function(url_str) {
  47.     var index = url_str.indexOf("://");
  48.     return index == -1 ? false : true;
  49.   };
  50.   /**
  51.    * Sets a mapping given a mapping and a URI to map.
  52.    * @method setMapping
  53.    * @param mapping {String} mapping
  54.    * @param iri {String} iri
  55.    * @example
  56.    *   st.setMapping("foaf", "http://xmlns.com/foaf/0.1/");
  57.    */
  58.   Triplestore.prototype.setMapping = function(mapping, iri) {
  59.     this.prefixMapping[mapping] = iri;
  60.   };
  61.   /**
  62.    * Retrieves a list of DOMStrings which are IRI identifiers for
  63.    * subjects given an optional property and value to match against.
  64.    * @method getSubjects
  65.    * @param [property] {String} property
  66.    * @param [value] {String} value
  67.    * @return {Array} Sequence&lt;DOMString>
  68.    * @example
  69.    *   st.getSubjects("foaf:name", "Bob");
  70.    */
  71.   Triplestore.prototype.getSubjects = function(property, value) {
  72.     var hasValue = function(list, value) {
  73.       for(var i = 0; list && i < list.length; i++) {
  74.         if(list[i] == value) {
  75.           return true;
  76.         }
  77.       }
  78.       return false;
  79.     };
  80.     
  81.     //init
  82.     property = resolveQName(this.prefixMapping, property);
  83.     value = resolveQName(this.prefixMapping, value);
  84.     
  85.     var res = [];
  86.     for(var subject in this.st) {
  87.       var props_str = this.st.getItem(subject);
  88.       var props = JSON.parse(props_str);
  89.       
  90.       if(property) {
  91.         if(value) {
  92.           if(hasValue(props[property], value)) {
  93.             res.push(subject.substr(this.appPrefixLen));
  94.           }
  95.         } else {
  96.           if(props[property]) {
  97.             res.push(subject.substr(this.appPrefixLen));
  98.           }
  99.         }
  100.       } else {
  101.         for(var prop in props) {
  102.           if(!value || hasValue(props[prop], value)) {
  103.             res.push(subject.substr(this.appPrefixLen));
  104.             break;
  105.           }
  106.         }
  107.       }
  108.     }
  109.     return res;
  110.   };
  111.   /**
  112.    * Retrieves a list of DOMStrings which are IRI identifiers for
  113.    * properties given an optional subject to match against.
  114.    * @method getProperties
  115.    * @param [subject] {String} subject
  116.    * @return {Array} Sequence&lt;DOMString>
  117.    * @example
  118.    *   st.getProperties("http://sample.org/bob");
  119.    */
  120.   Triplestore.prototype.getProperties = function(subject) {
  121.     if(subject) {
  122.       //init
  123.       subject = resolveQName(this.prefixMapping, subject);
  124.       subject = subject ? this.appPrefix + subject: null;
  125.       
  126.       var props_str = this.st.getItem(subject);
  127.       var props = JSON.parse(props_str);
  128.       var res = [];
  129.       for(var prop in props) {
  130.         res.push(prop);
  131.       }
  132.       return res; 
  133.     } else {
  134.       var map = {};
  135.       for(subject in this.st) {
  136.         if(subject.substr(0, this.appPrefixLen) == this.appPrefix) {
  137.           var props_str = this.st.getItem(subject);
  138.           var props = JSON.parse(props_str);
  139.           for(var prop in props) {
  140.             map[prop] = null;
  141.           }
  142.         }
  143.       }
  144.       var res = [];
  145.       for(var key in map) {
  146.         res.push(key);
  147.       }
  148.       return res;
  149.     }
  150.   };
  151.   /**
  152.    * Retrieves a list of mixed types given an optional subject
  153.    * and property to match against.
  154.    * @method getValues
  155.    * @param [subject] {String} subject
  156.    * @param [property] {String} property
  157.    * @return {Array} Sequence&lt;any>
  158.    * @example
  159.    *   st.getValues("http://sample.org/bob", "foaf:name");
  160.    */
  161.   Triplestore.prototype.getValues = function(subject, property) {
  162.     //init
  163.     subject = resolveQName(this.prefixMapping, subject);
  164.     property = resolveQName(this.prefixMapping, property);
  165.     subject = subject ? this.appPrefix + subject: null;
  166.     
  167.     var subjects = [];
  168.     if(subject) {
  169.       subjects.push(subject);
  170.     } else {
  171.       for(var subject in this.st) {
  172.         subjects.push(subject);
  173.       }
  174.     }
  175.     
  176.     var res = [];
  177.     for(var i = 0; i < subjects.length; i++) {
  178.       var subject = subjects[i];
  179.       var props_str = this.st.getItem(subject);
  180.       if(props_str) {
  181.         var props = JSON.parse(props_str);
  182.       
  183.         if(property) {
  184.           if(props[property]) {
  185.             res = res.concat(props[property]);
  186.           }
  187.         } else {
  188.           for(var prop in props) {
  189.             res = res.concat(props[prop]);
  190.           }
  191.         }
  192.       }
  193.     }
  194.     return res;
  195.   };
  196.   /**
  197.    * Set a triple to localStorage. The old value of the property is overwritten.
  198.    * @method set
  199.    * @param subject {String} subject
  200.    * @param property {String} property
  201.    * @param value {String} value
  202.    * @example
  203.    *   st.set("http://sample.org/bob", "foaf:name", "Bob");
  204.    */
  205.   Triplestore.prototype.set = function(subject, property, value) {
  206.     //init
  207.     subject = resolveQName(this.prefixMapping, subject);
  208.     property = resolveQName(this.prefixMapping, property);
  209.     value = resolveQName(this.prefixMapping, value);
  210.     subject = subject ? this.appPrefix + subject: null;
  211.     
  212.     var props_str = this.st[subject];
  213.     if(props_str) {
  214.       var props = JSON.parse(props_str);
  215.       props[property] = new Array(value);
  216.       this.st.setItem(subject, JSON.stringify(props));
  217.     } else {
  218.       var props = {};
  219.       props[property] = new Array(value);
  220.       this.st.setItem(subject, JSON.stringify(props)); 
  221.     }
  222.   };
  223.   /**
  224.    * Add a triple to localStorage. If the property has already values,
  225.    * the new value is concatenated to them.
  226.    * @method add
  227.    * @param subject {String} subject
  228.    * @param property {String} property
  229.    * @param value {String} value
  230.    * @example
  231.    *   st.add("http://sample.org/bob", "foaf:name", "Bob");
  232.    */
  233.   Triplestore.prototype.add = function(subject, property, value) {
  234.     //init
  235.     subject = resolveQName(this.prefixMapping, subject);
  236.     property = resolveQName(this.prefixMapping, property);
  237.     value = resolveQName(this.prefixMapping, value);
  238.     subject = subject ? this.appPrefix + subject: null;
  239.     
  240.     var props_str = this.st[subject];
  241.     if(props_str) {//exist
  242.       var props = JSON.parse(props_str);
  243.       if(props[property]) {
  244.         props[property].push(value);
  245.       } else {
  246.         props[property] = new Array(value);
  247.       }
  248.       this.st.setItem(subject, JSON.stringify(props));
  249.     } else {//not exist
  250.       var props = {};
  251.       props[property] = new Array(value);
  252.       this.st.setItem(subject, JSON.stringify(props)); 
  253.     }
  254.   };
  255.   /**
  256.    * Remove an subject or a property from internal storage to match against.
  257.    * @method remove
  258.    * @param [subject] {String} subject
  259.    * @param [property] {String} property
  260.    * @example
  261.    *   st.remove("http://sample.org/bob", "foaf:name");
  262.    */
  263.   Triplestore.prototype.remove = function(subject, property) {
  264.     //init
  265.     subject = resolveQName(this.prefixMapping, subject);
  266.     property = resolveQName(this.prefixMapping, property);
  267.     subject = subject ? this.appPrefix + subject: null;
  268.     
  269.     if(subject) {
  270.       if(property) {/* remove the property */
  271.         var props_str = this.st[subject];
  272.         if(props_str) {
  273.           var props = JSON.parse(props_str);
  274.           delete props[property];
  275.           this.st.setItem(subject, JSON.stringify(props));
  276.         } else {
  277.           throw Error("Not found " + subject + ":" + property);
  278.         }
  279.       } else {/* remove the subject */
  280.         this.st.removeItem(subject);
  281.       }
  282.     } else {
  283.       if(property) {/* remove all matched properties */
  284.         for(var subject in this.st) {
  285.           var props_str = this.st[subject];
  286.           var props = JSON.parse(props_str);
  287.           if(props[property]) {
  288.             delete props[property];
  289.             this.st.setItem(subject, JSON.stringify(props));
  290.           }
  291.         }
  292.       } else {
  293.         this.st.clear();  
  294.       }
  295.     }
  296.   };
  297.   /**
  298.    * Retrieves a Projection given a subject
  299.    * @method getProjection
  300.    * @param subject {String} subject
  301.    * @return {Projection} projection
  302.    * @example
  303.    *   st.getProjection("http://sample.org/bob");
  304.    */
  305.   Triplestore.prototype.getProjection = function(subject) {
  306.     //init
  307.     subject = resolveQName(this.prefixMapping, subject);
  308.     subject = subject ? this.appPrefix + subject: null;
  309.     
  310.     var props_str = this.st[subject];
  311.     var res = null;
  312.     if(props_str) {
  313.       var props = JSON.parse(props_str);
  314.       res = new Projection(this, subject, props);
  315.     }
  316.     return res;
  317.   };
  318.   /**
  319.    * Print the content of the storage.
  320.    * @method show
  321.    */
  322.   Triplestore.prototype.show = function() {
  323.     for(var i = 0; i < this.st.length; i++) {
  324.       var subject = this.st.key(i);
  325.       console.log(subject + ":" + this.st.getItem(subject));
  326.     }
  327.   };
  328.   
  329.   /**
  330.    * <a href="http://www.w3.org/TR/rdfa-api/#projections">
  331.    * Projection</a> class.
  332.    * @class Projection
  333.    * @private
  334.    * @constructor
  335.    */
  336.   var Projection = function(store, subject, props) {
  337.     this.store = store;
  338.     this.st = store.st;
  339.     this.prefixMapping = store.prefixMapping;
  340.     this.subject = subject;
  341.     this.props = props;
  342.   };
  343.  
  344.   /**
  345.    * Retrieves the list of properties that are available on
  346.    * the Projection. Each property must be an absolute URI.
  347.    * @method getProperties
  348.    * @return {Array} sequence&lt;String>
  349.    */
  350.   Projection.prototype.getProperties = function(value) {
  351.     //init
  352.     value = resolveQName(this.prefixMapping, value);
  353.     
  354.     var res = [];
  355.     for(var prop in this.props) {
  356.       if(value) {
  357.         if(this.props[prop] == value) {
  358.           res.push(prop);
  359.         }
  360.       } else {
  361.         res.push(prop);
  362.       }
  363.     }
  364.     return res;
  365.   };
  366.   /**
  367.    * Retrieves the subject URI of this Projection as a string,
  368.    * the value must be an absolute URI.
  369.    * @method getSubject
  370.    * @return {String}
  371.    */
  372.   Projection.prototype.getSubject = function() {
  373.     return this.subject.substr(this.store.appPrefixLen);
  374.   };
  375.   /**
  376.    * Retrieves the first property with the given name as a
  377.    * language-native datatype.
  378.    * @method get
  379.    * @param property {String} property
  380.    * @return {String}
  381.    * @example
  382.    *   projection.get("foaf:name");
  383.    */
  384.   Projection.prototype.get = function(property) {
  385.     var values = this.getAll(property);
  386.     return values ? values[0] : null;
  387.   };
  388.   /**
  389.    * Retrieves the list of values for a property as an array
  390.    * of language-native datatypes.
  391.    * @method getAll
  392.    * @param property {String} The name of the property to retrieve
  393.    * @return {Array} sequence&lt;String>
  394.    * @example
  395.    *   st.getAll("foaf:name");
  396.    */
  397.   Projection.prototype.getAll = function(property) {
  398.     //init
  399.     property = resolveQName(this.prefixMapping, property);
  400.     
  401.     if(property) {
  402.       return this.props[property] ? this.props[property] : [];
  403.     } else {
  404.       var res = [];
  405.       for(var prop in this.props) {
  406.         res = res.concat(this.props[prop]);
  407.       }
  408.       return res;
  409.     }
  410.   };
  411.   Projection.prototype.remove = function() {
  412.     this.st.removeItem(this.subject);
  413.   };
  414. })();
  415.  
  416.