home *** CD-ROM | disk | FTP | other *** search
/ C/C++ User's Journal & Wi…eveloper's Journal Tools / C-C__Users_Journal_and_Windows_Developers_Journal_Tools_1997.iso / windbase / windbase.exe / WINDBASE / DETAILS.TXT < prev    next >
Text File  |  1996-10-16  |  19KB  |  507 lines
  1.  
  2. THE DETAILS
  3. -----------
  4.  
  5. Version 3.0 of the Memory Structures Library (MemSL)
  6. adds Many New and Powerful Features
  7. ----------------------------------------------------
  8.  
  9. If you have been looking for software that includes a
  10. complete data structures library, memory tracing,
  11. memory  debugging, exception handling, definable memory
  12. handlers and more, then Windbase has the package for
  13. you.  The MemSL has a complete set of data structures
  14. which lets you choose the data structures that are best
  15. for your project.  The data structures included in
  16. version 3.0 include:
  17.  
  18.            Dynamic, Multi-Dimentional Arrays
  19.             Single and Double linked lists
  20.              Circular Single Linked Lists
  21.              Circular Double Linked Lists
  22.                  Linked List Pointers
  23.         Cut, Copy, and Paste with Linked Lists
  24.               Stacks, Queues and Dequeues
  25.                     Priority Queues
  26.             Sets, Tables, and Dictionaries
  27.          Hashing Tables with Separate Chaining
  28.           Hashing Tables with Dynamic Paging
  29.            Binary and Threaded Binary Trees
  30.               AVL and Threaded AVL Trees
  31.  
  32. The MemSL version 3.0 is designed to maximize
  33. flexibility and ease of use.  It incorporates more data
  34. structures than ever before.  And the data structures
  35. in version 3.0 are even more manageable and flexible
  36. using definable memory handlers, exception handling,
  37. memory tracing and debugging.
  38.  
  39. All for only $79.99  The combination of a complete
  40. data structures library, memory debugging tool, and the
  41. low price make the MemSL version 3.0 a terrific value!
  42.  
  43.  
  44. Data Structures in Detail
  45. -------------------------
  46.  
  47. Dynamic, Multi-Dimensional Arrays
  48. ---------------------------------
  49.  
  50. The MemSL provides an easy-to-use multi-dimensional
  51. dynamic array.  MemSL arrays can be allocated at any
  52. time during the program's runtime.  The arrays can be
  53. of any size and dimension, which can be determined at
  54. runtime.  With a simple call to open the array:
  55.  
  56.   WBArrayOpen(NULL,"10,10,80");
  57.  
  58. the programmer can allocate an array of any size and
  59. any number of dimensions.
  60.  
  61.  
  62. Single, Double and Circular Linked Lists
  63. ----------------------------------------
  64.  
  65. The MemSL provides numerous routines for dealing with
  66. single and double linked lists.  Routines for adding,
  67. deleting, sorting, searching and traversing make the
  68. MemSL linked lists very flexible and powerful.  Linked
  69. lists can have single or double links.  A linked list
  70. can also become a circular linked list by calling:
  71.  
  72.  WBDListCircular(list,WB_TRUE);
  73.  
  74. And, if needed, the circular list can become non-
  75. circular simply by making the same call with WB_FALSE.
  76.  
  77. All the MemSL linked list routines are easy to use.
  78. For example, the following functions are used for
  79. adding, deleting and searching items in a list:
  80.  
  81.  WBDListAdd(dlist,item,WB_FIRST);
  82.  WBDListDelete(dlist,WB_LAST);
  83.  item = WBDListSearch(dlist,item);
  84.  item = WBDListGet(dlist,WB_NEXT);
  85.  
  86. You can also choose to add, delete and get items from
  87. the end, previous, current and next positions in the
  88. list.  And by adding items with the sorting option:
  89.  
  90.  WBDListAdd(dlist, item, WB_SORT);
  91.  
  92. sorted linked lists can be used as well.
  93.  
  94. As an example of how powerful the MemSL linked list
  95. routines are, Windbase has developed a full-featured
  96. text editor complete with cut, copy and paste,
  97. highlighted text blocking, full-featured macros, read
  98. blocks, write blocks, buffered keyboard input (with the
  99. MemSL queue routines acting as a ring buffer), and
  100. more, all designed with the MemSL.
  101.  
  102.  
  103. New Linked List Pointers
  104. ------------------------
  105.  
  106. Version 3.0 of the MemSL now has linked list pointers.
  107. This powerful feature allows the programmer to use the
  108. MemSL list routines while pointing to several different
  109. positions in the list at the same time.
  110.  
  111. Opening a pointer to a linked list using the MemSL is
  112. simple:
  113.  
  114.  listptr = WBDListPointer(mainlist);
  115.  
  116. After obtaining the list pointer, any of the MemSL
  117. linked list routines can be used on the pointer to the
  118. list:
  119.  
  120.  WBDlistAdd(listptr, "New Item", WB_FIRST);
  121.  
  122. In the above example, the "New Item" seems to be added
  123. to the linked list pointer.  In reality, it is being
  124. added to the main list.
  125.  
  126.  
  127. Cut, Copy and Paste with Linked Lists
  128. -------------------------------------
  129.  
  130. Also new to version 3.0 of the MemSL is the ability to
  131. Cut, Copy and Paste linked list sections from one list
  132. to another.   This gives the MemSL even greater
  133. abilities with linked lists.  Programmers can now cut,
  134. copy and paste entire linked lists or parts of a list.
  135. By opening one or two pointers to a linked list, the
  136. programmer can call:
  137.  
  138.  WBDListCut(newlist, ptr1, ptr2);
  139.  WBDListCopy(newlist, listptr1, listptr2);
  140.  WBDListAddList(list1, list2, WB_LAST, 1);
  141.  
  142. you may have noticed all the above examples are using
  143. double linked lists. The same functions and
  144. functionality are available with single linked lists as
  145. well.
  146.  
  147.  
  148. Stacks, Queues and Dequeues
  149. ---------------------------
  150.  
  151. The MemSL stacks, queues and dequeues allow the
  152. programmer to use any data type such as char and int,
  153. or user-defined data types such as structures and
  154. unions.  The stacks, queues and dequeues can be used
  155. with arrays or linked lists.  Using stacks, queues, and
  156. dequeues with the array option allows the programmer to
  157. use only the memory needed to store the items.  It also
  158. allows the programmer to define a limit to the number
  159. of items that can be stored.  By using stacks, queues
  160. and dequeues with the linked list option there is no
  161. limit to the number of items that can be stored.
  162.  
  163.  
  164. Priority Queues
  165. ---------------
  166.  
  167. Version 3.0 of the MemSL now contains priority queues.
  168. Priority queues allow a programmer to store items and
  169. retrieve the items based on a priority value
  170. definition.  This priority value is an integer value
  171. from 0 to MAXUINT.
  172.  
  173.  
  174. Sets, Tables and Dictionaries
  175. -----------------------------
  176.  
  177. The set, table and dictionary structures make use of
  178. the MemSL threaded AVL tree.  This gives maximum speed
  179. for large or small sets, tables and dictionaries, while
  180. providing all the functionality required for these data
  181. structure types.
  182.  
  183. The MemSL sets, tables and dictionary ADTs all offer
  184. basic functionality with add, delete, clear, is empty,
  185. is member, number of items, execute, and more.  The
  186. table is the simplest of the three and provides only
  187. the basic functionality.  Sets have the basic
  188. functionality along with union, intersection,
  189. difference, subset, superset and is equal.
  190. Dictionaries have the basic functionality and provide
  191. the programmer with is predecessor, is successor, get
  192. predecessor, get successor and get range.  The get
  193. range function allows a programmer to select and copy a
  194. range of items from the dictionary into a new
  195. dictionary.
  196.  
  197.  
  198. Hash Tables with Separate Chaining
  199. ----------------------------------
  200.  
  201. The MemSL hashing table allows a programmer to define a
  202. table and a hashing function (the MemSL also provides a
  203. default hashing function).  Hash tables are great for
  204. searching, by providing a function that returns an
  205. index in to the table, finding an item in a table is
  206. very quick and in many cases only requires one search.
  207.  
  208. With separate chaining the MemSL hash table can add
  209. items dynamically.  Every time an item is added to the
  210. same position in the table, the new item is simply
  211. added to the beginning of a single linked list.  So, a
  212. hashing table in one of its simplest forms is simply an
  213. array of linked lists.
  214.  
  215.  
  216. Hash Tables with Dynamic Paging
  217. -------------------------------
  218.  
  219. Version 3.0 of the MemSL now has a dynamic paging hash
  220. table.  This powerful hash table provides all the
  221. functionality expected from a hashing table and also
  222. provides the ability for the table to grow as it needs
  223. to.  Every time the hash table reaches a programmer-
  224. defined average-items-per-bucket maximum, the hash
  225. table will automatically add a new page.  This allows
  226. the MemSL hash table to provide ideal searching by
  227. keeping the average number of items per bucket spread
  228. across the hash table.
  229.  
  230.  
  231. Binary and Threaded Binary Tree