class TQFolder: public TFolder, public TQTaggable

 Default constructor of TQFolder class: a new and empty instance of TQFolder is
 created and initialized. Its name will be set to "unkown". Please note: users
 should not use this constructor but the static factory method
 TQFolder::newFolder(...). This default constructor has to be present to allow
 ROOT's CINT to stream instances of TQFolder.

 Constructor of TQFolder class: a new and empty instance of TQFolder is created
 and initialized. Its name will be set to the value of the parameter "name_" if
 it is a valid name and "invalid_name" otherwise. Please refer to the
 documentation of the static method TQFolder::isValidName(...) for details on
 valid folder names. Please note: users should not use this constructor but the
 static factory method TQFolder::newFolder(...).

 This method is a reimplementation of ROOT's TObject::IsSortable() and will
 return true indicating that instances of the TQFolder class can be sorted
 reasonably.

 This method is a reimplementation of ROOT's TObject::Compare(...) and allows
 to compare an instance of TObject to this instance of TQFolder. It will
 return 0 if an instance of TQFolder with the same name as this instance is
 passed as an argument and +1 (-1) if the name of this instance is
 alphabetically classified after (before) the name of the instance passed as an
 argument. In case of passing an instance that is not a valid sub-class of
 TQFolder -1 is returned.

 Returns a new and empty instance of the TQFolder class with name <name>

 return true if this folder is 'lazy'.
 lazy folders are not fully resolved, i.e. components of the folder
 structure still reside on disk and have not been loaded into memory.

 Returns a new and empty instance of the TQFolder class with name <name> if
 <name> is a valid name and a null pointer otherwise. Please note: this method
 does exactly the same as TQFolder::newFolder(...) but may be overwritten by
 sub-classes of TQFolder.

 parse a destination string, i.e. 'path::newname'
 if the pattern was recognized, path and newName will be set accordingly.
 else, the entire intput will be used as path and newName will be empty
 this function will return true in either case and only return false if
 something about the input string was horribly wrong, e.g. if the newName
 component has length zero

 parse a "location string", i.e. 'filename:objname'
 if the pattern was recognized, filename and objname will be set accordingly.
 else, the entire input will be used as filename, and objname will be empty.
 this function shoudl return true in any case.

 open a file for retrieval of a TQFolder instance. the importPath can be
 given as 'filename:objname' for details on the parsing, see
 TQFolder::parseLocation. the opt string can be used to specify the opening
 mode (like in TFile::Open). the importPath argument will be stripped of
 the filename component and the separating colon by this function. this
 function will not take ownage of the file pointer, and it's the users
 responsibility to close and delete it.

 import an object from the given path, to be given in the typical
 'filename:objname' notation. if the filename component is left empty, the
 current gDirectory will be used.

 Returns a string containing all valid characters that can be used to build
 valid names of instances of TQFolder or TObjects stored inside an instance of
 TQFolder.

 Checks whether the name <name> passed as an argument is a valid name for an
 instance of TQFolder and return true if <name> is valid and false otherwise.
 Valid names may consist of letters a..z, A..Z, numerals 0..9, underscores "_"
 and dots ".". Please note: names only consisting of dots (e.g. "." or "..")
 are not considered as valid names as these have special meanings.

 Checks whether <path> is a valid path name. A path is considered as valid if
 all its path tokens (components between slashes "/") are valid names for
 instances of TQFolder or TObjects stored inside an instance of TQFolder (please
 refer to the documentation of the static method TQFolder::isValidName(...)
 for details on valid folder names). If <allowRelativePaths> is true (true by
 default) relative references like "." or ".." are also considered as valid path
 tokens. If <allowWildcards> is true (true by default) wildcards like "?" or "*"
 are also considered as valid path tokens.

 Makes the name <identifier> a valid name of instances of TQFolder or TObjects
 stored inside an instance of TQFolder (please refer to the documentation of the
 static method TQFolder::isValidName(...) for details on valid folder names).
 Invalid name characters in <identifier> are replaced by <replacement> (default
 is an empty string effectively removing such characters). If <replacement>
 itself does not contain invalid name characters the string returned is guaranteed
 to be a valid name of instances of TQFolder or TObjects stored inside an instance
 of TQFolder.

 Make the path <path> a valid path (please refer to the static method
 TQFolder::isValidPath(...) for details on valid paths). Invalid name characters
 in <path> are replaced by <replacement> (default is an empty string effectively
 removing such characters). If <replacement> itself does not contain invalid name
 characters the string returned is guaranteed to be a valid path.
 If <allowRelativePaths> is true (true by default) relative references like "."
 or ".." are kept and if <allowWildcards> is true (true by default) wildcards like
 "?" or "*" are also kept.
 keep track of leading and trailing slahes "/" since these will undesirably be
 removed by TQFolder::getPathHead(...) in the following and thus need to be added
 later again

 Removes the first path token (head) of <path> and returns it. (content of <path>
 will be changed). Examples:

 - TString path = "hello";
 getPathTail(path) returns "hello" and <path> becomes an empty string.
 - TString path = "hello/world";
 getPathTail(path) returns "hello" and <path> becomes "world".
 - TString path = "hello/world/test";
 getPathTail(path) returns "hello" and <path> becomes "world/test".

 Removes the last path token (tail) of <path> and returns it (content of <path>
 will be changed). Examples:

 - TString path = "hello";
 getPathTail(path) returns "hello" and <path> becomes an empty string.
 - TString path = "hello/world";
 getPathTail(path) returns "world" and <path> becomes "hello".
 - TString path = "hello/world/test";
 getPathTail(path) returns "test" and <path> becomes "hello/world".

 Returns <path> without the first path token (head). Examples:

 getPathWithoutHead("hello") returns an empty string
 getPathWithoutHead("hello/world") returns "world"
 getPathWithoutHead("hello/world/test") returns "world/test"

 Returns <path> without the last path token (tail). Examples:

 getPathWithoutTail("hello") returns an empty string
 getPathWithoutTail("hello/world") returns "hello"
 getPathWithoutTail("hello/world/test") returns "hello/world"

 Concatenates the two paths <path1> and <path2> ensuring exactly one intermediate
 slash "/" between the two in the resulting path. In case one path is an empty
 string the respective other one is returned. Examples:

 - concatPaths("a", "b") returns "a/b".
 - concatPaths("a/", "/b") returns "a/b".
 - concatPaths("a/", "b") returns "a/b".
 - concatPaths("a/b", "c") returns "a/b/c".

 Concatenates the three paths <path1>, <path2>, and <path3> ensuring exactly one
 intermediate slash "/" between each of them in the resulting path. In case one
 path is an empty string it is ignored. Examples:

 - concatPaths("a", "b", "c") returns "a/b/c".
 - concatPaths("a/", "b", "/c") returns "a/b/c".
 - concatPaths("a/", "", "/c") returns "a/c".

 Concatenates the four paths <path1>, <path2>, <path3>, and <path4> ensuring
 exactly one intermediate slash "/" between each of them in the resulting path.
 In case one path is an empty string it is ignored. Examples:

 - concatPaths("a", "b", "c", "d") returns "a/b/c/d".

 Concatenates the four paths <path1>, <path2>, <path3>, <path4>, and <path5> ensuring
 exactly one intermediate slash "/" between each of them in the resulting path.
 In case one path is an empty string it is ignored. Examples:

 - concatPaths("a", "b", "c", "d", "e") returns "a/b/c/d/e".

 Counts the number of path levels (valid names for instances of TQFolder separated
 by slashes "/") in input path <path>. If <path> is not a valid path -1 is returned
 (relative paths, e.g. "..", and wildcards, e.g. "?", are not considered as valid
 and will result in -1 as return value). Examples:

 - countPathLevels("") returns 0.
 - countPathLevels("hello") returns 1.
 - countPathLevels("hello/world") returns 2.
 - countPathLevels("hello/?") returns -1.

 returns true if the folder is equivalent to another one, e.g. if all
 elements present in one have a corresponding element of the same name
 present in the other as well.

 returns true if the folder is equivalent to another one, e.g. if all
 elements present in one have a corresponding element of the same name
 present in the other as well.

 print the difference between two folders, comparing them recursively

 print the difference between two folders, comparing them recursively

 print the difference between two folders, comparing them recursively

 this is an alias for the 'print' function

 Prints the contents of this instance of TQFolder via std::cout. The following options
 may be specified:

 - "r" recursively print contents of subfolders
 - "r<N>" (<N> replaced by a positive integer number) like "r" but
 does not go deeper than <N> levels
 - "d" prints an additional column summarizing details of the
 corresponding objects
 - "h" do not print contents of folders starting with a dot (".")
 recursively (if used with option "r")
 - "H" like "h" but do not even list folders starting with a dot (".")
 - "c" count and display the number of elements in each sub-folder
 - "C" like "c" but count the number of elements recursively
 - "l" additionally shows indentation lines
 - "f[<filter>]" only shows elements whose names match <filter> (allows use
 of wildcards "*" and "?" in the usual "ls-like" way)
 - "t" additionally prints tags associated to instances of TQFolder
 - "t[<filter>]" like "t" but only prints tags whose keys match <filter>

 The print command can be redirected to another folder by prepending the
 corresponding path followed by a colon to the list of options, e.g.
 "hello/world:trd". If wildcards are used in this path the print command will
 be redirected to the first match only.

 internal pretty-print function
 for documentation, please refer to the public variant

 Checks the consistency of system of bidirectional pointers between instances of
 TQFolder and their base folders and returns true if all references are consistent
 and false otherwise. It prints an error message in case <verbose> is true and
 an inconsistency is found.

 Returns true if this instance of TQFolder is a (not necessarily direct) base
 folder of <folder> and false otherwise.

 Removes the reference of the object referred to by <path> from the corresponding
 instance of TQFolder and returns true if has been removed successfully. The
 object itself is not affected. [Please note: this method is a wrapper to
 TQFolder::deleteObject(name, true).]

 Deletes/removes the object referred to by <path> from the corresponding
 instance of TQFolder and return the number of deleted/removed objects. If
 <removeOnly> is false (this is the default) the corresponding objected is deleted
 and its memory is freed. If <removeOnly> is true only the object's reference is
 removed. If a dash "-" is appended to the object's reference the containing
 instances of TQFolder are deleted/removed recursively as well if and only if by
 the operation an instance of TQFolder has become empty. [Please note: if
 <removeOnly> is true the corresponding instances of TQFolder won't be deleted but
 only detached from its base folders. One should take care in this case to not
 loose the pointers to these folders since the inter-reference between them is
 lost.] If an exclamation mark "!" is appended to the object's reference this
 method can be used to delete non-empty instances of TQFolder including its
 content. Please note: if "-" and "!" are combined one needs to append "!-"
 (and NOT "-!").

 Deletes all elements of this folder. This will also delete subfolders including
 their elements recursively. Returns the total number of deleted objects.
 Remark: If the folder contains TQImportLinks, only the links will be deleted.
 The corresponding content that still resides on disk will not be touched
 and can still be accessed via TQFolder::loadFolder()

 Sorts the elements of this folder and all its subfolders by
 ascending alphabetical order. This does not affect the objects
 itself but only the order of references (pointers to these
 objects) kept by this instance of TQFolder.

 Sorts the elements of this folder by ascending alphabetical order and returns
 the number of elements processed. This does not affect the objects itself but
 only the order of references (pointers to these objects) kept by this instance
 of TQFolder.

 Detaches this instance of TQFolder from its base folder and returns a pointer
 to this folder (which became the root of this tree of folders by this operation).
 This method ensures that the bidirectional reference between base folder and
 this folder are updated properly.

 Moves this instance of TQFolder to the folder <dest> and returns true in case
 of success and false otherwise. The operation is not performed in case this
 instance of TQFolder is a base folder of the destination folder. Optionally, a
 new name <newName> of this instance of TQFolder can be specified to be applied
 upon successfully having moved it to the destination folder. This method ensures
 that the bidirectional reference between base folder and this folder are updated
 properly.

 Moves this instance of TQFolder to the one referred to by <dest> and returns
 true in case of success and false otherwise. The operation is not performed in
 case this instance of TQFolder is a base folder of the destination folder.
 Optionally, the folder can be renamed upon successfully moving it to its new
 location by appending "::" followed by the new name to <dest>. This method
 ensures that the bidirectional reference between base folder and this folder
 are updated properly. Examples:

 - moveTo("/hello") moves this folder to "/hello"
 - moveTo("/hello :: myNewName") moves this folder to "/hello" and renames it
 to "myNewName".

 [Please note: this is a wrapper to TQFolder::moveTo(TQFolder * dest, ...).]

 Moves the instance of TQFolder referred to by <source> to the one referred to
 by <dest> and returns true in case of success and false otherwise. The operation
 is not performed in case the source instance of TQFolder is a base folder of
 the destination folder. Optionally, the folder can be renamed upon successfully
 moving it to its new location by appending "::" followed by the new name to <dest>.
 This method ensures that the bidirectional reference between base folder and this
 folder are updated properly. Please note that this method does NOT behave
 exactly as the shell command "mv" does. Examples:

 - moveFolder("/hello", "/world") moves the folder "/hello" to "/world" (resulting
 in its new path "/world/hello")
 - moveFolder("/hello", "/world ::myNewName") moves the folder "/hello" to "/world"
 and renames it to "myNewName" (resulting in its new path "/world/myNewName")

 [Please note: this is a wrapper to TQFolder::moveTo(TQFolder * dest, ...).]

 Creates an independent copy of this instance of TQFolder including all its
 sub-elements and return a pointer to it. Optionally, a new name <newName> can
 be assigned to the copy.

 Creates an independet copy of this instance of TQFolder (including all its
 sub-elements), adds it to <dest>, and returns a pointer to the copy in case of
 success and a NULL pointer otherwise.

 Creates an independet copy of this instance of TQFolder (including all its
 sub-elements), adds it to the instance of TQFolder referred to by <dest>, and
 returns a pointer to the copy in case of success and a NULL pointer otherwise.

 [Please note: this is a wrapper to TQFolder::copyTo(TQFolder * dest).]

 Creates an independet copy of this instance of the TQFolder at the path
 <source> (including all its sub-elements), adds it to the instance of
 TQFolder referred to by <dest>, and returns a pointer to the copy in case
 of success and a NULL pointer otherwise.

 [Please note: this is a wrapper to TQFolder::copyTo(TQFolder * dest).]

 Returns the number of elements (objects and subfolders) in this folder. If
 recursive = true, the number of elements in subfolders is added recursively.
 If a class is specified, elements are only counted if they inherit from that
 class

 return the number of objects matching the given name filter

 Returns true if this instance of TQFolder does not contain any element and
 false otherwise.

 Returns an estimated size (in bytes) of this instance of TQFolder including
 its sub-elemets in memory. The number returned is mainly calculated from the
 estimated size of histograms stored within the folder hierarchy (using the
 method TQHistogramUtils::estimateSize(...)) and a contribution for any other
 type of object obtained from the C++ function sizeof(...). Please note that
 this does determine the size of the pointer rather than the size of the object
 itself. Thus, TQFolder::getSize() does only provide reasonable results if most
 elements within the folder hierarchy are histograms (instances of TH1).

 TODO: move this to TQStringUtils

 set the base folder

 retrieve the base folder as TQTaggable

 retrieve list of subfolders

 retrieve list of subfolders

 retrieve a list of folders under the given path matching the class
 TODO: handle tag requirements

 determines a set of (sub) folders which have a tag equivalent to the one
 provided. Tags on containing folders are
 considered as well (i.e., tags are being searched for
 towards the root node of the folder structure)
 note that once a folder matches its sub folders are no longer considered
 even if the relevant tag might change when retrieving it from a sub folder
 of the one in the returned set

 determines a set of (sub) folders which have tags equivalent to those provided
 (applying a logical "AND" on requirements). Tags on containing folders are
 considered as well (i.e., tags are being searched for
 towards the root node of the folder structure)

 returns a std::vector<TString> containing the full paths of folders matching
 the given requirements.

 returns a std::vector<TString> containing the full paths of folders matching
 the given requirements. This variant returns the paths in their wildcarded
 representation (using the "wildcarded" tag on the respective folders). If
 multiple folders matching the requirements with the same wildcarded path are
 found, the path is added to the vector only once.

 retrieve a list of objects matching the given path

 retrieve a list of objects matching the given path

 retrieve an object with the given name from a path

 expand and return the path of some object

 return the paths of all objects matching the pattern
 The ownership of the list elements is with the returned list itself.

 retrieve the name of this object

 set the name of this object

 retrieve a const reference to the name of this object

 wrapper to help resolve ambiguous calls

 wrapper to help resolve ambiguous calls

 Returns the folder (instance of TQFolder) that matches the path pattern <path_>
 and a NULL pointer in case no match can be found. If more than one folder matches
 <path_> (because wildcards are used) the first match is returned. Additionally,
 a new instance of TQFolder is created as requested if it does not already
 exist and a "+" has been appended to <path_>. The path <path_> may be built
 up from any number of path levels in either case and an arbitrary number of
 nested folders may be created by appending one "+" to the full path.

 Examples:

 - getFolder("subfolder") returns a pointer to the instance of TQFolder named
 "subfolder" within this instance of TQFolder if it does exist.
 - getFolder("subfolder+") returns a pointer to the instance of TQFolder named
 "subfolder" within this instance of TQFolder and does create it if it does
 not exist
 - getFolder("subfolder/fol2+") returns a pointer to the instance of TQFolder
 named "fol2" within "subfolder" (in turn within this instance of TQFolder)
 and does create it if it does not exist

 add a folder at the given path

 Return the list of names of objects in a folder

 Returns the full path of this instance of TQFolder in the hierarchy. For the
 root folder "/." is returned.

 Returns the full path of this instance of TQFolder in the hierarchy. For the
 root folder "/" is returned.
 this version of getPath replaces the names of folders that have the tag
 wildcarded=true
 set with a wildcard ('?')

 Returns a pointer to the base folder of this instance of TQFolder and a NULL
 pointer in case it is the root folder of the folder hierarchy. In general, if
 <depth> is larger than 1 (it is 1 by default) a pointer to the instance of
 TQFolder <depth> levels up the hierarchy is returned and a NULL pointer if the
 root folder is traversed before. If <depth> is zero a pointer to this instance
 of TQFolder is returned.

 checks if this folder or the other folder are subfolders of the respective
 other. Returns +1*nSteps if 'other' is a subfolder of 'this', -1*nSteps in the inverse case
 and 0 otherwise. nSteps is the distance between the two folders starting at 1
 if the two folders are equal. Example: If 'this' is a direct subfolder of
 'other' then -2 is returned

 Returns the a pointer to the instance of TQFolder which is the root of this
 folder hierarchy.

 Returns true if this instance of TQFolder is the root of the folder hierarchy
 (there is no base folder) and false otherwise.

 Returns the number of hierarchy levels to be traversed up to the root folder
 of this hierarchy.

 Returns the number of levels to be traversed down to the deepest element. For
 an instance of TQFolder that does not contain "sub-instances" of TQFolder the
 return value is 1.

 retrieve a list of folders containing all hierarchy levels up to the root
 folder

 this function works exactly as TQFolder::loadFolder, with the exception that
 all folder branches that have been externalized/splitted when writing the file
 will remain in collapsed state until they are accessed.
 for large files with an excessive use of externalization/splitting, this will
 significantly speed up accessing the data, since the branches are only expanded
 on-demand.

 please note, however, that you will only experience a total speed gain if you
 only access small fractions of your data. if you plan to read most of the file's data
 at some point, requiring the expansion of all branches, this 'lazy' feature
 will only postpone the work of loading the data into RAM to the point where it is accessed
 bringing no total speed gain.

 Loads an instance of TQFolder from an external ROOT file and returns a pointer
 to it and a NULL pointer in case of failure. The ROOT file and the key within
 the key within the ROOT file to be read is identified by <path> which has to
 have the form "filename:keyname", e.g. "file.root:folder".
 If the folder to load is stored within a structre of TDirectory in the file
 it can be accessed by prepending the corresponding path to the folder name,
 e.g. "file.root:dir1/dir2/folder". To load only a subfolder of an instance of
 TQFolder from the ROOT file one can append the corresponding path to the folder
 name, e.g. "file.root:folder/subfolder". In this case a pointer to "subfolder"
 is returned which is made the root folder before
 the 'lazy' flag will trigger lazy loading, please refer to TQFolder::loadLazyFolder
 for documentation of this feature.

 Creates a new instance of TQFolder, performs an import from an external text
 file <filename> on it, and returns a pointer to it in case of success and a
 NULL pointer in case of failure. If <showErrorMessage> is true and an error
 occurs during the import process the corresponding error message is displayed
 via std::cout. If the name of the instance returned is set to the filename of the
 text file with invalid characters replaced by "_".

 [Please note: this is a wrapper to TQFolder::loadFromTextFile(TString filename,
 TString &errorMessage).]

 Creates a new instance of TQFolder, performs an import from an external text
 file <filename> on it, and returns a pointer to it in case of success and a
 NULL pointer in case of failure.
 error messages will be fed into the string given as second argument

 Adds the object <object> to this instance of TQFolder or to the one referred to
 by <destination> and returns a pointer to the destination folder in case of
 success or a NULL pointer in case of failure. If destination ends on "!" an
 existing object with the same name will be replaced by the new one. Default is
 to keep the old object and return 0 if one exists already.

 retrieve the directory wherein this folder resides

 set the directory of this folder
 will migrate all data to the new directory, might be slow
 second argument decides whether the folder owns the directory handed

 clear and delete the directory associated to this folder if owned

 set the directory of this folder
 internal variant, will not migrate any data
 DO NOT USE, UNLESS YOU KNOW WHAT YOU ARE DOING

 Adds an independent copy of the object <object> to this the instance of
 TQFolder or to the one referred to by <destination> and returns a pointer to
 the destination folder in case of success or a NULL pointer in case of failure.

 return true if the folder has an object of the given name/path in its
 folder structure

 resolve all import links and load all missing components from disk to
 memory, converting a "lazy" sample folder into a fully expanded one

 resolve all import links and load all missing components the given
 directory to memory, converting a "lazy" sample folder into a fully
 expanded one

 resolve one specific import link given by name

 resolve one specific import link given by name from a given TDirectory

 automatically generate an export name for this folder the export name is
 required in order to allow writing this folder to disk with a non-zero
 split value. however, the user should NEVER need to call this function, as
 this should be handled automatically

 automatically generate an export names for this folder and all its subfolders
 for further details, refer to TQFolder::autoSetExportName

 set a specific export name for this folder and auto-generate ones for all
 its subfolders
 for further details, refer to TQFolder::autoSetExportName

 import an object from a TDirectory and deploy it at the given importPath

 writes a TQFolder to a given directory
 the precise functionality of this function can be customized using optional parameters
 in the default settings,
 - dir is the directory to which the folder will be written
 - exportName is the key under which the folder will be deployed in the directory

 after this function has been successfully executed, the the given directory will be associated
 to this folder. further writes via writeFolder or writeUpdate will use this directory
 if no other (new) directory is given

 also, all currently collapsed branches of the folder hierarchy will be expanded and rewritten
 to the new directory.

 since ROOT has problems with too large TObjects, the optional depth argument allows automatic splitting
 of a large folder hierarchy into parts. this splitting will on the top level and on each succeeding
 level of the folder hierarchy, until the depth exceeds the optional depth parameter.

 the keepInMemory=false flag can be used to automatically remove all folders from memory
 that have been linked/externalized with the depth-splitting procedure
 this causes the corresponding branhces of the folder hierarchy to be collapsed
 these branches are expanded (and the contents are then automatically reloaded from disk)
 when they are accessed
 with keepInMemory=false, reading/writing folder contents will take significantly longer
 however, lots of RAM space will be freed whenever writeFolder or writeUpdate are called
 with keepInMemory=false

 this function is still under developement, please use the usual TQFolder::writeFolder function instead

 as opposed to TQFolder::writeFolder(TDirectory*dir,TString name, int depth, bool keepInMemory)
 this function does not take the 'name' argument and automatically used the folder name instead
 for further documentation on the functionality, please refer to the aforementioned function

 this function is still under developement, please use the usual TQFolder::writeFolder function instead

 this function will transform the given string into a valid export name
 for further information, please refer to TQFolder::writeFolder
 THIS FUNCTION IS FOR INTERNAL USE ONLY

 return the currently set export name of this folder
 for further information, please refer to TQFolder::writeFolder

 wrapper function to allow subclasses to easily hook into the writing procedure

 this private function implements the TQFolder::writeFolder functionality
 other flavours of this function merely use the functionality of this one
 however, for documentation, please refer to the public variants

 check if the TQFolder has a valid directory set
 and is available to be re-read from this directory

 check if the TQFolder is available from the given directory

 collapse the folder down to its TQImportLinks
 this is useful in cases where you read a large TQFolder structure
 only accessing a tiny proportion of the entire structure at a time
 and only reading (not writing) any data
 in this case, occasional calles of TQFolder::collapse()
 will free the memory space used by the TQFolder branch in question
 and resinsert a TQImportLink at the corresponding points
 to allow re-reading the folder contents if need be
 ideally, this will drastically reduce the memory usage of your applicaton
 however, any modification made to the folder structure will be lost!

 this function, just like TQFolder::writeFolder, will write the folder contents to disk
 as opposed to the aforementioned function, this will only write an incremental update
 of the folder, that is, only write those chunks of data that have been accessed since
 the last write has been performed

 to determine this, writeUpdate will check for expanded branches of the folder hierarchy
 and will save them into an external object in the current directory
 this directory will be either of the following (with descending priority)
 - the directory to which the folder has been written at the last call of writeFolder
 - the directory from which the folder has been retrieved originally, if writeable
 - the current working directory

 please note that the inremential nature of the updates is only achieved if
 - previous calls of writeUpdate and/or writeFolder have used the keepInMemory=false flag, and
 - the depth argument for previous writeFolder and/or writeUpdate calls has been >0
 since this is the only case in which there will be collapsed branches in the folder hierarchy
 alternatively, incremental updates will also work if the folder is opened in lazy mode, see
 TQFolder::loadLazyFolder

 write this TQFolder >>as a TDirectory<< to the given base directory this
 function is intended to allow easy export of TQFolders to co-workers which
 are not using this framework

 applies the textual definitions from one or more text files to this instance
 for details, please refer to TQFolder::loadFromTextFile

 applies the textual definitions from one or more text files to this instance
 for details, please refer to TQFolder::loadFromTextFile
 error messages will be fed into the string given as second argument

 applies the textual definitions from exaclty one text file to this instance
 for details, please refer to TQFolder::loadFromTextFile

 applies the textual definitions from exaclty one text file to this instance
 for details, please refer to TQFolder::loadFromTextFile
 error messages will be fed into the string given as second argument

 import a text file

 export this instance of TQFolder to a list of strings
 the result can be used to create a new instance of TQFolder via
 TQFolder::loadFolderFromText or to patch an existing folder by calling
 TQFolder::importFromText

 creat an HTML-view of this TQFolder instance
 please be aware that the result can be unmanagably large for large folder hierarchies

 creat an HTML-view of this TQFolder instance and write it to a file
 please be aware that the result can be unmanagably large for large folder hierarchies

 export this instance of TQFolder to a text file
 the result can be used to create a new instance of TQFolder via
 TQFolder::loadFolderFromTextFile or to patch an existing folder by calling
 TQFolder::importFromTextFile

 Import folders and tags from text. The syntax is built from three basic elements:

 1) creating new folders (instances of TQFolder),
 2) setting tags on folders,
 3) executing commands.

 Lines starting with "#" will be considered a comment and will be ignored. In
 the following the syntax is explain my means of an example text:

 # Create a new sub-folder ("mySubfolder"):
 +mySubfolder;

 # Create a new sub-folder ("mySubfolder") and import recursively:
 +mySubfolder {

 }

 # Please note: If a recursive import block is opened "{...}" no
 # terminating ";" is needed.

 # Create new nested sub-folders ("mySubfolder/anotherSubFolder"):
 +mySubfolder/anotherSubFolder;

 # This one does also work with recursive import:
 +mySubfolder/anotherSubFolder {

 }

 # Set a tag ("myTag") with some value (myValue) on this folder:
 <myTag = myValue>

 # Set more than one tag:
 <myTag = myValue, anotherTag = false, hello = "world">

 # Set a tag ("myTag") with some value (myValue) on a sub-folder ("mySubfolder"):
 <myTag = myValue> @ mySubfolder;

 # Include text to import from an external text file ("myImportText.txt"):
 $include("myImportText.txt");

 # Delete a folder ("mySubfolder"):
 $delete("mySubfolder");

 # (this one simply calls TQFolder::deleteObject(...)).

 # Ignore text inside a block:
 $ignore() {

 }

 # Please note: the text to be ignored should be a valid text block to import.

 # Copy a folder ("mySubfolder") and rename the new instance (to "mySubfolder2")
 $copy("mySubfolder >>:: mySubfolder2");

 Import folders and tags from text.
 for details, please refer to the wrapper function of the same name
 occurring errors will be fed into the string given as second argument

 read object source

 worker function to import a TQFolder from a text file

 Deletes this instance of TQFolder and all its objects and sub-folders recursively

 return a full TQFolder copy of some actual file system structure

 traverse a folder structure of the local physical file system and create a TQFolder-image thereof

 traverse a folder structure of the some EOS file system and create a TQFolder-image thereof

 write this folder to a file of the given name, splitting at the given depth value
 the name of the folder will be used as a key

 deposit a couple of tags with timestamp and meta-information about software versions

 find a common base folder of some list

 create a TList with strings for all tags matching the filter in this folder structure
 the result can be applied to some folder via TQFolder::importFromTextFile

 write to a file the strings for all tags matching the filter in this folder structure
 the result can be applied to some folder via TQFolder::importFromTextFile

 merge another instance of TQFolder into this one. this function will
 traverse the folder structure recursively and collect all existing
 subfolders from both instances and merge them into one. in the case of a
 conflict, it will always use the subfolder with the more recent time stamp

 simply merge to folders, merging all objects, taggs and subfolders

 merge (copy) the tags from another folder to this one

 merge (move) the objects from another folder to this one