
  //C:\Program Files\CodeBlocks\MinGW\x86_64-w64-mingw32\include

Factory C Bundle:
note: this folder (Factory) is a Code Blocks project folder (using Windows).
(this includes the folders: bin and obj)
(this includes the files: Factory.depend and Factory.layout)


(also includes: main.c
	(the one thing I would keep from above if using Linux, etc.))
(also includes WorkSpace.h    	- Functions for testing and displaying examples
					(to go with the console program inside main.c))
(also includes TrashBin.h       - Implementations I threw out but not erase completely)


Subfolders: 		OOC 		- Library Folder for Factory C (includes Manual)
            		DesignPatterns 	- Folder for OO Patterns (examples) (includes Readme)
					TODO: INCLUDE EXCERCISES IN DESIGN PATTERNS FOLDER NOT README
v.1.5.1

gpl v.3 or later


      this includes everything OOC offers. this includes a basic set
	  of datastructures needed to implement the factory, a vector, a
	  stack as a single-linked-list, a hashtable, and a heap as a
	  binary-search-tree are all included and ready to be typenamed
	  for whatever type you choose to use them for.

	  the factory itself is comprised of multiple singletons working
	  in conjunction with one another to operate an object-oriented
	  C program. you must also include the program constructor and
	  program destructor for Factory C inside your main.c
	  so:

	  don't forget to try out the class builder
	  for a class thats dynamic at runtime, inside Factory/DesignPatterns/...
	  (adjacent to Factory/OOC) are examples of things like adapters and
	  inside Factory/Workspace/Workspace.h is examples of everything
	  including the class builder example. also don't forget that Factory is
	  a CodeBlocks project folder you can open using CodeBlocks 5.1.0 or
	  something (OOC is a subfolder of Factory). for 64 bit pointers,
	  only the files vTable.h and aTable.h need to be updated, with each
	  occurence of 32 replaced by 64 in those two files. The macros
      that implement the hash tables assign a hash function at compile-time
      so just changing the first two files helps assign a 32 bit or 64 bit
      hash function.


    /* note: the 3 primary tables

     */
    cout(vtable)(ftable)(atable)cend;

    /* also: there is 2 secondary tables (stable, and btable)
             found inside the factory table and so accessed by:

             multimap()()()()
     */

	Updates:


					- - 		version 1.2.1			- -


			- includes all the template types used to implement Factory C
			inside the FactoryTable.


					- - 		version 1.3.1			- -


            - reimplemented is_polymorphic.

            - added thrown exceptions for null pointer in the factory methods.

            - added the macro: class(multimap).

            - made the adapter table able to downsize itself like the
              vtable and in a way parallel to the vtable like it is
              (by vstack).

            - finally made it so printf doesn't need to be used,
              when all the parameters passed into cout are passed
			  straight through to printf (including sprintf, fprintf).

            - re-implemented override.

            - fixed standard output for cout.


					- - 		version 1.4.1			- -


            - reimplemented is_polymorphic. this time using an iterator.

			- implemented an iterator to go with multimap for
			polymorphism between implemented structclass and builder
			class.

			- fixed the copy constructor for the class builder multimap.

			- hooked things up to the factory table directly so everything
			should be changeable by reassigning heaps, factory methods, etc...
			(class(Builder), struct(Bunker), multimap).


					- - 		version 1.4.2			- -


			- udapted/fixed the union multi method to use adapter factory
            table classes default interface from the class interface heap
			(so it works without using a class(AdapterTable)).

			- fixed the return in the output function(s)  in Exception.h so
			it/they return 0.


					- - 		version 1.4.3			- -


			- fixed the control factory for loop to deaccumulate its
			strategic command instead, solving the problem with multiples
			of the same digit.


					- - 		version 1.5.1			- -


			- reimplemented the interface heap copy to be polymorphic like
			the iterator from 1.4.1 (using the).

			- got rid of the duplicate tables as in tables with duplicate key
			sets because that is harder to manage.

			- implemented factory function as constructor for everything
			except OO Arrays (from typename) and Iterators. this way everything
			can be copied from one polymorphic complex object to another with
			a copy constructor.

			- overhaul of the builder.h file, separated all into more than 10
			files inside of OOC/Builder as the new folder for good stable
			definitions of the class builder. this is where i finalize my
			definitions and prepare for a proper presentation of some sort.
				-query or programming language type compiler/interpreter needed still.


					- - 		version 2.1.1			- -

	
			- re-implemented the ControlFactory. with this also re-impl. multimap
			union, override and got rid of the flag stack in favor of having an implicitly 
			stringized parameter (that was true or false by default) for accessing a 
			control factory array, so now it can be any keyword that, multimap can use
			for its control parameter that determines what array of functions it uses.
	
			- made registered factory table classes out of the class(Heap)s with 
			each using a couple sub(Table)s, instead of being in a class(StrategyHeap).
			- made registered factory table classes out of table name prefix types. 
			- made registered factory table classes out of control factory arrays.
				*all of these came with several new class(Table)s
			
			- re-implemented control to use a stack, instead of being a case/flag
			correcting a design flaw in the cFactory.h and FactoryObject.h 
			
			- implemented a singleton object overload for an allocator and deallocator
			that, just as long as a singleton's variable name is added to a class(AdapterHeap)
			in the singleton class, either by re-implementing, or implementing a new 
			heap (global static array) and placing an override on its respective table in 
			its respective class in the factory table.
			
			- there is more that will be done for __COMPLEX_C__ or complex level factory c
			whether or not the bTable is compiled for v 2.1.1 for complex level objects with
			object classes, v 2.1.1 will at least have a fully debugged and fully implemented
			__FACTORY_C__ or factory level factory c with things like decoupled methods.
			
			
			
CHEERS
