This is to support more cases where v5/cint got the parameter name wrong, by ommiting the full scope.
This fixes ROOT-8398

Make clear that it does not return a pointer to the created directory
in the case of a directory hierarchy.

Because the address of the element of a bitset and vector<bool> can not be
taken, we need to use a temporary storage to implement the interface that
requires the address of the element.  So far this had only been implemented
in the specialized collection proxy (TGenBitsetProxy and TGenVectorBoolProxy).
Those are obtained only when cloning a generic collection proxy.
Consequently using the result TClass::GetCollectionProxy for those two
directly did not work in all cases/interfaces.  However since TTree is making
a copy of the collection proxy, it was correctly in all cases.

This patch resolves all the issues seen in ROOT-8574 including
  - the bitset proxy's iterator did not record it started but still recorded its advance
  - the genertic proxy At function in case of bitset or vector<bool> was not return the right address

We also simplified TGenVectorBoolProxy since we know the actual container type at compilation time.

In 2004 kBool_t was the same value as kUChar_t (both 11).
So when the collection proxy were introduced to distinguished the two, a new
one was introduced kBOOL_t (value 21) to be used internally by the collection
proxies.

However this value is returned by TVirtualCollectionProxy::GetType and lead
to incorrect behaviors, for example:

    std::cerr << TDataType::GetDataType(proxy->GetType())->AsString(proxy->At(i)) << "\n";

as the value 21 is in TDataTypes.h the value of kDataTypeAliasUnsigned_t

In 2005 (eab7cae0), kBool_t was updated in TDataTypes.h (to the value 18)
to be distinct from kUChar_t as (at the time) sizeof(bool) on MacOS was 4.
However the code in collection proxy was never modernize to leverage this new
distinction.

Since the value is only recorded in the CollectionProxy objects and those
are never persisted, we can safetly switch from kBOOL_t to kBool_t.

The script didn't catch these in the previouis commit, so we
had to manually do this.

Signed-off-by: Vassil Vassilev <vvasilev@cern.ch>

Many headers contains redundant header guards around #include directives:

    #ifndef ROOT_TTree
    #include "TTree.h"
    #endif

This patch removes the #ifndef's around these includes as they
don't serve any pratical purpose anymore and are no longer part
of the current ROOT coding convention.

This patch also fixes the 153 typos that are contained in the
symbols of the #ifndef directives.

Signed-off-by: Vassil Vassilev <vvasilev@cern.ch>

Now array like        [3,3,3,3,3,3,1,2,2,2,2,2,2,2]
will be compressed as {v:3,n:6,v1:1,v2:2,n2:6}
If string representaion of value longer then 1 symbol, compression will
be much better

exclude position if it can be calculated from previous block

If there are large gaps or many similar values, they will be compressed
into JSROOT-specific way. JSROOT v5 will be required to decode such data

There are two reasons - keep type information (not supported in original
JSON) and implement compression.
First and simplest approch - skip 0 in the begin and end of the array
JSROOT need to be updated to understand such format.
Only actiavted when compact parameter >= 10

This reverts commit 5c076c6c.

This reverts commit b406328d, reversing
changes made to 318c7a47.

When the write-cache required flushing to file and the length of the buffer
to be written exceed the size of the cache buffer, requiring
direct-write-to-file, the offset (seek position) was incorrectly left to
the one of the last basket in the flushed cache.

Make cannot deal with 'export *', they have to be escaped and fixed later on.

Should fix a problem with 'hadd -k ...' reported on the forum
(https://root.cern.ch/phpBB3/viewtopic.php?f=3&t=22843).

This is the recommended way of using the modules feature and should pave our way
of enabling -fmodules-local-submodules-visibility mode.

Use the standard #include <typeinfo> and #include <iosfwd> instead.

Our two build systems can generate almost entirely a modulemap file laying out
one module per library. Due to some non-modular implementation in ROOT's core we
still need to treat some header files specially.

This patch appends modular header files to the modulemap while skipping the
predefined ones. Configure-make relates all headers that are installed in
$ROOTSYS/include to their library whereas relates only headers which are part of
library's dictionary.

JSON content automatically zipped - makes produced file approx 3 times
smaller. By default, JSON code will not include any additional spaces.

Before object reference was done with the string like "$ref12".
This approach is error-prone, while any normal string with
similar content will confuse JSROOT.parse function. Now
other syntax is used: {"$ref":12}. Such output can never be
produced with normal C++ classes, therefore is absolutely safe.

Starting from JSROOT version 4.8, both formats are supported.
Means old JSON files, produced with older ROOT versions still
can be used with actual JSROOT code.

Normally each JSON object accounted in object map,
which is required when dereferencing objects.
This does not works with pair JSON objects,
which are created after all contained objects are stored.
Therefore pair marked separately and does not accounted in reference
map.