Tree Container Library: Credits

The Tree Container Library

A C++ generic tree container library which, not only works much like the STL, but is also compatible with the STL algorithms. The Tree Container Library is used worldwide in thousands of industries and organizations. It is completely free to use, and is licensed under the zlib/libpng license.

Many developers have contributed to the success of the Tree Container Library in many ways. This page is to give that credit to those where it's due. The list below, ordered alphabetically by last name, includes some of those who have contributed in different ways to make the TCL bug free, useful, flexible, and successful.

  • Gabor Bernat
    Gabor discovered a problem when compiling the TCL under Visual Studio 2005 with Service Pack 1 installed. Gabor wasn't convinced that the problem was within the TCL, and upon further investigation, found the problem to be with the Service Pack 1 update for this version of visual studio. Gabor found that there is a fix for the SP1 issue, which he tested and verified that it resolved the issue. Gabor provided a Microsoft support link which TCL users can use to find out more about this issue.
  • Volker Bijewitz
    Volker was the one of the first developers to attempt to compile the TCL with Visual Studio 2005. Volker advised me of the problems when compiling the TCL with this compiler. Fixing the VC 2005 TCL problems led to the discovery of a large deficiency in the library iterator design. Fixing the iterator design problem rendered the TCL to be compliant with VC 2005.
  • Thomas Cook
    Thomas discovered some incompatibilies in the TCL with of of the later version of GCC (4.8). In particular, Thomas noticed that GCC now requires the qualification of std::ptrdiff_t, and also that the use of deallocate_tree_type also needed to be properly qualified. Thomas pointed out the needed changes to resolve these issues.
  • Glen Davidson
    Glen is the the first developer I know of to use and test the TCL on a 64 bit machine. Glen found an issue with the library when run on a 64 bit machine that didn't occur on 32 bit machines. Looking into the issue closer, Glen discovered that the problem was most likely within the TCL, and for some reason, the problem was not being detected on 32 bit machines. Glen revealed that in two locations in the TCL, memory was being de-allocated with the delete operation, when that should have been performed with the allocator members of basic_tree.
  • Neville Franks
    Neville Franks, author of ED and Surfulator has been a source of my inspiration more than once. Neville's own work on his commercial applications and documentation makes his suggestions for the TCL and it's documentation a welcome benefit.
  • Bear Huang
    Bear discovered multiple issues with the TCL test suite.
    By building and testing with multiple compilers, Bear discovered issues with release builds, and also corrected a qualified dependant template declaration issue which caused a build error with standard compliant compilers.
  • Shahid Hussain
    Shahid has offered valuable insight into TCL compiler compatibility by testing the TCL in multiple versions of gcc in a Linux environment. Shahid has found some compatibility issues, and is working to find the root of these issues. This work is essential in general, to determine if certain compiler version have particular issues, or if any issues remain in the TCL.
  • Quynh Nguyen Huu
    Quynh was one of the first developers to put the TCL to use in his project. Working with an early version of the TCL, Quynh discovered a few problems with the TCL, and not only advised me of the problems, but also provided the fix for them. Quynh has also given many suggestions for improving the TCL. He was the first to suggest a need for a type of tree container which does not naturally order the children (sequential_tree), and also suggested allowing a custom allocator.
  • Bj�rn Toft Madsen
    Bjorn has taken interest in the TCL, and had a crucial need for using the library with a custom allocator. Bjorn presented a complete solution to add a custom allocator as an extra template parameter for the tree container. The solution was the best, and most logical of all other solutions I had tried for the use of custom allocators. I would have liked to use Bjorns solution in the TCL, but unfortunately, the solution would not work for VC6, due to the problems that VC6 has with advanced standard compliant template usage. With Bjorns help, an alternate solution was found, which involves minimal changes to the base class of the TCL to allow it to be used with custom allocators.
  • Paschal Mushubi
    Paschal was one of the first developers to attempt to compile the TCL with Visual Studio 2005. Paschal informed me of the problems compiling the code with VC2005, and suggested I offer example code on my site, to give other developers a chance to see how the tree containers can be used.
  • Jean-Francois Ostiguy
    Late in the development in the TCL, I was feeling complacent that no bugs remained in the library. I learned that issues can be found even in mature libraries and code. In the TCL's later stages of development, Jean-Francios was sharp in discovering a serious issue with the const descendant iterators, and also discovered a problem with the assignment operators, which were not clearing the previous child nodes in the lhs objects. Jean-Francios not only discovered these issues, but provided insight into the problem, and good examples to show just where the problem was, facilitating the solution for the bugs. Jean-Francios has also been very helpful in suggesting needed operations and design changes for the sequential_tree and it's iterators, and testing the TCL in a unix environment.
  • Mike Pace, Brock Peabody
    Although Mike and Brock did not contribute directly to the TCL, they are responsible for introducing me to the STL and generic programming. Working with Mike and Brock also improved my knowledge and skills in this area, which gave me the needed skills to develop this library.
  • Roland Pibinger
    Roland was one of the first to offer feedback and suggestions for one of the earliest versions of the TCL. Roland took the time to compile the code in GCC, needing to make many corrections, as it was not yet GCC compatible at that time. Roland pointed out the problems the TCL had with 'two-phase name lookup', and where I could find more info to resolve these problems. Roland also offered suggestions on the interface of the TCL.
  • John Potter
    John was one of the first to offer feedback and suggestions for one of the earliest versions of the TCL. Taking the time to make the needed corrections to the TCL for it to successfully compile in the GCC, John impressed upon me that the library needs to be compatible with this compiler, as well as other standard compliant compilers. John gave examples for what needed to be done to the TCL to make it compliant and compile under GCC. He also suggested that I be wary of adding to much unneeded functionality to the library, which would cause it to be unnecessarily bloated.
  • Mark Sandler
    Mark was the first developer to suggest adding serialization functionality to the TCL. Not only did Mark offer the suggestion, but also submitted functions for the serialization for the tree container. His code submission is well written, and I decided to include it as an auxiliary function to the library. A new auxiliary code page has been created, where developers can choose from well written auxiliary functionality submitted by Mark and other developers to work with the TCL.
  • Beth Scaer
    During her use of the unique_tree container, Beth discovered a limitation in it's use, which is the fact that changing a node's key does not cause the primary or secondary order to be updated. Although the limitation is a natural limitation of associative containers, Beth needed a way to re-order the secondary order of unique_tree node's after the secondary key has been updated. Although modification of any key info in associative containers is considered to cause undefined behavior, Beth has submitted functions to refresh the secondary order of unique_tree nodes after the secondary keys have changed. Her submissions can be viewed in auxiliary code.
  • Andreas Schniertshauer
    Andreas found and resolved an issue in Visual Studio 2005 involving std::numeric_limits::max(). When using the TCL with the windows API, a max() macro is defined which conflicts with the std numeric_limits max() operation. This conflict created warning messages in basic_tree.h when using the library with the windows api (windows.h). Andreas informed me that the conflict could be resolved by forcing the call operation on the fully qualified std::max operation, as so (std::numeric_limits<int>::max)(). Since the technique is ansi C++ compatible, the fix works well with all VC compilers as well as GCC. Andreas also noted some inconsistancies in the typedefs and the way the typedefs were used in multiple tcl classes, which were correct in versions 5.0.0 and later.
    In May of 2008, Andreas also discovered an issue with the TCL test suite, when running on Visual C++ 2008, where the new VC9 compiler was bounds checking iterators more strictly.
  • Adrian Secord
    Adrian Secord was very convincing to point out that although the TCL was now stable, it needed to be wrapped appropriately in it's own namespace. This was very good and sound advice, although it would add a little extra work for current users when updating versions. Adrian suggested the namespace tcl which I used, and also sent in the namespace changes to be made. Later in 2007, Adrian informed me that the standard behavior of descendant iterators was to include the top (or called) node in the traversal. Upon further investigation, I discovered Adrian was correct in this matter. Although the behavior of the descendant iterators would change by correcting this issue, the correction was made, and is present in all versions 5.0.0 and greater, which was also suggested by Adrian. Also included in this newer version were some const correctness fixes for the iterators, also noted by Adrian.
  • Guglielmo Scotilanza
    Having a keen sense of interpretation and familiarity with the open source license verbiage, Guglielmo informed me about the problems associated with using the LGPL license for the TCL. After some research on this issue, I found Guglielmo to be correct, and changed the license agreement to one which is much simpler and less restricting.
  • Santhosh Shetty
    Santhosh has been a close friend of mine before I started working on the TCL. On a number of occasions, Santhosh has spent time brainstorming with me on particular issues and design considerations. Being well versed in Linux, Santhosh helped me get up to speed with GCC. He also persuaded me to find a way to design the TCL so that the sequential_tree could also inherit from the base class.
  • Martin Wirth
    Martin offered many good suggestions regarding the sequential_tree library. Due to the nature of the library, and the problems associated with template compatibility with specific compilers, I was not able to implement all of Martins suggestions. I was able to add subscript operations to sequential_tree, however, which could prove handy in it's use.
  • John Yao
    John Yao found an issue in the tcl which was occuring in GCC on linux environments, which involved self referencing friend declarations in the iterator classes. John worked with me to find the root of and resolve the issue. The fix is very important to linux users who have not been able to compile the TCL since version 5.0.8, which afterwards, the friend declarations were introduced.
  • Staff from Code Project, CodeGuru, and Programmer's Heaven
    No matter how well written a library may be, it can't succeed unless it gets presented to the developer community. It's only then when other developers can contribute to the fixes and enhancements to the library. The staff at these popular sites have been very helpful, patient, and hard working, in presenting and revising my library articles, and are largely responsible to the success of the TCL.