Harlinn.Windows - A Visual Studio 2022 Solution

Espen Harlinn

5.00/5 (40 votes)

Dec 10, 2021

CPOL

52 min read

91202

17734

Harlinn.Windows is a collection of libraries that I have put together that serves as a big part of the runtime we use at work.

The downloads were last updated on the 26^th of January, 2022. Information about what has changed can be found at the end of this article.

If you have problems downloading the full code archive as a single zip-file, all of the files below provides the download as a multi-part zip-file:

Note: If you download the individual files, extract the contents of each file into one directory and then use 7zip or WinZip to extract them.

Github

I have also created a Github repository, Harlinn.Windows, that provides access to the code. The code in the repository currently compiles with Visual Studio 17.11.0 (as of 16^th of August 2024). Earlier, some files where missing from the repository, and this has now been resolved. The version of the solution in the github repository has many updates and additions compared to the version provided with this article. The solution on Github currently contains 625 projects.

Overview

This article describes Harlinn.Windows, a Visual Studio 2022 solution.

Before you can build the solution, please read the build instructions and configure your environment accordingly.

This solution is for 64-bit, x64, builds only.

Introduction

Harlinn.Windows is a collection of libraries that I have put together that serves as a big part of the runtime we use at work. A few are my own; but most are; more or less, well-known open source libraries.

There are currently 521 projects in the solution, and this article provides a high-level overview of what's inside.

Why Did I Not Use cmake and vcpkg?

This is a good question, and initially I tried to do just that, but there were some snags:

The size of the release build, using vcpkg, for grpc.lib was 325 MB; while the size of the release build of Harlinn.grpc.dll is just 3.7 MB. Currently, the combined size of all the native DLLs created for a release build of the solution is 108 MB.
Some packages relied on different versions of the same package, including their own private copy of a package.
Some packages were compiled with /sdl on, while others were not. I prefer to turn /sdl and /GS off for release builds, and on for debug builds. This may not be as significant as it used to, but you still get better performance when turning /sdl and /GS off.
Many packages will not compile with:
- The /std:c++latest option, which enables all currently implemented compiler and standard library features proposed for the next draft standard, as well as some in-progress and experimental features.
Many packages creates static libraries, not DLLs.

Don't get me wrong; I think CMake and vcpkg are great tools, but putting everything into a single solution makes it easier, at least for me, to understand how everything is tied together.

Why put Harlinn in Front of Every DLL Name?

To avoid naming conflicts. I own the harlinn.com domain, so it is unlikely that anybody would, by accident, put Harlinn in front of the name of their DLL.

What About the Unit Tests?

A few of those are included, but still just a fraction of those available for the original packages.

In particular, I've included all unit tests, that can be expected to compile on Windows, for:

Abseil - 4430 tests pass, 26 fails, and 12 tests are disabled
boringssl
- crypto_test - 910 tests pass, 0 fails, and 0 tests are disabled
- ssl_test - 330 tests pass, 0 fails, and 0 tests are disabled
gRPC - the tests are implemented as 94 separate executables, using multiple approaches to testing. I think that the tests pass; but I am not certain, since much of the validation was performed manually.
bullet - 31 tests pass, 0 fails, and 0 tests are disabled
gdal - 84 tests pass, 0 fails, and 0 tests are disabled
skia - A fair number of the tests works, about 1500 of them, but then the test program terminates.

As far as I have been able to determine, this seems to be related to the test code.

I've also created a fair number of tests for my own projects:

Harlinn.Common.Core.Tests: 1175
Harlinn.Windows.Tests: 271
Harlinn.OCI.Tests: 49
Harlinn.ODBC.Tests: 9
Harlinn.Timeseries.Tests: 10
Harlinn.Julia.Tests: 11
Harlinn.Common.Config.Tests: 34

All tests can be found under the Tests folder.

What About the Examples?

So far, I've included 190 example projects.

All examples can be found under the Examples and DotNet\Examples folders.

How Stable Is This?

This is a snapshot of the solution, and while most things seems to work, there are bound to be some snags. The most common problem will be a function or variable that is not exported from a DLL, and there are probably other bugs too. Some, probably, created by yours truly.

Still, with this solution, you can now:

Use Open GL ES to create graphical applications on top of DirectX 3D:
Create nice 2D effects:
Create animated 3D visualizations:
Learn a lot about some of the most widely used open source packages available, using Visual Studio 2022 and C++.

Harlinn.Common.Core

Harlinn.Common.Core is a library packaged as a DLL that provides functionality that is useful for most Windows C++ projects.

Dependencies

The boost C++ libraries

Other 3rd Party Code included in Harlinn.Common.Core

The Harlinn.Common.Core library contains code from a number of libraries:

The {fmt} library, version 8.0.1, by Victor Zverovich
The xxHash library, version 0.8.1
The CRC-32C (Castagnoli) for C++ library
The xxhash_cx library

About char, wchar_t, signed char and unsigned char

The library tries to treat char and wchar_t as types used for the sole purpose of representing character data, while signed char and unsigned char are expected to represent signed and unsigned 8-bit integers, respectively.

Normally, this is not much of a problem, but consider:

constexpr char buffer1[] = { 1,2,3 };
constexpr unsigned char buffer2[] = { 1,2,3 };
constexpr char buffer3[] = "hello";
constexpr int buffer4[] = { 1,2,3 };
constexpr wchar_t_ buffer5[] = { 1,2,3 };
constexpr wchar_t_ buffer6[] = L"hello";
constexpr auto length1 = LengthOf( buffer1 );
constexpr auto length2 = LengthOf( buffer2 );
constexpr auto length3 = LengthOf( buffer3 );
constexpr auto length4 = LengthOf( buffer4 );
constexpr auto length5 = LengthOf( buffer5 );
constexpr auto length6 = LengthOf( buffer6 );

LengthOf expects buffer1 and buffer5 to be zero-terminated; but since they are not, the compiler will not be able to evaluate LengthOf( buffer1 ) and LengthOf( buffer5 ). LengthOf( buffer3 ) and LengthOf( buffer6 ) evaluate to 5, while LengthOf( buffer2 ) and LengthOf( buffer4 ) evaluate to 3.

The code in HCCPersistent.h, which is used by the code in HCCLogger.h, relies on this, eliminating a significant number of calls to strlen and wcslen at runtime.

Main Header Files

HCC7BitEncoding.h: provides constexpr support for 7-bit encoded values.
HCCActiveObject.h: provides:
- template<typename DerivedT> class ActiveObject:
  
  An active object implementation based on ConcurrentQueue<>.

HCCApplication.h: provides:

class Application:

Every program needs to create one, and only one, instance of this class, or a class derived from this class.

int main( int argc, char* argv[], char* envp[] )
{
    Harlinn::Common::Core::ApplicationOptions options;
    options.Load( );
    Harlinn::Common::Core::Application application( options );
    application.Start( );

    // your code goes here, perhaps:
    int result = foo( );

    application.Stop( );
    return result;
}

Currently this configures, starts and stops the logging back-end on behalf of the program.

HCCArray.h: provides:
- template<typename T, size_t N> ArrayEx:
  
  A template derived from std::array that supports constexpr concatenation using operator +.
- template<typename T, size_t N> class Array:
  
  An alternative to std::array that supports constexpr concatenation using operator +.
- template<size_t N> class ByteArray:
  
  A template that supports constexpr serialization of binary data.
- template<size_t N, bool networkByteOrder = false, bool use7BitEncodedSize = true> class ArrayReader:
  
  A template that implements constexpr deserialization of data.
- template<size_t N, bool networkByteOrder = false, bool use7BitEncodedSize = true> class ArrayWriter:
  
  A template that implements constexpr serialization of data.

HCCBinaryReader.h: provides:

BinaryReaderBase:

template<typename Derived, 
        bool networkByteOrder, 
        bool use7BitEncodedSize>
class BinaryReaderBase

A template that can be used to deserialize binary data.

BufferedBinaryReader:

template<typename StreamT, 
        size_t BufferSizeValue, 
        bool networkByteOrder = false, 
        bool use7BitEncodedSize = true> 
class BufferedBinaryReader

A template that can be used to deserialize binary data from a stream using an internal buffer.

BinaryReader:

template< IO::StreamReader StreamT, 
        bool networkByteOrder = false, 
        bool use7BitEncodedSize = true >
class BinaryReader

A template that can be used to deserialize binary data from a stream.

HCCBinaryWriter.h: provides:

BinaryWriterBase:

template<typename Derived, 
        bool networkByteOrder, 
        bool use7BitEncodedSize>
class BinaryWriterBase

A template that can be used to serialize binary data.

BufferedBinaryWriter:

template<IO::StreamWriter StreamWriterT, 
        size_t BufferSizeValue, 
        bool networkByteOrder = false, 
        bool use7BitEncodedSize = true >
class BufferedBinaryWriter

A template that can be used to serialize binary data to a stream using an internal buffer.

BinaryWriter:

template<IO::StreamWriter StreamT, 
        bool networkByteOrder = false, 
        bool use7BitEncodedSize = true>
class BinaryWriter

A template that can be used to serialize binary data to a stream.

HCCBuffer.h: provides Blocks::Stream a block oriented memory stream.
HCCCom.h: provides:
- class Unknown: A wrapper for the IUnknown interface
- template<typename T> class UnknownPtr: A generic smart pointer for COM interfaces
- template< class InterfaceType > class IUnknownImplementation: An implementation of the IUnknown interface
HCCConverters.h: provides various overloads of:
```
  template <typename ResultType, typename ArgumentType>
  inline ResultType ConvertTo( ArgumentType arg )
```
implementing efficient and 'safe' conversion between basic data types.
HCCCRC.h: provides a few ways of calculating the CRC value for data
HCCCrypto.h: provides functionality for working with certificates
HCCCurrency.h: declares the Currency class
HCCDateTime.h: provides functionality for handling date and time, declares:
- class TimeSpan
- class DateTime
- class Stopwatch
HCCEnvironment.h: provides easy access to system information
HCCEse.h: provides C++ classes for working with the Extensible Storage Engine
HCCException.h: provides a wide range of exception classes
HCCGuid.h: functionality for working with UUIDs/GUIDs, declares class Guid
HCCHandle.h: declares template<typename DerivedT, typename HandleT> class Handle
HCCHTTP.h: provides C++ classes for working with the HTTP Server API
HCCIO.h: provides file, directory, and stream I/O related C++ classes
HCCIOContext.h: declares:
- class Context: uses a thread-pool to process asynchronous I/O for an I/O completion port
- class ContextHandler: An instance of the Context class delegates the work for a particular OS handle to the Process override implemented for a class derived from ContextHandler.
- template<typename DerivedT> FileHandler: A template derived from ContextHandler used to perform file related asynchronous I/O
- class FileRequest: Base class for file related asynchronous I/O requests
- class ReadFileRequest: Represents an asynchronous file read request
- class WriteFileRequest: Represents an asynchronous file write request
- class FileDispatcher: Derived from FileHandler, broadcasts I/O completion events to callbacks attached to boost::signals2::signal<> handlers
HCCLib.h: provides a number of useful functions:
- ByteSwap:
```
template<typename T>
    requires IsInteger<std::remove_cvref_t<T>>
inline constexpr T ByteSwap( T value )
```
  Swaps the bytes of the argument, which must be some type of integer. Performs this operation, if possible, at compile-time. If the operation must be performed at runtime, the implementation will call _byteswap_ushort, _byteswap_ulong, _byteswap_uint64, or just return the argument; based on the byte size of the argument type. ByteSwap for float, double and enums are implemented as:
```
template<typename T>
    requires (IsFloatingPoint<std::remove_cvref_t<T>> || 
              std::is_enum_v<std::remove_cvref_t<T>> )
inline constexpr T ByteSwap( const T value ) noexcept
{
    using Type = std::remove_cvref_t<T>;
    using UIntType = MakeUnsigned<Type>;
    std::bit_cast<Type>( ByteSwap( std::bit_cast<UIntType>( value ) ) );
}
```
- BitMask:
```
template<size_t N>
struct BitMask
{
    using type = ...
    static constexpr type value = ...;
};
```
  BitMask::type: is the type of the smallest unsigned integer capable of holding a bit-mask of N bits, where N <= 64.
  
  BitMask::value: is the value of the bit-mask with the N lowest bits set to 1.
- LengthOf: returns the number of elements in an array, length of a char or wchar_t zero-terminated string, or the number of elements in a container.
- template<typename T> inline int Compare( T v1, T v2 ) noexcept: compares two arguments of the same basic type, returning < 0 if the first value is considered to be less than the second; 0 if they are considered equal, and otherwise > 0. For char or wchar_t zero-terminated strings, nullptr is considered equal to a string with 0 length.
- AreNearlyEqual:
```
template<typename T>
    requires std::is_floating_point_v<T>
constexpr bool AreNearlyEqual( T a, T b, 
                               T smallNumber = static_cast<T>( 0.0001 ) ) noexcept
```
  returns true if the absolute value of the difference between a and b is less than smallNumber.
- class XXH64Hasher: use this class to incrementally generate a hash value from multiple inputs.
- IsPowerOfTwo: returns true if an integer is a power of 2.
- NextPowerOfTwo: returns the next higher value, that is a power of 2, greater than the argument.
HCCLMDB.h: declares a set of C++ classes for working with LMDB based on 3rdParty\Harlinn.LMDB
HCCLogger.h: logger implementation
HCCLogging.h: preprocessor macros used for logging

HCCMath.h: constexpr math, namespace: Harlinn::Common::Core::Math

IsSameValue:

constexpr bool IsSameValue( double x, double y ) noexcept;
constexpr bool IsSameValue( float x, float y ) noexcept;

Returns true if x and y holds the same value, even if they hold NaN values.

IsZero:

constexpr bool IsZero( double x ) noexcept;
constexpr bool IsZero( float x ) noexcept;

Returns true if x is 0.0 or -0.0.

signum:

template< typename T>
    requires IsUnsignedInteger<std::remove_cvref_t<T>> || 
             IsBoolean<std::remove_cvref_t<T>>
inline constexpr T signum( T val ) noexcept;

template< typename T>
    requires IsSignedInteger<std::remove_cvref_t<T>>
inline constexpr T signum( T val ) noexcept;

template< typename T>
    requires IsFloatingPoint<std::remove_cvref_t<T>>
inline constexpr T signum( T val ) noexcept;

Indicates the sign of val, returning -1, 0, or +1.

Deg2Rad:

template< typename T>
    requires IsFloatingPoint<std::remove_cvref_t<T>>
inline constexpr std::remove_cvref_t<T> Deg2Rad( T angleInDegrees ) noexcept;

Convert angleInDegrees from degrees to radians.

Rad2Deg:

template< typename T>
    requires IsFloatingPoint<std::remove_cvref_t<T>>
inline constexpr std::remove_cvref_t<T> Rad2Deg( T angleInRadians ) noexcept;

Convert angleInRadians from radians to degrees.

NextAfter:

inline constexpr double NextAfter( double x, double y ) noexcept;
inline constexpr double NextAfter( float x, float y ) noexcept;

Returns the next representable value of x in the direction of y.

NextDown:

template<typename T>
    requires IsFloatingPoint<T>
inline constexpr std::remove_cvref_t<T> NextDown( T x ) noexcept;

Returns the next representable value of x in the direction of negative infinity.

NextUp:

template<typename T>
    requires IsFloatingPoint<T>
inline constexpr std::remove_cvref_t<T> NextUp( T x ) noexcept;

Returns the next representable value of x in the direction of positive infinity.

IsNaN:

template<typename T>
    requires IsInteger<T>
constexpr inline bool IsNaN( T val ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline bool IsNaN( T val ) noexcept;

Returns true if val is NaN.

IsInf:

template<typename T>
    requires IsInteger<T>
constexpr inline bool IsInf( T val ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline bool IsInf( T val ) noexcept;

Returns true if val is infinite.

Abs:

template<typename T>
    requires IsSignedInteger<T>
constexpr inline std::remove_cvref_t<T> Abs( T val ) noexcept;

template<typename T>
    requires IsUnsignedInteger<T>
constexpr inline std::remove_cvref_t<T> Abs( T val ) noexcept;

template<typename T>
    requires IsFloatingPoint<T> 
constexpr inline std::remove_cvref_t<T> Abs( T val ) noexcept;

Returns the absolute value of val.

SignBit:

template<typename T>
    requires IsSignedInteger<T>
constexpr inline bool SignBit( T val ) noexcept;

template<typename T>
    requires IsUnsignedInteger<T>
constexpr inline bool SignBit( T val ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline bool SignBit( T val ) noexcept;

Returns true if the value of the sign of val is negative, otherwise false.

FRExp:

template<typename T>
    requires IsInteger<T>
constexpr inline std::pair<double,int> FRExp( T val ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::pair<double,int> FRExp( T val ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline double FRExp( T val, int* exp ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> FRExp( T val, int* exp ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline double FRExp( T val, int& exp ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> FRExp( T val, int& exp ) noexcept;

Return (result,exp) such that result has a magnitude in the interval [1/2, 1) or 0, and val is equal to result * 2^exp.

ModF:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::pair<std::remove_cvref_t<T>, 
                 std::remove_cvref_t<T>> ModF( T val ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ModF( T val, T* integerPart ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ModF( T val, T& integerPart ) noexcept;

Return a std::pair<T,T> of the fractional and integral parts of a number. Both parts have the same sign as the argument.

Min:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Min( T first, T second ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Min( T first, T second ) noexcept;

Returns the smaller of the argument values.

Max:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Max( T first, T second ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Max( T first, T second ) noexcept;

Returns the greater of the argument values.

Trunc:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Trunc( T val ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Trunc( T val ) noexcept;

Returns the nearest integral value of the same type as val whose absolute value is less than or equal to the absolute value of val.

Floor:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Floor( T val ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Floor( T val ) noexcept;

Returns the nearest integral value of the same type as val that is less than or equal to val.

Ceil:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Ceil( T val ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Ceil( T val ) noexcept;

Returns the nearest integral value of the same type as val that is greater than or equal to val.

Round:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Round( T val ) noexcept;

template<typename T>
    requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Round( T val ) noexcept;

Returns val rounded to the nearest integral value.

Clamp:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> 
          Clamp( T val, T minimumValue, T maximumValue ) noexcept;

template<typename T>
    requires ( IsInteger<T> )
constexpr inline std::remove_cvref_t<T> 
          Clamp( T val, T minimumValue, T maximumValue ) noexcept;

If val compares less than minimumValue, returns minimumValue; otherwise if maximumValue compares less than val, returns maximumValue; otherwise returns val.

Lerp:

template<typename T, typename U>
    requires ( ( IsInteger<T> || IsFloatingPoint<T> ) && 
               ( IsInteger<U> || IsFloatingPoint<U> ) )
constexpr inline std::conditional_t<IsFloatingPoint<T>, T, 
 std::conditional_t<IsFloatingPoint<U>, U, T>> Lerp( T a, T b, U t ) noexcept;

Computes the linear interpolation between a and b for the parameter t (or extrapolation, when t is outside the range [0,1]).

CopySign:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> 
          CopySign( T magnitude, T signValue ) noexcept;

Returns a value with the magnitude of magnitude and the sign of signValue.

ScaleByN:

inline constexpr double ScaleByN( double x, int n ) noexcept;
inline constexpr double ScaleByN( float x, int n ) noexcept;

Multiplies a floating point value x by FLT_RADIX raised to power n.

FMod:

inline constexpr double FMod( double x, double y ) noexcept;
inline constexpr float FMod( float x, float y ) noexcept;

Computes the floating-point remainder of the division operation x/y.

Exp:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Exp( T x ) noexcept;

Computes e (Euler's number, 2.7182818)) raised to the given power of x.

Hypot:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Hypot( T x, T y ) noexcept;

Computes the hypotenuse.

Log:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Log( T x ) noexcept;

Computes the natural (base e)) logarithm of x.

Log2:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Log2( T x ) noexcept;

Computes the base 2 logarithm of x.

Log10:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Log10( T x ) noexcept;

Computes the base 10 logarithm of x.

Sin:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Sin( T x ) noexcept;

Computes the sine of x, where x is in radians.

ASin:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ASin( T x ) noexcept;

Computes the inverse sine of x, in radians.

Cos:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Cos( T x ) noexcept;

Computes cosine of x, where x is in radians.

ACos:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ACos( T x ) noexcept;

Computes the inverse cosine of x, with the result in radians.

Tan:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Tan( T x ) noexcept;

Computes tangent of x, where x is in radians.

ATan, ATan2:

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ATan( T x ) noexcept;

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ATan( T x, T y ) noexcept

template<typename T>
    requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ATan2( T x, T y ) noexcept

Compute the inverse tangent of y or y/x, respectively.

SinCos:

template<typename T>
    requires IsFloatingPoint<T>
inline constexpr void SinCos( T x, T& sinResult, T& cosResult ) noexcept;

Simultaneously compute the sine and cosine of x, where x is in radians.

HCCObj.h: provides wrapper C++ classes for a wide range of Windows COM interfaces.
HCCObjBase.h: provides wrapper C++ classes for central Windows COM interfaces.
HCCObservable.h: declares template<typename DerivedT> class Observable and a couple macros that can be used to implement observable properties.
HCCPersistent.h: provides a flexible and efficient serialization and deserialization mechanism.
HCCPersistentDecoder.h: provides a generic decoder for data serialized using the mechanism provided in HCCPersistent.h.
HCCPipe.h: Synchronous and synchronous I/O using named pipes.
HCCProcess.h: classes for working with Windows processes.
HCCPropSys.h: classes for working with the (Windows Property System)[https://docs.microsoft.com/en-us/windows/win32/api/_properties/]
HCCReference.h: support for intrusive reference counted objects.
HCCSecurity.h: classes for working with Windows Security and identity
HCCShell.h: classes for working with the Windows Shell API).
HCCSocket.h: Synchronous and synchronous I/O using sockets.
HCCSync.h: classes for working with synchronization.
HCCThread.h: classes for working with threads.
HCCTraits.h: useful meta programming features.
HCCTuple.h: yet another tuple implementation.
HCCVariant.h: provides functionality for working with the VARIANT structure.
HCCVector.h: yet another vector implementation.
HCCXml.h: classes for working with the MSXML SDK).

Harlinn.Windows

Harlinn.Windows provides functionality for developing user interfaces in C++.

It is used to implement 73 of the examples.

Main Header Files

HWDXGI.h: provides support for the DirectX Graphics Infrastructure API.
HWGraphicsD3D12.h: provides support for the Direct3D 12 API.
HWGraphics.h: provides support for the Direct2D API.
HWDWrite.h: provides support for the DirectWrite API.
HWImaging.h: provides support for the Windows Imaging Component API
HWHandles.h: provides support for the Windows GDI API.
HWControl.h: provides support for working with Windows Controls
HWMessage.h: provides the Message class, a simple abstraction for the MSG structure
HWMenu.h: provides support for working with Windows Menus.
HWForm.h: provides support for working with top level Windows Controls using the Form class.
HWApplication.h: provides an Application class and a MessageLoop class.
HWDXApplication.h: declares some Direct3D 12 utility classes:
- class DXMessageLoop: The render/message loop.
- class DXContext: Initializes and manages interaction with the D3D12Device, the DXGI::SwapChain3, the D3D12GraphicsCommandList, and the few other objects required for interaction with the Direct3D 12 API.
- class DXApplication: Derived from Windows::Application, tailored for developing Direct3D 12 using Windows::Form.
HWStdCtrls.h: provides a number of classes for working with standard Windows controls. The provided functionality is, unfortunately, quite limited.
HWFileDialog.h: provides support for the Open and Save As functionality from the Common Dialog Box Library.
HWEnvironment.h: provides easy access to system information.
HWSkia.h: provides support for creating Skia based applications.
HWImGui.h: provides support for creating Dear ImGui based applications.

HWControl.h, HWMessage.h, HWMenu.h, HWForm.h, HWApplication.h, HWStdCtrls.h, HWFileDialog.h, HWSkia.h are meant to be used together, while HWDXGI.h, HWGraphicsD3D12.h, HWGraphics.h, HWImaging.h and HWHandles.h can be used on their own.

These days, I often use the slightly modified version of Dear ImGui and ImPlot located under 3rdParty\Harlinn.ImGui to create user interfaces for my Harlinn\:\:Windows\:\:Form based applications.

#include "HWDXApplication.h"
#include "HWImGui.h"
#include "HWmenu.h"
#include "HWstdctrls.h"
#include <iostream>

using namespace Harlinn;

int main()
{
    try
    {
        Windows::ApplicationOptions applicationOptions;
        applicationOptions.Load( );
        Windows::ImGui::Application application( applicationOptions );
        application.Start( );

        Windows::ImGui::Form form;
        form.SetText( L"ImGui & ImPlot Demo" );

        bool showImGuiDemoWindow = true;
        bool showImPlotDemoWindow = true;
        bool showAnotherWindow = false;

        form.OnRender.connect( [&showImGuiDemoWindow,&showImPlotDemoWindow, 
                                &showAnotherWindow]( Windows::ImGui::Form* sender )
        {
            if ( showImGuiDemoWindow )
            {
                ImGui::ShowDemoWindow( &showImGuiDemoWindow );
            }
            if ( showImPlotDemoWindow )
            {
                ImPlot::ShowDemoWindow( &showImPlotDemoWindow );
            }
        } );

        auto result = application.Run( form );

        application.Stop( );

        return result;
    }
    catch ( std::exception& exc )
    {
        std::cout << exc.what( ) << std::endl;
    }
    catch ( ... )
    {
        std::cout << "Unknown exception" << std::endl;
    }
    return 0;
}

Harlinn.OCI

Harlinn.OCI provides high performance access to the Oracle RDBMS using the Oracle OCI API.

Harlinn.ODBC

Harlinn.ODBC provides high performance access to database servers and engines through the ODBC API.

Harlinn.Common.Config

This library implements an in-memory hierarchical storage suitable for handling configuration information.

Harlinn.Julia

This library provides easy access to Julia.

3^rd Party Libraries

This solution contains a few useful C and C++ libraries located under the 3rdParty folder.

Header only libraries are contained within ''Static library (.lib)'' projects, everything else creates a DLL.

All C++ code compiles using /std:c++latest and /Zc:__cplusplus

abseil

Version: 20210324.2

Description

Abseil is an open source collection of C++ libraries drawn from the most fundamental pieces of Google’s internal code-base. These libraries are the nuts-and-bolts that underpin almost everything Google runs. Bits and pieces of these APIs are embedded in most of our open source projects, and Abseil aims to bring them together into one comprehensive project. Abseil encompasses the most basic building blocks of Google’s code-base: code that is production-tested and will be fully maintained for years to come.

Projects

Harlinn.abseil
Tests\3rdParty\abseil\abseil_test

The abseil_test contains the unit tests for the Harlinn.abseil project

libaec - Adaptive Entropy Coding library

Version: master as of 2021.08.26

Description

Libaec provides fast lossless compression of 1 up to 32 bit wide signed or unsigned integers (samples).

Project: Harlinn.aec

ANGLE - Almost Native Graphics Layer Engine

Version: master as of 2021.09.20

Description

The goal of ANGLE is to allow users of multiple operating systems to seamlessly run WebGL and other OpenGL ES content by translating OpenGL ES API calls to one of the hardware-supported APIs available for that platform. ANGLE currently provides translation from OpenGL ES 2.0, 3.0 and 3.1 to Vulkan, desktop OpenGL, OpenGL ES, Direct3D 9, and Direct3D 11.

Projects

Harlinn.angle
Harlinn.angle-egl
Harlinn.angle-gl
Harlinn.angle-glesv1
Harlinn.angle-glesv2
Harlinn.angle-opencl
Harlinn.angle-util

Alliance for Open Media - AV1 Codec Library

Version: 3.1.2

Description

AV1 Codec Library

Project: Harlinn.aom

Armadillo: C++ Library for Linear Algebra & Scientific Computing

Version: 10.6.x

Description

Armadillo is a high quality linear algebra library (matrix maths) for the C++ language, aiming towards a good balance between speed and ease of use

Provides high-level syntax and functionality deliberately similar to Matlab

Useful for algorithm development directly in C++, or quick conversion of research code into production environments

Provides efficient classes for vectors, matrices and cubes; dense and sparse matrices are supported

Integer, floating point and complex numbers are supported

A sophisticated expression evaluator (based on template meta-programming) automatically combines several operations to increase speed and efficiency

Various matrix decompositions (eigen, SVD, QR, etc) are provided through integration with LAPACK, or one of its high performance drop-in replacements (eg. MKL or OpenBLAS)

Can automatically use OpenMP multi-threading (parallelisation) to speed up computationally expensive operations

Distributed under the permissive Apache 2.0 license, useful for both open-source and proprietary (closed-source) software

Can be used for machine learning, pattern recognition, computer vision, signal processing, bioinformatics, statistics, finance, etc

Project: Harlinn.armadillo

cpp-base64

Version: 2.0.rc8

Description

Base64 encoding and decoding with c++.

Project: Harlinn.base64

BoringSSL

Version: master as of 2021.09.20

Description

BoringSSL is a fork of OpenSSL that is designed to meet Google's needs.

Projects

Harlinn.boringssl
Tests\3rdParty\boringssl\crypto_test
Tests\3rdParty\boringssl\ssl_test

Brotli

Version: master as of 2021.08.04

Description

Brotli is a generic-purpose lossless compression algorithm that compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding and 2nd order context modeling, with a compression ratio comparable to the best currently available general-purpose compression methods. It is similar in speed with deflate but offers more dense compression.

Project: Harlinn.brotli

Bullet Physics SDK

Version: 3.21

Description

Real-time collision detection and multi-physics simulation for VR, games, visual effects, robotics, machine learning etc.

Project: Harlinn.bullet

Inverse Kinematics

Version: from bullet 3.21

Description

Selectively Damped Least Squares for Inverse Kinematics.

Project: Harlinn.BussIK

bzip2

Version: 1.0.8

Description

bzip2 is a freely available, patent free (see below), high-quality data compressor. It typically compresses files to within 10% to 15% of the best available techniques (the PPM family of statistical compressors), whilst being around twice as fast at compression and six times faster at decompression.

Project: Harlinn.bzip2

c-ares is a C library for asynchronous DNS requests (including name resolves)

Version: 1.17.0

Description

c-ares is a C library for asynchronous DNS requests (including name resolves)

Project: Harlinn.c-ares

CFITSIO - A FITS File Subroutine Library

Version: 4.0.0

Description

CFITSIO is a library of C and Fortran subroutines for reading and writing data files in FITS (Flexible Image Transport System) data format. CFITSIO provides simple high-level routines for reading and writing FITS files that insulate the programmer from the internal complexities of the FITS format. CFITSIO also provides many advanced features for manipulating and filtering the information in FITS files.

Project: Harlinn.cfitsio

Advanced DXTn Texture Compression Library

Version: 1.04

Description

crnlib is a lossy texture compression library for developers that ship content using the DXT1/5/N or 3DC compressed color/normal map/cubemap mipmapped texture formats.

It can compress mipmapped 2D textures, normal maps, and cubemaps to approx. 1-1.25 bits/texel, and normal maps to 1.75-2 bits/texel. The actual bitrate depends on the complexity of the texture itself, the specified quality factor/target bitrate, and ultimately on the desired quality needed for a particular texture.

Project: Harlinn.crnlib

clsocket

Version: 1.41.1

Description

Provides a mechanism for writing cross platform socket code. This library was originally written to only support blocking TCP sockets. Over the years it has been extended to support UDP and RAW sockets as well.

Project: Harlinn.clsocket

crossguid

Version: 0.2.2

Description

CrossGuid is a minimal, cross platform, C++ GUID library. It uses the best native GUID/UUID generator on the given platform and has a generic class for parsing, stringifying, and comparing IDs. The guid generation technique is determined by your platform.

Project: Harlinn.crossguid

libcurl - the multiprotocol file transfer library

Version: 7.78.0

Description

libcurl is a free and easy-to-use client-side URL transfer library, supporting DICT, FILE, FTP, FTPS, GOPHER, GOPHERS, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, MQTT, POP3, POP3S, RTMP, RTMPS, RTSP, SCP, SFTP, SMB, SMBS, SMTP, SMTPS, TELNET and TFTP. libcurl supports SSL certificates, HTTP POST, HTTP PUT, FTP uploading, HTTP form based upload, proxies, HTTP/2, HTTP/3, cookies, user+password authentication (Basic, Digest, NTLM, Negotiate, Kerberos), file transfer resume, http proxy tunneling and more!

Project: Harlinn.curl

D3D12 Memory Allocator

Version: 2.0.0-development (2021-07-26)

Description

Easy to integrate memory allocation library for Direct3D 12

Project: Harlinn.d3d12allocator

libdeflate

Version: 1.8

Description

libdeflate is a library for fast, whole-buffer DEFLATE-based compression and decompression

Project: Harlinn.deflate

Adobe Digital Negative (DNG) SDK

Version: 1.5.1

Description

The DNG SDK provides support for reading and writing DNG files as well as for converting DNG data to a format that is easily displayed or processed by imaging applications.

Project: Harlinn.dngsdk

Effcee

Version: main as of 2021.09.27

Description

Effcee is a C++ library for stateful pattern matching of strings, inspired by LLVM's FileCheck command.

Project: Harlinn.effcee

Eigen

Version: 3.4.0

Description

Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms.

Project: Harlinn.Eigen

ENet

Version: 1.3.17

Description

ENet's purpose is to provide a relatively thin, simple and robust network communication layer on top of UDP (User Datagram Protocol). The primary feature it provides is optional reliable, in-order delivery of packets.

Project: Harlinn.enet

Expat

Version: 2.4.1

Description

This is Expat, a C library for parsing XML, started by James Clark in 1997. Expat is a stream-oriented XML parser. This means that you register handlers with the parser before starting the parse. These handlers are called when the parser discovers the associated structures in the document being parsed. A start tag is an example of the kind of structures for which you may register handlers.

Project: Harlinn.expat

FlatBuffers

Version: 2.0.0

Description

FlatBuffers is an efficient cross platform serialization library for C++, C#, C, Go, Java, Kotlin, JavaScript, Lobster, Lua, TypeScript, PHP, Python, Rust and Swift. It was originally created at Google for game development and other performance-critical applications.

Project: Harlinn.flatbuffers

Freetype

Version: 2.11.0

Description

FreeType is a freely available software library to render fonts.

It is written in C, designed to be small, efficient, highly customizable, and portable while capable of producing high-quality output (glyph images) of most vector and bitmap font formats.

Project: Harlinn.freetype

GDAL - Geospatial Data Abstraction Library

Version: 3.4.0

Description

GDAL is a translator library for raster and vector geospatial data formats that is released under an X/MIT style Open Source License by the Open Source Geospatial Foundation. As a library, it presents a single raster abstract data model and single vector abstract data model to the calling application for all supported formats.

Project: Harlinn.gdal

GEOS - Coordinate Transformation Software Library

Version: 3.4.0

Description

GEOS is a C/C++ library for spatial computational geometry of the sort generally used by “geographic information systems” software.

Project: Harlinn.geos

Google gflags

Version: 2.2.2

Description

Gflags, the commandline flags library used within Google, differs from other libraries, such as getopt(), in that flag definitions can be scattered around the source code, and not just listed in one place such as main(). In practice, this means that a single source-code file will define and use flags that are meaningful to that file. Any application that links in that file will get the flags, and the gflags library will automatically handle that flag appropriately.

There's significant gain in flexibility, and ease of code reuse, due to this technique.

Project: Harlinn.gflags

Giflib

Version: 5.2.1

Project: Harlinn.gif

Description

giflib is a library for reading and writing gif images.

Glad

Version: generated by glad 0.1.35 on Sun Dec 26 15:01:04 2021

Description

GLSC2, OpenGL, OpenGL ES loader generated by glad 0.1.35 on Sun Dec 26 15:01:04 2021 using the Multi-Language GL/GLES/EGL/GLX/WGL Loader-Generator based on the official specs.

Project: Harlinn.glad

GLFW - multi-platform library for OpenGL, OpenGL ES and Vulkan development on the desktop

Version: 3.3.4

Description

GLFW is an Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan development on the desktop. It provides a simple API for creating windows, contexts and surfaces, receiving input and events.

Project: Harlinn.glfw

Glslang

Version: 2020.07.28

Description

Reference Validator and GLSL/ESSL -> AST Front End

An OpenGL GLSL and OpenGL|ES GLSL (ESSL) front-end for reference validation and translation of GLSL/ESSL into an internal abstract syntax tree (AST).

HLSL -> AST Front End

An HLSL front-end for translation of an approximation of HLSL to glslang's AST form.

AST -> SPIR-V Back End

Translates glslang's AST to the Khronos-specified SPIR-V intermediate language.

Reflector

An API for getting reflection information from the AST, reflection types/variables/etc. from the HLL source (not the SPIR-V).

Project: Harlinn.glslang

gRPC

Version: 1.41.1

Description

gRPC is a modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment. It can efficiently connect services in and across data centers with pluggable support for load balancing, tracing, health checking and authentication. It is also applicable in last mile of distributed computing to connect devices, mobile applications and browsers to backend services.

Projects

Harlinn.grpc
Harlinn.grpc-compiler
Tools\3rdParty\grpc\gen_hpack_tables
Tools\3rdParty\grpc\grpc_cpp_plugin
Tools\3rdParty\grpc\grpc_csharp_plugin
Tools\3rdParty\grpc\grpc_node_plugin
Tools\3rdParty\grpc\grpc_objective_c_plugin
Tools\3rdParty\grpc\grpc_php_plugin
Tools\3rdParty\grpc\grpc_python_plugin
Tools\3rdParty\grpc\grpc_ruby_plugin
Tests\3rdParty\gRPC\core\address_utils\grpc_test_core_address_utils_parse_address_test
Tests\3rdParty\gRPC\core\address_utils\grpc_test_core_address_utils_parse_address_with_named_scope_id_test
Tests\3rdParty\gRPC\core\address_utils\grpc_test_core_address_utils_sockaddr_utils_test
Tests\3rdParty\gRPC\core\avl\grpc_test_avl_avl_test
Tests\3rdParty\gRPC\core\backoff\grpc_test_backoff_backoff_test
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_badreq
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_bad_streaming_id
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_connection_prefix
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_duplicate_header
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_headers
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_head_of_line_blocking
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_initial_settings_frame
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_large_metadata
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_out_of_bounds
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_server_registered_method
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_simple_request
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_unknown_frame
Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_window_overflow
Tests\3rdParty\gRPC\core\bad_connection\grpc_test_bad_connection_close_fd_test
Tests\3rdParty\gRPC\core\bad_ssl\grpc_test_bad_ssl_alpn_server_test
Tests\3rdParty\gRPC\core\bad_ssl\grpc_test_bad_ssl_bad_ssl_test
Tests\3rdParty\gRPC\core\bad_ssl\grpc_test_bad_ssl_cert_server_test
Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_args_test
Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_stack_builder_test
Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_stack_test
Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_trace_test
Tests\3rdParty\gRPC\core\channel\grpc_test_core_channelz_registry_test
Tests\3rdParty\gRPC\core\channel\grpc_test_core_channelz_test
Tests\3rdParty\gRPC\core\channel\grpc_test_core_channel_status_util_test
Tests\3rdParty\gRPC\core\channel\grpc_test_core_minimal_stack_is_minimal_test
Tests\3rdParty\gRPC\core\client_channel\grpc_test_core_client_channel_certificate_provider_registry_test
Tests\3rdParty\gRPC\core\client_channel\grpc_test_core_client_channel_retry_throttle_test
Tests\3rdParty\gRPC\core\client_channel\grpc_test_core_client_channel_service_config_test
Tests\3rdParty\gRPC\core\client_channel\resolvers\dns_resolver_connectivity_test
Tests\3rdParty\gRPC\core\client_channel\resolvers\dns_resolver_cooldown_test
Tests\3rdParty\gRPC\core\client_channel\resolvers\grpc_test_dns_resolver_test
Tests\3rdParty\gRPC\core\client_channel\resolvers\grpc_test_fake_resolver_test
Tests\3rdParty\gRPC\core\client_channel\resolvers\grpc_test_sockaddr_resolver_test
Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_algorithm_test
Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_compression_test
Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_message_compress_test
Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_stream_compression_test
Tests\3rdParty\gRPC\core\config\grpc_test_core_config_core_configuration_test
Tests\3rdParty\gRPC\core\debug\grpc_test_core_debug_stats_test
Tests\3rdParty\gRPC\core\event_engine\grpc_test_core_event_engine_endpoint_config_test
Tests\3rdParty\gRPC\core\fling\fling_client
Tests\3rdParty\gRPC\core\fling\fling_server
Tests\3rdParty\gRPC\core\fling\grpc_test_core_fling_fling_stream_test
Tests\3rdParty\gRPC\core\fling\grpc_test_core_fling_fling_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_alloc_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_arena_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_cpu_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_env_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_log_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_murmur_hash_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_spinlock_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_string_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_sync_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_time_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_tls_test
Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_useful_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_bitset_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_capture_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_dual_ref_counted_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_examine_stack_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_fork_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_global_config_env_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_global_config_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_host_port_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_manual_constructor_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_match_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_mpscq_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_orphanable_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_overload_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_ref_counted_ptr_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_ref_counted_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_status_helper_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_stat_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_table_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_thd_test
Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_time_util_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_combiner_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_endpoint_pair_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_error_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_grpc_ipv6_loopback_available_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_load_file_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_mpmcqueue_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_pollset_windows_starvation_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_resolve_address_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_resource_quota_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_threadpool_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_timer_heap_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_timer_list_test
Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_time_averaged_stats_test
Tests\3rdParty\gRPC\grpc_test_core_util

libgta - Generic Tagged Arrays

Version: 1.2.1

Description

Libgta, a library that reads and writes GTA files.

Project: Harlinn.gta

GoogleTest

Version: 1.11.0

Description

GoogleTest is Google’s C++ testing and mocking framework.

Project: Harlinn.gtest

GWEN

Version: from bullet 3.21

Description

A C++ GUI library.

Project: Harlinn.gwen

HarfBuzz, a Text Shaping Library

Version: 3.0.0

Description

HarfBuzz is a text shaping library. Using the HarfBuzz library allows programs to convert a sequence of Unicode input into properly formatted and positioned glyph output—for any writing system and language.

Project: Harlinn.harfbuzz

HDF

Version: 4.2.15

Description

The Hierarchical Data Format, or HDF, is a multiobject file format for sharing scientific data in a distributed environment. HDF was created at the National Center for Supercomputing Applications, and is now developed and maintained by The HDF Group, to serve the needs of diverse groups of scientists working on projects in various fields

Project: Harlinn.hdf4

HDF5

Version: 1.12.1

Description

The HDF Group is the developer of HDF5®, a high-performance software library and data format that has been adopted across multiple industries and has become a de facto standard in scientific and research communities.

Project: Harlinn.hdf5

Highway

Version: 0.14.2

Description

Highway is a C++ library for SIMD (Single Instruction, Multiple Data), i.e. applying the same operation to multiple 'lanes' using a single CPU instruction.

Project: Harlinn.highway

Imath

Version: master as of 2021.08.18

Description

Imath is a basic, light-weight, and efficient C++ representation of 2D and 3D vectors and matrices and other simple but useful mathematical objects, functions, and data types common in computer graphics applications, including the “half” 16-bit floating-point type.

Project: Harlinn.imath

Dear ImGui and ImPlot

Version: master as of 2021.07.14

Description: Packages Dear ImGui and ImPlot as a single DLL.

Description 'Dear ImGui':

Dear ImGui is a bloat-free graphical user interface library for C++. It outputs optimized vertex buffers that you can render anytime in your 3D-pipeline enabled application.

Description 'ImPlot':

ImPlot is an immediate mode, GPU accelerated plotting library for Dear ImGui. It aims to provide a first-class API that ImGui fans will love. ImPlot is well suited for visualizing program data in real-time or creating interactive plots, and requires minimal code to integrate.

Project: Harlinn.ImGui

JasPer Image Processing/Coding Tool Kit

Version: 2.0.33

Description

JasPer Image Processing/Coding Tool Kit

Project: Harlinn.jasper

The Independent JPEG Group's JPEG software

Version: 9d

Description

IJG is an informal group that writes and distributes a widely used free library for JPEG image compression.

Project: Harlinn.jpeg

libjpeg-turbo

Version: 2.1.1

Description

libjpeg-turbo is a JPEG image codec that uses SIMD instructions (MMX, SSE2, AVX2, Neon, AltiVec) to accelerate baseline JPEG compression and decompression on x86, x86-64, Arm, and PowerPC systems, as well as progressive JPEG compression on x86 and x86-64 systems. On such systems, libjpeg-turbo is generally 2-6x as fast as libjpeg, all else being equal. On other types of systems, libjpeg-turbo can still outperform libjpeg by a significant amount, by virtue of its highly-optimized Huffman coding routines. In many cases, the performance of libjpeg-turbo rivals that of proprietary high-speed JPEG codecs.

libjpeg-turbo implements both the traditional libjpeg API as well as the less powerful but more straightforward TurboJPEG API. libjpeg-turbo also features colorspace extensions that allow it to compress from/decompress to 32-bit and big-endian pixel buffers (RGBX, XBGR, etc.), as well as a full-featured Java interface.

Project: Harlinn.jpeg-turbo

JSON-C - A JSON implementation in C

Version: master as of 2021.08.01

Description

A JSON implementation in C.

Project: Harlinn.json-c

JsonCpp

Version: 1.9.4

Description

JsonCpp is a C++ library that allows manipulating JSON values, including serialization and deserialization to and from strings. It can also preserve existing comment in unserialization/serialization steps, making it a convenient format to store user input files.

Project: Harlinn.jsoncpp

JPEG XL Reference Implementation

Version: 0.6.1

Description

A reference implementation of JPEG XL (encoder and decoder), called libjxl.

Project: Harlinn.jxl

kml

Version: 1.3.0

Description

This is Google's reference implementation of OGC KML 2.2.

Projects

Harlinn.kmlbase
Harlinn.kmlconvenience
Harlinn.kmldom
Harlinn.kmlengine
Harlinn.kmlregionator
Harlinn.kmlxsd

Little CMS

Version: 2.12

Description

Little CMS intends to be an OPEN SOURCE small-footprint color management engine, with special focus on accuracy and performance. It uses the International Color Consortium standard (ICC), which is the modern standard when regarding to color management. The ICC specification is widely used and is referred to in many International and other de-facto standards. It was approved as an International Standard, ISO 15076-1, in 2005.

Project: Harlinn.lcms2

LERC - Limited Error Raster Compression

Version: 3.0

Description

LERC is an open-source image or raster format which supports rapid encoding and decoding for any pixel type (not just RGB or Byte).

Project: Harlinn.Lerc

libde265 - open h.265 codec implementation

Version: 1.0.8

Description

libde265 is an open source implementation of the h.265 video codec. It is written from scratch and has a plain C API to enable a simple integration into other software.

libde265 supports WPP and tile-based multithreading and includes SSE optimizations. The decoder includes all features of the Main profile and correctly decodes almost all conformance streams

Project: Harlinn.libde265

FLAC - Free Lossless Audio Codec

Version: 1.3.2

Description

FLAC is an Open Source lossless audio codec

Project: Harlinn.libflac

libheif

Version: 1.12.0

Description

libheif is an ISO/IEC 23008-12:2017 HEIF and AVIF (AV1 Image File Format) file format decoder and encoder.

HEIF and AVIF are new image file formats employing HEVC (h.265) or AV1 image coding, respectively, for the best compression ratios currently possible.

Project: Harlinn.libheif

liblzma

Version: 5.2.5

Description

LZMA Utils is an attempt to provide LZMA compression to POSIX-like systems. The idea is to have a gzip-like command line tool and a zlib-like library, which would make it easy to adapt the new compression technology to existing applications.

Project: Harlinn.liblzma

libmysofa

Version: 1.2.1

Description

This is a simple set of C functions to read AES SOFA files, if they contain HRTFs stored according to the AES69-2015 standard.

Project: Harlinn.libmysofa

libogg

Version: 1.3.5

Description

Ogg is a multimedia container format, and the native file and stream format for the Xiph.org multimedia codecs.

Project: Harlinn.libogg

LIBSVM -- A Library for Support Vector Machines

Version: 3.16

Description

LIBSVM is an integrated software for support vector classification, (C-SVC, nu-SVC), regression (epsilon-SVR, nu-SVR) and distribution estimation (one-class SVM). It supports multi-class classification.

Project: Harlinn.libsvm

VMAF - Video Multi-Method Assessment Fusion

Version: 2.2.0

Description

VMAF is a perceptual video quality assessment algorithm developed by Netflix.

Project: Harlinn.libvmaf

Libxml2

Version: 2.9.12

Description

Libxml2 is the XML C parser and toolkit developed for the Gnome project.

Project: Harlinn.libxml2

Lightning Memory-Mapped Database

Version: 0.9.70

Description

An ultra-fast, ultra-compact, crash-proof, key-value, embedded data store

Project: Harlinn.LMDB

LodePNG - PNG encoder and decoder in C and C++, without dependencies

Version: 20200215

Description

LodePNG is a PNG image decoder and encoder, all in one, no dependency or linkage to zlib or libpng required.

Project: Harlinn.lodepng

LZ4 - Extremely Fast Compression

Version: 1.9.3

Description

LZ4 is lossless compression algorithm, providing compression speed > 500 MB/s per core, scalable with multi-cores CPU. It features an extremely fast decoder, with speed in multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.

Project: Harlinn.lz4

LZMA SDK

Version: 21.03

Description

LZMA / LZMA2 are default and general compression methods of 7z format in the 7-Zip program. LZMA provides a high compression ratio and fast decompression, so it is very suitable for embedded applications.

Project: Harlinn.lzma

Mesh Data Abstraction Library (MDAL)

Version: 0.8.1

Description

Mesh Data Abstraction Library.

Project: Harlinn.mdal

minizip

Version: 1.1

Description

This package enables to extract files from a .zip archive file.

Project: Harlinn.minizip

Unidata NetCDF

Version: TBD - this project is currently just a placeholder

Project: Harlinn.netcdf-c

JSON for Modern C++

Version: develop as of 2021.08.16

Description

JSON for Modern C++

Project: Harlinn.nlohmann-json

OpenAL Soft is an LGPL-licensed, cross-platform, software implementation of the OpenAL 3D audio API.

Version: 1.21.1

Description

OpenAL Soft is an LGPL-licensed, cross-platform, software implementation of the OpenAL 3D audio API.

OpenAL provides capabilities for playing audio in a virtual 3D environment. Distance attenuation, doppler shift, and directional sound emitters are among the features handled by the API.

Project: Harlinn.openal-soft

OpenCensus - A Stats Collection and Distributed Tracing Framework

Version: 0.4.0

Description

OpenCensus is a toolkit for collecting application performance and behavior data. It currently includes an API for tracing and stats.

Project: Harlinn.opencensus

OpenEXR

Version: master as of 2021.08.18

Description

OpenEXR provides the specification and reference implementation of the EXR file format, the professional-grade image storage format of the motion picture industry.

The purpose of EXR format is to accurately and efficiently represent high-dynamic-range scene-linear image data and associated metadata, with strong support for multi-part, multi-channel use cases.

Projects

Harlinn.iex
Harlinn.ilmthread
Harlinn.openexr
Harlinn.openexrcore
Harlinn.openexrutil

OpenFYBA

Version: 4.1.1

Description

OpenFYBA is the source code release of the FYBA library, distributed by the National Mapping Authority of Norway (Statens kartverk) to read and write files in the National geodata standard format SOSI.

Project: Harlinn.openfyba

The Preview Image Extractor (PIEX)

Version: master as of 2021.09.24

Description

The Preview Image Extractor (PIEX) is designed to find and extract the largest JPEG compressed preview image contained in a RAW file.

Project: Harlinn.piex

libpng

Version: 1.6.37

Description

libpng is the official PNG reference library. It supports almost all PNG features, is extensible, and has been extensively tested for over 23 years.

Project: Harlinn.png

PROJ is a Generic Coordinate Transformation Software

Version: 8.1.0

Description

PROJ is a generic coordinate transformation software that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations.

Project: Harlinn.proj

Protocol Buffers

Version: 3.17.3

Description

Protocol buffers are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler. You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages.

Projects

Harlinn.protobuf
Tools\3rdParty\protobuf\protoc

pthreads4w

Version: 3.0.0

Description

Also known as "pthreads-win32", POSIX Threads for Windows implements a large subset of the threads related API from the Single Unix Specification Version 3.

Conformance and quality are high priorities of this mature library. Development began in 1998 and has continued with numerous significant professional contributions.

Project: Harlinn.pthreads4w

Qpid Proton - The AMQP Messaging Toolkit

Version: 0.35.0

Description

Qpid Proton is a high-performance, lightweight messaging library. It can be used in the widest range of messaging applications, including brokers, client libraries, routers, bridges, proxies, and more. Proton makes it trivial to integrate with the AMQP 1.0 ecosystem from any platform, environment, or language.

Projects

Harlinn.qpid-proton
Harlinn.qpid-proton-cpp

RapidJSON

Version: master as of 2021.09.26

Description

A fast JSON parser/generator for C++ with both SAX/DOM style API.

Project: Harlinn.RapidJSON

RE2 - A Regular Expression Library

Version: 2021-09-01

Description

RE2 was designed and implemented with an explicit goal of being able to handle regular expressions from untrusted users without risk. One of its primary guarantees is that the match time is linear in the length of the input string. It was also written with production concerns in mind: the parser, the compiler and the execution engines limit their memory usage by working within a configurable budget – failing gracefully when exhausted – and they avoid stack overflow by eschewing recursion.

Project: Harlinn.re2

RocksDB: A Persistent Key-Value Store for Flash and RAM Storage

Version: 6.26.1

Description

RocksDB is a storage engine with key/value interface, where keys and values are arbitrary byte streams. It is a C++ library. It was developed at Facebook based on LevelDB and provides backwards-compatible support for LevelDB APIs.

RocksDB supports various storage hardware, with fast flash as the initial focus. It uses a Log Structured Database Engine for storage, is written entirely in C++

Project: Harlinn.rocksdb

Scintilla - A Free Source Code Editing Component

Version: 5.1.3

Description

Scintilla is a free source code editing component. It comes with complete source code and a license that permits use in any free project or commercial product.

As well as features found in standard text editing components, Scintilla includes features especially useful when editing and debugging source code. These include support for syntax styling, error indicators, code completion and call tips. The selection margin can contain markers like those used in debuggers to indicate breakpoints and the current line. Styling choices are more open than with many editors, allowing the use of proportional fonts, bold and italics, multiple foreground and background colours and multiple fonts.

Project: Harlinn.scintilla

Simple DirectMedia Layer (SDL) Version 2.0

Version: 2.0.16

Description

Simple DirectMedia Layer is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D.

Project: Harlinn.SDL2

Simple and Fast Multimedia Library

Version: 2.5.1

Description

SFML provides a simple interface to the various components of your PC, to ease the development of games and multimedia applications. It is composed of five modules: system, window, graphics, audio and network.

Projects

Harlinn.sfml-audio
Harlinn.sfml-graphics
Harlinn.sfml-network
Harlinn.sfml-system
Harlinn.sfml-window

The sjpeg Library

Version: master as of 2021.09.11

Description

sjpeg is a simple encoding library for encoding baseline JPEG files.

Project: Harlinn.sjpeg

skcms

Version: main as of 2021.09.12

Description: Skia Color Management

Project: Harlinn.skcms

Skia - The 2D Graphics Library

Version: 0.31

Description

Skia is an open source 2D graphics library which provides common APIs that work across a variety of hardware and software platforms. It serves as the graphics engine for Google Chrome and Chrome OS, Android, Flutter, Mozilla Firefox and Firefox OS, and many other products.

Projects

Harlinn.skia
Tools\3rdParty\Skia\skslc

Snappy - A Compression/Decompression Library

Version: master as of 2021.08.02

Description

Snappy is a compression/decompression library. It does not aim for maximum compression, or compatibility with any other compression library; instead, it aims for very high speeds and reasonable compression. For instance, compared to the fastest mode of zlib, Snappy is an order of magnitude faster for most inputs, but the resulting compressed files are anywhere from 20% to 100% bigger.

Project: Harlinn.snappy

SPIRV-Cross

Version: Version used for MoltenVK 1.1.5 release

Description

SPIRV-Cross is a tool designed for parsing and converting SPIR-V to other shader languages.

Project: Harlinn.spirv-cross

SPIR-V Headers

Version: 1.5.4

Description: The header files from https://github.com/KhronosGroup/SPIRV-Headers

Project: Harlinn.spirv-headers

SPIR-V Tools

Version: 2021.3

Description

The project includes an assembler, binary module parser, disassembler, validator, and optimizer for SPIR-V.

Project: Harlinn.spirv-tools

sqlite3

Version: 3.36.0

Description

SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine.

Projects

Harlinn.SQLite3
Tools\3rdParty\SQLite3\sqlite3

Single-File Public-domain/Open Source Libraries with Minimal Dependencies (STB)

Version: master as of 2021.09.10

Description

Small, easy-to-integrate, portable libraries which are usable from C and/or C++

Project: Harlinn.stb

SuperLU

Version: 5.2.2

Description

SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations.

Project: Harlinn.superlu

LibTIFF

Version: 4.3.0

Description

This software provides support for the Tag Image File Format (TIFF), a widely used format for storing image data.

Project: Harlinn.tiff

TinyXML-2

Version: master as of 2021.06.07

Description

TinyXML-2 is a simple, small, efficient, C++ XML parser that can be easily integrated into other programs.

Project: Harlinn.tinyxml2

μpb: small, fast C protos

Version: master as of 2021.10.21

Description

μpb (often written 'upb') is a small protobuf implementation written in C.

Projects

Harlinn.upb
Tools\3rdParty\upb\protoc-gen-upb
Tools\3rdParty\upb\protoc-gen-upbdefs

uriparser

Version: 0.9.5

Description

uriparser is a strictly RFC 3986 compliant URI parsing and handling library written in C89 ("ANSI C").

Project: Harlinn.uriparser

libvorbis, libvorbisfile and libvorbisenc

Version: 1.3.7

Description

Vorbis is a general purpose audio and music encoding format contemporary to MPEG-4's AAC and TwinVQ, the next generation beyond MPEG audio layer 3.

Project: Harlinn.vorbis

Vulkan Header Files

Version: main as of 2021.09.21

Description

Vulkan header files

Project: Harlinn.vulkan

Vulkan Memory Allocator

Version: 2.3.0

Description

The Vulkan® Memory Allocator (VMA) library provides a simple and easy to integrate API to help you allocate memory for Vulkan® buffer and image storage.

Project: Harlinn.vulkanmemoryallocator

libwebm

Version: main as of 2021.09.08

Description

The WebM Project is dedicated to developing a high-quality, open video format for the web that's freely available to everyone.

Project: Harlinn.webm

WebP - An Image Format for the Web

Version: main as of 2021.09.08

Description

WebP is a modern image format that provides superior lossless and lossy compression for images on the web. Using WebP, webmasters and web developers can create smaller, richer images that make the web faster.

Project: Harlinn.webp

Xerces-C++ - a validating XML parser

Version: 3.2.3

Description

Xerces-C++ is a validating XML parser written in a portable subset of C++. Xerces-C++ makes it easy to give your application the ability to read and write XML data.

Project: Harlinn.xerces-c

XMP-Toolkit-SDK

Version: 6.0.0

Description

The XMP Toolkit allows you to integrate XMP functionality into your product or solution.

Project: Harlinn.xmptoolkitsdk

libyuv

Version: main as of 2021-09-07

Description

libyuv is an open source project that includes YUV scaling and conversion functionality.

Project: Harlinn.yuv

zlib

Version: 1.2.11

Description

zlib is designed to be a free, general-purpose, legally unencumbered -- that is, not covered by any patents -- lossless data-compression library for use on virtually any computer hardware and operating system.

Project: Harlinn.zlib

zlib-ng

Version: develop as of 2021.05.08

Description

zlib data compression library for the next generation systems

Project: Harlinn.zlibng

Zstandard (zstd)

Version: dev as of 2021.08.04

Description

Zstandard, or zstd as short version, is a fast lossless compression algorithm, targeting real-time compression scenarios at zlib-level and better compression ratios.

Project: Harlinn.zstd

2022.01.26

Improved the tests for BitVector (BitVectorTests.cpp) in Harlinn.Common.Core.Tests

2022.01.25

Added functionality to template<typename VectorT> BitVector
- Implemented template<typename T> void append( const T* bits, size_t bitCount )
- Implemented template<typename VectorU> void append( const BitVector<VectorU>& other )
Added unit more tests for BitVector to BitVectorTests.cpp in Harlinn.Common.Core.Tests

2022.01.24

Added functionality to template<typename VectorT> BitVector
- Implemented BitVector operator~( ) const
- Implemented template<typename VectorU> void And( const BitVector<VectorU>& other )
- Implemented template<typename VectorU> void Or( const BitVector<VectorU>& other )
- Implemented template<typename VectorU> void Xor( const BitVector<VectorU>& other )
- Implemented template<typename VectorU> BitVector& operator &= ( const BitVector<VectorU>& other )
- Implemented template<typename VectorU> BitVector& operator |= ( const BitVector<VectorU>& other )
- Implemented template<typename VectorU> BitVector& operator ^= ( const BitVector<VectorU>& other )
- Implemented bool all( ) const noexcept
- Implemented bool none( ) const noexcept
- Implemented bool any( ) const
Added unit more tests for BitVector to BitVectorTests.cpp in Harlinn.Common.Core.Tests

2022.01.23

Added functionality to template<typename VectorT> BitVector
- Implemented explicit operator bool( ) const noexcept
- Implemented constexpr bool empty( ) const noexcept
- Implemented BitVector constructors
- Implemented operator & ( const BitVector<VectorT>& lhs, const BitVector<VectorU>& rhs )
- Implemented operator | ( const BitVector<VectorT>& lhs, const BitVector<VectorU>& rhs )
- Implemented operator ^ ( const BitVector<VectorT>& lhs, const BitVector<VectorU>& rhs )
Added unit more tests for BitVector to BitVectorTests.cpp in Harlinn.Common.Core.Tests

2022.01.22

Added functionality to template<typename VectorT> BitVector
- Implemented void resize( size_t newSize, bool value = false )
- Implemented void emplace_back( bool value )
- Implemented void push_back( bool value )
- Implemented template<size_t N> void append( const Bits<N> values )
- Implemented template<typename T> void append( const T value, size_t bitCount = sizeof(T) * BitsPerByte )
- Implemented void flip( ) noexcept
- Implemented constexpr size_t capacity( ) const noexcept
- Implemented void reserve( size_t numberOfBits )
- Implemented void clear( )
- Implemented void swap( BitVector& other ) noexcept
- Implemented BitVector::reference
- Implemented reference operator[]( size_t index ) noexcept
- Implemented bool operator[]( size_t index ) const noexcept
- Implemented bool test( size_t index ) const noexcept
- Implemented template<typename VectorU> bool EqualTo( const BitVector<VectorU>& other ) const noexcept
- Implemented template<typename VectorU> bool operator == ( const BitVector<VectorU>& other ) const noexcept
- Implemented template<typename VectorU> bool operator != ( const BitVector<VectorU>& other ) const noexcept
- Implemented word_type* data( ) noexcept
- Implemented const word_type* data( ) const noexcept
- Implemented constexpr size_t size( ) const noexcept
- Implemented constexpr size_t DataSize( ) const noexcept
- Implemented const VectorType& Vector( ) const noexcept

2022.01.21

Improved the implementation of template<size_t bitCount> Bits
- Performance improvements for template<size_t bitCount> Bits::reference

2022.01.20

Added more unit tests for template<size_t bitCount> Bits to BitsTests.cpp in Harlinn.Common.Core.Tests
Added more performance tests for template<size_t bitCount> Bits to BitsOperations.cpp in HCCMathPerfTest01

2022.01.19

Added more unit tests for template<size_t bitCount> Bits to BitsTests.cpp in Harlinn.Common.Core.Tests

2022.01.18

Fixed a bug in template<size_t N> struct BitMask, which caused an overflow in the calculation of the bit-mask for N=8, N=16, N=32 and N=64 (HCCLib.h)
Implemented template<size_t bitCount> Bits
Added unit tests for template<size_t bitCount> Bits (BitsTests.cpp) to Harlinn.Common.Core.Tests
Added performance tests for template<size_t bitCount> Bits (BitsOperations.cpp) to HCCMathPerfTest01

2022.01.17

Added new header HCCBits.h
- Added template<size_t bitCount> Bits
  Like template< std::size_t N > class bitset this template implements a fixed size container for bits.
  
  This template uses the smallest unsigned integer capable of holding bitCount number of bits to hold its value. It implements an API similar to std::bitset. Since it uses an unsigned integer to store the bits, bitCount has to be less or equal to 64. This also makes most operations significantly faster than the same operation on a std::bitset. My primary use for this template is to parse a binary, fixed size, bit-mask received over the network.
- Added template<typename VectorT> BitVector
  Like template<class Allocator> class vector<bool, Allocator> this template implements a variable sized container for bits, but with an API that is similar to template<size_t bitCount> Bits. Unlike std::vector<bool>, BitVector lets me specify the container used to store the bits, which must be a std::vector like container of some integer type. My primary use for this template is to parse a binary, variable sized, bit-mask received over the network. The idea is to be able to use boost::container::small_vector to store the bit-mask, and avoid dynamic memory allocation for, perhaps, 99% of the received bit-masks.
Fixed a bug in FileSystemEntriesBase::Read( )

2022.01.16

Fixed bug in the declaration of the WideStringType concept in HCCTraits.h
Finished initial/minimal implementation of the classes in HCCwbem.h
Added initial implementation of missing wrappers for common COM interfaces:
- Added ServiceProvider to HCCObj.h

2022.01.15

Added initial implementation of missing wrappers for common COM interfaces:
- Added OleLink to HCCObj.h
- Added OleItemContainer to HCCObj.h
- Added OleInPlaceUIWindow to HCCObj.h
- Added OleInPlaceActiveObject to HCCObj.h
- Added OleInPlaceFrame to HCCObj.h
- Added Continue to HCCObj.h
- Added DropSource to HCCObj.h
- Added DropTarget to HCCObj.h
- Added DropSourceNotify to HCCObj.h
- Added EnterpriseDropTarget to HCCObj.h
- Added CreateTypeInfo to HCCObj.h
- Added CreateTypeInfo2 to HCCObj.h
- Added CreateTypeLib to HCCObj.h
- Added CreateTypeLib2 to HCCObj.h
- Added TypeInfo2 to HCCObj.h
- Added TypeChangeEvents to HCCObj.h
- Added TypeFactory to HCCObj.h
- Added TypeMarshal to HCCObj.h
- Added RecordInfo to HCCObj.h
- Added ErrorLog to HCCObj.h
- Added TypeLibRegistrationReader to HCCObj.h
- Added TypeLibRegistration to HCCObj.h
- Added ClassFactory2 to HCCObj.h
- Added ProvideClassInfo2 to HCCObj.h
- Added ProvideMultipleClassInfo to HCCObj.h
- Added OleControl to HCCObj.h
- Added OleControlSite to HCCObj.h
- Added PropertyPage to HCCObj.h
- Added PropertyPage2 to HCCObj.h
- Added PropertyPageSite to HCCObj.h
- Added PropertyNotifySink to HCCObj.h
- Added SpecifyPropertyPages to HCCObj.h
- Added PersistMemory to HCCObj.h
- Added PersistStreamInit to HCCObj.h
- Added PersistPropertyBag to HCCObj.h
- Added SimpleFrameSite to HCCObj.h
- Added Font to HCCObj.h
- Added Picture to HCCObj.h
- Added Picture2 to HCCObj.h
- Added FontEventsDisp to HCCObj.h
- Added FontDisp to HCCObj.h
- Added PictureDisp to HCCObj.h
- Added OleInPlaceObject to HCCObj.h
- Added OleInPlaceObjectWindowless to HCCObj.h
- Added OleInPlaceSite to HCCObj.h
- Added OleInPlaceSiteEx to HCCObj.h
- Added OleInPlaceSiteWindowless to HCCObj.h
- Added ViewObject to HCCObj.h
- Added ViewObject2 to HCCObj.h
- Added ViewObjectEx to HCCObj.h
- Added OleUndoUnit to HCCObj.h
- Added OleParentUndoUnit to HCCObj.h
- Added EnumOleUndoUnits to HCCObj.h
- Added OleUndoManager to HCCObj.h
- Added PointerInactive to HCCObj.h
- Added ObjectWithSite to HCCObj.h
- Added PerPropertyBrowsing to HCCObj.h
- Added PropertyBag to HCCObj.h
- Added PropertyBag2 to HCCObj.h
- Added PersistPropertyBag2 to HCCObj.h
- Added AdviseSinkEx to HCCObj.h
- Added QuickActivate to HCCObj.h

2022.01.14

Added template<...> class ObjectBase to HCCComImpl.h
Added template<...> class Interfaces to HCCComImpl.h
Added ComInterfacesTests.cpp to Harlinn.Common.Core.Tests verifying that QueryInterface works for, currently, more than 1000 different COM interfaces.

Added ComImplTests.cpp to Harlinn.Common.Core.Tests verifying that

class ObjectImpl : public Com::ObjectBase<ObjectImpl, IEnumString, IEnumVARIANT>
{
    int value_ = 0;
public:
    virtual HRESULT __stdcall Next( ULONG celt, LPOLESTR* rgelt, ULONG* pceltFetched ) override;
    virtual HRESULT __stdcall Next( ULONG celt, VARIANT* rgVar, ULONG* pCeltFetched ) override;
    virtual HRESULT __stdcall Skip( ULONG celt ) override;
    virtual HRESULT __stdcall Reset( ) override;
    virtual HRESULT __stdcall Clone( IEnumString** ppenum ) override;
    virtual HRESULT STDMETHODCALLTYPE Clone( IEnumVARIANT** ppEnum ) override;
};

is a valid implementation of a COM object that implements both IEnumString and IEnumVARIANT.

Demonstrating an implementation that is significantly simpler than alternative COM implementation frameworks.

2022.01.13

Added HCCComImpl.h to Harlinn.Common.Core: Classes used to implement COM objects.

Added HCCComInterfaces.h to Harlinn.Common.Core:

  struct Interface : std::false_type
  template<typename ...InterfaceTypes>
  {
 
  };

With specializations for many common COM interfaces derived from:

  template<>
  struct Interface<IUnknown> : std::true_type
  {
      using InterfaceType = IUnknown;
      template<typename DerivedInterfaceType>
      static void* QueryInterface( const Guid& interfaceId, const DerivedInterfaceType* impl )
      {
          if ( interfaceId == __uuidof( InterfaceType ) )
          {
              auto* result = static_cast<InterfaceType*>( const_cast<DerivedInterfaceType*>( impl ) );
              return result;
          }
          else
          {
              return nullptr;
          }
      }
  };

Specializations for interfaces derived from IUnknown are the implemented using this macro:

  #define HCC_COM_DEFINE_INTERFACE( Itf, BaseItf ) \
  template<>  \
  struct Interface<Itf> : Interface<BaseItf>  \
  {  \
      using Base = Interface<BaseItf>; \
      using InterfaceType = Itf;  \
      template<typename DerivedInterfaceType>  \
      static void* QueryInterface( const Guid& interfaceId, const DerivedInterfaceType* impl )  \
      {  \
          if ( interfaceId == __uuidof( InterfaceType ) )  \
          {  \
              auto* result = static_cast<InterfaceType*>( const_cast<DerivedInterfaceType*>( impl ) ); \
              return result; \
          }  \
          else  \
          { \
              return Base::QueryInterface<DerivedInterfaceType>( interfaceId, impl ); \
          }  \
      }  \
  }

Which is then used to implement specializations of Interface<...> for COM interfaces like this:

  HCC_COM_DEFINE_INTERFACE( IEnumString, IUnknown );
  HCC_COM_DEFINE_INTERFACE( IClassFactory, IUnknown );
  HCC_COM_DEFINE_INTERFACE( ISequentialStream, IUnknown );
  HCC_COM_DEFINE_INTERFACE( IStream, ISequentialStream );
  HCC_COM_DEFINE_INTERFACE( IPersist, IUnknown );
  HCC_COM_DEFINE_INTERFACE( IPersistStream, IPersist );
  HCC_COM_DEFINE_INTERFACE( IEnumMoniker, IUnknown );
  HCC_COM_DEFINE_INTERFACE( IMoniker, IPersistStream );
      .
      .
      .

2022.01.11

Reimplemented IUnknownImplementation; fixing, among other things, a nasty bug in QueryInterface,
Continued reimplementing the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- CommandSink2
- GdiMetafile1
- GdiMetafileSink1
- SpriteBatch
- DeviceContext3
- Device3
- Factory4
- CommandSink3
- SvgGlyphStyle
- DeviceContext4
- Device4
- Factory5
- CommandSink4
- ColorContext1
- SvgAttribute
- SvgPaint
- SvgStrokeDashArray
- SvgPointCollection
- SvgPathData
- SvgElement
- SvgDocument
- DeviceContext5
- Device5
- Factory6
- CommandSink5
- DeviceContext6
- Device6
- Factory7

2022.01.10

Continued reimplementing the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- Device
- Factory1
- Multithread
- GeometryRealization
- DeviceContext1
- Device1
- Factory2
- CommandSink1
- InkStyle
- Ink
- GradientMesh
- ImageSource
- ImageSourceFromWic
- TransformedImageSource
- LookupTable3D
- DeviceContext2
- Device2
- Factory3

2022.01.09

Continued reimplementing the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- DeviceContextRenderTarget
- Factory
- GdiMetafileSink
- ID2D1GdiMetafileSinkImplementationBase
- GdiMetafile
- CommandSink
- ID2D1CommandSinkImplementationBase
- CommandList
- PrintControl
- ImageBrush
- BitmapBrush1
- StrokeStyle1
- PathGeometry1
- Properties
- Effect
- Bitmap1
- GradientStopCollection1
- DrawingStateBlock1
- DeviceContext

2022.01.08

Moved support for DirectWrite out of HWGraphics.h and out of the Harlinn::Windows::Graphics namespace and into HWDWrite.h and into the Harlinn::Windows::DirectWrite namespace.
Reimplemented the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- Resource
- Image
- ColorContext
- Bitmap
- GradientStopCollection
- Brush
- BitmapBrush
- SolidColorBrush
- LinearGradientBrush
- RadialGradientBrush
- StrokeStyle
- Geometry
- RectangleGeometry
- RoundedRectangleGeometry
- EllipseGeometry
- GeometryGroup
- TransformedGeometry
- SimplifiedGeometrySink
- ID2D1SimplifiedGeometrySinkImplementationBase
- GeometrySink
- ID2D1GeometrySinkImplementationBase
- TessellationSink
- ID2D1TessellationSinkImplementationBase
- PathGeometry
- Mesh
- Layer
- DrawingStateBlock
- RenderTarget
- BitmapRenderTarget
- ControlRenderTarget
- GdiInteropRenderTarget

This rewrite provides better documentation, improved error handling, improved support for working with raw COM interfaces, and an improved API compared to the API I created back in 2012.

2022.01.06/07

Added new classes to Tools\WMI\CIMTool
- Renderable
- TreeNode
- Command
- CommandManager
- Window
- MenuItem
- SubMenuItem
- Menu
- ClassObjectNode
- NamespaceNode
- Connection
- ConnectionManager
- ExplorerWindow
- PropertiesWindow
- FileMenu
- EditMenu
- ViewMenu
- MainMenuBar
- Main

2022.01.05

Added new project Tools\WMI\CIMTool - A tool for exploring Windows Management Instrumentation (WMI) API implemented using ImGui.

2022.01.04

Added new project Examples\Core\WMI\HCCExampleSimpleWMIClient
Added new project Examples\Core\WMI\HCCExampleSimpleAsyncWMIClient

2022.01.03

Added more classes for interfacing with the Windows Management Instrumentation (WMI) API
- WbemMethodSignature
- WbemMethod

2022.01.02

Added classes for interfacing with the Windows Management Instrumentation (WMI) API
- WbemProperty
- WbemClassObject
- WbemObjectAccess
- WbemQualifierSet
- WbemServices
- WbemLocator
- WbemObjectSink
- EnumWbemClassObject
- WbemCallResult
- WbemContext
- UnsecuredApartment
- WbemUnsecuredApartment
- WbemStatusCodeText
- WbemBackupRestore
- WbemBackupRestoreEx
- WbemRefresher
- WbemHiPerfEnum
- WbemConfigureRefresher
- WbemObjectSinkEx
- WbemShutdown
- WbemObjectTextSrc
- MofCompiler
- WbemPropertyProvider
- WbemUnboundObjectSink
- WbemEventProvider
- WbemEventProviderQuerySink
- WbemEventProviderSecurity
- WbemEventConsumerProvider
- WbemProviderInitSink
- WbemProviderInit
- WbemHiPerfProvider
- WbemDecoupledRegistrar
- WbemProviderIdentity
- WbemDecoupledBasicEventProvider
- WbemEventSink
- WbemTransport
- WbemLevel1Login
- WbemConnectorLogin
- WbemAddressResolution
- WbemClientTransport
- WbemClientConnectionTransport
- WbemConstructClassObject

2022.01.01

Added classes for interfacing with the Windows Location API
- LocationReport
- LatLongReport
- CivicAddressReport
- Location
- LocationPower
- DefaultLocation
- DispLatLongReport
- DispCivicAddressReport
- LocationReportFactory
- LatLongReportFactory
- CivicAddressReportFactory
Added classes for interfacing with the Windows sensor API
- WpdSerializer
- PortableDeviceValues
- PortableDeviceKeyCollection
- PortableDevicePropVariantCollection
- PortableDeviceValuesCollection
- SensorManager
- LocationPermissions
- SensorCollection
- Sensor
- SensorDataReport
- SensorManagerEvents
- SensorEvents
- SensorManagerEventSinkBase
- SensorManagerEventSink
- SensorEventSinkBase
- SensorEventSink

2021.12.29

Added classes for serial port device I/O to Harlinn.Common.Core
- DeviceControlBlock
- CommConfig
- SerialPort
- SerialPorts
- CommDeviceStream
- CommDeviceRequest
- ReadCommDeviceRequest
- WriteCommDeviceRequest
- CommDeviceHandler
- CommDeviceDispatcher
Added several backends to Harlinn.ImGui: DirectX 9 through 11: OpenGL 2 and 3; and Vulkan.

2021.12.28

Updated Harlinn.ImGui to Docking branch after merge of master at version 1.86 and ImPlot to version 0.12
Build fixes, rebuilding the entire solution for both Debug and release.
Fixed missing exports from Harlinn.tiff while building Harlinn.gdal

2021.12.27

Added new project Examples\3rdParty\bullet\BulletBasicDemo
Added bullet\examples\Importers to 3rdParty\Harlinn.bullet
Added bullet\examples\OpenGLWindow to 3rdParty\Harlinn.bullet
Added bullet\examples\Importers to 3rdParty\Harlinn.bullet
Added bullet\Extras\Serialize to 3rdParty\Harlinn.bullet
Added bullet\Extras\InverseDynamics to 3rdParty\Harlinn.bullet
Added bullet\Extras\HACD to 3rdParty\Harlinn.bullet
Added bullet\Extras\GIMPACTUtils to 3rdParty\Harlinn.bullet
Added bullet\Extras\ConvexDecomposition to 3rdParty\Harlinn.bullet
Added new project 3rdParty\Harlinn.rtmidi
Added new project 3rdParty\Harlinn.gwen
Added new project 3rdParty\Harlinn.enet
Added new project 3rdParty\Harlinn.crossguid
Added new project 3rdParty\Harlinn.base64
Added new project Tools\3rdParty\lua\luac
Added new project Tools\3rdParty\lua\lua
Added new project 3rdParty\Harlinn.lua
Added new project 3rdParty\Harlinn.clsocket

2021.12.26

Added new project 3rdParty\Harlinn.BussIK
Added new project 3rdParty\Harlinn.glad

2021.12.23

Added 31 tests to Tests\3rdParty\bullet\Harlinn.bullet.tests
Added new project Tests\3rdParty\bullet\Harlinn.bullet.tests

2021.12.22

Added new project 3rdParty\Harlinn.Eigen

2021.12.21

Added new project 3rdParty\Harlinn.bullet
Added new project 3rdParty\Harlinn.tinyobjloader
Added new project Examples\3rdParty\flatbuffers\FlatbuffersGreeterClient
Added new project Examples\3rdParty\flatbuffers\FlatbuffersGreeterServer
Added new project Tools\3rdParty\flatbuffers\flatc
Added new project 3rdParty\Harlinn.flatbuffers

2021.12.20

Updated Harlinn.Julia, required Julia version is now 1.7
Added new project Tools\3rdParty\proj\projinfo
Added new project Tools\3rdParty\proj\gie
Added new project Tools\3rdParty\proj\proj
Added new project Tools\3rdParty\proj\geod
Added new project Tools\3rdParty\proj\cs2cs
Added new project Tools\3rdParty\proj\projsync
Added new project Tools\3rdParty\proj\cct

2021.12.19

Added new project Examples\3rdParty\rocksdb\RocksDBOptimisticTransactionExample
Added new project Examples\3rdParty\rocksdb\RocksDBCompactionFilterExample
Added new project Examples\3rdParty\rocksdb\RocksDBCompactFilesExample
Added new project Examples\3rdParty\rocksdb\RocksDBColumnFamiliesExample
Added new project Tools\3rdParty\rocksdb\rocksdb_dump
Added new project Tools\3rdParty\rocksdb\rocksdb_undump
Added new project Tools\3rdParty\rocksdb\write_stress
Added new project Tools\3rdParty\rocksdb\trace_analyzer
Added new project Tools\3rdParty\rocksdb\sst_dump
Added new project Tools\3rdParty\rocksdb\io_tracer_parser

2021.12.18

Added new project Tools\3rdParty\rocksdb\db_sanity_test
Added new project Tools\3rdParty\rocksdb\db_repl_stress
Added new project Tools\3rdParty\rocksdb\db_bench
Added new project Tools\3rdParty\rocksdb\ldb
Added new project Examples\3rdParty\rocksdb\RocksDBSimpleExample2
Modified 3rdParty\Harlinn.rocksdb so that the Harlinn.rocksdb.dll now exports the C++ API.

2021.12.17

Added new project Examples\3rdParty\rocksdb\RocksDBSimpleExample
Added new project Tools\3rdParty\rocksdb\blob_dump
Added new project Tools\3rdParty\rocksdb\cache_bench
Upgraded 3rdParty\Harlinn.rocksdb to rocksdb 6.26.1
Added 5 tests to Tools\3rdParty\gdal\gdal_tests, for a total of 84 tests

2021.12.16

Added 79 tests to Tools\3rdParty\gdal\gdal_tests
Added gdal runtime datafiles to Share\gdal
Added proj runtime datafiles to Share\proj

2021.12.15

Added new project Harlinn.Java - A thin wrapper around the Java Native Interface. Locates jvm.dll dynamically.

2021.12.14

Added new project Tools\3rdParty\gdal\gdal_tests
Upgraded 3rdParty\Harlinn.jxl to libjxl 0.6.1
Upgraded 3rdParty\Harlinn.gdal to gdal 3.4
Upgraded 3rdParty\Harlinn.tiff with modifications from gdal 3.4
Added new project Tools\3rdParty\gdal\dumpoverviews
Added new project Tools\3rdParty\gdal\gdal_contour
Added new project Tools\3rdParty\gdal\gdal_create
Added new project Tools\3rdParty\gdal\gdal_grid
Added new project Tools\3rdParty\gdal\gdal_rasterize
Added new project Tools\3rdParty\gdal\gdal_translate
Added new project Tools\3rdParty\gdal\gdal_viewshed
Added new project Tools\3rdParty\gdal\gdal2ogr
Added new project Tools\3rdParty\gdal\gdaladdo
Added new project Tools\3rdParty\gdal\gdalasyncread
Added new project Tools\3rdParty\gdal\gdalbuildvrt
Added new project Tools\3rdParty\gdal\gdaldem
Added new project Tools\3rdParty\gdal\gdalenhance
Added new project Tools\3rdParty\gdal\gdalflattenmask
Added new project Tools\3rdParty\gdal\gdalinfo
Added new project Tools\3rdParty\gdal\gdallocationinfo
Added new project Tools\3rdParty\gdal\gdalmanage
Added new project Tools\3rdParty\gdal\gdalmdiminfo
Added new project Tools\3rdParty\gdal\gdalmultidimtranslate
Added new project Tools\3rdParty\gdal\gdalsrsinfo
Added new project Tools\3rdParty\gdal\gdaltindex
Added new project Tools\3rdParty\gdal\gdaltorture
Added new project Tools\3rdParty\gdal\gdaltransform
Added new project Tools\3rdParty\gdal\gdalwarp
Added new project Tools\3rdParty\gdal\gnmanalyse
Added new project Tools\3rdParty\gdal\gnmmanage
Added new project Tools\3rdParty\gdal\nearblack
Added new project Tools\3rdParty\gdal\ogr2ogr
Added new project Tools\3rdParty\gdal\ogrinfo
Added new project Tools\3rdParty\gdal\ogrlineref
Added new project Tools\3rdParty\gdal\ogrtindex

2021.12.12

Added new project Tests\3rdParty\skia\skia_test. A fair number of the tests works, about 1500 of them, but then the test program terminates. As far as I have been able to determine, this seems to be related to the test code.
Changed the build of 3rdParty\Harlinn.skia to support Vulkan, Open GL and DirectX 3D. Temporarily removed support for 3rdParty\Harlinn.Angle in 3rdParty\Harlinn.skia.

Harlinn.Windows - A Visual Studio 2022 Solution

Github

Overview

Introduction

Why Did I Not Use cmake and vcpkg?

Why put Harlinn in Front of Every DLL Name?

What About the Unit Tests?

What About the Examples?

How Stable Is This?

Harlinn.Common.Core

Dependencies

Other 3rd Party Code included in Harlinn.Common.Core

About char, wchar_t, signed char and unsigned char

Main Header Files

Harlinn.Windows

Main Header Files

Harlinn.OCI

Harlinn.ODBC

Harlinn.Common.Config

Harlinn.Julia

3rd Party Libraries

Dear ImGui and ImPlot

2022.01.26

2022.01.25

2022.01.24

2022.01.23

2022.01.22

2022.01.21

2022.01.20

2022.01.19

2022.01.18

2022.01.17

2022.01.16

2022.01.15

2022.01.14

2022.01.13

2022.01.11

2022.01.10

2022.01.09

2022.01.08

2022.01.06/07

3^rd Party Libraries