var maxiterations = testperiodic_extension_config.extensions.length* testperiodic_extension_config.extensions.length;
972668
function() {
        return function(ext, i) {
            iterations++;
            correct_order_exts[ext.name] = [];
            if (ext.periodicConfig.periodicDependencies) {
                let depPositionIndex;
                let optionalPositionIndex;
                ext.periodicConfig.periodicDependencies.forEach(function(extDep) {
                    // console.log('iterations',iterations);
                    depPositionIndex = arrayObjectIndexOf(testperiodic_extension_config.extensions, extDep.extname, 'name');
                    optionalPositionIndex = arrayObjectIndexOf(testperiodic_extension_config.extensions, extDep.extname, 'name');
                    if (depPositionIndex >= i) {
                        if (logger) {
                            logger.silly('WARNING : Extension[' + i + '] (' + ext.name + ') is being loaded before dependency (' + extDep.extname + ')[' + depPositionIndex + ']');
                        }
                        testperiodic_extension_config.extensions = move_array(testperiodic_extension_config.extensions, i, depPositionIndex + 1);
                        correct_order_exts[ext.name][extDep.extname] = { in_order: false };
                    } else if (extDep.optional && optionalPositionIndex >= i) {
                        if (logger) {
                            logger.silly('OPTIONAL : Extension[' + i + '] (' + ext.name + ') is being loaded before OPTIONAL dependency (' + extDep.extname + ')[' + optionalPositionIndex + ']');
                        }
                        testperiodic_extension_config.extensions = move_array(testperiodic_extension_config.extensions, i, optionalPositionIndex + 1);
                        correct_order_exts[ext.name][extDep.extname] = { in_order: false };
                    } else {
                        if (logger && logger.silly !== console.log) {
                            logger.silly('PASS : Extension[' + i + '] (' + ext.name + ') is after dependency (' + extDep.extname + ')[' + depPositionIndex + ']');
                        }
                        correct_order_exts[ext.name][extDep.extname] = { in_order: true };
                    }
                });
            }
        };
    }
300869
@Override
    public void setMaxInactiveInterval(int maxInactiveInterval) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            StringBuffer sb = new StringBuffer(newValueString).append(maxInactiveInterval).append(oldValueString).append(_maxInactiveInterval).append(appNameAndIdString);
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, "setMaxInactiveInterval", sb.toString());
        }
        if (maxInactiveInterval <= 0) {
            _maxInactiveInterval = -1;
        } else {
            _maxInactiveInterval = maxInactiveInterval;
        }
    }
823597
function calculateMaxLength(value) {
                var length = 16;
                if (!angular.isUndefined(value)) {
                    length = Math.floor(value).toString().length;
                }
                if (decimals > 0) {
                    // Add extra length for the decimals plus one for the decimal separator.
                    length += decimals + 1; 
                }
                if (min < 0) {
                    // Add extra length for the - sign.
                    length++;
                }
                return length;
            }
113809
function ensureLength (self, _newLength) {
  var newLength;
  if (_newLength > MAX_LENGTH) {
    newLength = MAX_LENGTH;
  } else {
    newLength = _newLength | 0;
  }
  var proto = Object.getPrototypeOf(self);
  var cur = proto[length] | 0;
  var num = newLength - cur;
  if (num > 0) {
    var desc = {};
    debug('creating a descriptor object with %o entries', num);
    for (var i = cur; i < newLength; i++) {
      desc[i] = setup(i);
    }
    debug('calling `Object.defineProperties()` with %o entries', num);
    Object.defineProperties(proto, desc);
    proto[length] = newLength;
  }
  return newLength;
}
850346
function(a, min, max, allowNumbers, msg) {
    return assert((this.assertStringMinLength(a, min, allowNumbers, msg)&&this.assertStringMaxLength(a, max, allowNumbers, msg)), msg);
  }
30707
function(w) {
    if(w.length === 0) { return {}; } // ... ;s
    var maxv = w[0];
    var minv = w[0];
    var maxi = 0;
    var mini = 0;
    var n = w.length;
    for(var i=1;i<n;i++) {
      if(w[i] > maxv) { maxv = w[i]; maxi = i; } 
      if(w[i] < minv) { minv = w[i]; mini = i; } 
    }
    return {maxi: maxi, maxv: maxv, mini: mini, minv: minv, dv:maxv-minv};
  }
149084
function(){
        var h=this.maxY-this.minY;
        var d=this.maxZ-this.minZ;
        return 2*((this.maxX-this.minX)*(h+d)+h*d);
    }
1189123
function _getExtension(file) {
        var ret;
        if (file) {
            var fileTypes = file.split(".");
            var len = fileTypes.length;
            if (0 === len) {
                return ret;
            }
            ret = fileTypes[len - 1];
            return ret;
        }
    }
65857
protected void initExtensions(IExtension[] extensions) {
		final String sourceMethod = "initExtension"; //$NON-NLS-1$
		boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(sourceClass, sourceMethod, new Object[]{extensions});
		}
		for (IExtension extension : extensions) {
			for (IConfigurationElement member : extension.getConfigurationElements()) {
				try {
					// make sure the contributing bundle is started.
					Bundle contributingBundle = Platform.getBundle(member.getNamespaceIdentifier());
					if (contributingBundle != null && contributingBundle.getState() != Bundle.ACTIVE && contributingBundle.getState() != Bundle.STARTING) {
						contributingBundle.start();
					}
					// get class attribute so we can see if the class is a singleton that we
					// already have an instance for.
					String className = member.getAttribute("class"); //$NON-NLS-1$
					Object ext = singletonExtensions.get(className);
					if (ext == null) {
						ext = member.createExecutableExtension("class"); //$NON-NLS-1$
						if (ext instanceof IExtensionSingleton) {
							// Add it to the map of singleton extensions
							singletonExtensions.put(className, ext);
						}
					}
					Properties props = new Properties();
					for (String attributeName : member.getAttributeNames()) {
						props.put(attributeName, member.getAttribute(attributeName));
					}
					InitParams initParams = getConfigInitParams(member);
					registerExtension(
							new AggregatorExtension(ext, props, initParams,
									extension.getExtensionPointUniqueIdentifier(),
									extension.getUniqueIdentifier(),
									this), null
							);
				} catch (CoreException ex) {
					if (log.isLoggable(Level.WARNING)) {
						log.log(Level.WARNING, ex.getMessage(), ex);
					}
				} catch (BundleException ex) {
					if (log.isLoggable(Level.WARNING)) {
						log.log(Level.WARNING, ex.getMessage(), ex);
					}
				}
			}
		}
		if (isTraceLogging) {
			log.exiting(sourceClass, sourceMethod);
		}
	}
628498
function validateLength(attr, conf, err) {
    if (nullCheck.call(this, attr, conf, err)) return;

    var len = this[attr].length;
    if (conf.min && len < conf.min) {
        err('min');
    }
    if (conf.max && len > conf.max) {
        err('max');
    }
    if (conf.is && len !== conf.is) {
        err('is');
    }
}
1096487
public Optional<Integer> getMaxlength() {
        if (property instanceof StringProperty) {
            StringProperty stringProperty = (StringProperty) property;
            return Optional.ofNullable(stringProperty.getMaxLength());
        } else if (property instanceof UUIDProperty) {
            UUIDProperty uuidProperty = (UUIDProperty) property;
            return Optional.ofNullable(uuidProperty.getMaxLength());
        }
        return Optional.empty();
    }
397787
function getKeywordLength (keyword) {
    const length = keyword.length;
    return {
      length,
      score: calc.iScore(1, MAX_KEYWORD_LENGTH, length)
    };
  }
483385
function(context) {
        var node = this.createElementDefaultNS("Extension");
        
        var bounds = context.maxExtent;
        var maxExtent = this.createElementNS(
            this.namespaces.ol, "ol:maxExtent"
        );
        this.setAttributes(maxExtent, {
            minx: bounds.left.toPrecision(18),
            miny: bounds.bottom.toPrecision(18),
            maxx: bounds.right.toPrecision(18),
            maxy: bounds.top.toPrecision(18)
        });
        node.appendChild(maxExtent);
        
        if (context.tileSize && !context.singleTile) {
            var size = this.createElementNS(
                this.namespaces.ol, "ol:tileSize"
            );
            this.setAttributes(size, context.tileSize);
            node.appendChild(size);
        }
        
        var properties = [
            "transparent", "numZoomLevels", "units", "isBaseLayer",
            "opacity", "displayInLayerSwitcher", "singleTile"
        ];
        var child;
        for(var i=0, len=properties.length; i<len; ++i) {
            child = this.createOLPropertyNode(context, properties[i]);
            if(child) {
                node.appendChild(child);
            }
        }

        return node;
    }
1184655
private int addExtendedName(int maxlength)
    {
        for (int i = TYPE_NAMES_.length - 1; i >= 0; i --) {
            // for each category, count the length of the category name
            // plus 9 =
            // 2 for <>
            // 1 for -
            // 6 for most hex digits per code point
            int length = 9 + add(m_nameSet_, TYPE_NAMES_[i]);
            if (length > maxlength) {
                maxlength = length;
            }
        }
        return maxlength;
    }
442263
protected XmlSchemaMaxLengthFacet createMaxLengthFacet(final int length) {
        XmlSchemaMaxLengthFacet xmlSchemaMaxLengthFacet = new XmlSchemaMaxLengthFacet();
        xmlSchemaMaxLengthFacet.setValue(length);
        return xmlSchemaMaxLengthFacet;
    }
1176140
private static AppendMaxLimitType getAppendLimitType(ExtractType extractType, String maxLimit) {
    LOG.debug("Getting append limit type");
    AppendMaxLimitType limitType;
    switch (extractType) {
      case APPEND_DAILY:
        limitType = AppendMaxLimitType.CURRENTDATE;
        break;
      case APPEND_HOURLY:
        limitType = AppendMaxLimitType.CURRENTHOUR;
        break;
      default:
        limitType = null;
        break;
    }

    if (!Strings.isNullOrEmpty(maxLimit)) {
      LOG.debug("Getting append limit type from the config");
      String[] limitParams = maxLimit.split("-");
      if (limitParams.length >= 1) {
        limitType = AppendMaxLimitType.valueOf(limitParams[0]);
      }
    }
    return limitType;
  }
825526
function ValidationExtension() {
    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
        _ref$reject = _ref.reject,
        reject = _ref$reject === undefined ? false : _ref$reject;

    _classCallCheck(this, ValidationExtension);

    // Store configuration
    var _this = _possibleConstructorReturn(this, (ValidationExtension.__proto__ || Object.getPrototypeOf(ValidationExtension)).call(this, {
      onEntityInstantiate: true,
      onChangeDetected: true
    }));

    _this.rejectInvalidValues = reject;
    return _this;
  }