Harlinn.Windows - A Visual Studio 2022 Solution





5.00/5 (40 votes)
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 26th 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:
- Download Harlinn.Windows 001 - 7.8 MB
- Download Harlinn.Windows 002 - 7.9 MB
- Download Harlinn.Windows 003 - 8 MB
- Download Harlinn.Windows 004 - 7.8 MB
- Download Harlinn.Windows 005 - 7.9 MB
- Download Harlinn.Windows 006 - 7.9 MB
- Download Harlinn.Windows 007 - 7.8 MB
- Download Harlinn.Windows 008 - 7.8 MB
- Download Harlinn.Windows 009 - 7.7 MB
- Download Harlinn.Windows 010 - 7.8 MB
- Download Harlinn.Windows 011 - 7.9 MB
- Download Harlinn.Windows 012 - 7.8 MB
- Download Harlinn.Windows 013 - 7.8 MB
- Download Harlinn.Windows 014 - 8 MB
- Download Harlinn.Windows 015 - 7.8 MB
- Download Harlinn.Windows 016 - 8 MB
- Download Harlinn.Windows 017 - 7.8 MB
- Download Harlinn.Windows 018 - 7.5 MB
- Download Harlinn.Windows 019 - 2.1 MB
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 16th 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 disabledssl_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
: 1175Harlinn.Windows.Tests
: 271Harlinn.OCI.Tests
: 49Harlinn.ODBC.Tests
: 9Harlinn.Timeseries.Tests
: 10Harlinn.Julia.Tests
: 11Harlinn.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 supportsconstexpr
concatenation using operator+
. -
template<typename T, size_t N> class Array
:An alternative to
std::array
that supportsconstexpr
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:
- 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 portclass ContextHandler
: An instance of theContext
class delegates the work for a particular OS handle to theProcess
override implemented for a class derived fromContextHandler
.template<typename DerivedT> FileHandler
: A template derived fromContextHandler
used to perform file related asynchronous I/Oclass FileRequest
: Base class for file related asynchronous I/O requestsclass ReadFileRequest
: Represents an asynchronous file read requestclass WriteFileRequest
: Represents an asynchronous file write requestclass FileDispatcher
: Derived fromFileHandler
, broadcasts I/O completion events to callbacks attached toboost::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
forfloat
,double
andenum
s 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, whereN <= 64
.BitMask::value
: is the value of the bit-mask with theN
lowest bits set to1
. LengthOf
: returns the number of elements in an array, length of a char orwchar_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
. Forchar
orwchar_t
zero-terminated strings,nullptr
is considered equal to astring
with0
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
returnstrue
if the absolute value of the difference betweena
andb
is less thansmallNumber
.class XXH64Hasher
: use this class to incrementally generate a hash value from multiple inputs.IsPowerOfTwo
: returnstrue
if an integer is a power of2
.NextPowerOfTwo
: returns the next higher value, that is a power of2
, 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;
Returnstrue
ifx
andy
holds the same value, even if they holdNaN
values.IsZero
:constexpr bool IsZero( double x ) noexcept; constexpr bool IsZero( float x ) noexcept;
Returns
true
ifx
is0.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;
ConvertangleInDegrees
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 ofy
.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
ifval
isNaN
. -
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
ifval
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 ofval
is negative, otherwisefalse
. -
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 thatresult
has a magnitude in the interval[1/2, 1)
or0
, andval
is equal toresult
*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 ofval
. -
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 toval
. -
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 toval
. -
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 thanminimumValue
, returnsminimumValue
; otherwise ifmaximumValue
compares less thanval
, returnsmaximumValue
; otherwise returnsval
. 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 betweena
andb
for the parametert
(or extrapolation, whent
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 ofsignValue
.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
byFLT_RADIX
raised to powern
.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
, wherex
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
, wherex
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
, wherex
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
ory
/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
, wherex
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 aMessageLoop
class. - HWDXApplication.h: declares some
Direct3D
12 utility classes:- class DXMessageLoop: The render/message loop.
- class DXContext: Initializes and manages interaction with the
D3D12Device
, theDXGI::SwapChain3
, theD3D12GraphicsCommandList
, and the few other objects required for interaction with the Direct3D 12 API. - class DXApplication: Derived from
Windows::Application
, tailored for developing Direct3D 12 usingWindows::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
andSave 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.
3rd 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
Inverse Kinematics
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
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
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
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 asgetopt()
, in that flag definitions can be scattered around the source code, and not just listed in one place such asmain()
. 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
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
HarfBuzz, a Text Shaping Library
Version: 3.0.0
Description
HarfBuzz
is a text shaping library. Using theHarfBuzz
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 aslibjpeg
, all else being equal. On other types of systems,libjpeg-turbo
can still outperformlibjpeg
by a significant amount, by virtue of its highly-optimized Huffman coding routines. In many cases, the performance oflibjpeg-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 )
- Implemented
- 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
- Implemented
- 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 )
- Implemented
- 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
- Implemented
2022.01.21
- Improved the implementation of
template<size_t bitCount> Bits
- Performance improvements for
template<size_t bitCount> Bits::reference
- Performance improvements for
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 tostd::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 astd::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 totemplate<size_t bitCount> Bits
. Unlikestd::vector<bool>
,BitVector
lets me specify the container used to store the bits, which must be astd::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 useboost::container::small_vector
to store the bit-mask, and avoid dynamic memory allocation for, perhaps, 99% of the received bit-masks.
- Added
- 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
- Added
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
TypeMarsha
l 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
- Added
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
andIEnumVARIANT
.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.