com.caucho.config.reflect.AnnotatedTypeImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of quercus Show documentation
Show all versions of quercus Show documentation
A PHP engine implemented in 100% Java
/*
* Copyright (c) 1998-2012 Caucho Technology -- all rights reserved
*
* This file is part of Resin(R) Open Source
*
* Each copy or derived work must preserve the copyright notice and this
* notice unmodified.
*
* Resin Open Source is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Resin Open Source is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
* of NON-INFRINGEMENT. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with Resin Open Source; if not, write to the
*
* Free Software Foundation, Inc.
* 59 Temple Place, Suite 330
* Boston, MA 02111-1307 USA
*
* @author Scott Ferguson
*/
package com.caucho.config.reflect;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.enterprise.inject.spi.AnnotatedConstructor;
import javax.enterprise.inject.spi.AnnotatedField;
import javax.enterprise.inject.spi.AnnotatedMethod;
import javax.enterprise.inject.spi.AnnotatedType;
/**
* Abstract introspected view of a Bean
*/
public class AnnotatedTypeImpl extends AnnotatedElementImpl
implements AnnotatedType
{
private Class _javaClass;
// private HashMap _paramMap = new HashMap();
private AnnotatedType _parentType;
/*
private Set> _constructorSet
= new CopyOnWriteArraySet>();
private Set> _fieldSet
= new CopyOnWriteArraySet>();
*/
private Set> _methodSet;
public AnnotatedTypeImpl(AnnotatedType annType)
{
super(annType);
_parentType = annType;
_javaClass = annType.getJavaClass();
/*
if (getBaseTypeImpl().getParamMap() != null)
_paramMap.putAll(getBaseTypeImpl().getParamMap());
*/
// _constructorSet.addAll(annType.getConstructors());
// _fieldSet.addAll(annType.getFields());
// initMethodSet()
}
public static AnnotatedTypeImpl create(AnnotatedType annType)
{
if (annType instanceof AnnotatedTypeImpl)
return (AnnotatedTypeImpl) annType;
else
return new AnnotatedTypeImpl(annType);
}
/**
* Returns the concrete Java class
*/
@Override
public Class getJavaClass()
{
return _javaClass;
}
@Override
public HashMap getBaseTypeParamMap()
{
// return _paramMap;
return getBaseTypeImpl().getParamMap();
}
private AnnotatedType getParentType()
{
return _parentType;
}
/**
* Returns the abstract introspected constructors
*/
@Override
public Set> getConstructors()
{
// return _constructorSet;
return (Set>) (Set) getParentType().getConstructors();
}
/**
* Returns the abstract introspected methods
*/
@Override
public Set> getMethods()
{
if (_methodSet != null)
return _methodSet;
else
return (Set>) (Set) getParentType().getMethods();
}
/**
* Returns the abstract introspected methods
*/
public Set> getMethodsForUpdate()
{
if (_methodSet == null) {
initMethodSet();
}
return _methodSet;
}
/**
* Returns the matching method, creating one if necessary.
*/
public AnnotatedMethod createMethod(Method method)
{
if (_methodSet == null) {
initMethodSet();
}
for (AnnotatedMethod annMethod : _methodSet) {
if (AnnotatedMethodImpl.isMatch(annMethod.getJavaMember(), method)) {
return annMethod;
}
}
AnnotatedMethod annMethod = new AnnotatedMethodImpl(this, null, method);
_methodSet.add(annMethod);
return annMethod;
}
/**
* Returns the abstract introspected fields
*/
@Override
public Set> getFields()
{
// return _fieldSet;
return (Set>) (Set) getParentType().getFields();
}
private void initMethodSet()
{
synchronized (this) {
if (_methodSet != null)
return;
_methodSet = new CopyOnWriteArraySet>();
for (AnnotatedMethod annMethod : getParentType().getMethods()) {
if (annMethod.getDeclaringType() == getParentType())
_methodSet.add(new AnnotatedMethodImpl(this, annMethod,
annMethod.getJavaMember()));
else {
_methodSet.add((AnnotatedMethod) annMethod);
}
}
}
}
}