org.apache.maven.tools.plugin.javadoc.FullyQualifiedJavadocReference Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of maven-plugin-tools-api Show documentation
Show all versions of maven-plugin-tools-api Show documentation
The Maven Plugin Tools Extractor API provides an API to extract descriptor information from Maven Plugins.
package org.apache.maven.tools.plugin.javadoc;
/*
* 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.
*/
import java.util.Objects;
import java.util.Optional;
/**
* Wraps a fully qualified (and resolved) code reference used in javadoc tags {@code see}, {@code link} and
* {@code linkplain}. Similar to {@link JavadocReference} but can distinguish between package names and class names. The
* package name is always set for a resolved reference (except for references to modules). The member is always the
* normalized form containing only fully qualified type names (without argument names), separated by {@code ,} without
* any whitespace characters. Also the member type is always resolved to one of {@link MemberType} (in case the
* reference contains a member part).
*/
public class FullyQualifiedJavadocReference
extends JavadocReference
{
/** if false, points to a class/package which is part of the current classloader (and not any of its parents) */
private final boolean isExternal;
private final Optional packageName;
private final Optional memberType;
/** The type of the member part of the reference. */
public enum MemberType
{
FIELD, METHOD, CONSTRUCTOR
}
public FullyQualifiedJavadocReference( String packageName, boolean isExternal )
{
this( packageName, Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty(), isExternal );
}
public FullyQualifiedJavadocReference( String packageName, Optional label, boolean isExternal )
{
this( packageName, Optional.empty(), Optional.empty(), Optional.empty(), label, isExternal );
}
public FullyQualifiedJavadocReference( String packageName, String className, boolean isExternal )
{
this( packageName, Optional.of( className ), Optional.empty(), Optional.empty(), Optional.empty(),
isExternal );
}
public FullyQualifiedJavadocReference( String packageName, String className, String member, MemberType memberType,
boolean isExternal )
{
this( packageName, Optional.of( className ), Optional.of( member ), Optional.of( memberType ),
Optional.empty(), isExternal );
}
public FullyQualifiedJavadocReference( String packageName, Optional className, Optional member,
Optional memberType, Optional label, boolean isExternal )
{
this( Optional.empty(), Optional.of( packageName ), className, member, memberType, label, isExternal );
}
public FullyQualifiedJavadocReference( Optional moduleName, Optional packageName,
Optional className, Optional member,
Optional memberType, Optional label,
boolean isExternal )
{
super( moduleName, className, member, label );
this.packageName = packageName;
this.isExternal = isExternal;
if ( !moduleName.isPresent() && !packageName.isPresent() )
{
throw new IllegalArgumentException( "At least one of module name or package name needs to be set" );
}
if ( member.isPresent() )
{
if ( !memberType.isPresent() )
{
throw new IllegalArgumentException( "When member is set, also the member type needs to be set" );
}
if ( member.get().matches( ".*\\s.*" ) )
{
throw new IllegalArgumentException( "member must not contain any whitespace characters!" );
}
}
this.memberType = memberType;
}
/**
*
* @return {@code true} in case this class/package is part of another classloader
*/
public boolean isExternal()
{
return isExternal;
}
/** @return the package name of the referenced class */
public Optional getPackageName()
{
return packageName;
}
/**
* @return the simple class name of the referenced class, may be prefixed by the declaring class names, separated by
* '.' (for inner classes)
*/
public Optional getClassName()
{
return getPackageNameClassName();
}
/** @return the type of the member. Only empty if no member is set. */
public Optional getMemberType()
{
return memberType;
}
public Optional getFullyQualifiedClassName()
{
if ( getClassName().isPresent() && getPackageName().isPresent() )
{
return Optional.of( getPackageName().get() + "." + getClassName().get() );
}
else
{
return Optional.empty();
}
}
@Override
public String toString()
{
return "FullyQualifiedJavadocReference [moduleName=" + getModuleName() + ", packageName=" + packageName
+ ", className=" + getClassName() + ", memberType=" + memberType + ", member=" + getMember() + ", label="
+ getLabel() + ", isExternal=" + isExternal + "]";
}
@Override
public int hashCode()
{
final int prime = 31;
int result = super.hashCode();
result = prime * result + Objects.hash( memberType, packageName, isExternal );
return result;
}
@Override
public boolean equals( Object obj )
{
if ( this == obj )
{
return true;
}
if ( !super.equals( obj ) )
{
return false;
}
if ( getClass() != obj.getClass() )
{
return false;
}
FullyQualifiedJavadocReference other = (FullyQualifiedJavadocReference) obj;
return Objects.equals( memberType, other.memberType ) && Objects.equals( packageName, other.packageName )
&& isExternal == other.isExternal;
}
}