some NuFX code not yet checked in

git-svn-id: https://profuse.googlecode.com/svn/branches/v2@404 aa027e90-d47c-11dd-86d7-074df07e0730

NuFX/DirectoryEntry.cpp

@@ -0,0 +1,63 @@
+#include "DirectoryEntry.h"
+
+#include <cstring>
+
+using namespace NuFX;
+
+EntryPointer DirectoryEntry::lookup(const std::string& name) const
+{
+    EntryIterator iter;
+    
+    for (iter = _children.begin(); iter != _children.end(); ++iter)
+    {
+    
+        EntryPointer e = *iter;
+        
+        if (e->name() == name) return e;
+    }
+
+    return EntryPointer(); // empty.
+}
+
+DirectoryEntryPointer DirectoryEntry::dir_lookup(const std::string &name)
+{
+    EntryIterator iter;
+
+    for (iter = _children.begin(); iter != _children.end(); ++iter)
+    {
+    
+        EntryPointer e = *iter;
+        
+        if (e->name() == name)
+        {
+            // dynamic cast, will return as empty pointer if
+            // not a directory.
+            
+            return DYNAMIC_POINTER_CAST(DirectoryEntryPointer, e);
+        }    
+    }
+    
+    // not found, insert it.. 
+
+    DirectoryEntryPointer e(new DirectoryEntryPointer(name));
+    VolumeEntryPointer v = volume().lock();
+    
+    _children.add(e);
+    
+    if (v)
+    {
+        v->addEntry(e);
+    }
+    
+    return e;
+}
+
+#pragma mark -
+#pragma mark fuse-support
+
+EntryPointer DirectoryEntry::childAtIndex(unsigned index) const
+{
+    if (index >= _children.size()) return EntryPointer();
+    
+    return _children[index];
+}

NuFX/DirectoryEntry.h

@@ -0,0 +1,38 @@
+#ifndef __NUFX_DIRECTORYENTRY_H__
+#define __NUFX_DIRECTORYENTRY_H__
+
+#include "Entry.h"
+
+#include <vector>
+#include <dirent.t>
+
+namespace NuFX {
+
+
+    class DirectoryEntry : public Entry
+    {
+    public:
+    
+    
+        EntryPointer lookup(const std::string & name) const;
+
+        EntryPointer childAtIndex(unsigned index) const;
+
+
+    protected:
+        
+        // creates directory if it does not exist.
+        DirectoryEntryPointer dir_lookup(const std::string &name);
+                
+    private:
+        
+        
+        std::vector<EntryPointer> _children;
+        
+        typedef std::vector<EntryPointer>::iterator EntryIterator;
+        
+    };
+}
+
+
+#endif

NuFX/Entry.cpp

@@ -0,0 +1,66 @@
+#include "Entry.h"
+#include "Exception.h"
+
+using namespace NuFX;
+
+
+Entry::Entry() :
+    _inode(0)
+{
+}
+
+Entry::Entry(const std::string& name) :
+    _name(name), _inode(0)
+{
+}
+
+
+Entry::~Entry()
+{
+}
+
+
+unsigned Entry::inode() const
+{
+    return _inode;
+}
+
+const std::string& Entry::name() const
+{
+    return _name;
+}
+
+void Entry::setName(const std::string& name)
+{
+    _name = name;
+}
+
+VolumeEntryWeakPointer Entry::volume() const
+{
+    return _volume;
+}
+
+void Entry::setVolume(VolumeEntryWeakPointer volume)
+{
+    _volume = volume;
+}
+
+int Entry::stat(struct stat *st) const
+{
+    return -1;
+}
+
+ssize_t Entry::read(size_t size, off_t offset) const
+{
+    return -1;
+}
+
+ssize_t Entry::listxattr(char *namebuf, size_t size, int options) const
+{
+    return -1;
+}
+
+ssize_t Entry::getxattr(const std::string &name, void *value, size_t size, u_int32_t position, int options) const
+{
+    return -1;
+}

NuFX/Entry.h

@@ -0,0 +1,69 @@
+#ifndef __NUFX_ENTRY_H__
+#define __NUFX_ENTRY_H__
+
+
+#include <Common/smart_pointers.h>
+
+#include <string>
+#include <stdint.h>
+
+
+#include <NufxLib.h>
+#include <sys/stat.h>
+#include <sys/xattr.h>
+#include <dirent.h>
+
+namespace NuFX {
+
+  class DirectoryEntry;
+  class Entry;
+  class FileEntry;
+  class VolumeEntry;
+
+    typedef SHARED_PTR(DirectoryEntry) DirectoryEntryPointer;
+    typedef SHARED_PTR(Entry) EntryPointer;
+    typedef SHARED_PTR(FileEntry) FileEntryPointer;
+    typedef SHARED_PTR(VolumeEntry) VolumeEntryPointer;
+
+    typedef WEAK_PTR(Entry) EntryWeakPointer;
+    typedef WEAK_PTR(VolumeEntry) VolumeEntryWeakPointer;
+
+    class Entry : public ENABLE_SHARED_FROM_THIS(Entry) {
+
+    public:
+
+        virtual ~Entry();
+
+        virtual unsigned inode() const;
+        virtual const std::string& name() const;
+        
+        
+        // operations...
+        virtual int stat(VolumeEntryPointer, struct stat *) const;
+        virtual ssize_t read(VolumeEntryPointer, size_t size, off_t offset) const;
+        virtual ssize_t listxattr(VolumeEntryPointer, char *namebuf, size_t size, int options) const;
+        virtual ssize_t getxattr(VolumeEntryPointer, const std::string &name, void *value, size_t size, u_int32_t position, int options) const;
+
+        virtual int open(VolumeEntryPointer, int flags);
+        virtual int close(VolumeEntryPointer);
+        
+
+                
+    protected:
+        Entry();
+        Entry(const std::string& name);
+        
+        void setName(const std::string&);
+
+    private:
+        Entry(const Entry&);
+        Entry& operator=(const Entry&);
+
+        friend VolumeEntry;
+
+        std::string _name;
+        unsigned _inode;
+    };
+}
+
+#endif

NuFX/FileEntry.h

@@ -0,0 +1,23 @@
+#ifndef __NUFX_FILEENTRY_H__
+#define __NUFX_FILEENTRY_H__
+
+#include "Entry.h"
+#include <NufxLib.h>
+
+namespace NuFX {
+
+
+    class FileEntry : public Entry
+    {
+    public:
+    
+    private:
+    
+        NuRecordIdx _recordID;
+        unsigned _flags; // threads
+        size_t _size; // data size
+    };
+}
+
+
+#endif

NuFX/VolumeEntry.cpp

@@ -0,0 +1,14 @@
+#include "VolumeEntry.h"
+
+using namespace NuFX;
+
+void VolumeEntry::addEntry(EntryPointer e)
+{
+    if (!e) return;
+    
+    e->setVolume(pointer());
+    
+    _inodeIndex->push_back(e);
+
+    e->_inode = _inodeIndex->length() + 100 - 1;
+}

NuFX/VolumeEntry.h

@@ -0,0 +1,35 @@
+#ifndef __NUFX_VOLUMEENTRY_H__
+#define __NUFX_VOLUMEENTRY_H__
+
+#include "DirectoryEntry.h"
+
+#include <Common/unordered_map.h>
+
+namespace NuFX {
+
+
+    class VolumeEntry : public DirectoryEntry
+    {
+    public:
+    
+        void addEntry(EntryPointer);
+        
+    private:
+    
+        VolumeEntryPointer pointer() const
+        {
+            return STATIC_POINTER_CAST(VolumeEntryPointer, shared_from_this());
+        }
+    
+        void parse();
+    
+        NuArchive *_archive;
+        
+        //unsigned _inodeGenerator;
+        
+        std::vector<WeakPointer> _inodeIndex;
+    };
+}
+
+
+#endif