JAVASCRIPT   85

Interfaces js

Guest on 31st May 2022 01:57:38 AM

  1. /**
  2.  * @author Tom
  3.  */
  4.  
  5. /**
  6.  * Read-only source.
  7.  */
  8. type("Getter", [], {
  9.         /**
  10.          * Returns value from the source.
  11.          * @return {Object} value
  12.          */
  13.         get: function() {}
  14.  
  15. },
  16.         /**
  17.          *
  18.          * @param {Function} get
  19.          * @constructor
  20.          */
  21.         function(get) {
  22.                 this.get = get;
  23.         }
  24. );
  25.  
  26. /**
  27.  * Read-write source.
  28.  */
  29. type("Accessor", ["Getter"], {
  30.         /**
  31.          * Sets the new value and returns the previous value.
  32.          * @param {Object} value
  33.          * @return {Object} old value
  34.          */
  35.         set: function(value) {}
  36. },
  37.         /**
  38.          *
  39.          * @param {Function} get
  40.          * @param {Function} set
  41.          * @constructor
  42.          */
  43.         function(get, set) {
  44.                 this.get = get;
  45.                 this.set = set;
  46.         }
  47. );
  48.  
  49. /**
  50.  * Object with change notifications.
  51.  */
  52. type("Observable", [], {
  53.         /**
  54.          * Attaches the new observer and returns function that detaches the observer.
  55.          * @param {Function} observer
  56.          * @return {Function} function to detach observer
  57.          */
  58.         observe: function(observer) {}
  59. },
  60.         /**
  61.          *
  62.          * @param {Function} observer
  63.          * @constructor
  64.          */
  65.         function(observer) {
  66.                 this.observe = observer;
  67.         }
  68. );
  69.  
  70. /**
  71.  * Observable that can simulate a change.
  72.  */
  73. type("InvokableObservable", ["Observable"], {
  74.         /**
  75.          * Simulates a change invoking the given observer.
  76.          * @param {Function} observer
  77.          */
  78.         invokeObserver: function(observer) {}
  79. },
  80.         /**
  81.          *
  82.          * @param {Function} observer
  83.          * @param {Function} invokeObserver
  84.          * @constructor
  85.          */
  86.         function(observer, invokeObserver) {
  87.                 this.observe = observer;
  88.                 this.invokeObserver = invokeObserver;
  89.         }
  90. );
  91.  
  92. /**
  93.  * Observable read-only source.
  94.  */
  95. type("WatchGetter", ["Getter", "InvokableObservable"], {
  96. },
  97.         /**
  98.          *
  99.          * @param {Function} get
  100.          * @param {Function} observe
  101.          * @param {Function} invokeObserver
  102.          * @constructor
  103.          */
  104.         function(get, observe, invokeObserver) {
  105.                 this.get = get;
  106.                 this.observe = observe;
  107.                 this.invokeObserver = invokeObserver;
  108.         }
  109. );
  110.  
  111. /**
  112.  * Observable read-write source.
  113.  */
  114. type("WatchAccessor", ["WatchGetter", "Accessor"], {
  115. },
  116.         /**
  117.          *
  118.          * @param {Function} get
  119.          * @param {Function} set
  120.          * @param {Function} observe
  121.          * @param {Function} invokeObserver
  122.          * @constructor
  123.          */
  124.         function(get, set, observe, invokeObserver) {
  125.                 this.get = get;
  126.                 this.set = set;
  127.                 this.observe = observe;
  128.                 this.invokeObserver = invokeObserver;
  129.         }
  130. );
  131.  
  132. /**
  133.  * Sometimes unreadable source.
  134.  */
  135. type("CanGet", [], {
  136.         /**
  137.          * Returns true if the source can be read.
  138.          * @return {Boolean} result
  139.          */
  140.         canGet: function() {
  141.                 throw new Error("Not implemented");
  142.         }
  143. });
  144.  
  145. /**
  146.  * Object with manual refreshing.
  147.  */
  148. type("Refreshable", [], {
  149.         /**
  150.          * Triggers refresh.
  151.          */
  152.         refresh: function() {}
  153. },
  154.         /**
  155.          *
  156.          * @param {Function} refresh
  157.          * @constructor
  158.          */
  159.         function(refresh) {
  160.                 this.refresh = refresh;
  161.         }
  162. );
  163.  
  164. /**
  165.  * Source state enumeration.
  166.  */
  167. var SourceState = new Enum("None", "Loading", "Loaded", "Committing", "Error");
  168.  
  169. /**
  170.  * Abstract remote source.
  171.  */
  172. type("Source", ["Refreshable"], {
  173.         /**
  174.          * State of the source.
  175.          * @type {WatchGetter}
  176.          */
  177.         state: null,
  178.  
  179.         /**
  180.          * Error of the source.
  181.          * @type {WatchGetter}
  182.          */
  183.         error: null
  184. });
  185.  
  186. /**
  187.  * Source with enumerable items.
  188.  */
  189. type("Enumerable", [], {
  190.         /**
  191.          * Enumerates all items.
  192.          * @param {Function} iterator
  193.          * @return {Object} result of iterator
  194.          */
  195.         each: function(iterator) {},
  196.  
  197.         isEmpty: function() {}
  198. },
  199.         /**
  200.          *
  201.          * @param {Object} each
  202.          * @constructor
  203.          */
  204.         function(each, isEmpty) {
  205.                 this.each = each;
  206.                 this.isEmpty = isEmpty;
  207.         }
  208. );
  209.  
  210. type("WatchListable", ["Enumerable"], {
  211.         /**
  212.          * Attaches the list observer and returns a function to detach the observer.
  213.          * @param {Object} listObserver
  214.          * @return {Function}
  215.          */
  216.         observe: function(listObserver) {}
  217. });
  218.  
  219. /**
  220.  * Collection with sequential access.
  221.  */
  222. type("List", ["Enumerable"], {
  223.         /**
  224.          * Number of items.
  225.          * @type {Getter}
  226.          */
  227.         length: null,
  228.  
  229.         /**
  230.          * Returns item at index
  231.          * @param {Number} index
  232.          * @return {Object} item
  233.          */
  234.         item: function(index) {},
  235.  
  236.         /**
  237.          * Returns accessor for item
  238.          * @param {Number} index
  239.          * @return {Accessor}
  240.          */
  241.         accessor: function(index) {
  242.                 var self = this;
  243.                 return new Accessor(function() {
  244.                         return self.item(index);
  245.                 }, function(value) {
  246.                         return self.replaceAt(index, value);
  247.                 });
  248.         },
  249.  
  250.  
  251.         /**
  252.          * Returns all items in an array
  253.          * @return {Array} items
  254.          */
  255.         allItems: function() {},
  256.  
  257.         /**
  258.          * Appends the new item and returns an index of the item.
  259.          * @param {Object} item
  260.          * @return {Number} index
  261.          */
  262.         append: function(item) {},
  263.  
  264.         appendExisting: function(item) {
  265.                 if (exists(item)) {
  266.                         return this.append(item);
  267.                 } else {
  268.                         return this.length;
  269.                 }
  270.         },
  271.  
  272.         appendMany: function(items) {
  273.                 var self = this;
  274.                 each(items, function(item) {
  275.                         self.append(item);
  276.                 });
  277.         },
  278.  
  279.         /**
  280.          * Inserts the new item at the index if available,
  281.          * otherwise inserts the item at the beginning.
  282.          * Returns the index of the item.
  283.          * @param {Object} item
  284.          * @param {Number} [index]
  285.          * @return {Number} index
  286.          */
  287.         insert: function(item, index) {},
  288.  
  289.         /**
  290.          * Removes the item and returns an index of the item.
  291.          * @param {Object} item
  292.          * @return {Number} index
  293.          */
  294.         remove: function(item) {},
  295.  
  296.         removeMany: function(items) {
  297.                 var self = this;
  298.                 each(items, function(item) {
  299.                         self.remove(item);
  300.                 });
  301.         },
  302.  
  303.         /**
  304.          * Removes an item at the given index and returns the item.
  305.          * @param {Object} index
  306.          * @return {Object} item
  307.          */
  308.         removeAt: function(index) {},
  309.  
  310.         removeManyAt: function(indexes) {
  311.                 var self = this;
  312.                 each(indexes, function(index) {
  313.                         self.removeAt(index);
  314.                 });
  315.         },
  316.  
  317.         /**
  318.          * Replaces item at index and returns previous item
  319.          * @param {Number} index
  320.          * @param {Object} item
  321.          * @return {Object} previous item
  322.          */
  323.         replaceAt: function(index, item) {
  324.                 var old = this.removeAt(index);
  325.             this.insert(item, index);
  326.                 return old;
  327.         },
  328.  
  329.         /**
  330.          * Moves an item from the source to the destination index
  331.          * and returns the item.
  332.          * @param {Number} source
  333.          * @param {Number} destination
  334.          * @return {Object} item
  335.          */
  336.         move: function(source, destination) {
  337.                 var item = this.removeAt(source);
  338.                 this.insert(item, destination);
  339.                 return item;
  340.         },
  341.  
  342.         /**
  343.          * Removes all items and return these items.
  344.          * @returns {Array} cleared elements
  345.          */
  346.         clear: function() {},
  347.  
  348.         /**
  349.          * Returns index of item or null if not found
  350.          * @param {Object} item
  351.          * @return {Number} index
  352.          */
  353.         indexOf: function(item) {}
  354. },
  355.         /**
  356.          * Builds a new list on top of the array.
  357.          * @param {Array} array
  358.          * @constructor
  359.          */
  360.         function(array) {
  361.                 array = getArray(array);
  362.                 var self = this;
  363.                 this.length = new Getter(function() {
  364.                         return array.length;
  365.                 });
  366.                 this.item = function(index) {
  367.                         return array[index];
  368.                 };
  369.                 this.allItems = function() {
  370.                         return array.slice(0);
  371.                 };
  372.                 this.append = function(item) {
  373.                         array.push(item);
  374.                         return array.length - 1;
  375.                 };
  376.                 this.insert = function(item, index) {
  377.                         if (!exists(index)) {
  378.                                 index = 0;
  379.                         }
  380.                         array.splice(index, 0, item);
  381.                         return index;
  382.                 };
  383.                 this.remove = function(item) {
  384.                         var index = this.indexOf(item);
  385.                         if (exists(index)) {
  386.                                 array.splice(index, 1);
  387.                         }
  388.                         return index;
  389.                 };
  390.                 this.removeAt = function(index) {
  391.                         return array.splice(index, 1)[0];
  392.                 };
  393.                 this.clear = function() {
  394.                         var old = array;
  395.                         array = [];
  396.                         return old;
  397.                 };
  398.                 if (isFunction(array.indexOf)) {
  399.                         this.indexOf = function(item) {
  400.                                 var index = array.indexOf(item);
  401.                                 return (index === -1) ? null : index;
  402.                         };
  403.                 } else {
  404.                         this.indexOf = function(item) {
  405.                                 for (var i in array) {
  406.                                         if (array[i] === item) {
  407.                                                 return i;
  408.                                         }
  409.                                 }
  410.                                 return null;
  411.                         };
  412.                 }
  413.                 this.each = function(iterator) {
  414.                         return iterate(array, iterator);
  415.                 };
  416.                 this.isEmpty = function() {
  417.                         return array.length === 0;
  418.                 };
  419.         }
  420. );
  421.  
  422. /**
  423.  * Lookup
  424.  */
  425. type("Lookup", [], {
  426.         /**
  427.          * Gets a value using the key.
  428.          * @param {String} key
  429.          * @return {Object} value
  430.          */
  431.         get: function(key) {
  432.                 throw new Error("Not implemented");
  433.         }
  434. },
  435.         function(values) {
  436.                 this.get = function(key) {
  437.                         var value = values[key];
  438.                         if (exists(value)) {
  439.                                 if (value.Getter) {
  440.                                         return value.get();
  441.                                 } else if (isFunction(value)) {
  442.                                         return value();
  443.                                 }
  444.                         }
  445.                         return value;
  446.                 };
  447.         }
  448. );
  449.  
  450. /**
  451.  * Map-like collection.
  452.  */
  453. type("Dictionary", ["Lookup", "Enumerable"], {
  454.  
  455.         /**
  456.          * Sets the value with the key and returns a previous value.
  457.          * @param {String} key
  458.          * @param {String} value
  459.          * @return {Object} old
  460.          */
  461.         set: function(key, value) {
  462.                 throw new Error("Not implemented");
  463.         },
  464.  
  465.         /**
  466.          * Get values of the all properties.
  467.          * @return {Object} values
  468.          */
  469.         getAll: function() {
  470.                 throw new Error("Not implemented");
  471.         },
  472.  
  473.         /**
  474.          * Updates multiple properties.
  475.          * @param {Object} values
  476.          * @return {Object} changes
  477.          */
  478.         update: function(values) {
  479.                 throw new Error("Not implemented");
  480.         },
  481.  
  482.         /**
  483.          * Replaces multiple properties.
  484.          * @param {Object} values
  485.          * @return {Object} changes
  486.          */
  487.         replace: function(values) {
  488.                 throw new Error("Not implemented");
  489.         },
  490.  
  491.         /**
  492.          * Deletes all properties and returns their values.
  493.          * @method clear
  494.          * @return {Object} changes
  495.          */
  496.         clear: function() {
  497.                 throw new Error("Not implemented");
  498.         }
  499. });
  500.  
  501. /**
  502.  * Attachable source.
  503.  */
  504. type("Attachable", [], {
  505.         /**
  506.          * Attaches the new item and returns a function to detach this item.
  507.          * @param {Object} item
  508.          * @param {Function} item remover
  509.          */
  510.         attach: function(item) {
  511.                 throw new Error("Not implemented");
  512.         }
  513. });
  514.  
  515. /**
  516.  * Attachable source that can enumerate its items.
  517.  */
  518. type("EnumerableAttachable", ["Attachable", "Enumerable"]);
  519.  
  520.  
  521.  
  522. type("Equatable", [], {
  523.         /**
  524.          *
  525.          */
  526.         equals: function(item) {
  527.                 return this == item;
  528.         }
  529. });

Raw Paste


Login or Register to edit or fork this paste. It's free.