Get stereotype string

@memberof UMLElementMixin
@return {string}
480940
function () {
            if (_.isString(this.stereotype) && (this.stereotype.length > 0)) {
                return "«" + this.stereotype + "»";
            } else if (this.stereotype instanceof type.Model) {
                return "«" + this.stereotype.name + "»";
            }
            return "";
        }
27616
function getType(fileName) {
        var type = 'text';
        if (fileName.indexOf('.json') === fileName.length - 5) {
            type = 'json';
        } else if (fileName.indexOf('.yml') === fileName.length - 4) {
            type = 'yml';
        }
        return type;
    }
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);
    }
274786
@Override
	public String getMimeType() {
		String contentType = backing.getContentType();

		// IE6 (and apparently IE7) are broken and send the MIME type "image/pjpeg"
		// regardless of whether the image is a progressive jpeg or not. Sending the
		// incorrect MIME type back can cause display issues. It is always safe to
		// change it to just be "image/jpeg".
		if ("image/pjpeg".equals(contentType)) {
			contentType = "image/jpeg";
		}

		return contentType;
	}
211028
function getType (str, typeLinks) {
  if (str in typeLinks) {
    return dom.create('a').class('qm-api-type-link').attr('href', typeLinks[str]).text(str)
  } else {
    return str
  }
}
1034429
function getModelFormat(oType) {
		var sPattern = "HH:mm:ss",
			iPrecision;

		if (!oType.oModelFormat) {
			iPrecision = oType.oConstraints && oType.oConstraints.precision;
			if (iPrecision) {
				sPattern += "." + "".padEnd(iPrecision, "S");
			}
			oType.oModelFormat = DateFormat.getTimeInstance({pattern : sPattern,
				strictParsing : true, UTC : true});
		}
		return oType.oModelFormat;
	}
511485
function() {
                return {
                    char:               this.char,
                    color:              this.color,
                    bgColor:            this.bgColor,
                    borderColor:        this.borderColor,
                    borderWidth:        this.borderWidth,
                    charStrokeColor:    this.charStrokeColor,
                    charStrokeWidth:    this.charStrokeWidth,
                    font:               this.font,
                    fontSize:           this.fontSize,
                    textAlign:          this.textAlign,
                    textBaseline:       this.textBaseline,
                    offsetX:            this.offsetX,
                    offsetY:            this.offsetY,
                };
            }
121856
function UMLActorView() {
        UMLClassifierView.apply(this, arguments);
        this.iconRatio = ACTOR_RATIO_PERCENT;

        this.fillColor = PreferenceManager.get("uml.actor.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
        this.stereotypeDisplay  = PreferenceManager.get("uml.actor.stereotypeDisplay", UML.SD_LABEL);
        this.suppressAttributes = PreferenceManager.get("uml.actor.suppressAttributes", true);
        this.suppressOperations = PreferenceManager.get("uml.actor.suppressOperations", true);
    }
561526
function UMLPortView() {
        UMLFloatingNodeView.apply(this, arguments);
        this.sizable = Core.SZ_NONE;
        this.fillColor = PreferenceManager.get("uml.port.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");

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

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

        /** @member {boolean} */
        this.showMultiplicity = true;
    }
9069
function detectMimeType() {
  var extension = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';

  extension = extension.toString().toLowerCase().replace(/\s/g, '').replace(/^\./g, '');

  if (!(extension in _listExtensions.extensions)) {
    return 'application/octet-stream';
  }

  if (typeof _listExtensions.extensions[extension] === 'string') {
    return _listExtensions.extensions[extension];
  }

  // search for name match
  for (var i = 0, len = _listExtensions.extensions[extension].length; i < len; i++) {
    var mimePart = _listExtensions.extensions[extension][i].split('/')[1];
    if (mimePart === extension) {
      return _listExtensions.extensions[extension][i];
    }
  }

  // use the first one
  return _listExtensions.extensions[extension][0];
}
328052
function UMLEvent() {
        UMLModelElement.apply(this, arguments);

        /** @member {string} */
        this.kind = EK_ANYRECEIVE;

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

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

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

        /** @member {UMLSignal} */
        this.targetSignal = null;
    }
815112
function getTextSpecStyle (ms = {}) {
  const lines = parseInt(ms.lines) || 0
  const overflow = ms['text-overflow'] || 'ellipsis'
  if (lines > 0) {
    return {
      overflow: 'hidden',
      'text-overflow': overflow,
      '-webkit-line-clamp': lines
    }
  }
}
1361589
function UMLStructuralFeature() {
        UMLFeature.apply(this, arguments);

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

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

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

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

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

        /** @member {string} */
        this.defaultValue = '';
    }
881024
function getType(value) {

  const type = typeof value;

  if (Array.isArray(value)) {
    return 'array';
  }

  if (value instanceof RegExp) {
    // Old webkits (at least until Android 4.0) return 'function' rather than
    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
    // passes PropTypes.object.
    return 'object';
  }

  if (isSymbol(type, value)) {
    return 'symbol';
  }

  return type;
}
478913
public String getMimeType() {
		if (format != null) {
			if (format == Format.JPEG && progressive)
			{
				return "image/pjpeg";
			}
			return format.getMimeType();
		} else {
			return null;
		}
	}
914199
function getCommonType(elems) {
        if (elems && elems.length > 0) {
            var commonType = elems[0].getClass();
            while (!_.every(elems, function (e) { return (e instanceof commonType); })) {
                commonType = getSuperType(commonType);
            }
            return commonType;
        } else {
            return null;
        }
    }
607244
function () {
    var str = '{';
    for (var i in this.schema){
      if (i == 'preset') continue;
      str += i + ': ';
      var type = this.schema[i].type;
      if (type == 'vec3') {
        str += '{ x: ' + this.data[i].x + ', y: ' + this.data[i].y + ', z: ' + this.data[i].z + '}';
      }
      else if (type == 'string' || type == 'color') {
        str += '"' + this.data[i] + '"';
      }
      else {
        str += this.data[i];
      }
      str += ', ';
    }
    str += '}';
    console.log(str);
  }