ALox  V. 2402 R. 0
Home ALox for C++ ALox for C# ALox for Java Download
Change Log

Historically, there existed a kind of predecessor of this library for C++ and Java and was more or less maintained since the year 1999. However this is a complete rewrite with C++, Java and C# implementations.
The first version released was V. 1.0.1 in May 2013.

This change log is sorted reversely in respect to chronology.

Changes of the C++ version of ALib / ALox are listed in the Change Log Of The ALib For C++ project.
Changes in the C# and Java versions of ALib / ALox may sometimes not justify a change of version. However, if the version number still changed, then this is due to changes in the C++ version which then have more impact.

Version 2402, Revision 0, released February 29th, 2024

  • This version supports newest Java and C# language standards.
    The most dramatical change here was the need to rename method AString::_ to AString::__ (two underscores), because the underscore became a reserved keyword in JAVA.
  • Furthermore, the JetBrains IDE project files have been updated.
  • Other IDE projects, tools and descriptions might have become a little outdated (but have not been touched). Community input would be very welcome.
  • Changes of the C++ version, which is constantly maintained are documented here

Version 1903, Revision 0, released March 16th, 2019

Changes in ALib:

  • Added field ALIB.MainThreadID (C#, Java).
  • Overhauled class AutoSizes (C++,C#, Java) to faster adjust to recent session length. I.e. the class now distinguishes tab stop positions from field widths and is able to "consolidate" the actual values with the currently measured ones. See the classes' documentation for more information (the changes are not listed completely here).
  • Renamed field FormatterPythonStyleBase::AutoSizes to FormatterPythonStyle::Sizes} and changed its access level from protected to public.
  • Changed access level of field from protected to public (and capitalized the first letter of its name in C++ and C# version).

Changes in ALox:

  • Refactored name of sub-namespace core in namespace aworx.lib.lox to detail (C++,C#, Java).
  • Fixed a bug with Lox::SetVerbosity (C++,C#, Java) which prevented the verbosity to be set, in the case that the given logger was not registered with that Lox before and a resourced verbosity value with the same priority existed.
  • With construction of class Lox (C++,C#, Java), a default thread dictionary entry is added, which maps the ID of the main thread to the name "PROCESS".
    In C#/Java, the ID is received with new field ALIB.MainThreadID (C#, Java), in C++ with new method Thread::GetMain.
    On the same token, an internal redundancy in respect to this thread ID to name translation map was fixed.
  • Added abstract methods ObjectConverter::GetAutoSizes (C++,C#, Java) and ObjectConverter::ResetAutoSizes (C++,C#, Java) and along with this implementations StandardConverter::GetAutoSizes (C++,C#, Java) and StandardConverter::ResetAutoSizes (C++,C#, Java).
  • Configuration variable ALOX_LOGGERNAME_AUTO_SIZES now stores the auto sizes values of the log output formatter in addition to those of the meta information. The values have a new format (see above) and the export data of each object is separated by a semicolon.
  • Changed behaviour of class MetaInfo (C++,C#, Java) to not write escape sequences for auto-tabulator tokens found in the format string, but to write spaces instead. With this, some smaller changes in the method signatures of the class occurred. The goal here was to have a more accurately formatted log-output in combination with overhauled class AutoSizes.

Version 1805, Revision 0, released July 29th, 2018


The C++ part of this multi-language project has been forked to ALib Class Library. The goal and consequences of this effort are:
  • Have a repository and website exclusively dedicated to ALib for C++.
  • Reverse the library nesting in the C++ Version: ALib here is now the main project, while ALox becomes one of several ALib Modules.
  • Decouple the development and roadmaps of future ALib modules from Java and C# language versions of ALib/ALox.

The changes performed with this release exclusively concern the C++ version and are documented in the new project's changelog.

Version 1712, Revision 1, released February 28th, 2018

This is a bug fixing revision, almost exclusively concentrating on C++ version.

Changes in ALib all languages:

  • Changed behaviour of externalization/internalization of config variable strings to be more intuitive for end users. (Class ccj_aworx{lib::config,Xternalizer}.

Changes in ALib for C++:

  • Changed CMake script alib.cmake to respect external settings of otherwise cached variables. This allows to permanently change their "default" values, by setting ALib CMake variables prior to invoking the script. On the same token, variable ALIB_CMAKE_COTIRE_DEFAULT has been removed, as now just ALIB_CMAKE_COTIRE can be set from outside.
  • Added macros ALIB_CPP14, ALIB_CPP17 and ALIB_CPP14_CONSTEXPR.
  • It is now allowed to have an C++ enum type be define "bitwise" and "arithmetical" at the same time. To achieve this, bitwise alias operators + (alias for |) and += (alias for |=) become disabled to avoid ambiguities with those operators introduced with arithmetical enum types.

    Furthermore, the following operators have been added for arithmetical enums:

    • ++, -- (prefix and postfix version).
    • unary +, unary -
    • *, *=, /, /=, %, %=
    • <<, <<=, >>, >>=

    Finally fixed the documentation of various operators and even a list of lhs arguments that accidentally had been passed as reference are now correctly passed by value.

  • Fixed a bug with loading resourced enum meta data for enumerations declared with ALIB_LANG_ENUM_NAMED and ALIB_LANG_RESOURCED.
  • Changed behavior of method Exception::Code. It now skips entries with negative exception enum element values. This allow to declare pure informational entries, not to be caught bei exception handlers, by giving them a negative enum element value. See documentation of class Exception for further details.
  • Added enum class Exceptions defining currently one exception, which is thrown with erroneous ALib reports. (Usually format string errors).
  • Fixed an infinitive loop in method AString::SearchAndReplace.
  • Added operator methods <= and >= to Strings for completeness.
  • Added new class WildcardMatcher which compiles wildcard patterns (using wildcards '*' and '?') and enables to match strings against the pattern.
  • Added new class RegexMatcher which compiles regular expression patterns using external boost::regex library.
    New compiler symbols ALIB_FEAT_BOOST_REGEX_ON / ALIB_FEAT_BOOST_REGEX_OFF control the integration of this feature to ALib. Corresponding CMake variable ALIB_FEAT_BOOST_REGEX was added.
  • As an alternative to already existing UnorderedStringMap, new type UnorderedStringMapIgnoreCase was added that uses case insensitive string keys. Furthermore types UnorderedAStringMap and UnorderedAStringMapIgnoreCase have been added, which hold an allocated copy of a key string.
  • Fixed description resource string of Exceptions::ArgumentIndexOutOfBounds.
  • Changed parameter type of method MemoryBlocks::Clear from bool to lang,CurrentData.
  • Changed accessibility of inner class PluginContainer::Slot from protected to public to allow a plug-in container to pass its list of plug-ins to helper classes.
  • Default constructor of Box is now trivial and therefore leaves boxes uninitialized. Before, the default constructor initialized a nulled box, same as Box(nullptr).
    Furthermore added explicitly defaulted copy and move constructors as well as copy and move assign operators.
  • Added method Box::IsNotNull (C++) for completeness.
  • Added templated implementation IEquals_TComparable of boxing interface IEquals usable for all types that defined C++ operator==. In addition added corresponding convenience macro ALIB_BOXING_DEFINE_IEQUALS_FOR_COMPARABLE_TYPE.
  • Added boxing interface IIsTrue.
  • Added type definition UnorderedBoxMap which uses new functors std_Hash and std_Equals to with a std::unordered_map with keys of type Box.
  • Fixed missing deletion of report writer in Lang.terminationCleanUp.
  • Moved internal type definition aworx::lib::lang::RTTIUnorderedMap to aworx::TypeMap.
  • Added field SimpleTextBase::DetectedMaxLineWidth.
  • Changed parameter of method StringTable::Clear from type bool to more readable CurrentData.
  • Fixed conversion !ATab and !AWidth of class FormatterPythonStyle in respect to multi-line strings. Furthermore, !ATab does not insert one minimum space character any more (which it was never documented to do).
  • Fixed a (serious) bug in NumberFormatBase::WriteFloat, which could cause wrong results when fractional parts unlimited length were written.
  • Changed method NumberFormatBase::ParseFloat to accept scientific separator on integral numbers (without parsing a decimal point).
  • Resourced static strings "true" and "false" written when boolean values are applied to type AString.
  • Added classes TimeStamp, TimeSpan, CalendarTime and StopWatch. These classes are supposed to replace classes Ticks (C++), TicksCalendarTime and TickWatch in the next release version (which are therefore to be considered deprecated).
  • Added Ticks::operator+, Ticks::operator-, Ticks::operator+=, Ticks::operator-=, Ticks::operator==, Ticks::operator!=, Ticks::operator<, Ticks::operator<=, Ticks::operator>, Ticks::operator>= and SetToAge. Furthermore added boxing/unboxing of Ticks by value.

Changes in ALox for C++:

  • Slightly changed meanings of parameters domainPrefix and logPrefix of method LogTools::Exception

Version 1712, Revision 0, released December 22nd, 2017

Details removed due to too many broken documentation links. For details checkout the corresponding Git version.

Version 1709, Revision 0, released September 13th, 2017

Details removed due to too many broken documentation links. For details checkout the corresponding Git version.

Version 1702, Revision 1, released March 9th, 2017

Details removed due to too many broken documentation links. For details checkout the corresponding Git version.

Version 1702, Revision 0, released February 6th, 2017

A General Note:
This is once more a major update of ALox. And - once more - we hope that with this update the foundation is now led to provide a stable version that will not undergo major interface changes in the future. The good news is: For existing logging statements, the interface is still valid and code does not need to be changed. The other good news is that the interface dramatically improved and - if a user wants - he/she may convert existing log statements to this new interface.

The change lies in the fact that prior versions supported one "logable" (aka one arbitrary object) to log. The new interface allows an arbitrary amount of logables to log. In respect to textual logging (the normal use case), this means that in prior versions the text to be logged needed to be assembled first and then passed to ALox. Now, this assembling is not necessary any more: All objects are concatenated inside the logger, of-course supporting now nice format strings that tell the logger how to do this.
This explains, why the interface remained compatible to the old version: The logger of-course still accepts such single pre-assembled strings to log. However, the benefits of passing the components of the string using a list of arguments are:

  • String concatenation is performed only if needed (if a log is executed in respect to its Verbosity)
  • Less code clutter, better readable log statements
  • better Readable
  • Easier to use

Now, people may wonder why this feature comes only so late!? The answer is: While in languages C# and Java such interface is quite easy to implement (due to the approach "everything is an object or gets automatically boxed into an object" of these languages) in C++ it is not: How can you pass arbitrary amounts of arbitrary objects and then process them and convert them to strings in C++? Our answer to this is: ALib Boxing!

In short, ALib Boxing allows to create methods that accept any type of argument as parameter, without the need of type conversion, wrapper classes, etc. Furthermore ALib Boxing allows to add virtual interfaces to C++ types, independent from the original implementation of the type itself. This means that any 3rd-party type can be adopted to support "boxing" and to provide its own virtual interface implementations. To reach this goal, quite a bit of template meta programming was used and some other tricks with C++ type information facilities.

Therefore, the big effort for this release affected two areas:

  • Implement C++ Boxing in underlying library ALib.
  • Implement formatters (we support Python style and Java style format syntax today) for all three languages.

We should not forget to mention that the impact on binary logging (logging of non textual objects using custom loggers) is huge: Custom loggers in general are not compatible to the new version. The good news is: ALib Boxing provides a whole new level of possibilities and ease of use to binary loggers in general.

The license was changed from "MIT License" to "Boost Software License". The Boost License is more liberal in respect to distributions in binary format. No copyright notice has to be given when ALib/ALox code is distributed exclusively within binary files (compiled code).

Pre-configured Projects and Tools:

  • Support for JetBrains CLion, JetBrains IntelliJ and JetBrains Rider added.
    Special thanks goes to JetBrains people for granting a free license to support ALox as an open source project!
    ALox logging and marvellous (!) JetBrains IDEs go together very well: On all platforms and languages, the log output will be nicely formatted with "clickable" links back into the source code!

    Information on how to use ALox with JetBrains products is found in the setup manual pages.

  • Moved to Doxygen V. 1.8.12, with some impact on ALox homepage design.
  • C++ Version:
    • All code is now fully compatible with clang compiler. ALox/ALib is using its maximum possible warning level for the code. The impact was huge! For example all "old style casts" have been removed from the code. Only a few single warnings need to be disabled. But those are anyhow more for analytics but for day-to-day use. So, we are optimistic that ALib/ALox compiles in any setting without warnings!
    • ALib and ALox code is now compiling under Mac OSX. Development of platform specific code sections has been made using CMake and JetBrains CLion. No XCode project has been set up, yet. Help for future Mac OS support is welcome!
    • Code is now compiling and tested on 32-bit GNU/Linux OS.
    • Added Pretty Printers for GNU Debugger. However, this is not completely satisfying with all IDEs. The best support for pretty printing of ALox/ALib classes is still with IDE QTCreator.
    • Renamed CMake files ALib_Base.cmake and ALox_Base.cmake to ALib.cmake and ALox.cmake.
    • Various ALib/ALox CMake variables which had been "hardcoded" have been turned into CMake cache variables.
    • Renamed macros ALIB_DLL_EXPORTS and ALOX_DLL_EXPORTS to ALIB_API_IS_DLL and ALOX_API_IS_DLL. On the same token, added macros ALIB_API_NO_DLL and ALOX_API_NO_DLL.
Details removed due to too many broken documentation links. For details checkout the corresponding Git release or the release's attachment on GitHub..

Version 1607, Revision 0, released July 23rd, 2016

Changes in Preconfigured Projects:

  • Eclipse Neon (4.6) support for ALox for Java. The project folder was renamed from




    (The Eclipse versions Luna, Mars and Neon should be compatible with the same project files.)

    When doing this, all compiler warnings have been switched to be even more strict than before. As a consequence several @SuppressWarnings tags had to be added to the code. Make sure to have your IDE setup to not warn on unnecessary @SuppressWarnings tags in the case your preference on warnings are less strict.

Details removed due to too many broken documentation links. For details checkout the corresponding Git release or the release's attachment on GitHub..

Version 1604, Revision 2, released June 20th, 2016

Details removed due to too many broken documentation links. For details checkout the corresponding Git release or the release's attachment on GitHub..

Version 1604, Revision 1, released May 26th, 2016

Details removed due to too many broken documentation links. For details checkout the corresponding Git release or the release's attachment on GitHub..

Version 1604, Revision 0, released April 19th, 2016

Details removed due to too many broken documentation links. For details checkout the corresponding Git release or the release's attachment on GitHub..

Version 1602, Revision 1, released February 15th, 2016

This is a revision of version 1602, with minimal impact on standard ALox user code.

Details removed due to too many broken documentation links. For details checkout the corresponding Git release or the release's attachment on GitHub..

Version 1602, Revision 0, released February 2nd, 2016

General changes

This is a major update. A lot, if not all was touched. The good news is that the logging interface itself did only change slightly for Java and C# versions. In C++ the macros were renamed because we started using 'variadic macros' instead of 'suffixed overloads'. This makes ALox C++ even more code-compatible to C#/Java versions. Therefore, very simple code changes (mostly renaming) should be needed to adopt this release.

More important general changes are:

Details removed due to too many broken documentation links. For details checkout the corresponding Git release or the release's attachment on GitHub..

Version 1.2.0, released June 2nd, 2015

  • ALox for C++ has arrived! Key features of this first version are:
    • Feature complete in respect to current C# and Java versions of ALox
    • GNU/Linux (gcc) and Windows (Microsoft Compiler) support
    • C++ 11 code standards. (Does not compile with C++ compilers prior to C++ 11)
    • CMake build system support
    • QTCreator build system
    • Visual Studio project files
  • Changes in C# and JAVA versions:
    • Due to the alignment with the new C++ code base many changes occurred. Only the most important ones are listed here.
    • Reorganization of directory structure of source code and project/build files.
    • A huge list of changes occurred ALIB classes of both languages,
      • Many corrections/improvements in class MString, which was in addition renamed to AString
      • Interface changes in Ticker and TickTime utility classes. Ticker was moved to Ticks, TickTime is now named TickWatch and both classes changed tremendously. Class TickSpan introduced in JAVA (while C# relies to built-in class).
    • Consumable source path prefix feature moved from class Lox to class TextLogger
  • Changes in ALox for C#:
    • Mono support and MonoDevelop project files
    • Support for Windows Phone 8.1 was added
    • Support for Windows Phone 7.1 was "officially" dropped. However, it should still work
    • Unit tests were removed from the Windows Phone projects configurations. We did not find a maintainer for this.
  • Changes in ALox for Java:
    • Transitioned Eclipse support from Kepler to Luna
    • Proguard 5.2 (January 2015) release tested
  • Various fixes in the documentation.

Version 1.1.2, released March 4th, 2015

  • Various fixes in the documentation.
  • Android fix fo LogCat output.
  • C# Version: Support for Mono and MonoDevelop. This means, corresponding ide files (MonoDevelop) have been set up and Unit Testing now supports VStudio and NUnit Test
  • Outlook: A C++ Version is currently in development and to be released in Q2 2015

Version 1.1.1, released November 26th, 2013

  • Added a first, simplistic file Logger. This is really just a first shot, not optimized in any respect. This is due to be extended in next versions.
  • Created an own source folder for tools and moved class LogTools there.
  • C# Version: Improvement of LogTools.Instance to be able to handle members of type KeyValuePair<,>, which are considered a value type in C#.
  • C# Version: In the tool section, added a simple generic JSON file reader which in combination with LogTools.Instance provides very easy simplistic JSON handling (good for quick and dirty exploration of JSON data).

Version 1.1.0, released July 31st, 2013

  • First ALox for Java Release! 100% Feature complete (as compared to actual C# Version).
  • ALox for Java includes an LogCat Logger for Android. This enables LogCat filtering and double-click support (jump to code line)
  • Doxygen documentation now builds three different sites: Main, C# and Java. With a little doxygen manipulation, these three sites nicely integrate into each other, without much of a "media break".
  • Added tutorials and sample projects on how to configure pruning for C# (incl. Windows Phone) and Java (incl. Android).
    Attn: The project folders and project names changed. So after doing a checkout, you have to fix your VStudio solution.
    For C#, see Setting Up Visual Studio
    For Java, see Setup your IDE for Java Projects
  • Slightly different namespace (C#), respectively package (Java) structure:
    • class Lox moved one package "up" from com.aworx.lox.core to com.aworx.lox
    • classes MemoryLogger and ConsoleLogger moved to a new package from com.aworx.lox.loggers This new packages is to be filled over time with new Logger types. Class TextLogger however, was kept in package com.aworx.lox.core as this class is an abstract foundation class for current and future text based Loggers.
  • Class TextLogger was completely redesigned to be more configurable and extensible. For a complete description, see new manual chapter A - Loggers and Implementing Custom Types.
  • Added a AString singleton to classes Log and Lox that can be acquired using Log.Buf respectively Lox.Buf and is automatically released when contents gets logged. See new tutorial section.
  • C# class ThreadLock corrected method names to follow "upper camel case".
  • A very lot of small changes and improvements. Reviewed and extended tutorials and user manual with new chapters.

Version 1.0.4, released June 24th, 2013

  • Java Version (including Android LogCat support) is on its way. It is almost "feature complete", but not in a state of being released, yet. Stay tuned!
  • Two manual chapters written.
  • Various internal improvements of speed and code consistency.
  • Changed the type of parameter "msg" in all logging methods of classes Log, Lox and Logger from String (or AString) to Object. Only TextLogger will then identify different string-types (e.g. String, StringBuilder, StringBuffer, AString, CharSequence, etc.) and handle them efficiently. Unknown types are converted using their ToString() function. Other Loggers might treat them differently. This should not affect your code base in respect to using the standard logging interface.
  • Introduced the new enumeration Scope. The scope is used by different methods as a parameter to define the applicable scope of a command. Scopes differ in different platform/languages supported by ALox. In C# the scope can be "Method" or "SourceFile" while in the upcoming Java version of ALox the scope "Package", "Class" and "Method" are defined. The difference is due to different mechanisms to automatically collect scope information.

    Attn C# users: If within one source file two or more classes with equal same method names exist, then such method names share the same scope and hence are ambiguous. This is due to technical restrictions of how scope information is collected in C#/.Net.

    The methods affected in this release are:

    • Log.GetMarker,
    • Log.SetMarker, and
    • Log.RegDomain.

    For the latter, the optional parameter "setAsDefault" was replaced by the scope and is not optional, but explicit now. For registering a Domain without setting it as the Scope Domain, the Scope value Scope.None has to be given.

  • Parameter list of abstract function TextLogger::logText got extended. Needs adaption if you derived your own TextLogger class.
  • Removed one and renamed two of the output control flags in Logger. If you used them, you will have to make small code changes.
  • Small changes in TextLogger format strings for date and time of day.
  • Renamed com.aworx.MutableString to MString. Several new methods added. (No impact on API)

Version 1.0.3, released May 27th, 2013

  • added Windows Phone 7.1 compatibility (Windows Phone 8, was already supported)
  • minor bug fixes in code and documentation
  • renamed methods Log.LOG(), Lox.log() and Logger.Log() to Logger.Line(). The reasons why they had been named as they were before, is maybe not too obvious. Some name conflicts where confusing. Now, all confusion should be gone!

    Note: If you had used these methods, you have to rename them in your code accordingly.

  • Enums Level and DomainLevel stop existing several times in different namespaces. Their place is now in class Log, hence Level and Verbosity.

    Note for those who are interested:* This was OK before and supported separation and avoided cyclic package references. However, with implementing the Java version, having multiple versions caused problems (Java does not support casting enum to int or enum A to enum B). While we are aware that class Log is not the right place in terms of code design (Logger and Lox should not know Log but now they use its enums heavily), but the alternatives to that would have led to either ugly calls in the user code or expensive enum conversion operations in the Java version of ALox. And both is what we wanted less than as it is now.

    For all standard use of ALox (through static Log interface Log) this change has no impact on your code.

  • Added further AWorx util classes, to support code compatibility between Java and C# (Java version of ALox development is ongoing but not part of this release

Version 1.0.2, released May 21st, 2013

  • Fixed list of minor bugs
  • Some improvements in formatted output of class LogTools
  • Improvements in formatted output of method Log.LogConfig.
  • Added more options to manipulate multi line message logging with TextLogger
  • Added more unit tests
  • Completed the tutorial section of the user manual (if such thing can ever be complete)
  • Started first "in depth" sections of the user manual

    The following are changes that need modifications in your code:**

  • Renamed conditional compiler symbol AWORX_LOG to ALOX_DEBUG
  • Renamed the namespaces from having prefix "com.aworx.log" to "com.aworx.lox"
  • Renamed all symbols in enum Verbosity and enum Level from *"upper case with underscores"* to *"upper camel case"*, for consistency with C# standards.
  • Renamed

    • Log.CreateDomain() to Log.RegDomain and on the same token renamed:
    • Log.SetDomainLogLevel() to Log.SetDomain()

    This was done to emphasize the fact that both functions create a domain if it does not exist yet and it is not important in which order they are called.

  • Removed method Log.SetDomain(). Use Log.RegDomain
  • Added new Parameter internalDomainLevel added to method Log.AddLogger().

    Note: You do not need to change your source code, because the new parameter has a default value. However, you might want to look at the documentation to understand the concept and use this parameter rightfully.*

Version 1.0.1, released May 17th, 2013

First stable release deployed to brave volunteers.