migration

assira1/src/main/java/net/ranides/assira/events/ReflectEventListener.java

@@ -1,189 +1,188 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.events;
-
-import java.lang.reflect.Method;
-import java.util.LinkedList;
-import java.util.List;
-import net.ranides.assira.annotations.Meta;
-import net.ranides.assira.awt.AWTInvoker;
-import net.ranides.assira.reflection.*;
-import net.ranides.assira.reflection.MethodFactory.MethodPointer;
-import net.ranides.assira.reflection.inspect.MethodInspector;
-import net.ranides.assira.reflection.inspect.MethodInspector.MethodFilter;
-import net.ranides.assira.reflection.util.MethodUtils;
-import net.ranides.assira.trace.AdvLogger;
-import net.ranides.assira.trace.LoggerUtils;
-
-/**
- * Obserwator pozwalający tworzyć klasy pochodne, które bezpośrednio w deklaracji
- * klasy definiują odpowiednie wiązania z nadchodzącymi zdarzeniami. Każde zdarzenie
- * otrzymane przez obserwatora jest przekazywane do wszystkich metod spełniających
- * kryteria. Deklaracja metody obsługi zdarzeń ma następującą postać:
- * <ul>
- *      <li>metoda pobiera tylko jeden argument</li>
- *      <li>typ argumentu odpowiada typowi obserwowanego zdarzenia</li>
- *      <li>metoda jest adnotowana za pomocą {@link net.ranides.assira.annotations.Meta.EventHandler}</li>
- *      <li>{@link net.ranides.assira.annotations.Meta.EventHandler} opcjonalnie określa sposób synchronizacji metody względem innych wątków</li>
- * </ul>
- * <p>
- * Jeśli chcesz wiązać zdarzenia na podstawie typu <b>oraz nazwy</b>, zobacz klasę {@link NamedEventListener}.
- * </p>
- *
- * <div class="message-note">thread-safe class</div>
- *
- * @param <T>
- * @author ranides
- * @todo (migration) #4 events
- */
-public class ReflectEventListener<T extends Event> implements EventListener<T> {
-
-    private static final AdvLogger LOGGER = LoggerUtils.getLogger();
-
-    private static final Class[] SUPPORTED_ARGS = { Event.class };
-
-    private static final Class[] EXCEPTION_ARGS = { Throwable.class };
-
-    private final List<EventListener<Event>> listeners = new LinkedList<>();
-
-    private final List<GenericMethod<?>> errorHandlers = new LinkedList<>();
-
-    /**
-     * Tworzy nowy obserwator, który przekazuje wszystkie zdarzenia do podanego
-     * obiektu, wywołując na jego rzecz odpowiednie metody dopasowane na podstawie
-     * typu zdarzenia. Przeczytaj opis klasy, aby poznać wymagania wobec metod obsługi zdarzeń.
-     * @param delegator
-     */
-    public ReflectEventListener(Object delegator) {
-        init(delegator);
-    }
-
-    /**
-     * {@code ReflectEventListener} nie może tworzony bez pośrednio - można jedynie
-     * tworzyć jego klasy pochodne. Po otrzymaniu zdarzenia uruchamia przy użyciu
-     * refleksji odpowiednie metody obsługi zdarzeń. Przeczytaj opis klasy,
-     * aby poznać wymagania wobec metod obsługi zdarzeń.
-     */
-    protected ReflectEventListener() {
-        init(this);
-    }
-
-    private void init(Object delegator) {
-        MethodFilter filter1 = MethodInspector.inobject(delegator)
-            .follow().declared()
-            .params(SUPPORTED_ARGS)
-            .contravariant()
-            .annotated(Meta.EventHandler.class);
-        for(MethodPointer<?> pointer : filter1.pointers()) {
-            listeners.add(wrap(delegator, pointer.reflective()));
-        }
-        MethodFilter filter2 = MethodInspector.inobject(delegator)
-            .follow().declared()
-            .params(EXCEPTION_ARGS)
-            .contravariant()
-            .annotated(Meta.ErrorHandler.class);
-        for(MethodPointer<?> pointer : filter2.pointers()) {
-            errorHandlers.add( pointer.bind(delegator) );
-        }
-    }
-
-    @Override
-    public final void handleEvent(T event) {
-        for(EventListener<Event> listener : listeners) {
-            listener.handleEvent(event);
-        }
-    }
-
-/* ************************************************************************** */
-
-    /**
-     * Klasa do użycia wewnętrznego. Reprezentuje obserwatora, który po otrzymaniu
-     * zdarzenia o podanej klasie wywoła określoną metodę na rzecz obiektu przekazanego
-     * konstruktorowi. Adapter filtruje typ zdarzenia oraz dba o synchronizację
-     * wywołania metody.
-     * <p>
-     * Obiekty typu {@code ReflectAdapter} nie mogą być tworzone bezpośrednio.
-     * Do ich utworzenia należy użyj jednej z metod statycznych {@link #wrap}.
-     */
-    private final class ReflectAdapter implements EventListener<Event> {
-        private final Class<?> type;
-        private final boolean awt;
-        private final boolean sync;
-        private final Object object;
-        private final Method method;
-
-        ReflectAdapter(Class<?> type, Object object, Method method) {
-            this.type   = type;
-            this.object = object;
-            this.method = method;
-            this.awt    = false;
-            this.sync   = false;
-        }
-
-        ReflectAdapter(Class<?> type, Object object, Method method, boolean sync) {
-            this.type   = type;
-            this.object = object;
-            this.method = method;
-            this.awt    = true;
-            this.sync   = sync;
-        }
-
-        @Override
-        public void handleEvent(Event event) {
-            if( !type.isInstance(event) ) {
-                return;
-            }
-            if(awt) {
-                AWTInvoker.run(sync, object, method, event);
-                return;
-            }
-            try {
-                MethodUtils.invoke(object, method, event);
-            } catch(InvokeException incause) {
-                Throwable cause = incause.getCause();
-                for(GenericMethod<?> pointer : errorHandlers) {
-                    if(pointer.canCall(cause)) {
-                        try {
-                            pointer.call(cause);
-                        } catch(Exception fatal) {
-                            LOGGER.xfatal("Unexpected exception caused by: %s\n\tThread: %s\n\tObject: %s\n\tMethod: #%s\n\tEvent: %s\n\tHandler: %s", fatal, cause, Thread.currentThread().getName(), object, method.getName(), event, pointer);
-                        }
-                    }
-                }
-            } catch(InspectException cause) {
-                LOGGER.xerror("Internal event dispath error.\n\tThread: %s\n\tObject: %s\n\tMethod: #%s\n\tEvent: %s", cause, Thread.currentThread().getName(), object, method.getName(), event);
-            }
-        }
-
-    };
-
-    /**
-     * Tworzy nowy obserwator-adapter, który po otrzymaniu zdarzenia wywołuję
-     * podaną metodę na rzecz podanego obiektu. Jeśli typ zdarzenia nie odpowiada
-     * podanej klasie, obserwator nie wykonuje żadnej akcji.
-     * @param clazz
-     * @param object
-     * @param handler
-     * @return
-     */
-    private EventListener<Event> wrap(Object object, Method handler) {
-        Meta.EventHandler info = handler.getAnnotation(Meta.EventHandler.class);
-        Class<?> type = handler.getParameterTypes()[0];
-
-        switch(info.sync()) {
-            case AWT:
-                return new ReflectAdapter(type, object, handler, false);
-            case AWT_WAIT:
-                return new ReflectAdapter(type, object, handler, true);
-            case NONE:
-                return new ReflectAdapter(type, object, handler);
-            default:
-                throw new UnsupportedOperationException(info.sync() + " is not supported");
-        }
-    }
-
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.events;
+
+import java.lang.reflect.Method;
+import java.util.LinkedList;
+import java.util.List;
+import net.ranides.assira.annotations.Meta;
+import net.ranides.assira.awt.AWTInvoker;
+import net.ranides.assira.reflection.*;
+import net.ranides.assira.reflection.MethodFactory.MethodPointer;
+import net.ranides.assira.reflection.inspect.MethodInspector;
+import net.ranides.assira.reflection.inspect.MethodInspector.MethodFilter;
+import net.ranides.assira.reflection.util.MethodUtils;
+import net.ranides.assira.trace.AdvLogger;
+import net.ranides.assira.trace.LoggerUtils;
+
+/**
+ * Obserwator pozwalający tworzyć klasy pochodne, które bezpośrednio w deklaracji
+ * klasy definiują odpowiednie wiązania z nadchodzącymi zdarzeniami. Każde zdarzenie
+ * otrzymane przez obserwatora jest przekazywane do wszystkich metod spełniających
+ * kryteria. Deklaracja metody obsługi zdarzeń ma następującą postać:
+ * <ul>
+ *      <li>metoda pobiera tylko jeden argument</li>
+ *      <li>typ argumentu odpowiada typowi obserwowanego zdarzenia</li>
+ *      <li>metoda jest adnotowana za pomocą {@link net.ranides.assira.annotations.Meta.EventHandler}</li>
+ *      <li>{@link net.ranides.assira.annotations.Meta.EventHandler} opcjonalnie określa sposób synchronizacji metody względem innych wątków</li>
+ * </ul>
+ * <p>
+ * Jeśli chcesz wiązać zdarzenia na podstawie typu <b>oraz nazwy</b>, zobacz klasę {@link NamedEventListener}.
+ * </p>
+ *
+ * <div class="message-note">thread-safe class</div>
+ *
+ * @param <T>
+ * @author ranides
+ */
+public class ReflectEventListener<T extends Event> implements EventListener<T> {
+
+    private static final AdvLogger LOGGER = LoggerUtils.getLogger();
+
+    private static final Class[] SUPPORTED_ARGS = { Event.class };
+
+    private static final Class[] EXCEPTION_ARGS = { Throwable.class };
+
+    private final List<EventListener<Event>> listeners = new LinkedList<>();
+
+    private final List<GenericMethod<?>> errorHandlers = new LinkedList<>();
+
+    /**
+     * Tworzy nowy obserwator, który przekazuje wszystkie zdarzenia do podanego
+     * obiektu, wywołując na jego rzecz odpowiednie metody dopasowane na podstawie
+     * typu zdarzenia. Przeczytaj opis klasy, aby poznać wymagania wobec metod obsługi zdarzeń.
+     * @param delegator
+     */
+    public ReflectEventListener(Object delegator) {
+        init(delegator);
+    }
+
+    /**
+     * {@code ReflectEventListener} nie może tworzony bez pośrednio - można jedynie
+     * tworzyć jego klasy pochodne. Po otrzymaniu zdarzenia uruchamia przy użyciu
+     * refleksji odpowiednie metody obsługi zdarzeń. Przeczytaj opis klasy,
+     * aby poznać wymagania wobec metod obsługi zdarzeń.
+     */
+    protected ReflectEventListener() {
+        init(this);
+    }
+
+    private void init(Object delegator) {
+        MethodFilter filter1 = MethodInspector.inobject(delegator)
+            .follow().declared()
+            .params(SUPPORTED_ARGS)
+            .contravariant()
+            .annotated(Meta.EventHandler.class);
+        for(MethodPointer<?> pointer : filter1.pointers()) {
+            listeners.add(wrap(delegator, pointer.reflective()));
+        }
+        MethodFilter filter2 = MethodInspector.inobject(delegator)
+            .follow().declared()
+            .params(EXCEPTION_ARGS)
+            .contravariant()
+            .annotated(Meta.ErrorHandler.class);
+        for(MethodPointer<?> pointer : filter2.pointers()) {
+            errorHandlers.add( pointer.bind(delegator) );
+        }
+    }
+
+    @Override
+    public final void handleEvent(T event) {
+        for(EventListener<Event> listener : listeners) {
+            listener.handleEvent(event);
+        }
+    }
+
+/* ************************************************************************** */
+
+    /**
+     * Klasa do użycia wewnętrznego. Reprezentuje obserwatora, który po otrzymaniu
+     * zdarzenia o podanej klasie wywoła określoną metodę na rzecz obiektu przekazanego
+     * konstruktorowi. Adapter filtruje typ zdarzenia oraz dba o synchronizację
+     * wywołania metody.
+     * <p>
+     * Obiekty typu {@code ReflectAdapter} nie mogą być tworzone bezpośrednio.
+     * Do ich utworzenia należy użyj jednej z metod statycznych {@link #wrap}.
+     */
+    private final class ReflectAdapter implements EventListener<Event> {
+        private final Class<?> type;
+        private final boolean awt;
+        private final boolean sync;
+        private final Object object;
+        private final Method method;
+
+        ReflectAdapter(Class<?> type, Object object, Method method) {
+            this.type   = type;
+            this.object = object;
+            this.method = method;
+            this.awt    = false;
+            this.sync   = false;
+        }
+
+        ReflectAdapter(Class<?> type, Object object, Method method, boolean sync) {
+            this.type   = type;
+            this.object = object;
+            this.method = method;
+            this.awt    = true;
+            this.sync   = sync;
+        }
+
+        @Override
+        public void handleEvent(Event event) {
+            if( !type.isInstance(event) ) {
+                return;
+            }
+            if(awt) {
+                AWTInvoker.run(sync, object, method, event);
+                return;
+            }
+            try {
+                MethodUtils.invoke(object, method, event);
+            } catch(InvokeException incause) {
+                Throwable cause = incause.getCause();
+                for(GenericMethod<?> pointer : errorHandlers) {
+                    if(pointer.canCall(cause)) {
+                        try {
+                            pointer.call(cause);
+                        } catch(Exception fatal) {
+                            LOGGER.xfatal("Unexpected exception caused by: %s\n\tThread: %s\n\tObject: %s\n\tMethod: #%s\n\tEvent: %s\n\tHandler: %s", fatal, cause, Thread.currentThread().getName(), object, method.getName(), event, pointer);
+                        }
+                    }
+                }
+            } catch(InspectException cause) {
+                LOGGER.xerror("Internal event dispath error.\n\tThread: %s\n\tObject: %s\n\tMethod: #%s\n\tEvent: %s", cause, Thread.currentThread().getName(), object, method.getName(), event);
+            }
+        }
+
+    };
+
+    /**
+     * Tworzy nowy obserwator-adapter, który po otrzymaniu zdarzenia wywołuję
+     * podaną metodę na rzecz podanego obiektu. Jeśli typ zdarzenia nie odpowiada
+     * podanej klasie, obserwator nie wykonuje żadnej akcji.
+     * @param clazz
+     * @param object
+     * @param handler
+     * @return
+     */
+    private EventListener<Event> wrap(Object object, Method handler) {
+        Meta.EventHandler info = handler.getAnnotation(Meta.EventHandler.class);
+        Class<?> type = handler.getParameterTypes()[0];
+
+        switch(info.sync()) {
+            case AWT:
+                return new ReflectAdapter(type, object, handler, false);
+            case AWT_WAIT:
+                return new ReflectAdapter(type, object, handler, true);
+            case NONE:
+                return new ReflectAdapter(type, object, handler);
+            default:
+                throw new UnsupportedOperationException(info.sync() + " is not supported");
+        }
+    }
+
+}

assira1/src/main/java/net/ranides/assira/events/SwingEventListener.java

@@ -1,93 +1,92 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.events;
-
-import net.ranides.assira.awt.AWTInvoker;
-
-/**
- * Obserwator, który po otrzymaniu informacji o zdarzeniu, wywołuje obsługuje 
- * w wątku AWT za pomocą {@link AWTInvoker#run}.
- * @param <T> 
- * @see AWTInvoker
- * @author ranides
- * @todo (migration) #4 events
- */
-public class SwingEventListener<T extends Event> implements EventListener<T> {
-    
-    private final boolean sync;
-    private final EventListener<T> handler;
-
-    /**
-     * Tworzy nowy obserwator, który wywołuje obsługę {@code handler}'a w wątku
-     * AWT. Jeśli argument {@code sync=true} obserwator blokuje również wątek
-     * routera do momentu, aż zdarzenie zostanie przez AWT obsłużone. 
-     * @see javax.swing.SwingUtilities#invokeAndWait
-     * @param handler
-     * @param sync 
-     */
-    public SwingEventListener(EventListener<T> handler, boolean sync) {
-        this.handler = handler;
-        this.sync = sync;
-    }
-    
-    /**
-     * Tworzy nowy obserwator, który wywołuje obsługę {@code handler}'a w wątku
-     * AWT. Wątek routera nie jest blokowany przez obsługę zdarzenia - obserwator
-     * kończy działanie natychmiast po przekazaniu zdarzenia do kolejki AWT.
-     * @see javax.swing.SwingUtilities#invokeLater
-     * @param handler 
-     */
-    public SwingEventListener(EventListener<T> handler) {
-        this(handler, false);
-    }
-
-    @Override
-    public void handleEvent(final T event) {
-        AWTInvoker.run(sync, handler, event);
-    }
-    
-    /**
-     * Metoda statyczna tworząca listener za pomocą konstruktora 
-     * {@link #SwingEventListener(EventListener) SwingEventListener(EventListener)}.
-     * Pozwala skrócić zapis, oszczędzając pisania typu parametru SwingEventListener'a - 
-     * kompilator potrafi go wydedukować nawet w Javie wcześniejszej niż 1.7
-     * @param <E>
-     * @param listener
-     * @return 
-     */
-    public static <E extends Event> SwingEventListener<E> wrap(EventListener<E> listener) {
-        return new SwingEventListener<>(listener);
-    }
-    
-    /**
-     * Metoda statyczna tworząca listener za pomocą konstruktora 
-     * {@link #SwingEventListener(EventListener) SwingEventListener(EventListener)}.
-     * Pozwala skrócić zapis, oszczędzając pisania typu parametru SwingEventListener'a - 
-     * kompilator potrafi go wydedukować nawet w Javie wcześniejszej niż 1.7
-     * @param <E>
-     * @param listener
-     * @param sync 
-     * @return 
-     */
-    public static <E extends Event> SwingEventListener<E> wrap(EventListener<E> listener, boolean sync) {
-        return new SwingEventListener<>(listener, sync);
-    }
-    /**
-     * Metoda statyczna tworząca listener za pomocą konstruktora 
-     * {@link #SwingEventListener(EventListener) SwingEventListener(EventListener)}.
-     * Pozwala skrócić zapis, oszczędzając pisania typu parametru SwingEventListener'a - 
-     * kompilator potrafi go wydedukować nawet w Javie wcześniejszej niż 1.7
-     * @param <E>
-     * @param listener
-     * @param sync 
-     * @return 
-     */
-    public static <E extends Event> SwingEventListener<E> wrap(boolean sync, EventListener<E> listener) {
-        return new SwingEventListener<>(listener, sync);
-    }
-
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.events;
+
+import net.ranides.assira.awt.AWTInvoker;
+
+/**
+ * Obserwator, który po otrzymaniu informacji o zdarzeniu, wywołuje obsługuje 
+ * w wątku AWT za pomocą {@link AWTInvoker#run}.
+ * @param <T> 
+ * @see AWTInvoker
+ * @author ranides
+ */
+public class SwingEventListener<T extends Event> implements EventListener<T> {
+    
+    private final boolean sync;
+    private final EventListener<T> handler;
+
+    /**
+     * Tworzy nowy obserwator, który wywołuje obsługę {@code handler}'a w wątku
+     * AWT. Jeśli argument {@code sync=true} obserwator blokuje również wątek
+     * routera do momentu, aż zdarzenie zostanie przez AWT obsłużone. 
+     * @see javax.swing.SwingUtilities#invokeAndWait
+     * @param handler
+     * @param sync 
+     */
+    public SwingEventListener(EventListener<T> handler, boolean sync) {
+        this.handler = handler;
+        this.sync = sync;
+    }
+    
+    /**
+     * Tworzy nowy obserwator, który wywołuje obsługę {@code handler}'a w wątku
+     * AWT. Wątek routera nie jest blokowany przez obsługę zdarzenia - obserwator
+     * kończy działanie natychmiast po przekazaniu zdarzenia do kolejki AWT.
+     * @see javax.swing.SwingUtilities#invokeLater
+     * @param handler 
+     */
+    public SwingEventListener(EventListener<T> handler) {
+        this(handler, false);
+    }
+
+    @Override
+    public void handleEvent(final T event) {
+        AWTInvoker.run(sync, handler, event);
+    }
+    
+    /**
+     * Metoda statyczna tworząca listener za pomocą konstruktora 
+     * {@link #SwingEventListener(EventListener) SwingEventListener(EventListener)}.
+     * Pozwala skrócić zapis, oszczędzając pisania typu parametru SwingEventListener'a - 
+     * kompilator potrafi go wydedukować nawet w Javie wcześniejszej niż 1.7
+     * @param <E>
+     * @param listener
+     * @return 
+     */
+    public static <E extends Event> SwingEventListener<E> wrap(EventListener<E> listener) {
+        return new SwingEventListener<>(listener);
+    }
+    
+    /**
+     * Metoda statyczna tworząca listener za pomocą konstruktora 
+     * {@link #SwingEventListener(EventListener) SwingEventListener(EventListener)}.
+     * Pozwala skrócić zapis, oszczędzając pisania typu parametru SwingEventListener'a - 
+     * kompilator potrafi go wydedukować nawet w Javie wcześniejszej niż 1.7
+     * @param <E>
+     * @param listener
+     * @param sync 
+     * @return 
+     */
+    public static <E extends Event> SwingEventListener<E> wrap(EventListener<E> listener, boolean sync) {
+        return new SwingEventListener<>(listener, sync);
+    }
+    /**
+     * Metoda statyczna tworząca listener za pomocą konstruktora 
+     * {@link #SwingEventListener(EventListener) SwingEventListener(EventListener)}.
+     * Pozwala skrócić zapis, oszczędzając pisania typu parametru SwingEventListener'a - 
+     * kompilator potrafi go wydedukować nawet w Javie wcześniejszej niż 1.7
+     * @param <E>
+     * @param listener
+     * @param sync 
+     * @return 
+     */
+    public static <E extends Event> SwingEventListener<E> wrap(boolean sync, EventListener<E> listener) {
+        return new SwingEventListener<>(listener, sync);
+    }
+
+}

assira1/src/main/java/net/ranides/assira/io/LocalOutputStream.java

@@ -1,132 +1,129 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.io;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
-import java.nio.charset.Charset;
-import net.ranides.assira.text.TextEncoding;
-
-/**
- *
- * @author ranides
- * @todo (migration) assira.io
- *  - koncepcje
- *  - napisać analogicznie LocalInputStream
- */
-public class LocalOutputStream extends OutputStream {
-    
-    public static final LocalOutputStream NULL_STREAM = toStream(NullOutputStream.INSTANCE);
-    
-    private final File file;
-    private final OutputStream delegate;
-    
-    /**
-     * Tworzy nowy obiekt powiązany z podaną nazwą pliku oraz strumieniem.
-     * @param file
-     * @param delegate
-     */
-    protected LocalOutputStream(File file, OutputStream delegate) {
-        this.file = file;
-        this.delegate = delegate;
-    }
-    
-    public static LocalOutputStream toFile(File file) throws FileNotFoundException {
-        return new LocalOutputStream(file, new FileOutputStream(file));
-    }
-    
-    public static LocalOutputStream toText() {
-        return toText(new File("anonymous"));
-    }
-    
-    public static LocalOutputStream toText(Charset charset) {
-        return toText(new File("anonymous"), charset);
-    }
-    
-    public static LocalOutputStream toText(File path) {
-        return new LocalOutputStream(path, new StrStream(TextEncoding.NIO_UTF8));
-    }
-    
-    public static LocalOutputStream toText(File path, Charset charset) {
-        return new LocalOutputStream(path, new StrStream(charset));
-    }
-    
-    public static LocalOutputStream toStream(OutputStream ostream) {
-        return toStream(new File("anonymous"), ostream);
-    }
-    
-    public static LocalOutputStream toStream(File path, OutputStream ostream) {
-        return new LocalOutputStream(path, ostream);
-    }
-    
-    public static LocalOutputStream toNull() {
-        return NULL_STREAM;
-    }
-    
-    /**
-     * Zwraca nazwę pliku skojarzonego ze strumieniem. Nie musi być to ścieżka 
-     * reprezentująca fizyczny plik, do którego zapisywana jest treść.
-     * @return
-     */
-    public File file() {
-        return file;
-    }
-
-    @Override
-    public void write(int ibyte) throws IOException {
-        delegate.write(ibyte);
-    }
-
-    @Override
-    public void write(byte[] bytes) throws IOException {
-        delegate.write(bytes);
-    }
-
-    @Override
-    public void write(byte[] bytes, int offset, int length) throws IOException {
-        delegate.write(bytes, offset, length);
-    }
-
-    @Override
-    public void flush() throws IOException {
-        delegate.flush();
-    }
-
-    @Override
-    public void close() throws IOException {
-        delegate.close();
-    }
-
-    @Override
-    public String toString() {
-        return delegate.toString();
-    }
-    
-    private static final class StrStream extends ByteArrayOutputStream {
-        private final Charset charset;
-
-        public StrStream(Charset charset) {
-            this.charset = charset;
-        }
-
-        @Override
-        public String toString() {
-            try {
-                return this.toString(charset.name());
-            } catch(UnsupportedEncodingException cause) {
-                throw new RIOException(cause);
-            }
-        }
-        
-    }
-    
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.io;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+import net.ranides.assira.text.TextEncoding;
+
+/**
+ *
+ * @author ranides
+ */
+public class LocalOutputStream extends OutputStream {
+    
+    public static final LocalOutputStream NULL_STREAM = toStream(NullOutputStream.INSTANCE);
+    
+    private final File file;
+    private final OutputStream delegate;
+    
+    /**
+     * Tworzy nowy obiekt powiązany z podaną nazwą pliku oraz strumieniem.
+     * @param file
+     * @param delegate
+     */
+    protected LocalOutputStream(File file, OutputStream delegate) {
+        this.file = file;
+        this.delegate = delegate;
+    }
+    
+    public static LocalOutputStream toFile(File file) throws FileNotFoundException {
+        return new LocalOutputStream(file, new FileOutputStream(file));
+    }
+    
+    public static LocalOutputStream toText() {
+        return toText(new File("anonymous"));
+    }
+    
+    public static LocalOutputStream toText(Charset charset) {
+        return toText(new File("anonymous"), charset);
+    }
+    
+    public static LocalOutputStream toText(File path) {
+        return new LocalOutputStream(path, new StrStream(TextEncoding.NIO_UTF8));
+    }
+    
+    public static LocalOutputStream toText(File path, Charset charset) {
+        return new LocalOutputStream(path, new StrStream(charset));
+    }
+    
+    public static LocalOutputStream toStream(OutputStream ostream) {
+        return toStream(new File("anonymous"), ostream);
+    }
+    
+    public static LocalOutputStream toStream(File path, OutputStream ostream) {
+        return new LocalOutputStream(path, ostream);
+    }
+    
+    public static LocalOutputStream toNull() {
+        return NULL_STREAM;
+    }
+    
+    /**
+     * Zwraca nazwę pliku skojarzonego ze strumieniem. Nie musi być to ścieżka 
+     * reprezentująca fizyczny plik, do którego zapisywana jest treść.
+     * @return
+     */
+    public File file() {
+        return file;
+    }
+
+    @Override
+    public void write(int ibyte) throws IOException {
+        delegate.write(ibyte);
+    }
+
+    @Override
+    public void write(byte[] bytes) throws IOException {
+        delegate.write(bytes);
+    }
+
+    @Override
+    public void write(byte[] bytes, int offset, int length) throws IOException {
+        delegate.write(bytes, offset, length);
+    }
+
+    @Override
+    public void flush() throws IOException {
+        delegate.flush();
+    }
+
+    @Override
+    public void close() throws IOException {
+        delegate.close();
+    }
+
+    @Override
+    public String toString() {
+        return delegate.toString();
+    }
+    
+    private static final class StrStream extends ByteArrayOutputStream {
+        private final Charset charset;
+
+        public StrStream(Charset charset) {
+            this.charset = charset;
+        }
+
+        @Override
+        public String toString() {
+            try {
+                return this.toString(charset.name());
+            } catch(UnsupportedEncodingException cause) {
+                throw new RIOException(cause);
+            }
+        }
+        
+    }
+    
+}

assira1/src/main/java/net/ranides/assira/io/LocalReader.java

@@ -1,184 +1,183 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.io;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.io.StringReader;
-import java.nio.CharBuffer;
-import java.nio.charset.Charset;
-import net.ranides.assira.text.TextEncoding;
-
-/**
- * Klasa, która rozwiązuje odwieczny problem: z jakim plikiem jest skojarzony
- * podany reader.
- * @author ranides
- * @todo (migration) assira.io
- */
-public class LocalReader extends Reader {
-    
-    private final File file;
-    private final Reader delegate;
-
-    /**
-     * Tworzy nowy obiekt powiązany z podaną nazwą pliku oraz readerem.
-     * @param file
-     * @param delegate
-     */
-    protected LocalReader(File file, Reader delegate) {
-        this.file = file;
-        this.delegate = delegate;
-    }
-    
-    /**
-     * Tworzy nowy reader ładujący z podanego pliku tekst w kodowaniu UTF8
-     * @param file
-     * @return
-     * @throws FileNotFoundException
-     */
-    public static LocalReader fromFile(File file) throws FileNotFoundException {
-        return fromFile(file, TextEncoding.NIO_UTF8);
-    }
-    
-    /**
-     * Tworzy nowy reader ładujący z podanego pliku tekst w podanym jawnie kodowaniu
-     * o podanym jawnie kodowaniu
-     * @param file
-     * @param charset
-     * @return
-     * @throws FileNotFoundException
-     */
-    public static LocalReader fromFile(File file, Charset charset) throws FileNotFoundException {
-        return new LocalReader(file, new InputStreamReader(new FileInputStream(file), charset));
-    }
-    
-    /**
-     * Tworzy nowy anonimowy reader zawierający podany tekst.
-     * @param content
-     * @return
-     */
-    public static LocalReader fromText(String content) {
-        return fromText(new File("anonymous"), content);
-    }
-    
-    /**
-     * Tworzy nowy reader skojarzony z podaną nazwą pliku zawierający podany tekst.
-     * @param path
-     * @param content
-     * @return
-     */
-    public static LocalReader fromText(File path, String content) {
-        return new LocalReader(path, new StringReader(content));
-    }
-    
-    /**
-     * Tworzy nowy anonimowy reader czytający tekst w kodowaniu UTF8 z podanego strumienia
-     * @param istream
-     * @return
-     */
-    public static LocalReader fromStream(InputStream istream) {
-        return fromStream(new File("anonymous"), istream, TextEncoding.NIO_UTF8);
-    }
-    
-    /**
-     * Tworzy nowy anonimowy reader czytający tekst w podanym jawnie kodowaniu z podanego strumienia
-     * @param istream
-     * @param charset
-     * @return
-     */
-    public static LocalReader fromStream(InputStream istream, Charset charset) {
-        return new LocalReader(new File("anonymous"), new InputStreamReader(istream, charset));
-    }
-    
-    /**
-     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
-     * w kodowaniu UTF8 z podanego strumienia
-     * @param path
-     * @param istream
-     * @return
-     */
-    public static LocalReader fromStream(File path, InputStream istream) {
-        return fromStream(path, istream, TextEncoding.NIO_UTF8);
-    }
-    
-    /**
-     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
-     * w podanym jawnie kodowaniu z podanego strumienia
-     * @param path
-     * @param istream
-     * @param charset
-     * @return
-     */
-    public static LocalReader fromStream(File path, InputStream istream, Charset charset) {
-        return new LocalReader(path, new InputStreamReader(istream, charset));
-    }
-
-    /**
-     * Zwraca nazwę pliku skojarzonego z readerem. Nie musi być to ścieżka 
-     * reprezentująca fizyczny plik, z którego została załadowana treść.
-     * @return
-     */
-    public File file() {
-        return file;
-    }
-
-    @Override
-    public int read(CharBuffer target) throws IOException {
-        return delegate.read(target);
-    }
-
-    @Override
-    public int read() throws IOException {
-        return delegate.read();
-    }
-
-    @Override
-    public int read(char[] cbuf) throws IOException {
-        return delegate.read(cbuf);
-    }
-
-    @Override
-    public int read(char[] cbuf, int off, int len) throws IOException {
-        return delegate.read(cbuf, off, len);
-    }
-
-    @Override
-    public long skip(long n) throws IOException {
-        return delegate.skip(n);
-    }
-
-    @Override
-    public boolean ready() throws IOException {
-        return delegate.ready();
-    }
-
-    @Override
-    public boolean markSupported() {
-        return delegate.markSupported();
-    }
-
-    @Override
-    public void mark(int readAheadLimit) throws IOException {
-        delegate.mark(readAheadLimit);
-    }
-
-    @Override
-    public void reset() throws IOException {
-        delegate.reset();
-    }
-
-    @Override
-    public void close() throws IOException {
-        delegate.close();
-    }
-    
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.io;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.StringReader;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import net.ranides.assira.text.TextEncoding;
+
+/**
+ * Klasa, która rozwiązuje odwieczny problem: z jakim plikiem jest skojarzony
+ * podany reader.
+ * @author ranides
+ */
+public class LocalReader extends Reader {
+    
+    private final File file;
+    private final Reader delegate;
+
+    /**
+     * Tworzy nowy obiekt powiązany z podaną nazwą pliku oraz readerem.
+     * @param file
+     * @param delegate
+     */
+    protected LocalReader(File file, Reader delegate) {
+        this.file = file;
+        this.delegate = delegate;
+    }
+    
+    /**
+     * Tworzy nowy reader ładujący z podanego pliku tekst w kodowaniu UTF8
+     * @param file
+     * @return
+     * @throws FileNotFoundException
+     */
+    public static LocalReader fromFile(File file) throws FileNotFoundException {
+        return fromFile(file, TextEncoding.NIO_UTF8);
+    }
+    
+    /**
+     * Tworzy nowy reader ładujący z podanego pliku tekst w podanym jawnie kodowaniu
+     * o podanym jawnie kodowaniu
+     * @param file
+     * @param charset
+     * @return
+     * @throws FileNotFoundException
+     */
+    public static LocalReader fromFile(File file, Charset charset) throws FileNotFoundException {
+        return new LocalReader(file, new InputStreamReader(new FileInputStream(file), charset));
+    }
+    
+    /**
+     * Tworzy nowy anonimowy reader zawierający podany tekst.
+     * @param content
+     * @return
+     */
+    public static LocalReader fromText(String content) {
+        return fromText(new File("anonymous"), content);
+    }
+    
+    /**
+     * Tworzy nowy reader skojarzony z podaną nazwą pliku zawierający podany tekst.
+     * @param path
+     * @param content
+     * @return
+     */
+    public static LocalReader fromText(File path, String content) {
+        return new LocalReader(path, new StringReader(content));
+    }
+    
+    /**
+     * Tworzy nowy anonimowy reader czytający tekst w kodowaniu UTF8 z podanego strumienia
+     * @param istream
+     * @return
+     */
+    public static LocalReader fromStream(InputStream istream) {
+        return fromStream(new File("anonymous"), istream, TextEncoding.NIO_UTF8);
+    }
+    
+    /**
+     * Tworzy nowy anonimowy reader czytający tekst w podanym jawnie kodowaniu z podanego strumienia
+     * @param istream
+     * @param charset
+     * @return
+     */
+    public static LocalReader fromStream(InputStream istream, Charset charset) {
+        return new LocalReader(new File("anonymous"), new InputStreamReader(istream, charset));
+    }
+    
+    /**
+     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
+     * w kodowaniu UTF8 z podanego strumienia
+     * @param path
+     * @param istream
+     * @return
+     */
+    public static LocalReader fromStream(File path, InputStream istream) {
+        return fromStream(path, istream, TextEncoding.NIO_UTF8);
+    }
+    
+    /**
+     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
+     * w podanym jawnie kodowaniu z podanego strumienia
+     * @param path
+     * @param istream
+     * @param charset
+     * @return
+     */
+    public static LocalReader fromStream(File path, InputStream istream, Charset charset) {
+        return new LocalReader(path, new InputStreamReader(istream, charset));
+    }
+
+    /**
+     * Zwraca nazwę pliku skojarzonego z readerem. Nie musi być to ścieżka 
+     * reprezentująca fizyczny plik, z którego została załadowana treść.
+     * @return
+     */
+    public File file() {
+        return file;
+    }
+
+    @Override
+    public int read(CharBuffer target) throws IOException {
+        return delegate.read(target);
+    }
+
+    @Override
+    public int read() throws IOException {
+        return delegate.read();
+    }
+
+    @Override
+    public int read(char[] cbuf) throws IOException {
+        return delegate.read(cbuf);
+    }
+
+    @Override
+    public int read(char[] cbuf, int off, int len) throws IOException {
+        return delegate.read(cbuf, off, len);
+    }
+
+    @Override
+    public long skip(long n) throws IOException {
+        return delegate.skip(n);
+    }
+
+    @Override
+    public boolean ready() throws IOException {
+        return delegate.ready();
+    }
+
+    @Override
+    public boolean markSupported() {
+        return delegate.markSupported();
+    }
+
+    @Override
+    public void mark(int readAheadLimit) throws IOException {
+        delegate.mark(readAheadLimit);
+    }
+
+    @Override
+    public void reset() throws IOException {
+        delegate.reset();
+    }
+
+    @Override
+    public void close() throws IOException {
+        delegate.close();
+    }
+    
+}

assira1/src/main/java/net/ranides/assira/io/LocalWriter.java

@@ -1,191 +1,190 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.io;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.nio.charset.Charset;
-import net.ranides.assira.text.TextEncoding;
-
-/**
- * Klasa, która rozwiązuje odwieczny problem: z jakim plikiem jest skojarzony
- * podany reader.
- * @author ranides
- * @todo (migration) assira.io
- */
-public class LocalWriter extends Writer {
-    
-    public static final LocalWriter NULL_WRITER = toStream(NullOutputStream.INSTANCE);
-    
-    private final File file;
-    private final Writer delegate;
-
-    /**
-     * Tworzy nowy obiekt powiązany z podaną nazwą pliku oraz readerem.
-     * @param file
-     * @param delegate
-     */
-    protected LocalWriter(File file, Writer delegate) {
-        this.file = file;
-        this.delegate = delegate;
-    }
-    
-    /**
-     * Tworzy nowy reader ładujący z podanego pliku tekst w kodowaniu UTF8
-     * @param file
-     * @return
-     * @throws FileNotFoundException
-     */
-    public static LocalWriter toFile(File file) throws FileNotFoundException {
-        return toFile(file, TextEncoding.NIO_UTF8);
-    }
-    
-    /**
-     * Tworzy nowy reader ładujący z podanego pliku tekst w podanym jawnie kodowaniu
-     * o podanym jawnie kodowaniu
-     * @param file
-     * @param charset
-     * @return
-     * @throws FileNotFoundException
-     */
-    public static LocalWriter toFile(File file, Charset charset) throws FileNotFoundException {
-        return new LocalWriter(file, new OutputStreamWriter(new FileOutputStream(file), charset));
-    }
-    
-    /**
-     * Tworzy nowy anonimowy reader zawierający podany tekst.
-     * @param content
-     * @return
-     */
-    public static LocalWriter toText() {
-        return toText(new File("anonymous"));
-    }
-    
-    /**
-     * Tworzy nowy reader skojarzony z podaną nazwą pliku zawierający podany tekst.
-     * @param path
-     * @param content
-     * @return
-     */
-    public static LocalWriter toText(File path) {
-        return new LocalWriter(path, new StringWriter());
-    }
-    
-    /**
-     * Tworzy nowy anonimowy reader czytający tekst w kodowaniu UTF8 z podanego strumienia
-     * @param istream
-     * @return
-     */
-    public static LocalWriter toStream(OutputStream ostream) {
-        return toStream(new File("anonymous"), ostream, TextEncoding.NIO_UTF8);
-    }
-    
-    /**
-     * Tworzy nowy anonimowy reader czytający tekst w podanym jawnie kodowaniu z podanego strumienia
-     * @param istream
-     * @param charset
-     * @return
-     */
-    public static LocalWriter toStream(OutputStream ostream, Charset charset) {
-        return new LocalWriter(new File("anonymous"), new OutputStreamWriter(ostream, charset));
-    }
-    
-    /**
-     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
-     * w kodowaniu UTF8 z podanego strumienia
-     * @param path
-     * @param istream
-     * @return
-     */
-    public static LocalWriter toStream(File path, OutputStream ostream) {
-        return toStream(path, ostream, TextEncoding.NIO_UTF8);
-    }
-    
-    /**
-     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
-     * w podanym jawnie kodowaniu z podanego strumienia
-     * @param path
-     * @param istream
-     * @param charset
-     * @return
-     */
-    public static LocalWriter toStream(File path, OutputStream ostream, Charset charset) {
-        return new LocalWriter(path, new OutputStreamWriter(ostream, charset));
-    }
-    
-    public static LocalWriter toNull() {
-        return NULL_WRITER;
-    }
-
-    /**
-     * Zwraca nazwę pliku skojarzonego z readerem. Nie musi być to ścieżka 
-     * reprezentująca fizyczny plik, z którego została załadowana treść.
-     * @return
-     */
-    public File file() {
-        return file;
-    }
-
-    @Override
-    public void write(int c) throws IOException {
-        delegate.write(c);
-    }
-
-    @Override
-    public void write(char[] cbuf) throws IOException {
-        delegate.write(cbuf);
-    }
-
-    @Override
-    public void write(char[] cbuf, int off, int len) throws IOException {
-        delegate.write(cbuf, off, len);
-    }
-
-    @Override
-    public void write(String str) throws IOException {
-        delegate.write(str);
-    }
-
-    @Override
-    public void write(String str, int off, int len) throws IOException {
-        delegate.write(str, off, len);
-    }
-
-    @Override
-    public Writer append(CharSequence csq) throws IOException {
-        return delegate.append(csq);
-    }
-
-    @Override
-    public Writer append(CharSequence csq, int start, int end) throws IOException {
-        return delegate.append(csq, start, end);
-    }
-
-    @Override
-    public Writer append(char c) throws IOException {
-        return delegate.append(c);
-    }
-
-    @Override
-    public void flush() throws IOException {
-        delegate.flush();
-    }
-
-    @Override
-    public void close() throws IOException {
-        delegate.close();
-    }
-    
-    
-    
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.io;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.charset.Charset;
+import net.ranides.assira.text.TextEncoding;
+
+/**
+ * Klasa, która rozwiązuje odwieczny problem: z jakim plikiem jest skojarzony
+ * podany reader.
+ * @author ranides
+ */
+public class LocalWriter extends Writer {
+    
+    public static final LocalWriter NULL_WRITER = toStream(NullOutputStream.INSTANCE);
+    
+    private final File file;
+    private final Writer delegate;
+
+    /**
+     * Tworzy nowy obiekt powiązany z podaną nazwą pliku oraz readerem.
+     * @param file
+     * @param delegate
+     */
+    protected LocalWriter(File file, Writer delegate) {
+        this.file = file;
+        this.delegate = delegate;
+    }
+    
+    /**
+     * Tworzy nowy reader ładujący z podanego pliku tekst w kodowaniu UTF8
+     * @param file
+     * @return
+     * @throws FileNotFoundException
+     */
+    public static LocalWriter toFile(File file) throws FileNotFoundException {
+        return toFile(file, TextEncoding.NIO_UTF8);
+    }
+    
+    /**
+     * Tworzy nowy reader ładujący z podanego pliku tekst w podanym jawnie kodowaniu
+     * o podanym jawnie kodowaniu
+     * @param file
+     * @param charset
+     * @return
+     * @throws FileNotFoundException
+     */
+    public static LocalWriter toFile(File file, Charset charset) throws FileNotFoundException {
+        return new LocalWriter(file, new OutputStreamWriter(new FileOutputStream(file), charset));
+    }
+    
+    /**
+     * Tworzy nowy anonimowy reader zawierający podany tekst.
+     * @param content
+     * @return
+     */
+    public static LocalWriter toText() {
+        return toText(new File("anonymous"));
+    }
+    
+    /**
+     * Tworzy nowy reader skojarzony z podaną nazwą pliku zawierający podany tekst.
+     * @param path
+     * @param content
+     * @return
+     */
+    public static LocalWriter toText(File path) {
+        return new LocalWriter(path, new StringWriter());
+    }
+    
+    /**
+     * Tworzy nowy anonimowy reader czytający tekst w kodowaniu UTF8 z podanego strumienia
+     * @param istream
+     * @return
+     */
+    public static LocalWriter toStream(OutputStream ostream) {
+        return toStream(new File("anonymous"), ostream, TextEncoding.NIO_UTF8);
+    }
+    
+    /**
+     * Tworzy nowy anonimowy reader czytający tekst w podanym jawnie kodowaniu z podanego strumienia
+     * @param istream
+     * @param charset
+     * @return
+     */
+    public static LocalWriter toStream(OutputStream ostream, Charset charset) {
+        return new LocalWriter(new File("anonymous"), new OutputStreamWriter(ostream, charset));
+    }
+    
+    /**
+     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
+     * w kodowaniu UTF8 z podanego strumienia
+     * @param path
+     * @param istream
+     * @return
+     */
+    public static LocalWriter toStream(File path, OutputStream ostream) {
+        return toStream(path, ostream, TextEncoding.NIO_UTF8);
+    }
+    
+    /**
+     * Tworzy nowy reader skojarzony z podaną nazwą pliku, czytający tekst 
+     * w podanym jawnie kodowaniu z podanego strumienia
+     * @param path
+     * @param istream
+     * @param charset
+     * @return
+     */
+    public static LocalWriter toStream(File path, OutputStream ostream, Charset charset) {
+        return new LocalWriter(path, new OutputStreamWriter(ostream, charset));
+    }
+    
+    public static LocalWriter toNull() {
+        return NULL_WRITER;
+    }
+
+    /**
+     * Zwraca nazwę pliku skojarzonego z readerem. Nie musi być to ścieżka 
+     * reprezentująca fizyczny plik, z którego została załadowana treść.
+     * @return
+     */
+    public File file() {
+        return file;
+    }
+
+    @Override
+    public void write(int c) throws IOException {
+        delegate.write(c);
+    }
+
+    @Override
+    public void write(char[] cbuf) throws IOException {
+        delegate.write(cbuf);
+    }
+
+    @Override
+    public void write(char[] cbuf, int off, int len) throws IOException {
+        delegate.write(cbuf, off, len);
+    }
+
+    @Override
+    public void write(String str) throws IOException {
+        delegate.write(str);
+    }
+
+    @Override
+    public void write(String str, int off, int len) throws IOException {
+        delegate.write(str, off, len);
+    }
+
+    @Override
+    public Writer append(CharSequence csq) throws IOException {
+        return delegate.append(csq);
+    }
+
+    @Override
+    public Writer append(CharSequence csq, int start, int end) throws IOException {
+        return delegate.append(csq, start, end);
+    }
+
+    @Override
+    public Writer append(char c) throws IOException {
+        return delegate.append(c);
+    }
+
+    @Override
+    public void flush() throws IOException {
+        delegate.flush();
+    }
+
+    @Override
+    public void close() throws IOException {
+        delegate.close();
+    }
+    
+    
+    
+}

assira1/src/main/java/net/ranides/assira/text/format/AnsiAttr.java

@@ -15,7 +15,6 @@ import net.ranides.assira.math.HashHelper;
 /**
  *
  * @author ranides
- * @todo (migration) assira (ansi)
  */
 public abstract class AnsiAttr implements Serializable {
     

assira1/src/main/java/net/ranides/assira/text/format/AnsiBuilder.java

@@ -11,7 +11,6 @@ import net.ranides.assira.text.StringUtils;
 /**
  *
  * @author ranides
- * @todo (migration) assira (ansi)
  */
 public class AnsiBuilder extends AnsiString {
     

assira1/src/main/java/net/ranides/assira/text/format/AnsiCharSequence.java

@@ -17,7 +17,6 @@ import net.ranides.assira.math.Bitwise;
  * Klasa reprezentująca ciąg znaków razem z przypisanymi do nich atrybutami 
  * (kolor tekstu, tła, czcionka, styl)
  * @author ranides
- * @todo (migration) assira (ansi)
  */
 public abstract class AnsiCharSequence implements CharSequence, Serializable {
     

assira1/src/main/java/net/ranides/assira/text/format/AnsiMatch.java

@@ -12,7 +12,6 @@ import java.util.regex.Matcher;
 /**
  *
  * @author Ranides Atterwim <ranides@gmail.com>
- * @todo (migration) assira (ansi)
  */
 public final class AnsiMatch implements Serializable {
     

assira1/src/main/java/net/ranides/assira/text/format/AnsiPattern.java

@@ -16,7 +16,6 @@ import net.ranides.assira.text.Strings;
 /**
  *
  * @author Ranides Atterwim <ranides@gmail.com>
- * @todo (migration) assira (ansi)
  */
 public abstract class AnsiPattern implements Serializable {
     

assira1/src/main/java/net/ranides/assira/text/format/AnsiRegion.java

@@ -11,7 +11,6 @@ import java.io.Serializable;
 /**
  *
  * @author Ranides Atterwim <ranides@gmail.com>
- * @todo (migration) assira (ansi)
  */
 public final class AnsiRegion implements Serializable {
     

assira1/src/main/java/net/ranides/assira/text/format/AnsiScheme.java

@@ -18,7 +18,6 @@ import net.ranides.assira.math.HashHelper;
 /**
  *
  * @author Ranides Atterwim <ranides@gmail.com>
- * @todo (migration) assira (ansi)
  */
 public final class AnsiScheme implements Serializable {
     

assira1/src/main/java/net/ranides/assira/text/format/AnsiString.java

@@ -14,7 +14,6 @@ import net.ranides.assira.math.Bitwise;
 /**
  *
  * @author ranides
- * @todo (migration) assira (ansi)
  */
 public class AnsiString extends AnsiCharSequence {
 

assira1/src/main/java/net/ranides/assira/text/format/AnsiStrings.java

@@ -13,7 +13,6 @@ import net.ranides.assira.math.Bitwise;
 /**
  *
  * @author Ranides Atterwim <ranides@gmail.com>
- * @todo (migration) assira (ansi)
  */
 public final class AnsiStrings {
     

assira1/src/main/java/net/ranides/assira/time/TimeStack.java

@@ -13,7 +13,6 @@ import java.util.Stack;
 /**
  *
  * @author ranides
- * @todo (migration) assira
  */
 public class TimeStack {
 

assira1/src/main/java/net/ranides/assira/trace/LoggerUtils.java

@@ -1,147 +1,146 @@
-/*
- *  @author Ranides Atterwim <ranides@gmail.com>
- *  @copyright Ranides Atterwim
- *  @license WTFPL
- *  @url http://ranides.net/projects/assira
- */
-
-package net.ranides.assira.trace;
-
-import java.util.Formatter;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import net.ranides.assira.reflection.inspect.FieldInspector;
-import net.ranides.assira.system.RuntimeUtils;
-
-/**
- *
- * @author ranides
- */
-public final class LoggerUtils {
-    
-    private static final Map<String, AdvLogger> CACHE = new HashMap<>();
-
-    public static final org.apache.log4j.Layout LAYOUT = new org.apache.log4j.PatternLayout("%d %p [%c %M] %m%n");
-    
-    public static final org.apache.log4j.Appender PRINTER = new org.apache.log4j.ConsoleAppender(LAYOUT, "System.out");
-
-    private LoggerUtils() { }
-
-    public static final String INVOKE = "invoke";
-
-    public static final String INVOKE_SUCCESS = "invoke success";
-
-    public static final String INVOKE_ERROR = "invoke error";
-
-    public static java.util.logging.Logger resetJavaLogger(java.util.logging.Level level) {
-        java.util.logging.LogManager.getLogManager().reset();
-        java.util.logging.Logger global = java.util.logging.Logger.getLogger(java.util.logging.Logger.GLOBAL_LOGGER_NAME);
-        global.setLevel(level);
-        return global;
-    }
-
-    public static void initTest() {
-        resetLogger4j(RuntimeUtils.invokedInsideSingleTest());
-    }
-
-    public static java.util.logging.Logger resetJavaLogger(boolean enable) {
-        return resetJavaLogger(enable ? java.util.logging.Level.ALL : java.util.logging.Level.OFF );
-    }
-
-    public static org.apache.log4j.Logger resetLogger4j(boolean enable) {
-        return resetLogger4j(enable ? org.apache.log4j.Level.ALL : org.apache.log4j.Level.OFF);
-    }
-
-    public static org.apache.log4j.Logger resetLogger4j(org.apache.log4j.Level level) {
-        return resetLogger4j(level, PRINTER);
-    }
-
-    public static org.apache.log4j.Logger resetLogger4j(org.apache.log4j.Level level, org.apache.log4j.Appender appender) {
-        org.apache.log4j.Logger logger = org.apache.log4j.Logger.getRootLogger();
-        logger.removeAllAppenders();
-        logger.addAppender(appender);
-        logger.setLevel(level);
-        return logger;
-    }
-
-    public static AdvLogger getLogger() {
-        return getLogger( new Throwable().getStackTrace()[1].getClassName() );
-    }
-
-    public static AdvLogger getLogger(Class<?> clazz) {
-        return getLogger(clazz.getName());
-    }
-
-    public static AdvLogger getLogger(String name) {
-        // Może się okazać, że logger INNEJ KLASY został już utworzony dla podanego "name"
-        // Wtedy nie ruszy nasza fabryka "FACTORY", tylko dostaniemy
-        // instancję wcześniej utworzoną (uwaga! skonfigurowaną!)
-        //
-        // nawet jeśli chcemy ją zignorować, to musimy przepisać z niej konfigurację
-
-        org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(name, AdvLogger.FACTORY);
-
-        if(logger instanceof AdvLogger) {
-            return (AdvLogger)logger;
-        } else {
-            synchronized(CACHE) {
-                if(CACHE.containsKey(name)) {
-                    return CACHE.get(name);
-                }
-                AdvLogger result = new AdvLogger(name);
-                FieldInspector.copy(result, logger);
-                CACHE.put(name, result);
-                return result;
-            }
-        }
-
-    }
-
-    /**
-     * Działa tylko wtedy, jeśli ustawiona jest zmienna systemowa "test".
-     * W praktyce oznacza to, że działa wtedy, gdy uruchomiono <b>pojedynczny</b>
-     * test jednostkowy: jeśli test uruchomiony jest np podczas budowania projektu,
-     * to nie funkcja nie wyświetla komunikatu.
-     * @param locale
-     * @param format
-     * @param args
-     */
-    @SuppressWarnings({"PMD.SystemPrintln", "NP_ALWAYS_NULL"})
-    public static void dump(Locale locale, String format, Object... args) {
-        if(RuntimeUtils.invokedInsideSingleTest()) {
-            System.out.print(new Formatter().format(locale, format, args).toString());
-        }
-    }
-
-    /**
-     * Działa tylko wtedy, jeśli ustawiona jest zmienna systemowa "test".
-     * W praktyce oznacza to, że działa wtedy, gdy uruchomiono <b>pojedynczny</b>
-     * test jednostkowy: jeśli test uruchomiony jest np podczas budowania projektu,
-     * to nie funkcja nie wyświetla komunikatu.
-     * @param format
-     * @param args
-     */
-    public static void dump(String format, Object... args) {
-        dump(Locale.ROOT, format, args);
-    }
-
-    // @todo (migration) LoggerUtils.setThreadLogger
-    public static void setThreadLogger(final org.apache.log4j.Logger logger) {
-        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
-            @Override
-            public void uncaughtException(Thread thread, Throwable exception) {
-                logger.fatal("Abnormal termination of thread: " + thread.getName(), exception);
-            }
-        });
-    }
-
-    public static void removeHandlers(final java.util.logging.Logger logger) {
-        for(java.util.logging.Handler handler : logger.getHandlers()) {
-            if( handler instanceof java.util.logging.ConsoleHandler) {
-                logger.removeHandler(handler);
-            }
-        }
-    }
-
-}
+/*
+ *  @author Ranides Atterwim <ranides@gmail.com>
+ *  @copyright Ranides Atterwim
+ *  @license WTFPL
+ *  @url http://ranides.net/projects/assira
+ */
+
+package net.ranides.assira.trace;
+
+import java.util.Formatter;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import net.ranides.assira.reflection.inspect.FieldInspector;
+import net.ranides.assira.system.RuntimeUtils;
+
+/**
+ *
+ * @author ranides
+ */
+public final class LoggerUtils {
+    
+    private static final Map<String, AdvLogger> CACHE = new HashMap<>();
+
+    public static final org.apache.log4j.Layout LAYOUT = new org.apache.log4j.PatternLayout("%d %p [%c %M] %m%n");
+    
+    public static final org.apache.log4j.Appender PRINTER = new org.apache.log4j.ConsoleAppender(LAYOUT, "System.out");
+
+    private LoggerUtils() { }
+
+    public static final String INVOKE = "invoke";
+
+    public static final String INVOKE_SUCCESS = "invoke success";
+
+    public static final String INVOKE_ERROR = "invoke error";
+
+    public static java.util.logging.Logger resetJavaLogger(java.util.logging.Level level) {
+        java.util.logging.LogManager.getLogManager().reset();
+        java.util.logging.Logger global = java.util.logging.Logger.getLogger(java.util.logging.Logger.GLOBAL_LOGGER_NAME);
+        global.setLevel(level);
+        return global;
+    }
+
+    public static void initTest() {
+        resetLogger4j(RuntimeUtils.invokedInsideSingleTest());
+    }
+
+    public static java.util.logging.Logger resetJavaLogger(boolean enable) {
+        return resetJavaLogger(enable ? java.util.logging.Level.ALL : java.util.logging.Level.OFF );
+    }
+
+    public static org.apache.log4j.Logger resetLogger4j(boolean enable) {
+        return resetLogger4j(enable ? org.apache.log4j.Level.ALL : org.apache.log4j.Level.OFF);
+    }
+
+    public static org.apache.log4j.Logger resetLogger4j(org.apache.log4j.Level level) {
+        return resetLogger4j(level, PRINTER);
+    }
+
+    public static org.apache.log4j.Logger resetLogger4j(org.apache.log4j.Level level, org.apache.log4j.Appender appender) {
+        org.apache.log4j.Logger logger = org.apache.log4j.Logger.getRootLogger();
+        logger.removeAllAppenders();
+        logger.addAppender(appender);
+        logger.setLevel(level);
+        return logger;
+    }
+
+    public static AdvLogger getLogger() {
+        return getLogger( new Throwable().getStackTrace()[1].getClassName() );
+    }
+
+    public static AdvLogger getLogger(Class<?> clazz) {
+        return getLogger(clazz.getName());
+    }
+
+    public static AdvLogger getLogger(String name) {
+        // Może się okazać, że logger INNEJ KLASY został już utworzony dla podanego "name"
+        // Wtedy nie ruszy nasza fabryka "FACTORY", tylko dostaniemy
+        // instancję wcześniej utworzoną (uwaga! skonfigurowaną!)
+        //
+        // nawet jeśli chcemy ją zignorować, to musimy przepisać z niej konfigurację
+
+        org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(name, AdvLogger.FACTORY);
+
+        if(logger instanceof AdvLogger) {
+            return (AdvLogger)logger;
+        } else {
+            synchronized(CACHE) {
+                if(CACHE.containsKey(name)) {
+                    return CACHE.get(name);
+                }
+                AdvLogger result = new AdvLogger(name);
+                FieldInspector.copy(result, logger);
+                CACHE.put(name, result);
+                return result;
+            }
+        }
+
+    }
+
+    /**
+     * Działa tylko wtedy, jeśli ustawiona jest zmienna systemowa "test".
+     * W praktyce oznacza to, że działa wtedy, gdy uruchomiono <b>pojedynczny</b>
+     * test jednostkowy: jeśli test uruchomiony jest np podczas budowania projektu,
+     * to nie funkcja nie wyświetla komunikatu.
+     * @param locale
+     * @param format
+     * @param args
+     */
+    @SuppressWarnings({"PMD.SystemPrintln", "NP_ALWAYS_NULL"})
+    public static void dump(Locale locale, String format, Object... args) {
+        if(RuntimeUtils.invokedInsideSingleTest()) {
+            System.out.print(new Formatter().format(locale, format, args).toString());
+        }
+    }
+
+    /**
+     * Działa tylko wtedy, jeśli ustawiona jest zmienna systemowa "test".
+     * W praktyce oznacza to, że działa wtedy, gdy uruchomiono <b>pojedynczny</b>
+     * test jednostkowy: jeśli test uruchomiony jest np podczas budowania projektu,
+     * to nie funkcja nie wyświetla komunikatu.
+     * @param format
+     * @param args
+     */
+    public static void dump(String format, Object... args) {
+        dump(Locale.ROOT, format, args);
+    }
+
+    public static void setThreadLogger(final org.apache.log4j.Logger logger) {
+        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread thread, Throwable exception) {
+                logger.fatal("Abnormal termination of thread: " + thread.getName(), exception);
+            }
+        });
+    }
+
+    public static void removeHandlers(final java.util.logging.Logger logger) {
+        for(java.util.logging.Handler handler : logger.getHandlers()) {
+            if( handler instanceof java.util.logging.ConsoleHandler) {
+                logger.removeHandler(handler);
+            }
+        }
+    }
+
+}