UMLMessage
@constructor
@extends UMLDirectedRelationship
971515
function UMLMessage() {
        UMLDirectedRelationship.apply(this, arguments);

        /** @member {string} */
        this.messageSort = MS_SYNCHCALL;

        /** @member {UMLOperation} */
        this.signature = null;

        /** @member {UMLConnector} */
        this.connector = null;

        /** @member {string} */
        this["arguments"] = '';

        /** @member {string} */
        this.assignmentTarget = '';

        /** @member {string} */
        this.guard = '';

        /** @member {string} */
        this.iteration = '';

        /** @member {boolean} */
        this.isConcurrentIteration = false;
    }
431513
function UMLActivationView() {
        NodeView.apply(this, arguments);
        this.sizable = Core.SZ_VERT;
        this.movable = Core.MM_NONE;
    }
134080
function UMLStateInvariantView() {
        NodeView.apply(this, arguments);
        this.movable = Core.MM_VERT;
        this.zIndex = 1;

        /** @member {LabelView} */
        this.invariantLabel = new LabelView();
        this.invariantLabel.horizontalAlignment = Graphics.AL_CENTER;
        this.invariantLabel.verticalAlignment = Graphics.AL_MIDDLE;
        this.addSubView(this.invariantLabel);
    }
1196844
function UMLGeneralEdgeView() {
        EdgeView.apply(this, arguments);

        /** @member {string} */
        this.stereotypeDisplay = UML.SD_LABEL;

        /** @member {boolean} */
        this.showVisibility = true;

        /** @member {boolean} */
        this.showProperty = true;

        /** @member {EdgeLabelView} */
        this.nameLabel = new EdgeLabelView();
        this.nameLabel.hostEdge = this;
        this.nameLabel.edgePosition = Core.EP_MIDDLE;
        this.nameLabel.distance = 15;
        this.nameLabel.alpha = Math.PI / 2;
        this.addSubView(this.nameLabel);

        /** @member {EdgeLabelView} */
        this.stereotypeLabel = new EdgeLabelView();
        this.stereotypeLabel.hostEdge = this;
        this.stereotypeLabel.edgePosition = Core.EP_MIDDLE;
        this.stereotypeLabel.distance = 30;
        this.stereotypeLabel.alpha = Math.PI / 2;
        this.addSubView(this.stereotypeLabel);

        /** @member {EdgeLabelView} */
        this.propertyLabel = new EdgeLabelView();
        this.propertyLabel.hostEdge = this;
        this.propertyLabel.edgePosition = Core.EP_MIDDLE;
        this.propertyLabel.distance = 15;
        this.propertyLabel.alpha = -Math.PI / 2;
        this.addSubView(this.propertyLabel);
    }
1069885
function UMLClassView() {
        UMLClassifierView.apply(this, arguments);
        this.fillColor  = PreferenceManager.get("uml.class.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
        this.stereotypeDisplay  = PreferenceManager.get("uml.class.stereotypeDisplay", UML.SD_LABEL);
        this.suppressAttributes = PreferenceManager.get("uml.class.suppressAttributes", false);
        this.suppressOperations = PreferenceManager.get("uml.class.suppressOperations", false);
    }
121673
void populateRelationForM2M(Object entity, EntityMetadata entityMetadata, PersistenceDelegator delegator,
            Relation relation, Object relObject, Map<String, Object> relationsMap)
    {
        // For M-M relationship of Collection type, relationship entities are
        // always fetched from Join Table.
        if (relation.getPropertyType().isAssignableFrom(List.class)
                || relation.getPropertyType().isAssignableFrom(Set.class))
        {
            if (relation.isRelatedViaJoinTable() && (relObject == null || ProxyHelper.isProxyOrCollection(relObject)))
            {
                populateCollectionFromJoinTable(entity, entityMetadata, delegator, relation);
            }

        }
        else if (relation.getPropertyType().isAssignableFrom(Map.class))
        {
            if (relation.isRelatedViaJoinTable())
            {
                // TODO: Implement Map relationships via Join Table (not
                // supported as of now)
            }
            else
            {
                populateCollectionFromMap(entity, delegator, relation, relObject, relationsMap);
            }
        }
    }
497319
function( model, attr, options ) {
			// Don't accept recursive calls to onChange (like onChange->findRelated->findOrCreate->initializeRelations->addRelated->onChange)
			if ( this.isLocked() ) {
				return;
			}
			this.acquire();
			options = this.sanitizeOptions( options );
			
			// 'options._related' is set by 'addRelated'/'removeRelated'. If it is set, the change
			// is the result of a call from a relation. If it's not, the change is the result of 
			// a 'set' call on this.instance.
			var changed = _.isUndefined( options._related );
			var oldRelated = changed ? this.related : options._related;
			
			if ( changed ) {	
				this.keyContents = attr;
				
				// Set new 'related'
				if ( attr instanceof this.relatedModel ) {
					this.related = attr;
				}
				else if ( attr ) {
					var related = this.findRelated( options );
					this.setRelated( related );
				}
				else {
					this.setRelated( null );
				}
			}
			
			// Notify old 'related' object of the terminated relation
			if ( oldRelated && this.related !== oldRelated ) {
				_.each( this.getReverseRelations( oldRelated ), function( relation ) {
						relation.removeRelated( this.instance, options );
					}, this );
			}
			
			// Notify new 'related' object of the new relation. Note we do re-apply even if this.related is oldRelated;
			// that can be necessary for bi-directional relations if 'this.instance' was created after 'this.related'.
			// In that case, 'this.instance' will already know 'this.related', but the reverse might not exist yet.
			_.each( this.getReverseRelations(), function( relation ) {
					relation.addRelated( this.instance, options );
				}, this);
			
			// Fire the 'update:<key>' event if 'related' was updated
			if ( !options.silentChange && this.related !== oldRelated ) {
				var dit = this;
				Backbone.Relational.eventQueue.add( function() {
					dit.instance.trigger( 'update:' + dit.key, dit.instance, dit.related, options );
				});
			}
			this.release();
		}
169425
function UMLComponentInstanceView() {
        UMLGeneralNodeView.apply(this, arguments);
        this.containerChangeable = true;
        // mixin UMLComponentViewMixin
        _.extend(UMLComponentInstanceView.prototype, UMLComponentViewMixin);

        this.fillColor = PreferenceManager.get("uml.componentinstance.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
        this.stereotypeDisplay  = PreferenceManager.get("uml.component.stereotypeDisplay", UML.SD_LABEL);
    }
1068938
function UMLClassifier() {
        UMLModelElement.apply(this, arguments);

        /** @member {Array.<UMLAttribute>} */
        this.attributes = [];

        /** @member {Array.<UMLOperation>} */
        this.operations = [];

        /** @member {Array.<UMLReception>} */
        this.receptions = [];

        /** @member {Array.<UMLBehavior>} */
        this.behaviors = [];

        /** @member {boolean} */
        this.isAbstract = false;

        /** @member {boolean} */
        this.isFinalSpecialization = false;

        /** @member {boolean} */
        this.isLeaf = false;
    }
633938
function parseRelations (data, relations, options) {
  var relationships = {}

  _.each(relations, function (relation, name) {
    var fkName = relation.keyTo

    // If relation is belongsTo then fk is the other way around
    if (utils.relationFkOnModelFrom(relation)) {
      fkName = relation.keyFrom
    }

    var pk = data[options.primaryKeyField]
    var fk = data[fkName]

    var toType = ''
    if (relation.polymorphic && utils.relationFkOnModelFrom(relation)) {
      var discriminator = relation.polymorphic.discriminator
      var model = options.app.models[data[discriminator]]
      toType = utils.pluralForModel(model)
    } else {
      toType = utils.pluralForModel(relation.modelTo)
    }

    // Relationship `links` should always be defined unless this is a
    // relationship request
    if (!options.isRelationshipRequest) {
      relationships[name] = {
        links: {
          related: options.host +
            options.restApiRoot +
            '/' +
            options.modelPath +
            '/' +
            pk +
            '/' +
            name
        }
      }
    }

    var relationship = null

    if (!_.isUndefined(fk) && relation.modelTo !== relation.modelFrom) {
      if (_.isArray(fk)) {
        relationship = makeRelations(toType, fk, options)
      } else {
        relationship = makeRelation(toType, fk, options)
      }
    }

    // No `data` key should be present unless there is actual relationship data.
    if (relationship) {
      relationships[name].data = relationship
    } else if (relation.type === 'belongsTo') {
      relationships[name].data = null
    }
  })

  return relationships
}
327368
function UMLContinuationView() {
        NodeView.apply(this, arguments);
        this.zIndex = 1;

        /** @member {LabelView} */
        this.nameLabel = new LabelView();
        this.nameLabel.horizontalAlignment = Graphics.AL_CENTER;
        this.nameLabel.verticalAlignment = Graphics.AL_MIDDLE;
        this.addSubView(this.nameLabel);
    }
610043
function UMLConnector() {
        UMLUndirectedRelationship.apply(this, arguments);

        /** @member {UMLConnectorEnd} */
        this.end1 = new UMLConnectorEnd();
        this.end1._parent = this;

        /** @member {UMLConnectorEnd} */
        this.end2 = new UMLConnectorEnd();
        this.end2._parent = this;

        /** @member {UMLAssociation} */
        this.type = null;

        /** @member {UMLConnectorKind} */
        this.kind = CK_ASSEMBLY;
    }
20020
function( relation ) {
			if ( relation.instance instanceof this.relatedModel && this.reverseRelation.key === relation.key
					&&	this.key === relation.reverseRelation.key ) {
				return true;
			}
			return false;
		}
241698
function UMLUndirectedRelationship() {
        type.UndirectedRelationship.apply(this, arguments);

        /** @member {UMLStereotype} */
        this.stereotype = null;

        /** @member {string} */
        this.visibility = VK_PUBLIC;

        // mixin UMLElementMixin
        _.extend(UMLUndirectedRelationship.prototype, UMLElementMixin);
    }
848922
function UMLStateView() {
        UMLGeneralNodeView.apply(this, arguments);
        this.containerChangeable = true;

        /** @member {UMLInternalActivityCompartmentView} */
        this.internalActivityCompartment = new UMLInternalActivityCompartmentView();
        this.internalActivityCompartment.parentStyle = true;
        this.addSubView(this.internalActivityCompartment);

        /** @member {UMLInternalTransitionCompartmentView} */
        this.internalTransitionCompartment = new UMLInternalTransitionCompartmentView();
        this.internalTransitionCompartment.parentStyle = true;
        this.addSubView(this.internalTransitionCompartment);

        /** @member {UMLDecompositionCompartmentView} */
        this.decompositionCompartment = new UMLDecompositionCompartmentView();
        this.decompositionCompartment.parentStyle = true;
        this.addSubView(this.decompositionCompartment);

        this.fillColor = PreferenceManager.get("uml.state.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
    }
329630
function UMLState() {
        UMLVertex.apply(this, arguments);

        /** @member {Array.<UMLRegion>} */
        this.regions = [];

        /** @member {Array.<UMLBehavior>} */
        this.entryActivities = [];

        /** @member {Array.<UMLBehavior>} */
        this.doActivities = [];

        /** @member {Array.<UMLBehavior>} */
        this.exitActivities = [];

        /** @member {UMLStateMachine} */
        this.submachine = null;

        /** @member {UMLConnectionPointReference} */
        this.connections = [];
    }
1337365
function UMLPort() {
        UMLAttribute.apply(this, arguments);

        /** @member {boolean} */
        this.isBehavior = false;

        /** @member {boolean} */
        this.isService = false;

        /** @member {boolean} */
        this.isConjugated = false;
    }