Documentation: In Depth API User Guide

API implements abstract data types and data structures using polymorphic principles. Each interface corresponds to an abstract data type and each class corresponds to one or more layers of data structures built on top.

What are the classes and interfaces API implements?

Following abstract data types and data structures have been implemented:

List: interface that defines operations of List abstract data type with following classes built on top:
- ArrayList: class that implements List using Dynamic Array data structure
  Its STL equivalent is std::vector!
- LinkedList: class that implements List using Linked List data structure
  Its STL equivalent is std::forward_list!
- DoublyLinkedList: class that implements List using Doubly Linked List data structure
  Its STL equivalent is std::list!
Map: interface that defines operations of Associative Array abstract data type with following classes built on top:
- HashMap: class that implements Map using Hash Table data structure
  Its STL equivalent is std::unordered_map!
- LinkedHashMap: class that implements Map using Linked Hash Table data structure
  It has no STL equivalent!
- TreeMap: class that implements Map using Red Black Tree data structure
  Its STL equivalent is std::map!
Set: interface that defines operations of Set abstract data type with following classes built on top:
- HashSet: class that implements Set using Hash Table data structure
  Its STL equivalent is std::unordered_set!
- LinkedHashSet: class that implements Set using Linked Hash Table data structure
  It has no STL equivalent!
- TreeSet: class that implements Set using Red Black Tree data structure
  Its STL equivalent is std::set!
Container: interface that defines operations of Container abstract data type with following classes built on top:
- Queue: class that implements Container using Queue data structure, itself working behind a modified Dynamic Array
  Its STL equivalent is std::queue!
- Stack: class that implements Container using Stack data structure, itself working behind a Dynamic Array
  Its STL equivalent is std::stack!
Tree: interface that defines operations of Tree abstract data type with following classes built on top:
- HashTree: class that implements Tree using Standard Tree data structure, itself working behind a Hash Table to insure node value uniqueness
  It has no STL equivalent!
- RedBlackTree: class that implements Tree using Binary Search Tree data structure, itself working by a Red Black Tree algorithm to guarantee optimal self-balancing
  Its STL equivalent is std::_Rb_tree!
Graph: interface that defines operations of Graph abstract data type with following classes built on top:
- UnweightedGraph: abstract class that implements Graph using Unweighted Graph data structure, itself working behind a Hash Table to insure vertex value uniqueness, in a version that assumes edge weights' absence
  - DirectedUnweightedGraph: class that extends UnweightedGraph using Unweighted Directed Graph data structure
    It has no STL equivalent!
  - UndirectedUnweightedGraph: class that extends UnweightedGraph using Unweighted Undirected Graph data structure
    It has no STL equivalent!
- WeightedGraph: abstract class that implements Graph using Weighted Graph data structure, itself working behind a Hash Table to insure vertex value uniqueness, in a version that assumes edge weights' presence
  - DirectedWeightedGraph: class that extends WeightedGraph using Weighted Undirected Graph data structure
    It has no STL equivalent!
  - UndirectedWeightedGraph: class that extends WeightedGraph using Weighted Undirected Graph data structure
    It has no STL equivalent!

User dependencies

Some of classes above require developers to implement C functions built via template specialization for each data type used:

comparators: comparison functions that need to be created by developers for each data type used (API comes only with long and char* support by default). Required by all classes, except Container
hashers: hash functions that need to be created by developers for each data type used (API comes only with long and char* support by default). Required by all classes that rely on a Hash Table.

How can above classes and interfaces be iterated?

All above interfaces and classes, with exception of Container instances (who are supposed to behave like black boxes), are iterable/traversable. Unlike STL iterators, this API takes advantage of polymorphism and iterates by abstractions (interfaces / abstract classes) with the exception of Tree implementations:

all classes extending List (latter included) are iterable via abstract class ListIterator
all classes extending Map (latter included) are iterable via abstract class MapIterator
all classes extending Set (latter included) are iterable via abstract class SetIterator
all classes extending Graph are iterable via functions DepthFirstSearchGraphIterator or BreadthFirstSearchGraphIterator
all classes extending Tree are iterable via functions PreOrderTreeIterator, PostOrderTreeIterator, LevelOrderTreeIterator (if HashTree) or specialized class methods (if RedBlackTree)