Лебедев Алексей, 393, Proxy

src/ru/fizteh/fivt/students/LebedevAleksey/proxy/BadXmlException.java

@@ -0,0 +1,19 @@
+package ru.fizteh.fivt.students.LebedevAleksey.proxy;
+
+public class BadXmlException extends Exception {
+    public BadXmlException() {
+        super();
+    }
+
+    public BadXmlException(String s) {
+        super(s);
+    }
+
+    public BadXmlException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public BadXmlException(Throwable cause) {
+        super(cause);
+    }
+}

src/ru/fizteh/fivt/students/LebedevAleksey/proxy/ProxyFactory.java

@@ -0,0 +1,152 @@
+package ru.fizteh.fivt.students.LebedevAleksey.proxy;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.lang.reflect.*;
+import java.util.Arrays;
+import java.util.IdentityHashMap;
+
+public class ProxyFactory implements ru.fizteh.fivt.proxy.LoggingProxyFactory {
+    public static final String ITERABLE_VALUE_TAG = "value";
+    private long timestamp;
+    private boolean testMode = false;
+
+    public ProxyFactory() {
+    }
+
+    public ProxyFactory(int timestamp) {
+        this.timestamp = timestamp;
+        testMode = true;
+    }
+
+    public void finishLog(Writer writer) throws IOException {
+        writer.append(System.lineSeparator() + "</log>");
+    }
+
+    @Override
+    public Object wrap(Writer writer, Object implementation, Class<?> interfaceClass) {
+        final XmlWriter xml = new XmlWriter(writer);
+        try {
+            xml.writeBeginDocument("log");
+        } catch (Exception e) {
+            // Eating this exception
+        }
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                if (Arrays.asList(Object.class.getMethods()).contains(method)) {
+                    if (method.getName().equals("toString")) {
+                        return "Wrapper on " + implementation.toString();
+                    }
+                    if (method.getName().equals("equals")) {
+                        return proxy == args[0];
+                    }
+                    if (method.getName().equals("hashCode")) {
+                        return xml.hashCode();
+                    }
+                    if (method.getName().equals("clone")) {
+                        return wrap(writer, implementation, interfaceClass);
+                    }
+                }
+                try {
+                    xml.writeBeginningTag("invoke");
+                    xml.writeArgument("timestamp",
+                            ((Long) (testMode ? timestamp : System.currentTimeMillis())).toString());
+                    xml.writeArgument("class", implementation.getClass().getName());
+                    xml.writeArgument("name", method.getName());
+                    xml.writeEndingOfTag();
+                    xml.writeBeginningTag("arguments");
+                    if (args != null) {
+                        xml.writeEndingOfTag();
+                        for (int i = 0; i < args.length; i++) {
+                            IdentityHashMap<Object, Object> map = new IdentityHashMap();
+                            xml.writeBeginningTag("argument");
+                            xml.writeEndingOfTag();
+                            printValue(args[i], map);
+                            xml.writeEndTag();
+                        }
+                        xml.writeEndTag();
+                    } else {
+                        xml.writeClosingEndingTag();
+                    }
+                } catch (Exception e) {
+                    // Eating exception
+                }
+                try {
+                    Object result = method.invoke(implementation, args);
+                    if (method.getReturnType() != void.class) {
+                        xml.writeBeginningTag("return");
+                        xml.writeEndingOfTag();
+                        IdentityHashMap<Object, Object> map = new IdentityHashMap();
+                        printValue(result, map);
+                        xml.writeEndTag();
+                    }
+                    return result;
+                } catch (InvocationTargetException e) {
+                    try {
+                        xml.writeBeginningTag("thrown");
+                        xml.writeEndingOfTag();
+                        xml.writePlainText(e.getTargetException().toString());
+                        xml.writeEndTag();
+                    } catch (Exception ex) {
+                        // Nothing to do with it
+                    }
+                    throw e.getCause();
+                } catch (Exception e) {
+                    return null;
+                } finally {
+                    try {
+                        xml.writeEndTag();
+                        xml.writeEndDocument();
+                    } catch (Exception e) {
+                        // Nothing to do with it
+                    }
+                }
+            }
+
+            private void printValue(Object item, IdentityHashMap<Object, Object> map)
+                    throws IOException, BadXmlException {
+                if (item == null) {
+                    xml.writeBeginningTagSameLine("null");
+                    xml.writeClosingEndingTag();
+                    return;
+                }
+                if (map.containsKey(item)) {
+                    xml.writeBeginningTagSameLine("cyclic");
+                    xml.writeClosingEndingTag();
+                    return;
+                } else {
+                    map.put(item, null);
+                }
+                if (item instanceof Iterable) {
+                    xml.writeBeginningTag("list");
+                    xml.writeEndingOfTag();
+                    for (Object value : (Iterable) item) {
+                        xml.writeBeginningTag(ITERABLE_VALUE_TAG);
+                        xml.writeEndingOfTag();
+                        printValue(value, map);
+                        xml.writeEndTag();
+                    }
+                    xml.writeEndTag();
+                    return;
+                }
+                if (item.getClass().isArray()) {
+                    xml.writeBeginningTag("array");
+                    xml.writeEndingOfTag();
+                    int length = Array.getLength(item);
+                    for (int i = 0; i < length; ++i) {
+                        xml.writeBeginningTag(ITERABLE_VALUE_TAG);
+                        xml.writeEndingOfTag();
+                        printValue(Array.get(item, i), map);
+                        xml.writeEndTag();
+                    }
+                    xml.writeEndTag();
+                    return;
+                }
+                xml.writePlainText(item.toString());
+            }
+        };
+        return Proxy.newProxyInstance(interfaceClass.getClassLoader(),
+                new Class<?>[]{interfaceClass}, invocationHandler);
+    }
+}

src/ru/fizteh/fivt/students/LebedevAleksey/proxy/XmlWriter.java

@@ -0,0 +1,116 @@
+package ru.fizteh.fivt.students.LebedevAleksey.proxy;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Stack;
+
+public class XmlWriter {
+    private Writer writer;
+    private String initialNodeName;
+    private Stack<String> lastNodes = new Stack<>();
+    private boolean wasPlainText = false;
+
+    public XmlWriter(Writer writer) {
+        this.writer = writer;
+    }
+
+    public void writeBeginDocument(String initialNodeName) throws IOException, BadXmlException {
+        this.initialNodeName = initialNodeName;
+        write("<?xml version=\"1.0\"?>");
+        writeBeginningTag(initialNodeName);
+        writeEndingOfTag();
+    }
+
+    public void writeEndingOfTag() throws IOException, BadXmlException {
+        write(">");
+    }
+
+    public void writeEndTag() throws IOException, BadXmlException {
+        writeEndTag(1);
+    }
+
+    private void writeNewLine() throws IOException {
+        writeln("");
+        for (int i = 0; i < lastNodes.size(); i++) {
+            write("    ");
+        }
+    }
+
+    public void writePlainText(String text) throws IOException {
+        wasPlainText = true;
+        write(toXmlString(text));
+    }
+
+    private void writeEndTag(int minTagCount) throws IOException, BadXmlException {
+        if (lastNodes.size() <= minTagCount) {
+            throw new BadXmlException("There is no tags to close");
+        } else {
+            String tag = lastNodes.pop();
+            if (!wasPlainText) {
+                writeNewLine();
+            }
+            wasPlainText = false;
+            write("</");
+            write(tag);
+            writeEndingOfTag();
+        }
+    }
+
+
+    public void writeClosingEndingTag() throws IOException, BadXmlException {
+        if (lastNodes.size() < 2) {
+            throw new BadXmlException("There is no tags to close");
+        } else {
+            lastNodes.pop();
+            wasPlainText = true;
+            write("/");
+            writeEndingOfTag();
+        }
+    }
+
+    public void writeBeginningTag(String name) throws BadXmlException, IOException {
+        checkSimpleText(name);
+        writeNewLine();
+        write("<");
+        write(name);
+        lastNodes.addElement(name);
+    }
+
+    public void writeBeginningTagSameLine(String name) throws BadXmlException, IOException {
+        checkSimpleText(name);
+        write("<");
+        write(name);
+        lastNodes.addElement(name);
+    }
+
+    private void checkSimpleText(String name) throws BadXmlException {
+        if (!name.equals(toXmlString(name))) {
+            throw new BadXmlException("Tag name is wrong");
+        }
+    }
+
+    public void writeEndDocument() throws IOException, BadXmlException {
+        if (initialNodeName == null) {
+            writeEndTag(0);
+        }
+    }
+
+    public void writeArgument(String name, String value) throws IOException, BadXmlException {
+        checkSimpleText(name);
+        write(" " + name + "=\"" + toXmlString(value) + "\"");
+    }
+
+    private void writeln(String text) throws IOException {
+        write(text);
+        write(System.lineSeparator());
+    }
+
+    private String toXmlString(String text) {
+        return text.replace("&", "&amp;").replace("\"", "&quot;").replace("'", "&apos;").
+                replace("<", "&lt;").replace(">", "&gt;").replace("\n", "&#10;").replace("\r", "$#13;");
+    }
+
+    private void write(String text) throws IOException {
+        writer.append(text);
+    }
+}