If you look at the AbstractSequentialIterator class in gate.io, you’ll see that computeNext is called in the finally block of the next method.
What does that mean? You cannot reuse the previous object nor alter its value in the computeNext method.
Guava caches are great, but developing with them can be troublesome.
One solution is wrapping the underlying cache using a simple implementation of the ForwardingCache class:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
public class DevelopmentForwardingCache<K,V> extends ForwardingCache<K,V> { private Cache<K,V> delegate; private boolean debug; public DevelopmentForwardingCache ( Cache<K,V> delegate ) { this.delegate = delegate; } public DevelopmentForwardingCache<K,V> DEBUG ( ) { this.debug = true; return this; } @Override protected Cache<K, V> delegate ( ) { return this.delegate; } @Override public V get ( K key, Callable<? extends V> valueLoader ) throws ExecutionException { V ret_val = super.get(key, valueLoader); if ( debug ) invalidate(key); return ret_val; } } |
Instead of using a Cache directly from a CacheBuilder, you can wrap it with this class and toggle debug mode.
Note: if you’re using a LoadingCache, you’ll want to derive from the ForwardingLoadingCache instead and override the get(K key) and getAll(Iterable<? extends K> keys) methods as well.
Sometimes I want to search a chain of exceptions (caught->cause1->cause2…) for an exception of a particular type. This isn’t a difficult problem, but having a simple utility makes it easier:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public class SearchCausesFor<T extends Throwable> { private Class<T> target; private SearchCausesFor ( Class<T> target ) { this.target = target; } public static <T extends Throwable> SearchCausesFor<T> SEARCH ( Class<T> target ) { if ( target == null ) throw new IllegalArgumentException ( "target is null" ); return new SearchCausesFor<T> ( target ); } public T IN ( Throwable source ) { if ( source == null ) return null; if ( target == null ) throw new IllegalStateException ( "target is null" ); if ( target.isInstance( source ) ) return target.cast(source); return IN ( source.getCause() ); } } |
It’s pretty easy to use:
|
1 2 3 4 5 6 7 8 9 |
try { ... // some code that throws an exception } catch ( RootExceptionType oops ) { ExceptionTypeIWant wanted = SearchCausesFor.SEARCH(ExceptionTypeIWant.class).IN(oops); if ( wanted != null ) // do something with wanted } |
By default a org.antlr.v4.runtime.Parser instance, as a subclass of org.antlr.v4.runtime.Recognizer, will have a org.antlr.v4.runtime.ConsoleErrorListener attached to it. Error messages will be piped through this listener and out to System.err, where they will be lost forever.
You can silence this output by calling removeErrorListeners() before parsing, and if you want to capture the error messages for parsing and display, you can add a custom BaseErrorListener implementation.
Here’s a simple one that keeps every error in a List:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
public class DSLErrorListener extends BaseErrorListener { private List<SyntaxErrorItem> items; public DSLErrorListener ( ) { this.items = new ArrayList<SyntaxErrorItem>(); } @Override public void syntaxError ( Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e ) { items.add ( new SyntaxErrorItem ( line, charPositionInLine, msg, offendingSymbol, e ) ); } public boolean hasErrors ( ) { return this.items.size() > 0; } @Override public String toString ( ) { if ( !hasErrors() ) return "0 errors"; StringBuilder builder = new StringBuilder(); for ( SyntaxErrorItem s : items ) { builder.append ( String.format ( "%s\n", s ) ); } return builder.toString(); } } class SyntaxErrorItem { private int line; private Object offendingSymbol; private int column; private String msg; private RecognitionException oops; SyntaxErrorItem ( int line, int column, String msg, Object symbol, RecognitionException oops ) { this.line = line; this.column = column; this.msg = msg; this.offendingSymbol = symbol; this.oops = oops; } @Override public String toString() { if ( oops == null ) return String.format ( "[%d:%d] %s", line, column, msg ); else { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter ( sw ); oops.printStackTrace(pw); pw.close(); return String.format ( "[%d:%d] %s\n%s", line, column, msg, sw.toString() ); } } } |
You would add it to a Parser using the addErrorListener method.
Here’s a complete example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
ANTLRInputStream input = ...; Lexer lexer = ...; CommonTokenStream tokens = new CommonTokenStream ( lexer ); DSLErrorListener errorListener = new DSLErrorListener(); Parser parser = ...; parser.removeErrorListeners(); parser.addErrorListener ( errorListener ); ParseTree tree = ...; // Usually the parser subclass top-level rule name if ( errorListener.hasErrors() ) System.err.printf( "%s\n", errorListener ); // Or parse the errors: up to you else { ParseTreeWalker walker = new ParseTreeWalker(); // Walk the tree or visit it } |
It’s up on GitHub.
If you’re using an R800 on the mac for a custom application along with my CSTEventManager library, the following keycodes can be used. Don’t forget that you should configure the R800 as an ISO keyboard.
| Code Number | Description |
|---|---|
116 |
The Previous Slide button |
121 |
The Next Slide button |
96 |
Start/Stop Presentation toggle button |
47 |
Blank screen toggle button |
After reading this stackoverflow post, I thought that I would simplify it by subclassing AFHTTPRequestOperationManager and wrap all of this stuff in a new method that I called GET:parameters:success:failure:unmodified:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
@interface CSTHTTPRequestOperationManager : AFHTTPRequestOperationManager - (AFHTTPRequestOperation *)GET:(NSString *)URLString parameters:(NSDictionary *)parameters success:(void (^)(AFHTTPRequestOperation *operation, id responseObject))success failure:(void (^)(AFHTTPRequestOperation *operation, NSError *error))failure unmodified:(void (^)(AFHTTPRequestOperation *operation, id responseObject))unmodified; @end @implementation CSTHTTPRequestOperationManager +(void)initialize { if ( self == [CSTHTTPRequestOperationManager class] ) { [NSURLCache sharedURLCache]; } } - (AFHTTPRequestOperation *)GET:(NSString *)URLString parameters:(NSDictionary *)parameters success:(void (^)(AFHTTPRequestOperation *operation, id responseObject))success failure:(void (^)(AFHTTPRequestOperation *operation, NSError *error))failure unmodified:(void (^)(AFHTTPRequestOperation *operation, id responseObject))unmodified { BOOL __block responseFromCache = YES; void (^successWrapper)(AFHTTPRequestOperation *operation, id responseObject) = ^(AFHTTPRequestOperation *operation, id responseObject) { if (responseFromCache) { unmodified(operation,responseObject); } else { success(operation,responseObject); } }; NSMutableURLRequest *request = [self.requestSerializer requestWithMethod:@"GET" URLString:[[NSURL URLWithString:URLString relativeToURL:self.baseURL] absoluteString] parameters:parameters error:nil]; [request setCachePolicy:NSURLRequestReturnCacheDataElseLoad]; AFHTTPRequestOperation *operation = [self HTTPRequestOperationWithRequest:request success:successWrapper failure:failure]; [operation setCacheResponseBlock:^NSCachedURLResponse *(NSURLConnection *connection, NSCachedURLResponse *cachedResponse) { // this will be called whenever server returns status code 200, not 304 responseFromCache = NO; return cachedResponse; }]; [self.operationQueue addOperation:operation]; return operation; } @end |
According to this other stackoverflow post, NSURLCache needs a little bit of time to warm up, so I added a class initializer. From your AppDelegate’s application:didFinishLaunchingWithOptions: method you can call this early:
|
1 |
[CSTHTTPRequestOperationManager class]; |
Using this new method is simple:
|
1 2 3 4 5 6 7 8 9 |
CSTHTTPRequestOperationManager *manager = [CSTHTTPRequestOperationManager manager]; manager.responseSerializer = [AFXMLParserResponseSerializer new]; [manager GET:URL parameters:nil success:^(AFHTTPRequestOperation *operation, id responseObject) { // HTTP 200 response } failure:^(AFHTTPRequestOperation *operation, NSError *error) { // Neither 200 nor 304 } unmodified:^(AFHTTPRequestOperation *operation, id responseObject) { // HTTP 304 response }]; |
Hopefully this will be useful for you. If you’re worried about a nil unmodified or success block, you can prefix those calls with if (unmodified) unmodified(operation,responseObject) and if (success) success(operation,responseObject).
I don’t like checking if the caller passed me a nil NSError** in my own methods, especially if the implementation is somewhat lengthy, so I’ve put together a very basic C macro that declares an autoreleasing NSError* to use as temporary storage in case of a null NSError** parameter from the caller:
|
1 2 3 |
#define ERROR(x,y) __autoreleasing NSError * y;\ x = x == NULL ? &y : x; \ *x = nil; |
Imagine that I have a method named foo that takes a single NSString* and an optional NSError**:
|
1 2 3 4 |
-(BOOL)foo:(NSString*)someString error:(NSError**)error { ERROR(error,tempError); // do the work } |
Now I don’t need to check if I’ve been passed a valid NSError** pointer, because it will be assigned to the local tempError variable if it was nil.
Sometimes I write web applications for Tomcat where I don’t want to report any errors beyond the HTTP status code. The quickest method for disabling those messages is configuring a Valve on the host section of the server.xml configuration file.
If you subclass the org.apache.catalina.valves.ErrorReportValve class (it’s in your Tomcat’s lib/catalina.jar) and override the report method like this:
|
1 2 3 4 5 6 7 8 |
public class ErrorSuppressorValve extends ErrorReportValve { protected void report(Request request, Response response, Throwable throwable) { // Override the default behavior by doing nothing } } |
The client still receives the HTTP status code and anything already buffered, but it hides all of the automatically generated Tomcat error information.
To install it, just JAR up the class and put it in your Tomcat’s lib folder, then add the errorReportValveClass attribute to your Tomcat’s server.xml file.
I just thought I’d share something I ran across today with iOS 6 and UISwitch controls.
If you put a UISwitch in a XIB and expect the text inside of the UISwitch to appear in the right language, iOS 6 will look in your app’s (current region name).lproj for a file named (same as xib).strings.
For example, if I have a UI defined in SettingsViewController.xib, and that UI has a UISwitch, and I want a Japanese user to see that switch’s on/off in Japanese, I need to make a file named ja.lproj/SettingsViewController.strings. The strings file doesn’t need to have anything in it, but it can’t be zero length. The easiest thing to do is just throw in something like:
|
1 2 3 |
/* * Just another file. */ |
And then convert that file to a binary plist using the plutil command-line tool:
|
1 |
plutil -convert binary1 SettingsViewController.strings |
Note: don’t forget the ‘1’ in binary1. More information on man plutil.
If you’re developing exclusively within XCode 5, then I’d suggest just localizing any XIBs and let XCode do the magic for you.