File indexing completed on 2024-04-28 04:40:01

 #include "deepfiletree.h"
 #include <QUrl>
 #include <QFileInfo>
 #include <QDir>
 #include <QVector>
 #include <QVariant>
 #include <QXmlQuery>
 #include <QDomElement>
 #include "pole.h"
 #include <QDebug>
 
 using namespace std;
 
 /** This XML model spans the file system, OLE streams in OLE files and data structures in some
  *  OLE streams.
  **/
 
 namespace {
 class ElementNode {
 public:
     // if parent, firstSibling, next or previous are -1, they corresponding node does not exist
     // if the value is -2, the corresponding node has not been searched yet
     int parentId;
     int firstSiblingId;
     int nextId;
     int previousId;
 
     ElementNode() :parentId(-2), firstSiblingId(-2), nextId(-2), previousId(-2) {}
 };
 
 class OleStreamElementNode : public ElementNode {
 public:
     string streamname;
     int size;
     bool isdir;
 };
 
 class XmlElementNode : public ElementNode {
 public:
     QDomElement element;
 };
 
 enum Type {
     File,
     OLEStream,
     XmlElement
 };
 
 const int typeSize = 3;
 const int indexSize = sizeof(int)*8 - typeSize;
 
 Type getType(int id) {
     return (Type)(id >> indexSize);
 }
 // last bits are used for the type
 int getIndex(int id) {
     return (id << typeSize) >> typeSize;
 }
 int getId(Type t, int index) {
     return (t << indexSize) | index;
 }
 
 enum Kind {
     Element,
     AttributeName,
     AttributeSize
 };
 
 }
 
 class DeepFileTree::Private {
 public:
     QXmlNamePool namepool;
     QList<ElementNode> fileinfonodes;
     QList<QFileInfo> fileinfos;
     QList<OleStreamElementNode> olestreams;
     QList<XmlElementNode> xmlelements;
     QDomDocument doc;
     const QXmlName directory;
     const QXmlName file;
     const QXmlName olestream;
     const QXmlName olestreamdir;
     const QXmlName name;
     const QXmlName size;
 
     Private(const QXmlNamePool& pool) :namepool(pool),
             directory(QXmlName(namepool, QLatin1String("directory"))),
             file(QXmlName(namepool, QLatin1String("file"))),
             olestream(QXmlName(namepool, QLatin1String("olestream"))),
             olestreamdir(QXmlName(namepool, QLatin1String("olestreamdir"))),
             name(QXmlName(namepool, QLatin1String("name"))),
             size(QXmlName(namepool, QLatin1String("size"))) {
     }
 
     ElementNode& getElementNode(int id) {
         int index = getIndex(id);
         switch (getType(id)) {
             case File: return fileinfonodes[index];
             case OLEStream: return olestreams[index];
             case XmlElement:
             default:
             return xmlelements[index];
         }
     }
     QFileInfo* getFileInfo(int id) {
         return (getType(id) == File) ?&fileinfos[getIndex(id)] :0;
     }
 
     int getFileIndex(const QFileInfo& fileinfo) {
         // find the parent
         QDir dir = fileinfo.dir();
         QFileInfo parentInfo(dir.path());
         if (fileinfo == parentInfo) { // parent does not exist
             ElementNode node;
             node.parentId = node.nextId = node.previousId = -1;
             fileinfos.append(fileinfo);
             fileinfonodes.append(node);
             return fileinfonodes.count() - 1;
         }
 
         int parentIndex = getFileIndex(parentInfo);
         if (parentIndex == -1) return -1;
         ElementNode& parent = fileinfonodes[parentIndex];
         if (parent.firstSiblingId != -2) return -1;
 
         // the parent has not initialized its siblings yet
         const int indexOf = fileinfos.indexOf(parentInfo);
         if (indexOf != -1) return indexOf;
 
         int offset = fileinfos.count();
         loadFileSiblings(dir, parentIndex, parent);
         return fileinfos.indexOf(fileinfo, offset);
     }
 
     void loadFileSiblings(const QDir& dir, int parentIndex, ElementNode& parent) {
         QFileInfoList list = dir.entryInfoList(QStringList(),
             QDir::AllEntries|QDir::AllDirs|QDir::NoDotAndDotDot|QDir::Hidden, QDir::Name);
         int offset = fileinfos.count();
         fileinfos.append(list);
         parent.firstSiblingId = (list.count()) ?getId(File, offset) :-1;
         for (int i=0; i<list.size(); ++i) {
             ElementNode n;
             n.parentId = getId(File, parentIndex);
             n.previousId = (i) ?getId(File, offset + i - 1) :-1;
             n.nextId = (i == list.size()-1) ?-1 :getId(File, offset + i + 1);
             fileinfonodes.append(n);
         }
     }
 
     void loadStreamSiblings(const QFileInfo& info, int parentIndex, ElementNode& parent) {
 //        if (info.suffix().toLower() != "ppt") return;
         POLE::Storage storage(info.absoluteFilePath().toLocal8Bit());
         if (!storage.open()) return;
         int offset = olestreams.count();
         int count = 0;
         list<string> entries = storage.entries();
         for (list<string>::const_iterator i=entries.begin(); i!=entries.end(); ++i) {
             if (!storage.isDirectory(*i)) {
                 POLE::Stream stream(&storage, "/"+*i);
                 OleStreamElementNode n;
                 n.streamname = *i;
                 n.size = stream.size();
                 n.isdir = false;
                 n.parentId = getId(File, parentIndex);
                 n.previousId = (count) ?getId(OLEStream, offset + count - 1) :-1;
                 n.nextId = getId(OLEStream, offset + count + 1);
                 olestreams.append(n);
                 count++;
             }
         }
         if (count) {
             parent.firstSiblingId = getId(OLEStream, offset);
             olestreams[olestreams.count()-1].nextId = -1;
         }
     }
 
     QDomElement createTestElement() {
         QDomElement e(doc.createElement("TESTING"));
         e.setAttribute("e", "E");
         QDomElement a(doc.createElement("suba"));
         a.setAttribute("a", "A");
         QDomElement b(doc.createElement("subb"));
         b.setAttribute("b", "B");
         b.setAttribute("c", "C");
         e.appendChild(a);
         e.appendChild(b);
         return e;
     }
 
     void loadStreamAsXmlElements(int parentId, ElementNode& parent) {
         parent.firstSiblingId = getId(XmlElement, xmlelements.count());
         QDomElement e = createTestElement();
         XmlElementNode& en = addXmlElement(e);
         en.parentId = parentId;
         en.nextId = -1;
         en.previousId = -1;
     }
 
     XmlElementNode& addXmlElement(const QDomElement& e) {
         int eindex = xmlelements.count();
         xmlelements.append(XmlElementNode());
         XmlElementNode& xe = xmlelements[eindex];
         xe.element = e;
 
         int eid = getId(XmlElement, eindex);
         int count = 0;
         QDomElement ce = e.firstChildElement();
         while (!ce.isNull()) {
             count++;
             XmlElementNode& cen = addXmlElement(ce);
             cen.parentId = eid; 
             cen.previousId = (count) ?eid + count - 1:-1;
             ce = ce.nextSiblingElement();
             cen.nextId = (ce.isNull()) ?-1 :eid + count + 1;
         }
         xe.firstSiblingId = (count > 0) ?eid + 1 :-1;
         return xe;
     }
 };
 
 DeepFileTree::DeepFileTree(const QXmlNamePool& pool) :d(new Private(pool)) {
 }
 DeepFileTree::~DeepFileTree() {
     delete d;
 }
 
 QXmlNodeModelIndex
 DeepFileTree::toNodeIndex(const QFileInfo& fileinfo) const {
     int indexOf = d->fileinfos.indexOf(fileinfo);
     if (indexOf == -1) {
         indexOf = d->getFileIndex(fileinfo);
         if (indexOf == -1) return QXmlNodeModelIndex();
     }
     return createIndex(indexOf, Element);
 }
 
 QVector<QXmlNodeModelIndex>
 DeepFileTree::attributes(const QXmlNodeModelIndex& element) const {
     QVector<QXmlNodeModelIndex> v;
     Type type = getType(element.data());
     switch (type) {
     case File: {
         v.append(createIndex(element.data(), AttributeName));
         const QFileInfo* info = d->getFileInfo(element.data());
         if (info->isFile()) {
             v.append(createIndex(element.data(), AttributeSize));
         }
         break;
     }
     case OLEStream: {
         v.append(createIndex(element.data(), AttributeName));
         const OleStreamElementNode& e = (const OleStreamElementNode&)d->getElementNode(element.data());
         if (!e.isdir) {
             v.append(createIndex(element.data(), AttributeSize));
         }
         break;
     }
     case XmlElement: {
         QDomElement e = d->xmlelements[getIndex(element.data())].element;
         QDomNamedNodeMap attributes = e.attributes();
         for (uint i=0; i<attributes.length(); ++i) {
              v.append(createIndex(element.data(), i+1));
         }
     }
     }
     return v;
 }
 
 QXmlNodeModelIndex
 DeepFileTree::nextFromSimpleAxis(SimpleAxis axis, const QXmlNodeModelIndex& origin) const {
     const QFileInfo* info = d->getFileInfo(origin.data());
     ElementNode& node = d->getElementNode(origin.data());
 
     int data = -1;
     switch (axis) {
         case Parent:
             data = node.parentId; break;
 
         case FirstChild:
             if (node.firstSiblingId == -2) {
                 if (info && info->isDir()) {
                     d->loadFileSiblings(info->filePath(), origin.data(), node);
                 } else if (info && info->isFile()) {
                     d->loadStreamSiblings(info->filePath(), origin.data(), node);
                 } else if (getType(origin.data()) == OLEStream) {
                     d->loadStreamAsXmlElements(origin.data(), node);
                 }
                 if (node.firstSiblingId == -2) {
                     node.firstSiblingId = -1;
                 }
             }
             data = node.firstSiblingId; break;
  
         case PreviousSibling:
             data = node.previousId; break;
 
         case NextSibling:
             data = node.nextId; break;
     };
     return (data == -1) ?QXmlNodeModelIndex() :createIndex(data, 0);
 }
 
 QUrl
 DeepFileTree::baseUri(const QXmlNodeModelIndex& n) const {
     return documentUri(n);
 }
 QXmlNodeModelIndex::DocumentOrder
 DeepFileTree::compareOrder(const QXmlNodeModelIndex& ni1, const QXmlNodeModelIndex& ni2) const {
     if (ni1.data() < ni2.data()) return QXmlNodeModelIndex::Precedes;
     return (ni1.data() == ni2.data()) ?QXmlNodeModelIndex::Is :QXmlNodeModelIndex::Follows;
 }
 QUrl
 DeepFileTree::documentUri(const QXmlNodeModelIndex& n) const {
     // TODO: find root and get uri from that
     const QFileInfo& fileinfo = d->fileinfos[n.data()];
     return QUrl::fromLocalFile(fileinfo.filePath());
 }
 QXmlNodeModelIndex
 DeepFileTree::elementById(const QXmlName& id) const {
     return QXmlNodeModelIndex();
 }
 QXmlNodeModelIndex::NodeKind
 DeepFileTree::kind(const QXmlNodeModelIndex& ni) const {
     return ni.additionalData() == Element ? QXmlNodeModelIndex::Element : QXmlNodeModelIndex::Attribute;
 }
 QXmlName
 DeepFileTree::name(const QXmlNodeModelIndex& ni) const {
     QVector<QXmlNodeModelIndex> v;
     Type type = getType(ni.data());
     switch (type) {
         case File:
             switch ((Kind)ni.additionalData()) {
                 case Element: return d->getFileInfo(ni.data())->isFile() ?d->file :d->directory;
                 case AttributeName: return d->name;
                 case AttributeSize: return d->size;
             }
         case OLEStream:
             switch ((Kind)ni.additionalData()) {
                 case Element: {
                     const OleStreamElementNode& e
                          = (const OleStreamElementNode&)d->getElementNode(ni.data());
                     return (e.isdir) ?d->olestreamdir :d->olestream;
                 }
                 case AttributeName: return d->name;
                 case AttributeSize: return d->size;
             }
         case XmlElement:
         default: {
             QDomElement e = d->xmlelements[getIndex(ni.data())].element;
             if (ni.additionalData() == 0) {
                 return QXmlName(d->namepool, e.nodeName());
             } else {
                 return QXmlName(d->namepool, e.attributes().item(ni.additionalData()-1).nodeName());
             }
         }
     }
 }
 QVector<QXmlName>
 DeepFileTree::namespaceBindings(const QXmlNodeModelIndex& n) const {
     return QVector<QXmlName>();
 }
 QVector<QXmlNodeModelIndex>
 DeepFileTree::nodesByIdref(const QXmlName& idref) const {
     return QVector<QXmlNodeModelIndex>();
 }
 QXmlNodeModelIndex
 DeepFileTree::root(const QXmlNodeModelIndex& n) const {
     int index = n.data();
     ElementNode& e = d->getElementNode(n.data());
     while (e.parentId != -1) {
          index = e.parentId;
          e = d->getElementNode(index);
     }
     return createIndex(index, 0);
 }
 QString
 DeepFileTree::stringValue(const QXmlNodeModelIndex& n) const {
     return typedValue(n).toString();
 }
 QVariant
 DeepFileTree::typedValue(const QXmlNodeModelIndex& n) const {
     Type type = getType(n.data());
     switch (type) {
         case File: {
             const QFileInfo* info = d->getFileInfo(n.data());
             switch ((Kind)n.additionalData()) {
                 case AttributeName: return info->fileName();
                 case AttributeSize: return info->size();
                 default:;
             }
         }
         case OLEStream: {
             const OleStreamElementNode& e
                 = (const OleStreamElementNode&)d->getElementNode(n.data());
             switch ((Kind)n.additionalData()) {
                 case AttributeName: return e.streamname.c_str();
                 case AttributeSize: return e.size;
                 default:;
             }
         }
         case XmlElement: {
             if (n.additionalData() > 0) {
                 QDomElement e = d->xmlelements[getIndex(n.data())].element;
                 return e.attributes().item(n.additionalData()-1).nodeValue();
             }
         }
     }
     return QVariant();
 }