class TRootSniffer: public TNamed

 constructor

 destructor

 set current http arguments, which then used in different process methods
 For instance, if user authorized with some user name,
 depending from restrictions some objects will be invisible
 or user get full access to the element

 When specified, _autoload attribute will be always add
 to top element of h.json/h.hml requests
 Used to instruct browser automatically load special code

 return name of configured autoload scripts (or 0)

 Restrict access to the specified location

 Hides or provides read-only access to different parts of the hierarchy
 Restriction done base on user-name specified with http requests
 Options can be specified in URL style (separated with &)
 Following parameters can be specified:
    visible = [all|user(s)] - make item visible for all users or only specified user
    hidden = [all|user(s)] - make item hidden from all users or only specified user
    readonly = [all|user(s)] - make item read-only for all users or only specified user
    allow = [all|user(s)] - make full access for all users or only specified user
    allow_method = method(s)  - allow method(s) execution even when readonly flag specified for the object
 Like make command seen by all but can be executed only by admin
    sniff->Restrict("/CmdReset","allow=admin");
 Or fully hide command from guest account
    sniff->Restrict("/CmdRebin","hidden=guest");

 Made fast check if item with specified name is in restriction list
 If returns true, requires precise check with CheckRestriction() method

 return 2 when option match to current user name
 return 1 when option==all
 return 0 when option does not match user name

 Checked if restriction is applied to the item
 full_item_name should have full path to the item

 Returns -1 - object invisible, cannot be accessed or listed
          0 -  no explicit restrictions, use default
          1 - read-only access
          2 - full access

 scan object data members
 some members like enum or static members will be excluded

 scans object properties
 here such fields as _autoload or _icon properties depending on class or object name could be assigned
 By default properties, coded in the Class title are scanned. Example:
   ClassDef(UserClassName, 1) //  class comments *SNIFF*  _field1=value _field2="string value"
 Here *SNIFF* mark is important. After it all expressions like field=value are parsed
 One could use double quotes to code string values with spaces.
 Fields separated from each other with spaces

 scans object childs (if any)
 here one scans collection, branches, trees and so on

 scan collection content

 scan complete ROOT objects hierarchy
 For the moment it includes objects in gROOT directory
 and list of canvases and files
 Also all registered objects are included.
 One could reimplement this method to provide alternative
 scan methods or to extend some collection kinds

 return true if object can be drawn

 scan ROOT hierarchy with provided store object

 Search element with specified path
 Returns pointer on element
 Optionally one could obtain element class, member description
 and number of childs. When chld!=0, not only element is searched,
 but also number of childs are counted. When member!=0, any object
 will be scanned for its data members (disregard of extra options)

 Search element in hierarchy, derived from TObject

 Returns hash value for streamer infos
 At the moment - just number of items in streamer infos list.

 Get hash function for specified item
 used to detect any changes in the specified object

 Method verifies if object can be drawn

 Method returns true when object has childs or
 one could try to expand item

 Creates TMemFile instance, which used for objects streaming
 One could not use TBufferFile directly,
 while one also require streamer infos list

 produce JSON data for specified item
 For object conversion TBufferJSON is used

 execute command marked as _kind=='Command'

 produce JSON/XML for specified item
 contrary to h.json request, only fields for specified item are stored

 produce XML data for specified item
 For object conversion TBufferXML is used

 method replaces all kind of special symbols, which could appear in URL options

 execute command for specified object
 options include method and extra list of parameters
 sniffer should be not-readonly to allow execution of the commands
 reskind defines kind of result 0 - debug, 1 - json, 2 - binary

 Process several requests, packing all results into binary or JSON buffer
 Input parameters should be coded in the POST block and has
 individual request relative to current path, separated with '\n' symbol like
 item1/root.bin\n
 item2/exe.bin?method=GetList\n
 item3/exe.bin?method=GetTitle\n
 Request requires 'number' URL option which contains number of requested items

 In case of binary request output buffer looks like:
 4bytes length + payload, 4bytes length + payload, ...
 In case of JSON request output is array with results for each item
 multi.json request do not support binary requests for the items

 Return true if it is streamer info item name

 produce binary data for specified item
 if "zipped" option specified in query, buffer will be compressed

 Method to produce image from specified object

 Parameters:
    kind - image kind TImage::kPng, TImage::kJpeg, TImage::kGif
    path - path to object
    options - extra options

 By default, image 300x200 is produced
 In options string one could provide following parameters:
    w - image width
    h - image height
    opt - draw options
  For instance:
     http://localhost:8080/Files/hsimple.root/hpx/get.png?w=500&h=500&opt=lego1

  Return is memory with produced image
  Memory must be released by user with free(ptr) call

 Method produce different kind of data out of object
 Parameter 'path' specifies object or object member
 Supported 'file' (case sensitive):
   "root.bin"  - binary data
   "root.png"  - png image
   "root.jpeg" - jpeg image
   "root.gif"  - gif image
   "root.xml"  - xml representation
   "root.json" - json representation
   "exe.json"  - method execution with json reply
   "exe.bin"   - method execution with binary reply
   "exe.txt"   - method execution with debug output
   "cmd.json"  - execution of registered commands
 Result returned either as string or binary buffer,
 which should be released with free() call

 return item from the subfolders structure

 creates subfolder where objects can be registered

 Register object in subfolder structure
 subfolder parameter can have many levels like:

 TRootSniffer* sniff = new TRootSniffer("sniff");
 sniff->RegisterObject("my/sub/subfolder", h1);

 Such objects can be later found in "Objects" folder of sniffer like

 h1 = sniff->FindTObjectInHierarchy("/Objects/my/sub/subfolder/h1");

 If subfolder name starts with '/', object will be registered starting from top folder.

 One could provide additional fields for registered objects
 For instance, setting "_more" field to true let browser
 explore objects members. For instance:

 TEvent* ev = new TEvent("ev");
 sniff->RegisterObject("Events", ev);
 sniff->SetItemField("Events/ev", "_more", "true");

 unregister (remove) object from folders structures
 folder itself will remain even when it will be empty

 create item element

 return true when object is TNamed with kItemField bit set
 such objects used to keep field values for item

 set or get field for the child
 each field coded as TNamed object, placed after chld in the parent hierarchy

 set field for specified item

 return field for specified item

 return field for specified item

 Register command which can be executed from web interface

 As method one typically specifies string, which is executed with
 gROOT->ProcessLine() method. For instance
    serv->RegisterCommand("Invoke","InvokeFunction()");

 Or one could specify any method of the object which is already registered
 to the server. For instance:
     serv->Register("/", hpx);
     serv->RegisterCommand("/ResetHPX", "/hpx/->Reset()");
 Here symbols '/->' separates item name from method to be executed

 One could specify additional arguments in the command with
 syntax like %arg1%, %arg2% and so on. For example:
     serv->RegisterCommand("/ResetHPX", "/hpx/->SetTitle(\"%arg1%\")");
     serv->RegisterCommand("/RebinHPXPY", "/hpxpy/->Rebin2D(%arg1%,%arg2%)");
 Such parameter(s) will be requested when command clicked in the browser.

 Once command is registered, one could specify icon which will appear in the browser:
     serv->SetIcon("/ResetHPX", "rootsys/icons/ed_execute.png");

 One also can set extra property '_fastcmd', that command appear as
 tool button on the top of the browser tree:
     serv->SetItemField("/ResetHPX", "_fastcmd", "true");
 Or it is equivalent to specifying extra argument when register command:
     serv->RegisterCommand("/ResetHPX", "/hpx/->Reset()", "button;rootsys/icons/ed_delete.png");

 Returns read-only flag for current item 

 When readonly on (default), sniffer is not allowed to change ROOT structures
 For instance, it is not allowed to read new objects from files

 When enabled (default), sniffer scans gROOT for files, canvases, histograms