http://www.erdem.tk/wiki/_media/resim/soru2.png

Özellikleri bu şekilde olabilir. ;-)

Ben şimdilik şu kütüphaneye de bakıyorum:

http://code.dlang.org/packages/libasync

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ali hocam hatırlarsanız daha önce bu programın benzerini kütüğün değişme zamanını kaydederek yapmıştık.

İşletim sisteminden yardım alan sürümüne henüz bakamadım. Ama benim merak ettiğim acaba böyle bir uygulamada hash tablolarından faydalanılabilir mi.

Dikkat ederseniz git programı da benzer şekilde çalışıyor. Örneğin bir dosyada değişiklik yaptığınızda kırmızı ile gösteriyor eklediğinizde yeşil ile gösteriyor vs. Acaba o programı kodlarken nasıl yapmış olabilirler.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

import std.stdio: writeln;

import libasync;
import libasync.watcher;
import libasync.threads;

shared static ~this() { destroyAsyncThreads(); }

void dizindeDeğişiklikOldu(DWChangeInfo değişiklik)
{
   writeln ("Dizinde değişiklik oldu : ", değişiklik);
   writeln ("Kutuk : ", değişiklik.path());
   switch (değişiklik.event)
   {
   case DWFileEvent.CREATED:
       writeln ("Kütük oluşturuldu");
       break;
   case DWFileEvent.DELETED:
       writeln ("Kütük silindi");
       break;
   case DWFileEvent.MODIFIED:
       writeln ("Kütük değişti");
       break;
   default:
       break;
   }
}

void main()
{
   auto olayDöngüsü = getThreadEventLoop();

   auto bekçi = new AsyncDirectoryWatcher(olayDöngüsü);

   DWChangeInfo[8] değişiklikBilgisi;

   bekçi.run(
   {
       writeln("Dizin olayı gerçekleşti");
       DWChangeInfo[] değişiklikler = değişiklikBilgisi;

       uint sayaç;

       do
       {
           sayaç = bekçi.readChanges(değişiklikler);

           foreach (i; 0 .. sayaç)
           {
               dizindeDeğişiklikOldu(değişiklikler[i]);
           }
       } while (sayaç > 0);
   });

   bekçi.watchDir("ilk");

   writeln("Olay döngüsü çalışıyor. ilk dizininde bir dosya kaydedin");

   while (olayDöngüsü.loop())
       continue;

   writeln("Olay döngüsünden çıkıldı");
}

libasync ile ufak bir örnek yazdım. Yalnız emacs'ın dosya oluşturma davranışı biraz değişik :-)

Alıntı:

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Kütüphanenin bize verdiğinden çok uygulamayı kurma, yönetme ve döngüye alma tarzı çok hoşuma gitti.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Peki diyelim ki 3 dakika kadar bekledikten sonra kaydetmek istiyoruz.

struct Dosya
{
   string isim;
   string[SysTime] olay;
}

Dosya[] dosyalar;

dosyalar ~= Dosya(değişiklik.path(), olay["kütük oluşturuldu"] = Clock.currTime());

Burada yapının kurucu işlevinde ilişkili diziyi nasıl ilklendiriyorduk :-O

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bu konu bir kaç gün önce İngilizce forumda da açıldı. Orada da söylendiği gibi, işletim sistemleri 'inotify' gibi destek sağlıyorlar.

http://forum.dlang.org/thread/anjvvpwaksrpgrxqqyzs@forum.dlang.org

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

lstat'ten yararlanıyormuş:

https://stackoverflow.com/questions/1778862/how-does-git-detect-that-a-file-has-been-modified

Orada söylendiğine göre, lstat şöyle kullanılıyormuş:

https://www.kernel.org/pub/software/scm/git/docs/technical/racy-git.txt

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Şimdi biraz değişiklikten sonra kod şu hale geldi:

import std.stdio: writeln;
import std.datetime;

import libasync;
import libasync.watcher;
import libasync.threads;

shared static ~this() { destroyAsyncThreads(); }

struct Dosya
{
   string isim;
   string[SysTime] olay;

   this (DWChangeInfo değişiklik)
   {
       this.isim = değişiklik.path();

       string olay;

       switch (değişiklik.event)
       {
       case DWFileEvent.CREATED:
           olay = "oluşturuldu";
           break;
       case DWFileEvent.DELETED:
           olay = "silindi";
           break;
       case DWFileEvent.MODIFIED:
           olay = "değişti";
           break;
       default:
           break;
       }
       auto zaman = Clock.currTime();

       this.olay[zaman] = olay;

   }
}

Dosya[] dosyalar;

void dizindeDeğişiklikOldu(DWChangeInfo değişiklik)
{
   writeln ("Dizinde değişiklik oldu : ", değişiklik);
   writeln ("Kutuk : ", değişiklik.path());
   writeln ("Zaman : ", Clock.currTime());

   dosyalar ~= Dosya(değişiklik);

   foreach (dosya; dosyalar)
       writeln (dosya);
}

void main()
{
   auto olayDöngüsü = getThreadEventLoop();

   auto bekçi = new AsyncDirectoryWatcher(olayDöngüsü);

   DWChangeInfo[8] değişiklikBilgisi;

   bekçi.run(
   {
       writeln("Dizin olayı gerçekleşti");
       DWChangeInfo[] değişiklikler = değişiklikBilgisi;

       uint sayaç;

       do
       {
           sayaç = bekçi.readChanges(değişiklikler);

           foreach (i; 0 .. sayaç)
           {
               dizindeDeğişiklikOldu(değişiklikler[i]);
           }
       } while (sayaç > 0);
   });

   bekçi.watchDir("ilk");

   writeln("Olay döngüsü çalışıyor. ilk dizininde bir dosya kaydedin");

   while (olayDöngüsü.loop())
       continue;

   writeln("Olay döngüsünden çıkıldı");
}

Örnek program çıktısı:
Alıntı:

Ama sanrım burada dosyaların dosya dizisine eklenip eklenmediğini de kontrol etmek gerekecek.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Çok güzel bir paylaşım bence. Çok faydalı gözüküyor.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Şimdi kendim bir zaman yapısı kullandım. Emacs'ın #otomatik kaydetme# ve yedekleme~ dosyalarını da kapatınca neredeyse olması gerektiği gibi çalışmaya başladı. Neredeyse diyorum çünkü son komut sanki yankı yapıyor. Aslında aynı saniye içerisinde sadece bir kere değişti diye kaydetmesini istiyoruz.

import std.stdio: writeln;
import std.algorithm: canFind;
import std.datetime: SysTime;
import std.datetime: Clock;
import std.format: format;

import libasync;
import libasync.watcher;
import libasync.threads;

shared static ~this() { destroyAsyncThreads(); }

struct Zaman
{
   SysTime zaman;
   ubyte saniye, dakika, saat;
   this (SysTime zaman)
   {
       this.zaman = zaman;
       this.saniye = zaman.second;
       this.dakika = zaman.minute;
       this.saat = zaman.hour;
   }

   string toString()
   {
       return format("%02s:%02s:%02s", this.saat, this.dakika, this.saniye);
   }
}

struct Dosya
{
   string isim;
   string[Zaman] olay;

   this (DWChangeInfo değişiklik)
   {
       this.isim = değişiklik.path();

       string olay;

       switch (değişiklik.event)
       {
       case DWFileEvent.CREATED:
           olay = "oluşturuldu";
           break;
       case DWFileEvent.DELETED:
           olay = "silindi";
           break;
       case DWFileEvent.MODIFIED:
           olay = "değişti";
           break;
       default:
           break;
       }
       auto zaman = Zaman(Clock.currTime());
       this.olay[zaman] = olay;
   }

   void olayEkle(DWChangeInfo değişiklik)
   {
       string olay;

       switch (değişiklik.event)
       {
       case DWFileEvent.CREATED:
           olay = "oluşturuldu";
           break;
       case DWFileEvent.DELETED:
           olay = "silindi";
           break;
       case DWFileEvent.MODIFIED:
           olay = "değişti";
           break;
       case DWFileEvent.MOVED_FROM:
           olay = "taşındı";
           break;

       default:
           break;
       }
       auto zaman = Zaman(Clock.currTime());

       this.olay[zaman] = olay;
   }
}

Dosya[] dosyalar;

void dizindeDeğişiklikOldu(DWChangeInfo değişiklik)
{
   if (!canFind(değişiklik.path(), "#")
       && !canFind(değişiklik.path(), "~"))
   {
       bool dosyaKayıtlı = false;
       int i = 0;

       for (; i < dosyalar.length; ++i)
       {
           if (canFind(dosyalar[i].isim, değişiklik.path()))
           {
               writeln(dosyalar[i].isim, " dosyası zaten kayıtlıymış");
               dosyaKayıtlı = true;
               break;
           }

       }

       if (dosyaKayıtlı)
       {
           writeln("Olay : ", değişiklik.event);
           dosyalar[i].olayEkle(değişiklik);
       }

       else
       {
           writeln("Olay : ", değişiklik.event);
           dosyalar ~= Dosya(değişiklik);
       }

   }

   foreach (dosya; dosyalar)
       writeln (dosya);
}

void main()
{
   auto olayDöngüsü = getThreadEventLoop();

   auto bekçi = new AsyncDirectoryWatcher(olayDöngüsü);

   DWChangeInfo[8] değişiklikBilgisi;

   bekçi.run(
   {
       DWChangeInfo[] değişiklikler = değişiklikBilgisi;

       uint sayaç;

       do
       {
           sayaç = bekçi.readChanges(değişiklikler);

           foreach (i; 0 .. sayaç)
           {
               dizindeDeğişiklikOldu(değişiklikler[i]);
           }
       } while (sayaç > 0);
   });

   bekçi.watchDir("ilk");

   writeln("Olay döngüsü çalışıyor. ilk dizininde bir dosya kaydedin");

   while (olayDöngüsü.loop())
       continue;

   writeln("Olay döngüsünden çıkıldı");
}

Ama dikkat ederseniz yeşille gösterilen yerlerde aynı olayı iki defa kaydetmiş.
Alıntı:

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]