grammar org.oasisopen.relaxng with org.eclipse.xtext.common.Terminals

generate relaxng "http://www.oasis-open.org/relaxng"

terminal Letter:
   ID;

terminal CHAR:
   '#x9' | '#xA' | '#xD' | ('#x20'..'#xD7FF') | ('#xE000'..'#xFFFD') | ('#x10000'..'#x10FFFF');  

terminal NewLine:
   '#xA' | '#xD' | ('#xA' '#xD');
 
terminal NameStartChar:
   ":" |
   ('A'..'Z') |
   "_" | 
   ('a'..'z') |
   ('#xC0'..'#xD6') | 
   ('#xD8'..'#xF6') | 
   ('#xF8'..'#x2FF') | 
   ('#x370'..'#x37D') | 
   ('#x37F'..'#x1FFF') | 
   ('#x200C'..'#x200D') |
   ('#x2070'..'#x218F') | 
   ('#x2C00'..'#x2FEF') |
   ('#x3001'..'#xD7FF') |
   ('#xF900'..'#xFDCF') |
   ('[#xFDF0'..'-#xFFFD') |
   ('#x10000'..'#xEFFFF');

terminal NameChar:
   NameStartChar | "-" | "." | ('0'..'9') | '#xB7' | ('#x0300'..'#x036F') | ('#x203F'..'#x2040');

Model :
   (elements += TopLevel);

TopLevel:
   Decl* (Pattern | GrammarContent*);
    
Decl:
   'namespace' (IdentifierOrKeyWord '=' NamespaceURILiteral) |
   'default' 'namespace' (IdentifierOrKeyWord) '=' NamespaceURILiteral |
   'datatypes' IdentifierOrKeyWord '=' Literal;

Pattern:
   'element' NameClass '{' Pattern '}' |
   'attribute' NameClass '{' Pattern '}' |
   Pattern (',' Pattern)+ |
   Pattern ('&' Pattern)+ |
   Pattern ('|' Pattern)+ |
   Pattern '?' |
   Pattern '*' |
   Pattern '+' |
   'list' '{' Pattern '}' |
   'mixed' '{' Pattern '}' |
   Identifier |
   'parent' Identifier |
   'empty' |
   'text' |
   (DataTypeName) DataTypeValue |
   DataTypeName ('{' Param* '}') (ExceptPattern) |
   'notAllowed' |
   'external' AnyURILiteral (Inherit) |
   'grammar' '{' GrammarContent* '}' |
   '(' Pattern ')';
   
Param:
   IdentifierOrKeyWord '=' Literal;

ExceptPattern:
   '-' Pattern;

GrammarContent:
   Start | Define |
   'div' '{' GrammarContent* '}' |
   'include' AnyURILiteral (Inherit) ('{' IncludeContent* '}');

IncludeContent:
   Define | Start |
   'div' '{' GrammarContent* '}';

Start:
   'start' AssignedMethod Pattern;

Define:
   Identifier AssignedMethod Pattern;

AssignMethod:
   '=' |
   '|=' |
   '&=';

NameClass:
   Name |
   NsName (ExceptClassName) |
   AnyName (ExceptClassName) |
   NameClass '|' NameClass |
   '(' NameClass ')';

Name:
   IdentiferOrKeyWord | CName;

ExceptNameClass:
   '-' NameClass;

DataTypeName:
   CName |
   'string' |
   'token';

DataTypeValue:
   Literal;

AnyURILiteral:
   Literal;

NamespaceURILiteral:
   Literal | 'inherit';

Inherit:
   'inherit' '=' IdentifierOrKeyWord;

IdentifierOrKeyWord:
   Identifier | KeyWord;


Identifier:
   (NCName .. KeyWord) |
   QuotedIdentifier;


CName:
   NCName ':' NCName;

NsName:
   NCName ':*';

AnyName:
   '*';

Literal:
   LiteralSegment ('~' LiteralSegment)+;

LiteralSegment:
   '"' (CHAR .. ('"' | NewLine))* '"' |
   "'" (CHAR .. ("'" | Newline))* "'" |
   '"""' (('"') ('"') (CHAR .. '"'))* '"""';

KeyWord:
   "attribute"
   | "default"
   | "datatypes"
   | "div"
   | "element"
   | "empty"
   | "external"
   | "grammar"
   | "include"
   | "inherit"
   | "list"
   | "mixed"
   | "namespace"
   | "notAllowed"
   | "parent"
   | "start"
   | "string"
   | "text"
   | "token";

NCName:
   NCNameStartChar NCNameChar*; /* An XML Name, minus the ":" */
    
NCNameChar:
   NameChar - ':';
    
NCNameStartChar:
   Letter | '_';
    
Name:
   NameStartChar (NameChar)*;
    
Names:
   Name ('#x20' Name)*;
    
Nmtoken:
   (NameChar)+;
    
Nmtokens:
   Nmtoken ('#x20' Nmtoken)*;

QuotedIdentifier:
    '\' NCName;

import "platform:/resource/my.project/src/othermodel.dsl"

//.. refer to elements from othermodel.dsl

<extension point="org.eclipse.emf.index.indexer">
<indexer class="org.eclipse.xtext.example.DomainmodelExecutableExtensionFactory
                  :org.eclipse.xtext.index.DefaultDeclarativeResourceIndexer"
            fileextensions="dmodel"/>
</extension>

String qualifiedName(MyType foo) {
  // compute different qualified name for MyTypes
  // ...
}

public IndexStore bindIndexStore() {
 return EmfIndexUIPlugin.getDefault().getIndexStore();
}

@Inject
private IndexStore store;

public IndexStore bindIndexStore() {
 return new PersistableIndexStore();
}
  
@Override
public Class bindIScopeProvider() {
 return DefaultIndexBasedScopeProvider.class;
}

import java.util.Set;

package foo {
  import bar.Foo
  entity Bar extends Foo {
  }
}

package bar {
  entity Foo {}
}

package bar {
  entity Bar extends Foo {}
  entity Foo {}
}

package bar {
  entity Bar extends bar.Foo {}
  entity Foo {}
}

I like portable software. I carry around a bunch of them in my flash drive. I just found out that both Java and Eclipse are available as portable versions at PortableApps.com. The Java version they have is Java 6 update 14 but Eclipse is stuck at 3.4.2.

Eclipse uses portable Java, so Java need not be installed in the PC to run it. Nice. The portable version has some trouble finding the workspace but once you correct the path it works fine.

I updated the Eclipse binaries in to the just released 3.5 and it work great too. Nice way to take Eclipse and your work with you.

Related posts:

1. Eclipse Tip: Keeping plugins and workspace separate
2. Eclipse Tip: Java Editor Breadcrumb Navigation Bar
3. Eclipse Tip: Sharing Java project settings
4. Eclipse Tip: Grouping Java Problems
5. Java rides on Google App Engine

Jetty-6 Continuations introduced the concept of asynchronous servlets to provide scalability and quality of service to web 2.0 applications such as chat, collaborative editing, price publishing, as well as powering HTTP based frameworks like cometd, apache camel, openfire XMPP and flex BlazeDS.

With the introduction of similar  asynchronous features in Servlet-3.0, some have suggested that the Continuation API would be deprecated.  Instead, the Continuation API has been updated to provide a simplified portability run asynchronously on any servlet 3.0 container as well as on Jetty (6,7 & 8).  Continuations will work synchronously (blocking) on any 2.5 servlet container. Thus programming to the Continuations API allows your application to achieve asynchronicity today without waiting for the release of stable 3.0 containers (and needing to upgrade all your associated infrastructure).

Continuation Improvements

The old continuation API threw an exception when the continuation was suspended, so that the thread to exit the service method of the servlet/filter. This caused a potential race condition as a continuation would need to be registered with the asynchronous service before the suspend, so that service could do a resume before the actual suspend, unless a common mutex was used.  

Also, the old continuation API had a waiting continuation that would work on non-jetty servers.  However the behaviour of this the waiting continuation was a little different to the normal continuation, so code had to be carefully written to work for both.

The new continuation API does not throw an exception from suspend, so the continuation can be suspended before it is registered with any services and the mutex is no longer needed. With the use of a ContinuationFilter for non asynchronous containers, the continuation will now behaive identically in all servers.

Continuations and Servlet 3.0

The servlet 3.0 asynchronous API introduced some additional asynchronous features not supported by jetty 6 continuations, including:

While powerful, these additional features may also be very complicated and confusing. Thus the new Continuation API has cherry picked the good ideas and represents a good compromise between power and complexity.  The servlet 3.0 features adopted are:

Using The Continuation API

The new continuation API is available in Jetty-7 and is not expected to significantly change in future releases.  Also the continuation library is intended to be deployed in WEB-INF/lib and is portable.  Thus the jetty-7 continuation jar will work asynchronously when deployed in jetty-6, jetty-7, jetty-8 or any servlet 3.0 container.

Obtaining a Continuation

    Continuation continuation = ContinuationSupport.getContinuation(request);

Suspending a Request

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
    ...
    continuation.suspend();
    ...
  }

Once a request is suspended, the continuation should be registered with an asynchronous service so that it may be used by an asynchronous callback once the waited for event happens.

The request will be suspended until either continuation.resume() or continuation.complete() is called. If neither is called then the continuation will timeout after a default period or a time set before the suspend by a call to continuation.setTimeout(long). If no timeout listeners resume or complete the continuation, then the continuation is resumed with continuation.isExpired() true. There is a variation of suspend for use with request wrappers and the complete lifecycle (see below):

    continuation.suspend(response);

Resuming a Request

  void myAsyncCallback(Object results)
  {
    continuation.setAttribute("results",results);
    continuation.resume();
  }

Continuation resume is analogous to Servlet 3.0 AsyncContext.dispatch().

Completing Request

  void myAsyncCallback(Object results)
  {
    writeResults(continuation.getServletResponse(),results);
    continuation.complete();
  }

Continuation resume is analogous to Servlet 3.0 AsyncContext.complete().

Continuation Listeners

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
    ...
    
    Continuation continuation = ContinuationSupport.getContinuation(request);
    continuation.addContinuationListener(new ContinuationListener()
    {
      public void onTimeout(Continuation continuation) { ... }
      public void onComplete(Continuation continuation) { ... }
    });
    
    continuation.suspend();
    ...
  }

Continuation listeners are analogous to Servlet 3.0 AsyncListeners.

Continuation Patterns

Suspend Resume Pattern

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
     // if we need to get asynchronous results
     Object results = request.getAttribute("results);
     if (results==null)
     {
       final Continuation continuation = ContinuationSupport.getContinuation(request);
       
       // if this is not a timeout
       if (continuation.isExpired())
       {
         sendMyTimeoutResponse(response);
         return;
       }
       
       // suspend the request
       continuation.suspend(); // always suspend before registration
       
       // register with async service.  The code here will depend on the
       // the service used (see Jetty HttpClient for example)
       myAsyncHandler.register(new MyHandler()
       {
          public void onMyEvent(Object result)
          {
            continuation.setAttribute("results",results);
            continuation.resume();
          }
       });
       return; // or continuation.undispatch();
     }
     
     // Send the results
     sendMyResultResponse(response,results);
   }    

Suspend Continue Pattern

  void doGet(HttpServletRequest request, HttpServletResponse response)
  {
     final Continuation continuation = ContinuationSupport.getContinuation(request);
     
     // if this is not a timeout
     if (continuation.isExpired())
     {
       sendMyTimeoutResponse(request,response);
       return;
     }
     
     // suspend the request
     continuation.suspend(response); // response may be wrapped.
     
     // register with async service.  The code here will depend on the
     // the service used (see Jetty HttpClient for example)
     myAsyncHandler.register(new MyHandler()
     {
       public void onMyEvent(Object result)
       {
         sendMyResultResponse(continuation.getServletResponse(),results);
         continuation.complete();
       }
     });
   }    

This style is very good when the response does not needs the facilities of the servlet container (eg it does not use a web framework) and if an event will resume only one continuation. If many responses are to be sent (eg a chat room), then writing one response may block and cause a DOS on the other responses.

Continuation Examples

Chat Servlet

Quality of Service Filter

If too many requests are received, the extra requests wait for a short time on a semaphore, before being suspended. As requests within the filter return, they use a priority queue to resume the suspended requests. This allows your authenticated or priority users to get a better share of your servers resources when the machine is under load.

Denial of Service Filter

Proxy Servlet

Gzip Filter

The jetty GzipFilter is a filter that implements dynamic compression by wrapping the response objects. This filter has been enhanced to understand continuations, so that if a request is suspended in suspend/complete style and the wrapped response is passed to the asynchronous handler, then a ContinuationListener is used to finish the wrapped response. This allows the GzipFilter to work with the asynchronous ProxyServlet and to compress the proxied responses.

Where do you get it?

You can read about it, or download it with jetty or include it in your maven project like this pom.xml.

• A friend of mine just realized that his ex installed a key logger on his computer. Damn, that's pretty hard-core. #
• I'm fat, and apparently, so are you! bit.ly/Tn6wZ #
• Erik's Tumbles - Outloud “We Run” bit.ly/zap38 #
• Getting dinner. Yum. - Photo: bkite.com/098vl #
• No contingencies for Bubbles (bit.ly/3TS4bY) in Michael Jackson's last will. So sad. bit.ly/RfvQf #
• Just got done washing the car. Simple green car wash rules. #
• Getting a late dinner around here is close to impossible. 24hrs McDonald's is closed for cleaning. Denny's grill is shutting down in 20mins. #

VirtualBox 3.0, is now available for download. This is a major release (PR), most notable is support for guest SMP support - up to 32 vCPUs. Also included is support for OpenGL 2.0 for Windows, Linux and Solaris guests and experimental support for Direct3D 8/9 on Windows guests. Check the Changelog Details and then go to download page.

Andy has a nice Overview and Podcast; Jeff has an overview focused on Virtual SMP Support. Other Sun reviews come from Rudolf and Homer. Non-Sun reviews include Softpedia, Virtualization Review and an early mention in InfoWeek.

The ZDnet/CNet folks have several reviews on VirtualBox and seem increasingly positive about it - see Jason Perlow's Very Positive Review (earlier last year he had written a V12N Comparison based on VBox 1.6) and Dan Kusnetzky Review; also see their Screenshot Gallery. On the CNetTV, check Tom Merritt's story on Installing Windows 7 RC on VBox.

Finally, this is a very interesting release and I believe it will make a big difference in applicability of VirtualBox, but all major releases "push the envelope" a bit. I'm not in the VirtualBox team but, based on their Release History I'd expect follow-up maintenance releases "soon".

http://download.eclipse.org/technology/epp/packages/galileo/