/**
 *  Copyright (c)2020 CEA LIST, Committer Name, and others.
 * 
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License 2.0
 *  which accompanies this distribution, and is available at
 *  https://www.eclipse.org/legal/epl-2.0/
 * 
 *  SPDX-License-Identifier: EPL-2.0
 * 
 *  Contributors:
 *  CEA LIST - Initial API and implementation
 *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
 *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr 
 * 
 */
package org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.util;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notifier;

import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data;
import org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData;

import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.*;

/**
 * <!-- begin-user-doc -->
 * The <b>Adapter Factory</b> for the model.
 * It provides an adapter <code>createXXX</code> method for each class of the model.
 * <!-- end-user-doc -->
 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.pdp4engReqGDPRPackage
 * @generated
 */
public class pdp4engReqGDPRAdapterFactory extends AdapterFactoryImpl {
	/**
	 * The cached model package.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected static pdp4engReqGDPRPackage modelPackage;

	/**
	 * Creates an instance of the adapter factory.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public pdp4engReqGDPRAdapterFactory() {
		if (modelPackage == null) {
			modelPackage = pdp4engReqGDPRPackage.eINSTANCE;
		}
	}

	/**
	 * Returns whether this factory is applicable for the type of the object.
	 * <!-- begin-user-doc -->
	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
	 * <!-- end-user-doc -->
	 * @return whether this factory is applicable for the type of the object.
	 * @generated
	 */
	@Override
	public boolean isFactoryForType(Object object) {
		if (object == modelPackage) {
			return true;
		}
		if (object instanceof EObject) {
			return ((EObject)object).eClass().getEPackage() == modelPackage;
		}
		return false;
	}

	/**
	 * The switch that delegates to the <code>createXXX</code> methods.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected pdp4engReqGDPRSwitch<Adapter> modelSwitch =
		new pdp4engReqGDPRSwitch<Adapter>() {
			@Override
			public Adapter caseProcessRequirement(ProcessRequirement object) {
				return createProcessRequirementAdapter();
			}
			@Override
			public Adapter caseStakeholder(Stakeholder object) {
				return createStakeholderAdapter();
			}
			@Override
			public Adapter casePersonalDataRequirement(PersonalDataRequirement object) {
				return createPersonalDataRequirementAdapter();
			}
			@Override
			public Adapter caseGDPRPrinciple(GDPRPrinciple object) {
				return createGDPRPrincipleAdapter();
			}
			@Override
			public Adapter caseProcessPrinciple(ProcessPrinciple object) {
				return createProcessPrincipleAdapter();
			}
			@Override
			public Adapter casePurposePersonalDataPrinciple(PurposePersonalDataPrinciple object) {
				return createPurposePersonalDataPrincipleAdapter();
			}
			@Override
			public Adapter caseDataMinimisation(DataMinimisation object) {
				return createDataMinimisationAdapter();
			}
			@Override
			public Adapter casePurposeLimitation(PurposeLimitation object) {
				return createPurposeLimitationAdapter();
			}
			@Override
			public Adapter caseAccuracy(Accuracy object) {
				return createAccuracyAdapter();
			}
			@Override
			public Adapter caseStorageLimitation(StorageLimitation object) {
				return createStorageLimitationAdapter();
			}
			@Override
			public Adapter caseLawful(Lawful object) {
				return createLawfulAdapter();
			}
			@Override
			public Adapter caseFairly(Fairly object) {
				return createFairlyAdapter();
			}
			@Override
			public Adapter caseTransparency(Transparency object) {
				return createTransparencyAdapter();
			}
			@Override
			public Adapter caseSecuritySafety(SecuritySafety object) {
				return createSecuritySafetyAdapter();
			}
			@Override
			public Adapter caseRelatedTo(RelatedTo object) {
				return createRelatedToAdapter();
			}
			@Override
			public Adapter caseAvailableAt(AvailableAt object) {
				return createAvailableAtAdapter();
			}
			@Override
			public Adapter caseDerivedFrom(DerivedFrom object) {
				return createDerivedFromAdapter();
			}
			@Override
			public Adapter caseDataRequirement(DataRequirement object) {
				return createDataRequirementAdapter();
			}
			@Override
			public Adapter caseLinkable(Linkable object) {
				return createLinkableAdapter();
			}
			@Override
			public Adapter caseGeneratedRequirements(GeneratedRequirements object) {
				return createGeneratedRequirementsAdapter();
			}
			@Override
			public Adapter caseDataFlowRequirement(DataFlowRequirement object) {
				return createDataFlowRequirementAdapter();
			}
			@Override
			public Adapter caseDataSubjects(DataSubjects object) {
				return createDataSubjectsAdapter();
			}
			@Override
			public Adapter caseDataRequirements(DataRequirements object) {
				return createDataRequirementsAdapter();
			}
			@Override
			public Adapter caseAvailableInformation(AvailableInformation object) {
				return createAvailableInformationAdapter();
			}
			@Override
			public Adapter casePersonalInformation(PersonalInformation object) {
				return createPersonalInformationAdapter();
			}
			@Override
			public Adapter caseAvailableInformationContainer(AvailableInformationContainer object) {
				return createAvailableInformationContainerAdapter();
			}
			@Override
			public Adapter casePersonalInformationContainer(PersonalInformationContainer object) {
				return createPersonalInformationContainerAdapter();
			}
			@Override
			public Adapter caseUnlinkabilityRequirement(UnlinkabilityRequirement object) {
				return createUnlinkabilityRequirementAdapter();
			}
			@Override
			public Adapter casePrivacyRequirement(PrivacyRequirement object) {
				return createPrivacyRequirementAdapter();
			}
			@Override
			public Adapter caseDataUnlinkabilityRequirement(DataUnlinkabilityRequirement object) {
				return createDataUnlinkabilityRequirementAdapter();
			}
			@Override
			public Adapter caseControlers(Controlers object) {
				return createControlersAdapter();
			}
			@Override
			public Adapter caseLink(Link object) {
				return createLinkAdapter();
			}
			@Override
			public Adapter caseUndectabilityRequirement(UndectabilityRequirement object) {
				return createUndectabilityRequirementAdapter();
			}
			@Override
			public Adapter casePseudonimityRequirement(PseudonimityRequirement object) {
				return createPseudonimityRequirementAdapter();
			}
			@Override
			public Adapter caseAnanomityRequirement(AnanomityRequirement object) {
				return createAnanomityRequirementAdapter();
			}
			@Override
			public Adapter caseDataRecordRequirement(DataRecordRequirement object) {
				return createDataRecordRequirementAdapter();
			}
			@Override
			public Adapter caseFunctionalRequirements(FunctionalRequirements object) {
				return createFunctionalRequirementsAdapter();
			}
			@Override
			public Adapter caseNonFunctionalRequirements(NonFunctionalRequirements object) {
				return createNonFunctionalRequirementsAdapter();
			}
			@Override
			public Adapter caseLawfulByConsent(LawfulByConsent object) {
				return createLawfulByConsentAdapter();
			}
			@Override
			public Adapter caseLawfulByContract(LawfulByContract object) {
				return createLawfulByContractAdapter();
			}
			@Override
			public Adapter caseLawfulByPublicInterest(LawfulByPublicInterest object) {
				return createLawfulByPublicInterestAdapter();
			}
			@Override
			public Adapter caseLawfulByLegitimateInterest(LawfulByLegitimateInterest object) {
				return createLawfulByLegitimateInterestAdapter();
			}
			@Override
			public Adapter caseLawfulByLegalObligation(LawfulByLegalObligation object) {
				return createLawfulByLegalObligationAdapter();
			}
			@Override
			public Adapter caseLawfulByVitalInterest(LawfulByVitalInterest object) {
				return createLawfulByVitalInterestAdapter();
			}
			@Override
			public Adapter caseLawfullBySafeGuard(LawfullBySafeGuard object) {
				return createLawfullBySafeGuardAdapter();
			}
			@Override
			public Adapter caseProcess(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process object) {
				return createProcessAdapter();
			}
			@Override
			public Adapter caseData(Data object) {
				return createDataAdapter();
			}
			@Override
			public Adapter casePersonalData(PersonalData object) {
				return createPersonalDataAdapter();
			}
			@Override
			public Adapter defaultCase(EObject object) {
				return createEObjectAdapter();
			}
		};

	/**
	 * Creates an adapter for the <code>target</code>.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param target the object to adapt.
	 * @return the adapter for the <code>target</code>.
	 * @generated
	 */
	@Override
	public Adapter createAdapter(Notifier target) {
		return modelSwitch.doSwitch((EObject)target);
	}


	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessRequirement <em>Process Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessRequirement
	 * @generated
	 */
	public Adapter createProcessRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Stakeholder <em>Stakeholder</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Stakeholder
	 * @generated
	 */
	public Adapter createStakeholderAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalDataRequirement <em>Personal Data Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalDataRequirement
	 * @generated
	 */
	public Adapter createPersonalDataRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GDPRPrinciple <em>GDPR Principle</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GDPRPrinciple
	 * @generated
	 */
	public Adapter createGDPRPrincipleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessPrinciple <em>Process Principle</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.ProcessPrinciple
	 * @generated
	 */
	public Adapter createProcessPrincipleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple <em>Purpose Personal Data Principle</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposePersonalDataPrinciple
	 * @generated
	 */
	public Adapter createPurposePersonalDataPrincipleAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataMinimisation <em>Data Minimisation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataMinimisation
	 * @generated
	 */
	public Adapter createDataMinimisationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposeLimitation <em>Purpose Limitation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PurposeLimitation
	 * @generated
	 */
	public Adapter createPurposeLimitationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Accuracy <em>Accuracy</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Accuracy
	 * @generated
	 */
	public Adapter createAccuracyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.StorageLimitation <em>Storage Limitation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.StorageLimitation
	 * @generated
	 */
	public Adapter createStorageLimitationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Lawful <em>Lawful</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Lawful
	 * @generated
	 */
	public Adapter createLawfulAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Fairly <em>Fairly</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Fairly
	 * @generated
	 */
	public Adapter createFairlyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Transparency <em>Transparency</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Transparency
	 * @generated
	 */
	public Adapter createTransparencyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.SecuritySafety <em>Security Safety</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.SecuritySafety
	 * @generated
	 */
	public Adapter createSecuritySafetyAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo <em>Related To</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.RelatedTo
	 * @generated
	 */
	public Adapter createRelatedToAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt <em>Available At</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableAt
	 * @generated
	 */
	public Adapter createAvailableAtAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DerivedFrom <em>Derived From</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DerivedFrom
	 * @generated
	 */
	public Adapter createDerivedFromAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRequirement <em>Data Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRequirement
	 * @generated
	 */
	public Adapter createDataRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable <em>Linkable</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable
	 * @generated
	 */
	public Adapter createLinkableAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GeneratedRequirements <em>Generated Requirements</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.GeneratedRequirements
	 * @generated
	 */
	public Adapter createGeneratedRequirementsAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataFlowRequirement <em>Data Flow Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataFlowRequirement
	 * @generated
	 */
	public Adapter createDataFlowRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataSubjects <em>Data Subjects</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataSubjects
	 * @generated
	 */
	public Adapter createDataSubjectsAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRequirements <em>Data Requirements</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRequirements
	 * @generated
	 */
	public Adapter createDataRequirementsAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation <em>Available Information</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformation
	 * @generated
	 */
	public Adapter createAvailableInformationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation <em>Personal Information</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformation
	 * @generated
	 */
	public Adapter createPersonalInformationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformationContainer <em>Available Information Container</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AvailableInformationContainer
	 * @generated
	 */
	public Adapter createAvailableInformationContainerAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformationContainer <em>Personal Information Container</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PersonalInformationContainer
	 * @generated
	 */
	public Adapter createPersonalInformationContainerAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UnlinkabilityRequirement <em>Unlinkability Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UnlinkabilityRequirement
	 * @generated
	 */
	public Adapter createUnlinkabilityRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement <em>Privacy Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PrivacyRequirement
	 * @generated
	 */
	public Adapter createPrivacyRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataUnlinkabilityRequirement <em>Data Unlinkability Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataUnlinkabilityRequirement
	 * @generated
	 */
	public Adapter createDataUnlinkabilityRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Controlers <em>Controlers</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Controlers
	 * @generated
	 */
	public Adapter createControlersAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link <em>Link</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link
	 * @generated
	 */
	public Adapter createLinkAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UndectabilityRequirement <em>Undectability Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.UndectabilityRequirement
	 * @generated
	 */
	public Adapter createUndectabilityRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonimityRequirement <em>Pseudonimity Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonimityRequirement
	 * @generated
	 */
	public Adapter createPseudonimityRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AnanomityRequirement <em>Ananomity Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.AnanomityRequirement
	 * @generated
	 */
	public Adapter createAnanomityRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRecordRequirement <em>Data Record Requirement</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.DataRecordRequirement
	 * @generated
	 */
	public Adapter createDataRecordRequirementAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.FunctionalRequirements <em>Functional Requirements</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.FunctionalRequirements
	 * @generated
	 */
	public Adapter createFunctionalRequirementsAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.NonFunctionalRequirements <em>Non Functional Requirements</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.NonFunctionalRequirements
	 * @generated
	 */
	public Adapter createNonFunctionalRequirementsAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByConsent <em>Lawful By Consent</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByConsent
	 * @generated
	 */
	public Adapter createLawfulByConsentAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByContract <em>Lawful By Contract</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByContract
	 * @generated
	 */
	public Adapter createLawfulByContractAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest <em>Lawful By Public Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest
	 * @generated
	 */
	public Adapter createLawfulByPublicInterestAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegitimateInterest <em>Lawful By Legitimate Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegitimateInterest
	 * @generated
	 */
	public Adapter createLawfulByLegitimateInterestAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegalObligation <em>Lawful By Legal Obligation</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegalObligation
	 * @generated
	 */
	public Adapter createLawfulByLegalObligationAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest <em>Lawful By Vital Interest</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest
	 * @generated
	 */
	public Adapter createLawfulByVitalInterestAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard <em>Lawfull By Safe Guard</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard
	 * @generated
	 */
	public Adapter createLawfullBySafeGuardAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process <em>Process</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process
	 * @generated
	 */
	public Adapter createProcessAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data <em>Data</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data
	 * @generated
	 */
	public Adapter createDataAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData <em>Personal Data</em>}'.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null so that we can easily ignore cases;
	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData
	 * @generated
	 */
	public Adapter createPersonalDataAdapter() {
		return null;
	}

	/**
	 * Creates a new adapter for the default case.
	 * <!-- begin-user-doc -->
	 * This default implementation returns null.
	 * <!-- end-user-doc -->
	 * @return the new adapter.
	 * @generated
	 */
	public Adapter createEObjectAdapter() {
		return null;
	}

} //pdp4engReqGDPRAdapterFactory
