PlanetJava

I've posted the May 09 GlassFish Adoption Report. Some growth from April 09, but not back to the March 09 peak; probably some seasonal drop, possibly some impact from the Oracle announcement. The full report includes the usual download data for run-time and tools bundles, a comparison with JBoss downloads, GeoMap, Registration and Update Center.

I expect to post the June report next week.

The title about says it; both kinds of purple are flowers.

The little ones are a ground-cover recommended by a professional gardener for our front yard; since the kids play out back, we don’t want to be defending a grass lawn from moss and creeping buttercup and dandelions and all the other enemies. This stuff just spreads out and covers up and you can walk on it a bit while you’re gardening. Don’t know what it’s called.

Don’t know what the larger purple flowers are either.

We’re working on a fairly substantial revision of the Sun Cloud API, motivated by this problem: In a RESTful context, how do you handle state-changing operations (POST, PUT, DELETE) which have substantial and unpredictable latency?

What we’ve learned, from work with our own back-end based on the Q-layer technology and with some other back-ends, is that Cloud operations are by and large not very fast; and that the latencies show up in weird places. Here’s an example: in our own implementation, creating a Virtual Machine from a template or by copying another VM instance is very snappy. But weirdly, connecting a network (public or private) to a VM can sometimes be extremely slow. Go check out other implementations like EC2 and you see a similar unpredictable-latency narrative.

The idiom we’d been using so far was along these lines:

• As with both AtomPub and Rails, when you want to create something new you POST it to a collection of some sort and the server comes back with “201 Created” and the URI of the new object.

• When you POST to some controller (for example “boot a machine”) or do a DELETE, the server comes back with “204 No content” to signal success.

This is all very well and good; but what happens when some of these operations take a handful of milliseconds and others (e.g. “boot all the VMs in this cluster”) could easily go away for several minutes.

The current thinking is evolving in the Project Kenai forums, and was started up by Craig McLanahan in PROPOSAL: Handling Asynchronous Operation Requests. Check it out, and put your oar in if you have something better in mind.

To summarize: For any and all PUT/POST/DELETE operations, we return “202 In progress” and a new “Status” resource, which contains a 0-to-100 progress indicator, a target_uri for whatever’s being operated on, an op to identify the operation, and, when progress reaches 100, status and message fields to tell how the operation came out. The idea is that this is designed to give a hook that implementors can make cheap to poll.

We also thought about a Comet style implementation where we keep the HTTP channel open, and that can be made clean but support for it in popular libraries is less than ubiquitous. My personal favorite idea was to use “Web hooks”, i.e. the client sends a URI along with the request and the server POSTs back to it when the operation is complete. But every time I started talking about it I ran into a brick wall because it probably doesn’t work for a client behind a firewall, which is where most of them will be. Sigh.

There are a few points that are still troubling me, listed here in no particular order:

• When an operation is finished and you want to provide a Status code, we’re re-using HTTP status codes. Which on the one hand seems a bit outside their design space, but on the other hand maybe it’s a wheel we don’t have to re-invent.

• Instead of having the “op” field, we could have a different media-type for each imaginable kind of Status resource. That might be a bit more RESTful but seems a less convenient to use for client implementors.

• This whole notion of the target_uri makes me wonder if we’re missing a generalization. The most obvious role is when the Status is that of a create operation, for example Create New VM; then the target_uri is the new resource’s URI, what would come back in the Location HTTP header in a synchronous world.

  And in a few cases you might want more than one target, for example when you’re attaching an IP address to a VM.

  Hmmm.

• Speaking of generalization, I wonder if this whole “Slow REST” thingie is a pattern that’s going to pop up again often enough in the future that we should be thinking of a standardized recipe for approaching it; the kind of thing that has arisen for CRUD operations in the context of AtomPub and Rails.

What do you think?

• Patterns and Best Practices for Dynamic OSGi Applications (pdf)

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.

I was editing some pictures (which I organize per-month) and realized that there were a ton in the June folder that I’d been meaning to run, and now it’s not June. So let’s populate the first few days of July with some of ’em. First, musical faces of Car-Free Vancouver Day.

The first is self-explanatory.

The second is a few blocks north; DRMHLLR, a spacey sort of jam band, was playing really loud. I was pushing my little toddlergirl and she’s usually pretty sensitive, always telling me to turn down the rock & roll in the car. But as we rolled up she seemed fascinated, so I bashed a couple of bystanders with the stroller to get a front-row spot. She just leaned back and went with the groove; I have high hopes for the girl.

That Car-Free day, it’s OK by me. This is on Main and there were thousands and thousands of people there; interesting shopping, good eats, cool beats, and fun people to look at.

The glass on that parchment had broken in transit, so I’d dropped it off at a framing shop on Main for repairs. I wheeled my ice-cream-stained daughter out of the crowd into the shop, and he told me he’d done a huge amount of walk-in business and spent the rest of the day enjoying the show. What’s not to like? Can we do this every month in the summer?

• 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/

Recently, Vancouver’s City Council passed an “Open Data, Open Source” motion. I was too busy at the time to pay much attention, which I’ve regretted. Now I’ve started poking around a bit, and turned up an interesting person and an outstanding example.

Open Garbage Data

No, I’m not kidding. This idea was recently floated by David Eaves in How Open Data even makes Garbage collection sexier, easier and cheaper. Seriously; take a moment and read it. If there’s low-hanging fruit in garbage collection [Watch those metaphors. -Ed.] it’s hard not to get excited over what you could build on the raw data about housing and zoning and licensing and traffic and all the other intensely-local things a city has its hands on.

I’ve always liked opening up data resources and have spent my career building technology to support this, but for me this is a powerful abstraction-free “Hello World” example of why.

Meeting David

By an odd coincidence, I already had a date to meet David Eaves, the guy who wrote that piece. He’d come across my radar as one of the people doing work on that Open Everything resolution and then he published a blog piece saying “Who are the people that read this?” and I’d dropped him a note saying “I’m an Internet guy who likes what the city’s doing, wondering if I can help”, so we had coffee.

He doesn’t actually work for the City, but he’s an activist with Vision Vancouver, the municipal sort-of-political-party that currently holds a majority on council. They’re not perfect, but they seem, on balance, level-headed and smart.

David has lots of ideas about other good things that could be accomplished by opening up this data source or that, and it all seems affordable. I was pleasantly surprised to discover that there’s not much in the way of organized opposition. I imagine the city’s IT department is grumbling about unasked-for extra work, which is fair, but it shouldn’t be that painful.

The thinking seems to be along these lines:

• Publish the data in a usable form.

• License it in a way that turns people loose to do whatever they want, but doesn’t create unreasonable liability risk for the city.

• See what happens. Nobody’s smart enough to predict what combination of private-business and community-activist players will use it, or what they’ll use it for. If nobody does, well, it didn’t cost much to try.

Vancouver’s not alone; apparently Washington DC, of all places, is the world leader in doing this; also some West Coast cities including San Francisco are making good progress.

Going Local

Me, I’ve spent the last few decades starting businesses and trying to improve the Internet. I’ve been well-rewarded for doing it and I have few regrets. But I’m increasingly getting an urge to pitch in and give back at a local level, if I can find somewhere I’d be useful.

I’m not sure where that is. But as a first step, I’m joining Vision Vancouver; the first political party I’ve been a member of since the early Eighties.

I still moderate all the comments here, but the setup is idiosyncratic enough that hardly any spam gets through. Today, I’m pondering one particular comment, wondering whether to approve.

The comment is to Kindle Yourself, about how you can buy the contents of this blog for $1.99 a month on your Kindle. It says:

From: Wendy

As much as I love to read - especially blogs - I don't think it would be feasible for most people to subscribe to 5 or 6 blogs for that price. Not in this economy. But it's a great idea and I would gladly do it for some of the top daily newspapers.

Sensible enough. As I often do, since I care who reads this, I clicked on the “Wendy” link and it took me to wendycarlisle.com. While at first glance this is a vanilla blog, something about it bothered me; also, I was pretty sure I’d seen this movie before; comments from other blogs that somehow, in some intangible way I couldn’t put a finger on, felt like this one.

A bit of poking around increased my discomfort. First, there’s the blog’s “Disclosure Policy”, a graphic of some text (?!) from which I excerpt:

This blog is a personal blog written and edited by me. For questions about this blog, please contact <gmail address elided>.

This blog accepts forms of cash advertising, sponsorship, paid insertions or other forms of compensation... the owner(s) of this blog is compensated to provide opinion on products, services, websites, and various other topics. Even though the owner(s) of this blog receives compensation for or posts or advertisements, we always give our honest opinions, findings, beliefs, or experiences on those topics or products...

Hmm, well, OK, I guess.

Then I glanced at the blogroll. All linked by first name, all hosted at URLs of the form FirstnameLastname.com. All sounding like they were written by real people living in real places, but theme-free and passion-free. All with what looked like bits of product placement. All WordPress. Most but not all of the domain names registered by AC Merchandising LLC.

So, yep, I’m pretty sure this is a new (to me) form of, uh... what? Spam? I’m not sure. It seems there are some real people in the system writing these blogs? Innocent folk looking to make a few extra bucks? A small staff each emulating a bunch of these people?

Anyhow, I don’t think I’m going to approve the comment. Wendy, if you’re a real person, I apologize.

My CommunityOne 2009 presentation is now available online.

As part of the Eclipse Galileo release, we updated all of our training courses to reflect the latest release:

• Eclipse RCP Development (4 Days)
• Eclipse RCP Advanced Topics (3 Days)
• OSGi and Equinox (3 Days)
• OSGi and Equinox Primer (1 Day)
• RAP for Java Developers (4 Days)
• RAP for RCP Developers (2 Days)

We have also added two new courses to cover two popular topics, Equinox p2 and migrating to Galileo RCP:

• Provisioning Eclipse and OSGi systems with p2 (2 days)
• Migrating to Galileo RCP (2 days)

We are also offering our courses online now. If you’re interested in any of these courses, please email us.

The Setting

1. migrate the grammar
2. adapt the M2M-transformation
3. adapt client code which uses the model and the Xtext API

Migrating the Grammar

RuleXY: ... ( "with" with=Block)? ...

RuleXY: ... ( "with" _with=Block)? ...

Backtracking

ParameterReference: QualifiedParameterReference|SimpleParameterReference;

SimpleParameterReference: type=Type (name=ID)?;  

QualifiedParameterReference: type=Type name=ID;

ParameterReference: SimpleParameterReference|QualifiedParameterReference;

SimpleParameterReference: type=Type (name=ID)?;  

QualifiedParameterReference: type=Type name=ID;

<fragment class="org.eclipse.xtext.generator.AntlrDelegatingFragment" />

<fragment class="de.itemis.xtext.antlr.XtextAntlrGeneratorFragment">

   <options k="2" backtrack="true" memoize="true"/>

</fragment>

Lexer Rules

Native INT: ('-')?('0'..'9')+ 

terminal INT: ('0'..'9')+ 

terminal FLOAT returns ecore::EFloat: ('0'..'9')*'.'('0'..'9')+;

OrmPackage missing

- WrappedException: java.lang.ClassNotFoundException: com.sun.java.xml.ns.persistence.orm.OrmPackage"

Unassigned Actions

NullLiteral: "null";

Block: "{" (statements+=BlockStatement)* "}";