Fix plucky

.gitea/workflows/tag.yaml

@@ -0,0 +1,44 @@
+name: Build and Deploy on Tag
+on:
+  push:
+    tags:
+      - 'v*'
+
+env:
+  GITEA_AUTH: ${{ secrets.MY_GITEA_AUTH }}
+
+jobs:
+  build-arch:
+    runs-on: arch-builder
+    steps:
+      - run: pacman --noconfirm -Sy nodejs npm
+      - uses: actions/checkout@v4
+      - run: pacman --noconfirm -Sy mbedtls curl
+      - run: pacman --config /opt/cross/ppc/pacman.conf --noconfirm -Sy mbedtls
+      - run: cp Packaging/Linux/PKGBUILD /home/build/PKGBUILD
+      - run: cp Packaging/Linux/build-arch.sh /home/build/build-arch.sh
+      - run: chmod 755 /home/build/build-arch.sh
+      - run: chown build:build /home/build/PKGBUILD
+      - run: chown build:build /home/build/build-arch.sh
+      - run: su build -c /home/build/build-arch.sh
+  build-jammy:
+    runs-on: deb-builder-jammy
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build for jammy, noble
+        run: |
+          bash build-ubuntu-jammy.sh
+          bash push-ubuntu-jammy.sh
+        working-directory: ./Packaging/Linux
+  build-plucky:
+    runs-on: deb-builder-plucky
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build for plucky, resolute
+        run: |
+          bash build-ubuntu-plucky.sh
+          bash push-ubuntu-plucky.sh
+        working-directory: ./Packaging/Linux
+      - uses: akkuman/gitea-release-action@v1
+        env:
+          NODE_OPTIONS: '--experimental-fetch' # if nodejs < 18

.onedev-buildspec.yml

@@ -1,18 +1,21 @@
-version: 39
+version: 43
 jobs:
 - name: Build for x86_64
   steps:
-  - !CheckoutStep
+  - type: CheckoutStep
     name: Checkout
-    cloneCredential: !DefaultCredential {}
+    cloneCredential:
+      type: DefaultCredential
     withLfs: true
     withSubmodules: false
-    condition: ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL
-  - !CommandStep
+    condition: SUCCESSFUL
+    optional: false
+  - type: CommandStep
     name: Execute build
     runInContainer: true
     image: onedev.site.tesses.net/dependencies/dependencies:latest
-    interpreter: !DefaultInterpreter
+    interpreter:
+      type: DefaultInterpreter
       commands: |
         mkdir build
         cd build
@@ -20,72 +23,28 @@ jobs:
         make -j12
         make install DESTDIR=out
     useTTY: true
-    condition: ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL
-  - !BuildImageStep
+    condition: SUCCESSFUL
+    optional: false
+  - type: BuildImageStep
     name: Build Docker Image
     dockerfile: Dockerfile.run
-    output: !RegistryOutput
-      tags: onedev.site.tesses.net/tesses-framework/tesses-framework:latest onedev.site.tesses.net/tesses-framework/tesses-framework:@commit_hash@
+    output:
+      type: RegistryOutput
+      tags: onedev.site.tesses.net/tesses-framework/tesses-framework:latest onedev.site.tesses.net/tesses-framework/tesses-framework:@commit_hash@ git.tesseslanguage.com/tesses50/tesses-framework:latest git.tesseslanguage.com/tesses50/tesses-framework:@commit_hash@
     registryLogins:
     - registryUrl: '@server_url@'
       userName: '@job_token@'
       passwordSecret: dockersecret
+    - registryUrl: git.tesseslanguage.com
+      userName: tesses50
+      passwordSecret: GITEA_AUTH
     platforms: linux/amd64
-    condition: ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL
-  - !CommandStep
-    name: Build archlinux
-    runInContainer: true
-    image: git.tesseslanguage.com/tesses50/arch-builds:2025-11-11
-    interpreter: !DefaultInterpreter
-      commands: |
-        pacman --noconfirm -Sy mbedtls curl
-        pacman --config /opt/cross/ppc/pacman.conf --noconfirm -Sy mbedtls
-        cp Packaging/Linux/PKGBUILD /home/build/PKGBUILD
-        cp Packaging/Linux/build-arch.sh /home/build/build-arch.sh
-        chmod 755 /home/build/build-arch.sh
-        chown build:build /home/build/PKGBUILD
-        chown build:build /home/build/build-arch.sh
-        su build -c /home/build/build-arch.sh
-    envVars:
-    - name: GITEA_AUTH
-      value: '@secret:GITEA_AUTH@'
-    useTTY: true
-    condition: ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL
-  - !CommandStep
-    name: Build and Publish Deb Package
-    runInContainer: true
-    image: onedev.site.tesses.net/dependencies/debbuilder/jammy:latest
-    interpreter: !DefaultInterpreter
-      commands: |
-        cd Packaging/Linux
-        bash build-ubuntu-jammy.sh
-        bash push-ubuntu-jammy.sh
-    envVars:
-    - name: GITEA_AUTH
-      value: '@secret:GITEA_AUTH@'
-    - name: BUILD_NO
-      value: '@build_number@'
-    useTTY: true
-    condition: ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL
-  - !CommandStep
-    name: Build and Publish Deb Package (Plucky)
-    runInContainer: true
-    image: onedev.site.tesses.net/dependencies/debbuilder/plucky:latest
-    interpreter: !DefaultInterpreter
-      commands: |
-        cd Packaging/Linux
-        bash build-ubuntu-plucky.sh
-        bash push-ubuntu-plucky.sh
-    envVars:
-    - name: GITEA_AUTH
-      value: '@secret:GITEA_AUTH@'
-    - name: BUILD_NO
-      value: '@build_number@'
-    useTTY: true
-    condition: ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL
+    condition: SUCCESSFUL
+    optional: false
   triggers:
-  - !BranchUpdateTrigger
+  - type: BranchUpdateTrigger
     branches: master
+    userMatch: anyone
     projects: tesses-framework
   retryCondition: never
   maxRetries: 3

CMakeLists.txt

@@ -1,6 +1,10 @@
 cmake_minimum_required(VERSION 3.16)
 
-project(TessesFramework VERSION 1.0.0)
+set(TESSESFRAMEWORK_MAJOR_VERSION 0)
+set(TESSESFRAMEWORK_MINOR_VERSION 0)
+set(TESSESFRAMEWORK_PATCH_VERSION 1)
+
+project(TessesFramework VERSION ${TESSESFRAMEWORK_MAJOR_VERSION}.${TESSESFRAMEWORK_MINOR_VERSION}.${TESSESFRAMEWORK_PATCH_VERSION})
 
 set(CMAKE_CXX_STANDARD 17)
 
@@ -409,6 +413,11 @@ add_executable(trng apps/trng.cpp)
 
 target_link_libraries(trng PUBLIC tessesframework)
 install(TARGETS trng DESTINATION "${CMAKE_INSTALL_BINDIR}")
+
+add_executable(twatch apps/twatch.cpp)
+
+target_link_libraries(twatch PUBLIC tessesframework)
+install(TARGETS twatch DESTINATION "${CMAKE_INSTALL_BINDIR}")
 endif()
 
 include(InstallRequiredSystemLibraries)

Packaging/Linux/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: Mike Nolan <tesses@tesses.net>
 pkgname=tesses-framework # '-bzr', '-git', '-hg' or '-svn'
-pkgver=1.0.0
+pkgver=0.0.1
 pkgrel=1
 pkgdesc=""
 arch=('x86_64' 'powerpc')
@@ -18,21 +18,7 @@ options=(!strip)
 else
 options=(!buildflags !strip)
 fi
-# Please refer to the 'USING VCS SOURCES' section of the PKGBUILD man page for
-# a description of each element in the source array.
 
-pkgver() {
-	cd "$srcdir/${pkgname}"
-
-# The examples below are not absolute and need to be adapted to each repo. The
-# primary goal is to generate version numbers that will increase according to
-# pacman's version comparisons with later commits to the repo. The format
-# VERSION='VER_NUM.rREV_NUM.HASH', or a relevant subset in case VER_NUM or HASH
-# are not available, is recommended.
-
-# Git, no tags available
-	printf "r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
-}
 
 prepare() {
 	cd "$srcdir/${pkgname}"

Packaging/Linux/version.sh

@@ -1,2 +1 @@
-export BUILD=$(($BUILD_NO-163))
-export DEB_VERSION=1.0.0-$BUILD
+export DEB_VERSION=0.0.1

TessesFrameworkFeatures.h.in

@@ -1,6 +1,11 @@
 #pragma once
 #define TESSES_FRAMEWORK_FLAG_OFF 0
 #define TESSES_FRAMEWORK_FLAG_ON 1
+
+#define TESSES_FRAMEWORK_MAJOR @TESSESFRAMEWORK_MAJOR_VERSION@
+#define TESSES_FRAMEWORK_MINOR @TESSESFRAMEWORK_MINOR_VERSION@
+#define TESSES_FRAMEWORK_PATCH @TESSESFRAMEWORK_PATCH_VERSION@
+
 #if defined(TESSES_FRAMEWORK_FLAG_@TESSESFRAMEWORK_ENABLE_SQLITE@) && !defined(TESSESFRAMEWORK_ENABLE_SQLITE)
 #define TESSESFRAMEWORK_ENABLE_SQLITE
 #endif

apps/twatch.cpp

@@ -0,0 +1,24 @@
+#include <TessesFramework/TessesFramework.hpp>
+
+using namespace Tesses::Framework;
+using namespace Tesses::Framework::Filesystem;
+using namespace Tesses::Framework::Filesystem::Literals;
+
+int main(int argc, char** argv)
+{
+    TF_Init();
+    if(argc<2)
+    {
+        std::cout << "USAGE " << argv[0] << " <file|dir>" << std::endl;
+        return 1;
+    }
+
+    auto watcher=FSWatcher::Create(LocalFS,VFSPath{argv[1]});
+    watcher->events = FSWatcherEventType::All;
+    watcher->event = [](FSWatcherEvent& evt)->void{
+        std::cout << evt.ToString() << std::endl;
+    };
+    watcher->SetEnabled(true);
+    TF_RunEventLoop();
+    return 0;
+}

include/TessesFramework/Common.hpp

@@ -10,6 +10,7 @@
 #include <functional>
 #include "Threading/Mutex.hpp"
 #include <optional>
+#include <atomic>
    
 namespace Tesses::Framework
 {

include/TessesFramework/Filesystem/LocalFS.hpp

@@ -42,6 +42,9 @@ namespace Tesses::Framework::Filesystem
             void Lock(VFSPath path);
             void Unlock(VFSPath path);
 
+            protected:
+            std::shared_ptr<FSWatcher> CreateWatcher(std::shared_ptr<VFS> vfs, VFSPath path);
+
     };  
     extern std::shared_ptr<LocalFilesystem> LocalFS;
 }

include/TessesFramework/Filesystem/VFS.hpp

@@ -8,6 +8,7 @@
             
 namespace Tesses::Framework::Filesystem
 {
+
     class StatVFSData {
         public:
             uint64_t BlockSize;
@@ -29,7 +30,8 @@ namespace Tesses::Framework::Filesystem
             static std::vector<std::string> SplitPath(std::string path);
             std::vector<std::string> path;  
             VFSPath();
-            
+            explicit VFSPath(const char* path) : VFSPath(std::string(path))
+            {}
             VFSPath(std::vector<std::string> path);
             VFSPath(std::string path);
             VFSPath(VFSPath p, std::string subent);
@@ -118,7 +120,74 @@ namespace Tesses::Framework::Filesystem
 
             VFSPathEnumeratorItterator end();
     };
+    enum class FSWatcherEventType {
 
+        None = 0,
+        //IN_ACCESS
+        Accessed=1,
+        //IN_ATTRIB
+        AttributeChanged =2,
+        //IN_CLOSE_WRITE
+        Writen = 4,
+        //IN_CLOSE_NOWRITE
+        Read = 8,
+        //IN_CREATE
+        Created = 16,
+        //IN_DELETE
+        Deleted = 32,
+        //IN_DELETE_SELF
+        WatchEntryDeleted = 64,
+        //IN_MODIFY
+        Modified = 128,
+        //IN_MOVE_SELF
+        WatchEntryMoved = 256,
+        //IN_MOVED_FROM
+        MoveOld = 512,
+        //IN_MOVED_TO
+        MoveNew = 1024,
+        //IN_OPEN
+        Opened = 2048,
+        //IN_CLOSE
+        Closed = Writen | Read,
+        //IN_MOVE
+        Moved = MoveOld | MoveNew,
+        //IN_ALL_EVENTS
+        All = Accessed | AttributeChanged | Created | Deleted | WatchEntryDeleted | Modified | WatchEntryMoved | Opened | Closed | Moved
+    };
+    struct FSWatcherEvent {
+        //the file or source on move
+        VFSPath src;
+        //the dest when moving
+        VFSPath dest;
+        FSWatcherEventType type;
+        bool isDir;
+
+        bool IsEvent(FSWatcherEventType e);
+
+        std::string ToString();
+    };
+    class VFS;
+
+    class FSWatcher {
+        private:
+            std::shared_ptr<VFS> vfs;
+            VFSPath path;
+        protected:
+
+            std::atomic<bool> enabled=false;
+            virtual void SetEnabledImpl(bool enabled);
+        public:
+            FSWatcher(std::shared_ptr<VFS> vfs, VFSPath path);
+            std::function<void(FSWatcherEvent&)> event;
+            FSWatcherEventType events = FSWatcherEventType::All;
+            bool GetEnabled();
+            void SetEnabled(bool val);
+            std::shared_ptr<VFS> GetFilesystem();
+            const VFSPath& GetPath();
+            virtual ~FSWatcher() = default;
+            
+            static std::shared_ptr<FSWatcher> Create(std::shared_ptr<VFS> vfs, VFSPath path); 
+    };
 
     class VFS {
         public:
@@ -156,9 +225,25 @@ namespace Tesses::Framework::Filesystem
 
             virtual void Lock(VFSPath path);
             virtual void Unlock(VFSPath path);
-
+        
+          
             virtual ~VFS();
 
             virtual void Close();
+
+        protected:
+              virtual std::shared_ptr<FSWatcher> CreateWatcher(std::shared_ptr<VFS> vfs, VFSPath path);
+        friend class FSWatcher;
     };
-}
+
+    
+
+    namespace Literals
+    {
+        inline VFSPath operator""_tpath(const char* path)
+        {
+            return VFSPath(path);
+        }
+    }
+}
+

src/Filesystem/LocalFS.cpp

@@ -10,6 +10,13 @@
 #include <utime.h>
 #include <sys/statvfs.h>
 #endif
+
+#include "TessesFramework/Threading/Thread.hpp"
+#if defined(__linux__)
+#include <poll.h>
+#include <sys/inotify.h>
+#include <unistd.h>
+#endif
 namespace Tesses::Framework::Filesystem
 {
     #if defined(_WIN32)
@@ -249,8 +256,184 @@ namespace Tesses::Framework::Filesystem
         std::error_code error;
         std::filesystem::remove(VFSPathToSystem(path),error);
     }
+    #if defined(__linux__)
+
+    class INotifyWatcher : public FSWatcher {
+        std::shared_ptr<Threading::Thread> thrd;
+        static uint32_t to_linux_mask(FSWatcherEventType flags)
+        {
+            uint32_t lflags = 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::Accessed) != 0) ? IN_ACCESS : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::AttributeChanged) != 0) ? IN_ATTRIB : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::Writen) != 0) ? IN_CLOSE_WRITE : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::Read) != 0) ? IN_CLOSE_NOWRITE : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::Created) != 0) ? IN_CREATE : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::Deleted) != 0) ? IN_DELETE : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::WatchEntryDeleted) != 0) ? IN_DELETE_SELF : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::Modified) != 0) ? IN_MODIFY : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::WatchEntryMoved) != 0) ? IN_MOVE_SELF : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::MoveOld) != 0) ? IN_MOVED_FROM : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::MoveNew) != 0) ? IN_MOVED_TO : 0;
+            lflags |= (((uint32_t)flags & (uint32_t)FSWatcherEventType::Opened) != 0) ? IN_OPEN : 0;
+            
+            return lflags;
+        }
+        static FSWatcherEventType from_linux_mask(uint32_t lflags)
+        {
+            uint32_t flags = 0;
+            flags |= ((lflags & IN_ACCESS) != 0) ? (uint32_t)FSWatcherEventType::Accessed : 0;
+            flags |= ((lflags & IN_ATTRIB) != 0) ? (uint32_t)FSWatcherEventType::AttributeChanged : 0;
+            flags |= ((lflags & IN_CLOSE_WRITE) != 0) ? (uint32_t)FSWatcherEventType::Writen : 0;
+            flags |= ((lflags & IN_CLOSE_NOWRITE) != 0) ? (uint32_t)FSWatcherEventType::Read : 0;
+            flags |= ((lflags & IN_CREATE) != 0) ? (uint32_t)FSWatcherEventType::Created : 0;
+            flags |= ((lflags & IN_DELETE) != 0) ? (uint32_t)FSWatcherEventType::Deleted : 0;
+            flags |= ((lflags & IN_DELETE_SELF) != 0) ? (uint32_t)FSWatcherEventType::WatchEntryDeleted : 0;
+            flags |= ((lflags & IN_MODIFY) != 0) ? (uint32_t)FSWatcherEventType::Modified : 0;
+            flags |= ((lflags & IN_MOVE_SELF) != 0) ? (uint32_t)FSWatcherEventType::WatchEntryMoved : 0;
+            flags |= ((lflags & IN_MOVED_FROM) != 0) ? (uint32_t)FSWatcherEventType::MoveOld : 0;
+            flags |= ((lflags & IN_MOVED_TO) != 0) ? (uint32_t)FSWatcherEventType::MoveNew : 0;
+            flags |= ((lflags & IN_OPEN) != 0) ? (uint32_t)FSWatcherEventType::Opened : 0;
+            
+            return (FSWatcherEventType)flags;
+        }
+        public:
+            INotifyWatcher(std::shared_ptr<VFS> vfs, VFSPath path) : FSWatcher(vfs,path)
+            {
+
+            }
+
+        protected:
+            
+            void SetEnabledImpl(bool enabled)
+            {
+                if(enabled)
+                {
+                    int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+                    if (fd == -1)
+                    {
+                        throw std::runtime_error("Cannot init inotify");
+                    }
+                    auto str =  this->GetFilesystem()->VFSPathToSystem(this->GetPath());
+
+                    int watch = inotify_add_watch(fd, str.c_str(),to_linux_mask(this->events));
+
+                    thrd = std::make_shared<Threading::Thread>([this,watch,fd]()-> void {
+                        int cnt = 0;
+                        struct pollfd pfd = {.fd = fd, .events = POLLIN};
+                        std::vector<std::pair<VFSPath,uint32_t>> mvFroms;
+                        char buf[4096]
+                            __attribute__ ((aligned(__alignof__(struct inotify_event))));
+                        const struct inotify_event *event;
+                        ssize_t size;
+                        
+                        bool fail=false;
+
+                        FSWatcherEvent evt;
+                        evt.dest = this->GetPath();
+                        while(!fail && this->enabled)
+                        {
+                            cnt = poll(&pfd,1,-1);
+                            if(cnt == -1) break;
+
+                            if(cnt > 0)
+                            {
+                                if(pfd.revents & POLLIN)
+                                {
+                                    for (;;) {
+                                        size = read(fd, buf, sizeof(buf));
+                                        if (size == -1 && errno != EAGAIN) {
+                                            fail=true;
+                                            break;
+                                        }
+
+                                        if (size <= 0)
+                                            break;
+
+                                        for (char *ptr = buf; ptr < buf + size;
+                                                                ptr += sizeof(struct inotify_event) + event->len) {
+
+                                            event = (const struct inotify_event *) ptr;
+                                            VFSPath path = this->GetPath();
+
+                                            if(event->len)
+                                                path = path / std::string(event->name, (size_t)event->len);
+
+                                            if(((uint32_t)this->events & (uint32_t)FSWatcherEventType::Moved) == (uint32_t)FSWatcherEventType::Moved && event->mask & IN_MOVED_FROM)
+                                            {
+                                                mvFroms.emplace_back(path,event->cookie);
+                                            }
+                                            else if(((uint32_t)this->events & (uint32_t)FSWatcherEventType::Moved) == (uint32_t)FSWatcherEventType::Moved && event->mask & IN_MOVED_TO)
+                                            {
+                                                for(auto ittr = mvFroms.begin(); ittr != mvFroms.end(); ittr++)
+                                                {
+                                                    if(ittr->second == event->cookie)
+                                                    {
+                                                        evt.src = ittr->first;
+                                                        mvFroms.erase(ittr);
+                                                        break;
+                                                    }
+                                                }
+                                                evt.isDir = (event->mask & IN_ISDIR);
+                                                evt.dest = path;
+                                                evt.type = FSWatcherEventType::Moved;
+                                                if(this->event)
+                                                    this->event(evt);
+                                            }
+                                            else {
+
+                                                evt.isDir = (event->mask & IN_ISDIR);
+                                                evt.src = path;
+                                                evt.type = from_linux_mask(event->mask);;
+                                                if(this->event)
+                                                    this->event(evt);
+                                            }
+                                            if(event->mask & IN_MOVE_SELF)
+                                            {
+                                                close(fd);
+                                                return;
+                                            }
+                                            if(event->mask & IN_DELETE_SELF)
+                                            {
+                                                close(fd);
+                                                return;
+                                            }
+                                        }    
+                                    }
+                                }
+                            }
+                        }
+                        
+                        close(fd);
+                    });
+
+
+                }
+                else
+                {
+                    thrd = nullptr;
+                }
+            }
+            public:
+            ~INotifyWatcher()
+            {
+                this->enabled = false;
+            }
+    };
+    #endif
+    
+    
+
+    std::shared_ptr<FSWatcher> LocalFilesystem::CreateWatcher(std::shared_ptr<VFS> vfs, VFSPath path)
+    {
+        #if defined(__linux__)
+            return std::make_shared<INotifyWatcher>(vfs, path);
+        #endif
+        return VFS::CreateWatcher(vfs,path);
+    }
 
     std::shared_ptr<LocalFilesystem> LocalFS = std::make_shared<LocalFilesystem>();
+
+
 }
 
 // C:/Users/Jim/Joel

src/Filesystem/VFS.cpp

@@ -232,7 +232,8 @@ namespace Tesses::Framework::Filesystem
 
         if(i == this->path.size()-1 && i == toMakeRelativeTo.path.size()-1)
         {
-            VFSPath path({this->path[this->path.size()-1]});
+            std::vector<std::string> paths{this->path[this->path.size()-1]};
+            VFSPath path(paths);
             path.relative = true;
             return path;
         }
@@ -387,7 +388,8 @@ namespace Tesses::Framework::Filesystem
         if(ext.empty()) return;
         if(ext[0] != '.') 
         {
-            str += '.' + ext;
+            str += '.';
+            str += ext;
         }
         else
         {
@@ -560,4 +562,113 @@ namespace Tesses::Framework::Filesystem
     {
         
     }
-}
+
+
+
+    std::shared_ptr<FSWatcher> VFS::CreateWatcher(std::shared_ptr<VFS> vfs,VFSPath path)
+    {
+        return std::make_shared<FSWatcher>(vfs,path);
+    }
+    void FSWatcher::SetEnabled(bool enabled)
+    {
+        if(this->enabled == enabled) return;
+        this->enabled = enabled;
+        this->SetEnabledImpl(enabled);
+    }
+
+    bool FSWatcher::GetEnabled()
+    {
+        return this->enabled;
+    }
+
+    void FSWatcher::SetEnabledImpl(bool enabled)
+    {
+
+    }
+
+    std::shared_ptr<VFS> FSWatcher::GetFilesystem()
+    {
+        return this->vfs;
+    }
+    const VFSPath& FSWatcher::GetPath()
+    {
+        return this->path;
+    }
+
+    FSWatcher::FSWatcher(std::shared_ptr<VFS> vfs, VFSPath path): vfs(vfs), path(path)
+    {
+
+    }
+            
+    std::shared_ptr<FSWatcher> FSWatcher::Create(std::shared_ptr<VFS> vfs, VFSPath path)
+    {
+        return vfs->CreateWatcher(vfs,path);
+    }
+
+    bool FSWatcherEvent::IsEvent(FSWatcherEventType e)
+    {
+        if(e == FSWatcherEventType::All) return this->type != FSWatcherEventType::None;
+        if(e == FSWatcherEventType::Moved) return ((uint32_t)this->type & (uint32_t)FSWatcherEventType::Moved) == (uint32_t)FSWatcherEventType::Moved;
+        if(e == FSWatcherEventType::Closed) return ((uint32_t)this->type & (uint32_t)FSWatcherEventType::Closed) != 0;
+        return (uint32_t)this->type & (uint32_t)e;
+    }
+
+    std::string FSWatcherEvent::ToString()
+    {
+        if(IsEvent(FSWatcherEventType::Moved))
+        {
+            return (this->isDir ? "Moved directory " : "Moved file ") + this->src.ToString() + " -> " + this->dest.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::MoveOld))
+        {
+            return (this->isDir ? "Move source directory " : "Move source file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::MoveNew))
+        {
+            return (this->isDir ? "Move destination directory " : "Move destination file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::Accessed))
+        {
+            return (this->isDir ? "Accessed directory " : "Accessed file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::AttributeChanged))
+        {
+            return (this->isDir ? "Changed attr on directory " : "Changed attr on file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::Writen))
+        {
+            return (this->isDir ? "Finished changing directory " : "Finished writing to file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::Read))
+        {
+            return (this->isDir ? "Finished reading directory " : "Finished reading from file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::Created))
+        {
+            return (this->isDir ? "Created directory " : "Created file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::Deleted))
+        {
+            return (this->isDir ? "Deleted directory " : "Deleted file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::WatchEntryDeleted))
+        {
+
+            return (this->isDir ? "Deleted watched directory " : "Deleted watched file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::Modified))
+        {
+            return (this->isDir ? "Modified directory " : "Modified file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::WatchEntryMoved))
+        {
+            return (this->isDir ? "Moved watched directory " : "Moved watched file ") + this->src.ToString();
+        }
+        else if(IsEvent(FSWatcherEventType::Opened))
+        {
+            return (this->isDir ? "Opened directory " : "Opened file ") + this->src.ToString();
+        }
+
+        return "";
+    }
+}   

src/Http/HttpServer.cpp

@@ -389,11 +389,8 @@ namespace Tesses::Framework::Http
     static bool parseUntillBoundaryEnd(std::shared_ptr<Tesses::Framework::Streams::Stream> src, std::shared_ptr<Tesses::Framework::Streams::Stream> dest, std::string boundary)
     {
         bool hasMore=true;
-        #if defined(_WIN32)
         uint8_t* checkBuffer = new uint8_t[boundary.size()];
-        #else
-        uint8_t checkBuffer[boundary.size()];
-        #endif
+        
         int b;
         size_t i = 0;
         size_t i2 = 0;
@@ -457,9 +454,8 @@ namespace Tesses::Framework::Http
         {
             dest->Write(buffer,offsetInMem);
         }
-        #if defined(_WIN32)
-        delete checkBuffer;
-        #endif
+        delete[] checkBuffer;
+        
         return hasMore;
     }
 

src/TF_Init.cpp

@@ -712,6 +712,244 @@ if (iResult != 0) {
                     
                     
                     
+                    }
+                    else if(portable_str == "absolute")
+                    {
+                        if(dict2.TryGetValueAsType("user",portable_str))
+                        {
+                            if(portable_str != "system")   
+                            {
+                                VFSPath userDir = portable_str;
+                                portable_config.user = userDir.CollapseRelativeParents();
+
+                                
+                            }
+
+
+
+                        }
+                        
+                        if(dict2.TryGetValueAsType("documents", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.documents = *(portable_config.user) / "Documents";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.documents = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("downloads", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.downloads = *(portable_config.user) / "Downloads";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.downloads = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("desktop", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.desktop = *(portable_config.user) / "Desktop";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.desktop = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("pictures", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.pictures = *(portable_config.user) / "Pictures";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.pictures = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("videos", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.videos = *(portable_config.user) / "Videos";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.videos = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("music", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.music = *(portable_config.user) / "Music";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.music = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("config", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.config = *(portable_config.user) / "Config";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.config = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("cache", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.cache = *(portable_config.user) / "Cache";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.cache = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("data", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.data = *(portable_config.user) / "Data";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.data = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("state", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.state = *(portable_config.user) / "State";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.state = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                        if(dict2.TryGetValueAsType("temp", portable_str))
+                        {
+                            
+                            if(portable_str != "system")
+                            {
+                                if(portable_str == "default")
+                                {
+                                    if(portable_config.user)
+                                    {
+                                        portable_config.temp = *(portable_config.user) / "Temp";
+                                    }
+                                }
+                                else 
+                                {
+                                    VFSPath userDir = portable_str;
+                                    portable_config.temp = userDir.CollapseRelativeParents();
+
+                                }
+                            }
+                        }
+                    
                     }
                 }
             }