UMLState
@constructor
@extends UMLVertex
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 = [];
    }
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);
    }
325680
function UMLGeneralizationView() {
        UMLGeneralEdgeView.apply(this, arguments);
        this.tailEndStyle = Core.ES_FLAT;
        this.headEndStyle = Core.ES_TRIANGLE;
        this.lineMode = Core.LM_SOLID;
    }
831243
function UMLOperation() {
        UMLBehavioralFeature.apply(this, arguments);

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

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

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

        /** @member {Array.<UMLConstraint>} */
        this.preconditions = [];

        /** @member {Array.<UMLConstraint>} */
        this.bodyConditions = [];

        /** @member {Array.<UMLConstraint>} */
        this.postconditions = [];
    }
200898
function(state) {
			var changed = false,
				opts = this.tree.options,
				unselectable = FT.evalOption(
					"unselectable",
					this,
					this,
					opts,
					false
				),
				unselectableStatus = FT.evalOption(
					"unselectableStatus",
					this,
					this,
					opts,
					undefined
				);

			if (unselectable && unselectableStatus != null) {
				state = unselectableStatus;
			}
			switch (state) {
				case false:
					changed = this.selected || this.partsel;
					this.selected = false;
					this.partsel = false;
					break;
				case true:
					changed = !this.selected || !this.partsel;
					this.selected = true;
					this.partsel = true;
					break;
				case undefined:
					changed = this.selected || !this.partsel;
					this.selected = false;
					this.partsel = true;
					break;
				default:
					_assert(false, "invalid state: " + state);
			}
			// this.debug("fixSelection3AfterLoad() _changeSelectStatusAttrs()", state, changed);
			if (changed) {
				this.renderStatus();
			}
			return changed;
		}
39309
function UMLCollaborationView() {
        UMLGeneralNodeView.apply(this, arguments);

        /** @member {UMLTemplateParameterCompartmentView} */
        this.templateParameterCompartment = new UMLTemplateParameterCompartmentView();
        this.templateParameterCompartment.selectable = Core.SK_PROPAGATE;
        this.templateParameterCompartment.parentStyle = true;
        this.addSubView(this.templateParameterCompartment);

        this.fillColor = PreferenceManager.get("uml.collaboration.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
    }
380205
function createAgentChildState (appname, moduleName, state, parentStateName, moduleUrl) {
  var controllerPath = path.join(appname, 'generated', 'agents', moduleName, 'controllers'),
    partialPath = path.join(appname, 'generated', 'partials', 'agents', moduleName)

  state['name'] = state.subPath.replace('/', '')

  fs.mkdir(path.join(controllerPath, parentStateName), function (response) {
    createTemplate(appname, path.join('generated', 'agents', 'agentChildController.js'), {
      moduleName: moduleName,
      state: state
    })
    var oldControllerPath = path.join(appname, 'generated', 'agents', 'agentChildController.js'),
      newControllerPath = path.join(controllerPath, parentStateName, state.name + '.js')
    fs.renameSync(oldControllerPath, newControllerPath)
  })

  fs.mkdir(path.join(partialPath, parentStateName), function (response) {
    createTemplate(appname, path.join('generated', 'agents', 'agentChild.html'), {
      moduleName: moduleName,
      parentStateName: parentStateName,
      state: state,
      moduleUrl: moduleUrl

    })

    var oldHtmlPath = path.join(appname, 'generated', 'agents', 'agentChild.html'), newHtmlPath = path.join(partialPath,
        parentStateName, state.name + '.html')
    fs.renameSync(oldHtmlPath, newHtmlPath)
  })
}
975868
function UMLActivityInterruptView() {
        UMLGeneralEdgeView.apply(this, arguments);
        this.tailEndStyle = Core.ES_FLAT;
        this.headEndStyle = Core.ES_STICK_ARROW;
        this.lineMode = Core.LM_SOLID;
        
        /** @member {UMLZigZagAdornmentView} */
        this.adornment = new UMLZigZagAdornmentView();
        this.adornment.parentStyle = true;
        this.addSubView(this.adornment);        
    }
1337365
function UMLPort() {
        UMLAttribute.apply(this, arguments);

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

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

        /** @member {boolean} */
        this.isConjugated = false;
    }
1333744
function UMLPartView() {
        UMLGeneralNodeView.apply(this, arguments);
        this.containerChangeable = false;
        this.showVisibility = false;

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

        this.fillColor = PreferenceManager.get("uml.part.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
    }
415642
function UMLComponentRealizationView() {
        UMLGeneralEdgeView.apply(this, arguments);
        this.tailEndStyle = Core.ES_FLAT;
        this.headEndStyle = Core.ES_TRIANGLE;
        this.lineMode = Core.LM_DOT;
    }
77796
public void createStateModelBinding(final TransitionableState state, final String modelName, final Class modelType) {
        state.getAttributes().put("model", createExpression(modelName, modelType));
    }
906537
function UMLAttribute() {
        UMLStructuralFeature.apply(this, arguments);

        /** @member {string} */
        this.isDerived = false;

        /** @member {string} */
        this.aggregation = AK_NONE;

        /** @member {boolean} */
        this.isID = false;
    }
125970
function UMLPackageView() {
        UMLGeneralNodeView.apply(this, arguments);
        this.containerChangeable = true;
        this.fillColor = PreferenceManager.get("uml.package.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
    }
65473
function render(expr, traverse, path, state) {
  if (isString(expr)) {
    utils.append(expr, state);
  } else if (Array.isArray(expr)) {
    expr.forEach(function(w) {
      render(w, traverse, path, state);
    });
  } else {
    utils.move(expr.range[0], state);
    traverse(expr, path, state);
    utils.catchup(expr.range[1], state);
  }
}
689788
private function EnterState()
	{
		switch ( $this->m_state )
		{
			case LexerState::DefaultState:
				$this->DefaultState();
				break;

			case LexerState::Operator:
				$this->OperatorState();
				break;

			case LexerState::VarName:
				$this->VarNameState();
				break;


			case LexerState::SingleType:
				$this->SingleTypeState();
				break;

			case LexerState::ItemType:
				$this->ItemTypeState();
				break;

			case LexerState::KindTest:
				$this->KindTestState();
				break;

			case LexerState::KindTestForPi:
				$this->KindTestForPiState();
				break;

			case LexerState::CloseKindTest:
				$this->CloseKindTestState();
				break;

			case LexerState::OccurrenceIndicator:
				$this->OccurrenceIndicatorState();
				break;
		}
	}
1008549
function processInitState(state, action) {
    const { data, persistState, path } = action.payload;
    const pathItems = path.split("/");
    const doNotReplace = persistState;
    const hasData = objectPath.has(state, pathItems);
    if (hasData) {
        if (doNotReplace) {
            // --- has initialised
            // --- force component.state to refresh
            const existingData = objectPath.get(state, pathItems);
            return objectPathImmutable.merge(state, pathItems, existingData);
        }
    }
    return objectPathImmutable.merge(state, pathItems, data);
}