Logo Search packages:      
Sourcecode: aspectj version File versions

AbstractReferenceTypeDelegate.java

/* *******************************************************************
 * Copyright (c) 2002 Contributors
 * All rights reserved. 
 * This program and the accompanying materials are made available 
 * under the terms of the Eclipse Public License v1.0 
 * which accompanies this distribution and is available at 
 * http://www.eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: 
 *     PARC     initial implementation 
 *     Andy Clement - June 2005 - separated out from ResolvedType
 * ******************************************************************/
package org.aspectj.weaver;

import java.util.ArrayList;
import java.util.List;

import org.aspectj.bridge.ISourceLocation;
import org.aspectj.util.GenericSignature;
import org.aspectj.util.GenericSignatureParser;
import org.aspectj.util.GenericSignature.ClassSignature;

public abstract class AbstractReferenceTypeDelegate implements ReferenceTypeDelegate {

      private String sourcefilename = UNKNOWN_SOURCE_FILE;
      private ISourceContext sourceContext = SourceContextImpl.UNKNOWN_SOURCE_CONTEXT;

      protected boolean exposedToWeaver;
      protected ReferenceType resolvedTypeX;
      protected ClassSignature cachedGenericClassTypeSignature;

      // Happens to match Bcel javaClass default of '<Unknown>'
      public final static String UNKNOWN_SOURCE_FILE = "<Unknown>";

      public AbstractReferenceTypeDelegate(ReferenceType resolvedTypeX, boolean exposedToWeaver) {
            this.resolvedTypeX = resolvedTypeX;
            this.exposedToWeaver = exposedToWeaver;
      }

      public final boolean isClass() {
            return !isAspect() && !isInterface();
      }

      /**
       * Designed to be overriden by EclipseType to disable collection of shadow mungers during pre-weave compilation phase
       */
      public boolean doesNotExposeShadowMungers() {
            return false;
      }

      public boolean isExposedToWeaver() {
            return exposedToWeaver;
      }

      public ReferenceType getResolvedTypeX() {
            return resolvedTypeX;
      }

      public final String getSourcefilename() {
            return sourcefilename;
      }

      public final void setSourcefilename(String sourceFileName) {
            sourcefilename = sourceFileName;
            if (sourceFileName != null && sourceFileName.equals(AbstractReferenceTypeDelegate.UNKNOWN_SOURCE_FILE)) {
                  sourcefilename = "Type '" + getResolvedTypeX().getName() + "' (no debug info available)";
            } else {
                  String pname = getResolvedTypeX().getPackageName();
                  if (pname != null) {
                        sourcefilename = pname.replace('.', '/') + '/' + sourceFileName;
                  }
            }
            if (sourcefilename != null && sourceContext instanceof SourceContextImpl) {
                  ((SourceContextImpl) sourceContext).setSourceFileName(sourcefilename);
            }
      }

      public ISourceLocation getSourceLocation() {
            return getSourceContext().makeSourceLocation(0, 0);
      }

      public ISourceContext getSourceContext() {
            return sourceContext;
      }

      public void setSourceContext(ISourceContext isc) {
            sourceContext = isc;
      }

      public GenericSignature.ClassSignature getGenericClassTypeSignature() {
            if (cachedGenericClassTypeSignature == null) {
                  String sig = getDeclaredGenericSignature();
                  if (sig != null) {
                        GenericSignatureParser parser = new GenericSignatureParser();
                        cachedGenericClassTypeSignature = parser.parseAsClassSignature(sig);
                  }
            }
            return cachedGenericClassTypeSignature;
      }

      protected GenericSignature.FormalTypeParameter[] getFormalTypeParametersFromOuterClass() {
            List typeParameters = new ArrayList();
            ResolvedType outerClassType = getOuterClass();
            if (!(outerClassType instanceof ReferenceType)) {
                  throw new BCException("Whilst processing type '"+this.resolvedTypeX.getSignature()+"' - cannot cast the outer type to a reference type.  Signature="+outerClassType.getSignature()+" toString()="+outerClassType.toString());
            }
            ReferenceType outer = (ReferenceType) outerClassType;
            ReferenceTypeDelegate outerDelegate = outer.getDelegate();
            AbstractReferenceTypeDelegate outerObjectType = (AbstractReferenceTypeDelegate) outerDelegate;
            if (outerObjectType.isNested()) {
                  GenericSignature.FormalTypeParameter[] parentParams = outerObjectType.getFormalTypeParametersFromOuterClass();
                  for (int i = 0; i < parentParams.length; i++) {
                        typeParameters.add(parentParams[i]);
                  }
            }
            GenericSignature.ClassSignature outerSig = outerObjectType.getGenericClassTypeSignature();
            if (outerSig != null) {
                  for (int i = 0; i < outerSig.formalTypeParameters.length; i++) {
                        typeParameters.add(outerSig.formalTypeParameters[i]);
                  }
            }

            GenericSignature.FormalTypeParameter[] ret = new GenericSignature.FormalTypeParameter[typeParameters.size()];
            typeParameters.toArray(ret);
            return ret;
      }

      public boolean copySourceContext() {
            return true;
      }

}

Generated by  Doxygen 1.6.0   Back to index