The C++ framework for developing highly scalable, high performance servers on Windows platforms.

Release Notes - Win32 Tools Library

You might also be interested in the release notes for the libraries that this one is built on:

  • Admin
  • C++ Tools (this was a separate library prior to version 6.0 at which point it was merged with the Win32 Tools Library
  • Core Tools

Version 7.4
  • Remove support for Visual Studio 2015.
  • Remove deprecated functionality.

Version 7.3
Version 7.2
  • Removal of manual "#define include guards" now that all supported compilers support pragma once.
  • Removal of out of date lint directives.
  • Added support for Visual Studio 2022 Preview.

Version 7.1
Version 7.0
  • Major changes due to preparations for multi-platform support. Addition of CoreTools library which contains all cross platform code that was previously in Win32Tools.

Version 6.9.5
  • Added support for Visual Studio 2019 (16.5 - 16.9).
  • Updated project files to make release build optimisations consistent.
  • Rationalised precompiled header usage.
  • Removed unrequired includes.
  • Began to move towards removing JetByteTools\Win32Tools\Utils.h by splitting it into more functionally cohesive headers.
  • Added GetLastErrorMessage.h and moved the functions out of Utils.h.
  • Added GUID.h and moved the functions GUIDAsString() and CreateGUIDAsString() out of Utils.h.
  • Added JetByteTools::Win32::IConfiguration::HasConfiguration() which returns true if a given sub configuration exists.
  • Added JetByteTools::Win32::IConfiguration::GetOptionalConfigurationOrNullConfiguration() which will return an instance of JetByteTools::Win32::CNullConfiguration if the optional configuration does not exist. This allows use of the 'null object pattern' during configuration processing.
  • Added JetByteTools::Win32::IConfiguration::Visit which takes an instance of an object that implements JetByteTools::Win32::IVisitConfigurationElements which is called for each element in the configuration.
  • Added JetByteTools::Win32::TDebugLog and JetByteTools::Win32::DebugLogBase which will form the basis of a new debug trace system that allows trace messages from the framework, and from client code, to be configured at runtime.
  • Added JetByteTools::Win32::ILogMessagesWithFixedFileHeader which allows for logs that can have some log lines designated as header lines which will appear at the top of all log files.
  • Added two new log methods to JetByteTools::Win32::ILogMessages that allow you to log vectors or deques of log lines with one call.
  • Bug fix to JetByteTools::Win32::CRecursiveDirectorySearch in how we deal with access denied errors accessing directories.
  • Added JetByteTools::Win32::DumpDataAsHex() which does the 'hex dump' part of DumpData but not the 'display printable' part.
  • Breaking change to JetByteTools::Win32::CSEHException which now derives from JetByteTools::Win32::CException. This means that if you want to catch JetByteTools::Win32::CSEHException explicitly, which you usually don't, then you need to do so before catching JetByteTools::Win32::CException. Note that, in general, prefer to remove all reference to JetByteTools::Win32::CSEHException and rely on catching and processing as JetByteTools::Win32::CException as this will ease migration to cross platform code.
  • Breaking change to JetByteTools::Win32::CException. JetByteTools::Win32::CException::GetMessage() is now JetByteTools::Win32::CException::GetWhat(). This removes the mess that is caused by windows headers having a define for "GetMessage". In general, switch you using GetDetails() rather than GetWhere() and GetWhat().
  • Added JetByteTools::Win32::IWaitable::WaitForMultipleHandles().
  • Added JetByteTools::Win32::CMD5 an MD5 implementation that doesn't rely on Windows API calls. If JETBYTE_TOOLS_USE_WINDOWS_NATIVE_MD5 is defined then this implementation forwards to the code in Win32::GetMD5Digest() if not defined then an implementation from is used.
  • Added JetByteTools::Win32::SHA1 a SHA1 implementation that doesn't rely on Windows API calls. If JETBYTE_TOOLS_USE_WINDOWS_NATIVE_SHA1 is defined then this implementation forwards to the code in Win32::GetSHA1Hash() if not defined then an implementation from is used.
  • Added JetByteTools::Win32::CStringConverter::AtoT(), etc. overrides where the input and output are provided as pointers and lengths and where the output is a pointer and length and the input is a pointer which has strlen called on it.
  • Added static methods to JetByteTools::Win32::CSystemTime. JetByteTools::Win32::CSystemTime::GetSystemTime() and JetByteTools::Win32::CSystemTime::GetLocalTime().
  • Added static method to JetByteTools::Win32::CTickCount64Provider. JetByteTools::Win32::CTickCount64Provider::TickCount64().
  • Added static method to JetByteTools::Win32::CTickCountProvider. JetByteTools::Win32::CTickCount64Provider::TickCount().
  • Bug fix to JetByteTools::Win32::TZeroInitialiseExpandableBuffer<>::Resize() so that we zero fill the whole of the new buffer.

Version 6.9.4
  • Added support for Visual Studio 2019 (16.4).

Version 6.9.3
  • Fixed issued raised by Resharper++
  • Changed include path separators from \ to / so as to support compilation on Linux using CLANG
  • Fixed case of include file names to aid portability.
  • Migrating code towards 'modern C++' idioms.
  • Suppress warning C4355 "'this': used in base member initializer list" in Warnings.h and remove per file suppressions. We just use this idiom far too often for it to be a special case.
  • Added support for Visual Studio 2019 (16.3).
  • Dropped support for Visual Studio 2013.

Version 6.9.2
  • Added support for Visual Studio 2017 (15.6 - 15.9).
  • Added support for Visual Studio 2019 (16 - 16.2).
  • Added code to JetByteTools::Win32::CActivatableObject that reduces the need to call OnActivatableObjectMoreCommandsToProcess() for commands queued as 'queue dont process' if a thread is already processing the queued commands.
  • Bug fix to JetByteTools::Win32::TimeChangeNotificationMonitor and JetByteTools::Win32::CSystemShutdownMonitor so that we don't truncate the pointer passed to SetWindowLongPtr(). Truncation was rarely occurring to just the top bits.
  • Bug fix to JetByteTools::Win32::CSystemTime so that we correctly set times and dates that are in the past in the presence of daylight savings time differences between 'now' and the date/time being set.
Added code to JetByteTools::Win32::CThread to allow you to register an interface that is notified when threads are named. Removed const from some of the methods in JetByteTools::Win32::CIOCompletionPort, JetByteTools::Win32::CThreadPool and JetByteTools::Win32::CThreadPoolEx.
Version 6.9.1
  • Added support for Visual Studio 2017 15.5.
  • Added code to JetByteTools::Win32::CActivatableObject which allows for partial consumption of a block of queued commands. This allows more balanced processing and helps to prevent one object from hogging a thread.
  • Added support for objects using JetByteTools::Win32::CReferenceCountedSmartPointer to optionally provide a 'ReportOwnershipChange()' function, using SFINAE. If present this is called in various constructors and assignment operators to allow more detailed tracing of reference ownership in reference tracking traces.
  • Bug fix to JetByteTools::Win32::TimeChangeNotificationMonitor so that it doesn't leak windows timer handles. Note the leak was, at worst, one handle per object lifetime.
  • Bug fix to JetByteTools::Win32::TZeroInitialiseExpandableBuffer for when it's instantiated with non-POD types. We were potentially failing to call object destructors. The framework never uses this class with non-POD types but a unit test failure under a new leak testing tool indicated the problem.

Version 6.9
  • Fixed issued raised by CppDepend
  • Fixed issued raised by Resharper++
  • Added JetByteTools::Win32::IQueueTimers::TimerIsSet() which returns true if the supplied timer handle is currently set. Note that there's an inherent race condition between testing this and using the result of the test as the timer may have expired after the test was completed but before the call returns.
  • Added a new defaulted parameter to JetByteTools::Win32::IQueueTimers::SetTimer() and the templated reference managing versions. You can now ask to set the timer 'always' which was always the default behaviour or you can ask to set it only if it's not set. The later, new behaviour, will set the timer only if it is unset when the call to SetTimer() occurs. This prevents you from overriding a timer that is set with a new one.
  • Added JetByteTools::Win32::IQueueTimers::UpdateTimer() which can be used to update a timer based on comparing the current timeout with the supplied timeout; "update only if new value is sooner" or "update only if new value is later". Or it can be used to update always, which is the same as calling JetByteTools::Win32::IQueueTimers::SetTimer() or it can be used to just update the user data and the timer callback.
  • Added JetByteTools::Win32::COneWayToggle which is a JetByteTools::Win32::CAtomicBool that starts off as false and can be set to true by toggling it. It cannot then be set back to false.
  • Added JetByteTools::Win32::CRandomByteProvider which uses the crypto library to return random bytes.
  • Added JetByteTools::Win32::CTickCountCompare which contains static members to safely compare tick count values with each other whilst allowing for wrap.
  • Added JETBYTE_SMART_POINTER_DUMP_ON_NULL_REFERENCE which defaults to 0 and when set to 1 enables mini dump creation when a null smart pointer is dereferenced.
  • Added JETBYTE_REFERENCE_COUNTED_SMART_POINTER_DUMP_ON_NULL_REFERENCE which defaults to 0 and when set to 1 enables mini dump creation when a null reference counted smart pointer is dereferenced.
  • Bug fix to JetByteTools::Win32::TAddressOrderedMultiLock::Unlock() which was not setting the 'locked' flag correctly and so could lead to locks being unlocked multiple times.
  • Added JetByteTools::Win32::CCompareStrings which extracts the code previously used by JetByteTools::Test::CTestLog for string comparisons.
  • Added JetByteTools::Win32::CalculateStringCRC32C() and variants.
  • Bug fix to JetByteTools::Win32::CEventOwner to correctly handle the 'nothing' flag.
  • Added JetByteTools::Win32::IConfiguration::GetNamedConfigurationSection() and JetByteTools::Win32::IConfiguration::GetOptionalNamedConfigurationSection().
  • Breaking changes to JetByteTools::Win32::IMonitorThreadPool. Both JetByteTools::Win32::IMonitorThreadPool::OnThreadPoolProcessingStarted() and JetByteTools::Win32::IMonitorThreadPool::OnThreadPoolProcessingStopped() have a new parameter passed to them dataAvailable a bool which is used with the functionality that was added in 6.6.5 whereby JetByteTools::Win32::IIOCPWorkerThreadCallback::ProcessEx() can return true to cause JetByteTools::Win32::IIOCPWorkerThreadCallback::NoItemsToProcess() to be called when the queue is empty. The addition of this bool allows monitoring code to differentiate between calls that result in processing and calls that do not. This is especially important if you are monitoring the number of items in the queue by tracking them as they go in and when their processing begins. This change results in corresponding changes to the following classes: JetByteTools::Win32::CNullThreadPoolMonitor, JetByteTools::Win32::IManageThreadPoolThreads, JetByteTools::Win32::CThreadPool and JetByteTools::Win32::CThreadPoolEx.
  • Added JetByteTools::Win32::TMultipleRangeReusableIdManager which is a version of JetByteTools::Win32::TReusableIdManager which can be initialised with multiple disparate ranges of valid ids rather than a single contiguous range.
  • Deprecated JetByteTools::Win32::CRegistryConfiguration.
  • Changes to JetByteTools::Win32::TReusableIdManager to support the addition of JetByteTools::Win32::TMultipleRangeReusableIdManager and in addition to allow creation of a manager with both a min and max value for the single contiguous range rather than just a max.
  • Added JetByteTools::Win32::TTypeSafeTypedef::operator==() and JetByteTools::Win32::TTypeSafeTypedef::operator!=().
  • Deprecated JetByteTools::Win32::TTypeSafeTypedef::operator baseType(), an implicit cast to the base type. This caused some very strange code gen problems for a client, possibly due to inconsistent project file settings.
  • Removed JetByteTools::Win32::ICollectableThreadPool and JetByteTools::Win32::CThreadPoolCollection.
  • Removed JetByteTools::Win32::TLinkedClass.
  • Removed JetByteTools::Win32::TSingleton.
  • Added JetByteTools::Win32::IProvideRandomBytes and JetByteTools::Win32::CRandomByteProvider.
  • Added JetByteTools::Win32::HexDigitsSpacesBetween to JetByteTools::Win32::ToHexStringHexDigitRepresentation. This flag affects how the void * version of JetByteTools::Win32::ToHexString() formats data.
  • Added JetByteTools::Win32::IsAllHexDigits().

Version 6.8
  • Made pragma once unconditional in headers.
  • Fixed issued raised by PC-Lint Plus.
  • Fixed issued raised by CppDepend
  • Fixed issued raised by Resharper++
  • Use override rather than virtual for implementations of virtual functions in derived classes.
  • JetByteTools::Win32::CThreadPoolCollection has been deprecated and is no longer available unless you define JETBYTE_DEPRECATE_THREAD_POOL_COLLECTION to 0 in Config.h. This code was only ever used for one client and should have been client specific.
  • JetByteTools::Win32::TSingleton has been deprecated and is no longer available unless you define JETBYTE_DEPRECATE_SINGLETON to 0 in Config.h. As the comments with the class say, "Remember, Singletons are EVIL! and what's more they're generally unnecessary".
  • JetByteTools::Win32::TLinkedClass has been deprecated and is no longer available unless you define JETBYTE_DEPRECATE_LINKED_CLASS to 0 in Config.h.
  • Changed JetByteTools::Win32::CActivatableObject::Callback::OnActivatableObjectProcessCommands() and JetByteTools::Win32::CActivatableObject::Callback::OnActivatableObjectProcessCommand() to both return bool if you return false then you will not be called again if more commands are currently queued until another new command is queued or until JetByteTools::Win32::CActivatableObject::ProcessQueuedCommands() is called. This allows an activatable object to prevent itself from hogging a thread by only allowing a set number of commands to be processed before it forces the caller to 'take a break'. If more commands would have been processed at this time but cannot due to the callback returning false then JetByteTools::Win32::CActivatableObject::Callback::OnActivatableObjectMoreCommandsToProcess() is called to notify the object of the situation. The idea is that the object can then do something to schedule future processing of these unprocessed commands. The first time commands are processed a call to JetByteTools::Win32::CActivatableObject::Callback::OnActivatableObjectAboutToProcessCommands() is called so that the object can reset its 'number of commands processed this time around' counter...
  • Added JetByteTools::Win32::CActivatableObject::Callback::OnActivatableObjectExpandQueue() which is called when an activatable object's command queue is expanded.
  • Changed JetByteTools::Win32::CActivatableObject::QueueCommandForProcessing() to take an enum for ProcessingFlags rather than just a boolean flag. This allows you to pass the following mutually exclusive flags; QueueOnlyDoNotProcess, ProcessAll and ProcessOnlyThisCommand.
  • Added checked_static_cast<> which is used just like a static_cast<> but which checks that the converted value will fit into the target type without overflow and throws an exception if this is not the case.
  • Added CRC32 functions in CRC32.h
  • Redesigned JetByteTools::Win32::IManageTimerQueue, see for details.
  • Renamed the static JetByteTools::Win32::IWaitable::Wait() functions to JetByteTools::Win32::IWaitable::WaitForHandle() so that classes that implement the interface don't hide the static functions by implementing the non-static wait function.
  • Bug fix to JetByteTools::Win32::CJob::QueryInformation() which limited the information returned to the first 10 processes.
  • Added JETBYTE_LOCKABLE_OBJECT_CHECK_FOR_REENTRANT_USE_GENERATE_CRASH_DUMP and JETBYTE_LOCKABLE_OBJECT_CHECK_FOR_REENTRANT_USE_EXCEPTION which both help you to tune how JetByteTools::Win32::CLockableObject and JetByteTools::Win32::CLockableObjectTracksLockingThread deal with failed reentrancy checks.
  • Renamed the define that is used to cause a JetByteTools::Win32::CLockableObject to fall back on a reentrant implementation based on JetByteTools::Win32::CCriticalSection. This was called JETBYTE_HAS_SRW_LOCK_TRY_ENTER and it's now called JETBYTE_LOCKABLE_OBJECT_USE_CRITICAL_SECTIONS. The reason for this is that now all supported platforms have JETBYTE_HAS_SRW_LOCK_TRY_ENTER set to 1 but there are still some good reasons for running with the critical section implementation in some situations. The renaming makes the choice more obvious.
  • Added JetByteTools::Win32::CMiniDumper::IncludeFileVersion to the enum used to specify the filename parts for a dump file name. If you add this flag then your dump file will include the exe's version number from its file resource.
  • Added move constructor and assignment operator to JetByteTools::Win32::TReferenceCountedSmartPointer. This removes unneccessary reference counting activity.
  • Added JetByteTools::Win32::CSystemTime::SetAsSystemTimeFromLocalTime(), JetByteTools::Win32::CSystemTime::SetAsLocalTimeFromSystemTime(), JetByteTools::Win32::CSystemTime::SetFromTimeT32(), JetByteTools::Win32::CSystemTime::SetFromTimeT64(), JetByteTools::Win32::CSystemTime::GetAsTimeT32(), JetByteTools::Win32::CSystemTime::GetAsTimeT64() and JetByteTools::Win32::CSystemTime::GetAsTimeT().
  • Removed the concept of 'dispatching timers whilst holding a lock' from the JetByteTools::Win32::IQueueTimers implementations. All implementations now always dispatch without holding a lock.
  • Removed the entired TimerQueueImplementation from JetByteTools::Win32::CThreadedCallbackTimerQueue. Since 6.7 we have been ignoring everything except the locking flags and now that they have been removed there is no need for the enum at all. This is a breaking change. Where the enum was previously used you must delete it.
  • Bug fix to JetByteTools::Win32::CThreadPoolEx so that it deals better with fixed sized thread pools.
  • Bug fix to JetByteTools::Win32::CUTF8StreamConverter::AtoUTF8() to remove a locale leak.
  • Changed function signature for JetByteTools::Win32::IRunnable::Run() so that it returns an unsigned in rather than a int.
  • AddedJetByteTools::Win32::StripLastDirectoryFromPathName() and JetByteTools::Win32::RemoveDirectoryAndContents().

Version 6.7
  • Removed JetByteTools::Win32::ICriticalSectionFactory, JetByteTools::Win32::ISharedCriticalSection, JetByteTools::Win32::IManageSharedCriticalSections, JetByteTools::Win32::CCriticalSection2, JetByteTools::Win32::CSharedCriticalSection, JetByteTools::Win32::CSharedCriticalSectionFactory, JetByteTools::Win32::CSmartSharedCriticalSection and JetByteTools::Win32::CUniqueCriticalSectionFactory. The concept of shared critical sections is no longer supported.
  • Removed JetByteTools::Win32::CThreadedCallbackTimerQueue::HybridTickCount64 and JetByteTools::Win32::CThreadedCallbackTimerQueue::HybridTickCount64NoLock as the hybrid GetTickCount64() implementation is no longer required as all supported platforms now provide GetTickCount64.
  • Removed JetByteTools::Win32::CCallbackTimerQueue. JetByteTools::Win32::CCallbackTimerQueueEx is now the only timer queue implementation.
  • Bug fix to JetByteTools::Win32::CCallbackTimerQueueEx::BeginTimeoutHandling() to prevent incrementing m_nextTimeoutHanlde causing the value to wrap to InvalidTimeoutHandleValue which was possible, but unlikely.
  • Removed JETBYTE_USE_CAPTURE_STACK_BACK_TRACE we now ALWAYS used CaptureStackBackTrace() so there's no need to make it optional.
  • Added new overloads for JetByteTools::Win32::GetFileNameFromPathName() and JetByteTools::Win32::StripFileNameFromPathName() which takes the path separator. This allows the functions to be used for file system paths or URI paths.
  • Added new overloads for JetByteTools::Win32::GetFileVersion() and JetByteTools::Win32::GetFileVersionString() which take languge IDs and charset IDs
  • Added JetByteTools::Win32::RemoveDirectoryContents().
  • Added JetByteTools::Win32::GetFileSize().
  • Added some code to the top and bottom of Utils.h which try to deal with situations where min and max have been defined as macros. We use the std::min() and std::max() template versions and macros confuse matters so the new code attempts to undef the macros if present and then redefine them at the end of the header.

Version 6.6.5
Version 6.6.4
  • Bug fix to JetByteTools::Win32::CallbackTimerQueueBase which prevents the timeout handle from ever being incremented to zero. It's unlikely but possible.
  • Added JetByteTools::Win32::COSVersionInfo::IsWindows81OrLater() and JetByteTools::Win32::COSVersionInfo::IsWindows10OrLater().
  • Adjusted all includes to remove relative paths and instead be absolute in relation to the library root. So, rather than include "..\Blah.h" it would always be include "JetByteTools\Lib\Blah.h" this is due to a new warning in Visual Studio 2015 update 1.

Version 6.6.3
  • Ran Visual Lint using Gimpel PC Lint on all code and adjusted to remove warnings and fix bugs.
  • Removed all use of exception specifications. We only ever used throw() but that's now gone too.
  • Protected non-virtual destructors on interfaces are now virtual even though they you can't delete the object via the interface.
  • All destructors that could throw exceptions now have optional "log and swallow" exception handlers which are enabled by default. This is better than ignoring the problem and being faced with a call to std::terminate() which can be hard to track down.
  • Added JetByteTools::Win32::CActivatableObject::CommandWrapper to remove duplication in the users of JetByteTools::Win32::CActivatableObject
  • Bug fix for JetByteTools::Win32::CCallbackTimerWheel::EndTimeoutHandling() where we were leaking one shot timers.
  • Removed JetByteTools::Win32::CFileChangeMonitor as it was not used or compiled. The functionality is contained in JetByteTools::Win32::CDirectoryChangeMonitor.
  • Added JetByteTools::Win32::CNTPTime which converts SYSTEMTIME to and from NTP timestamps.
  • Fixed some bugs in and added some tests for JetByteTools::Win32::CRecursiveDirectorySearch
  • Added JetByteTools::Win32::StringToBoolA().
  • Added JetByteTools::Win32::CSmartHGlobal which wraps an HGLOBAL
  • Added JetByteTools::Win32::CSystemTime::GetAsHTTPDate()
  • Added JetByteTools::Win32::CSystemTime::ValidateInRangeForDisplay() which is now called before we format dates and times for display.
  • AddedJETBYTE_DELAY_THREAD_TERMINATION_HACK and JETBYTE_DELAY_THREAD_TERMINATION_DELAY which are used in JetByteTools::Win32::CThread::ThreadFunction() to optionally delay thread termination in an attempt to work around this issue:
  • Bug fixes in JetByteTools::Win32::CThreadPool::OnThreadPoolThreadStopped() and JetByteTools::Win32::CThreadPoolEx::OnThreadPoolThreadStopped() so that the call to the monitor's OnThreadPoolStopped() function is consistent and in the right place.
  • Changes to the various JetByteTools::Win32::ToString() implementations so that they remain consistent across Visual Studio versions. Visual Studio 2015 changes how precision is used in the printf family of functions and provides greater default precision. We limit precision to 17 in JetByteTools::Win32::ToString() so that the output is consistent with earlier versions of Visual Studio.
  • Bug fix to JetByteTools::Win32::CSmartHandle so that closing a pseudo thread handle or pseudo process handle does not cause an exception.
  • JetByteTools::Win32::TReusableIdManager::Release() now returns the id.
  • JetByteTools::Win32::CCommandLine::Parse() now takes a reference to a string that can be used to return an error message.
  • Added JetByteTools::Win32::IQueueTimers::SetTimerWithRefCountedTimer(), JetByteTools::Win32::IQueueTimers::CancelTimerWithRefCountedTimer() and JetByteTools::Win32::IQueueTimers::DestroyTimerWithRefCountedTimer() which deal with the common pattern of code required when the timer handle is a reference counted class.
  • Added JetByteTools::Win32::IQueueTimers::RefCountedTimer.
  • Bug fix to JetByteTools::Win32::TReusableIdManager::InternalTryFree() so that we correctly merge intervals. Note that this bug was purely in the was we stored the intervals (which was less efficient than it could be) and did not affect the function of the manager.
  • Added JetByteTools::Win32::IManageEnvironmentVariables::TryDeleteVariable().
  • Added locking to JetByteTools::Win32::CEnvironmentBlock so that it's now safe to use from multiple threads.
  • Added checking when we lock JetByteTools::Win32::TLockableObjectPotentialOwner<> and JetByteTools::Win32::TReentrantLockableObjectPotentialOwner<> so that an exception is thrown if it's already locked. Also changed how JetByteTools::Win32::TReentrantLockableObjectPotentialOwner<> is implemented as it was unnecessarilly complex.
  • Breaking Change VS2015's exponent doesn't include a leading 0 when calling sprintf, etc. This changes the output for some calls to JetByteTools::Win32::ToString() and makes it inconsistent with all previous releases.
  • Bug fix to JetByteTools::Win32::TZeroInitialiseExpandableBuffer::Resize() so that it doesn't trash memory if you reduce the size of the buffer.
  • Bug fix to JetByteTools::Win32::TZeroInitialiseExpandableBuffer assignment operator so that it actually compiles and works.

Version 6.6.2
  • Changes to remove non-trivial, function level static objects from the code, the construction of which is problematic in multi-threaded code.
  • Added Intrusive containers. A set, map and multi-map which can be used to replace STL containers with ones which do not need to do memory operations during insertion and removal.
  • Changed JetbyteTools::Win32::CCallbackTimerQueue and JetbyteTools::Win32::CCallbackTimerWheel to use the new intrusive containers.
  • Added the concepts of "logical size" and "physical size" to JetByteTools::Win32::TExpandableBuffer. This allows for the buffer to be resized smaller without a memory allocation change.
  • Added JetByteTools::Win32::CDirectoryChangeMonitor::InvalidHandleValue
  • Added JetByteTools::Win32::IIndexedOpaqueUserData::InvalidUserDataIndex
  • Changed the type used for JetByteTools::Win32::IManageTimerQueue::TimeoutHandle
  • Bug fix for JetByteTools::Win32::IQueueTimers::SetTimerWithRefCountedUserData(). We now wrap the SetTimer() call in a try/catch block and Release() the reference we created with AddRef() if there's an exception.
  • Changed JetByteTools::Win32::TLockableObject so that it only uses a SRWL if we're building for Windows 7 or later. This is so that the TryEnter() API is available for the SRWL.
  • We now use JetByteTools::Win32::CombinePath() where possible rather than combining paths by hand.
  • Added JetByteTools::Win32::CRAIIAtomicBool which provides a scope based way to set an instance of JetByteTools::Win32::CAtomicBool back to its original value when it leaves a scope.
  • Added JetByteTools::Win32::CRecursiveDirectorySearch.
  • Added JetByteTools::Win32::CRegistryKey::TryDeleteValue().
  • Added JetByteTools::Win32::TReusableIdManager<T>::TryFree().
  • Added JetByteTools::Win32::TThreadSafeReusableIdManager<T>::TryFree().
  • Added JetByteTools::Win32::CRingBuffer::GetSize().
  • Added JetByteTools::Win32::CActivatableObject. See here for details.
  • Changed JetByteTools::Win32::CThreadPool::OnThreadPoolThreadStopped() so that it calls JetByteTools::Win32::IMonitorThreadPool::OnThreadPoolThreadStopped() before deleting the thread and decrementing the counter. This makes it possible to clean up the monitor when the final thread is deleted (and the wait on the counter returns).
  • Added JetByteTools::Win32::CalculateRequiredPrecision() which takes a double value and returns the optimum precision required to format the value for display.
  • Changed all versions of JetByteTools::Win32::ToString() which take a double or long double to also accept a precision value. This value defaults to 6, which is the default precision used if precision isn't specified.
  • Changed JetByteTools::Win32::CreateDirectoryIfRequired() to return a bool which indicates if the directory was created.
  • Changed JetByteTools::Win32::CreateDirectoriesIfRequired() to return a count of the number of directories created.

Version 6.6.1
  • Bug fix to JetByteTools::Win32::CDirectoryChangeMonitor() to ensure that multiple shutdown attempts do not access deleted data.
  • Added an overload to JetByteTools::Win32::CException() constructor that takes std::string.
  • Added JetByteTools::Win32::TExpandableBuffer<T>::Swap().
  • Added JetByteTools::Win32::IConfiguration::GetUnsignedShortValue().
  • Added JetByteTools::Win32::IQueueTimers::SetTimerWithRefCountedUserData(), JetByteTools::Win32::IQueueTimers::CancelTimerWithRefCountedUserData(), and JetByteTools::Win32::IQueueTimers::DestroyTimerWithRefCountedUserData() which all implement the operations using the correct 'AddRef()/Release()' pattern. Bug fix to JetByteTools::Win32::TLockableObjectTracksLockingThread<T>::IsLockedByThisThread() to correct a casting bug that prevents some configurations from building. Bug fix to JetByteTools::Win32::CTimeChangeNotificationMonitor which fires the timer callback immediately if the delay timer cannot be set and which also prevents the timer callback from being fired continually once it has been fired once (assuming a delay timer is used).

Version 6.6
  • JetByteTools::Win32::CCallTracker now supports multiple "instances" of tracked data. This makes it possible to track an object through a destruction/recreation phase (assuming the object is pooled) and makes tracking some obscure and complex reference counting bugs easier.
  • The reference tracking code now supports adding text "notes" to the reference list for a tracked item, so you can add additional information to the trace, and a timestamp, so that it's easier to tie an entry in the trace back to other lines in the log.
  • Added an optional null pointer dereference check to JetByteTools::Win32::TConditionalSmartPointer::operator->() and operator*() If JETBYTE_SMART_POINTER_THROW_ON_NULL_REFERENCE is enabled then we throw an exception if the reference is null at point of use.
  • Added JetByteTools::Win32::CLockableObject, JetByteTools::Win32::CSlimLockableObject, JetByteTools::Win32::CLockableObject, JetByteTools::Win32::CSlimReentrantLockableObject, JetByteTools::Win32::CLockableObjectTracksLockingThread. JetByteTools::Win32::CSlimLockableObjectTracksLockingThread, JetByteTools::Win32::CLockableObjectTracksLockingThread, JetByteTools::Win32::CSlimReentrantLockableObjectTracksLockingThread and asociated interfaces. These new locks replace JetByteTools::Win32::CCriticalSection and the non-reentrant locks use Slim Reader Writer locks (in exclusive mode) to implement a mutual exclusion lock which is fractionally more performant (on most modern hardware) and less resource intensive. SRW locks are only available on Windows Vista and later and so we fall back to using a CRITICAL_SECTION on XP. Note that SRW locks are not reentrant and so we have a separate set of reentrant locks which are based on CRITICAL_SECTION on all platforms. The abundance of different locks allows us to be more precise about our locking requirements and opens the way for possible performance enhancements in the future. You can guard against inadvertent reentrant use of a non-reentrant lock by defining JETBYTE_LOCKABLE_OBJECT_CHECK_FOR_REENTRANT_USE to 1 in Config.h, you can break immediately into the debugger on such usage if you also define JETBYTE_LOCKABLE_OBJECT_CHECK_FOR_REENTRANT_USE_DEBUG_BREAK to 1. Both of these debugging aids reduce the performance of the lock somewhat. Note that the "Slim" in the name of some of these locks does not in any way refer to SRW locks it refers to the relative "fatness" of the lock object. The "slim" versions do not have virtual member functions and do not derive from interface classes and this makes them smaller than the "non-slim" versions. Given that the size of the "slim" versions is the size of a pointer adding the interface and vtable doubles the size of the lock. These slim locks MAY be of some use if you need to use lots of them and you want them to take up the smallest possible amount of space.
  • All locking in this library has been updated to use the new locks.
  • Added JetByteTools::Win32::ICriticalSection::IsLockedByThisThread()
  • Added JetByteTools::Win32::ICriticalSection::EnsureLockedByThisThread() and JetByteTools::Win32::ICriticalSection::EnsureIsNotLockedByThisThread() which create dumps, throw exceptions and break into the debugger if they fail. These allow you to create simple macros which can ensure that the a precondition regarding an object's lock is met. This is useful in complex code where you don't want to lock in every private method but you need to be able to catch errors introduced by having a method which should lock before calling a private method not do so.
  • JetByteTools::Win32::CCriticalSection can be deprecated and removed from the code base by defining JETBYTE_DEPRECATE_CRITICAL_SECTION to 1 in Config.h. Note that this is not deprecated by default yet as other libraries still require JetByteTools::Win32::CCritical section as they haven't all been adjusted to use the new locks yet.
  • JetByteTools::Win32::CCriticalSection2 has been deprecated and is no longer available unless you define JETBYTE_DEPRECATE_CRITICAL_SECTION_2 to 0 in Config.h. This class is viewed as being of limited use with no benefits over the other locks available.
  • Shared critical sections, JetByteTools::Win32::CSharedCriticalSection, JetByteTools::Win32::CSharedCriticalSectionFactory, JetByteTools::Win32::CUniqueCriticalSectionFactory, JetByteTools::Win32::ICriticalSectionFactory, JetByteTools::Win32::ISharedCriticalSection, JetByteTools::Win32::IManageSharedCriticalSections and JetByteTools::Win32::CSmartSharedCriticalSection, have been deprecated. The resource limitations present on the machines from the NT4 era when this code was concieved are no longer an issue and the presence of the code encourages its use which is no longer recommended. In almost all situations it's far better to allocate a lock per object rather than share locks. This code is no longer available unless you define JETBYTE_DEPRECATE_SHARED_CRITICAL_SECTIONS to 0 in Config.h. Note that if this code is unavailable then the SocketTools library cannot support shared lock sockets and they must also be disabled.
  • Changes to JetByteTools::Win32::CCrtReportHook, JetByteTools::Win32::DebugTrace and JetByteTools::Win32::CGlobalErrorHandler to include code that checks for the shutdown of the CRT (via the registration of an "atexit" function) and disables functionality that requires the CRT if the CRT has already been shutdown. This is mainly due to CLR hosting requirements where the CLR can terminate a process rudely, but any abnormal shutdown situations may also benefit. The problem is that these classes use RAII to enable/disable themselves and if ExitProcess() is called then they are left enabled after main() returns. The CRT can not be used after this point and attempting to do so causes all kinds of problems.
  • JetByteTools::Win32::CGlobalErrorHandler now registers a signal handler for SIGABRT as there are some situations where this is called by the CRT and other CRT error functions are not called.
  • Bug fix to JetByteTools::Win32::CDirectoryChangeMonitor to remove race condition in JetByteTools::Win32::CDirectoryChangeMonitor::RemoveWatch().
  • Added support for GetQueuedCompletionStatusEx() to JetByteTools::Win32::CIOCompletionPort if the platform supports it (so on Windows Vista and later).
  • Added JetByteTools::Win32::IProvideSystemTime as a complement to JetByteTools::Win32::IProvideLocalTime. Also added JetByteTools::Win32::CSystemTimeProvider which implements it.
  • Adjusted the debug output from JetByteTools::Win32::CMiniDumpGenerator for when it is prevented from producing a dump due to the dump limit being reached.
  • Added JETBYTE_MINI_DUMP_GENERATOR_BREAK_INTO_DEBUGGER which can be defined to 1 to cause a debug break to occur before JetByteTools::Win32::CMiniDumpGenerator generates a mini dump if the code is running in a debugger at the time. Often this is more useful than having the dump generated and then having to debug the dump. JetByteTools::Win32::COptext now derives from JetByteTools::Win32::IReentrantLockableObjectTracksLockingThread rather than JetByteTools::Win32::ICriticalSection.
  • Updated JetByteTools::Win32::COSVersionInfo to use OSVERSIONINFOEX rather than OSVERSIONINFO and to provide the helper methods JetByteTools::Win32::COSVersionInfo::IsServer2008OrLater(), JetByteTools::Win32::COSVersionInfo::IsWindows7OrLater() and JetByteTools::Win32::COSVersionInfo::IsWindows8OrLater().
  • Removed support for setting a "pure call handler" by simply defining a function called _purecall() as now all supported compilers support _set_pure_call_handler(). This also removes the optional configuration define JETBYTE_DEFAULT_PURE_CALL_HANDLER_INSTALL_ON_EARLY_COMPILERS.
  • Added JetByteTools::Win32::CRAIIBool a simple class which takes a snapshot of a bool's value in its constructor and sets the value back in it's destructor. Use when you need to ensure that a flag is correctly reset whenever code leaves a scope.
  • The destructor for JetByteTools::Win32::TReferenceCountedSmartPointer is now virtual, as is JetByteTools::Win32::TReferenceCountedSmartPointer::SafeRelease().
  • JetByteTools::Win32::TReferenceCountedSmartPointer::SafeRelease() now sets its internal reference to zero (having taken a copy) before releasing the copy.
  • Added support for the concept of "instances" to JetByteTools::Win32::CReferenceTracker. This makes it possible to track an object through a destruction/recreation phase (assuming the object is pooled) and makes tracking some obscure and complex reference counting bugs easier.
  • Bug fix to JetByteTools::Win32::TReusableIdManager which fixes a problem where we were failing to merge adjacent intervals under some situations.
  • Added JetByteTools::Win32::TReusableIdManager::Dump() which makes it easier to write tests for JetByteTools::Win32::TReusableIdManager as it returns a string representation of the internal state of the manager.
  • JetByteTools::Win32::CSEHException will now NOT attempt to create a crash dump if JETBYTE_AUTOMATIC_SEH_CRASH_DUMP_CREATION is enabled and the exception was EXCEPTION_STACK_OVERFLOW as it's not possible as the dump code requires stack space which is not available.
  • JetByteTools::Win32::CSmartStartupInfo now creates the files for standard error and standard output with FILE_SHARE_READ enabled.
  • Added the ability to enable and disable the dormant thread maintenance of a JetByteTools::Win32::CThreadPool and JetByteTools::Win32::CThreadPoolEx. Note that there's no good reason to use this functionality apart from test predictability.
  • Added some explicit overloads for JetByteTools::Win32::ToString() for size_t on Visual Studio 2005 in x64 mode as otherwise the template instantiation gets confused.
  • Added the ability to specify the hex digit representation format for JetByteTools::Win32::PointerToString()
  • Removed the various GetStringLengthAs... functions from Utils.h. These are all replaced by the templated versions (GetStringLength<DWORD>(), GetStringLength<int>(), etc) which now work on all supported compilers.
  • Added JetByteTools::Win32::MoveFile() and JetByteTools::Win32::SaveBinaryDataAsFile().
  • All of the crash handling code now supports an optional "hang on error" mode. This causes the crash handler to wait for an event that will never be set, thus hanging the thread that has called into the handler. This makes it easier to get complete dumps from other threads rather than having, say, the purecall handler terminate the program whilst other threads are dumping for the same pure call, or whatever. Use with care.
  • Breaking Change Removed the include for IRunnable.h from Thread.h as a forward declaration will suffice. This change may require the addition of an include for IRunnable.h in your source files if you use the type and were previously relying on Thread.h to include it for you.
  • Added JetByteTools::Win32::CThreadLocalStorage::ClearValue(), JetByteTools::Win32::CThreadLocalStorage::GetValueAsDWORD() and DWORD specific override for JetByteTools::Win32::CThreadLocalStorage::SetValue(). These changes simplify the use of the API for x64 usage under Visual Studio 2013 as they remove the need to cast at the call site in some situations.
  • Added an optionally enabled hacky fix for the fact that the Visual Studio 2013 Preview broke isprint(). See here for details of the problem and fix it by defining VS2013_PREVIEW_BROKEN_ISPRINT to 1 in your Config.h
  • Addition of an include for algorithm.h in many places for std::min and std::max to support Visual Studio 2013.
  • Added JetByteTools::Win32::CAtomicCounter::Incrementer and JetByteTools::Win32::CAtomicCounter::Decrementer which provide RAII style increment and decrement for atomic counters.

Version 6.5.9
  • Added JetByteTools::Win32::CalculateSpaceRequiredForDecodeBytesBase64A(), JetByteTools::Win32::DecodeBytesBase64A() and JetByteTools::Win32::DecodeBase64A()
  • Added a new constructor for JetByteTools::Win32::CCallStackCreator which allows you to specify the symbol path.
  • Added JETBYTE_TERMINATE_CRASH_DUMP_CREATION and JETBYTE_UNEXPECTED_CRASH_DUMP_CREATION which determine if JetByteTools::Win32::CGlobalErrorHandler will create crash dumps if std::terminate or std::unexpected are called.
  • >Added a callback function that can be supplied to JetByteTools::Win32::CMiniDumpGenerator which is called when 'too many' mini dumps have been produced and a new dump is requested. This can be used to shut a process down after `x` dumps or whatever.
  • >Added a copy constructor for JetByteTools::Win32::TReusableIdManager::SmartId and virtualised the public interface of JetByteTools::Win32::TReusableIdManager so that it can be easily derived from.
  • >Added JetByteTools::Win32::TThreadSafeReusableIdManager which derives from JetByteTools::Win32::TReusableIdManager and adds locking around all of the public interface functions so that the manager is thread safe.
  • >Added typedefs for JetByteTools::Win32::StringMapA, JetByteTools::Win32::StringMapW, JetByteTools::Win32::StringSetA, JetByteTools::Win32::StringSetW, JetByteTools::Win32::StringVectorA and JetByteTools::Win32::StringVectorW.
  • >Added new configuration flag, JetByteTools::Win32::CSimpleMessageLog::IncludeTimestamp, which, when set, causes the JetByteTools::Win32::CSimpleMessageLog to include a time stamp with each log message.

Version 6.5.8
  • No changes.

Version 6.5.7
  • Updated our support of Visual Studio 2012 to the RTM version. Added a few more warning suppressions. Fixed the solution file format so that it's actually a 2012 solution file and not a 2010 solution file using the 2012 tool chain.

Version 6.5.6
  • Updated our support of Visual Studio 2012 (11) to the RC version. Added a few more warning suppressions. Renamed the output directories. Renamed the solutions and projects from .11. to .2012.
  • Added JetByteTools::Win32::TryCombinePath() and JetByteTools::Win32::CombinePath()
  • Added JetByteTools::Win32::MakePathAbsolute()
  • Bug fix to JetByteTools:Win32::CSystemTime::AddMonths().
  • JetByteTools::Win32::CSystemTime::AddDays(), JetByteTools::Win32::CSystemTime::AddMonths() and JetByteTools::Win32::CSystemTime::AddYears() now all take an int to specify the value to add and the value can be negative...
  • Added JetByteTools::Win32::CSystemTime::GetDaysInMonth(), JetByteTools::Win32::CSystemTime::IsLeapYear(), JetByteTools::Win32::CSystemTime::GetYearsDifferent(), JetByteTools::Win32::CSystemTime::GetMonthsDifferent(), JetByteTools::Win32::CSystemTime::GetDaysDifferent().
  • JetByteTools::Win32::CTempDirectory now includes the process id in the temporary directory name.

Version 6.5.5
  • Fixed some warnings generated by /analyze.
  • Added the very unsafe to use JetByteTools::Win32::COptext::Reset() which forcibly resets an optex to unlocked. Use with great care.
  • Added debug trace output to JetByteTools::Win32::CThreadedCallbackTimerQueue::OnThreadTerminationException(). This is one of the rare cases where the libraries log to the debug trace internally. You should override JetByteTools::Win32::CThreadedCallbackTimerQueue::OnThreadTerminationException() if you don't want it to log to the debug trace BUT you should log the details somewhere as a thread termination in the timer queue will stall the queue and produce bugs which are hard to track down if you haven't logged the fact that the thread has died.

Version 6.5.4
Version 6.5.3
  • No changes.

Version 6.5.2
  • Changed JetByteTools::Win32::CAtomicBool to use Interlocked operations to set the value and compare to 1.
  • Added Various new functions to JetByteTools::Win32::CUTF8StreamConverter

Version 6.5.1
  • No changes.

Version 6.5
  • Added JetByteTools::Win32::CBufferHistory a class for use when debugging protocol parsing issues. It can keep track of the past 'n' contents of a buffer and then dump the details on demand. Useful to see where a protocol parser might be going astray.
  • Added JetByteTools::Win32::EncodeBytesBase64A() and JetByteTools::Win32::EncodeBase64A(), which use the source code from here to perform Base64 encoding. via the Interlocked range of functions.
  • Adjusted how JetByteTools::Win32::CCrtReportHook works and added JetByteTools::Win32::CCrtReportHook::GenerateDumpOnWarnings() to enable you to turn on crash dump generation for warnings as well as errors and assertions.
  • Added JetByteTools::Win32::CGlobalErrorHandler which deals with wrapping up SEH exception translation, CrtReportHook management, Purecall trapping and SetErrorMode handling all in one place.
  • Added JetByteTools::Win32::IDataDeflatorFactory, JetByteTools::Win32::IDeflateData and JetByteTools::Win32::IInflateData which allow you to provide alternative implementations to the code deflation code in ZLibTools.
  • Added JetByteTools::Win32::IProvideRandomNumbers and JetByteTools::Win32::RandomNumberProvider.
  • Bug fix to JetByteTools::Win32::CMiniDumper to make the calls to MiniDumpWriteFile() thread safe.
  • Bug fix to JetByteTools::Win32::MiniDumpGenerator so that the dump limit works.
  • Added JetByteTools::Win32::GetSHA1Hash() which generates an SHA1 Hash.
  • Added UTF8 functions to JetByteTools::Win32::CStringConverter.
  • Added JetByteTools::Win32::CUTF8StreamConverter which maintains state and allows the conversion of a stream of bytes fed into it into UTF8 characters. The inbound byte stream can end at any point within a UTF8 character and the partial character will be returned once the stream has provided more input data.
  • Added JetByteTools::Win32::StripWhiteSpace() which strips all whitespace characters from the input.
  • Added JetByteTools::Win32::CThreadPoolEx which is a more performant version of JetByteTools::Win32::CThreadPool which uses a single IOCP and a counter to determine when to spawn new threads.

Version 6.4
  • Added JetByteTools::Win32::CAtomicCounter, a volatile long value that is manipulated via the Interlocked range of functions.
  • Bug fix for an bug in JetByteTools::Win32::CCallbackTimerQueue and JetByteTools::Win32::CCallbackTimerWheel whereby memory could become corrupted if you called DeleteTimer() from within OnTimer(). See here for more details.
  • Added JetByteTools::Win32::CCodePage
  • Bug fix to JetByteTools::Win32::CStringConverter::WtoA() for systems with multi-byte default code pages. See here for more details.
  • Added JetByteTools::Win32::CCrtReportHook which will generate crash dumps when CRT errors occur.
  • Bug fix to JetByteTools::Win32::CEvent so that we can connect to existing events more reliably.
  • Added JetByteTools::Win32::ICriticalSection::PotentialOwner::Leave() so that you can have potential owners that can operate like JetByteTools::Win32::ICriticalSection::ConditionalOwner.
  • Added JetByteTools::Win32::IMonitorThreadPool::OnThreadPoolDispatch() which is called each time a work item is dispatched to a thread pool. This can be useful for generating 'event/second' perf counters.
  • Added JetByteTools::Win32::ISingleWriterMultipleReaderLock::TryEnterToWrite() and JetByteTools::Win32::ISingleWriterMultipleReaderLock::TryEnterToRead() and implemented them in all reader writer locks.
  • Added lots of new functionality to JetByteTools::Win32::CJob.
  • Added JetByteTools::Win32::CLibraryLoader::LoadIfPossible() and JetByteTools::Win32::CLibraryLoader::IsLoaded() to make it easier to attempt to load dlls that you don't expect to be able to load.
  • JETBYTE_USE_TEMPLATE_TO_STRING is no longer supported. ToString.h now only contains the new versions of the functions that were introduced in version 6.0. The pre 6.0 code has now been removed.
  • Added JetByteTools::Win32::CMemoryBasedMessageLog an implementation of JetByteTools::Win32::ILogMessages that logs to a memory buffer.
  • Added JetByteTools::Win32::CMiniDumper to programatically generate crash dumps.
  • Added JetByteTools::Win32::CMiniDumpGenerator to generate a number of crash dumps for a process when certain events occur. This is now used by PureCallHandler.h and JetByteTools::Win32::CSEHException to generate mini dumps when purecalls or exceptions occur.
  • JetByteTools::Win32::CNamedIndex can now be restricted in the number of indices that can be registered.
  • Added JetByteTools::Win32::CPerThreadUsageTracker which can be useful to determine how often some code is being called from different threads.
  • Added JETBYTE_PURE_CALL_CRASH_DUMP_CREATION with a default of 0. When set to 1 purecalls will generate a crash dump using JetByteTools::Win32::CMiniDumpGenerator.
  • Added JetByteTools::Win32::CReentrantSingleWriterMultipleReaderLock which is a reentrant version of JetByteTools::Win32::CSingleWriterMultipleReaderLock that uses one TLS slot per lock; so it's expensive, don't create many of them.
  • Added JetByteTools::Win32::CReentrantSingleWriterMultipleReaderLock2 which is a reentrant version of JetByteTools::Win32::CSingleWriterMultipleReaderLock that allows for a compile time determined maximum number of threads to access it (we store the reentrancy information in a fixed sized memory block). Set JETBYTE_REENTRANT_SINGLE_WRITER_MULTIPLE_READER_LOCK_2_MAX_THREADS to the number of threads that you need to support, defaults to 100.
  • Breaking Change JetByteTools::Win32::TReferenceCountedSmartPointer::SafeRelease() now returns 0 rather than a pointer to the object that you don't own a reference to anymore.
  • Added JetByteTools::Win32::TReleaseOnlyReferenceCountedSmartPointer which only requires that the object being managed supports Release() rather than requiring AddRef() AND Release(). Bug fix and functionality change to JetByteTools::Win32::TReusableIdManager. We now reuse id's correctly when we wrap and you can restrict the range of Id's better.
  • Added JETBYTE_AUTOMATIC_SEH_CRASH_DUMP_CREATION with a default of 0. When set to 1 all CSEHExceptions will generate a crash dump using JetByteTools::Win32::CMiniDumpGenerator when they are created, so at the point where they are converted from Windows SEH exceptions to C++ exceptions.
  • JetByteTools::Win32::CSimpleMessageLog can now log to a memory buffer as well as the various other locations that it supports.
  • Added JetByteTools::Win32::CSystemTime::GetAsDatabaseDateTimeStampA().
  • Added JETBYTE_TRACK_THREAD_NAMES with a default of 0. When set to 1 JetByteTools::Win32::CThread will keep track of all threads that are named using JetByteTools::Win32::CThread::SetThreadName() and return these details, thread Id and name, from a call to JetByteTools::Win32::CThread::GetThreadNames(). Breaking Change JetByteTools::Win32::ToHexString() can now take new flags which can be used to determine if the resulting string is padded with leading zeroes; so you can decide between 0x1 and 0x00000001 outputs for the DWORD value 1, etc. The defaults match what the function used to produce, but different types produced different default output. Also JetByteTools::Win32::ToHexStringHexDigitRepresentation::HexDigitsNoPrefix (which changes the output from 0xFFFFFFFF to FFFFFFFF) wasn't always being applied to all types, now it is.
  • Added JetByteTools::Win32::IsAllHexDigitsA().
  • Added a version of JetByteTools::Win32::GetFileVersion() that takes an HMODULE.
  • Added JetByteTools::Win32::ToUpperW(), JetByteTools::Win32::ToLower(), JetByteTools::Win32::ToLowerA() and JetByteTools::Win32::ToLowerW().
  • Added JetByteTools::Win32::SaveStringToFileA().
  • Added JetByteTools::Win32::LoadFileAsStringA().
  • Added a version of JetByteTools::Win32::FindAndReplace() that can be restricted to a maximum number of replacements.
  • Added JetByteTools::Win32::FindAndReplaceA().
  • Added JetByteTools::Win32::GetLongFromStringA().
  • Added JetByteTools::Win32::GetShortFromStringA().
  • Bug fix to JetByteTools::Win32::CWaitableCounter whereby there was a race condition in JetByteTools::Win32::CWaitableCounter::Decrement() if the owner of the counter wanted to delete the counter once it became signalled.
  • Added a new constructor to JetByteTools::Win32::CException which takes a 'where' a 'message' and an error code that is converted into a message which is appended to the supplied message.
  • Added JetByteTools::Win32::TZeroInitialiseExpandableBuffer which is an JetByteTools::Win32::TExpandableBuffer that sets its memory buffer to all zeroes upon construction and sets the new portion of the buffer to zeroes upon resizing and expansion.
  • Breaking Change renamed JetByteTools::Win32::CProcess::DetatchProcess() to JetByteTools::Win32::CProcess::DetachProcess().

Version 6.3.3
  • No changes.

Version 6.3.2
  • No changes.

Version 6.3.1
  • No changes.

Version 6.3
  • Lots of white space changes which make comparing actual changes with 6.2 quite hard. Sorry.
  • Added optional monitoring to JetByteTools::Win32::CCallbackTimerQueueBase. This can be disabled by defining JETBYTE_PERF_TIMER_QUEUE_MONITORING to 0 in your Config.h.
  • Added JetByteTools::Win32::IMonitorCallbackTimerQueue which allows you to implement the monitoring interface required by the callback timer queues.
  • Added optional thread contention monitoring to JetByteTools::Win32::CThreadedCallbackTimerQueue. This changes how we acquire locks when using the class and so could introduce performance issues. We first attempt to "try enter" the lock and if that fails we inform the monitor of the contention and then obtain the lock normally. This code is disabled by default but can be enabled by defining JETBYTE_PERF_TIMER_CONTENTION_MONITORING to 1 in your Config.h. disabled by defining JETBYTE_PERF_TIMER_QUEUE_MONITORING to 0 in your Config.h.
  • Added JetByteTools::Win32::IMonitorThreadedCallbackTimerQueue which allows you to implement the monitoring interface required by the threaded callback timer queues; this includes additional contention monitoring.
  • Redesigned JetByteTools::Win32::CCallbackTimerQueueBase to allow for more efficient timeout processing. See here for more details.
  • Added JetByteTools::Win32::CCallbackTimerWheel which is an alternative to the various timer queue options. It conforms to the same interface as the timer queues but works with timers which have a more limited scope. It's considerably more efficient for some operations than the timer queues. See here for more details.
  • Added JetByteTools::Win32::CCallStackCreator which allows you to easily obtain a callstack for a location in code.
  • Added exception handlers for std::exception to library exception handlers. This dumps details of the exception to the appropriate places in the same way that is done for other exception types.
  • Added JetByteTools::Win32::IConfiguration::HasValue() which returns true if the value exists in the configuration.
  • Added JetByteTools::Win32::ICriticalSection::PotentialOwner which is a new RAII class which allows you to call JetByteTools::Win32::ICriticalSection::TryEnter() on a critical section and correctly releases the lock in its destructor if you manage to obtain it.
  • Added PureCallHandler.h which allows you to easily install a pure call handler that will capture a stack trace if it's called.
  • Added JetByteTools::Win32::TReusableIdManager which allows you to manage ids so that you can allocate, release and reuse them.
  • Added JetByteTools::Win32::CRingBuffer which is a simple ring buffer.
  • Fixed JetByteTools::Win32::CSEHException::GetCallStack() so that it does not crash if the exception is EXCEPTION_STACK_OVERFLOW.
  • Added creation flags to the constructors of JetByteTools::Win32::CSemaphore which operate in a similar way to the ones for JetByteTools::Win32::CEvent to allow you to specify that you want to create a new object or connect to an existing, or that you don't care.
  • Fixed a bug in JetByteTools::Win32::CSimpleFixedSizedMemoryAllocator which caused the final chunk to be allocated from a block incorrectly, causing an access violation.
  • Added explicit implementations of JetByteTools::Win32::ToString(const bool val); rather than letting bools get passed to the int version. There was a memory access error in certain situations.
  • Fixed a bug in JetByteTools::Win32::IsAllDigits() whereby it was returning true for an empty string.
  • Added JetByteTools::Win32::IsAllDigitsA().
  • Fixed a bug in JetByteTools::Win32::Is32bitProcess() we were always returning true.
  • Added JetByteTools::Win32::StripLeadingA() and JetByteTools::Win32::StripTrailingA().
  • Added the ability to restrict the number of replacements made in calls to JetByteTools::Win32::FindAndReplace() and JetByteTools::Win32::InPlaceFindAndReplace().
  • Fixed a bug in JetByteTools::Win32::GetTempPath() which would cause it to fail if the path contained double slashes.

Version 6.2
  • Fixed a stack overflow bug in JetByteTools::Win32::GetLastErrorMessage() which could occur in some very unlikely situations where FormatMessage() failed multiple times. We now break out of the recursive calls if the error code returned from GetLastError() after a FormatMessage() failure is the same as the input error code.
  • Fixed how JetByteTools::Win32::CThreadPool operates when the number of threads in the pool is fixed. Whilst we were optimising dispatch in this case we weren't doing everything we could given the fixed sized nature of the pool. Now we don't start the dispatch thread, which wasn't used, and shut down in a cleaner manner.
  • Deal with work items that have been dispatched to a JetByteTools::Win32::CThreadPool after the pool has been shutdown. These items are now passed straight to JetByteTools::Win32::IThreadPoolWorkerThreadFactory::DisposeOfQueuedItemsAfterShutdown() whereas before they would have accumulated in the queue that fed the pool and would then have been cleaned up when the pool was destroyed.
  • Added The ability to shut down an instance of JetByteTools::Win32::CThreadedCallbackTimerQueue without destroying it. The class now follows the standard BeginShutdown(), WaitForShutdownToComplete() pattern.
  • Added Two new constructors for JetByteTools::Win32::CProcessToken so that you can construct from an existing handle.
  • Added JetByteTools::Win32::TReferenceCountedSmartPointer::ConstructionOwnershipSemantics which can be passed in to a constructor to change how it deals with the ownership of the passed in pointer. The default is for the smart pointer to take ownership of the existing reference; this is how the code has always worked in the past. The constructor defaults to taking JetByteTools::Win32::TReferenceCountedSmartPointer::TakeOwnershipOfExistingReference. If you have a reference counted object with a reference of 1 and you pass a pointer to it into a JetByteTools::Win32::TReferenceCountedSmartPointer then the smart pointer will decrement the reference to 0 when it is destroyed. There's now a new ownership type, JetByteTools::Win32::TReferenceCountedSmartPointer::CreateNewReference which causes the smart pointer to call AddRef() on the input pointer if the input pointer is not null. This mans that the smart pointer is creating a new reference.
  • Added JetByteTools::Win32::TReferenceCountedSmartPointer::AddRef() which allows you to perform a "safe" AddRef() on a smart pointer that may or may not contain a valid reference. That is, smartPtr.AddRef() can be used to replace the following code sequence: if (smartPtr.Get()) smartPtr->AddRef();. JetByteTools::Win32::TReferenceCountedSmartPointer::SafeAddRef() and JetByteTools::Win32::TReferenceCountedSmartPointer::SafeRelease() are now public rather than private.
  • Added JetByteTools::Win32::TReferenceCountedSmartPointer::ConstructionOwnershipSemantics which allow you to specify whether the smart pointer constructors takes ownership of an existing reference or creates a new reference of their own. The constructors default to taking ownership of this existing referece, which is backwards compatible with pre 6.2 code. Use JetByteTools::Win32::TReferenceCountedSmartPointer::ConstructionOwnershipSemantics::CreateNewReference when you would otherwise want to call AddRef() after constructing the smart pointer...
  • Added JetByteTools::Win32::CThreadedCallbackTimerQueue::WaitForShutdownToComplete() and made JetByteTools::Win32::CThreadedCallbackTimerQueue::BeginShutdown() public, so that you can shutdown a timer queue and wait for it to finish.
  • Added JetByteTools::Win32::CAtomicBool - a simple boolean class which provides an atomic way to query and toggle the value using InterlockedCompareExchange()
  • Fixed a memory leak bug in JetByteTools::Win32::CCallStack where we were deleting an array with delete rather than delete [].
  • Added JetByteTools::Win32::CConditionalSmartPointer - a smart pointer which can be told, during construction or assignment, not to act as a smart pointer. This can be useful if sometimes you own some memory and sometimes you don't and you want to hold the memory in a smart pointer when you DO own it...
  • Breaking Change All instances of InitiateShutdown() have been changed to BeginShutdown() this is to remove the issue with the Win32 InitiateShutdown() function which is conditionally defined as either InitiateShutdownA() or InitiateShutdownW() and which could then cause issues. The following classes are affected:
  • Added JetByteTools::Win32::ICompressData an interface that represents a stateless data compressor/decompressor. At present the only implementation of this is JetByteTools::ZLib::CDataCompressor.
  • JetByteTools::Win32::ISingleWriterMultipleReaderLock::Reader now takes a const ISingleWriterMultipleReaderLock reference in its constructor as entering to read is a logically const operation for most classes that would be using the ISingleWriterMultipleReaderLock lock.
  • Added JetByteTools::Win32::IWaitable::IsSignalled() which calls Wait() with a timeout of zero to determine if the object is currently signalled. This gets around the need to cast the zero to JetByteTools::Milliseconds to avoid ambiguity.
  • Fixed JetByteTools::Win32::CNamedIndex::FindOrAdd() so that it only checks to see if the index collection is locked if it needs to add a new index.
  • Added an optional null pointer dereference check to JetByteTools::Win32::TReferenceCountedSmartPointer::operator->(). If JETBYTE_REFERENCE_COUNTED_SMART_POINTER_THROW_ON_NULL_REFERENCE is enabled then we throw an exception if the reference is null at point of use.
  • Added JetByteTools::Win32::CRegistryConfiguration an implementation of JetByteTools::Win32::IConfiguration which reads data from a specify set of registry keys.
  • Added JetByteTools::Win32::CSmartBool::operator bool().
  • Added a new overload to JetByteTools::Win32::CStringConverter::AtoBSTR().
  • Added some new conversion formats to JetByteTools::Win32::CSystemTime. You can now pass date/times in any of the following string formats to the JetByteTools::Win32::CSystemTime constructor.
  • Added JetByteTools::Win32::CSystemTime::GetAsHHMMSSMMM().
  • Added JetByteTools::Win32::CSystemTime::GetAsDatabaseDateTimeStamp() which returns the date/time as YYYY-MM-DD HH:MM:SS.MMM
  • Added JetByteTools::Win32::CSystemTime::ContainsDate() which returns true if the date portion of date/time is valid.
  • Breaking Change JetByteTools::Win32::CTempDirectory::RemoveContents() now removes the contents of sub-directories as well as files within the temporary directory.
  • Breaking Change JetByteTools::Win32::CThread::WasStarted() has been removed and replaced by JetByteTools::Win32::CThread::IsRunning(). This is because instances of JetByteTools::Win32::CThread can now be restarted after they have been shutdown.
  • Fixed a rare memory leak with JetByteTools::Win32::CThreadedCallbackTimerQueue. We now use JetByteTools::Win32::CConditionalSmartPointer to hold the timer queue so that failed construction of the JetByteTools::Win32::CThreadedCallbackTimerQueue after the timer queue has been created causes the timer queue to be destroyed correctly.
  • Added conditional code for VS2002 and VS2003 for JetByteTools::Win32::GetStringLengthAsDWORD() and all other versions so that we are using the templated version for VS2005 and later and only using custom code for those compilers that don't support the template code. This is to make it easier to move away from the custom code when we drop support for the older compilers.
  • JetByteTools::Win32::CWaitableCounter::Increment() now returns true if the value was incremented from zero.
  • JetByteTools::Win32::CWaitableCounter::Decrement() now returns true if the value was decremented to zero.
  • Added JetByteTools::Win32::CWaitableCounter::Add() which allows you to add an arbitrary amount to a waitable counter and correctly toggles the various events if the counter passes through zero.
  • Added JetByteTools::Win32::CWaitableCounter::Subtract() which allows you to subtract an arbitrary amount to a waitable counter and correctly toggles the various events if the counter passes through zero.
  • Added JetByteTools::Win32::CWaitableCounter::Incrementer::LeaveIncremented().
  • Added JetByteTools::Win32::CWaitableCounter::Decrementer::LeaveDecremented().
  • JetByteTools::Win32::CException now strips trailing new lines from error messages obtained by JetByteTools::Win32::GetLastErrorMessage().
  • Added JetByteTools::Win32::CSEHException::GetCallStack() which returns the callstack that was active when the JetByteTools::Win32::CSEHException was generated.

Version 6.1.1
  • Added JetByteTools::Win32::MurMurHash2 by Austin Appleby, See This is used JetByteTools::Win32::CCallStack to provide a hash of the stack.
  • Updated JetByteTools::Win32::StackWalker to use the v10 (2009-11-01) version of Jochen Kalmbach's code. See for details.
  • Fixed a 'lack of locking' bug in JetByteTools::Win32::CCallTracker which caused problems during over-release reference dumps.
  • Added JetByteTools::Win32::ITrackReferences::TrackAllocationsFrom, JetByteTools::Win32::ITrackReferences::ExcludeAllocationsFrom and JetByteTools::Win32::ITrackReferences::TrackFromHere which allow you to restrict which socket or buffer allocators are tracked by the reference tracking code when it's enabled. This can be very useful in reducing the runtime performance cost of enabling reference tracking.

Version 6.1
  • Added JetByteTools::Win32::CCallStack which is used to represent a call stack within a process.
  • Added JetByteTools::Win32::CCallTracker which is used to collect callstacks for a series of calls to a function.
  • Added JetByteTools::Win32::IAllocateFixedSizeMemory and JetByteTools::Win32::CSimpleFixedSizedMemoryAllocator which provides a nieve fixed sized memory allocator.
  • Added JetByteTools::Win32::ITrackReferences and JetByteTools::Win32::CReferenceTracker to enable the tracking of calls to reference counting functions such as AddRef() or Release().
  • Added JetByteTools::Win32::StackWalker which is on a BSD license and is based on code from
  • Added JetByteTools::Win32::ISingleWriterMultipleReaderLock as we now have two implementations of a reader/writer lock.
  • Breaking Change JetByteTools::Win32::CSingleWriterMultipleReaderLock::Leave() now throws an exception if the lock is not locked.
  • Added JetByteTools::Win32::CSingleWriterMultipleReaderLockEx which is an implementation of JetByteTools::Win32::ISingleWriterMultipleReaderLock that allows recursive entry and also allows a writer to downgrade to a reader by simply calling JetByteTools::Win32::CSingleWriterMultipleReaderLockEx::EnterToRead() whilst holding a write lock.
  • Changed how catch(...) handlers are implemented within library code. See the release notes for Admin.h for more details.
  • Changes to JetByteTools::Win32::CException if JETBYTE_EXCEPTION_STACK_TRACES is defined to 1. When enabled exceptions derived from JetByteTools::Win32::CException will capture a call stack at the point where they are thrown. This can then be accessed via JetByteTools::Win32::CException::GetCallStack() and, optionally, displayed as part of the string that is returned from a call to JetByteTools::Win32::CException::GetWhere().
  • Changed how JetByteTools::Win32::CSEHException operates. Structured exception translation can be globally disabled by setting JETBYTE_TRANSLATE_SEH_EXCEPTIONS or JETBYTE_TRANSLATE_SEH_EXCEPTIONS_IN_DEBUGGER to 0 before building.
  • Added JetByteTools::Win32::CThreadedCallbackTimerQueue::OnThreadInitialised() and JetByteTools::Win32::CThreadedCallbackTimerQueue::OnThreadShutdown() which allow derived classes to call some code (such as to initialise COM) on the thread that is used to dispatch timers.
  • Changed how JetByteTools::Win32::CThreadPool works when maxThreads == minThreads. If we determine that the thread pool is a fixed size, i.e. maxThreads == minThreads then dispatch is done directly to the worker threads rather than via the dispatch port and the dispatcher thread. This is a slight performance optimisation and is useful in some situations.
  • Added JetByteTools::Win32::GUIDAsString() which converts a GUID to a string representation with or without leading and trailing braces.
  • Breaking Change Moved JetByteTools::CSmartBool to JetByteTools::Win32::CSmartBool.
  • Breaking Change Moved JetByteTools::TLinkedClass to JetByteTools::Win32::TLinkedClass.
  • Breaking Change Moved JetByteTools::TSingleton to JetByteTools::Win32::TSingleton.
  • Breaking Change Moved JetByteTools::TTypeSafeTypedef to JetByteTools::Win32::TTypeSafeTypedef.

Version 6.0
  • The C++Tools and RegistryTools libraries have been merged with this library. All code that used to be in these libraries and their associated namespaces are now in the JetByteTools::Win32 namespace.
  • Breaking Changes to how we share a pool of critical sections; see below and see here: for more details.
    • Breaking Change. The functionality that was in JetByteTools::Win32::CSharedCriticalSection in previous releases of the library is now in JetByteTools::Win32::CSharedCriticalSectionFactory as this more accurately describes what the class is. JetByteTools::Win32::CSharedCriticalSection now provides functionality for a critical section that is provided by one of the critical section factorys.
    • Added the JetByteTools::Win32::ISharedCriticalSection interface which allows you to access the underlying JetByteTools::Win32::ICriticalSection interface and requires that you call JetByteTools::Win32::ISharedCriticalSection::Release() when you no longer need to use the shared lock.
    • Added JetByteTools::Win32::CSmartSharedCriticalSection which provides an RAII wrapper for JetByteTools::Win32::ISharedCriticalSection instances.
    • Breaking Change to JetByteTools::Win32::ICriticalSectionFactory, it now returns instances of JetByteTools::Win32::ISharedCriticalSection rather than JetByteTools::Win32::ICriticalSection. It also supports 'pools' of shared locks and the ability to request a shared lock from a specific pool.
    • Added a new critical section factory, JetByteTools::Win32::CUniqueCriticalSectionFactory which creates a unique instance of a critical section for each request and destroys the instance when JetByteTools::Win32::ISharedCriticalSection::Release() is called on it. This allows you to replace an instance of JetByteTools::Win32::CSharedCriticalSectionFactory with an instance of this factory to give each user of the factory its own unique critical sections. This can be useful if you find that no matter what the size of the pool the contention between users for the same, shared, lock is too great.
  • Added support for JetByteTools::Win32::ICriticalSection::TryEnter().
  • Breaking Change to the JetByteTools::Win32::ToString() functions in Utils.h. These have all been moved into ToString.h, though Utils.h still provides access. We have also changed how we convert numeric types to strings. Prior to this release we used std::strstream and templates and streamed the type into a string. However this requires the acquisition of a process wide lock (for accessing locales and facets) in some versions of STL which is less than ideal for multi-threaded use. From this release we default to using a custom sprintf based system to convert from numbers to strings. We also decided to change how 0 is represented in JetByteTools::Win32::ToHexString(), it's converted to 0x0 in the new code whereas it was converted to 0 in the old. JetByteTools::Win32::ToHexString() was also enhanced to allow for the user to decide if they want upper or lower case hex digits and we added JetByteTools::Win32::PointerToString() which gives a consistent represenation of pointers across 32bit and 64bit operating systems (always representing pointers as 64bit hex values). If you define JETBYTE_USE_TEMPLATE_TO_STRING as 1 in your Admin\Config.h file then you will revert to the pre version 6.0 behaviour and functionality using std::strstream. Please note that this old code is likely to be deprecated in a future release and then removed.
  • JetByteTools::Win32::CTimeChangeNotificationMonitor now compiles on versions of the compiler with headers that don't include a definition of USER_TIMER_MAXIMUM.
  • Added /Zm200 to the Visual Studio .Net (2002) project file as it seems to need more space for precompiled headers when compiling with STLPort. Note that you can remove this if you do not need STLPort support

Version 5.2.5
  • No changes.

Version 5.2.4
Version 5.2.3
Version 5.2.2
Version 5.2.1
  • VS 2008 support - Adding projects and solutions and excluding warning 4627...
  • This is the first release built using continuous integration, some project file fixes to fix incorrect output directories, etc so that x64 and x86 builds can be done in complete isolation.
  • We no longer output ANY debug logging directly from library code. It's your choice to log if you want to.
  • Added JetByteTools::Win32::IMonitorThreadPool::OnThreadPoolError() which is called when an error occurs in a thread pool
  • Added JetByteTools::Win32::IIOCPWorkerThreadCallback::OnProcessException() and JetByteTools::Win32::IIOCPWorkerThreadCallback::OnThreadTerminationException() which are called when worker threads have problems.
  • Added JetByteTools::Win32::CThreadedCallbackTimerQueue::OnThreadTerminationException() which is called when the worker thread dies unexpectedly.
  • Fixed JetByteTools::Win32::CThreadPool where there was a bug in the code used to forcibly terminate threads if they didn't shutdown cleanly in time during a shutdown of the pool. If the pool had expanded and then contracted, or if any threads had terminated due to exceptions then there would be invalid entries in the list of threads that the pool would attempt to terminate and this could cause access violations.
  • Fixed JetByteTools::Win32::GetLastErrorMessage() it no longer reports "invalid parameter" as the error message for any messages which have insertion strings...
  • JetByteTools::Win32::IsGoodReadPtr() is now cross process
  • Added JetByteTools::Win32::SetCurrentDirectory()
  • Added JetByteTools::Win32::StripFileNameFromPathName() which does the opposite of JetByteTools::Win32::GetFileNameFromPathName(); that is, the new function returns the path without the element after the last backslash.
  • Fixed JetByteTools::Win32::CThreadNameInfo to use DWORD_PTRs rather than DWORDs.
  • Added JetByteTools::Win32::CThread::IsThisThread() which returns true if the calling thread is the thread represented by the thread object.
  • Added JetByteTools::Win32::IConfiguration::GetShortValue().
  • Fixed JetByteTools::Win32::CThreadPool where an exception thrown from Process() would prevent OnThreadPoolProcessingStopped() being called which would screw up the active thread count and lead to thread starvation.
  • Added JetByteTools::Win32::IsWow64Process() which returns true if the process is an x86 process that is running under WOW64 on an x64 system.
  • Added JetByteTools::Win32::Is64bitProcess() which returns true if the process is an x64 process.
  • Added JetByteTools::Win32::Is32bitProcess() which returns true if the process is an x86 process.
  • Added JetByteTools::Win32::IConfiguration::GetOptionalConfiguration() and JetByteTools::Win32::IConfiguration::GetOptionalConfigurations().
  • Added JetByteTools::Win32::CEvent::CreationFlags and adjusted the constructors of all three event classes so that you can specify if construction should fail if a named event object already exists, or doesn't already exist. The default behaviour is to not care, which is the same as previous versions of the library.
  • A few small lint related changes, as we're now running PC-Lint on the code again.
  • New constructors for JetByteTools::Win32::CEvent, JetByteTools::Win32::CAutoResetEvent and JetByteTools::Win32::CManualResetEvent to enable you to specify that creation of a named event should fail if an event of that name already exists, or if an event of that name does NOT already exist.

Version 5.2
  • x64 port - Some data types have changed...
  • Some tightening up on const.
  • Some classes now take explicit security attributes.
  • The concept of 'argument groups' has been removed from JetByteTools::Win32::CCommandLine.
  • JetByteTools::Win32::IIKernelObjectName now supports three new methods that allow you to query the type of name, IsGlobalName(), IsLocalName() and IsUnqualifiedName().
  • Added JetByteTools::Win32::CDebugTrace and JetByteTools::Win32::CSimpleMessageLog and legitimised the concept of debug tracing. These classes work with JetByteTools::ILogMessages and JetByteTools::CMessageLog, from the C++ Tools library (I'm still not convinced that how I've split this up is "good"), and provide a pluggable log system. If you want performance you should look at JetByteTools::IO::CAsyncFileLog from the IO Tools Library.
  • Added JetByteTools::Win32::IConfiguration which is just a placeholder interface for accessing hierarchical configuration data. See JetByteTools::XML::CXMLConfiguration for an example implementation over an XML file.
  • Added JetByteTools::Win32::ILocalTimeProvider and JetByteTools::Win32::CLocalTimeProvider so that testing of things that use GetLocalTime() can be made easier.
  • Added JetByteTools::Win32::CProcessToken, JetByteTools::Win32::CSecurityPrivilege and JetByteTools::Win32::CSecurityPrivileges which are all incomplete and unfinished.

There were no release notes for this library prior to version 5.2

Generated on Sun Sep 12 19:06:45 2021 for The Server Framework - v7.4 by doxygen 1.5.3