Tree.h

// -*- C++ -*-
//
// Tree.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef LWH_Tree_H
#define LWH_Tree_H
//
// This is the declaration of the Tree class.
//

#include "AITree.h"
#include "ManagedObject.h"
#include <fstream>
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <string>

namespace LWH {

using namespace AIDA;

class Tree: public ITree {

public:

  friend class AnalysisFactory;

  typedef std::vector<std::string> Path;

  typedef std::set<Path> PathSet;

  typedef std::map<std::string, IManagedObject *> ObjMap;

public:

  Tree(std::string storename, bool xml = true)
    : name(storename), flat(!xml), cwd("/"), overwrite(true) {
    dirs.insert(Path());
  }

  Tree(): name(""), flat(false), cwd("/") {
    dirs.insert(Path());
  }

  Tree(const Tree & dt)
    : ITree(dt), name(dt.name), flat(dt.flat), dirs(dt.dirs),
      objs(dt.objs), cwd(dt.cwd), overwrite(true) {}

  virtual ~Tree() {
    for ( ObjMap::iterator it = objs.begin(); it != objs.end(); ++it )
      delete it->second;
  }

  std::string storeName() const {
    return name;
  }

  IManagedObject * find(const std::string & path) {
    ObjMap::const_iterator it = objs.find(path);
    return it == objs.end()? (IManagedObject *)0: it->second;
  }

  ITree * findTree(const std::string &) {
    return 0;
  }

  bool cd(const std::string & dir) {
    PathSet::iterator it = dirs.find(purgepath(str2pth(fullpath(sts(dir)))));
    if ( it == dirs.end() ) return false;
    cwd = pth2str(*it);
    return true;
  }

  bool insert(std::string str, IManagedObject * o) {
    Path path = purgepath(str2pth(fullpath(str)));
    if ( dirs.find(path) == dirs.end() ) {
      std::string fullname = pth2str(path);
      path.pop_back();
      if ( dirs.find(path) != dirs.end() ) {
        ObjMap::iterator old = objs.find(fullname);
        if ( old == objs.end() || overwrite ) {
          if ( old != objs.end() ) {
            delete old->second;
            objs.erase(old);
          }
          objs[fullname] = o;
          return true;
        }
      }
    }
    return false;
  }

  std::string pwd() const {
    return cwd;
  }

  bool ls(const std::string & = ".", bool = false,
          std::ostream & = std::cout) const {
    return false;
  }

  std::vector<std::string> listObjectNames(const std::string & = ".",
                                           bool = false) const {
    return std::vector<std::string>();
  }

  std::vector<std::string> listObjectTypes(const std::string & = ".",
                                           bool = false) const {
    return std::vector<std::string>();
  }

  bool mkdir(const std::string & dir) {
    Path p = purgepath(str2pth(fullpath(sts(dir))));
    Path base = p;
    base.pop_back();
    if ( dirs.find(base) == dirs.end() ) return false;
    dirs.insert(p);
    return true;
  }

  bool mkdirs(const std::string & dir) {
    return mkdirs(purgepath(str2pth(fullpath(sts(dir)))));
  }

  bool mkdirs(Path p) {
    if ( dirs.find(p) != dirs.end() ) return true;
    dirs.insert(p);
    p.pop_back();
    return mkdirs(p);
  }

  bool rmdir(const std::string & dir) {
    Path path = purgepath(str2pth(fullpath(sts(dir))));
    if ( dirs.find(path) == dirs.end() ) return false;
    for ( ObjMap::const_iterator it = objs.begin(); it != objs.end(); ++it )
      if ( it->first.substr(0, dir.length()) == dir ) return false;
    dirs.erase(path);
    return true;
  }

  bool rm(const std::string & path) {
    ObjMap::iterator it = objs.find(fullpath(path));
    if ( it == objs.end() ) return false;
    delete it->second;
    objs.erase(it);
    return true;
  }

  std::string findPath(const IManagedObject & o) const {
    for ( ObjMap::const_iterator it = objs.begin(); it != objs.end(); ++it )
      if ( it->second == &o ) return it->first;
    return "";
  }

  bool mv(const std::string & oldp, const std::string & newp) {
    Path newpath = purgepath(str2pth(fullpath(sts(newp))));
    std::string foldp = fullpath(oldp);
    Path oldpath = purgepath(str2pth(foldp));
    ObjMap::iterator it = objs.find(foldp);
    if ( it == objs.end() ) return false;
    if ( dirs.find(newpath) != dirs.end() ) return false;
    newpath.push_back(oldpath.back());
    if ( !insert(pth2str(newpath), it->second) ) return false;
    objs.erase(foldp);
    return true;
  }

  bool commit() {
    std::ofstream of(name.c_str());
    if ( !of ) return false;
    if ( !flat ) of
      << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE aida SYSTEM "
      << "\"http://aida.freehep.org/schemas/3.0/aida.dtd\">\n"
      << "<aida version=\"3.0\">\n"
      << "<implementation version=\"1.0\" package=\"FreeHEP\"/>" << std::endl;
    for ( ObjMap::const_iterator it = objs.begin(); it != objs.end(); ++it ) {
      ManagedObject * o = dynamic_cast<ManagedObject *>(it->second);
      if ( !o ) continue;
      std::string path = it->first.substr(0, it->first.rfind('/'));
      std::string name = it->first.substr(it->first.rfind('/') + 1);
      if ( flat )
        o->writeFLAT(of, path, name);
      else
        o->writeXML(of, path, name);
    }
    if ( !flat ) of << "</aida>" << std::endl;
    return of.good();
  }

  void setOverwrite(bool o = true) {
    overwrite = o;
  }

  bool cp(const std::string &, const std::string &, bool = false) {
    return false;
  }

  bool symlink(const std::string &, const std::string &) {
    return false;
  }

  bool mount(const std::string &, ITree &, const std::string &) {
    return false;
  }

  bool unmount(const std::string &) {
    return false;
  }

  bool close() {
    return commit();
  }

  void * cast(const std::string &) const {
    return 0;
  }

protected:

  std::string sts(std::string s) const {
    if ( s[s.length() - 1] == '/' ) s = s.substr(0, s.length() - 1);
    if ( s[s.length() - 1] == '/' ) return "";
    return s;
  }

  std::string stn(std::string s) const {
    std::string::size_type slash = s.rfind('/');
    return s.substr(0, slash);
  }

  std::string fullpath(std::string d) const {
    if ( d[0] != '/' ) d = cwd + "/" + d;
    return pth2str(purgepath(str2pth(d)));
  }

  Path str2pth(std::string s) const {
    Path pth;
    std::string::size_type i = s.find_first_not_of("/");
    while ( i != std::string::npos ) {
      s = s.substr(i);
      i = s.find_first_of("/");
      pth.push_back(s.substr(0, i));
      if ( i == std::string::npos ) return pth;
      s = s.substr(i);
      i = s.find_first_not_of("/");
    }
    return pth;
  }

  std::string pth2str(const Path & pth) const {
    std::string str;
    for ( int i = 0, N = pth.size(); i < N; ++i ) str += "/" + pth[i];
    return str;
  }

  Path purgepath(const Path & pth) const {
    Path p;
    for ( int i = 0, N = pth.size(); i < N; ++i ) {
      if ( pth[i] == ".." ) p.pop_back();
      else if ( pth[i] != "." ) p.push_back(pth[i]);
    }
    return p;
  }

private:

  std::string name;

  bool flat;

  PathSet dirs;

  ObjMap objs;

  std::string cwd;

  bool overwrite;

};

}

#endif /* LWH_Tree_H */