java代ç : |
interface Dependency{ Object getArgument(int i, Class type); Class verifyArgument(int i, Class type); Object getProperty(Object key, Class type); Class verifyProperty(Object key, Class type); } |
java代ç : |
interface Component{ Class getType(); Object create(Dependency dep); Class verify(Dependency dep); } |
java代ç : |
interface Container{ Component getComponent(Object key); Component getComponentOfType(Class type); } |
java代ç : |
class ValueComponent implements Component{ private final Object v; public Class getType(){ return v==null?null:v.getClass(); } public Object create(Dependency dep){ return v; } public Class verify(Dependency dep){ return getType(); } } |
java代ç : |
interface Function{ Class getReturnType(); Class[] getParameterTypes(); Object call(Object[] args); } |
java代ç : |
class Functions{ static Function ctor(Constructor ctor); static Function method(Object obj, Method mtd); static Function static_method(Class type, Method mtd); } |
java代ç : |
static Function ctor(Class type); |
java代ç : |
class FunctionComponent implements Component{ private final Function f; public Class getType(){ return f.getReturnType(); } public Object create(Dependency dep){ final Class[] types = f.getParameterTypes(); final Object[] args = new Object[types.length]; foreach(t:types){ args[i] = dep.getArgument(i, t); } return f.call(args); } public Class verify(Dependency dep){ final Class[] types = f.getParameterTypes(); foreach(t:types){ Class arg_type = dep.verifyArgument(i, t); checkTypeMatch(types[i], arg_type); } return f.getReturnType(); } } |
java代ç : |
class BeanComponent implements Component{ private final Class type; public Class getType(){ return type; } public Object create(Dependency dep){ Object r = createInstance(); setJavaBeans(r,dep); } public Class verify(Dependency dep){ ... } } |
java代ç : |
class WithArgument implements Component{ private final Component parent; private final int pos; private final Component arg; public Class getType(){ return parent.getType(); } public Object create(Dependency dep){ return parent.create(withArg(dep)); } public Class verify(Dependency dep){ return parent.verify(withArg(dep)); } private Dependency withArg(final Dependency dep){ return new Dependency(){ public Object getArgument(int i, Class type){ if(i==pos){ checkTypeMatch(type, arg); return arg.create(dep); } else return dep.getArgument(i, type); } } ... } } |
java代ç : |
class WithProperty implements Component{ private final Component parent; private final Object key; private final Component prop; public Class getType(){ return parent.getType(); } public Object create(Dependency dep){ return parent.create(withProp(dep)); } public Class verify(Dependency dep){ return parent.verify(withProp(dep)); } private Dependency withProp(final Dependency dep){ return new Dependency(){ public Object getProperty(Object k, Class type){ if(k.equals(key)){ checkTypeMatch(type, prop); return prop.create(dep); } else return dep.getProperty(k, type); } } ... } } |
java代ç : |
interface Map{ Object map(Object obj); } |
java代ç : |
class MapComponent implements Component{ private final Component c; private final Map map; public Class getType(){ return null; } public Object create(Dependency dep){ return map.map(c.create(dep)); } public Class verify(Dependency dep){ c.verify(dep); return Object.class; } ... } |
java代ç : |
interface Binder{ Component bind(Object obj); } |
java代ç : |
class BoundComponent implements Component{ private final Component c; private final Binder binder; public Class getType(){ return null; } public Object create(Dependency dep){ return binder.bind(c.create(dep)).create(dep); } public Class verify(Dependency dep){ c.verify(dep); return Object.class; } ... } |
java代ç : |
map(a, f) = bind (a, \x->value(f(x))); |
java代ç : |
return new ValueComponent(map.map(v)); |
java代ç : |
class UseKey extends Component{ private final Object key; public Object create(Dependency dep){ //????????? } .... } |
java代ç : |
interface Dependency{ Object getArgument(int i, Class type); Object getProperty(Object key, Class type); Container getContainer(); } |
java代ç : |
Container.getInstance(Object key); |
java代ç : |
class UseKey extends Component{ private final Object key; public Object create(Dependency dep){ final Component c = dep.getContainer().getComponent(key); if(c==null)throw new ComponentNotFoundException(...); return c.create(dep); } .... } |
java代ç : |
interface ParameterBinder{ Component bind(int i, Class type); } |
java代ç : |
class ParameterBoundDependency implements Dependency{ private final Dependency dep; private final ParameterBinder binder; public Object getArgument(int i, Class type){ return binder.bind(i, type).create(dep); } ... } |
java代ç : |
ParameterBoundComponent extends Component{ private final Component c; private final ParameterBinder binder; public Object create(Dependency dep){ return c.create(new ParameterBoundDependency(dep, binder)); } ... } |
java代ç : |
Component x = ...; Component x2 = x.bind(new ParameterBinder(){ public Component bind(int i, Class type){ if(type.equals(A.class)){ return Components.useKey("a1"); } else{ //???? è¡? } } }); |
java代ç : |
Component x = ...; Component x2 = x.bind(new ParameterBinder(){ public Component bind(int i, Class type){ if(type.equals(A.class)){ return Components.useKey("a1"); } else{ return Components.useArgument(i, type);// è¡? } } }); |
java代ç : |
class UseArgument extends Component{ private final int i; private final Class type; public Object create(Dependency dep){ return dep.getArgument(i, type); } ..... } |
java代ç : |
Component withArgument(Component c, final int i, final Component arg){ return c.bind(new ParameterBinder(){ public Component bind(int k, Class type){ if(k==i) return arg; else return Components.useArgument(k, type); } }); } |
java代ç : |
c.withArguments(new Component[]{c1, c2, c3}); |
java代ç : |
Component withArguments(final Component[] args){ return bind(new ParameterBinder(){ public Component bind(int i, Class type){ return args[i]; } }); } |
java代ç : |
new ClassX(..., Loggers.instance(ClassX.class), ...); |
java代ç : |
interface Factory{ String create(); } class PrefixLogger implements Logger{ private final Logger logger; private final Factory factory; private boolean freshline = true; private void prefix(int lvl){ if(freshline){ Object r = factory.create(); if(r!=null) logger.print(lvl, r); freshline = false; } } public void print(int lvl, String s){ prefix(lvl); logger.print(lvl, s); } public void println(int lvl, String s){ prefix(lvl); logger.println(lvl, s); freshline = true; } public void printException(int lvl, Throwable e){ prefix(lvl); logger.printException(lvl, e); freshline = true; } } |
java代ç : |
class TimestampFactory implements Factory{ private final DateFormat fmt; public String create(){ return fmt.format(new Date()); } } |
java代ç : |
interface SourceLocationFormat{ String format(StackTraceElement frame); } class TraceBackFactory implements Factory{ private final SourceLocationFormat fmt; public String create(){ final StackTraceElement frame = getNearestUserFrame(); if(frame!=null) return fmt.format(frame); else return null; } private StackTraceElement getNearestUserFrame(){ final StackTraceElement[] frames = new Throwable().getStackTrace(); foreach(frame: frames){ if(!frame.getClassName().startsWith("org.mylogging")){ //user frame return frame; } } return null; } } |
java代ç : |
class ReturnFactory implements Factory{ private final String s; public String create(){return s;} } |
java代ç : |
class ConcatFactory implements Factory{ private final Factory[] fs; public String create(){ StringBuffer buf = new StringBuffer(); foreach(f: fs){ buf.append(f.create()); } return buf.toString(); } } |
java代ç : |
Logger myprefix(Logger l){ Factory timestamp = new TimestampFactory(some_date_format); Factory traceback = new TraceBackFactory(some_location_format); Factory both = new ConcatFactory( timestamp, new ReturnFactory(" - "), traceback, new ReturnFactory(" : ") ); return new PrefixLogger(both, l); } |
java代ç : |
class Boy{ private final Girl girl; public Boy(Girl g){ this.girl = g; } ... } |
java代ç : |
picocontainer container = new DefaultContainer(); container.registerComponentImplementation(Boy.class); container.registerComponentImplementation(Girl.class); |
java代ç : |
Object obj = container.getComponentInstance(Boy.class); |
java代ç : |
void A createA(){ B b = new B(); return new A(b,b); } |
java代ç : |
container.registerComponent("b" new CachingComponentAdapter(new ConstructorInjectionComponentAdapter(B.class))); container.registerComponent("a", new ConstructorInjectionComponentAdapter(A.class)); |
java代ç : |
A createA(){ B b = new B(); return new A(b, b.createC(x_component)); } |
java代ç : |
b_component = Components.ctor(B.class).singleton(); a_component = Components.ctor(A.class) .withArgument(0, b_component) .withArgument(1, b_component.method("createC")); |
java代ç : |
if level > 1 then logger1 else logger2 |
java代ç : |
ignore(1, logger1, logger2); |
java代ç : |
Logger err_log = writer(err_writer); Logger warning_log = writer(warning_writer); Logger info_log = writer(info_writer); |
java代ç : |
err_log = filter(ERROR, err_log, nop()); warning_log = filter(WARNING, warning_log, nop()); info_log = filter(INFO, info_log, nop()); |
java代ç : |
Logger logger = sequence(err_log, warning_log, info_log); |
java代ç : |
logger = timestamp(logger); |
java代ç : |
Logger std_logger = writer(new PrintWriter(System.err)); std_logger = ignore(ERROR, std_logger); logger = sequence(std_logger, logger); |
java代ç : |
PrintWriter out = new PrintWriter(System.err); std_logger = new ErrorMessageLogger(out, writer(out)); std_logger = ignore(ERROR, std_logger, nop()); |
java代ç : |
std_logger = ignore(WARNING, std_logger, nop()); |
java代ç : |
logger = ignore(some_level, logger, nop()); |
java代ç : |
final Logger err_logger = new ErrorMessageLogger(writer); final Logger jaskell_logger = new JaskellExceptionLogger(writer, err_logger); final Logger neptune_logger = new NeptuneExceptionLogger(writer, jaskell_logger); return neptune_logger; |
java代ç : |
public class StreamLogger { private final OutputStream out; /** * To create a StreamLogger object. * @param out the OutputStream object that the log message should go to. */ public StreamLogger(OutputStream out) { this.out = out; } /** * To get the OutputStream that the log messages should go to. */ public OutputStream getStream() { return out; } private static Logger getBaseLogger(PrintWriter writer){ final Logger nop = new NopLogger(); final Logger base = Loggers.logger(writer); final Logger neptune_logger = new NeptuneExceptionLogger(writer, nop); final Logger jaskell_logger = new JaskellExceptionLogger(writer, nop); return Loggers.sequence( new Logger[]{neptune_logger, jaskell_logger, base} ); } private static Logger getEchoLogger(PrintWriter writer){ return new ErrorMessageLogger(writer); } private static Logger getErrorLogger(PrintWriter writer){ final Logger err_logger = new ErrorMessageLogger(writer); final Logger jaskell_logger = new JaskellExceptionLogger(writer, err_logger); final Logger neptune_logger = new NeptuneExceptionLogger(writer, jaskell_logger); return neptune_logger; } /** * Get the Logger instance. * @param min_level the minimal critical level for a log message to show up in the log. * @return the Logger instance. */ public Logger getDefaultLogger(int min_level){ final PrintWriter writer = new PrintWriter(out, true); final PrintWriter err = new PrintWriter(System.err, true); final PrintWriter warn = new PrintWriter(System.out, true); final Logger all = Loggers.sequence(new Logger[]{ Loggers.ignore(getErrorLogger(err), Logger.ERROR), Loggers.filter(getEchoLogger(warn), Logger.WARNING), getBaseLogger(writer) } ); return Loggers.ignore(all, min_level); } } |
java代ç : |
all_logger = ignore messages below ERROR for getErrorLogger(err); filter messages except WARNING for getEchoLogger(warn); baseBaseLogger(writer); ignore messages below lvl for all_logger; |