/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package flex2.compiler.config;
import java.lang.reflect.*;
import java.util.Map;
import java.util.List;
import java.util.Set;
/**
* Flex MXMLC compiler uses the result of the client configuration parser
* to generate mixin initialization source code to be added to the SWF by
* PreLink. It also requires a list of channel classes to be added as
* dependencies.
*
* @exclude
*/
public class ServicesDependenciesWrapper
{
private Object servicesDependenciesInstance;
private Class servicesDependenciesClass;
@SuppressWarnings("unchecked")
public ServicesDependenciesWrapper(String path, String parserClass, String contextRoot)
{
try
{
servicesDependenciesClass = Class.forName("flex.messaging.config.ServicesDependencies");
}
catch (ClassNotFoundException e)
{
return;
}
Class partypes[] = new Class[3];
partypes[0] = String.class;
partypes[1] = String.class;
partypes[2] = String.class;
try
{
Constructor ct = servicesDependenciesClass.getConstructor(partypes);
Object arglist[] = new Object[3];
arglist[0] = path;
arglist[1] = parserClass;
arglist[2] = contextRoot;
try
{
servicesDependenciesInstance = ct.newInstance(arglist);
}
catch (Exception e3)
{
if(e3 instanceof InvocationTargetException) {
e3.getCause().printStackTrace();
} else {
e3.printStackTrace();
}
}
}
catch (NoSuchMethodException e2)
{
}
}
@SuppressWarnings("unchecked")
public Set getLazyAssociations(String destination)
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getLazyAssociations", new Class[] {String.class});
Object arglist[] = new Object[1];
arglist[0] = destination;
return (Set)method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
return null;
}
@SuppressWarnings("unchecked")
public void addLazyAssociation(String destination, String associationProp)
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getLazyAssociations", new Class[] {String.class});
Object arglist[] = new Object[2];
arglist[0] = destination;
arglist[1] = associationProp;
method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
}
@SuppressWarnings("unchecked")
public String getServerConfigXmlInit()
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getServerConfigXmlInit", new Class[] {} );
Object arglist[] = new Object[0];
return (String)method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
return null;
}
@SuppressWarnings("unchecked")
public String getImports()
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getImports", new Class[] {} );
Object arglist[] = new Object[0];
return (String)method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
return null;
}
@SuppressWarnings("unchecked")
public String getReferences()
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getReferences", new Class[] {} );
Object arglist[] = new Object[0];
return (String)method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
return null;
}
@SuppressWarnings("unchecked")
public List getChannelClasses()
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getChannelClasses", new Class[] {} );
Object arglist[] = new Object[0];
return (List)method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
return null;
}
@SuppressWarnings("unchecked")
public void addChannelClass(String className)
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("addChannelClass", new Class[] {} );
Object arglist[] = new Object[0];
method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
}
@SuppressWarnings("unchecked")
public void addConfigPath(String path, long modified)
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("addConfigPath", new Class[] { String.class, Long.TYPE } );
Object arglist[] = new Object[2];
arglist[0] = path;
arglist[1] = modified;
method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
}
@SuppressWarnings("unchecked")
public Map getConfigPaths()
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getConfigPaths", new Class[] {} );
Object arglist[] = new Object[0];
return (Map)method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
return null;
}
/*
public static ClientConfiguration getClientConfiguration(String path, String parserClass)
{
ClientConfiguration config = new ClientConfiguration();
ConfigurationParser parser = getConfigurationParser(parserClass);
if (parser == null)
{
// "Unable to create a parser to load messaging configuration."
LocalizedException lme = new LocalizedException();
lme.setMessage(10138);
throw lme;
}
LocalFileResolver local = new LocalFileResolver();
parser.parse(path, local, config);
config.addConfigPath(path, new File(path).lastModified());
return config;
}
static ConfigurationParser getConfigurationParser(String className)
{
ConfigurationParser parser = null;
Class parserClass = null;
// Check for Custom Parser Specification
if (className != null)
{
try
{
parserClass = Class.forName(className);
parser = (ConfigurationParser)parserClass.newInstance();
}
catch (Exception t)
{
if (traceConfig)
{
System.out.println("Could not load services configuration parser as: " + className);
}
}
}
// Try Sun JRE 1.4 / Apache Xalan Based Implementation
if (parser == null)
{
try
{
Class.forName("org.apache.xpath.CachedXPathAPI");
className = "flex.messaging.config.ApacheXPathClientConfigurationParser";
parserClass = Class.forName(className);
parser = (ConfigurationParser)parserClass.newInstance();
}
catch (Exception t)
{
if (traceConfig)
{
System.out.println("Could not load configuration parser as: " + className);
}
}
}
// Try Sun JRE 1.5 Based Implementation
if (parser == null)
{
try
{
className = "flex.messaging.config.XPathClientConfigurationParser";
parserClass = Class.forName(className);
// double-check, on some systems the above loads but the import classes don't
Class.forName("javax.xml.xpath.XPathExpressionException");
parser = (ConfigurationParser)parserClass.newInstance();
}
catch (Exception t)
{
if (traceConfig)
{
System.out.println("Could not load configuration parser as: " + className);
}
}
}
if (traceConfig && parser != null)
{
System.out.println("Services Configuration Parser: " + parser.getClass().getName());
}
return parser;
}
private static List listChannelClasses(ServicesConfiguration config)
{
List channelList = new ArrayList();
Iterator it = config.getAllChannelSettings().values().iterator();
while (it.hasNext())
{
ChannelSettings settings = (ChannelSettings)it.next();
if (!settings.serverOnly)
{
String clientType = settings.getClientType();
channelList.add(clientType);
}
}
return channelList;
}
*/
/**
*
public void codegenServiceAssociations(ConfigMap metadata, StringBuffer e4x, String destination, String relation)
{
if (servicesDependenciesClass != null)
{
try
{
Method method = servicesDependenciesClass.getMethod("getConfigPaths", new Class[] { ConfigMap.class, StringBuffer.class, String.class, String.class } );
Object arglist[] = new Object[4];
arglist[0] = metadata;
arglist[1] = e4x;
arglist[2] = destination;
arglist[3] = relation;
method.invoke(servicesDependenciesInstance, arglist);
}
catch (Exception e)
{
}
}
}
*/
/**
* This method will return an import and variable reference for channels specified in the map.
* @param map HashMap containing the client side channel type to be used, typically of the form
* "mx.messaging.channels.XXXXChannel", where the key and value are equal.
* @param imports StringBuffer of the imports needed for the given channel definitions
* @param references StringBuffer of the required references so that these classes will be linked in.
public static void codegenServiceImportsAndReferences(Map map, StringBuffer imports, StringBuffer references)
{
String channelSetImplType = (String)map.remove("ChannelSetImpl");
String type;
imports.append("import mx.messaging.config.ServerConfig;\n");
references.append(" // static references for configured channels\n");
for (Iterator chanIter = map.values().iterator(); chanIter.hasNext();)
{
type = (String)chanIter.next();
imports.append("import ");
imports.append(type);
imports.append(";\n");
references.append(" private static var ");
references.append(type.replace('.', '_'));
references.append("_ref:");
references.append(type.substring(type.lastIndexOf(".") +1) +";\n");
}
if (channelSetImplType != null)
imports.append("import mx.messaging.AdvancedChannelSet;\nimport mx.messaging.messages.ReliabilityMessage;\n");
}
*/
}