package org.apache.beehive.controls.runtime.generator;
/*
* Copyright 2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* $Header:$
*/
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.io.IOException;
import java.io.Writer;
import com.sun.mirror.apt.Filer;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.TypeMirror;
import com.sun.mirror.type.ClassType;
import org.apache.beehive.controls.api.events.EventHandler;
import org.apache.beehive.controls.runtime.generator.apt.TwoPhaseAnnotationProcessor;
/**
* The AptControlClient class contains metadata about a class that contains nested control
* references (AptControlField).
*/
public class AptControlClient extends AptType implements Generator
{
/**
* Constructs a new ControlClient instance where information is derived
* from APT metadata
* @param decl the annotated declaration
*/
public AptControlClient(Declaration decl, TwoPhaseAnnotationProcessor ap)
{
_ap = ap;
if (! (decl instanceof ClassDeclaration))
{
_ap.printError( decl, "control.illegal.usage" );
return;
}
_clientDecl = (ClassDeclaration)decl;
setDeclaration(_clientDecl);
_controls = initControls();
initEventAdaptors();
//
// Construct a new initializer class from this implementation class
//
_init = new ClientInitializer(this);
}
/**
* Returns true if this type of client requires that nested controls have unique identifiers
*/
protected boolean needsUniqueID()
{
//
// BUGBUG:
// Pageflows need to have a more unique ID generated for fields, because multiple pageflows
// may be shared within a single ControlContainerContext, and just using the field name could
// result in collisions. A better (and less hard-wired) approach is needed than searching for
// specific annotations. Perhaps a model that enables particular client types to subclass
// AptControlClient and override getID() would be much better.
//
for (AnnotationMirror annotMirror : _clientDecl.getAnnotationMirrors())
{
String annotType = annotMirror.getAnnotationType().toString();
if (annotType.equals("org.apache.beehive.netui.pageflow.annotations.Jpf.Controller") ||
annotType.equals("org.apache.beehive.netui.pageflow.annotations.Jpf.Backing"))
return true;
}
return false;
}
/**
* Returns a unique ID for a control field
*/
public String getID(AptControlField control)
{
if (!needsUniqueID())
return "\"" + control.getName() + "\"";
return "client.getClass() + \"@\" + client.hashCode() + \"." + control.getName() + "\"";
}
/**
* Returns the list of ControlFields declared directly by this ControlImpl
*/
public ArrayList<AptControlField> getControls() { return _controls; }
/**
* Returns true if the implemenation class contains any nested controls
*/
public boolean hasControls() { return _controls.size() != 0; }
/**
* Returns true if the control client needs field initialization support
*/
public boolean needsFieldInit()
{
return hasControls();
}
/**
* Returns the field with the specified name
*/
public AptField getField(String name)
{
for (AptField field : _controls)
if (field.getName().equals(name))
return field;
return null;
}
/**
* Returns the list of fully qualified class names for types that are derived
* from this Generator
*/
public String [] getGeneratedTypes()
{
return new String [] { _init.getClassName() };
}
/**
* Returns the information necessary to generate a ImplInitializer from this
* ControlImplementation.
*/
public List<GeneratorOutput> getCheckOutput(Filer filer) throws IOException
{
return null;
}
/**
* Returns the information necessary to generate a ClientInitializer from this control
*/
public List<GeneratorOutput> getGenerateOutput(Filer filer) throws IOException
{
HashMap<String,Object> map = new HashMap<String,Object>();
map.put("client", this); // control client
map.put("init", _init); // control client initializer
Writer writer = new IndentingWriter(filer.createSourceFile(_init.getClassName()));
GeneratorOutput genOut =
new GeneratorOutput(writer,"org/apache/beehive/controls/runtime/generator/ClientInitializer.vm",
map);
ArrayList<GeneratorOutput> genList = new ArrayList<GeneratorOutput>(1);
genList.add(genOut);
return genList;
}
/**
* Initializes the list of ControlFields declared directly by this ControlClient
*/
protected ArrayList<AptControlField> initControls()
{
ArrayList<AptControlField> controls = new ArrayList<AptControlField>();
if ( _clientDecl == null || _clientDecl.getFields() == null )
return controls;
Collection<FieldDeclaration> declaredFields = _clientDecl.getFields();
for (FieldDeclaration fieldDecl : declaredFields)
{
if (fieldDecl.getAnnotation(org.apache.beehive.controls.api.bean.Control.class) != null)
controls.add(new AptControlField(this, fieldDecl, _ap));
}
return controls;
}
public boolean hasSuperClient()
{
return ( getSuperClientName() != null );
}
/**
* Returns the fully qualified classname of the closest control client in the inheritance chain.
* @return class name of the closest control client
*/
public String getSuperClientName()
{
ClassType superType = _clientDecl.getSuperclass();
while ( superType != null )
{
ClassDeclaration superDecl = superType.getDeclaration();
Collection<FieldDeclaration> declaredFields = superDecl.getFields();
for (FieldDeclaration fieldDecl : declaredFields)
{
if (fieldDecl.getAnnotation(org.apache.beehive.controls.api.bean.Control.class) != null)
{
// Found an @control annotated field, so return this class name
return superDecl.getQualifiedName();
}
}
superType = superType.getSuperclass();
}
return null;
}
/**
* Returns the super class for this class
*/
public AptControlClient getSuperClass() { return null; }
/**
* Initializes the list of EventAdaptors for this ControlImpl
*/
protected void initEventAdaptors()
{
if ( _clientDecl == null || _clientDecl.getMethods() == null )
return;
for (MethodDeclaration clientMethod : _clientDecl.getMethods())
{
//
// Do a quick check for the presence of the EventHandler annotation on methods
//
if (clientMethod.getAnnotation(EventHandler.class) == null ||
clientMethod.toString().equals("<clinit>()"))
continue;
//
// If found, we must actually read the value using an AnnotationMirror, since it
// contains a Class element (eventSet) that cannot be loaded
//
AnnotationMirror handlerMirror = null;
for (AnnotationMirror annot : clientMethod.getAnnotationMirrors())
{
if ( annot == null ||
annot.getAnnotationType() == null ||
annot.getAnnotationType().getDeclaration() == null ||
annot.getAnnotationType().getDeclaration().getQualifiedName() == null )
return;
if ( annot.getAnnotationType().getDeclaration().getQualifiedName().equals(
"org.apache.beehive.controls.api.events.EventHandler"))
{
handlerMirror = annot;
break;
}
}
if (handlerMirror == null)
{
throw new CodeGenerationException("Unable to find EventHandler annotation on " +
clientMethod);
}
AptAnnotationHelper handlerAnnot = new AptAnnotationHelper(handlerMirror);
//
// Locate the EventField based upon the field element value
//
String fieldName = (String)handlerAnnot.getObjectValue("field");
AptEventField eventField = (AptEventField)getField(fieldName);
if (eventField == null)
{
// Deliberately not issuing a diagnostic if an event handler specifies
// a field that isn't a control. Other annotation processors also
// handle event handlers, so delegate diagnostic responsibility to them.
continue;
}
//
// Locate the EventSet based upon the eventSet element value
//
TypeMirror tm = (TypeMirror)( handlerAnnot.getObjectValue("eventSet") );
if ( tm == null )
continue;
String setName = tm.toString();
AptControlInterface controlIntf = eventField.getControlInterface();
AptEventSet eventSet = controlIntf.getEventSet(setName);
if (eventSet == null)
{
_ap.printError( clientMethod, "eventhandler.eventset.not.found", setName );
continue;
}
//
// Register a new EventAdaptor for the EventSet, if none exists already
//
EventAdaptor adaptor = eventField.getEventAdaptor(eventSet);
if (adaptor == null)
{
adaptor = new EventAdaptor(eventField, eventSet);
eventField.addEventAdaptor(eventSet, adaptor);
}
//
// Locate the EventSet method based upon the eventName element value. Once
// found, add a new AptEventHandler to the adaptor for this event.
//
boolean found = false;
String eventName = (String)handlerAnnot.getObjectValue("eventName");
AptMethod handlerMethod = new AptMethod(clientMethod, _ap);
//
// Will start at the currrent event set and look up through any ones it
// extends to try and find a matching event
//
while (eventSet != null)
{
for (AptEvent controlEvent : eventSet.getEvents())
{
if (controlEvent == null ||
controlEvent.getName() == null ||
!controlEvent.getName().equals(eventName))
continue;
if ( controlEvent.getArgTypes() == null )
continue;
//
// BUGBUG: If the arguments are parameterized, then the event handler
// might declare a specific bound version of the type, so a direct
// comparison will fail. If parameterized, we don't validate.
//
if (controlEvent.hasParameterizedArguments() ||
(controlEvent.getArgTypes().equals(handlerMethod.getArgTypes()) &&
controlEvent.getReturnType().equals(handlerMethod.getReturnType())
)
)
{
HashSet<String> throwSet = new HashSet<String>(controlEvent.getThrowsList());
ArrayList<String> handlerThrows = handlerMethod.getThrowsList();
boolean throwsMatches = true;
for ( String t : handlerThrows )
{
if ( !throwSet.contains(t) )
throwsMatches = false;
}
if ( !throwsMatches )
{
_ap.printError( clientMethod, "eventhandler.throws.mismatch", handlerMethod.getName() );
}
adaptor.addHandler(controlEvent,
new AptEventHandler(controlEvent, clientMethod, _ap ));
found = true;
break;
}
}
if (found) // outer loop too
break;
//
// Look up on the super event set if not found at the current level
//
eventSet = eventSet.getSuperEventSet();
}
if (!found)
{
_ap.printError( clientMethod, "eventhandler.method.not.found", setName );
}
}
}
ClassDeclaration _clientDecl;
TwoPhaseAnnotationProcessor _ap;
ArrayList<AptControlField> _controls;
ClientInitializer _init;
}