text: #include "umlReflectionExec/RegionObject.hpp"
  
  //General Includes
  #include "abstractDataTypes/SubsetUnion.hpp"
  #include "uml/Region.hpp"
  #include "umlReflection/UMLPackage.hpp"
  #include "fUML/Semantics/Loci/Locus.hpp"
  #include "uml/Class.hpp"
  //Includes From Composite Structures
  /*Not done for metamodel object classes*/
  //Execution Engine Includes
  #include "abstractDataTypes/Any.hpp"
  #include "PSCS/Semantics/StructuredClassifiers/StructuredClassifiersFactory.hpp"
  #include "PSCS/Semantics/StructuredClassifiers/CS_Reference.hpp"
  #include "fUML/Semantics/SimpleClassifiers/SimpleClassifiersFactory.hpp"
  #include "fUML/Semantics/Values/Value.hpp"
  #include "fUML/Semantics/SimpleClassifiers/FeatureValue.hpp"
  #include "PSCS/Semantics/StructuredClassifiers/CS_Link.hpp"
  #include "PSCS/Semantics/StructuredClassifiers/CS_InteractionPoint.hpp"
  #include "fUML/Semantics/CommonBehavior/Execution.hpp"
  #include "fUML/Semantics/CommonBehavior/CommonBehaviorFactory.hpp"
  #include "fUML/Semantics/Loci/ExecutionFactory.hpp"
  #include "fUML/Semantics/Loci/ChoiceStrategy.hpp"
  //UML Includes
  #include "uml/umlPackage.hpp"
  #include "uml/Association.hpp"
  #include "uml/Connector.hpp"
  #include "uml/ConnectorEnd.hpp"
  #include "uml/Operation.hpp"
  #include "uml/Property.hpp"
  #include "uml/Port.hpp"
  //Property Includes
  #include "uml/Comment.hpp"
  #include "umlReflectionExec/CommentObject.hpp"
  #include "uml/Element.hpp"
  #include "umlReflectionExec/ElementObject.hpp"
  #include "uml/Element.hpp"
  #include "umlReflectionExec/ElementObject.hpp"
  #include "uml/Dependency.hpp"
  #include "umlReflectionExec/DependencyObject.hpp"
  #include "fUML/Semantics/SimpleClassifiers/StringValue.hpp"
  #include "uml/StringExpression.hpp"
  #include "umlReflectionExec/StringExpressionObject.hpp"
  #include "uml/Namespace.hpp"
  #include "umlReflectionExec/NamespaceObject.hpp"
  #include "fUML/Semantics/SimpleClassifiers/StringValue.hpp"
  #include "fUML/Semantics/SimpleClassifiers/EnumerationValue.hpp"
  #include "uml/VisibilityKind.hpp"
  #include "uml/ElementImport.hpp"
  #include "umlReflectionExec/ElementImportObject.hpp"
  #include "uml/PackageableElement.hpp"
  #include "umlReflectionExec/PackageableElementObject.hpp"
  #include "uml/NamedElement.hpp"
  #include "umlReflectionExec/NamedElementObject.hpp"
  #include "uml/NamedElement.hpp"
  #include "umlReflectionExec/NamedElementObject.hpp"
  #include "uml/Constraint.hpp"
  #include "umlReflectionExec/ConstraintObject.hpp"
  #include "uml/PackageImport.hpp"
  #include "umlReflectionExec/PackageImportObject.hpp"
  #include "fUML/Semantics/SimpleClassifiers/BooleanValue.hpp"
  #include "uml/RedefinableElement.hpp"
  #include "umlReflectionExec/RedefinableElementObject.hpp"
  #include "uml/Region.hpp"
  #include "umlReflectionExec/RegionObject.hpp"
  #include "uml/Classifier.hpp"
  #include "umlReflectionExec/ClassifierObject.hpp"
  #include "uml/State.hpp"
  #include "umlReflectionExec/StateObject.hpp"
  #include "uml/StateMachine.hpp"
  #include "umlReflectionExec/StateMachineObject.hpp"
  #include "uml/Vertex.hpp"
  #include "umlReflectionExec/VertexObject.hpp"
  #include "uml/Transition.hpp"
  #include "umlReflectionExec/TransitionObject.hpp"
  //Property Packages Includes
  #include "primitivetypesReflection/PrimitiveTypesPackage.hpp"
  
  
  using namespace UML;
  
  RegionObject::RegionObject(std::shared_ptr<uml::Region> _element):
  
  	m_RegionValue(_element)
  {		
  	this->getTypes()->insert(this->getTypes()->begin(), UML::UMLPackage::eInstance()->get_UML_Region());
  }
  
  RegionObject::RegionObject(RegionObject &obj):
  	CS_ObjectImpl(obj)
  {
  }
  
  RegionObject::RegionObject()
  {	
  	this->getTypes()->insert(this->getTypes()->begin(), UML::UMLPackage::eInstance()->get_UML_Region());
  }
  
  RegionObject::~RegionObject()
  {
  }
  
  std::shared_ptr<ecore::EObject> RegionObject::copy()
  {
  	std::shared_ptr<RegionObject> element(new RegionObject(*this));
  	element->setThisRegionObjectPtr(element);
  	return element;
  }
  
  void RegionObject::destroy()
  {	
  	m_RegionValue.reset();
  
  	fUML::Semantics::StructuredClassifiers::ObjectImpl::destroy();
  }
  
  std::shared_ptr<uml::Element> RegionObject::getUmlValue() const
  {
  	return getRegionValue();
  }
  
  std::shared_ptr<uml::Region> RegionObject::getRegionValue() const
  {
  	return m_RegionValue;
  }
  
  void RegionObject::setUmlValue(std::shared_ptr<uml::Element> _element)
  {
  	setRegionValue(std::dynamic_pointer_cast<uml::Region>(_element));
  }
  
  void RegionObject::setRegionValue(std::shared_ptr<uml::Region> _RegionElement)
  {
  	m_RegionValue = _RegionElement;
  	//set super type values
  	UML::NamespaceObject::setNamespaceValue(_RegionElement);
  	UML::RedefinableElementObject::setRedefinableElementValue(_RegionElement);
  }
  
  void RegionObject::setThisRegionObjectPtr(std::weak_ptr<RegionObject> thisObjectPtr)
  {
  	setThisCS_ObjectPtr(thisObjectPtr);
  }
  
  bool RegionObject::equals(std::shared_ptr<fUML::Semantics::Values::Value> otherValue)
  {
  	bool isEqual = false;
  	
  	std::shared_ptr<RegionObject> otherRegionObject = std::dynamic_pointer_cast<RegionObject>(otherValue);
  
  	if(otherRegionObject != nullptr)
  	{
  		if(this->getRegionValue() == otherRegionObject->getRegionValue())
  		{
  			isEqual = true;
  		}
  	}
  
  	return isEqual;
  }
  
  std::string RegionObject::toString()
  {
  	std::string buffer = "Instance of 'RegionObject', " + std::to_string(getTypes()->size()) + " types (";
  	for(unsigned int i = 0; i < getTypes()->size(); ++i)
  	{
  		buffer += "type{" + std::to_string(i) + "}: '" + getTypes()->at(i)->getName() + "', ";
  	}
  	buffer +=")";
  
  	return buffer;
  }
  
  std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Object>> RegionObject::getDirectContainers()
  {   
  	std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Object>> directContainers(new Bag<PSCS::Semantics::StructuredClassifiers::CS_Object>());
  
  	/*Not done for metamodel object classes*/
  
  	return directContainers;
  }
  
  std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Link>> RegionObject::getLinks(std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_InteractionPoint> interactionPoint)
  {
  	std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Link>> allLinks(new Bag<PSCS::Semantics::StructuredClassifiers::CS_Link>());
  
  	/*Not done for metamodel object classes*/
  
  	return allLinks;
  }
  
  std::shared_ptr<Bag<fUML::Semantics::Values::Value>> RegionObject::retrieveEndValueAsInteractionPoint(std::shared_ptr<fUML::Semantics::Values::Value> endValue, std::shared_ptr<uml::ConnectorEnd> end)
  {
  	/*Not done for metamodel object classes*/
  
  	return nullptr;
  }
  
  void RegionObject::removeValue(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<fUML::Semantics::Values::Value> value)
  {
  	if (feature->getMetaElementID() != uml::umlPackage::PROPERTY_CLASS && feature->getMetaElementID() != uml::umlPackage::PORT_CLASS && feature->getMetaElementID() != uml::umlPackage::EXTENSIONEND_CLASS)
  	{
  		std::cerr << __PRETTY_FUNCTION__ << ": feature is null or not kind of uml::Property" << std::endl;
  		throw "feature is null or not kind of uml::Property";
  	}
  
  	if (m_RegionValue == nullptr)
  	{
  		std::cerr << __PRETTY_FUNCTION__ << ": no value stored inside RegionObject (property: " << feature->getName() << ")" << std::endl;
  		throw "NullPointerException";	
  	}
  
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment())
  	{
  		if (value == nullptr) // clear mode
  		{
  			m_RegionValue->getOwnedComment()->clear();
  		}
  		else
  		{
  			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
  			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
  			std::shared_ptr<UML::CommentObject> inputValue = std::dynamic_pointer_cast<UML::CommentObject>(reference->getReferent());
  			if (inputValue != nullptr)
  			{
  				m_RegionValue->getOwnedComment()->erase(inputValue->getCommentValue());
  			}
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_name())
  	{
  				// no default value defined, clear not realized
  
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression())
  	{
  				m_RegionValue->getNameExpression().reset();
  
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_visibility())
  	{
  				// no default value defined, clear not realized
  
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_elementImport())
  	{
  		if (value == nullptr) // clear mode
  		{
  			m_RegionValue->getElementImport()->clear();
  		}
  		else
  		{
  			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
  			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
  			std::shared_ptr<UML::ElementImportObject> inputValue = std::dynamic_pointer_cast<UML::ElementImportObject>(reference->getReferent());
  			if (inputValue != nullptr)
  			{
  				m_RegionValue->getElementImport()->erase(inputValue->getElementImportValue());
  			}
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_ownedRule())
  	{
  		if (value == nullptr) // clear mode
  		{
  			m_RegionValue->getOwnedRule()->clear();
  		}
  		else
  		{
  			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
  			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
  			std::shared_ptr<UML::ConstraintObject> inputValue = std::dynamic_pointer_cast<UML::ConstraintObject>(reference->getReferent());
  			if (inputValue != nullptr)
  			{
  				m_RegionValue->getOwnedRule()->erase(inputValue->getConstraintValue());
  			}
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_packageImport())
  	{
  		if (value == nullptr) // clear mode
  		{
  			m_RegionValue->getPackageImport()->clear();
  		}
  		else
  		{
  			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
  			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
  			std::shared_ptr<UML::PackageImportObject> inputValue = std::dynamic_pointer_cast<UML::PackageImportObject>(reference->getReferent());
  			if (inputValue != nullptr)
  			{
  				m_RegionValue->getPackageImport()->erase(inputValue->getPackageImportValue());
  			}
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_isLeaf())
  	{
  				m_RegionValue->setIsLeaf(false /*defined default value*/);
  
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_extendedRegion())
  	{
  				m_RegionValue->getExtendedRegion().reset();
  
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_state())
  	{
  				m_RegionValue->getState().reset();
  
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_stateMachine())
  	{
  				m_RegionValue->getStateMachine().reset();
  
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_subvertex())
  	{
  		if (value == nullptr) // clear mode
  		{
  			m_RegionValue->getSubvertex()->clear();
  		}
  		else
  		{
  			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
  			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
  			std::shared_ptr<UML::VertexObject> inputValue = std::dynamic_pointer_cast<UML::VertexObject>(reference->getReferent());
  			if (inputValue != nullptr)
  			{
  				m_RegionValue->getSubvertex()->erase(inputValue->getVertexValue());
  			}
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_transition())
  	{
  		if (value == nullptr) // clear mode
  		{
  			m_RegionValue->getTransition()->clear();
  		}
  		else
  		{
  			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
  			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
  			std::shared_ptr<UML::TransitionObject> inputValue = std::dynamic_pointer_cast<UML::TransitionObject>(reference->getReferent());
  			if (inputValue != nullptr)
  			{
  				m_RegionValue->getTransition()->erase(inputValue->getTransitionValue());
  			}
  		}
  	}
  }
  
  
  std::shared_ptr<Bag<fUML::Semantics::Values::Value>> RegionObject::getValues(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> featureValues)
  {
  	if (feature->getMetaElementID() != uml::umlPackage::PROPERTY_CLASS && feature->getMetaElementID() != uml::umlPackage::PORT_CLASS && feature->getMetaElementID() != uml::umlPackage::EXTENSIONEND_CLASS)
  	{
  		std::cerr << __PRETTY_FUNCTION__ << ": feature is null or not kind of uml::Property" << std::endl;
  		throw "feature is null or not kind of uml::Property";
  	}
  
  	if (m_RegionValue == nullptr)
  	{
  		std::cerr << __PRETTY_FUNCTION__ << ": no value stored inside RegionObject (property: " << feature->getName() << ")" << std::endl;
  		throw "NullPointerException";	
  	}
  
  	std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values(new Bag<fUML::Semantics::Values::Value>());
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment())
  	{
  		std::shared_ptr<Bag<uml::Comment>> ownedCommentList = m_RegionValue->getOwnedComment();
  		Bag<uml::Comment>::iterator iter = ownedCommentList->begin();
  		Bag<uml::Comment>::iterator end = ownedCommentList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::CommentObject> value(new UML::CommentObject());
  			value->setThisCommentObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setCommentValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedElement())
  	{
  		std::shared_ptr<Bag<uml::Element>> ownedElementList = m_RegionValue->getOwnedElement();
  		Bag<uml::Element>::iterator iter = ownedElementList->begin();
  		Bag<uml::Element>::iterator end = ownedElementList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::ElementObject> value(new UML::ElementObject());
  			value->setThisElementObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setElementValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_owner())
  	{
  		std::shared_ptr<UML::ElementObject> value(new UML::ElementObject());
  		value->setThisElementObjectPtr(value);
  		value->setLocus(this->getLocus());
  		value->setElementValue(m_RegionValue->getOwner().lock());
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  		reference->setReferent(value);
  		values->add(reference);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_clientDependency())
  	{
  		std::shared_ptr<Bag<uml::Dependency>> clientDependencyList = m_RegionValue->getClientDependency();
  		Bag<uml::Dependency>::iterator iter = clientDependencyList->begin();
  		Bag<uml::Dependency>::iterator end = clientDependencyList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::DependencyObject> value(new UML::DependencyObject());
  			value->setThisDependencyObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setDependencyValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_name())
  	{
  		std::shared_ptr<fUML::Semantics::SimpleClassifiers::StringValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createStringValue();
  		value->setValue(m_RegionValue->getName());
  		values->add(value);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression())
  	{
  		std::shared_ptr<UML::StringExpressionObject> value(new UML::StringExpressionObject());
  		value->setThisStringExpressionObjectPtr(value);
  		value->setLocus(this->getLocus());
  		value->setStringExpressionValue(m_RegionValue->getNameExpression());
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  		reference->setReferent(value);
  		reference->setCompositeReferent(value);
  		values->add(reference);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_namespace())
  	{
  		std::shared_ptr<UML::NamespaceObject> value(new UML::NamespaceObject());
  		value->setThisNamespaceObjectPtr(value);
  		value->setLocus(this->getLocus());
  		value->setNamespaceValue(m_RegionValue->getNamespace().lock());
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  		reference->setReferent(value);
  		values->add(reference);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_qualifiedName())
  	{
  		std::shared_ptr<fUML::Semantics::SimpleClassifiers::StringValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createStringValue();
  		value->setValue(m_RegionValue->getQualifiedName());
  		values->add(value);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_visibility())
  	{
  		uml::VisibilityKind visibility = m_RegionValue->getVisibility();
  		std::shared_ptr<fUML::Semantics::SimpleClassifiers::EnumerationValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createEnumerationValue();
  		if (visibility == uml::VisibilityKind::PUBLIC)
  		{
  			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_public());
  		}
  		if (visibility == uml::VisibilityKind::PRIVATE)
  		{
  			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_private());
  		}
  		if (visibility == uml::VisibilityKind::PROTECTED)
  		{
  			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_protected());
  		}
  		if (visibility == uml::VisibilityKind::PACKAGE)
  		{
  			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_package());
  		}
  		values->add(value);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_elementImport())
  	{
  		std::shared_ptr<Bag<uml::ElementImport>> elementImportList = m_RegionValue->getElementImport();
  		Bag<uml::ElementImport>::iterator iter = elementImportList->begin();
  		Bag<uml::ElementImport>::iterator end = elementImportList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::ElementImportObject> value(new UML::ElementImportObject());
  			value->setThisElementImportObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setElementImportValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_importedMember())
  	{
  		std::shared_ptr<Bag<uml::PackageableElement>> importedMemberList = m_RegionValue->getImportedMember();
  		Bag<uml::PackageableElement>::iterator iter = importedMemberList->begin();
  		Bag<uml::PackageableElement>::iterator end = importedMemberList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::PackageableElementObject> value(new UML::PackageableElementObject());
  			value->setThisPackageableElementObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setPackageableElementValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_member())
  	{
  		std::shared_ptr<Bag<uml::NamedElement>> memberList = m_RegionValue->getMember();
  		Bag<uml::NamedElement>::iterator iter = memberList->begin();
  		Bag<uml::NamedElement>::iterator end = memberList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::NamedElementObject> value(new UML::NamedElementObject());
  			value->setThisNamedElementObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setNamedElementValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_ownedMember())
  	{
  		std::shared_ptr<Bag<uml::NamedElement>> ownedMemberList = m_RegionValue->getOwnedMember();
  		Bag<uml::NamedElement>::iterator iter = ownedMemberList->begin();
  		Bag<uml::NamedElement>::iterator end = ownedMemberList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::NamedElementObject> value(new UML::NamedElementObject());
  			value->setThisNamedElementObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setNamedElementValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_ownedRule())
  	{
  		std::shared_ptr<Bag<uml::Constraint>> ownedRuleList = m_RegionValue->getOwnedRule();
  		Bag<uml::Constraint>::iterator iter = ownedRuleList->begin();
  		Bag<uml::Constraint>::iterator end = ownedRuleList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::ConstraintObject> value(new UML::ConstraintObject());
  			value->setThisConstraintObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setConstraintValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_packageImport())
  	{
  		std::shared_ptr<Bag<uml::PackageImport>> packageImportList = m_RegionValue->getPackageImport();
  		Bag<uml::PackageImport>::iterator iter = packageImportList->begin();
  		Bag<uml::PackageImport>::iterator end = packageImportList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::PackageImportObject> value(new UML::PackageImportObject());
  			value->setThisPackageImportObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setPackageImportValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_isLeaf())
  	{
  		std::shared_ptr<fUML::Semantics::SimpleClassifiers::BooleanValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createBooleanValue();
  		value->setValue(m_RegionValue->getIsLeaf());
  		values->add(value);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_redefinedElement())
  	{
  		std::shared_ptr<Bag<uml::RedefinableElement>> redefinedElementList = m_RegionValue->getRedefinedElement();
  		Bag<uml::RedefinableElement>::iterator iter = redefinedElementList->begin();
  		Bag<uml::RedefinableElement>::iterator end = redefinedElementList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::RedefinableElementObject> value(new UML::RedefinableElementObject());
  			value->setThisRedefinableElementObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setRedefinableElementValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_extendedRegion())
  	{
  		std::shared_ptr<UML::RegionObject> value(new UML::RegionObject());
  		value->setThisRegionObjectPtr(value);
  		value->setLocus(this->getLocus());
  		value->setRegionValue(m_RegionValue->getExtendedRegion());
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  		reference->setReferent(value);
  		values->add(reference);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_redefinitionContext())
  	{
  		std::cout << __PRETTY_FUNCTION__ << ": multiplicity conflict between property 'redefinitionContext[1..1]' and redefined property 'redefinitionContext[0..-1]'" << std::endl;
  		exit(EXIT_FAILURE);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_state())
  	{
  		std::shared_ptr<UML::StateObject> value(new UML::StateObject());
  		value->setThisStateObjectPtr(value);
  		value->setLocus(this->getLocus());
  		value->setStateValue(m_RegionValue->getState().lock());
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  		reference->setReferent(value);
  		values->add(reference);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_stateMachine())
  	{
  		std::shared_ptr<UML::StateMachineObject> value(new UML::StateMachineObject());
  		value->setThisStateMachineObjectPtr(value);
  		value->setLocus(this->getLocus());
  		value->setStateMachineValue(m_RegionValue->getStateMachine().lock());
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  		reference->setReferent(value);
  		values->add(reference);
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_subvertex())
  	{
  		std::shared_ptr<Bag<uml::Vertex>> subvertexList = m_RegionValue->getSubvertex();
  		Bag<uml::Vertex>::iterator iter = subvertexList->begin();
  		Bag<uml::Vertex>::iterator end = subvertexList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::VertexObject> value(new UML::VertexObject());
  			value->setThisVertexObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setVertexValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_transition())
  	{
  		std::shared_ptr<Bag<uml::Transition>> transitionList = m_RegionValue->getTransition();
  		Bag<uml::Transition>::iterator iter = transitionList->begin();
  		Bag<uml::Transition>::iterator end = transitionList->end();
  		while (iter != end)
  		{
  			std::shared_ptr<UML::TransitionObject> value(new UML::TransitionObject());
  			value->setThisTransitionObjectPtr(value);
  			value->setLocus(this->getLocus());
  			value->setTransitionValue(*iter);
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
  			reference->setReferent(value);
  			reference->setCompositeReferent(value);
  			values->add(reference);
  			iter++;
  		} 
  	}
  	return values;
  }
  
  std::shared_ptr<fUML::Semantics::SimpleClassifiers::FeatureValue> RegionObject::retrieveFeatureValue(std::shared_ptr<uml::StructuralFeature> feature)
  {
  	std::shared_ptr<fUML::Semantics::SimpleClassifiers::FeatureValue> featureValue(fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createFeatureValue());
  	featureValue->setFeature(feature);
  
  	std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> featureValues(new Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>());
  	std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values = this->getValues(feature, featureValues);
  	
  	unsigned int valuesSize = values->size();
  	for(unsigned int i = 0; i < valuesSize; i++)
  	{
  		featureValue->getValues()->add(values->at(i));
  	}
  
  	return featureValue;
  }
  
  
  void RegionObject::setFeatureValue(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values, int position)
  {
  	if (feature->getMetaElementID() != uml::umlPackage::PROPERTY_CLASS && feature->getMetaElementID() != uml::umlPackage::PORT_CLASS && feature->getMetaElementID() != uml::umlPackage::EXTENSIONEND_CLASS)
  	{
  		std::cerr << __PRETTY_FUNCTION__ << ": feature is null or not kind of uml::Property" << std::endl;
  		throw "feature is null or not kind of uml::Property";
  	}
  
  	if (m_RegionValue == nullptr)
  	{
  		std::cerr << __PRETTY_FUNCTION__ << ": no value stored inside RegionObject (property: " << feature->getName() << ")" << std::endl;
  		throw "NullPointerException";	
  	}
  
  	if (values->size() == 0)
  	{
  		std::cout << __PRETTY_FUNCTION__ << ": no input value given" << std::endl;
  		return;
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment())
  	{
  		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
  		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
  		m_RegionValue->getOwnedComment()->clear();
  		while (iter != end)
  		{
  			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  			std::shared_ptr<UML::CommentObject> value = std::dynamic_pointer_cast<UML::CommentObject>(reference->getReferent());
  			if (value != nullptr)
  			{
  				m_RegionValue->getOwnedComment()->push_back(value->getCommentValue());
  			}
  			
  			iter++;
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_name())
  	{
  		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
  		std::shared_ptr<fUML::Semantics::SimpleClassifiers::StringValue> valueObject = std::dynamic_pointer_cast<fUML::Semantics::SimpleClassifiers::StringValue>(inputValue);
  		if (valueObject != nullptr)
  		{
  			m_RegionValue->setName(valueObject->getValue());
  		}
  		
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression())
  	{
  		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  		std::shared_ptr<UML::StringExpressionObject> value = std::dynamic_pointer_cast<UML::StringExpressionObject>(reference->getReferent());
  		if (value != nullptr)
  		{
  			m_RegionValue->setNameExpression(value->getStringExpressionValue());
  		}
  		
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_visibility())
  	{
  		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
  		std::shared_ptr<fUML::Semantics::SimpleClassifiers::EnumerationValue> enumValue = std::dynamic_pointer_cast<fUML::Semantics::SimpleClassifiers::EnumerationValue>(inputValue);
  		std::shared_ptr<uml::EnumerationLiteral> literal = enumValue->getLiteral();
  		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_public())
  		{
  			m_RegionValue->setVisibility(uml::VisibilityKind::PUBLIC);
  		}
  		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_private())
  		{
  			m_RegionValue->setVisibility(uml::VisibilityKind::PRIVATE);
  		}
  		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_protected())
  		{
  			m_RegionValue->setVisibility(uml::VisibilityKind::PROTECTED);
  		}
  		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_package())
  		{
  			m_RegionValue->setVisibility(uml::VisibilityKind::PACKAGE);
  		}
  		
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_elementImport())
  	{
  		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
  		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
  		m_RegionValue->getElementImport()->clear();
  		while (iter != end)
  		{
  			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  			std::shared_ptr<UML::ElementImportObject> value = std::dynamic_pointer_cast<UML::ElementImportObject>(reference->getReferent());
  			if (value != nullptr)
  			{
  				m_RegionValue->getElementImport()->push_back(value->getElementImportValue());
  			}
  			
  			iter++;
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_ownedRule())
  	{
  		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
  		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
  		m_RegionValue->getOwnedRule()->clear();
  		while (iter != end)
  		{
  			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  			std::shared_ptr<UML::ConstraintObject> value = std::dynamic_pointer_cast<UML::ConstraintObject>(reference->getReferent());
  			if (value != nullptr)
  			{
  				m_RegionValue->getOwnedRule()->push_back(value->getConstraintValue());
  			}
  			
  			iter++;
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Namespace_packageImport())
  	{
  		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
  		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
  		m_RegionValue->getPackageImport()->clear();
  		while (iter != end)
  		{
  			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  			std::shared_ptr<UML::PackageImportObject> value = std::dynamic_pointer_cast<UML::PackageImportObject>(reference->getReferent());
  			if (value != nullptr)
  			{
  				m_RegionValue->getPackageImport()->push_back(value->getPackageImportValue());
  			}
  			
  			iter++;
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_isLeaf())
  	{
  		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
  		std::shared_ptr<fUML::Semantics::SimpleClassifiers::BooleanValue> valueObject = std::dynamic_pointer_cast<fUML::Semantics::SimpleClassifiers::BooleanValue>(inputValue);
  		if (valueObject != nullptr)
  		{
  			m_RegionValue->setIsLeaf(valueObject->isValue());
  		}
  		
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_extendedRegion())
  	{
  		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
  		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  		std::shared_ptr<UML::RegionObject> value = std::dynamic_pointer_cast<UML::RegionObject>(reference->getReferent());
  		if (value != nullptr)
  		{
  			m_RegionValue->setExtendedRegion(value->getRegionValue());
  		}
  		
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_subvertex())
  	{
  		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
  		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
  		m_RegionValue->getSubvertex()->clear();
  		while (iter != end)
  		{
  			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  			std::shared_ptr<UML::VertexObject> value = std::dynamic_pointer_cast<UML::VertexObject>(reference->getReferent());
  			if (value != nullptr)
  			{
  				m_RegionValue->getSubvertex()->push_back(value->getVertexValue());
  			}
  			
  			iter++;
  		}
  	}
  	if (feature == UML::UMLPackage::eInstance()->get_UML_Region_transition())
  	{
  		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
  		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
  		m_RegionValue->getTransition()->clear();
  		while (iter != end)
  		{
  			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
  			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
  			std::shared_ptr<UML::TransitionObject> value = std::dynamic_pointer_cast<UML::TransitionObject>(reference->getReferent());
  			if (value != nullptr)
  			{
  				m_RegionValue->getTransition()->push_back(value->getTransitionValue());
  			}
  			
  			iter++;
  		}
  	}
  }
  
  void RegionObject::assignFeatureValue(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values, int position)
  {
  	this->setFeatureValue(feature, values, position);
  }
  
  std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> RegionObject::retrieveFeatureValues()
  {
  	std::shared_ptr<uml::Classifier> type = this->getTypes()->at(0);
  	std::shared_ptr<Bag<uml::Property>> allAttributes = type->getAllAttributes();
  	std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> featureValues(new Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>());
  	
  	unsigned int allAttributesSize = allAttributes->size();
  
  	for(unsigned int i = 0; i < allAttributesSize; i++)
  	{
  		std::shared_ptr<uml::Property> property = allAttributes->at(i);
  		if (property == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment() && m_RegionValue->getOwnedComment() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Element_ownedElement() && m_RegionValue->getOwnedElement() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Element_owner() && m_RegionValue->getOwner().lock() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_NamedElement_clientDependency() && m_RegionValue->getClientDependency() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression() && m_RegionValue->getNameExpression() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_NamedElement_namespace() && m_RegionValue->getNamespace().lock() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Namespace_elementImport() && m_RegionValue->getElementImport() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Namespace_importedMember() && m_RegionValue->getImportedMember() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Namespace_member() && m_RegionValue->getMember() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Namespace_ownedMember() && m_RegionValue->getOwnedMember() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Namespace_ownedRule() && m_RegionValue->getOwnedRule() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Namespace_packageImport() && m_RegionValue->getPackageImport() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_redefinedElement() && m_RegionValue->getRedefinedElement() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Region_extendedRegion() && m_RegionValue->getExtendedRegion() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Region_redefinitionContext() && m_RegionValue->getRedefinitionContext() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Region_state() && m_RegionValue->getState().lock() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Region_stateMachine() && m_RegionValue->getStateMachine().lock() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Region_subvertex() && m_RegionValue->getSubvertex() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  		if (property == UML::UMLPackage::eInstance()->get_UML_Region_transition() && m_RegionValue->getTransition() != nullptr)
  		{
  			featureValues->add(this->retrieveFeatureValue(property));
  		}
  	}
  	
  	return featureValues;
  }
  
  