Profile Management

/**
 * Interface for managing Maven profiles and their activation
 * @deprecated Use newer Maven 3.x profile management APIs
 */
@Deprecated
public interface ProfileManager {
    /**
     * Adds a profile to the manager
     * @param profile profile to add
     */
    void addProfile(Profile profile);
    
    /**
     * Adds multiple profiles to the manager
     * @param profiles list of profiles to add
     */
    void addProfiles(List<Profile> profiles);
    
    /**
     * Explicitly activates a profile by ID
     * @param profileId ID of profile to activate
     */
    void explicitlyActivate(String profileId);
    
    /**
     * Explicitly activates multiple profiles by IDs
     * @param profileIds list of profile IDs to activate  
     */
    void explicitlyActivate(List<String> profileIds);
    
    /**
     * Explicitly deactivates a profile by ID
     * @param profileId ID of profile to deactivate
     */
    void explicitlyDeactivate(String profileId);
    
    /**
     * Explicitly deactivates multiple profiles by IDs
     * @param profileIds list of profile IDs to deactivate
     */
    void explicitlyDeactivate(List<String> profileIds);
    
    /**
     * Gets list of currently active profiles
     * @return List of active Profile objects
     * @throws ProfileActivationException if activation fails
     */
    List getActiveProfiles() throws ProfileActivationException;
    
    /**
     * Gets all profiles by their IDs
     * @return Map of profile ID to Profile object
     */
    Map getProfilesById();
    
    /**
     * Gets list of explicitly activated profile IDs
     * @return List of activated profile ID strings
     */
    List<String> getExplicitlyActivatedIds();
    
    /**
     * Gets list of explicitly deactivated profile IDs
     * @return List of deactivated profile ID strings  
     */
    List<String> getExplicitlyDeactivatedIds();
    
    /**
     * Gets list of profile IDs activated by default
     * @return List of default active profile IDs
     */
    List getIdsActivatedByDefault();
    
    /**
     * Gets the request properties used for profile activation
     * @return Properties object with activation properties
     */
    Properties getRequestProperties();
}

/**
 * Default implementation of ProfileManager
 */
public class DefaultProfileManager implements ProfileManager {
    /**
     * Creates a new DefaultProfileManager
     */
    public DefaultProfileManager();
    
    /**
     * Adds a profile to the manager
     */
    public void addProfile(Profile profile);
    
    /**
     * Explicitly activates a profile by ID
     */
    public void explicitlyActivate(String profileId);
    
    /**
     * Explicitly deactivates a profile by ID
     */
    public void explicitlyDeactivate(String profileId);
    
    /**
     * Gets list of currently active profiles
     */
    public List getActiveProfiles() throws ProfileActivationException;
    
    /**
     * Gets the request properties used for profile activation
     */
    public Properties getRequestProperties();
}

/**
 * Interface for building profile configurations from files
 * @deprecated Use newer Maven 3.x profile building APIs
 */
@Deprecated
public interface MavenProfilesBuilder {
    /**
     * Role constant for Plexus component lookup
     */
    String ROLE = MavenProfilesBuilder.class.getName();
    
    /**
     * Builds profiles from the given base directory
     * @param basedir base directory to search for profiles
     * @return ProfilesRoot containing parsed profiles
     * @throws ProfilesBuilderException if profile building fails
     */
    ProfilesRoot buildProfiles(File basedir) throws ProfilesBuilderException;
}

/**
 * Default implementation of MavenProfilesBuilder
 */
public class DefaultMavenProfilesBuilder implements MavenProfilesBuilder {
    /**
     * Builds profiles from the given base directory
     */
    public ProfilesRoot buildProfiles(File basedir) throws ProfilesBuilderException;
}

/**
 * Base interface for profile activation strategies
 */
public interface ProfileActivator {
    /**
     * Determines if a profile can be detected/activated
     * @param profile profile to check
     * @param context activation context
     * @return true if profile can be activated
     * @throws ProfileActivationException if activation check fails
     */
    boolean canDetermineActivation(Profile profile, ProfileActivationContext context) 
                                  throws ProfileActivationException;
    
    /**
     * Determines if a profile should be activated
     * @param profile profile to check
     * @param context activation context  
     * @return true if profile should be activated
     * @throws ProfileActivationException if activation determination fails
     */
    boolean isActive(Profile profile, ProfileActivationContext context) 
                    throws ProfileActivationException;
}

/**
 * Activates profiles based on file existence
 */
public class FileProfileActivator extends DetectedProfileActivator {
    /**
     * Checks if profile should be activated based on file presence/absence
     */
    public boolean isActive(Profile profile, ProfileActivationContext context) 
                           throws ProfileActivationException;
}

/**
 * Activates profiles based on JDK version matching
 */
public class JdkPrefixProfileActivator extends DetectedProfileActivator {
    /**
     * Checks if profile should be activated based on JDK version
     */
    public boolean isActive(Profile profile, ProfileActivationContext context) 
                           throws ProfileActivationException;
}

/**
 * Activates profiles based on system property values
 */
public class SystemPropertyProfileActivator extends DetectedProfileActivator {
    /**
     * Checks if profile should be activated based on system properties
     */
    public boolean isActive(Profile profile, ProfileActivationContext context) 
                           throws ProfileActivationException;
}

/**
 * Activates profiles based on operating system characteristics
 */
public class OperatingSystemProfileActivator extends DetectedProfileActivator {
    /**
     * Checks if profile should be activated based on OS details
     */
    public boolean isActive(Profile profile, ProfileActivationContext context) 
                           throws ProfileActivationException;
}

import org.apache.maven.profiles.ProfileManager;
import org.apache.maven.profiles.DefaultProfileManager;
import org.apache.maven.model.Profile;
import org.apache.maven.profiles.activation.ProfileActivationException;

// Create profile manager
ProfileManager profileManager = new DefaultProfileManager();

// Create and add profiles
Profile devProfile = new Profile();
devProfile.setId("development");
Profile prodProfile = new Profile();
prodProfile.setId("production");

profileManager.addProfile(devProfile);
profileManager.addProfile(prodProfile);

// Explicitly activate profiles
profileManager.explicitlyActivate("development");
profileManager.explicitlyDeactivate("production");

try {
    // Get active profiles
    List activeProfiles = profileManager.getActiveProfiles();
    System.out.println("Active profiles: " + activeProfiles.size());
    
    // Access request properties
    Properties props = profileManager.getRequestProperties();
    System.out.println("Request properties: " + props);
} catch (ProfileActivationException e) {
    System.err.println("Profile activation failed: " + e.getMessage());
}

import org.apache.maven.profiles.MavenProfilesBuilder;
import org.apache.maven.profiles.DefaultMavenProfilesBuilder;
import org.apache.maven.profiles.ProfilesBuilderException;

// Build profiles from directory
MavenProfilesBuilder builder = new DefaultMavenProfilesBuilder();
File projectDir = new File(".");

try {
    ProfilesRoot profilesRoot = builder.buildProfiles(projectDir);
    List<Profile> profiles = profilesRoot.getProfiles();
    System.out.println("Found " + profiles.size() + " profiles");
    
    for (Profile profile : profiles) {
        System.out.println("Profile: " + profile.getId());
    }
} catch (ProfilesBuilderException e) {
    System.err.println("Failed to build profiles: " + e.getMessage());
}

import org.apache.maven.profiles.activation.ProfileActivator;
import org.apache.maven.profiles.activation.FileProfileActivator;
import org.apache.maven.profiles.activation.JdkPrefixProfileActivator;
import org.apache.maven.profiles.activation.SystemPropertyProfileActivator;

// File-based activation
ProfileActivator fileActivator = new FileProfileActivator();
boolean fileBasedActive = fileActivator.isActive(profile, context);

// JDK version-based activation  
ProfileActivator jdkActivator = new JdkPrefixProfileActivator();
boolean jdkBasedActive = jdkActivator.isActive(profile, context);

// System property-based activation
ProfileActivator propActivator = new SystemPropertyProfileActivator();
boolean propBasedActive = propActivator.isActive(profile, context);

System.out.println("Activation results:");
System.out.println("  File-based: " + fileBasedActive);
System.out.println("  JDK-based: " + jdkBasedActive);
System.out.println("  Property-based: " + propBasedActive);

// Complete profile management workflow
public void configureProfiles(File projectDir, List<String> activeProfileIds) {
    try {
        // Build profiles from directory
        MavenProfilesBuilder builder = new DefaultMavenProfilesBuilder();
        ProfilesRoot profilesRoot = builder.buildProfiles(projectDir);
        
        // Create profile manager
        ProfileManager profileManager = new DefaultProfileManager();
        
        // Add all discovered profiles
        for (Profile profile : profilesRoot.getProfiles()) {
            profileManager.addProfile(profile);
        }
        
        // Activate requested profiles
        for (String profileId : activeProfileIds) {
            profileManager.explicitlyActivate(profileId);
        }
        
        // Get final active profiles
        List activeProfiles = profileManager.getActiveProfiles();
        System.out.println("Configured " + activeProfiles.size() + " active profiles");
        
    } catch (ProfilesBuilderException | ProfileActivationException e) {
        System.err.println("Profile configuration failed: " + e.getMessage());
    }
}

/**
 * Exception thrown when profile activation fails
 */
public class ProfileActivationException extends Exception {
    /**
     * Creates exception with message
     * @param message error message
     */
    public ProfileActivationException(String message);
    
    /**
     * Creates exception with message and cause
     * @param message error message
     * @param cause underlying cause
     */
    public ProfileActivationException(String message, Throwable cause);
}

/**
 * Exception thrown when profile building fails
 */
public class ProfilesBuilderException extends Exception {
    /**
     * Creates exception with message
     * @param message error message
     */
    public ProfilesBuilderException(String message);
    
    /**
     * Creates exception with message and cause
     * @param message error message
     * @param cause underlying cause
     */
    public ProfilesBuilderException(String message, Throwable cause);
}