fold inotify/inutil into inotify

1 files changed, 18 insertions, 18 deletions

diff --git a/inotify/inutil/inotify_util.go b/inotify/channels.go
index c643e59..737b312 100644
--- a/inotify/inutil/inotify_util.go
+++ b/inotify/channels.go
@@ -14,37 +14,37 @@
 // License along with this manual; if not, see
 // <http://www.gnu.org/licenses/>.
 
-// Package inutil provides a channel-based interface to inotify.
-package inutil
+package inotify
 
 import (
-	"inotify"
 	"os"
 	"syscall"
 )
 
+// A Watcher is a wrapper around an (*Inotify) that exposes a
+// channel-based interface that is much nicer to work with.
 type Watcher struct {
-	Events <-chan inotify.Event
+	Events <-chan Event
 	Errors <-chan error
-	events chan<- inotify.Event
+	events chan<- Event
 	errors chan<- error
-	in     *inotify.Inotify
+	in     *Inotify
 }
 
-// Wraps inotify.InotifyInit()
+// Wraps InotifyInit()
 func WatcherInit() (*Watcher, error) {
-	in, err := inotify.InotifyInit()
+	in, err := InotifyInit()
 	return newWatcher(in, err)
 }
 
-// Wraps inotify.InotifyInit1()
+// Wraps InotifyInit1()
 func WatcherInit1(flags int) (*Watcher, error) {
-	in, err := inotify.InotifyInit1(flags &^ inotify.IN_NONBLOCK)
+	in, err := InotifyInit1(flags &^ IN_NONBLOCK)
 	return newWatcher(in, err)
 }
 
-func newWatcher(in *inotify.Inotify, err error) (*Watcher, error) {
-	events := make(chan inotify.Event)
+func newWatcher(in *Inotify, err error) (*Watcher, error) {
+	events := make(chan Event)
 	errors := make(chan error)
 	o := &Watcher{
 		Events: events,
@@ -57,18 +57,18 @@ func newWatcher(in *inotify.Inotify, err error) (*Watcher, error) {
 	return o, err
 }
 
-// Wraps inotify.Inotify.AddWatch(); adds or modifies a watch.
-func (o *Watcher) AddWatch(path string, mask inotify.Mask) (inotify.Wd, error) {
+// Wraps Inotify.AddWatch(); adds or modifies a watch.
+func (o *Watcher) AddWatch(path string, mask Mask) (Wd, error) {
 	return o.in.AddWatch(path, mask)
 }
 
-// Wraps inotify.Inotify.RmWatch(); removes a watch.
-func (o *Watcher) RmWatch(wd inotify.Wd) error {
+// Wraps Inotify.RmWatch(); removes a watch.
+func (o *Watcher) RmWatch(wd Wd) error {
 	return o.in.RmWatch(wd)
 }
 
-// Wraps inotify.Inotify.Close().  Unlike inotify.Inotify.Close(),
-// this cannot block.  Also unlike inotify.Inotify.Close(), nothing
+// Wraps Inotify.Close().  Unlike Inotify.Close(),
+// this cannot block.  Also unlike Inotify.Close(), nothing
 // may be received from the channel after this is called.
 func (o *Watcher) Close() {
 	func() {