	//[ array ]0
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**||                                                     || *
     *					  THE FACTORY C MANUAL                   *
     * ||                                                     ||**/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* @about:     The Factory C Library (Factory C) (OOC)       *
	 * @version:   1.5.1                                         *
	 * @author:    Christopher (Willy) Posten                    */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* define factory c:										 *
	 *                                                           *
	 *		factory c is free software for the purpose(s) of     *
     * education, modification and distribution. it is an        *
	 * object-oriented programming definition in c that gets     *
	 * extended into a class-oriented programming definition.    *
	 * that class-oriented programming (cop) is an extension     *
	 * of oop and that it has an attribute to itself apart       *
	 * from oop are attributes of the definition of factory c,   *
	 * which is implemented defensively using object-oriented    *
	 * programming techniques and design patterns like factory   *
	 * method. factory c is meant to be used in defensive        *
	 * program implementation(s) and those that require modifi-  *
	 * cation after implementation.                              *
     * 															 *
	 *		to implement in factory c is to implement classes    *
     * that use an integrated singleton class factory method     *
     * used by the factory table to hook onto a class. this      *
     * class factory method uses a class interface heap with     *
     * interfaces and, after the class extended class virtual    *
     * table interface there are many non-extended class tables  *
	 * each directly coupled with a primary and secondary method *
	 * like the class vtable before extending it. when a class   *
	 * is assigned a factory method for its interface heap this  *
	 * de-couples the class methods from just a single interface,*
	 * from there each non-extended class table can simply enca- *
	 * psulate each ooa&d pattern. this makes simple directives  *
     * out of methods/operations (like input/output and compar-  *
	 * ison) that can be otherwise challenging to organize in a  *
	 * single interface and have ready for all classes of object.*
	 * this is the first critical decoupling point of a class    *
	 * and it's method(s). the second point, is with a vtable    *
	 * being paired with a class virtual heap in a class inter-  *
	 * face heap. the vheap is a virtual table map with a fact-  *
	 * ory method, a sub factory method to the class factory     *
	 * method, one that stores the subscript value or position   *
	 * of the method(s) in the vtable organized by method name   *
	 * as the primary key. this all is used to de-couple the     *
	 * "bulk" methods of the class vtable from their data-field  *
	 * positions in their level(s) of class extension in their   *
	 * interfaces. also a class complex heap is used to de-      *
	 * couple datamembers from their data field positions in the *
	 * class objects. classes that implement the dual sub-factory*
	 * methods by cheap and vheap can be used to copy into run-  *
	 * time structures of run time objects, object classes rela- *
	 * tive to a class-oriented mobile outpost and as a wing of a*
	 * object class (dynamic class) or a multiple inheritance of *
	 * one. this covers the case of run-time inheritances or     *
	 * fused classes and their objects.							 *
	 * 															 *
	 * 		in order to achieve this undertaking in object-orie- *
	 * nted programming definition extension run-time objects    *
	 * are placed under a protocol(s) that is either primary and *
     * foreward or secondary and reverse. the virtual table obj- *
     * ect as a/the primary foreward object protocol is matched  *
     * with the builder table interface as a/the secondary rev-  *
     * erse object protocol. there is a protocol extension for   *
     * either that reverse couples the object to its more primary*
     * foreward object as a basic object adapter. this would be  *
     * as the more primary foreward object has the adapter fore- *
     * ward coupled to itself as a foreward datamember. the cla- *
     * ss vtable from basic object oriented programming is rev-  *
     * erse coupled to its class factory method as an object ada-*
     * pter of by the time it is fully coupled to its class id   *
     * assigned class factory method of a factory table class and*
     * a functioning secondary reverse object to the primary for-*
     * eward virtual table object of a class. this also means    *
     * that in class oriented programming interfaces get implem- *
	 * ented as classes themselves in a way that is identical to *
     * one for a virtual table object (vto) other than that the  *
     * class factory table used to encapsulate object oriented   *
     * programming for a class would encapsulate a different     *
	 * keyword, or set of keywords from new/delete, but build/de-*
	 * molish. also a class that implements an additional class  *
     * sub protocol table for additional type identification.    *
	 *
	 * 		the class ftable, the original interface offered by  *
	 * a factory table class is used to encapsulate only the     *
	 * first half of the constructor in/from basic object orie-  *
	 * nted programming only after the constructor has been de-  *
	 * coupled into two parts the: allocator/initializer. but i  *
	 * was unsuccessful at doing so in c++ when i tried, with an *
	 * implicit constructor/initializer call instead if function *
	 * parenthesis omitted. the primary reason why factory c is  *
	 * a c definition/declaration/implementation not a C++ one   *
	 * and because of this, and to properly extend, not reimpl-  *
	 * ement object-oriented programming factory c closely imi-  *
	 * tates c++ as a sincere form of strategy. this is done with*
	 * exactly the very first (of 4) hash table singletons imp-  *
	 * lemented. the first and last hash tables both implement a *
	 * protocol of run-time object (rto) as twin tables and the  *
	 * hash tables that are like the hip-hop turntables for one  *
	 * being like a primary foreward table and the other being   *
	 * like a secondary reverse table.                           *
	 *                                                           *
	 * 		maybe just for someone who is left handed if the     *
	 * first one is on the left and primary foreward as or some- *
	 * thing. the second hashtable is the most widely structured *
	 * and implemented one with the third hashtable being a thin *
	 * connector table of reverse couplings like a table of elb- *
	 * ows of objects. you can use your imagination for how the  *
	 * four hashtables, the four corners of factory c are rela-  *
	 * tive to a dj setup or something, maybe if you like being  *
	 * like a dj with your object-oriented programming then you  *
	 * can use factory c easily and fluently then. 				 *
	 *															 *
	 *		factory c was inspired by the constructor from c++,  *
	 * with its class-oriented programming (cop) primary method, *
	 * the factory table multimap or primary multimap that is    *
	 * also inspired by the array. this uses a unique class of   *
	 * class the control factory, the generic method conveyor    *
	 * belt or template of methods. this way multimap can have   *
	 * small classes implemented for it to extend its functiona- *
	 * lity as a class-oriented method/structure or run-time str-*
	 * ucture like the constructor. factory c is also inspired by*
	 * the ooc textbook, offered by some university for free     *
	 * online i can leave a note of what university here, or in  *
	 * this manual sometime would be fine. anyways, factory c is *
	 * placed inside a folder named ooc because it was supposed  *
	 * to be where i read and complete the examples to implement *
	 * an object oriented c but, after one or two chapter decided*
	 * to implement my own way instead, one that imitates c++ for*
	 * as far as it has a definition to imitate in the object-or-*
	 * iented department. being truly inspired somehow by even   *
	 * just the first page of the textbook that went so far to   *
	 * say something about objects doing everything if we imple- *
	 * ment them slowly and carefully enough or something.       *
	 *															 *
	 *		this manual will break down structure by their top-  *
	 * level definitions mostly. this includes all the recycled  *
	 * from c++ keywords and new keyworded definitions, and most *
	 * definately, broken down into class structure as the set   *
	 * requirements to use each keyword. the chapters go in order*
	 * of definition which is also of importance, with at least  *
	 * one other critical point of decoupling factory c impleme- *
	 * nts being how functions are decoupled from their paramet- *
	 * ers using a stack. so: main, factory function, i/o overl- *
	 * oad then virtual table object, etc...					 *
	 *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	 * #interface				            					 *
	 * #1a		   main  										 *
	 *															 *
	 *             		define(s):   		     				 *
	 *			   1a.1    - typename(constructor)         ({}); *
	 *			   1a.2    - typename(destructor)          ({}); *
	 *                                                           *
	 * #1b	       factory function                    (+sStack) *
	 *															 *
	 *             		keyword(s):                              *
	 *             1b.1	   - control                        ()() *
	 *             1b.2    - arg                              () *
	 *                                                           *
	 * #1c	       i/o overload                        (+iStack) *
	 *                                                 (+oStack) *
	 *             		keyword(s):                              *
	 *             1c.1    - cscan                            () *
	 *             1c.2	   - cprint                           () *
	 *															 *
	 * #2a		   virtual table object                (+vTable) *
	 *                                                 (+vStack) *
	 *             		keyword(s):                              *
	 *             2a.1    - new					        ()() *
	 *		   	   2a.2    - delete		    	  	          () *
	 *			   2a.3    - virtual				      ()()-> *
	 *		   	   2a.4    - typeid				 		      () *
	 *         	   2a.5    - is_object				     	(){} *
	 *         	   2a.6    - instanceof			   	      !i()() *
	 *	     	   2a.7	   - destroy                     	  () *
	 *         	   2a.8    - this				     	 	 n/a *
	 *             		implementation(s):                       *
     *             2a.9    - structures:					     *
	 *						1 - class                    typedef *
	 *                      2 - class(VirtualTable)      typedef *
     *             2a.10   - prototypes:					     *
	 *                      1 - class(Init)               static *
	 *                      2 - class(Dtor)               static *
	 *                      3 - class(Type)               static *
     *             2a.11   - interface:						     *
	 *                      1 - class(Interface)          static *
     *             2a.12   - implementations:	 		     	 *
	 *                      1 - class(Init)             explicit *
	 *                      2 - class(Dtor)             explicit *
	 *             		define(s):   		     				 *
     *             2a.13   - typename(Dtor)               ()(){} *
	 *             2a.14   - typename(Type)                  (); *
	 *															 *
	 * #2b		   exception/assertion        		   (+eStack) *
	 *    		                     				   (+jStack) *
	 *             		keyword(s):                              *
	 *			   2b.1    - try/catch                    {}(){} *
	 *			   2b.2	   - throw                     (new())() *
	 *			   2b.3    - place   		           (new())() *
	 *             2b.4    - debug                 ( ,new())(){} *
	 *             2b.5    - exception                       n/a *
	 *             2b.6    - flag                             () *
	 *             		define(s):			     				 *
     *             2b.7    - typename(Exception)             (); *
	 *             2b.8    - typename(Assertion)             (); *
	 *															 *
	 * #3a		   factory table class                 (+fTable) *
	 *                                                 (+mStack) *
	 *                                                 (+tStack) *
	 *             		keyword(s):                              *
	 *			   3a.1    - register						  () *
	 *			   3a.2	   - drop                             () *
	 *			   3a.3    - primary/multimap           ()()()() *
	 *			   3a.4    - iterator                         () *
	 *             3a.5    - factory                        ()() *
	 *             3a.6    - destruct                         () *
	 *			   3a.7	   - function                 (()*f())() *
	 *			   3a.8	   - complex                    (*()c()) *
	 *             3a.9    - override                     ()()() *
	 *             3a.10   - is_class                       (){} *
	 *             3a.11   - type                             () *
	 *             3a.12   - map                              () *
	 *             3a.13   - int_id                           () *
	 *             		implementation(s):                       *
     *             3a.13   - prototypes:					     *
	 *						1 - class(Ctor)           	  static *
	 *						2 - class(Free)           	  static *
     *             3a.14   - interface registrations:   		 *
	 *                      1 - class(VirtualTable)       static *
	 *                          1 - class(Init)           static *
	 *                          2 - class(Dtor)           static *
	 *						2 - class(FactoryTable)       static *
	 *							1 - class(Ctor)			  static *
	 *						    2 - class(Free)			  static *
	 *                      3 - class(AdapterTable)       static *
	 *							1 - adapter(Type)         static *
	 *                          2 - class(Type)           static *
	 *                      4 - class(CompareTable)       static *
	 *							1 - class(Equal)		  static *
	 *						    2 - class(Greater)	      static *
	 *                      5 - class(ConsoleTable)       static *
	 *						6 - class(StandardTable)      static *
	 *						7 - class(FileTable)          static *
	 *                      8 - class(StrategyHeap)       static *
	 *						9 - class(PolymorphHeap)      static *
	 *						10- class(VirtualHeap)        static *
	 *						11- class(ComplexHeap)        static *
	 *                      12- class(ControlHeap)        static *
	 *                      13- class(BuilderHeap)        static *
	 *                      14- class(SecurityHeap)       static *
	 *                      15- class(SingletonTable)     static *
	 *						16- class(SubjectStack)       static *
	 *                      17- class(BasicsHeap)         static *
	 *						18- class(LibraryHeap)        static *
	 *                      19- class(OverloadHeap)       static *
	 *                      20- class(TemplateHeap)	      static *
	 *						21- class(AdapterHeap)        static *
	 *                      22- class(ControlTable)       static *
	 *                      23- class(SubjectHeap)        static *
	 *                      24- class(TemplateMethod)     static *
	 *                      25- struct(AbortKey)          static *
	 *						26- class(TemplateTable)	  static *
	 *						27- singleton(ObjectTable)	  static *
	 *						28- sub(FactoryMethod)	      static *
	 *						29- sub(Container)	          static *
	 *						30- sub(Protocol)	          static *
	 *						31- class(FactoryControl)	  static *
	 *						32- class(CommandControl)	  static *
	 *						33- class(ControlFactory)	  static *
	 *						34- class(FactoryTable)	      static *
	 *						35- class(InterfaceHeap)	  static *
	 *						36- array(DetonateTable)	  static *
	 *						37- class(PreviousTable)	  static *
	 *						38- singleton(TypeInfo)	      static *
	 *						39- string(StrategyHeap)	  static *
	 *						40- class(BridgeHeap)	      static *
	 *						41- builder(Container)	      static *
	 *						42- class(InfoHeap)	          static *
	 *						43- class(WeightHeap)	      static *
	 *						44- builder(IdentifyTable)	  static *
	 *			   3a.15   - class factory method:               *
	 *                      1 - class(InterfaceHeap)      static *
	 *                      2 - class(FactoryMethod)      static *
	 *                      2 - class(Setup)		      static *
	 *                      3 - class(Abort)		      static *
	 *             		define(s)			     				 *
     *             3a.16   - typename(Ctor)                  (); *
     *             3a.17   - typename(class(FactoryMethod))  (); *
     *             3a.18   - typename(class(FactoryControl)) (); *
	 *             3a.29   - typename(sub(FactoryMethod)     (); *
	 *             3a.20   - typename(Setup)                (){} *
	 *             3a.21   - typename(Abort)                (){} *
	 *															 *
	 * #3b		   template array 		         	 (+cFactory) *
	 *                                                 (+cStack) *
	 *             		keyword(s):                              *
	 *             3b.1    - template			              () *
	 *             3b.2    - cbegin              ()()()...()cend *
	 *             3b.3	   - cend                            n/a *
	 *             3b.4    - break                            () *
	 *             3b.5    - cout                ()()()...()cend *
	 *             3b.6    - cin				 ()()()...()cend *
	 *             3b.7    - endl                            n/a *
	 *             		implementation(s):                       *
	 *															 *
	 * #4   	   adapter table object adapter        (+aTable) *
	 *                                                           *
	 *             		keyword(s):                              *
	 *			   1.1 	   - adapter 						()() *
	 *			   1.2     - friend							 ()= *
	 *             1.3     - is_adapter                       {} *
	 *			   1.1     - union						  ()()() *
	 *             1.2	   - type_info                        () *
	 *             		implementation(s):                       *
     *             1.10    - prototypes						     *
	 *                      1 - class(Adapter)(Init)      static *
	 *                      2 - class(Adapter)(Dtor)      static *
     *             1.11    - interface						     *
	 *                      1 - class(Adapter)(Interface) static *
     *             1.12    - implementations	 		     	 *
	 *                      1 - class(Adapter)(Init)    explicit *
	 *                      2 - class(Adapter)(Dtor)    explicit *
	 *														     *
	 * #5 		   builder table interface             (+bTable) *
	 *                                                 (+hStack) *
	 *                                                 (+nStack) *
	 *             		keyword(s):                              *
	 *             4.1     - build							()() *
	 *             4.2     - demolish                         () *
	 * 			   4.3     - to_builder                       () *
	 *             4.4     - is_builder                     (){} *
	 *             4.5     - builder_id                       () *
	 *             4.7     - int_class                        () *
	 *             4.8     - class_id                         () *
	 *             		implementation(s):                       *
     *             4.10    - structures:					     *
	 *						2 - sub(Table)               typedef *
	 *						2 - sub(Table)(VirtualTable) typedef *
     *             4.11    - prototypes:					     *
	 *                      1 - sub(Table)(Type)          static *
	 *                      2 - sub(Table)(Init)          static *
	 *                      3 - sub(Table)(Dtor)          static *
     *             1.11    - interface:						     *
	 *                      1 - sub(Table)(Protocol)      static *
	 *                      1 - sub(Table)(Interface)     static *
     *             1.12    - implementations:	 		     	 *
	 *                      1 - sub(Table)(Init)        explicit *
	 *                      2 - sub(Table)(Dtor)        explicit *
	 *			   												 *
	 * #6A		   bunker object                       (-vTable) *
	 *                                                           *
	 *             		keyword(s):                              *
	 *             2.1     - accumulate			            ()() *
	 *		   	   2.2     - deaccumulate    	  	          () *
	 *			   2.3     - bunker  				      ()()-> *
	 *		   	   2.4     - bunker_id		    		      () *
	 *         	   2.5     - is_bunker				     	(){} *
	 *                                                           *
	 * #6B		   object class           	                     *
	 *                                                           *
	 *             		keyword(s):                              *
	 *			   5.1     - typedef           ()(); -or- ()(){} *
	 *			   5.2	   - auto                             () *
	 *			   5.3     - static                         ()() *
	 *             5.4     - bytes                            () *
	 *															 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
#if 0
1a[ array ]
#endif // 0
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**||  C PROGRAM CONSTRUCTOR AND DESTRUCTOR FOR FACTORY C || *
     * ||                                                     ||**/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* @todo:                                                    *
	 *                                                           *
	 *  	 inside your:                                        *
	 *	CodeBlocks/MinGW/lib/gcc/mingw32/5.1.0/include           *
	 *       -or-                                                *
     *  CodeBlocks\MinGW\x86_64-w64-mingw32\include	    		 *
	 *                                                           *
	 *       folder you place your OOC folder. inside your OOC   *
	 * folder you place your: Factory/obj/Debug/OOC/OOC.o object *
	 * file and remove the OOC.c file (with the .o file in its   *
	 * place). this turns the Factory project (C project) or the *
	 * OOC portion of it into a library you include with a single*
	 * file.                                                     *
	 *                                                           *
	 * @also:                                                    *
	 *                                                           *
	 *       You will need to implement the program constructor  *
	 * that is, actually an implicit program constructor followed*
	 * by an explicit program constructor that is by default,    *
	 * empty. we will get into what you have that you can put    *
	 * there when we introduce the FactoryTable (found in Factory*
	 * /fTable.h). this is also true for the program destructor  *
	 * that is an explicit program destructor followed by an imp-*
	 * licit program destructor. again, when we cover the Factory*
	 * Table you will see what we put there. so ...              *
	 *															 *
	 * @note:                                                    *
	 *															 *
	 *       Factory C is implemented in three levels, meaning   *
	 * it can also be Virtual C or Complex C. Virtual level Fact-*
	 * ory C or Virtual C can be configured by the user express- *
	 * ing that they want. replace __FACTORY_C__ below with __VI-*
	 * RTUAL_C__ for level 1 or __COMPLEX_C__ for level 3. for   *
	 * level 2 either use the expression __FACTORY_C__ or omit   *
	 * for Factory C as default. each level corresponds to an    *
	 * object level.								             *
	 *															 *
	 * @also: 													 *
	 *															 *
	 *		 #1A, #1B, #1C, #2A, #2B, #4 are all __VIRTUAL_C__.  *
	 *		 everything from __VIRTUAL_C__ and #3A, #3B are		 *
	 *       __FACTORY_C__. that plus everything else is		 *
     *       __COMPLEX_C__.							 			 *
	 *														     *
	 * @define(s):   	                	     				 *
	 *															 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

	#define __FACTORY_C__
	#include <OOC/OOC.h> /// Object-Oriented C (Factory C)

	typename(constructor) ({  }) ;

	int main()
	{
		String * obj = factory ("String")(this, 2, "Hello World") ;

		cout (obj) endl cend;

		delete (obj);

		return 0;
	}

	typename(destructor) ({}) ;

      // is placed inside your main.c

    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
#if 0
1b[ array ]
#endif // 0
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**||   THE FACTORY C FUNCTION ARGUMENTS STACK FOR THE    || *
     *                      FACTORY FUNCTION                     *
     *                                                           *
     *             by Willy (??/??/2022)(04/17/2022)             *
     *                      (04/20/2022)(12/05/2022)             *
     *                      (04/15/2025)                         *
     * ||                                                     ||**/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     * @brief  Reason(s) to use:                                 *
     *                                                           *
     *   1)  decouple functions from their parameter(s) in a 	 *
	 *       way that the control calling function passes 		 *
	 *       control to the function it encapsulates, if any.    *
     *                                                           *
     *   2a) pass control to no other function so pop or         *
     *       return this stack top. (0.)	                     *
     *                                                           *
     *   2b) pass to another function so push or redirect.       *
     *       (non-0).										     *
     *                                                           *
     *   X)  these two choices are determined by control's 		 *
	 *       parameter (the one at the end) and whether it's	 *
	 *       null (0) or not.									 *
     *                                                           *
     ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     * @brief  Keyword(s)               						 *
     *                                                           *
     *   1.1)  control                                      ()() *
	 *															 *
	 *	 override@_StackTop(Interface).vcontrol           		 *
	 *                                                           *
	 *		 not found in anything else i know. not when it      *
	 *       allows functions to encapsulate one another and     *
	 *       pass all their parameters straight through a        *
	 *       recursive amount of times. otherwise similar to     *
	 *       va_list and va_arg from c for a parameter stack.	 *
	 *															 *
	 *       this was implemented with oop in mind when it       *
	 *       is like a constructor for your factory functions,   *
	 *       just place the function name always i n the         *
	 *       first parenthesis, this is used as a reference      *
	 *       by addressof & and stringized for readability by    *
	 *       #. the first parameter of your function or the      *
	 *       last one with the ellipsis on the right is what     *
	 *       gets placed inside the second parenthesis with      *
	 *       last but not least, the address (p) of the func-    *
	 *       tion control is passed to, 0 if no other function.  *
	 *                                                           *
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/

    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                Stack * stack = control(Func)(self, 0) ;
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                      control(Func)(self, ctrl) ;

					  ctrl(self);
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                      int var = arg(stack, int) ;
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                      int var = stack(arg)(int) ;
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#if 0
2a[ array ]
#endif // 0
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*-OBJECT TABLE - OBJECT TABLE - OBJECT TABLE - OBJECT TABLE-*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**||    C VIRTUAL TABLE  (STRUCTCLASS OBJECT FACTORY)    || *
     *                                                           *
     *             by Willy (11/06/2018)(01/13/2021)             *
     *                      (12/01/2021)(12/15/2021)             *
     *                      (01/04/2022)(02/05/2022)             *
     *                      (02/07/2022)(02/09/2022)             *
     *                      (02/16/2022)(03/31/2022)             *
     *                      (09/11/2022)(03/31/2023)             *
     * ||                   (01/15/2024)                      ||**/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*-OBJECT TABLE - OBJECT TABLE - OBJECT TABLE - OBJECT TABLE-*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     * @brief  Reason(s) to use:                                 *
     *                                                           *
     *   1)  keep an extra pointer to each location where non-   *
     *       automatic memory for an object is located, this way *
     *       memory leaks won't occur as easy.                   *
     *                                                           *
     *   2)  all objects come fully initialized using the        *
     *       constructor.                                        *
     *                                                           *
     *   3)  assign an interface to each object, retrieving it   *
     *       when necessary.                                     *
     *                                                           *
     *   4)  with a fully object-based approach, anything not an *
     *       object that is off-the-stack and not on-the-stack   *
     *       can be deallocated through a pointer inside an      *
     *       object's destructor as non-automatic memory (heap). *
     *                                                           *
     *   5)  when the object is assigned its interface, one      *
     *       should note that the first datafield position of    *
     *       every interface is reserved for the type method,    *
     *       used to give (its) description, otherwise the       *
     *       objects description as a runtime string, the        *
     *       objects type id. this is the class key to the       *
     *       map/multimap assigned to it at the factory table.   *
     *                                                           *
     ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     * @brief  Keyword(s)               						 *
     *                                                           *
     *   2a.1) new                                          ()() *
	 *															 *
	 *	 override@VirtualTable(Interface).insert        		 *
	 *                                                           *
	 *		 found in Java, little has changed with this         *
	 *       keyword other than the classname goes in            *
	 *       parenthesis and a pointer (this) gets passed        *
	 *       into the first parameter of the constructor.        *
	 *       the second parameter may be used for the case       *
	 *       number for a constructor as a factory function      *
	 *       that has multiple uses. case 1 is reserved          *
	 *       for the copy constructor. this is the way to        *
	 *       instantiate an instance of an object that is        *
	 *       not only a runtime object but a virtual table       *
	 *       object. instantiation not only includes             *
	 *       allocation but also initialization using an         *
	 *       initializer function called from the constructor    *
     *       as a pointer. the first set of parenthesis for      *
     *       new is considered an allocator and encapsulating    *
     *       it without calling the constructor is what the      *
     *       class allocator for a factory table class does      *
	 *       and that is one of the bigger reasons why we        *
	 *       are here in C for the definition of Factory C       *
	 *       and not C++ is because we want to use new to        *
	 *       return the address of the initializer function      *
	 *       with an object on the stack at some point. this     *
	 *       keyword or the location of its method has at		 *
	 *       least one override placed on it when the fTable     *
	 *       gets registered for an object-oriented pre-         *
	 *       initializer overload by class(PreviousTable).		 *
     *                                                           *
     *       1) write an add function for the vtable             *
     *          to take memory from an object, init              *
     *          and return the constructor's pointer.            *
     *                                                           *
     *       2) an extra front-end pointer named this can        *
     *          pass memory from the vtable into the ctor        *
     *                                                           *
     *       3) write the constructor to return memory           *
     *          finishing new in a statement                     *
     *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
       Vector(class) * vector = new (Vector(class))(this, ...) ;
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* debug:
		   / *++++new()()++++++++++++++++++++++++++++++++* /
	  	    type:	 Vector(class)
		    info:	 Vector(class)
	   	    self:	 0x1f18b0 (this)
		    ctor:	 0x406849
		    line:	 1927
		    file:	 C:/...
	   	   / *+++++++++++++++++++++++++++++++++++++++++++* /
	 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**                                                          *
     *   2a.2) delete                                         () *
	 *															 *
	 *	 override@VirtualTable(Interface).remove        		 *
     *                                                           *
	 *       found in C++, but not Java. as the new keyword      *
	 *       is original to C++ so is the keyword delete.        *
	 *       this is where the destructor is called and the      *
	 *       instance is deallocated.                            *
	 *                                                           *
     *       1) pass the pointer to the vtable so                *
     *          it can call the objects destructor.              *
     *                                                           *
     *       2) deallocate the object itself.                    *
     *                                                           *
     *       3) remove entry from vTable data structure.         *
	 *															 *
	 *		 note: it cannot be a temporary memory location      *
	 *             or a pop off a stack that gets passed         *
	 *             into delete because the pointer that          *
	 *             points to the object that gets passed         *
	 *             into delete gets set to null (0).			 *
	 *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                            delete(vector);
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* debug:
		   / *++++delete(&)++++++++++++++++++++++++++++++* /
			type:	 Vector(class)
			name:	 &vector
			self:	 0x10a6280
			loca:	 0x78f8f0
			line:	 1772
			file:	 C:/...
		   / *+++++++++++++++++++++++++++++++++++++++++++* /
	 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**															 *
     *   2a.3) virtual                                    ()()-> *
	 *															 *
	 *	 override@VirtualTable(Interface).search        		 *
	 *                                                           *
	 *       this is where Java uses a '.' for accessing         *
	 *       interface methods. virtual casts the objects        *
	 *       interface (class vtable) as it's being returned     *
	 *       from the virtual table, the place to access ->      *
	 *       method() from the objects interface.                *
     *                                                           *
     *       1) retrieve the pointer to object's interface.      *
     *                                                           *
     *       2) cast the pointer to Class(VirtualTable) type.    *
     *                                                           *
     *       3) pass the pointer (this) into the interface       *
     *          method's first parameter to initialize self.     *
	 *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
           virtual(Container)(vector) -> insert (this, ...);
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* debug:
		   / *++++virtual()()++++++++++++++++++++++++++++* /
	    	type:	 Vector(class)
			name:	 vector
			self:	 0x10a62c0
			cast:	 Container(VirtualTable)*
			line:	 2224
			file:	 C:/...
		   / *+++++++++++++++++++++++++++++++++++++++++++* /
	 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**															 *
     *   2a.4) typeid						    			  () *
	 *															 *
	 *	 override@_typeid										 *
     *                                                           *
	 *		 if this isn't found in Java, it's definately        *
	 *       found in C++. typeid is how you access the          *
	 *       class name of the object as a cstring.	the 		 *
	 *       Class(Type) function that initializes the 			 *
	 *       . type method of the class(VirtualTable) at		 *
	 *       [0] of the interface assigned to a vto is		     *
	 *       called by typeid.									 *
	 *															 *
     *       1) ask the vtable what an object is and return      *
     *          the cstring for its type id (class type).        *
	 *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                    cstring type = typeid(vector) ;
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* debug:
		   / *++++typeid()+++++++++++++++++++++++++++++++* /
			type:	 Vector(class)
			name:	 vector
			self:	 0x4c10cc
			line:	 1804
			file:	 C:/...
	       / *+++++++++++++++++++++++++++++++++++++++++++* /
	 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**                                                          *
     *   2a.5) is_object									(){} *
	 *															 *
	 *		 whatever C++ used this for, i'm guessing for        *
	 *       the same thing we use it for here and thats to      *
	 *       check if a pointer points to an object.             *
	 *       is_object is a global method that may return        *
	 *       null (0) (false). use it as a case (if is object)   *
	 *       or something, remember you can use it to return     *
     *       the class virtual table also but check return       *
     *       for 0 (null) (false) first.                         *
	 *															 *
     *       1) ask the vtable if its an instance passed         *
     *          and return its class vtable if it is.            *
     *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                          is_object( vector ){}
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
        class(VirtualTable) * def = is_object( vector ){}else{}
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**															 *
	 *   2a.6) instanceof									()() *
	 *															 *
	 *       this is a macro that can be substituted with        *
	 *       string(equal)("Class", typeid(a)). 				 *
	 *                                                           *
     *       1) use a string comparison to check if the          *
     *          objects typeid is the same as the stringized     *
	 *          classname.                                       *
	 *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                  !instanceof(Vector(int))( vector )
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**															 *
	 *   2a.7) destroy   									  () *
	 *															 *
	 *       destroy is a method you can give a new initial-     *
	 *       ization or a new function implementation to.        *
	 *       this (by default) will destroy all the programs     *
	 *       objects, emptying the virtual table. destroy is     *
     *       a substitute for delete, if you are strategic       *
	 *       enough with implementing your program, destroy      *
	 *       can deallocate all your objects instead of using    *
     *       delete.                                             *
	 *                                                           *
     *       1) call the virtual table's destructor.             *
	 *                                                           *
	 *       2) call the virtual table's initializer and         *
	 *          allocate an array for it of a size determined    *
	 *          by the macro default_prime.                      *
	 *                                                           *
	 *       note: default_prime is a variable that can be       *
	 *             re-initalized before calling destroy.         *
	 *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                                destroy() ;
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/*															 *
	 *   2a.8) this                                          n/a *
     *                                                           *
	 *		 this is not only an automatic pointer but is the    *
	 *       action or mechanism of a pop function being         *
	 *       called. this as a pointer represents a stack        *
	 *       of objects. try to imagine what error you would     *
	 *       get if this was not a stack but only a single       *
	 *       pointer when you pass new into the constructor      *
	 *       of another new a non-descript amount of times.      *
	 *       that may help you imagine how great it is to        *
	 *       overcome this error that is resolved using a        *
	 *       stack. we will see other keywords that represent    *
	 *       other stacks later on in the implementation of      *
	 *       Factory C and discover how colorful variations      *
	 *       of a keyword like this is. take note of how         *
	 *       this is initialized in the constructor/allocator,   *
	 *       the function call under new() and passed into       *
	 *       the constructor/initializer, the parenthesis        *
	 *       after new(). because each object that gets          *
	 *       popped off the stack is aligned with its            *
	 *       responsible or respective constructor function.     *
	 *       this represents the vstack object (class vStack)    *
     *       and the global function vTable(This).               *
	 *                                                           *
	 *       1) check every case where zero 0 (null) would       *
	 *          other-wise be returned and throw an Exception    *
	 *          for each.                                        *
	 *                                                           *
     *       2) pop the top object and return it.                *
	 *       												     */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
      new(class)(this, new(class)(this, new(class)(this, ...))) ;
    #endif // 0
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     *[0]array                                                   *
     *       THIS IS FOR THE VIRTUAL TABLE OBJECT: (BASIC)       *
     *                                                           *
     *                   [  STRUCTURE(S)  ]          (.h)        *
     *                                                           *
     *     -the class member macro Class(Member)Class##Member    *
     *     is the namespace tool for the Class required by       *
     *     class construction macros like new()()                *
     *                                                           *
     *     -automatic memory of base type named base             *
     *     (simple inheritance by cast) placed at first          *
     *     data field position.                                  *
     *                                                           *
     *     -data member list here inside Class (object).         *
     *                                                           *
     *     -function pointer list here (1) inside                *
     *     Class(VirtualTable) (interface).                      *
     *                                                           *
     *     -separate data members and functions into two         *
     *     structs, one for the object type and one for the      *
     *     interface type, keeping functions of strategic        *
     *     significance in the struct with data members (Class). *
     *                                                           *
     *     -the object type or Class may/may not be extended     *
     *     from the struct class for the object type but the     *
     *     interface type needs to be extended from the          *
     *     class(VirtualTable) or struct class(VirtualTable) as  *
     *     its given an automatic struct variable named base     *
	 *     at the first data field pos (preferably).             *
     *                                                           *
     *     -the interface type or Class(VirtualTable) needs      *
     *     to be extended from the struct class (VirtualTable).  *
     *                                                           *
     *                     [ PROTOTYPES ]            (.h)        *
     *                                                           *
     *     -constructor/destructor/type function prototypes.     *
     *                                                           *
     *     -make sure each function is within scope              *
     *     of each other function by prototyping.                *
     *                                                           *
     *     -function prototype list here (2).                    *
     *                                                           *
     *     -prototype list generally labeled as static.          *
     *                                                           *
     *     -the first parameter of every member function is      *
     *     reserved for a self pointer (also known as            *
     *     interface methods).                                   *
     *                                                           *
     *                      [ INTERFACE ]            (.h or .c)  *
     *                                                           *
     *     -declare an automatic struct variable of the          *
     *     interface type and initialize each of its data        *
     *     field positions to the address of each global         *
     *     function here (3).                                    *
     *                                                           *
     *     -the interface is labeled as static.                  *
     *                                                           *
     *                    [ IMPLEMENTAIONS ]         (.h or .c)  *
     *                                                           *
     *     -type implementation: {return "Class";}               *
     *                                                           *
     *     -implement function list here (4).                    *
     *                                                           *
     *     -implementations labeled as explicit if implemented   *
     *     inside a header file.                                 *
     *                                                           *
     ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/* references:												 *
	 *	Factory/DesignPatterns/Virtual/Shape.h					 *
	 *		- covers interface type between interface/class      *
	 *        type.                                              *
	 *		- uses an implemented structured datatype            *
	 *        (struct x2).                                       *
	 *		- documentation infile.		     					 *
	 *	Factory/DesignPatterns/Virtual/Rectangle.h				 *
	 *	Factory/DesignPatterns/Virtual/Circle.h					 *
	 *	Factory/DesignPatterns/Virtual/Square.h					 *
	 *		- covers class type(s) between interface/class       *
	 *        type(s).                                           *
	 *		- the class type is the derived type or subclass.    *
	 * notes:                                                    *
	 *                                                           */
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**															 *
	 * @brief  Evaluation:                                       *
     *                                                           *
     * 	 1)  VirtualTable                                        *
	 *															 *
	 *       the virtual table is one of three primary tables.   *
	 *       it was defined, declared and implemented with Java  *
	 *       and C++ in mind. it is the first real cornerstone   *
	 *       of the implementation of Factory C and Exceptions   *
	 *       are included at the same time as the vTable for the *
	 *       pointer this to throw an Exception Object for being *
	 *       OutOfMemory. we get the basic toolkit of keywords   *
	 *       otherwise provided originally by C++. we should     *
	 *       be able to easily separate it from the rest of the  *
	 *       Factory C implementation if just basic OOP needs    *
	 *       to be provided in a C program (OOC). the virtual    *
	 *       table provides good, loose coupling between the     *
	 *       object and it's interface. as a hash table, the     *
	 *       object's address becomes the key as the quickest    *
	 *       route to the object's assigned interface. as you    *
     *       can see, the virtual table basically provides       *
	 *       object-oriented programming by itself.	as the       *
     *       table thats used to provide OOP in C (OOC) for      *
     *       my personal choice of an implementation of OOC,     *
	 *       when there are many variations of OOC, this table   *
     *       is itself object-oriented. this being said, new     *
     *       virtual table object(s) can be loaded into what     *
     *       would become the primary virtual table, a virtual   *
     *       table of virtual tables (and of objects and their   *
	 *       class virtual tables). each of the three primary    *
     *       table is itself object-oriented.                    *
	 *                                                           *
	 *       you can observe below we have a vector class being  *
	 *       defined, declared and implemented by typename.      *
	 *       inside main we have an instance being instantiated  *
	 *       of our new vector object.	all that is incomplete   *
	 *       here are the function parameters for the            *
	 *       constructor and the insert method, but you can      *
	 *       just put an unsigned integer greater than 1 into    *
	 *       the constructor and that will be for the            *
	 *       constructor default case of allocate an array       *
	 *       (vector) of that size and you can pass another      *
	 *       unsigned integer > 0 and < size into the insert     *
	 *       method, for the index followed by a signed integer  *
	 *       for the value inserted. try using * -> at() with    *
	 *       virtual and pass it into cout like how cout is      *
	 *       used in the first example of main.                  *
	 *															 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
	# include  "OOC/Virtual/vTable.h" // ...
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/*                     Program Entry Point                   */
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	# define  classVector(Member)classVector ## Member
	# define  classIterator(Member)classIterator ## Member
	typename (Vector) (class, typename (Iterator) (class));

	typename (constructor)({});
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	int main(void)
	{
		Vector(class) * vector = new (Vector(class))(this, ...);

			virtual (Container)(vector) -> insert(this, ...);

		delete (vector);

		return 0;
	}
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	typename (destructor)({  }) ;
	/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**                                                       \ /
             ________        __      __              __      - * -
            /\___  __\      /\ \    /\ \            /\ \      / \
         __ \/__/\ \_/  ___ \ \ \___\ \ \    ___    \ \ \___
        /\ \/\ \\ \ \  / __`\\ \  __`\ \ \  / __`\   \ \  __`\
        \ \ \/ / \ \ \/\ \/\.\_ \ \/\ \ \ \/\  __/_  _\ \ \/\ \
         \ \__/   \ \_\ \___/\_\ \____/\ \_\ \_____\/\_\ \_\ \_\
          \/_/     \/_/\/__/\/_/\/___/  \/_/\/_____/\/_/\/_/\/_/

                                                             end */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/** virtual												     *
	 ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
    /*  clipboard:

    - - everything should be good to go (03/31/2022).

    - - MAKE SURE THE PROGRAM CONSTRUCTOR/DESTRUCTOR IS DEFINED
	    IN TIME FOR VTABLE.H TO BE INCLUDED. IT CAN BE UNDEFINED
		AND (RE) DEFINED AFTERWARDS SO AN APPROPRIATE PAIR OF
		MACROS+FUNCTIONS CAN BE PROVIDED FOR EACH LEVEL OF DEF.

    - -

	- -

     */
	//[ array ]1b
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**||                     C EXCEPTION                     || *
	 *															 *
     *             by Willy (11/06/2018)(01/17/2021)             *
     *                      (12/21/2021)(08/23/2022)             *
     *                      (09/04/2022)(12/11/2022)             *
     * ||                   (08/13/2023)(08/11/2024)          || */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**                                                          *
     * @brief  Exception/Assertion                               *
     *                                                           *
     *  note: as an aide, thrown exceptions and failed           *
     *        assertions can both make a ding or alert           *
     *        beep when they occur, for those who are            *
     *        oldschool, see ... (Assertion.h) also, the         *
     *        Exception(Flag) when true makes a ding, false      *
     *        does not make a ding. print in the catch block     *
     *        after throw so when either there is a ding +       *
     *        print.                                             *
     *                                                           *
     *  also: if there is an object you want to be there         *
     *        for you after a throw you can push it not          *
     *        onto the jump stack (jpush(jump)) but the          *
     *        object stack using vpush(obj) and then use         *
     *        vtop() and vpop() in the catch block. vpop()       *
     *        as you may know is used by this (for the           *
     *        constructor).                                      *
	 *  														 *
     *        throw(new(Exception))(this, "text");               *
     *                                                           *
     *  note: this exception gets extended into an assertion.    *
     *                                                           *
     *        nothrow(new(Assertion))(this, a > b);              *
	 *                                                           *
	 *  then: check the stack for them: cout(exception)cend;     *
     *                                                           */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*** * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	 *                                                           *
	 *   2.1)  try                                        {}(){} *
     *                                                           *
	 *       try pushes a jump buffer object onto the jump       *
	 *       stack and sets the flag for branching into the      *
	 *       try block in a way that when there is a throw       *
	 *       inside the try, (or more like inside a function     *
	 *       called inside the try{}) it branches back to the    *
	 *       top of the try to branch over its block and go      *
	 *       straight into the catch block.                      *
	 *                                                           *
     *       1) allocate both the jumpbuffer object and the      *
     *          bool object and push them both onto the jump     *
     *          stack.                                           *
     *                                                           *
     *       2) call set(), setting the pointer to the jump      *
     *          value (flag).                                    *
     *                                                           *
     *       3) if the jump value pointer is null or the jump    *
     *          value itself is 0 (false) then branch into the   *
     *          try block {}                                     *
     *                                                           *
	 *   2.2)  catch                                        (){} *
     *                                                           *
	 *       catch pops the jump buffer object off the stack     *
	 *       if it has not already (from a throw that pops).     *
	 *       the pointer gets initialized to the Exception       *
	 *       object that was thrown, you decide what to name     *
	 *       your object used inside its very own block. the     *
	 *       catch block is skipped if there was no throw        *
	 *       from inside the try.                                *
	 *                                                           *
     *       1)
     *                                                           *
     *       2)
     *                                                           *
     *       3)
     *                                                           *
     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    #if 0
                      try{}catch(Exception * e){}
    #endif // 1
    /*/ /// /// /// /// /// /// /// /// /// /// /// /// /// /// /*/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        WARNING;WARNING;      INCOMPLETE;       WARNING;WARNING;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**
 _______          \ /                       __    __
/\  ____\        - * -                     /\ \__/\_\
\ \ \___/   __  __/ \ ___     ___     ___ /\__  _\/_/_    ___     ___
 \ \  _\   /\_\/ _\  / ___\  / __`\  / __`\/_/\ \/ /\ \  / __`\  / __`\
  \ \ \/___\/_/ _\/_/\ \__/_/\  __/_/\ \/\ \ \ \ \/\ \ \/\ \/\ \/\ \/\ \
   \ \______\/\_\/\_\ \_____\ \_____\ \  __/  \ \__/\ \_\ \____/\ \_\ \_\
    \/______/\/_/\/_/\/_____/\/_____/\ \ \/    \/_/  \/_/\/___/  \/_/\/_/
                                      \ \_\
                                       \/_/\ /
                                          - * -
                                           / \                   */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///

	[ array ]2A
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     *[1]array                                                   *
     *       THIS IS FOR THE FACTORY TABLE CLASS: (ADVANCED)     *
     *                                                           *
     *                    [  STRUCTURE(S)  ]                     *
     *                                                           *
     *     -any of the other base interfaces or registration     *
     *     style interfaces of the class interface heap can be   *
     *     extended by structures implemented here               *
     *     (if not structclass.h) (can be but wont).             *
     *                                                           *
     *                      [ PROTOTYPES ]                       *
     *                                                           *
     *     -prototypes for other heap interface functions.       *
     *                                                           *
     *     -the factory methods are implemented using a typename *
     *     so therefore are implemented by prototyping, they may *
     *     have actual prototypes included here but no need to.  *
     *                                                           *
     *     -if a factory table class is in any way a continuation*
     *     of the virtual table object for having a constructor  *
     *     and destructor its where it has something dubbed as   *
     *     the allocator. the allocator is a hook like the type  *
     *     function but where new(Class) is encapsulated. this   *
     *     hook becomes a method for the class(FactoryTable).    *
     *                                                           *
     *                       [ INTERFACE ]                       *
     *                                                           *
     *     -static class interface heap interface                *
     *     registrations and info heaps here.                    *
     *                                                           *
     *     -static arrays for interfaces with their own          *
     *     factory methods (sub-factory methods). these are      *
     *     manually sorted arrays (info heaps) subject to a      *
     *     binary search.                                        *
     *                                                           *
     *     -sub-factory method typename prototype(s) here.       *
     *                                                           *
     *     -static array for class interface heap.               *
     *                                                           *
     *     -class factory method typename prototype here.        *
     *                                                           *
     *                     [ IMPLEMENTAIONS ]                    *
     *                                                           *
     *     -allocator implementation: {return new(Class);}       *
     *                                                           *
     *     -class setup and class abort functions typenames.     *
     *                                                           *
     ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /* - CLASS TABLE - CLASS TABLE - CLASS TABLE - CLASS TABLE - */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**||      C FACTORY TABLE (FACTORY METHOD SOLUTION)      || *
	 *															 *
     *               by Willy (12/21/2021)(12/25/2021)           *
     *                        (12/27/2021)(02/12/2022)           *
     *                        (08/15/2022)(08/16/2022)           *
     * ||                     (09/11/2022)                    || */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /* - CLASS TABLE - CLASS TABLE - CLASS TABLE - CLASS TABLE - */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     * @brief  Reason(s) to use:                                 *
     *                                                           *
     *   1)  delegate with the virtual table in a way that       *
     *       creating instances of objects with it becomes       *
     *       fully dynamic using a string parameter not class    *
     *       name.                                               *
     *                                                           *
     *   2)  delegate for the constructor.                       *
     *                                                           *
     *   3)  assign a composite map/multimap to each class, as   *
     *       the class name that gets registered at the factory  *
     *       table uses a runtime string for dynamic access to   *
     *       the class factory method.                           *
     *                                                           *
     *   4)  the class factory method uses a runtime string for  *
     *       dynamic access to an interface (registration) of    *
     *       the class interface heap.                           *
     *                                                           *
     *   5)  an interface (registration) of the class interface  *
     *       heap may be an interface with its own sub-factory   *
     *       method that uses a runtime string for dynamic       *
     *       access to info from one of the class info heaps     *
     *       (composite).                                        *
     *                                                           *
     ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/

    /*             3a.15    - interface registrations:   		 *
	 * 1 - class(VirtualTable)       static *
	 * 2 - class(FactoryTable)       static *
	 * 3 - class(AdapterTable)       static *
	 * 4 - class(CompareTable)       static *
	 * 5 - class(ConsoleTable)       static *
	 * 6 - class(StandardTable)      static *
	 * 7 - class(FileTable)          static *
	 * 8 - class(StrategyHeap)       static *
	 * 9 - class(PolymorphHeap)      static *
	 * 10- class(VirtualHeap)        static *
	 * 11- class(ComplexHeap)        static *
	 * 12- class(ControlHeap)        static *
	 * 13- class(BuilderHeap)        static *
	 * 14- class(SecurityHeap)       static *
	 * 15- class(SingletonTable)     static *
	 * 16- class(SubjectStack)       static *
	 * 17- class(BasicsHeap)         static *
	 * 18- class(LibraryHeap)        static *
	 * 19- class(OverloadHeap)       static *
	 * 20- class(TemplateHeap)	     static *
	 * 21- class(AdapterHeap)        static *
	 * 22- class(ControlTable)       static *
	 * 23- class(ComplexMethod)         static *
	 * 24- class(TemplateMethod)     static *


    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	/**															 *
	 * @brief  Evaluation                                        *
     *                                                           *
     * 	 1.X)  FactoryTable                                      *
	 *															 *
	 *       the factory table is one of four primary tables.    *
     *       it was defined, declared and implemented not only   *
     *       with Java and C++ in mind, but with extending the   *
     *       definition of object-oriented programming (OOP)     *
     *       into more definition(s) of more best practice(s).   *
     *       not only do classes get registered, (and dropped)   *
	 *       but classes become dynamic-at-runtime as they are   *
	 *       polymorphic with normal compile-time classes. the   *
	 *       object class is a fully object-oriented class made  *
	 *       of runtime objects for everything down to its class *
	 *       extended interface and class typeid string. when    *
	 *       we use all object-oriented datamembers for our      *
	 *       classes, our objects become arrays of pointers      *
     *       and when we "class" our datamembers by pairing      *
     *       a method/member identifier string with a datatype   *
     *       string, we can share across all our classes data    *
     *       that is inherited by data member classing. this     *
     *       means that all our problems for inheritance are     *
     *       solved. with the factory table and it's object      *
     *       classes programs can now be so dynamic as to...     *
	 *                                                           *
	 *
	 *
	 *															 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /* - BONUS TABLE - BONUS TABLE - BONUS TABLE - BONUS TABLE - */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**|| C ADAPTER TABLE (TABLE OF SELF POINTER DATA MEMBERS)|| *
     *                                                           *
     *              by Willy (01/10/2022)(02/09/2022)            *
     *                       (09/13/2022)(11/06/2022)            *
     * ||                    (03/31/2023)                     || */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /* - BONUS TABLE - BONUS TABLE - BONUS TABLE - BONUS TABLE - */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
     * @brief  Reason(s) to use:                                 *
     *                                                           *
     *   1)  assign an alternate adapter interface and adapter   *
     *       constructor to a virtual table object that is used  *
     *       as an object adapter to another virtual table       *
	 *       object.                                             *
     *                                                           *
     *   2)  store the class self pointer to the adapter.        *
     *                                                           *
     ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
        COMMAND; CENTER;    COMMAND; CENTER;    COMMAND; CENTER;
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///






    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
    /**
 _______                  __                               _______
/\  ____\                /\ \__                           /\  ____\
\ \ \___/  ___      ___ /\__  _\    ___   ____   __  __   \ \ \___/
 \ \  _\  / __`\   / ___\/_/\ \/   / __`\/\  _`\/\ \/\ \   \ \ \
  \ \ \/ /\ \/\.\_/\ \__/_ \ \ \/\/\ \/\ \ \ \_/\ \ \_\ \   \ \ \____
   \ \_\ \ \___/\_\ \_____\ \ \__/\ \____/\ \_\  \ \____ \   \ \______\
    \/_/  \/__/\/_/\/_____/  \/_/  \/___/  \/_/   \/___/\ \   \/______/
                                                    /\ \_\ \
                                                    \ \____/
                                                     \/___/
                                                                 */
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
		https://www.linkedin.com/in/christopher-posten-20a025265
		https://factoryc.org
    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///






    /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
	#if 0
	[ 0XA1 ]intro;
	#endif // CHAPTER




dynamic-at-      *
	 *       compile-time macros can restrict how dynamic
	 *       the program is at key points therefore providing structure that       *
	 *       reinforces your common operations/procedures.       *
	 *       we will get into this more when we introduce        *
	 *       the factory table multimap.



	 * the configuration of having a virtual table   *
	 * object that is assigned its interface there making the    *
	 * objects address the quickest processor route to its
	 * interface no matter

		 *			   i.3     - virtual object						 *
	 *             		   i.3.1 - constructor/initializer       *
	 *                     i.3.2 - destructor                    *
	 *                     i.3.3 - class type                    *
	 *			   i.4     - factory/complex object				 *
	 *                     i.4.1 - constructor/allocator         *
	 *                     i.4.3 - sub factory method(s)         *
	 *                     i.4.2 - class factory method          *
	 *                     i.4.4 - class setup                   *
     *                     i.4.5 - class abort 	                 *
	 *			   i.5     - object adapter                      *
	 *			   i.6     - control factory					 *


	 	 *			   1.13	   - vto
	 *             1.14    - instantiation
	 *             1.15    - method
	 *             1.16    - interface
	 *             1.17    - virtual table
	 *             1.18    - constructor/initializer
	 *             1.19    - destructor
	 *             1.20    - type id



	 *			   1.9     - namespace:                          *
	 *                      1 - class(Member)             define *

	 * #4b		   struct bunker object         (struct(Bunker)) *
	 *             4b.1    - struct(bunker)(control)          () *

	 	/*
	 *

	 *  p.1	 -  inspiration                                      *
	 *      1.1 - program to the interface                       *
	 *
	 * 		to program to the interface, not the implementation; *
	 * you program to the interface type, the typedef struct     *
	 * Class(VirtualTable) not the function implementation(s).   *
	 * by that just look at the interface, that should tell you  *
	 * everything.


/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
/* [ctrl] - z for undo, [ctrl] - x for cut, [ctrl] - c for copy      */
/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
/**
            __             _____  __
           /\ \           /  ___\/\_\
           \_\ \     ___ /\ \___/\/_/_    ___     ___
           / __`\   / __`\ \  _\   /\ \  / __`\  / __`\
          /\ \/\.\_/\  __/_ \ \/   \ \ \/\ \/\ \/\  __/_
          \ \___/\_\ \_____\ \_\    \ \_\ \_\ \_\ \_____\
           \/__/\/_/\/_____/\/_/     \/_/\/_/\/_/\/_____/

 */
/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
/* [ctrl] - v for paste, [ctrl] - y for redo, [ctrl] - r for search  */
/// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///


	/*
    +-------------------------------------------------------------+
    |                                                             |
    |      the three levels of object oriented programming:       |
    |                                                             |
    +-------------------------------------------------------------+
    |                                                             |
    |          *****     VIRTUAL OBJECT (LOW)     *****       # 1 |
    |                                                             |
    +-------------------------------------------------------------+
    |                                                             |
    |    		- virtual table object (VTO)                      |
    |    		- implemented struct class                        |
    |    		- single class extended interface                 |
    |       		* simple inheritance possible (easy)          |
    |    		- destructor method                               |
    |    		- constructor/initializer method                  |
    |    		- type hook method (for typeid)                   |
    |                	                                          |
    +-------------------------------------------------------------+
    |                                                             |
    |          *****     FACTORY OBJECT (MID)     *****       # 2 |
    |                                                             |
    +-------------------------------------------------------------+
    |                                                             |
    |           - not only a virtual table object but an          |
    |               object of a factory table class (FTC)         |
    |           - everything from virtual object                  |
    |           - constructor/allocator hook method:              |
	|				   {return new(Class);}                       |
    |           - singleton factory method(s)                     |
    |               * class interface heap                        |
    |                 = vto interface utility                     |
    |                 = multiple inheritance solution             |
    |                 = partial inheritance/bridge pattern        |
    |               * class info sub heaps                        |
    |                 = overloads/interface overload #1           |
    |                 = fully dynamic programming                 |
    |                                                             |
    |           - typeid() used for strategy/overloads            |
    |               in conjunction with multimap()()()()          |
    |                                                             |
    +-------------------------------------------------------------+
    |                                                             |
    |          *****     COMPLEX OBJECT (HIGH)     *****      # 3 |
    |                                                             |
    +-------------------------------------------------------------+
    |                                                             |
    |           - factory object that uses runtime objects        |
    |               for its interface, info heaps, typeid, ...    |
    |           - everything from factory object                  |
    |           - implemented in function(s) builder class        |
	|             "complex"                                       |
    |                                                             |
    |           - more dynamic in more ways, overloads            |
    |               being dynamic, now dynamic for amount         |
    |               of functions being overloaded per             |
    |               overload (dynamic-at-runtime)                 |
    |               (more fully dynamic programming)              |
    |                                                             |
    |           - complex methods get implemented. those          |
    |               are methods that use multimap and look        |
    |               for the complex heap so the amount of         |
    |               datamembers declared inside the complex       |
    |               heap determine things like how many           |
    |               parameters the constructor takes (and         |
    |               in alphabetical alphabetical order).          |
    |               these can be known as "complex methods".      |
    |                                                             |
    |           - interface methods like complex methods          |
    |               can take it into their own responsibility     |
    |               that since a function is called on a          |
    |               class object it can be up to the function     |
    |               (probably added as an interface method(s))    |
    |               to add datamembers to the complex heap or     |
    |               add interface methods to the virtual heap     |
    |               or as a set of strategic methods through      |
    |               a strategy/overload heap or anything. so      |
    |               after the datamembers are added, they can     |
    |               be used to execute to function then. these    |
    |               can be known as "builder methods".            |
    |                                                             |
    +-------------------------------------------------------------+
    |                                                             |
    |          *****            STRUCTURE          *****      # X |
    |                                                             |
    +-------------------------------------------------------------+
	|			-
    +-------------------------------------------------------------+
	*/


	 *      - used by everything from here on out...             *
	 *      * class-oriented programming implementation for      *
	 *        dynamic classes polymorphic with non-dynamic       *
	 *        classes depend on interface-oriented programming,  *
	 *        that itself uses a secondary virtual table         *
	 *        for class-oriented runtime object interface        *
	 *        registrations (int regs) with virtual table        *
	 *        object (vto) datamember(s) . . .                   *
