ROOT logo
// @(#)root/base:$Id: TDataSetManager.cxx 37897 2011-01-27 15:24:59Z ganis $
// Author: Jan Fiete Grosse-Oetringhaus, 04.06.07

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDataSetManager                                                 //
//                                                                      //
// This class contains functions to handle datasets in PROOF            //
// It is the layer between TProofServ and the file system that stores   //
// the datasets.                                                        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


#include "TDataSetManager.h"

#include "Riostream.h"

#include "TEnv.h"
#include "TError.h"
#include "TFile.h"
#include "TFileCollection.h"
#include "TFileInfo.h"
#include "TFileStager.h"
#include "TMD5.h"
#include "THashList.h"
#include "TKey.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TParameter.h"
#include "TPRegexp.h"
#include "TRegexp.h"
#include "TSystem.h"
#include "TTree.h"
#include "TUrl.h"
#include "TVirtualMonitoring.h"

// One Gigabyte
#define DSM_ONE_GB (1073741824)

// Name for common datasets
TString TDataSetManager::fgCommonDataSetTag = "COMMON";
TList   *TDataSetManager::fgDataSetSrvMaps = 0;

ClassImp(TDataSetManager)

//_____________________________________________________________________________
TDataSetManager::TDataSetManager(const char *group, const char *user,
                                           const char *options)
                     : fGroup(group),
                       fUser(user), fCommonUser(), fCommonGroup(),
                       fGroupQuota(), fGroupUsed(),
                       fUserUsed(), fNTouchedFiles(0), fNOpenedFiles(0),
                       fNDisappearedFiles(0), fMTimeGroupConfig(-1)
{
   //
   // Main constructor

   // Fill default group and user if none is given
   if (fGroup.IsNull())
      fGroup = "default";
   if (fUser.IsNull()) {
      fUser = "--nouser--";
      // Get user logon name
      UserGroup_t *pw = gSystem->GetUserInfo();
      if (pw) {
         fUser = pw->fUser;
         delete pw;
      }
   }

   fGroupQuota.SetOwner();
   fGroupUsed.SetOwner();
   fUserUsed.SetOwner();

   fCommonUser = "COMMON";
   fCommonGroup = "COMMON";

   fNTouchedFiles = -1;
   fNOpenedFiles = -1;
   fNDisappearedFiles = -1;
   fMTimeGroupConfig = -1;

   fAvgFileSize = 50000000;  // Default 50 MB per file

   // Parse options
   ParseInitOpts(options);

   if (!fUser.IsNull() && !fGroup.IsNull()) {

      // If not in sandbox, construct the base URI using session defaults
      // (group, user) (syntax: /group/user/dsname[#[subdir/]objname])
      if (!TestBit(TDataSetManager::kIsSandbox))
         fBase.SetUri(TString(Form("/%s/%s/", fGroup.Data(), fUser.Data())));

   }

   // List of dataset server mapping instructions
   TString srvmaps(gEnv->GetValue("DataSet.SrvMaps",""));
   TString srvmapsenv(gSystem->Getenv("DATASETSRVMAPS"));
   if (!(srvmapsenv.IsNull())) {
      if (srvmapsenv.BeginsWith("+")) {
         if (!(srvmaps.IsNull())) srvmaps += ",";
         srvmaps += srvmapsenv(1,srvmapsenv.Length());
      } else {
         srvmaps = srvmapsenv;
      }
   }
   if (!(srvmaps.IsNull()) && !(fgDataSetSrvMaps = ParseDataSetSrvMaps(srvmaps)))
      Warning("TDataSetManager", "problems parsing DataSet.SrvMaps input info (%s)"
                                 " - ignoring", srvmaps.Data());

   // Read config file
   ReadGroupConfig(gEnv->GetValue("Proof.GroupFile", ""));
}

//______________________________________________________________________________
TDataSetManager::~TDataSetManager()
{
   // Destructor

   // Clear used space
   fGroupQuota.DeleteAll();
   fGroupUsed.DeleteAll();
   fUserUsed.DeleteAll();
}

//______________________________________________________________________________
void TDataSetManager::ParseInitOpts(const char *opts)
{
   // Parse the opts string and set the init bits accordingly
   // Available options:
   //    Cq:               set kCheckQuota
   //    Ar:               set kAllowRegister
   //    Av:               set kAllowVerify
   //    Ti:               set kTrustInfo
   //    Sb:               set kIsSandbox
   //    Ca:               set kUseCache or kDoNotUseCache
   // The opts string may also contain additional unrelated info: in such a case
   // the field delimited by the prefix "opt:" is analyzed, e.g. if opts is
   // "/tmp/dataset  opt:Cq:-Ar: root://lxb6046.cern.ch" only the substring
   // "Cq:-Ar:" will be parsed .

   // Default option bits
   ResetBit(TDataSetManager::kCheckQuota);
   SetBit(TDataSetManager::kAllowRegister);
   SetBit(TDataSetManager::kAllowVerify);
   SetBit(TDataSetManager::kTrustInfo);
   ResetBit(TDataSetManager::kIsSandbox);
   ResetBit(TDataSetManager::kUseCache);
   ResetBit(TDataSetManager::kDoNotUseCache);

   if (opts && strlen(opts) > 0) {
      TString opt(opts);
      // If it contains the prefix "opt:", isolate the related field
      Int_t ip = opt.Index("opt:");
      if (ip != kNPOS) opt.Remove(0, ip + 4);
      ip = opt.Index(" ");
      if (ip != kNPOS) opt.Remove(ip);
      // Check the content, now
      if (opt.Contains("Cq:") && !opt.Contains("-Cq:"))
         SetBit(TDataSetManager::kCheckQuota);
      if (opt.Contains("-Ar:"))
         ResetBit(TDataSetManager::kAllowRegister);
      if (opt.Contains("-Av:"))
         ResetBit(TDataSetManager::kAllowVerify);
      if (opt.Contains("-Ti:"))
         ResetBit(TDataSetManager::kTrustInfo);
      if (opt.Contains("Sb:") && !opt.Contains("-Sb:"))
         SetBit(TDataSetManager::kIsSandbox);
      if (opt.Contains("Ca:"))
         SetBit(TDataSetManager::kUseCache);
      if (opt.Contains("-Ca:"))
         SetBit(TDataSetManager::kDoNotUseCache);
   }

   // Check dependencies
   if (TestBit(TDataSetManager::kAllowVerify)) {
      // Dataset verification or requires registration permition
      SetBit(TDataSetManager::kAllowRegister);
   }
   // UseCache has priority
   if (TestBit(TDataSetManager::kUseCache) && TestBit(TDataSetManager::kDoNotUseCache))
      ResetBit(TDataSetManager::kDoNotUseCache);
}

//______________________________________________________________________________
Bool_t TDataSetManager::ReadGroupConfig(const char *cf)
{
   // Read group config file 'cf'.
   // If cf == 0 re-read, if changed, the file pointed by fGroupConfigFile .
   //
   // expects the following directives:
   // Group definition:
   //   group <groupname> <user>+
   // disk quota
   //   property <groupname> diskquota <quota in GB>
   // average filesize (to be used when the file size is not available)
   //   averagefilesize <average size>{G,g,M,m,K,k}

   // Validate input
   FileStat_t st;
   if (!cf || (strlen(cf) <= 0) || !strcmp(cf, fGroupConfigFile.Data())) {
      // If this is the first time we cannot do anything
      if (fGroupConfigFile.IsNull()) {
         if (gDebug > 0)
            Info("ReadGroupConfig", "path to config file undefined - nothing to do");
         return kFALSE;
      }
      // Check if fGroupConfigFile has changed
      if (gSystem->GetPathInfo(fGroupConfigFile, st)) {
         Error("ReadGroupConfig", "could not stat %s", fGroupConfigFile.Data());
         return kFALSE;
      }
      if (st.fMtime <= fMTimeGroupConfig) {
         if (gDebug > 0)
            Info("ReadGroupConfig","file has not changed - do nothing");
         return kTRUE;
      }
   }

   // Either new file or the file has changed
   if (cf && (strlen(cf) > 0)) {
      // The file must exist and be readable
      if (gSystem->GetPathInfo(cf, st)) {
         Error("ReadGroupConfig", "could not stat %s", cf);
         return kFALSE;
      }
      if (gSystem->AccessPathName(cf, kReadPermission)) {
         Error("ReadGroupConfig", "cannot read %s", cf);
         return kFALSE;
      }
      // Ok
      fGroupConfigFile = cf;
      fMTimeGroupConfig = st.fMtime;
   }

   if (gDebug > 0)
      Info("ReadGroupConfig","reading group config from %s", cf);

   // Open the config file
   ifstream in;
   in.open(cf);
   if (!in.is_open()) {
      Error("ReadGroupConfig", "could not open config file %s", cf);
      return kFALSE;
   }

   // Container for the global common user
   TString tmpCommonUser;

   // Go through
   TString line;
   while (in.good()) {
      // Read new line
      line.ReadLine(in);
      // Explicitely skip comment lines
      if (line[0] == '#') continue;
      // Parse it
      Ssiz_t from = 0;
      TString key;
      if (!line.Tokenize(key, from, " ")) // No token
         continue;
      // Parsing depends on the key
      if (key == "property") {
         // Read group
         TString grp;
         if (!line.Tokenize(grp, from, " ")) {// No token
            if (gDebug > 0)
               Info("ReadGroupConfig","incomplete line: '%s'", line.Data());
            continue;
         }
         // Read type of property
         TString type;
         if (!line.Tokenize(type, from, " ")) // No token
            continue;
         if (type == "diskquota") {
            // Read diskquota
            TString sdq;
            if (!line.Tokenize(sdq, from, " ")) // No token
               continue;
            // Enforce GigaBytes as default
            if (sdq.IsDigit()) sdq += "G";
            Long64_t quota = ToBytes(sdq);
            if (quota > -1) {
               fGroupQuota.Add(new TObjString(grp),
                               new TParameter<Long64_t> ("group quota", quota));
            } else {
               Warning("ReadGroupConfig",
                       "problems parsing string: wrong or unsupported suffix? %s",
                        sdq.Data());
            }
         } else if (type == "commonuser") {
            // Read common user for this group
            TString comusr;
            if (!line.Tokenize(comusr, from, " ")) // No token
               continue;

         }

      } else if (key == "dataset") {
         // Read type
         TString type;
         if (!line.Tokenize(type, from, " ")) {// No token
            if (gDebug > 0)
               Info("ReadGroupConfig","incomplete line: '%s'", line.Data());
            continue;
         }
         if (type == "commonuser") {
            // Read global common user
            TString comusr;
            if (!line.Tokenize(comusr, from, " ")) // No token
               continue;
            fCommonUser = comusr;
         } else if (type == "commongroup") {
            // Read global common group
            TString comgrp;
            if (!line.Tokenize(comgrp, from, " ")) // No token
               continue;
            fCommonGroup = comgrp;
         } else if (type == "diskquota") {
            // Quota check switch
            TString on;
            if (!line.Tokenize(on, from, " ")) // No token
               continue;
            if (on == "on") {
               SetBit(TDataSetManager::kCheckQuota);
            } else if (on == "off") {
               ResetBit(TDataSetManager::kCheckQuota);
            }
         }

      } else if (key == "averagefilesize") {

         // Read average size
         TString avgsize;
         if (!line.Tokenize(avgsize, from, " ")) {// No token
            if (gDebug > 0)
               Info("ReadGroupConfig","incomplete line: '%s'", line.Data());
            continue;
         }
         Long64_t avgsz = ToBytes(avgsize);
         if (avgsz > -1) {
            fAvgFileSize = avgsz;
         } else {
            Warning("ReadGroupConfig",
                    "problems parsing string: wrong or unsupported suffix? %s",
                    avgsize.Data());
         }
      } else if (key == "include") {

         // Read file to include
         TString subfn;
         if (!line.Tokenize(subfn, from, " ")) {// No token
            if (gDebug > 0)
               Info("ReadGroupConfig","incomplete line: '%s'", line.Data());
            continue;
         }
         // The file must be readable
         if (gSystem->AccessPathName(subfn, kReadPermission)) {
            Error("ReadGroupConfig", "request to parse file '%s' which is not readable",
                                     subfn.Data());
            continue;
         }
         if (!ReadGroupConfig(subfn))
            Error("ReadGroupConfig", "problems parsing include file '%s'", subfn.Data());
      }
   }
   in.close();

   return kTRUE;
}

//______________________________________________________________________________
Long64_t TDataSetManager::ToBytes(const char *size)
{
   // Static utility function to gt the number of bytes from a string
   // representation in the form "<digit><sfx>" with <sfx> = {"", "k", "M", "G",
   // "T", "P"} (case insensitive).
   // Returns -1 if the format is wrong.

   Long64_t lsize = -1;

   // Check if valid
   if (!size || strlen(size) <= 0) return lsize;

   TString s(size);
   // Determine factor
   Long64_t fact = 1;
   if (!s.IsDigit()) {
      const char *unit[5] = { "k", "M", "G", "T", "P"};
      fact = 1024;
      Int_t jj = 0;
      while (jj <= 4) {
         if (s.EndsWith(unit[jj], TString::kIgnoreCase)) {
            s.Remove(s.Length()-1);
            break;
         }
         fact *= 1024;
         jj++;
      }
   }
   // Apply factor now
   if (s.IsDigit())
      lsize = s.Atoi() * fact;

   // Done
   return lsize;
}

//______________________________________________________________________________
TFileCollection *TDataSetManager::GetDataSet(const char *, const char *)
{
   // Utility function used in various methods for user dataset upload.

   AbstractMethod("GetDataSet");
   return (TFileCollection *)0;
}

//______________________________________________________________________________
Bool_t TDataSetManager::RemoveDataSet(const char *)
{
   // Removes the indicated dataset

   AbstractMethod("RemoveDataSet");
   return kFALSE;
}

//______________________________________________________________________________
Bool_t TDataSetManager::ExistsDataSet(const char *)
{
   // Checks if the indicated dataset exits

   AbstractMethod("ExistsDataSet");
   return kFALSE;
}

//______________________________________________________________________________
TMap *TDataSetManager::GetDataSets(const char *, UInt_t)
{
   //
   // Returns all datasets for the <group> and <user> specified by <uri>.
   // If <user> is 0, it returns all datasets for the given <group>.
   // If <group> is 0, it returns all datasets.
   // The returned TMap contains:
   //    <group> --> <map of users> --> <map of datasets> --> <dataset> (TFileCollection)
   //
   // The unsigned int 'option' is forwarded to GetDataSet and BrowseDataSet.
   // Available options (to be .or.ed):
   //    kShowDefault    a default selection is shown that include the ones from
   //                    the current user, the ones from the group and the common ones
   //    kPrint          print the dataset content
   //    kQuotaUpdate    update quotas
   //    kExport         use export naming
   //
   // NB1: options "kPrint", "kQuoatUpdate" and "kExport" are mutually exclusive
   // NB2: for options "kPrint" and "kQuoatUpdate" return is null.

   AbstractMethod("GetDataSets");

   return (TMap *)0;
}
//______________________________________________________________________________
Int_t TDataSetManager::ScanDataSet(const char *uri, const char *opts)
{
   // Scans the dataset indicated by 'uri' following the 'opts' directives
   //
   // The 'opts' string contains up to 4 directive fields separated by ':'
   //
   //  'selection' field :
   //    A, allfiles:    process all files
   //    D, staged:      process only staged (on Disk) files (if 'allfiles:' is not specified
   //                    the default is to process only files marked as non-staged)
   //  'pre-action field':
   //    O, open:        open the files marked as staged when processing only files
   //                    marked as non-staged
   //    T, touch:       open and touch the files marked as staged when processing
   //                    only files marked as non-staged
   //    I, nostagedcheck: do not check the actual stage status on selected files
   //
   //  'process' field:
   //    N, noaction:    do nothing on the selected files
   //    P, fullproc:    open the selected files and extract the meta information
   //    L, locateonly:  only locate the selected files
   //    S, stageonly:   issue a stage request for the selected files not yet staged
   //
   //  'auxilliary' field
   //    V, verbose:     notify the actions
   //
   // Returns 0 on success, -1 if any failure occurs.

   // Extract the directives
   UInt_t o = 0;
   if (opts) {
      // Selection options
      if (strstr(opts, "allfiles:") || strchr(opts, 'A'))
         o |= kAllFiles;
      else if (strstr(opts, "staged:") || strchr(opts, 'D'))
         o |= kStagedFiles;
      // Pre-action options
      if (strstr(opts, "open:") || strchr(opts, 'O'))
         o |= kReopen;
      if (strstr(opts, "touch:") || strchr(opts, 'T'))
         o |= kTouch;
      if (strstr(opts, "nostagedcheck:") || strchr(opts, 'I'))
         o |= kNoStagedCheck;
      // Process options
      if (strstr(opts, "noaction:") || strchr(opts, 'N'))
         o |= kNoAction;
      if (strstr(opts, "locateonly:") || strchr(opts, 'L'))
         o |= kLocateOnly;
      if (strstr(opts, "stageonly:") || strchr(opts, 'S'))
         o |= kStageOnly;
      // Auxilliary options
      if (strstr(opts, "verbose:") || strchr(opts, 'V'))
         o |= kDebug;
   } else {
      // Default
      o = kReopen | kDebug;
   }

   // Run
   return ScanDataSet(uri, o);
}

//______________________________________________________________________________
Int_t TDataSetManager::ScanDataSet(const char *, UInt_t)
{
   // Scans the dataset indicated by <uri> and returns the number of missing files.
   // Returns -1 if any failure occurs.
   // For more details, see documentation of
   // ScanDataSet(TFileCollection *dataset, const char *option)

   AbstractMethod("ScanDataSet");

   return -1;
}

//______________________________________________________________________________
void TDataSetManager::GetQuota(const char *group, const char *user,
                                    const char *dsName, TFileCollection *dataset)
{
   //
   // Gets quota information from this dataset

   if (gDebug > 0)
      Info("GetQuota", "processing dataset %s %s %s", group, user, dsName);

   if (dataset->GetTotalSize() > 0) {
      TParameter<Long64_t> *size =
         dynamic_cast<TParameter<Long64_t>*> (fGroupUsed.GetValue(group));
      if (!size) {
         size = new TParameter<Long64_t> ("group used", 0);
         fGroupUsed.Add(new TObjString(group), size);
      }

      size->SetVal(size->GetVal() + dataset->GetTotalSize());

      TMap *userMap = dynamic_cast<TMap*> (fUserUsed.GetValue(group));
      if (!userMap) {
         userMap = new TMap;
         fUserUsed.Add(new TObjString(group), userMap);
      }

      size = dynamic_cast<TParameter<Long64_t>*> (userMap->GetValue(user));
      if (!size) {
         size = new TParameter<Long64_t> ("user used", 0);
         userMap->Add(new TObjString(user), size);
      }

      size->SetVal(size->GetVal() + dataset->GetTotalSize());
   }
}

//______________________________________________________________________________
void TDataSetManager::ShowQuota(const char *opt)
{
   // Display quota information

   UpdateUsedSpace();

   TMap *groupQuotaMap = GetGroupQuotaMap();
   TMap *userUsedMap = GetUserUsedMap();
   if (!groupQuotaMap || !userUsedMap)
      return;

   Bool_t noInfo = kTRUE;
   TIter iter(groupQuotaMap);
   TObjString *group = 0;
   while ((group = dynamic_cast<TObjString*> (iter.Next()))) {
      noInfo = kFALSE;
      Long64_t groupQuota = GetGroupQuota(group->String());
      Long64_t groupUsed = GetGroupUsed(group->String());

      Printf(" +++ Group %s uses %.1f GB out of %.1f GB", group->String().Data(),
                                        (Float_t) groupUsed / DSM_ONE_GB,
                                       (Float_t) groupQuota / DSM_ONE_GB);

      // display also user information
      if (opt && !TString(opt).Contains("U", TString::kIgnoreCase))
         continue;

      TMap *userMap = dynamic_cast<TMap*> (userUsedMap->GetValue(group->String()));
      if (!userMap)
         continue;

      TIter iter2(userMap);
      TObjString *user = 0;
      while ((user = dynamic_cast<TObjString*> (iter2.Next()))) {
         TParameter<Long64_t> *size2 =
            dynamic_cast<TParameter<Long64_t>*> (userMap->GetValue(user->String().Data()));
         if (!size2)
            continue;

         Printf(" +++  User %s uses %.1f GB", user->String().Data(),
                                  (Float_t) size2->GetVal() / DSM_ONE_GB);
      }

      Printf("------------------------------------------------------");
   }
   // Check if something has been printed
   if (noInfo) {
      Printf(" +++ Quota check enabled but no quota info available +++ ");
   }
}

//______________________________________________________________________________
void TDataSetManager::PrintUsedSpace()
{
   //
   // Prints the quota

   Info("PrintUsedSpace", "listing used space");

   TIter iter(&fUserUsed);
   TObjString *group = 0;
   while ((group = dynamic_cast<TObjString*> (iter.Next()))) {
      TMap *userMap = dynamic_cast<TMap*> (fUserUsed.GetValue(group->String()));

      TParameter<Long64_t> *size =
         dynamic_cast<TParameter<Long64_t>*> (fGroupUsed.GetValue(group->String()));

      if (userMap && size) {
         Printf("Group %s: %lld B = %.2f GB", group->String().Data(), size->GetVal(),
                                      (Float_t) size->GetVal() / DSM_ONE_GB);

         TIter iter2(userMap);
         TObjString *user = 0;
         while ((user = dynamic_cast<TObjString*> (iter2.Next()))) {
            TParameter<Long64_t> *size2 =
               dynamic_cast<TParameter<Long64_t>*> (userMap->GetValue(user->String().Data()));
            if (size2)
               Printf("  User %s: %lld B = %.2f GB", user->String().Data(), size2->GetVal(),
                                            (Float_t) size2->GetVal() / DSM_ONE_GB);
         }

         Printf("------------------------------------------------------");
      }
   }
}

//______________________________________________________________________________
void TDataSetManager::MonitorUsedSpace(TVirtualMonitoringWriter *monitoring)
{
   //
   // Log info to the monitoring server

   Info("MonitorUsedSpace", "sending used space to monitoring server");

   TIter iter(&fUserUsed);
   TObjString *group = 0;
   while ((group = dynamic_cast<TObjString*> (iter.Next()))) {
      TMap *userMap = dynamic_cast<TMap*> (fUserUsed.GetValue(group->String()));
      TParameter<Long64_t> *size =
         dynamic_cast<TParameter<Long64_t>*> (fGroupUsed.GetValue(group->String()));

      if (!userMap || !size)
         continue;

      TList *list = new TList;
      list->SetOwner();
      list->Add(new TParameter<Long64_t>("_TOTAL_", size->GetVal()));
      Long64_t groupQuota = GetGroupQuota(group->String());
      if (groupQuota != -1)
         list->Add(new TParameter<Long64_t>("_QUOTA_", groupQuota));

      TIter iter2(userMap);
      TObjString *user = 0;
      while ((user = dynamic_cast<TObjString*> (iter2.Next()))) {
         TParameter<Long64_t> *size2 =
            dynamic_cast<TParameter<Long64_t>*> (userMap->GetValue(user->String().Data()));
         if (!size2)
            continue;
         list->Add(new TParameter<Long64_t>(user->String().Data(), size2->GetVal()));
      }

      monitoring->SendParameters(list, group->String());
      delete list;
   }
}

//______________________________________________________________________________
Long64_t TDataSetManager::GetGroupUsed(const char *group)
{
   //
   // Returns the used space of that group

   if (fgCommonDataSetTag == group)
      group = fCommonGroup;

   TParameter<Long64_t> *size =
      dynamic_cast<TParameter<Long64_t>*> (fGroupUsed.GetValue(group));
   if (!size) {
      if (gDebug > 0)
         Info("GetGroupUsed", "group %s not found", group);
      return 0;
   }

   return size->GetVal();
}

//______________________________________________________________________________
Long64_t TDataSetManager::GetGroupQuota(const char *group)
{
   //
   // returns the quota a group is allowed to have

   if (fgCommonDataSetTag == group)
      group = fCommonGroup;

   TParameter<Long64_t> *value =
      dynamic_cast<TParameter<Long64_t>*> (fGroupQuota.GetValue(group));
   if (!value) {
      if (gDebug > 0)
         Info("GetGroupQuota", "group %s not found", group);
      return 0;
   }
   return value->GetVal();
}

//______________________________________________________________________________
void TDataSetManager::UpdateUsedSpace()
{
   // updates the used space maps

   AbstractMethod("UpdateUsedSpace");
}

//______________________________________________________________________________
Int_t TDataSetManager::RegisterDataSet(const char *,
                                       TFileCollection *, const char *)
{
   // Register a dataset, perfoming quota checkings, if needed.
   // Returns 0 on success, -1 on failure

   AbstractMethod("RegisterDataSet");
   return -1;
}

//______________________________________________________________________________
Int_t TDataSetManager::NotifyUpdate(const char * /*group*/,
                                    const char * /*user*/,
                                    const char * /*dspath*/,
                                    Long_t /*mtime*/,
                                    const char * /*checksum*/)
{
   // Save into the <datasetdir>/dataset.list file the name of the last updated
   // or created or modified dataset
   // Returns 0 on success, -1 on error

   AbstractMethod("NotifyUpdate");
   return -1;
}

//______________________________________________________________________________
Int_t TDataSetManager::ClearCache(const char * /*uri*/)
{
   // Clear cached information matching uri

   AbstractMethod("ClearCache");
   return -1;
}

//______________________________________________________________________________
Int_t TDataSetManager::ShowCache(const char * /*uri*/)
{
   // Show cached information matching uri

   AbstractMethod("ShowCache");
   return -1;
}

//______________________________________________________________________________
TString TDataSetManager::CreateUri(const char *dsGroup, const char *dsUser,
                                        const char *dsName, const char *dsObjPath)
{
   // Creates URI for the dataset manger in the form '[[/dsGroup/]dsUser/]dsName[#dsObjPath]',
   // The optional dsObjPath can be in the form [subdir/]objname]'.

   TString uri;

   if (dsGroup && strlen(dsGroup) > 0) {
      if (dsUser && strlen(dsUser) > 0) {
         uri += Form("/%s/%s/", dsGroup, dsUser);
      } else {
         uri += Form("/%s/*/", dsGroup);
      }
   } else if (dsUser && strlen(dsUser) > 0) {
      uri += Form("%s/", dsUser);
   }
   if (dsName && strlen(dsName) > 0)
      uri += dsName;
   if (dsObjPath && strlen(dsObjPath) > 0)
      uri += Form("#%s", dsObjPath);

   // Done
   return uri;
}

//______________________________________________________________________________
Bool_t TDataSetManager::ParseUri(const char *uri,
                                 TString *dsGroup, TString *dsUser,
                                 TString *dsName, TString *dsTree,
                                 Bool_t onlyCurrent, Bool_t wildcards)
{
   // Parses a (relative) URI that describes a DataSet on the cluster.
   // The input 'uri' should be in the form '[[/group/]user/]dsname[#[subdir/]objname]',
   //  where 'objname' is the name of the object (e.g. the tree name) and the 'subdir'
   // is the directory in the file wher it should be looked for.
   // After resolving against a base URI consisting of proof://masterhost/group/user/
   // - meaning masterhost, group and user of the current session -
   // the path is checked to contain exactly three elements separated by '/':
   // group/user/dsname
   // If wildcards, '*' is allowed in group and user and dsname is allowed to be empty.
   // If onlyCurrent, only group and user of current session are allowed.
   // Only non-null parameters are filled by this function.
   // Returns kTRUE in case of success.

   // Append trailing slash if missing when wildcards are enabled
   TString uristr(uri);
   Int_t pc = 0;
   if (wildcards && uristr.Length() > 0) {
      pc = uristr.CountChar('/');
      Bool_t endsl = uristr.EndsWith("/") ? kTRUE : kFALSE;
      Bool_t beginsl = uristr.BeginsWith("/") ? kTRUE : kFALSE;
      if (beginsl) {
         if (pc == 1) uristr += "/*/";
         if (pc == 2 && endsl) uristr += "*/";
         if (pc == 2 && !endsl) uristr += "/";
      }
   }

   // Resolve given URI agains the base
   TUri resolved = TUri::Transform(uristr, fBase);
   if (resolved.HasQuery())
      Info ("ParseUri", "URI query part <%s> ignored", resolved.GetQuery().Data());

   TString path(resolved.GetPath());
   // Must be in the form /group/user/dsname
   if ((pc = path.CountChar('/')) != 3) {
      if (!TestBit(TDataSetManager::kIsSandbox)) {
         Error ("ParseUri", "illegal dataset path: '%s'", uri);
         return kFALSE;
      } else if (pc >= 0 && pc < 3) {
         // Add missing slashes
         TString sls("/");
         if (pc == 2) {
            sls = "/";
         } else if (pc == 1) {
            sls.Form("/%s/", fGroup.Data());
         } else if (pc == 0) {
            sls.Form("/%s/%s/", fGroup.Data(), fUser.Data());
         }
         path.Insert(0, sls);
      }
   }
   if (gDebug > 1)
      Info("ParseUri", "path: '%s'", path.Data());

   // Get individual values from tokens
   Int_t from = 1;
   TString group, user, name;
   path.Tokenize(group, from, "/");
   path.Tokenize(user, from, "/");
   path.Tokenize(name, from, "/");

   // The fragment may contain the subdir and the object name in the form '[subdir/]objname'
   TString tree = resolved.GetFragment();
   if (tree.EndsWith("/"))
      tree.Remove(tree.Length()-1);

   if (gDebug > 1)
      Info("ParseUri", "group: '%s', user: '%s', dsname:'%s', seg: '%s'",
                              group.Data(), user.Data(), name.Data(), tree.Data());

   // Check for unwanted use of wildcards
   if ((user == "*" || group == "*") && !wildcards) {
      Error ("ParseUri", "no wildcards allowed for user/group in this context (uri: '%s')", uri);
      return kFALSE;
   }

   // dsname may only be empty if wildcards expected
   if (name.IsNull() && !wildcards) {
      Error ("ParseUri", "DataSet name is empty");
      return kFALSE;
   }

   // Construct regexp whitelist for checking illegal characters in user/group
   TPRegexp wcExp (wildcards ? "^(?:[A-Za-z0-9-*_.]*|[*])$" : "^[A-Za-z0-9-_.]*$");

   // Check for illegal characters in all components
   if (!wcExp.Match(group)) {
      Error("ParseUri", "illegal characters in group (uri: '%s', group: '%s')", uri, group.Data());
      return kFALSE;
   }

   if (!wcExp.Match(user)) {
      Error("ParseUri", "illegal characters in user (uri: '%s', user: '%s')", uri, user.Data());
      return kFALSE;
   }

   // Construct regexp whitelist for checking illegal characters in name
   if (!wcExp.Match(name)) {
      Error("ParseUri", "illegal characters in name (uri: '%s', name: '%s')", uri, name.Data());
      return kFALSE;
   }

   if (tree.Contains(TRegexp("[^A-Za-z0-9-/_]"))) {
      Error("ParseUri", "Illegal characters in subdir/object name (uri: '%s', obj: '%s')", uri, tree.Data());
      return kFALSE;
   }

   // Check user & group
   if (onlyCurrent && (group.CompareTo(fGroup) || user.CompareTo(fUser))) {
      Error("ParseUri", "only datasets from your group/user allowed");
      return kFALSE;
   }

   // fill parameters passed by reference, if defined
   if (dsGroup)
      *dsGroup = group;
   if (dsUser)
      *dsUser = user;
   if (dsName)
      *dsName = name;
   if (dsTree)
      *dsTree = tree;

   return kTRUE;
}

//______________________________________________________________________________
TMap *TDataSetManager::GetSubDataSets(const char *ds, const char *exclude)
{
   // Partition dataset 'ds' accordingly to the servers.
   // The returned TMap contains:
   //                <server> --> <subdataset> (TFileCollection)
   // where <subdataset> is the subset of 'ds' on <server>
   // The partitioning is done using all the URLs in the TFileInfo's, so the
   // resulting datasets are not mutually exclusive.
   // The string 'exclude' contains a comma-separated list of servers to exclude
   // from the map.

   TMap *map = (TMap *)0;

   if (!ds || strlen(ds) <= 0) {
      Info("GetDataSets", "dataset name undefined!");
      return map;
   }

   // Get the dataset
   TFileCollection *fc = GetDataSet(ds);
   if (!fc) {
      Info("GetDataSets", "could not retrieve the dataset '%s'", ds);
      return map;
   }

   // Get the subset
   if (!(map = fc->GetFilesPerServer(exclude))) {
      if (gDebug > 0)
         Info("GetDataSets", "could not get map for '%s'", ds);
   }

   // Cleanup
   delete fc;

   // Done
   return map;
}

//______________________________________________________________________________
void TDataSetManager::PrintDataSet(TFileCollection *fc, Int_t popt)
{
   // Formatted printout of the content of TFileCollection 'fc'.
   // Options in the form
   //           popt = u * 10 + f
   //     f    0 => header only, 1 => header + files
   //   when printing files
   //     u    0 => print file name only, 1 => print full URL

   if (!fc) return;

   Int_t f = popt%10;
   Int_t u = popt - 10 * f;

   Printf("+++");
   if (fc->GetTitle() && (strlen(fc->GetTitle()) > 0)) {
      Printf("+++ Dumping: %s: ", fc->GetTitle());
   } else {
      Printf("+++ Dumping: %s: ", fc->GetName());
   }
   Printf("%s", fc->ExportInfo("+++ Summary:", 1)->GetName());
   if (f == 1) {
      Printf("+++ Files:");
      Int_t nf = 0;
      TIter nxfi(fc->GetList());
      TFileInfo *fi = 0;
      while ((fi = (TFileInfo *)nxfi())) {
         if (u == 1)
            Printf("+++ %5d. %s", ++nf, fi->GetCurrentUrl()->GetUrl());
         else
            Printf("+++ %5d. %s", ++nf, fi->GetCurrentUrl()->GetFile());
      }
   }
   Printf("+++");
}

//______________________________________________________________________________
void TDataSetManager::ShowDataSets(const char *uri, const char *opt)
{
   // Prints formatted information about the dataset 'uri'.
   // The type and format of output is driven by 'opt':
   //
   //   1. opt = "server:srv1[,srv2[,srv3[,...]]]"
   //            Print info about the subsets of 'uri' on servers srv1, srv2, ...
   //   2. opt = "servers[:exclude:srv1[,srv2[,srv3[,...]]]]"
   //            Print info about the subsets of 'uri' on all servers, except
   //            the ones in the exclude list srv1, srv2, ...
   //   3. opt = <any>
   //            Print info about all datasets matching 'uri'
   //
   //   If 'opt' contains 'full:' the list of files in the datasets are also printed.
   //   In case 3. this is enabled only if 'uri' matches a single dataset.
   //
   //   In case 3, if 'opt' contains
   //      'full:'      the list of files in the datasets are also printed.
   //      'forcescan:' the dataset are open to get the information; otherwise the
   //                   pre-processed information is used.
   //      'noheader:'  the labelling header is not printed; usefull when to chain
   //                   several printouts
   //      'noupdate:'  do not update the cache (which may be slow on very remote
   //                   servers)
   //      'refresh:'   refresh the information (requires appropriate credentials;
   //                   typically it can be done only for owned datasets)

   TFileCollection *fc = 0;
   TString o(opt);
   Int_t popt = 0;
   if (o.Contains("full:")) {
      o.ReplaceAll("full:","");
      popt = 1;
   }
   if (o.BeginsWith("server:")) {
      o.ReplaceAll("server:", "");
      TString srv;
      Int_t from = 0;
      while ((o.Tokenize(srv, from, ","))) {
         fc = GetDataSet(uri, srv.Data());
         PrintDataSet(fc, popt);
         delete fc;
      }
   } else if (o.BeginsWith("servers")) {
      o.ReplaceAll("servers", "");
      if (o.BeginsWith(":exclude:"))
         o.ReplaceAll(":exclude:", "");
      else
         o = "";
      TMap *dsmap = GetSubDataSets(uri, o.Data());
      if (dsmap) {
         TIter nxk(dsmap);
         TObject *k = 0;
         while ((k = nxk()) && (fc = (TFileCollection *) dsmap->GetValue(k))) {
            PrintDataSet(fc, popt);
         }
         delete dsmap;
      }
   } else {
      TString u(uri), grp, usr, dsn;
      // Support for "*" or "/*"
      if (u == "" || u == "*" || u == "/*" || u == "/*/" || u == "/*/*") u = "/*/*/";
      if (!ParseUri(u.Data(), &grp, &usr, &dsn, 0, kFALSE, kTRUE))
         Warning("ShowDataSets", "problems parsing URI '%s'", uri);
      // Scan the existing datasets and print the content
      UInt_t xopt = (UInt_t)(TDataSetManager::kPrint);
      if (o.Contains("forcescan:")) xopt |= (UInt_t)(TDataSetManager::kForceScan);
      if (o.Contains("noheader:")) xopt |= (UInt_t)(TDataSetManager::kNoHeaderPrint);
      if (o.Contains("noupdate:")) xopt |= (UInt_t)(TDataSetManager::kNoCacheUpdate);
      if (o.Contains("refresh:")) xopt |= (UInt_t)(TDataSetManager::kRefreshLs);
      if (!u.IsNull() && !u.Contains("*") && !grp.IsNull() && !usr.IsNull() && !dsn.IsNull()) {
         if (ExistsDataSet(uri)) {
            // Single dataset
            if (popt == 0) {
               // Quick listing
               GetDataSets(u.Data(), xopt);
            } else if ((fc = GetDataSet(uri))) {
               // Full print option
               PrintDataSet(fc, 10 + popt);
               delete fc;
            }
            return;
         }
         // Try all the directories
         TRegexp reg(grp, kTRUE), reu(usr, kTRUE);
         if (u.Index(reg) == kNPOS) grp = "*";
         if (u.Index(reu) == kNPOS) usr = "*";
         // Rebuild the uri
         u.Form("/%s/%s/%s", grp.Data(), usr.Data(), dsn.Data());
      }
      GetDataSets(u.Data(), xopt);
   }

   return;
}

//______________________________________________________________________________
Int_t TDataSetManager::ScanDataSet(TFileCollection *dataset,
                                   Int_t fopt, Int_t sopt, Int_t ropt, Bool_t dbg,
                                   Int_t *touched, Int_t *opened, Int_t *disappeared,
                                   TList *flist, Long64_t avgsz, const char *mss,
                                   Int_t maxfiles, const char *stageopts)
{
   // Go through the files in the specified dataset, selecting files according to
   // 'fopt' and doing on these files the actions described by 'sopt'.
   // If required, the information in 'dataset' is updated.
   //
   // The int fopt controls which files have to be processed (or added to the list
   // if ropt is 1 - see below); 'fopt' is defined in term of csopt and fsopt:
   //                    fopt = sign(fsopt) * csopt * 100 + fsopt
   // where 'fsopt' controls the actual selection
   //    -1              all files in the dataset
   //     0              process only files marked as 'non-staged'
   //   >=1              as 0 but files that are marked 'staged' are open
   //   >=2              as 1 but files that are marked 'staged' are touched
   //    10              process only files marked as 'staged'; files marked as 'non-staged'
   //                    are ignored
   // and 'csopt' controls if an actual check on the staged status (via TFileStager) is done
   //     0              check that the file is staged using TFileStager
   //     1              do not hard check the staged status
   // (example: use fopt = -101 to check the staged status of all the files, or fopt = 110
   //  to re-check the stage status of all the files marked as staged)
   //
   // If 'dbg' is true, some information about the ongoing operations is reguraly
   // printed; this can be useful when processing very large datasets, an operation
   // which can take a very long time.
   //
   // The int 'sopt' controls what is done on the selected files (this is effective only
   // if ropt is 0 or 2 - see below):
   //    -1              no action (fopt = 2 and sopt = -1 touches all staged files)
   //     0              do the full process: open the files and fill the meta-information
   //                    in the TFileInfo object, including the end-point URL
   //     1              only locate the files, by updating the end-point URL (uses TFileStager::Locate
   //                    which is must faster of an TFile::Open)
   //     2              issue a stage request on the files
   //
   // The int 'ropt' controls which actions are performed:
   //     0              do the full process: get list of files to process and process them
   //     1              get the list of files to be scanned and return it in flist
   //     2              process the files in flist (according to sopt)
   // When defined flist is under the responsability the caller.
   //
   // If avgsz > 0 it is used for the final update of the dataset global counters.
   //
   // If 'mss' is defined use it to initialize the stager (instead of the Url in the
   // TFileInfo objects)
   //
   // If maxfiles > 0, select for processing a maximum of 'filesmax' files (but if fopt is 1 or 2
   // all files marked as 'staged' are still open or touched)
   //
   // Return code
   //     1 dataset was not changed
   //     2 dataset was changed
   //
   // The number of touched, opened and disappeared files are returned in the respective
   // variables, if these are defined.

   // Max number of files
   if (maxfiles > -1 && dbg)
      ::Info("TDataSetManager::ScanDataSet", "processing a maximum of %d files", maxfiles);

   // File selection, Reopen and Touch options
   Bool_t allf     = (fopt == -1)               ? kTRUE : kFALSE;
   Bool_t checkstg = (fopt >= 100 || fopt < -1) ? kFALSE : kTRUE;
   if (fopt >= 0) fopt %= 100;
   Bool_t nonstgf  = (fopt >= 0 && fopt < 10)   ? kTRUE : kFALSE;
   Bool_t reopen   = (fopt >= 1 && fopt < 10)   ? kTRUE : kFALSE;
   Bool_t touch    = (fopt >= 2 && fopt < 10)   ? kTRUE : kFALSE;
   Bool_t stgf     = (fopt == 10)               ? kTRUE : kFALSE;

   // File processing options
   Bool_t noaction   = (sopt == -1) ? kTRUE : kFALSE;
   Bool_t fullproc   = (sopt == 0)  ? kTRUE : kFALSE;
   Bool_t locateonly = (sopt == 1)  ? kTRUE : kFALSE;
   Bool_t stageonly  = (sopt == 2)  ? kTRUE : kFALSE;

   // Run options
   Bool_t doall       = (ropt == 0) ? kTRUE : kFALSE;
   Bool_t getlistonly = (ropt == 1) ? kTRUE : kFALSE;
   Bool_t scanlist    = (ropt == 2) ? kTRUE : kFALSE;
   if (scanlist && !flist) {
      ::Error("TDataSetManager::ScanDataSet", "input list is mandatory for option 'scan file list'");
      return -1;
   }

   Int_t ftouched = 0;
   Int_t fopened = 0;
   Int_t fdisappeared = 0;

   Bool_t changed = kFALSE;

   TList *newStagedFiles = 0;
   TFileInfo *fileInfo = 0;
   TFileStager *stager = 0;
   Bool_t createStager = kFALSE;

   if (doall || getlistonly) {

      // Point to the list
      newStagedFiles = (!doall && getlistonly && flist) ? flist : new TList;
      if (newStagedFiles != flist) newStagedFiles->SetOwner(kFALSE);

      stager = (mss && strlen(mss) > 0) ? TFileStager::Open(mss) : 0;
      createStager = (stager) ? kFALSE : kTRUE;

      // Check which files have been staged, this can be replaced by a bulk command,
      // once it exists in the xrdclient
      TIter iter2(dataset->GetList());
      while ((fileInfo = (TFileInfo *) iter2())) {

         // For real time monitoring
         gSystem->DispatchOneEvent(kTRUE);

         if (!allf) {

            fileInfo->ResetUrl();
            if (!fileInfo->GetCurrentUrl()) {
               ::Error("TDataSetManager::ScanDataSet", "GetCurrentUrl() returned 0 for %s",
                                                      fileInfo->GetFirstUrl()->GetUrl());
               continue;
            }

            if (nonstgf && fileInfo->TestBit(TFileInfo::kStaged)) {

               // Skip files flagged as corrupted
               if (fileInfo->TestBit(TFileInfo::kCorrupted)) continue;

               // Skip if we are not asked to re-open the staged files
               if (!reopen) continue;

               // Set the URL removing the anchor (e.g. #AliESDs.root) because IsStaged()
               // and TFile::Open() with filetype=raw do not accept anchors
               TUrl *curl = fileInfo->GetCurrentUrl();
               const char *furl = curl->GetUrl();
               TString urlmod;
               if (TDataSetManager::CheckDataSetSrvMaps(curl, urlmod) && !(urlmod.IsNull()))
                  furl = urlmod.Data();
               TUrl url(furl);   
               url.SetAnchor("");

               // Notify
               if (dbg && (ftouched+fdisappeared) % 100 == 0)
                  ::Info("TDataSetManager::ScanDataSet", "opening %d: file: %s",
                        ftouched + fdisappeared, curl->GetUrl());

               // Check if file is still available, if touch is set actually read from the file
               TString uopt(url.GetOptions());
               uopt += "filetype=raw&mxredir=2";
               url.SetOptions(uopt.Data());
               TFile *file = TFile::Open(url.GetUrl());
               if (file) {
                  if (touch) {
                     // Actually access the file
                     char tmpChar = 0;
                     file->ReadBuffer(&tmpChar, 1);
                     // Count
                     ftouched++;
                  }
                  file->Close();
                  delete file;
               } else {
                  // File could not be opened, reset staged bit
                  if (dbg) ::Info("TDataSetManager::ScanDataSet", "file %s disappeared", url.GetUrl());
                  fileInfo->ResetBit(TFileInfo::kStaged);
                  fdisappeared++;
                  changed = kTRUE;

                  // Remove invalid URL, if other one left...
                  if (fileInfo->GetNUrls() > 1)
                     fileInfo->RemoveUrl(curl->GetUrl());
               }
               // Go to next
               continue;

            } else if (stgf && !(fileInfo->TestBit(TFileInfo::kStaged))) {
               // All staged files are processed: skip non staged
               continue;
            }
         }

         // Only open maximum number of 'new' files
         if (maxfiles > 0 && newStagedFiles->GetEntries() >= maxfiles)
            continue;

         // Hard check of the staged status, if required
         if (checkstg) {
            // Set the URL removing the anchor (e.g. #AliESDs.root) because IsStaged()
            // and TFile::Open() with filetype=raw do not accept anchors
            TUrl *curl = fileInfo->GetCurrentUrl();
            const char *furl = curl->GetUrl();
            TString urlmod;
            Bool_t mapped = kFALSE;
            if (TDataSetManager::CheckDataSetSrvMaps(curl, urlmod) && !(urlmod.IsNull())) {
               furl = urlmod.Data();
               mapped = kTRUE;
            }
            TUrl url(furl);
            url.SetAnchor("");

            // Get the stager (either the global one or from the URL)
            stager = createStager ? TFileStager::Open(url.GetUrl()) : stager;

            Bool_t result = kFALSE;
            if (stager) {
               result = stager->IsStaged(url.GetUrl());
               if (gDebug > 0)
                  ::Info("TDataSetManager::ScanDataSet", "IsStaged: %s: %d", url.GetUrl(), result);
               if (createStager)
                  SafeDelete(stager);
            } else {
               ::Warning("TDataSetManager::ScanDataSet",
                        "could not get stager instance for '%s'", url.GetUrl());
            }

            // Go to next in case of failure
            if (!result) {
               if (fileInfo->TestBit(TFileInfo::kStaged)) {
                  // Reset the bit
                  fileInfo->ResetBit(TFileInfo::kStaged);
                  changed = kTRUE;
               }
               continue;
            } else {
               if (!(fileInfo->TestBit(TFileInfo::kStaged))) {
                  // Set the bit
                  fileInfo->SetBit(TFileInfo::kStaged);
                  changed = kTRUE;
               }
            }

            // If the url was re-mapped add the new url in front of the list
            if (mapped) {
               url.SetOptions(curl->GetOptions());
               url.SetAnchor(curl->GetAnchor());
               fileInfo->AddUrl(url.GetUrl(), kTRUE);
            }
         }

         // Register the newly staged file
         if (!noaction) newStagedFiles->Add(fileInfo);
      }
      SafeDelete(stager);

      // If required to only get the list we are done
      if (getlistonly) {
         if (dbg && newStagedFiles->GetEntries() > 0)
            ::Info("TDataSetManager::ScanDataSet", " %d files appear to be newly staged",
                                                   newStagedFiles->GetEntries());
         if (!flist) SafeDelete(newStagedFiles);
         return ((changed) ? 2 : 1);
      }
   }

   if (!noaction && (doall || scanlist)) {

      // Point to the list
      newStagedFiles = (!doall && scanlist && flist) ? flist : newStagedFiles;
      if (newStagedFiles != flist) newStagedFiles->SetOwner(kFALSE);

      // loop over now staged files
      if (dbg && newStagedFiles->GetEntries() > 0)
         ::Info("TDataSetManager::ScanDataSet", "opening %d files that appear to be newly staged",
                                                newStagedFiles->GetEntries());

      // If staging files, prepare the stager
      if (locateonly || stageonly) {
         stager = (mss && strlen(mss) > 0) ? TFileStager::Open(mss) : 0;
         createStager = (stager) ? kFALSE : kTRUE;
      }

      // Notify each 'fqnot' files (min 1, max 100)
      Int_t fqnot = (newStagedFiles->GetSize() > 10) ? newStagedFiles->GetSize() / 10 : 1;
      if (fqnot > 100) fqnot = 100;
      Int_t count = 0;
      TIter iter3(newStagedFiles);
      while ((fileInfo = (TFileInfo *) iter3())) {

         if (dbg && (count%fqnot == 0))
            ::Info("TDataSetManager::ScanDataSet", "processing %d.'new' file: %s",
                                                   count, fileInfo->GetCurrentUrl()->GetUrl());
         count++;

         // For real time monitoring
         gSystem->DispatchOneEvent(kTRUE);

         Int_t rc = -1;
         // Set the URL removing the anchor (e.g. #AliESDs.root) because IsStaged()
         // and TFile::Open() with filetype=raw do not accept anchors
         TUrl *curl = fileInfo->GetCurrentUrl();
         const char *furl = curl->GetUrl();
         TString urlmod;
         Bool_t mapped = kFALSE;
         if (TDataSetManager::CheckDataSetSrvMaps(curl, urlmod) && !(urlmod.IsNull())) {
            furl = urlmod.Data();
            mapped = kTRUE;
         }
         TUrl url(furl);
         url.SetOptions("");
         url.SetAnchor("");
         // Point to the right stager
         if (createStager) {
            if (!stager || (stager && !stager->Matches(url.GetUrl()))) {
               SafeDelete(stager);
               if (!(stager = TFileStager::Open(url.GetUrl())) || !(stager->IsValid())) {
                  ::Error("TDataSetManager::ScanDataSet",
                           "could not get valid stager instance for '%s'", url.GetUrl());
                  continue;
               }
            }
         }
         // Locate the file, if just requested so
         if (locateonly) {
            TString eurl;
            if (stager && stager->Locate(url.GetUrl(), eurl) == 0) {
               TString opts(curl->GetOptions());
               TString anch(curl->GetAnchor());
               // Get the effective end-point Url
               curl->SetUrl(eurl);
               // Restore original options and anchor, if any
               curl->SetOptions(opts);
               curl->SetAnchor(anch);
               // Flag and count
               changed = kTRUE;
               fopened++;
            } else {
               // Failure
               ::Error("TDataSetManager::ScanDataSet", "could not locate %s", url.GetUrl());
            }
         } else if (stageonly) {
            if (stager && !(stager->IsStaged(url.GetUrl()))) {
               if (!(stager->Stage(url.GetUrl(), stageopts))) {
                  // Failure
                  ::Error("TDataSetManager::ScanDataSet",
                           "problems issuing stage request for %s", url.GetUrl());
               }
            }
         } else if (fullproc) {
            // Full file validation
            rc = -2;
            Bool_t doscan = kTRUE;
            if (checkstg) {
               doscan = kFALSE;
               if ((doall && fileInfo->TestBit(TFileInfo::kStaged)) ||
                   (stager && stager->IsStaged(url.GetUrl()))) doscan = kTRUE;
            }
            if (doscan) {
               if ((rc = TDataSetManager::ScanFile(fileInfo, dbg)) < -1) continue;
               changed = kTRUE;
            } else if (stager) {
               ::Warning("TDataSetManager::ScanDataSet",
                         "required file '%s' does not look as being online (staged)", url.GetUrl());
            }
            if (rc < 0) continue;
            // Count
            fopened++;
         }
      }
      if (newStagedFiles != flist) SafeDelete(newStagedFiles);

      dataset->RemoveDuplicates();
      dataset->Update(avgsz);
   }

   Int_t result = (changed) ? 2 : 1;
   if (result > 0 && dbg)
      ::Info("TDataSetManager::ScanDataSet", "%d files 'new'; %d files touched;"
                                             " %d files disappeared", fopened, ftouched, fdisappeared);

   // Fill outputs, if required
   if (touched) *touched = ftouched;
   if (opened) *opened = fopened;
   if (disappeared) *disappeared = fdisappeared;

   // For real time monitoring
   gSystem->DispatchOneEvent(kTRUE);

   return result;
}

//______________________________________________________________________________
Int_t TDataSetManager::ScanFile(TFileInfo *fileinfo, Bool_t dbg)
{
   // Open the file described by 'fileinfo' to extract the relevant meta-information.
   // Return 0 if OK, -2 if the file cannot be open, -1 if it is corrupted

   Int_t rc = -2;
   // We need an input
   if (!fileinfo) {
      ::Error("TDataSetManager::ScanFile", "undefined input (!)");
      return rc;
   }

   TUrl *url = fileinfo->GetCurrentUrl();

   TFile *file = 0;

   // To determine the size we have to open the file without the anchor
   // (otherwise we get the size of the contained file - in case of a zip archive)
   // We open in raw mode which makes sure that the opening succeeds, even if
   // the file is corrupted
   const char *furl = url->GetUrl();
   TString urlmod;
   if (TDataSetManager::CheckDataSetSrvMaps(url, urlmod) && !(urlmod.IsNull()))
      furl = urlmod.Data();
   TUrl urlNoAnchor(furl);
   urlNoAnchor.SetAnchor("");
   urlNoAnchor.SetOptions("filetype=raw");
   // Wait max 5 secs per file
   if (!(file = TFile::Open(urlNoAnchor.GetUrl(), "TIMEOUT=5"))) return rc;

   // OK, set the relevant flags
   rc = -1;
   fileinfo->SetBit(TFileInfo::kStaged);

   // Add url of the disk server in front of the list
   TUrl eurl(*(file->GetEndpointUrl()));
   eurl.SetOptions(url->GetOptions());
   eurl.SetAnchor(url->GetAnchor());
   fileinfo->AddUrl(eurl.GetUrl(), kTRUE);

   if (gDebug > 0) ::Info("TDataSetManager::ScanFile", "added URL %s", eurl.GetUrl());

   if (file->GetSize() > 0) fileinfo->SetSize(file->GetSize());
   fileinfo->SetUUID(file->GetUUID().AsString());

   file->Close();
   delete file;

   // Disable warnings when reading a tree without loading the corresponding library
   Int_t oldLevel = gErrorIgnoreLevel;
   gErrorIgnoreLevel = kError+1;

   // Wait max 5 secs per file
   if (!(file = TFile::Open(url->GetUrl(), "TIMEOUT=5"))) {
      // If the file could be opened before, but fails now it is corrupt...
      if (dbg) ::Info("TDataSetManager::ScanFile", "marking %s as corrupt", url->GetUrl());
      fileinfo->SetBit(TFileInfo::kCorrupted);
      // Set back old warning level
      gErrorIgnoreLevel = oldLevel;
      return rc;
   }
   rc = 0;

   // Loop over all entries and create/update corresponding metadata.
   // TODO If we cannot read some of the trees, is the file corrupted as well?
   if ((rc = TDataSetManager::FillMetaData(fileinfo, file, "/")) != 0) {
      ::Error("TDataSetManager::ScanFile",
              "problems processing the directory tree in looking for metainfo");
   }
   // Set back old warning level
   gErrorIgnoreLevel = oldLevel;

   file->Close();
   delete file;

   // Done
   return rc;
}

//_______________________________________________________________________________________
Int_t TDataSetManager::FillMetaData(TFileInfo *fi, TDirectory *d, const char *rdir)
{
   // Navigate the directory 'd' (and its subdirectories) looking for TTree objects.
   // Fill in the relevant metadata information in 'fi'. The name of the TFileInfoMeta
   // metadata entry will be "/dir1/dir2/.../tree_name".
   // Return 0 on success, -1 if any problem happens (object found in keys cannot be read,
   // for example)

   // Check inputs
   if (!fi || !d || !rdir) {
      ::Error("TDataSetManager::FillMetaData",
              "some inputs are invalid (fi:%p,d:%p,r:%s)", fi, d, rdir);
      return -1;
   }

   if (d->GetListOfKeys()) {
      TIter nxk(d->GetListOfKeys());
      TKey *k = 0;
      while ((k = dynamic_cast<TKey *> (nxk()))) {

         if (TClass::GetClass(k->GetClassName())->InheritsFrom(TDirectory::Class())) {
            // Get the directory
            TDirectory *sd = (TDirectory *) d->Get(k->GetName());
            if (!sd) {
               ::Error("TDataSetManager::FillMetaData", "cannot get sub-directory '%s'", k->GetName());
               return -1;
            }
            if (TDataSetManager::FillMetaData(fi, sd, TString::Format("%s%s/", rdir, k->GetName())) != 0) {
               ::Error("TDataSetManager::FillMetaData", "problems processing sub-directory '%s'", k->GetName());
               return -1;
            }

         } else {
            // We process only trees
            if (!TClass::GetClass(k->GetClassName())->InheritsFrom(TTree::Class())) continue;

            TString ks;
            ks.Form("%s%s", rdir, k->GetName());

            TFileInfoMeta *md = fi->GetMetaData(ks);
            if (!md) {
               // Create it
               md = new TFileInfoMeta(ks, k->GetClassName());
               fi->AddMetaData(md);
               if (gDebug > 0)
                  ::Info("TDataSetManager::FillMetaData", "created meta data for tree %s", ks.Data());
            }
            // Fill values
            TTree *t = dynamic_cast<TTree *> (d->Get(k->GetName()));
            if (t) {
               if (t->GetEntries() >= 0) {
                  md->SetEntries(t->GetEntries());
                  if (t->GetTotBytes() >= 0)
                     md->SetTotBytes(t->GetTotBytes());
                  if (t->GetZipBytes() >= 0)
                     md->SetZipBytes(t->GetZipBytes());
               }
            } else {
               ::Error("TDataSetManager::FillMetaData", "could not get tree '%s'", k->GetName());
               return -1;
            }
         }
      }
   }
   // Done
   return 0;
}

//_______________________________________________________________________________________
TList *TDataSetManager::ParseDataSetSrvMaps(const TString &srvmaps)
{
   // Create a server mapping list from the content of 'srvmaps'
   // Return the list (owned by the caller) or 0 if no valid info could be found)

   TList *srvmapslist = 0;
   if (srvmaps.IsNull()) {
      ::Warning("TDataSetManager::ParseDataSetSrvMaps",
                "called with an empty string! - nothing to do");
      return srvmapslist;
   }
   TString srvmap, sf, st;
   Int_t from = 0, from1 = 0;
   while (srvmaps.Tokenize(srvmap, from, " ")) {
      sf = ""; st = "";
      if (srvmap.Contains("|")) {
         from1 = 0;
         if (srvmap.Tokenize(sf, from1, "|")) srvmap.Tokenize(st, from1, "|");
      } else {
         st = srvmap;
      }
      if (st.IsNull()) {
         ::Warning("TDataSetManager::ParseDataSetSrvMaps",
                   "parsing DataSet.SrvMaps: target must be defined"
                   " (token: %s) - ignoring", srvmap.Data());
         continue;
      } else if (!(st.EndsWith("/"))) {
         st += "/";
      }
      // TUrl if wildcards or TObjString
      TString sp;
      TUrl *u = 0;
      if (!(sf.IsNull()) && sf.Contains("*")) {
         u = new TUrl(sf);
         if (!(sf.BeginsWith(u->GetProtocol()))) u->SetProtocol("root");
         sp.Form(":%d", u->GetPort());
         if (!(sf.Contains(sp))) u->SetPort(1094);
         if (!TString(u->GetHost()).Contains("*")) SafeDelete(u);
      }
      if (!srvmapslist) srvmapslist = new TList;
      if (u) {
         srvmapslist->Add(new TPair(u, new TObjString(st)));
      } else {
         srvmapslist->Add(new TPair(new TObjString(sf), new TObjString(st)));
      }
   }
   // Done
   if (srvmapslist) srvmapslist->SetOwner(kTRUE);
   return srvmapslist;
}

//_______________________________________________________________________________________
TList *TDataSetManager::GetDataSetSrvMaps()
{
   // Static getter for server mapping list

   return fgDataSetSrvMaps;
}
 
//_______________________________________________________________________________________
Bool_t TDataSetManager::CheckDataSetSrvMaps(TUrl *furl, TString &file1, TList *srvmaplist)
{
   // Check if the dataset server mappings apply to the url defined by 'furl'.
   // Use srvmaplist if defined, else use the default list.
   // If yes, resolve the mapping into file1 and return kTRUE.
   // Otherwise return kFALSE.

   Bool_t replaced = kFALSE;
   if (!furl) return replaced;

   const char *file = furl->GetUrl();
   TList *mlist = (srvmaplist) ? srvmaplist : fgDataSetSrvMaps;
   if (mlist && mlist->GetSize() > 0) {
      TIter nxm(mlist);
      TPair *pr = 0;
      while ((pr = (TPair *) nxm())) {
         Bool_t replace = kFALSE;
         // If TUrl apply reg exp on host
         TUrl *u = dynamic_cast<TUrl *>(pr->Key());
         if (u) {
            if (!strcmp(u->GetProtocol(), furl->GetProtocol())) {
               Ssiz_t len;
               if (!strcmp(u->GetProtocol(), "file")) {
                  TRegexp re(u->GetFileAndOptions(), kTRUE);
                  if (re.Index(furl->GetFileAndOptions(), &len) == 0) replace = kTRUE;
               } else {
                  if (u->GetPort() == furl->GetPort()) {
                     TRegexp re(u->GetHost(), kTRUE);
                     if (re.Index(furl->GetHost(), &len) == 0) replace = kTRUE;
                  }
               }
            }
         } else {
            TObjString *os = dynamic_cast<TObjString *>(pr->Key());
            if (os) {
               if (os->GetString().IsNull() ||
                   !strncmp(file, os->GetName(), os->GetString().Length())) replace = kTRUE;
            }
         }
         if (replace) {
            TObjString *ost = dynamic_cast<TObjString *>(pr->Value());
            if (ost) {
               file1.Form("%s%s", ost->GetName(), furl->GetFileAndOptions());
               replaced = kTRUE;
               break;
            }
         }
      }
   }
   // Done
   return replaced;
}

//_______________________________________________________________________________________
void TDataSetManager::SetScanCounters(Int_t t, Int_t o, Int_t d)
{
   // Update scan counters

   fNTouchedFiles = (t > -1) ? t : fNTouchedFiles;
   fNOpenedFiles = (o > -1) ? o : fNOpenedFiles;
   fNDisappearedFiles = (d > -1) ? d : fNDisappearedFiles;
}
 TDataSetManager.cxx:1
 TDataSetManager.cxx:2
 TDataSetManager.cxx:3
 TDataSetManager.cxx:4
 TDataSetManager.cxx:5
 TDataSetManager.cxx:6
 TDataSetManager.cxx:7
 TDataSetManager.cxx:8
 TDataSetManager.cxx:9
 TDataSetManager.cxx:10
 TDataSetManager.cxx:11
 TDataSetManager.cxx:12
 TDataSetManager.cxx:13
 TDataSetManager.cxx:14
 TDataSetManager.cxx:15
 TDataSetManager.cxx:16
 TDataSetManager.cxx:17
 TDataSetManager.cxx:18
 TDataSetManager.cxx:19
 TDataSetManager.cxx:20
 TDataSetManager.cxx:21
 TDataSetManager.cxx:22
 TDataSetManager.cxx:23
 TDataSetManager.cxx:24
 TDataSetManager.cxx:25
 TDataSetManager.cxx:26
 TDataSetManager.cxx:27
 TDataSetManager.cxx:28
 TDataSetManager.cxx:29
 TDataSetManager.cxx:30
 TDataSetManager.cxx:31
 TDataSetManager.cxx:32
 TDataSetManager.cxx:33
 TDataSetManager.cxx:34
 TDataSetManager.cxx:35
 TDataSetManager.cxx:36
 TDataSetManager.cxx:37
 TDataSetManager.cxx:38
 TDataSetManager.cxx:39
 TDataSetManager.cxx:40
 TDataSetManager.cxx:41
 TDataSetManager.cxx:42
 TDataSetManager.cxx:43
 TDataSetManager.cxx:44
 TDataSetManager.cxx:45
 TDataSetManager.cxx:46
 TDataSetManager.cxx:47
 TDataSetManager.cxx:48
 TDataSetManager.cxx:49
 TDataSetManager.cxx:50
 TDataSetManager.cxx:51
 TDataSetManager.cxx:52
 TDataSetManager.cxx:53
 TDataSetManager.cxx:54
 TDataSetManager.cxx:55
 TDataSetManager.cxx:56
 TDataSetManager.cxx:57
 TDataSetManager.cxx:58
 TDataSetManager.cxx:59
 TDataSetManager.cxx:60
 TDataSetManager.cxx:61
 TDataSetManager.cxx:62
 TDataSetManager.cxx:63
 TDataSetManager.cxx:64
 TDataSetManager.cxx:65
 TDataSetManager.cxx:66
 TDataSetManager.cxx:67
 TDataSetManager.cxx:68
 TDataSetManager.cxx:69
 TDataSetManager.cxx:70
 TDataSetManager.cxx:71
 TDataSetManager.cxx:72
 TDataSetManager.cxx:73
 TDataSetManager.cxx:74
 TDataSetManager.cxx:75
 TDataSetManager.cxx:76
 TDataSetManager.cxx:77
 TDataSetManager.cxx:78
 TDataSetManager.cxx:79
 TDataSetManager.cxx:80
 TDataSetManager.cxx:81
 TDataSetManager.cxx:82
 TDataSetManager.cxx:83
 TDataSetManager.cxx:84
 TDataSetManager.cxx:85
 TDataSetManager.cxx:86
 TDataSetManager.cxx:87
 TDataSetManager.cxx:88
 TDataSetManager.cxx:89
 TDataSetManager.cxx:90
 TDataSetManager.cxx:91
 TDataSetManager.cxx:92
 TDataSetManager.cxx:93
 TDataSetManager.cxx:94
 TDataSetManager.cxx:95
 TDataSetManager.cxx:96
 TDataSetManager.cxx:97
 TDataSetManager.cxx:98
 TDataSetManager.cxx:99
 TDataSetManager.cxx:100
 TDataSetManager.cxx:101
 TDataSetManager.cxx:102
 TDataSetManager.cxx:103
 TDataSetManager.cxx:104
 TDataSetManager.cxx:105
 TDataSetManager.cxx:106
 TDataSetManager.cxx:107
 TDataSetManager.cxx:108
 TDataSetManager.cxx:109
 TDataSetManager.cxx:110
 TDataSetManager.cxx:111
 TDataSetManager.cxx:112
 TDataSetManager.cxx:113
 TDataSetManager.cxx:114
 TDataSetManager.cxx:115
 TDataSetManager.cxx:116
 TDataSetManager.cxx:117
 TDataSetManager.cxx:118
 TDataSetManager.cxx:119
 TDataSetManager.cxx:120
 TDataSetManager.cxx:121
 TDataSetManager.cxx:122
 TDataSetManager.cxx:123
 TDataSetManager.cxx:124
 TDataSetManager.cxx:125
 TDataSetManager.cxx:126
 TDataSetManager.cxx:127
 TDataSetManager.cxx:128
 TDataSetManager.cxx:129
 TDataSetManager.cxx:130
 TDataSetManager.cxx:131
 TDataSetManager.cxx:132
 TDataSetManager.cxx:133
 TDataSetManager.cxx:134
 TDataSetManager.cxx:135
 TDataSetManager.cxx:136
 TDataSetManager.cxx:137
 TDataSetManager.cxx:138
 TDataSetManager.cxx:139
 TDataSetManager.cxx:140
 TDataSetManager.cxx:141
 TDataSetManager.cxx:142
 TDataSetManager.cxx:143
 TDataSetManager.cxx:144
 TDataSetManager.cxx:145
 TDataSetManager.cxx:146
 TDataSetManager.cxx:147
 TDataSetManager.cxx:148
 TDataSetManager.cxx:149
 TDataSetManager.cxx:150
 TDataSetManager.cxx:151
 TDataSetManager.cxx:152
 TDataSetManager.cxx:153
 TDataSetManager.cxx:154
 TDataSetManager.cxx:155
 TDataSetManager.cxx:156
 TDataSetManager.cxx:157
 TDataSetManager.cxx:158
 TDataSetManager.cxx:159
 TDataSetManager.cxx:160
 TDataSetManager.cxx:161
 TDataSetManager.cxx:162
 TDataSetManager.cxx:163
 TDataSetManager.cxx:164
 TDataSetManager.cxx:165
 TDataSetManager.cxx:166
 TDataSetManager.cxx:167
 TDataSetManager.cxx:168
 TDataSetManager.cxx:169
 TDataSetManager.cxx:170
 TDataSetManager.cxx:171
 TDataSetManager.cxx:172
 TDataSetManager.cxx:173
 TDataSetManager.cxx:174
 TDataSetManager.cxx:175
 TDataSetManager.cxx:176
 TDataSetManager.cxx:177
 TDataSetManager.cxx:178
 TDataSetManager.cxx:179
 TDataSetManager.cxx:180
 TDataSetManager.cxx:181
 TDataSetManager.cxx:182
 TDataSetManager.cxx:183
 TDataSetManager.cxx:184
 TDataSetManager.cxx:185
 TDataSetManager.cxx:186
 TDataSetManager.cxx:187
 TDataSetManager.cxx:188
 TDataSetManager.cxx:189
 TDataSetManager.cxx:190
 TDataSetManager.cxx:191
 TDataSetManager.cxx:192
 TDataSetManager.cxx:193
 TDataSetManager.cxx:194
 TDataSetManager.cxx:195
 TDataSetManager.cxx:196
 TDataSetManager.cxx:197
 TDataSetManager.cxx:198
 TDataSetManager.cxx:199
 TDataSetManager.cxx:200
 TDataSetManager.cxx:201
 TDataSetManager.cxx:202
 TDataSetManager.cxx:203
 TDataSetManager.cxx:204
 TDataSetManager.cxx:205
 TDataSetManager.cxx:206
 TDataSetManager.cxx:207
 TDataSetManager.cxx:208
 TDataSetManager.cxx:209
 TDataSetManager.cxx:210
 TDataSetManager.cxx:211
 TDataSetManager.cxx:212
 TDataSetManager.cxx:213
 TDataSetManager.cxx:214
 TDataSetManager.cxx:215
 TDataSetManager.cxx:216
 TDataSetManager.cxx:217
 TDataSetManager.cxx:218
 TDataSetManager.cxx:219
 TDataSetManager.cxx:220
 TDataSetManager.cxx:221
 TDataSetManager.cxx:222
 TDataSetManager.cxx:223
 TDataSetManager.cxx:224
 TDataSetManager.cxx:225
 TDataSetManager.cxx:226
 TDataSetManager.cxx:227
 TDataSetManager.cxx:228
 TDataSetManager.cxx:229
 TDataSetManager.cxx:230
 TDataSetManager.cxx:231
 TDataSetManager.cxx:232
 TDataSetManager.cxx:233
 TDataSetManager.cxx:234
 TDataSetManager.cxx:235
 TDataSetManager.cxx:236
 TDataSetManager.cxx:237
 TDataSetManager.cxx:238
 TDataSetManager.cxx:239
 TDataSetManager.cxx:240
 TDataSetManager.cxx:241
 TDataSetManager.cxx:242
 TDataSetManager.cxx:243
 TDataSetManager.cxx:244
 TDataSetManager.cxx:245
 TDataSetManager.cxx:246
 TDataSetManager.cxx:247
 TDataSetManager.cxx:248
 TDataSetManager.cxx:249
 TDataSetManager.cxx:250
 TDataSetManager.cxx:251
 TDataSetManager.cxx:252
 TDataSetManager.cxx:253
 TDataSetManager.cxx:254
 TDataSetManager.cxx:255
 TDataSetManager.cxx:256
 TDataSetManager.cxx:257
 TDataSetManager.cxx:258
 TDataSetManager.cxx:259
 TDataSetManager.cxx:260
 TDataSetManager.cxx:261
 TDataSetManager.cxx:262
 TDataSetManager.cxx:263
 TDataSetManager.cxx:264
 TDataSetManager.cxx:265
 TDataSetManager.cxx:266
 TDataSetManager.cxx:267
 TDataSetManager.cxx:268
 TDataSetManager.cxx:269
 TDataSetManager.cxx:270
 TDataSetManager.cxx:271
 TDataSetManager.cxx:272
 TDataSetManager.cxx:273
 TDataSetManager.cxx:274
 TDataSetManager.cxx:275
 TDataSetManager.cxx:276
 TDataSetManager.cxx:277
 TDataSetManager.cxx:278
 TDataSetManager.cxx:279
 TDataSetManager.cxx:280
 TDataSetManager.cxx:281
 TDataSetManager.cxx:282
 TDataSetManager.cxx:283
 TDataSetManager.cxx:284
 TDataSetManager.cxx:285
 TDataSetManager.cxx:286
 TDataSetManager.cxx:287
 TDataSetManager.cxx:288
 TDataSetManager.cxx:289
 TDataSetManager.cxx:290
 TDataSetManager.cxx:291
 TDataSetManager.cxx:292
 TDataSetManager.cxx:293
 TDataSetManager.cxx:294
 TDataSetManager.cxx:295
 TDataSetManager.cxx:296
 TDataSetManager.cxx:297
 TDataSetManager.cxx:298
 TDataSetManager.cxx:299
 TDataSetManager.cxx:300
 TDataSetManager.cxx:301
 TDataSetManager.cxx:302
 TDataSetManager.cxx:303
 TDataSetManager.cxx:304
 TDataSetManager.cxx:305
 TDataSetManager.cxx:306
 TDataSetManager.cxx:307
 TDataSetManager.cxx:308
 TDataSetManager.cxx:309
 TDataSetManager.cxx:310
 TDataSetManager.cxx:311
 TDataSetManager.cxx:312
 TDataSetManager.cxx:313
 TDataSetManager.cxx:314
 TDataSetManager.cxx:315
 TDataSetManager.cxx:316
 TDataSetManager.cxx:317
 TDataSetManager.cxx:318
 TDataSetManager.cxx:319
 TDataSetManager.cxx:320
 TDataSetManager.cxx:321
 TDataSetManager.cxx:322
 TDataSetManager.cxx:323
 TDataSetManager.cxx:324
 TDataSetManager.cxx:325
 TDataSetManager.cxx:326
 TDataSetManager.cxx:327
 TDataSetManager.cxx:328
 TDataSetManager.cxx:329
 TDataSetManager.cxx:330
 TDataSetManager.cxx:331
 TDataSetManager.cxx:332
 TDataSetManager.cxx:333
 TDataSetManager.cxx:334
 TDataSetManager.cxx:335
 TDataSetManager.cxx:336
 TDataSetManager.cxx:337
 TDataSetManager.cxx:338
 TDataSetManager.cxx:339
 TDataSetManager.cxx:340
 TDataSetManager.cxx:341
 TDataSetManager.cxx:342
 TDataSetManager.cxx:343
 TDataSetManager.cxx:344
 TDataSetManager.cxx:345
 TDataSetManager.cxx:346
 TDataSetManager.cxx:347
 TDataSetManager.cxx:348
 TDataSetManager.cxx:349
 TDataSetManager.cxx:350
 TDataSetManager.cxx:351
 TDataSetManager.cxx:352
 TDataSetManager.cxx:353
 TDataSetManager.cxx:354
 TDataSetManager.cxx:355
 TDataSetManager.cxx:356
 TDataSetManager.cxx:357
 TDataSetManager.cxx:358
 TDataSetManager.cxx:359
 TDataSetManager.cxx:360
 TDataSetManager.cxx:361
 TDataSetManager.cxx:362
 TDataSetManager.cxx:363
 TDataSetManager.cxx:364
 TDataSetManager.cxx:365
 TDataSetManager.cxx:366
 TDataSetManager.cxx:367
 TDataSetManager.cxx:368
 TDataSetManager.cxx:369
 TDataSetManager.cxx:370
 TDataSetManager.cxx:371
 TDataSetManager.cxx:372
 TDataSetManager.cxx:373
 TDataSetManager.cxx:374
 TDataSetManager.cxx:375
 TDataSetManager.cxx:376
 TDataSetManager.cxx:377
 TDataSetManager.cxx:378
 TDataSetManager.cxx:379
 TDataSetManager.cxx:380
 TDataSetManager.cxx:381
 TDataSetManager.cxx:382
 TDataSetManager.cxx:383
 TDataSetManager.cxx:384
 TDataSetManager.cxx:385
 TDataSetManager.cxx:386
 TDataSetManager.cxx:387
 TDataSetManager.cxx:388
 TDataSetManager.cxx:389
 TDataSetManager.cxx:390
 TDataSetManager.cxx:391
 TDataSetManager.cxx:392
 TDataSetManager.cxx:393
 TDataSetManager.cxx:394
 TDataSetManager.cxx:395
 TDataSetManager.cxx:396
 TDataSetManager.cxx:397
 TDataSetManager.cxx:398
 TDataSetManager.cxx:399
 TDataSetManager.cxx:400
 TDataSetManager.cxx:401
 TDataSetManager.cxx:402
 TDataSetManager.cxx:403
 TDataSetManager.cxx:404
 TDataSetManager.cxx:405
 TDataSetManager.cxx:406
 TDataSetManager.cxx:407
 TDataSetManager.cxx:408
 TDataSetManager.cxx:409
 TDataSetManager.cxx:410
 TDataSetManager.cxx:411
 TDataSetManager.cxx:412
 TDataSetManager.cxx:413
 TDataSetManager.cxx:414
 TDataSetManager.cxx:415
 TDataSetManager.cxx:416
 TDataSetManager.cxx:417
 TDataSetManager.cxx:418
 TDataSetManager.cxx:419
 TDataSetManager.cxx:420
 TDataSetManager.cxx:421
 TDataSetManager.cxx:422
 TDataSetManager.cxx:423
 TDataSetManager.cxx:424
 TDataSetManager.cxx:425
 TDataSetManager.cxx:426
 TDataSetManager.cxx:427
 TDataSetManager.cxx:428
 TDataSetManager.cxx:429
 TDataSetManager.cxx:430
 TDataSetManager.cxx:431
 TDataSetManager.cxx:432
 TDataSetManager.cxx:433
 TDataSetManager.cxx:434
 TDataSetManager.cxx:435
 TDataSetManager.cxx:436
 TDataSetManager.cxx:437
 TDataSetManager.cxx:438
 TDataSetManager.cxx:439
 TDataSetManager.cxx:440
 TDataSetManager.cxx:441
 TDataSetManager.cxx:442
 TDataSetManager.cxx:443
 TDataSetManager.cxx:444
 TDataSetManager.cxx:445
 TDataSetManager.cxx:446
 TDataSetManager.cxx:447
 TDataSetManager.cxx:448
 TDataSetManager.cxx:449
 TDataSetManager.cxx:450
 TDataSetManager.cxx:451
 TDataSetManager.cxx:452
 TDataSetManager.cxx:453
 TDataSetManager.cxx:454
 TDataSetManager.cxx:455
 TDataSetManager.cxx:456
 TDataSetManager.cxx:457
 TDataSetManager.cxx:458
 TDataSetManager.cxx:459
 TDataSetManager.cxx:460
 TDataSetManager.cxx:461
 TDataSetManager.cxx:462
 TDataSetManager.cxx:463
 TDataSetManager.cxx:464
 TDataSetManager.cxx:465
 TDataSetManager.cxx:466
 TDataSetManager.cxx:467
 TDataSetManager.cxx:468
 TDataSetManager.cxx:469
 TDataSetManager.cxx:470
 TDataSetManager.cxx:471
 TDataSetManager.cxx:472
 TDataSetManager.cxx:473
 TDataSetManager.cxx:474
 TDataSetManager.cxx:475
 TDataSetManager.cxx:476
 TDataSetManager.cxx:477
 TDataSetManager.cxx:478
 TDataSetManager.cxx:479
 TDataSetManager.cxx:480
 TDataSetManager.cxx:481
 TDataSetManager.cxx:482
 TDataSetManager.cxx:483
 TDataSetManager.cxx:484
 TDataSetManager.cxx:485
 TDataSetManager.cxx:486
 TDataSetManager.cxx:487
 TDataSetManager.cxx:488
 TDataSetManager.cxx:489
 TDataSetManager.cxx:490
 TDataSetManager.cxx:491
 TDataSetManager.cxx:492
 TDataSetManager.cxx:493
 TDataSetManager.cxx:494
 TDataSetManager.cxx:495
 TDataSetManager.cxx:496
 TDataSetManager.cxx:497
 TDataSetManager.cxx:498
 TDataSetManager.cxx:499
 TDataSetManager.cxx:500
 TDataSetManager.cxx:501
 TDataSetManager.cxx:502
 TDataSetManager.cxx:503
 TDataSetManager.cxx:504
 TDataSetManager.cxx:505
 TDataSetManager.cxx:506
 TDataSetManager.cxx:507
 TDataSetManager.cxx:508
 TDataSetManager.cxx:509
 TDataSetManager.cxx:510
 TDataSetManager.cxx:511
 TDataSetManager.cxx:512
 TDataSetManager.cxx:513
 TDataSetManager.cxx:514
 TDataSetManager.cxx:515
 TDataSetManager.cxx:516
 TDataSetManager.cxx:517
 TDataSetManager.cxx:518
 TDataSetManager.cxx:519
 TDataSetManager.cxx:520
 TDataSetManager.cxx:521
 TDataSetManager.cxx:522
 TDataSetManager.cxx:523
 TDataSetManager.cxx:524
 TDataSetManager.cxx:525
 TDataSetManager.cxx:526
 TDataSetManager.cxx:527
 TDataSetManager.cxx:528
 TDataSetManager.cxx:529
 TDataSetManager.cxx:530
 TDataSetManager.cxx:531
 TDataSetManager.cxx:532
 TDataSetManager.cxx:533
 TDataSetManager.cxx:534
 TDataSetManager.cxx:535
 TDataSetManager.cxx:536
 TDataSetManager.cxx:537
 TDataSetManager.cxx:538
 TDataSetManager.cxx:539
 TDataSetManager.cxx:540
 TDataSetManager.cxx:541
 TDataSetManager.cxx:542
 TDataSetManager.cxx:543
 TDataSetManager.cxx:544
 TDataSetManager.cxx:545
 TDataSetManager.cxx:546
 TDataSetManager.cxx:547
 TDataSetManager.cxx:548
 TDataSetManager.cxx:549
 TDataSetManager.cxx:550
 TDataSetManager.cxx:551
 TDataSetManager.cxx:552
 TDataSetManager.cxx:553
 TDataSetManager.cxx:554
 TDataSetManager.cxx:555
 TDataSetManager.cxx:556
 TDataSetManager.cxx:557
 TDataSetManager.cxx:558
 TDataSetManager.cxx:559
 TDataSetManager.cxx:560
 TDataSetManager.cxx:561
 TDataSetManager.cxx:562
 TDataSetManager.cxx:563
 TDataSetManager.cxx:564
 TDataSetManager.cxx:565
 TDataSetManager.cxx:566
 TDataSetManager.cxx:567
 TDataSetManager.cxx:568
 TDataSetManager.cxx:569
 TDataSetManager.cxx:570
 TDataSetManager.cxx:571
 TDataSetManager.cxx:572
 TDataSetManager.cxx:573
 TDataSetManager.cxx:574
 TDataSetManager.cxx:575
 TDataSetManager.cxx:576
 TDataSetManager.cxx:577
 TDataSetManager.cxx:578
 TDataSetManager.cxx:579
 TDataSetManager.cxx:580
 TDataSetManager.cxx:581
 TDataSetManager.cxx:582
 TDataSetManager.cxx:583
 TDataSetManager.cxx:584
 TDataSetManager.cxx:585
 TDataSetManager.cxx:586
 TDataSetManager.cxx:587
 TDataSetManager.cxx:588
 TDataSetManager.cxx:589
 TDataSetManager.cxx:590
 TDataSetManager.cxx:591
 TDataSetManager.cxx:592
 TDataSetManager.cxx:593
 TDataSetManager.cxx:594
 TDataSetManager.cxx:595
 TDataSetManager.cxx:596
 TDataSetManager.cxx:597
 TDataSetManager.cxx:598
 TDataSetManager.cxx:599
 TDataSetManager.cxx:600
 TDataSetManager.cxx:601
 TDataSetManager.cxx:602
 TDataSetManager.cxx:603
 TDataSetManager.cxx:604
 TDataSetManager.cxx:605
 TDataSetManager.cxx:606
 TDataSetManager.cxx:607
 TDataSetManager.cxx:608
 TDataSetManager.cxx:609
 TDataSetManager.cxx:610
 TDataSetManager.cxx:611
 TDataSetManager.cxx:612
 TDataSetManager.cxx:613
 TDataSetManager.cxx:614
 TDataSetManager.cxx:615
 TDataSetManager.cxx:616
 TDataSetManager.cxx:617
 TDataSetManager.cxx:618
 TDataSetManager.cxx:619
 TDataSetManager.cxx:620
 TDataSetManager.cxx:621
 TDataSetManager.cxx:622
 TDataSetManager.cxx:623
 TDataSetManager.cxx:624
 TDataSetManager.cxx:625
 TDataSetManager.cxx:626
 TDataSetManager.cxx:627
 TDataSetManager.cxx:628
 TDataSetManager.cxx:629
 TDataSetManager.cxx:630
 TDataSetManager.cxx:631
 TDataSetManager.cxx:632
 TDataSetManager.cxx:633
 TDataSetManager.cxx:634
 TDataSetManager.cxx:635
 TDataSetManager.cxx:636
 TDataSetManager.cxx:637
 TDataSetManager.cxx:638
 TDataSetManager.cxx:639
 TDataSetManager.cxx:640
 TDataSetManager.cxx:641
 TDataSetManager.cxx:642
 TDataSetManager.cxx:643
 TDataSetManager.cxx:644
 TDataSetManager.cxx:645
 TDataSetManager.cxx:646
 TDataSetManager.cxx:647
 TDataSetManager.cxx:648
 TDataSetManager.cxx:649
 TDataSetManager.cxx:650
 TDataSetManager.cxx:651
 TDataSetManager.cxx:652
 TDataSetManager.cxx:653
 TDataSetManager.cxx:654
 TDataSetManager.cxx:655
 TDataSetManager.cxx:656
 TDataSetManager.cxx:657
 TDataSetManager.cxx:658
 TDataSetManager.cxx:659
 TDataSetManager.cxx:660
 TDataSetManager.cxx:661
 TDataSetManager.cxx:662
 TDataSetManager.cxx:663
 TDataSetManager.cxx:664
 TDataSetManager.cxx:665
 TDataSetManager.cxx:666
 TDataSetManager.cxx:667
 TDataSetManager.cxx:668
 TDataSetManager.cxx:669
 TDataSetManager.cxx:670
 TDataSetManager.cxx:671
 TDataSetManager.cxx:672
 TDataSetManager.cxx:673
 TDataSetManager.cxx:674
 TDataSetManager.cxx:675
 TDataSetManager.cxx:676
 TDataSetManager.cxx:677
 TDataSetManager.cxx:678
 TDataSetManager.cxx:679
 TDataSetManager.cxx:680
 TDataSetManager.cxx:681
 TDataSetManager.cxx:682
 TDataSetManager.cxx:683
 TDataSetManager.cxx:684
 TDataSetManager.cxx:685
 TDataSetManager.cxx:686
 TDataSetManager.cxx:687
 TDataSetManager.cxx:688
 TDataSetManager.cxx:689
 TDataSetManager.cxx:690
 TDataSetManager.cxx:691
 TDataSetManager.cxx:692
 TDataSetManager.cxx:693
 TDataSetManager.cxx:694
 TDataSetManager.cxx:695
 TDataSetManager.cxx:696
 TDataSetManager.cxx:697
 TDataSetManager.cxx:698
 TDataSetManager.cxx:699
 TDataSetManager.cxx:700
 TDataSetManager.cxx:701
 TDataSetManager.cxx:702
 TDataSetManager.cxx:703
 TDataSetManager.cxx:704
 TDataSetManager.cxx:705
 TDataSetManager.cxx:706
 TDataSetManager.cxx:707
 TDataSetManager.cxx:708
 TDataSetManager.cxx:709
 TDataSetManager.cxx:710
 TDataSetManager.cxx:711
 TDataSetManager.cxx:712
 TDataSetManager.cxx:713
 TDataSetManager.cxx:714
 TDataSetManager.cxx:715
 TDataSetManager.cxx:716
 TDataSetManager.cxx:717
 TDataSetManager.cxx:718
 TDataSetManager.cxx:719
 TDataSetManager.cxx:720
 TDataSetManager.cxx:721
 TDataSetManager.cxx:722
 TDataSetManager.cxx:723
 TDataSetManager.cxx:724
 TDataSetManager.cxx:725
 TDataSetManager.cxx:726
 TDataSetManager.cxx:727
 TDataSetManager.cxx:728
 TDataSetManager.cxx:729
 TDataSetManager.cxx:730
 TDataSetManager.cxx:731
 TDataSetManager.cxx:732
 TDataSetManager.cxx:733
 TDataSetManager.cxx:734
 TDataSetManager.cxx:735
 TDataSetManager.cxx:736
 TDataSetManager.cxx:737
 TDataSetManager.cxx:738
 TDataSetManager.cxx:739
 TDataSetManager.cxx:740
 TDataSetManager.cxx:741
 TDataSetManager.cxx:742
 TDataSetManager.cxx:743
 TDataSetManager.cxx:744
 TDataSetManager.cxx:745
 TDataSetManager.cxx:746
 TDataSetManager.cxx:747
 TDataSetManager.cxx:748
 TDataSetManager.cxx:749
 TDataSetManager.cxx:750
 TDataSetManager.cxx:751
 TDataSetManager.cxx:752
 TDataSetManager.cxx:753
 TDataSetManager.cxx:754
 TDataSetManager.cxx:755
 TDataSetManager.cxx:756
 TDataSetManager.cxx:757
 TDataSetManager.cxx:758
 TDataSetManager.cxx:759
 TDataSetManager.cxx:760
 TDataSetManager.cxx:761
 TDataSetManager.cxx:762
 TDataSetManager.cxx:763
 TDataSetManager.cxx:764
 TDataSetManager.cxx:765
 TDataSetManager.cxx:766
 TDataSetManager.cxx:767
 TDataSetManager.cxx:768
 TDataSetManager.cxx:769
 TDataSetManager.cxx:770
 TDataSetManager.cxx:771
 TDataSetManager.cxx:772
 TDataSetManager.cxx:773
 TDataSetManager.cxx:774
 TDataSetManager.cxx:775
 TDataSetManager.cxx:776
 TDataSetManager.cxx:777
 TDataSetManager.cxx:778
 TDataSetManager.cxx:779
 TDataSetManager.cxx:780
 TDataSetManager.cxx:781
 TDataSetManager.cxx:782
 TDataSetManager.cxx:783
 TDataSetManager.cxx:784
 TDataSetManager.cxx:785
 TDataSetManager.cxx:786
 TDataSetManager.cxx:787
 TDataSetManager.cxx:788
 TDataSetManager.cxx:789
 TDataSetManager.cxx:790
 TDataSetManager.cxx:791
 TDataSetManager.cxx:792
 TDataSetManager.cxx:793
 TDataSetManager.cxx:794
 TDataSetManager.cxx:795
 TDataSetManager.cxx:796
 TDataSetManager.cxx:797
 TDataSetManager.cxx:798
 TDataSetManager.cxx:799
 TDataSetManager.cxx:800
 TDataSetManager.cxx:801
 TDataSetManager.cxx:802
 TDataSetManager.cxx:803
 TDataSetManager.cxx:804
 TDataSetManager.cxx:805
 TDataSetManager.cxx:806
 TDataSetManager.cxx:807
 TDataSetManager.cxx:808
 TDataSetManager.cxx:809
 TDataSetManager.cxx:810
 TDataSetManager.cxx:811
 TDataSetManager.cxx:812
 TDataSetManager.cxx:813
 TDataSetManager.cxx:814
 TDataSetManager.cxx:815
 TDataSetManager.cxx:816
 TDataSetManager.cxx:817
 TDataSetManager.cxx:818
 TDataSetManager.cxx:819
 TDataSetManager.cxx:820
 TDataSetManager.cxx:821
 TDataSetManager.cxx:822
 TDataSetManager.cxx:823
 TDataSetManager.cxx:824
 TDataSetManager.cxx:825
 TDataSetManager.cxx:826
 TDataSetManager.cxx:827
 TDataSetManager.cxx:828
 TDataSetManager.cxx:829
 TDataSetManager.cxx:830
 TDataSetManager.cxx:831
 TDataSetManager.cxx:832
 TDataSetManager.cxx:833
 TDataSetManager.cxx:834
 TDataSetManager.cxx:835
 TDataSetManager.cxx:836
 TDataSetManager.cxx:837
 TDataSetManager.cxx:838
 TDataSetManager.cxx:839
 TDataSetManager.cxx:840
 TDataSetManager.cxx:841
 TDataSetManager.cxx:842
 TDataSetManager.cxx:843
 TDataSetManager.cxx:844
 TDataSetManager.cxx:845
 TDataSetManager.cxx:846
 TDataSetManager.cxx:847
 TDataSetManager.cxx:848
 TDataSetManager.cxx:849
 TDataSetManager.cxx:850
 TDataSetManager.cxx:851
 TDataSetManager.cxx:852
 TDataSetManager.cxx:853
 TDataSetManager.cxx:854
 TDataSetManager.cxx:855
 TDataSetManager.cxx:856
 TDataSetManager.cxx:857
 TDataSetManager.cxx:858
 TDataSetManager.cxx:859
 TDataSetManager.cxx:860
 TDataSetManager.cxx:861
 TDataSetManager.cxx:862
 TDataSetManager.cxx:863
 TDataSetManager.cxx:864
 TDataSetManager.cxx:865
 TDataSetManager.cxx:866
 TDataSetManager.cxx:867
 TDataSetManager.cxx:868
 TDataSetManager.cxx:869
 TDataSetManager.cxx:870
 TDataSetManager.cxx:871
 TDataSetManager.cxx:872
 TDataSetManager.cxx:873
 TDataSetManager.cxx:874
 TDataSetManager.cxx:875
 TDataSetManager.cxx:876
 TDataSetManager.cxx:877
 TDataSetManager.cxx:878
 TDataSetManager.cxx:879
 TDataSetManager.cxx:880
 TDataSetManager.cxx:881
 TDataSetManager.cxx:882
 TDataSetManager.cxx:883
 TDataSetManager.cxx:884
 TDataSetManager.cxx:885
 TDataSetManager.cxx:886
 TDataSetManager.cxx:887
 TDataSetManager.cxx:888
 TDataSetManager.cxx:889
 TDataSetManager.cxx:890
 TDataSetManager.cxx:891
 TDataSetManager.cxx:892
 TDataSetManager.cxx:893
 TDataSetManager.cxx:894
 TDataSetManager.cxx:895
 TDataSetManager.cxx:896
 TDataSetManager.cxx:897
 TDataSetManager.cxx:898
 TDataSetManager.cxx:899
 TDataSetManager.cxx:900
 TDataSetManager.cxx:901
 TDataSetManager.cxx:902
 TDataSetManager.cxx:903
 TDataSetManager.cxx:904
 TDataSetManager.cxx:905
 TDataSetManager.cxx:906
 TDataSetManager.cxx:907
 TDataSetManager.cxx:908
 TDataSetManager.cxx:909
 TDataSetManager.cxx:910
 TDataSetManager.cxx:911
 TDataSetManager.cxx:912
 TDataSetManager.cxx:913
 TDataSetManager.cxx:914
 TDataSetManager.cxx:915
 TDataSetManager.cxx:916
 TDataSetManager.cxx:917
 TDataSetManager.cxx:918
 TDataSetManager.cxx:919
 TDataSetManager.cxx:920
 TDataSetManager.cxx:921
 TDataSetManager.cxx:922
 TDataSetManager.cxx:923
 TDataSetManager.cxx:924
 TDataSetManager.cxx:925
 TDataSetManager.cxx:926
 TDataSetManager.cxx:927
 TDataSetManager.cxx:928
 TDataSetManager.cxx:929
 TDataSetManager.cxx:930
 TDataSetManager.cxx:931
 TDataSetManager.cxx:932
 TDataSetManager.cxx:933
 TDataSetManager.cxx:934
 TDataSetManager.cxx:935
 TDataSetManager.cxx:936
 TDataSetManager.cxx:937
 TDataSetManager.cxx:938
 TDataSetManager.cxx:939
 TDataSetManager.cxx:940
 TDataSetManager.cxx:941
 TDataSetManager.cxx:942
 TDataSetManager.cxx:943
 TDataSetManager.cxx:944
 TDataSetManager.cxx:945
 TDataSetManager.cxx:946
 TDataSetManager.cxx:947
 TDataSetManager.cxx:948
 TDataSetManager.cxx:949
 TDataSetManager.cxx:950
 TDataSetManager.cxx:951
 TDataSetManager.cxx:952
 TDataSetManager.cxx:953
 TDataSetManager.cxx:954
 TDataSetManager.cxx:955
 TDataSetManager.cxx:956
 TDataSetManager.cxx:957
 TDataSetManager.cxx:958
 TDataSetManager.cxx:959
 TDataSetManager.cxx:960
 TDataSetManager.cxx:961
 TDataSetManager.cxx:962
 TDataSetManager.cxx:963
 TDataSetManager.cxx:964
 TDataSetManager.cxx:965
 TDataSetManager.cxx:966
 TDataSetManager.cxx:967
 TDataSetManager.cxx:968
 TDataSetManager.cxx:969
 TDataSetManager.cxx:970
 TDataSetManager.cxx:971
 TDataSetManager.cxx:972
 TDataSetManager.cxx:973
 TDataSetManager.cxx:974
 TDataSetManager.cxx:975
 TDataSetManager.cxx:976
 TDataSetManager.cxx:977
 TDataSetManager.cxx:978
 TDataSetManager.cxx:979
 TDataSetManager.cxx:980
 TDataSetManager.cxx:981
 TDataSetManager.cxx:982
 TDataSetManager.cxx:983
 TDataSetManager.cxx:984
 TDataSetManager.cxx:985
 TDataSetManager.cxx:986
 TDataSetManager.cxx:987
 TDataSetManager.cxx:988
 TDataSetManager.cxx:989
 TDataSetManager.cxx:990
 TDataSetManager.cxx:991
 TDataSetManager.cxx:992
 TDataSetManager.cxx:993
 TDataSetManager.cxx:994
 TDataSetManager.cxx:995
 TDataSetManager.cxx:996
 TDataSetManager.cxx:997
 TDataSetManager.cxx:998
 TDataSetManager.cxx:999
 TDataSetManager.cxx:1000
 TDataSetManager.cxx:1001
 TDataSetManager.cxx:1002
 TDataSetManager.cxx:1003
 TDataSetManager.cxx:1004
 TDataSetManager.cxx:1005
 TDataSetManager.cxx:1006
 TDataSetManager.cxx:1007
 TDataSetManager.cxx:1008
 TDataSetManager.cxx:1009
 TDataSetManager.cxx:1010
 TDataSetManager.cxx:1011
 TDataSetManager.cxx:1012
 TDataSetManager.cxx:1013
 TDataSetManager.cxx:1014
 TDataSetManager.cxx:1015
 TDataSetManager.cxx:1016
 TDataSetManager.cxx:1017
 TDataSetManager.cxx:1018
 TDataSetManager.cxx:1019
 TDataSetManager.cxx:1020
 TDataSetManager.cxx:1021
 TDataSetManager.cxx:1022
 TDataSetManager.cxx:1023
 TDataSetManager.cxx:1024
 TDataSetManager.cxx:1025
 TDataSetManager.cxx:1026
 TDataSetManager.cxx:1027
 TDataSetManager.cxx:1028
 TDataSetManager.cxx:1029
 TDataSetManager.cxx:1030
 TDataSetManager.cxx:1031
 TDataSetManager.cxx:1032
 TDataSetManager.cxx:1033
 TDataSetManager.cxx:1034
 TDataSetManager.cxx:1035
 TDataSetManager.cxx:1036
 TDataSetManager.cxx:1037
 TDataSetManager.cxx:1038
 TDataSetManager.cxx:1039
 TDataSetManager.cxx:1040
 TDataSetManager.cxx:1041
 TDataSetManager.cxx:1042
 TDataSetManager.cxx:1043
 TDataSetManager.cxx:1044
 TDataSetManager.cxx:1045
 TDataSetManager.cxx:1046
 TDataSetManager.cxx:1047
 TDataSetManager.cxx:1048
 TDataSetManager.cxx:1049
 TDataSetManager.cxx:1050
 TDataSetManager.cxx:1051
 TDataSetManager.cxx:1052
 TDataSetManager.cxx:1053
 TDataSetManager.cxx:1054
 TDataSetManager.cxx:1055
 TDataSetManager.cxx:1056
 TDataSetManager.cxx:1057
 TDataSetManager.cxx:1058
 TDataSetManager.cxx:1059
 TDataSetManager.cxx:1060
 TDataSetManager.cxx:1061
 TDataSetManager.cxx:1062
 TDataSetManager.cxx:1063
 TDataSetManager.cxx:1064
 TDataSetManager.cxx:1065
 TDataSetManager.cxx:1066
 TDataSetManager.cxx:1067
 TDataSetManager.cxx:1068
 TDataSetManager.cxx:1069
 TDataSetManager.cxx:1070
 TDataSetManager.cxx:1071
 TDataSetManager.cxx:1072
 TDataSetManager.cxx:1073
 TDataSetManager.cxx:1074
 TDataSetManager.cxx:1075
 TDataSetManager.cxx:1076
 TDataSetManager.cxx:1077
 TDataSetManager.cxx:1078
 TDataSetManager.cxx:1079
 TDataSetManager.cxx:1080
 TDataSetManager.cxx:1081
 TDataSetManager.cxx:1082
 TDataSetManager.cxx:1083
 TDataSetManager.cxx:1084
 TDataSetManager.cxx:1085
 TDataSetManager.cxx:1086
 TDataSetManager.cxx:1087
 TDataSetManager.cxx:1088
 TDataSetManager.cxx:1089
 TDataSetManager.cxx:1090
 TDataSetManager.cxx:1091
 TDataSetManager.cxx:1092
 TDataSetManager.cxx:1093
 TDataSetManager.cxx:1094
 TDataSetManager.cxx:1095
 TDataSetManager.cxx:1096
 TDataSetManager.cxx:1097
 TDataSetManager.cxx:1098
 TDataSetManager.cxx:1099
 TDataSetManager.cxx:1100
 TDataSetManager.cxx:1101
 TDataSetManager.cxx:1102
 TDataSetManager.cxx:1103
 TDataSetManager.cxx:1104
 TDataSetManager.cxx:1105
 TDataSetManager.cxx:1106
 TDataSetManager.cxx:1107
 TDataSetManager.cxx:1108
 TDataSetManager.cxx:1109
 TDataSetManager.cxx:1110
 TDataSetManager.cxx:1111
 TDataSetManager.cxx:1112
 TDataSetManager.cxx:1113
 TDataSetManager.cxx:1114
 TDataSetManager.cxx:1115
 TDataSetManager.cxx:1116
 TDataSetManager.cxx:1117
 TDataSetManager.cxx:1118
 TDataSetManager.cxx:1119
 TDataSetManager.cxx:1120
 TDataSetManager.cxx:1121
 TDataSetManager.cxx:1122
 TDataSetManager.cxx:1123
 TDataSetManager.cxx:1124
 TDataSetManager.cxx:1125
 TDataSetManager.cxx:1126
 TDataSetManager.cxx:1127
 TDataSetManager.cxx:1128
 TDataSetManager.cxx:1129
 TDataSetManager.cxx:1130
 TDataSetManager.cxx:1131
 TDataSetManager.cxx:1132
 TDataSetManager.cxx:1133
 TDataSetManager.cxx:1134
 TDataSetManager.cxx:1135
 TDataSetManager.cxx:1136
 TDataSetManager.cxx:1137
 TDataSetManager.cxx:1138
 TDataSetManager.cxx:1139
 TDataSetManager.cxx:1140
 TDataSetManager.cxx:1141
 TDataSetManager.cxx:1142
 TDataSetManager.cxx:1143
 TDataSetManager.cxx:1144
 TDataSetManager.cxx:1145
 TDataSetManager.cxx:1146
 TDataSetManager.cxx:1147
 TDataSetManager.cxx:1148
 TDataSetManager.cxx:1149
 TDataSetManager.cxx:1150
 TDataSetManager.cxx:1151
 TDataSetManager.cxx:1152
 TDataSetManager.cxx:1153
 TDataSetManager.cxx:1154
 TDataSetManager.cxx:1155
 TDataSetManager.cxx:1156
 TDataSetManager.cxx:1157
 TDataSetManager.cxx:1158
 TDataSetManager.cxx:1159
 TDataSetManager.cxx:1160
 TDataSetManager.cxx:1161
 TDataSetManager.cxx:1162
 TDataSetManager.cxx:1163
 TDataSetManager.cxx:1164
 TDataSetManager.cxx:1165
 TDataSetManager.cxx:1166
 TDataSetManager.cxx:1167
 TDataSetManager.cxx:1168
 TDataSetManager.cxx:1169
 TDataSetManager.cxx:1170
 TDataSetManager.cxx:1171
 TDataSetManager.cxx:1172
 TDataSetManager.cxx:1173
 TDataSetManager.cxx:1174
 TDataSetManager.cxx:1175
 TDataSetManager.cxx:1176
 TDataSetManager.cxx:1177
 TDataSetManager.cxx:1178
 TDataSetManager.cxx:1179
 TDataSetManager.cxx:1180
 TDataSetManager.cxx:1181
 TDataSetManager.cxx:1182
 TDataSetManager.cxx:1183
 TDataSetManager.cxx:1184
 TDataSetManager.cxx:1185
 TDataSetManager.cxx:1186
 TDataSetManager.cxx:1187
 TDataSetManager.cxx:1188
 TDataSetManager.cxx:1189
 TDataSetManager.cxx:1190
 TDataSetManager.cxx:1191
 TDataSetManager.cxx:1192
 TDataSetManager.cxx:1193
 TDataSetManager.cxx:1194
 TDataSetManager.cxx:1195
 TDataSetManager.cxx:1196
 TDataSetManager.cxx:1197
 TDataSetManager.cxx:1198
 TDataSetManager.cxx:1199
 TDataSetManager.cxx:1200
 TDataSetManager.cxx:1201
 TDataSetManager.cxx:1202
 TDataSetManager.cxx:1203
 TDataSetManager.cxx:1204
 TDataSetManager.cxx:1205
 TDataSetManager.cxx:1206
 TDataSetManager.cxx:1207
 TDataSetManager.cxx:1208
 TDataSetManager.cxx:1209
 TDataSetManager.cxx:1210
 TDataSetManager.cxx:1211
 TDataSetManager.cxx:1212
 TDataSetManager.cxx:1213
 TDataSetManager.cxx:1214
 TDataSetManager.cxx:1215
 TDataSetManager.cxx:1216
 TDataSetManager.cxx:1217
 TDataSetManager.cxx:1218
 TDataSetManager.cxx:1219
 TDataSetManager.cxx:1220
 TDataSetManager.cxx:1221
 TDataSetManager.cxx:1222
 TDataSetManager.cxx:1223
 TDataSetManager.cxx:1224
 TDataSetManager.cxx:1225
 TDataSetManager.cxx:1226
 TDataSetManager.cxx:1227
 TDataSetManager.cxx:1228
 TDataSetManager.cxx:1229
 TDataSetManager.cxx:1230
 TDataSetManager.cxx:1231
 TDataSetManager.cxx:1232
 TDataSetManager.cxx:1233
 TDataSetManager.cxx:1234
 TDataSetManager.cxx:1235
 TDataSetManager.cxx:1236
 TDataSetManager.cxx:1237
 TDataSetManager.cxx:1238
 TDataSetManager.cxx:1239
 TDataSetManager.cxx:1240
 TDataSetManager.cxx:1241
 TDataSetManager.cxx:1242
 TDataSetManager.cxx:1243
 TDataSetManager.cxx:1244
 TDataSetManager.cxx:1245
 TDataSetManager.cxx:1246
 TDataSetManager.cxx:1247
 TDataSetManager.cxx:1248
 TDataSetManager.cxx:1249
 TDataSetManager.cxx:1250
 TDataSetManager.cxx:1251
 TDataSetManager.cxx:1252
 TDataSetManager.cxx:1253
 TDataSetManager.cxx:1254
 TDataSetManager.cxx:1255
 TDataSetManager.cxx:1256
 TDataSetManager.cxx:1257
 TDataSetManager.cxx:1258
 TDataSetManager.cxx:1259
 TDataSetManager.cxx:1260
 TDataSetManager.cxx:1261
 TDataSetManager.cxx:1262
 TDataSetManager.cxx:1263
 TDataSetManager.cxx:1264
 TDataSetManager.cxx:1265
 TDataSetManager.cxx:1266
 TDataSetManager.cxx:1267
 TDataSetManager.cxx:1268
 TDataSetManager.cxx:1269
 TDataSetManager.cxx:1270
 TDataSetManager.cxx:1271
 TDataSetManager.cxx:1272
 TDataSetManager.cxx:1273
 TDataSetManager.cxx:1274
 TDataSetManager.cxx:1275
 TDataSetManager.cxx:1276
 TDataSetManager.cxx:1277
 TDataSetManager.cxx:1278
 TDataSetManager.cxx:1279
 TDataSetManager.cxx:1280
 TDataSetManager.cxx:1281
 TDataSetManager.cxx:1282
 TDataSetManager.cxx:1283
 TDataSetManager.cxx:1284
 TDataSetManager.cxx:1285
 TDataSetManager.cxx:1286
 TDataSetManager.cxx:1287
 TDataSetManager.cxx:1288
 TDataSetManager.cxx:1289
 TDataSetManager.cxx:1290
 TDataSetManager.cxx:1291
 TDataSetManager.cxx:1292
 TDataSetManager.cxx:1293
 TDataSetManager.cxx:1294
 TDataSetManager.cxx:1295
 TDataSetManager.cxx:1296
 TDataSetManager.cxx:1297
 TDataSetManager.cxx:1298
 TDataSetManager.cxx:1299
 TDataSetManager.cxx:1300
 TDataSetManager.cxx:1301
 TDataSetManager.cxx:1302
 TDataSetManager.cxx:1303
 TDataSetManager.cxx:1304
 TDataSetManager.cxx:1305
 TDataSetManager.cxx:1306
 TDataSetManager.cxx:1307
 TDataSetManager.cxx:1308
 TDataSetManager.cxx:1309
 TDataSetManager.cxx:1310
 TDataSetManager.cxx:1311
 TDataSetManager.cxx:1312
 TDataSetManager.cxx:1313
 TDataSetManager.cxx:1314
 TDataSetManager.cxx:1315
 TDataSetManager.cxx:1316
 TDataSetManager.cxx:1317
 TDataSetManager.cxx:1318
 TDataSetManager.cxx:1319
 TDataSetManager.cxx:1320
 TDataSetManager.cxx:1321
 TDataSetManager.cxx:1322
 TDataSetManager.cxx:1323
 TDataSetManager.cxx:1324
 TDataSetManager.cxx:1325
 TDataSetManager.cxx:1326
 TDataSetManager.cxx:1327
 TDataSetManager.cxx:1328
 TDataSetManager.cxx:1329
 TDataSetManager.cxx:1330
 TDataSetManager.cxx:1331
 TDataSetManager.cxx:1332
 TDataSetManager.cxx:1333
 TDataSetManager.cxx:1334
 TDataSetManager.cxx:1335
 TDataSetManager.cxx:1336
 TDataSetManager.cxx:1337
 TDataSetManager.cxx:1338
 TDataSetManager.cxx:1339
 TDataSetManager.cxx:1340
 TDataSetManager.cxx:1341
 TDataSetManager.cxx:1342
 TDataSetManager.cxx:1343
 TDataSetManager.cxx:1344
 TDataSetManager.cxx:1345
 TDataSetManager.cxx:1346
 TDataSetManager.cxx:1347
 TDataSetManager.cxx:1348
 TDataSetManager.cxx:1349
 TDataSetManager.cxx:1350
 TDataSetManager.cxx:1351
 TDataSetManager.cxx:1352
 TDataSetManager.cxx:1353
 TDataSetManager.cxx:1354
 TDataSetManager.cxx:1355
 TDataSetManager.cxx:1356
 TDataSetManager.cxx:1357
 TDataSetManager.cxx:1358
 TDataSetManager.cxx:1359
 TDataSetManager.cxx:1360
 TDataSetManager.cxx:1361
 TDataSetManager.cxx:1362
 TDataSetManager.cxx:1363
 TDataSetManager.cxx:1364
 TDataSetManager.cxx:1365
 TDataSetManager.cxx:1366
 TDataSetManager.cxx:1367
 TDataSetManager.cxx:1368
 TDataSetManager.cxx:1369
 TDataSetManager.cxx:1370
 TDataSetManager.cxx:1371
 TDataSetManager.cxx:1372
 TDataSetManager.cxx:1373
 TDataSetManager.cxx:1374
 TDataSetManager.cxx:1375
 TDataSetManager.cxx:1376
 TDataSetManager.cxx:1377
 TDataSetManager.cxx:1378
 TDataSetManager.cxx:1379
 TDataSetManager.cxx:1380
 TDataSetManager.cxx:1381
 TDataSetManager.cxx:1382
 TDataSetManager.cxx:1383
 TDataSetManager.cxx:1384
 TDataSetManager.cxx:1385
 TDataSetManager.cxx:1386
 TDataSetManager.cxx:1387
 TDataSetManager.cxx:1388
 TDataSetManager.cxx:1389
 TDataSetManager.cxx:1390
 TDataSetManager.cxx:1391
 TDataSetManager.cxx:1392
 TDataSetManager.cxx:1393
 TDataSetManager.cxx:1394
 TDataSetManager.cxx:1395
 TDataSetManager.cxx:1396
 TDataSetManager.cxx:1397
 TDataSetManager.cxx:1398
 TDataSetManager.cxx:1399
 TDataSetManager.cxx:1400
 TDataSetManager.cxx:1401
 TDataSetManager.cxx:1402
 TDataSetManager.cxx:1403
 TDataSetManager.cxx:1404
 TDataSetManager.cxx:1405
 TDataSetManager.cxx:1406
 TDataSetManager.cxx:1407
 TDataSetManager.cxx:1408
 TDataSetManager.cxx:1409
 TDataSetManager.cxx:1410
 TDataSetManager.cxx:1411
 TDataSetManager.cxx:1412
 TDataSetManager.cxx:1413
 TDataSetManager.cxx:1414
 TDataSetManager.cxx:1415
 TDataSetManager.cxx:1416
 TDataSetManager.cxx:1417
 TDataSetManager.cxx:1418
 TDataSetManager.cxx:1419
 TDataSetManager.cxx:1420
 TDataSetManager.cxx:1421
 TDataSetManager.cxx:1422
 TDataSetManager.cxx:1423
 TDataSetManager.cxx:1424
 TDataSetManager.cxx:1425
 TDataSetManager.cxx:1426
 TDataSetManager.cxx:1427
 TDataSetManager.cxx:1428
 TDataSetManager.cxx:1429
 TDataSetManager.cxx:1430
 TDataSetManager.cxx:1431
 TDataSetManager.cxx:1432
 TDataSetManager.cxx:1433
 TDataSetManager.cxx:1434
 TDataSetManager.cxx:1435
 TDataSetManager.cxx:1436
 TDataSetManager.cxx:1437
 TDataSetManager.cxx:1438
 TDataSetManager.cxx:1439
 TDataSetManager.cxx:1440
 TDataSetManager.cxx:1441
 TDataSetManager.cxx:1442
 TDataSetManager.cxx:1443
 TDataSetManager.cxx:1444
 TDataSetManager.cxx:1445
 TDataSetManager.cxx:1446
 TDataSetManager.cxx:1447
 TDataSetManager.cxx:1448
 TDataSetManager.cxx:1449
 TDataSetManager.cxx:1450
 TDataSetManager.cxx:1451
 TDataSetManager.cxx:1452
 TDataSetManager.cxx:1453
 TDataSetManager.cxx:1454
 TDataSetManager.cxx:1455
 TDataSetManager.cxx:1456
 TDataSetManager.cxx:1457
 TDataSetManager.cxx:1458
 TDataSetManager.cxx:1459
 TDataSetManager.cxx:1460
 TDataSetManager.cxx:1461
 TDataSetManager.cxx:1462
 TDataSetManager.cxx:1463
 TDataSetManager.cxx:1464
 TDataSetManager.cxx:1465
 TDataSetManager.cxx:1466
 TDataSetManager.cxx:1467
 TDataSetManager.cxx:1468
 TDataSetManager.cxx:1469
 TDataSetManager.cxx:1470
 TDataSetManager.cxx:1471
 TDataSetManager.cxx:1472
 TDataSetManager.cxx:1473
 TDataSetManager.cxx:1474
 TDataSetManager.cxx:1475
 TDataSetManager.cxx:1476
 TDataSetManager.cxx:1477
 TDataSetManager.cxx:1478
 TDataSetManager.cxx:1479
 TDataSetManager.cxx:1480
 TDataSetManager.cxx:1481
 TDataSetManager.cxx:1482
 TDataSetManager.cxx:1483
 TDataSetManager.cxx:1484
 TDataSetManager.cxx:1485
 TDataSetManager.cxx:1486
 TDataSetManager.cxx:1487
 TDataSetManager.cxx:1488
 TDataSetManager.cxx:1489
 TDataSetManager.cxx:1490
 TDataSetManager.cxx:1491
 TDataSetManager.cxx:1492
 TDataSetManager.cxx:1493
 TDataSetManager.cxx:1494
 TDataSetManager.cxx:1495
 TDataSetManager.cxx:1496
 TDataSetManager.cxx:1497
 TDataSetManager.cxx:1498
 TDataSetManager.cxx:1499
 TDataSetManager.cxx:1500
 TDataSetManager.cxx:1501
 TDataSetManager.cxx:1502
 TDataSetManager.cxx:1503
 TDataSetManager.cxx:1504
 TDataSetManager.cxx:1505
 TDataSetManager.cxx:1506
 TDataSetManager.cxx:1507
 TDataSetManager.cxx:1508
 TDataSetManager.cxx:1509
 TDataSetManager.cxx:1510
 TDataSetManager.cxx:1511
 TDataSetManager.cxx:1512
 TDataSetManager.cxx:1513
 TDataSetManager.cxx:1514
 TDataSetManager.cxx:1515
 TDataSetManager.cxx:1516
 TDataSetManager.cxx:1517
 TDataSetManager.cxx:1518
 TDataSetManager.cxx:1519
 TDataSetManager.cxx:1520
 TDataSetManager.cxx:1521
 TDataSetManager.cxx:1522
 TDataSetManager.cxx:1523
 TDataSetManager.cxx:1524
 TDataSetManager.cxx:1525
 TDataSetManager.cxx:1526
 TDataSetManager.cxx:1527
 TDataSetManager.cxx:1528
 TDataSetManager.cxx:1529
 TDataSetManager.cxx:1530
 TDataSetManager.cxx:1531
 TDataSetManager.cxx:1532
 TDataSetManager.cxx:1533
 TDataSetManager.cxx:1534
 TDataSetManager.cxx:1535
 TDataSetManager.cxx:1536
 TDataSetManager.cxx:1537
 TDataSetManager.cxx:1538
 TDataSetManager.cxx:1539
 TDataSetManager.cxx:1540
 TDataSetManager.cxx:1541
 TDataSetManager.cxx:1542
 TDataSetManager.cxx:1543
 TDataSetManager.cxx:1544
 TDataSetManager.cxx:1545
 TDataSetManager.cxx:1546
 TDataSetManager.cxx:1547
 TDataSetManager.cxx:1548
 TDataSetManager.cxx:1549
 TDataSetManager.cxx:1550
 TDataSetManager.cxx:1551
 TDataSetManager.cxx:1552
 TDataSetManager.cxx:1553
 TDataSetManager.cxx:1554
 TDataSetManager.cxx:1555
 TDataSetManager.cxx:1556
 TDataSetManager.cxx:1557
 TDataSetManager.cxx:1558
 TDataSetManager.cxx:1559
 TDataSetManager.cxx:1560
 TDataSetManager.cxx:1561
 TDataSetManager.cxx:1562
 TDataSetManager.cxx:1563
 TDataSetManager.cxx:1564
 TDataSetManager.cxx:1565
 TDataSetManager.cxx:1566
 TDataSetManager.cxx:1567
 TDataSetManager.cxx:1568
 TDataSetManager.cxx:1569
 TDataSetManager.cxx:1570
 TDataSetManager.cxx:1571
 TDataSetManager.cxx:1572
 TDataSetManager.cxx:1573
 TDataSetManager.cxx:1574
 TDataSetManager.cxx:1575
 TDataSetManager.cxx:1576
 TDataSetManager.cxx:1577
 TDataSetManager.cxx:1578
 TDataSetManager.cxx:1579
 TDataSetManager.cxx:1580
 TDataSetManager.cxx:1581
 TDataSetManager.cxx:1582
 TDataSetManager.cxx:1583
 TDataSetManager.cxx:1584
 TDataSetManager.cxx:1585
 TDataSetManager.cxx:1586
 TDataSetManager.cxx:1587
 TDataSetManager.cxx:1588
 TDataSetManager.cxx:1589
 TDataSetManager.cxx:1590
 TDataSetManager.cxx:1591
 TDataSetManager.cxx:1592
 TDataSetManager.cxx:1593
 TDataSetManager.cxx:1594
 TDataSetManager.cxx:1595
 TDataSetManager.cxx:1596
 TDataSetManager.cxx:1597
 TDataSetManager.cxx:1598
 TDataSetManager.cxx:1599
 TDataSetManager.cxx:1600
 TDataSetManager.cxx:1601
 TDataSetManager.cxx:1602
 TDataSetManager.cxx:1603
 TDataSetManager.cxx:1604
 TDataSetManager.cxx:1605
 TDataSetManager.cxx:1606
 TDataSetManager.cxx:1607
 TDataSetManager.cxx:1608
 TDataSetManager.cxx:1609
 TDataSetManager.cxx:1610
 TDataSetManager.cxx:1611
 TDataSetManager.cxx:1612
 TDataSetManager.cxx:1613
 TDataSetManager.cxx:1614
 TDataSetManager.cxx:1615
 TDataSetManager.cxx:1616
 TDataSetManager.cxx:1617
 TDataSetManager.cxx:1618
 TDataSetManager.cxx:1619
 TDataSetManager.cxx:1620
 TDataSetManager.cxx:1621
 TDataSetManager.cxx:1622
 TDataSetManager.cxx:1623
 TDataSetManager.cxx:1624
 TDataSetManager.cxx:1625
 TDataSetManager.cxx:1626
 TDataSetManager.cxx:1627
 TDataSetManager.cxx:1628
 TDataSetManager.cxx:1629
 TDataSetManager.cxx:1630
 TDataSetManager.cxx:1631
 TDataSetManager.cxx:1632
 TDataSetManager.cxx:1633
 TDataSetManager.cxx:1634
 TDataSetManager.cxx:1635
 TDataSetManager.cxx:1636
 TDataSetManager.cxx:1637
 TDataSetManager.cxx:1638
 TDataSetManager.cxx:1639
 TDataSetManager.cxx:1640
 TDataSetManager.cxx:1641
 TDataSetManager.cxx:1642
 TDataSetManager.cxx:1643
 TDataSetManager.cxx:1644
 TDataSetManager.cxx:1645
 TDataSetManager.cxx:1646
 TDataSetManager.cxx:1647
 TDataSetManager.cxx:1648
 TDataSetManager.cxx:1649
 TDataSetManager.cxx:1650
 TDataSetManager.cxx:1651
 TDataSetManager.cxx:1652
 TDataSetManager.cxx:1653
 TDataSetManager.cxx:1654
 TDataSetManager.cxx:1655
 TDataSetManager.cxx:1656
 TDataSetManager.cxx:1657
 TDataSetManager.cxx:1658
 TDataSetManager.cxx:1659
 TDataSetManager.cxx:1660
 TDataSetManager.cxx:1661
 TDataSetManager.cxx:1662
 TDataSetManager.cxx:1663
 TDataSetManager.cxx:1664
 TDataSetManager.cxx:1665
 TDataSetManager.cxx:1666
 TDataSetManager.cxx:1667
 TDataSetManager.cxx:1668
 TDataSetManager.cxx:1669
 TDataSetManager.cxx:1670
 TDataSetManager.cxx:1671
 TDataSetManager.cxx:1672
 TDataSetManager.cxx:1673
 TDataSetManager.cxx:1674
 TDataSetManager.cxx:1675
 TDataSetManager.cxx:1676
 TDataSetManager.cxx:1677
 TDataSetManager.cxx:1678
 TDataSetManager.cxx:1679
 TDataSetManager.cxx:1680
 TDataSetManager.cxx:1681
 TDataSetManager.cxx:1682
 TDataSetManager.cxx:1683
 TDataSetManager.cxx:1684
 TDataSetManager.cxx:1685
 TDataSetManager.cxx:1686
 TDataSetManager.cxx:1687
 TDataSetManager.cxx:1688
 TDataSetManager.cxx:1689
 TDataSetManager.cxx:1690
 TDataSetManager.cxx:1691
 TDataSetManager.cxx:1692
 TDataSetManager.cxx:1693
 TDataSetManager.cxx:1694
 TDataSetManager.cxx:1695
 TDataSetManager.cxx:1696
 TDataSetManager.cxx:1697
 TDataSetManager.cxx:1698
 TDataSetManager.cxx:1699
 TDataSetManager.cxx:1700
 TDataSetManager.cxx:1701
 TDataSetManager.cxx:1702
 TDataSetManager.cxx:1703
 TDataSetManager.cxx:1704
 TDataSetManager.cxx:1705
 TDataSetManager.cxx:1706
 TDataSetManager.cxx:1707
 TDataSetManager.cxx:1708
 TDataSetManager.cxx:1709
 TDataSetManager.cxx:1710
 TDataSetManager.cxx:1711
 TDataSetManager.cxx:1712
 TDataSetManager.cxx:1713
 TDataSetManager.cxx:1714
 TDataSetManager.cxx:1715
 TDataSetManager.cxx:1716
 TDataSetManager.cxx:1717
 TDataSetManager.cxx:1718
 TDataSetManager.cxx:1719
 TDataSetManager.cxx:1720
 TDataSetManager.cxx:1721
 TDataSetManager.cxx:1722
 TDataSetManager.cxx:1723
 TDataSetManager.cxx:1724
 TDataSetManager.cxx:1725
 TDataSetManager.cxx:1726
 TDataSetManager.cxx:1727
 TDataSetManager.cxx:1728
 TDataSetManager.cxx:1729
 TDataSetManager.cxx:1730
 TDataSetManager.cxx:1731
 TDataSetManager.cxx:1732
 TDataSetManager.cxx:1733
 TDataSetManager.cxx:1734
 TDataSetManager.cxx:1735
 TDataSetManager.cxx:1736
 TDataSetManager.cxx:1737
 TDataSetManager.cxx:1738
 TDataSetManager.cxx:1739
 TDataSetManager.cxx:1740
 TDataSetManager.cxx:1741
 TDataSetManager.cxx:1742
 TDataSetManager.cxx:1743
 TDataSetManager.cxx:1744
 TDataSetManager.cxx:1745
 TDataSetManager.cxx:1746
 TDataSetManager.cxx:1747
 TDataSetManager.cxx:1748
 TDataSetManager.cxx:1749
 TDataSetManager.cxx:1750
 TDataSetManager.cxx:1751
 TDataSetManager.cxx:1752
 TDataSetManager.cxx:1753
 TDataSetManager.cxx:1754
 TDataSetManager.cxx:1755
 TDataSetManager.cxx:1756
 TDataSetManager.cxx:1757
 TDataSetManager.cxx:1758
 TDataSetManager.cxx:1759
 TDataSetManager.cxx:1760
 TDataSetManager.cxx:1761
 TDataSetManager.cxx:1762
 TDataSetManager.cxx:1763
 TDataSetManager.cxx:1764
 TDataSetManager.cxx:1765
 TDataSetManager.cxx:1766
 TDataSetManager.cxx:1767
 TDataSetManager.cxx:1768
 TDataSetManager.cxx:1769
 TDataSetManager.cxx:1770
 TDataSetManager.cxx:1771
 TDataSetManager.cxx:1772
 TDataSetManager.cxx:1773
 TDataSetManager.cxx:1774
 TDataSetManager.cxx:1775
 TDataSetManager.cxx:1776
 TDataSetManager.cxx:1777
 TDataSetManager.cxx:1778
 TDataSetManager.cxx:1779
 TDataSetManager.cxx:1780
 TDataSetManager.cxx:1781
 TDataSetManager.cxx:1782
 TDataSetManager.cxx:1783
 TDataSetManager.cxx:1784
 TDataSetManager.cxx:1785
 TDataSetManager.cxx:1786
 TDataSetManager.cxx:1787