processes a method call looking for parameters that are arrays. If this array was seen earlier as a simple wrapping array, then it marks it as being
having been used as a parameter.
165782
private void processMethodCall() {
        if ("invoke".equals(getNameConstantOperand()) && "java/lang/reflect/Method".equals(getClassConstantOperand())) {
            return;
        }
        String sig = getSigConstantOperand();
        List<String> args = SignatureUtils.getParameterSignatures(sig);
        if (stack.getStackDepth() >= args.size()) {
            for (int i = 0; i < args.size(); i++) {
                String argSig = args.get(i);
                if (argSig.startsWith(Values.SIG_ARRAY_PREFIX)) {
                    OpcodeStack.Item itm = stack.getStackItem(args.size() - i - 1);
                    int arrayReg = itm.getRegisterNumber();
                    WrapperInfo wi = wrappers.get(Integer.valueOf(arrayReg));
                    if (wi != null) {
                        wi.wasArg = true;
                    }
                }
            }
        }
    }
562179
function processsupercall() {
		if (methodname) {
			if (!character.match(METHODNAME)) {
				buffer += '.call';
				methodname = false;
			}
		} else if (superargs) {
			if (character.match(METHODNAME)) {
				buffer += ', ';
				superargs = false;
			}
		}
		switch (character) {
			case '(':
				character = '(this';
				superargs = true;
				break;
			case ')':
				supercall = false;
				superargs = false;
				break;
		}
	}
505376
private void processParameters() throws BadElementException, IOException {
        type = JPEG;
        originalType = ORIGINAL_JPEG;
        InputStream is = null;
        try {
            String errorID;
            if (rawData == null){
                is = url.openStream();
                errorID = url.toString();
            }
            else{
                is = new java.io.ByteArrayInputStream(rawData);
                errorID = "Byte array";
            }
            if (is.read() != 0xFF || is.read() != 0xD8)	{
                throw new BadElementException(errorID + " is not a valid JPEG-file.");
            }
            boolean firstPass = true;
            int len;
            while (true) {
                int v = is.read();
                if (v < 0)
                    throw new IOException("Premature EOF while reading JPG.");
                if (v == 0xFF) {
                    int marker = is.read();
                    if (firstPass && marker == M_APP0) {
                        firstPass = false;
                        len = getShort(is);
                        if (len < 16) {
                            Utilities.skip(is, len - 2);
                            continue;
                        }
                        byte bcomp[] = new byte[JFIF_ID.length];
                        int r = is.read(bcomp);
                        if (r != bcomp.length)
                            throw new BadElementException(errorID + " corrupted JFIF marker.");
                        boolean found = true;
                        for (int k = 0; k < bcomp.length; ++k) {
                            if (bcomp[k] != JFIF_ID[k]) {
                                found = false;
                                break;
                            }
                        }
                        if (!found) {
                            Utilities.skip(is, len - 2 - bcomp.length);
                            continue;
                        }
                        Utilities.skip(is, 2);
                        int units = is.read();
                        int dx = getShort(is);
                        int dy = getShort(is);
                        if (units == 1) {
                            dpiX = dx;
                            dpiY = dy;
                        }
                        else if (units == 2) {
                            dpiX = (int)(dx * 2.54f + 0.5f);
                            dpiY = (int)(dy * 2.54f + 0.5f);
                        }
                        Utilities.skip(is, len - 2 - bcomp.length - 7);
                        continue;
                    }
                    if (marker == M_APPE) {
                        len = getShort(is) - 2;
                        byte[] byteappe = new byte[len];
                        for (int k = 0; k < len; ++k) {
                            byteappe[k] = (byte)is.read();
                        }
                        if (byteappe.length >= 12) {
                            String appe = new String(byteappe, 0, 5, "ISO-8859-1");
                            if (appe.equals("Adobe")) {
                                invert = true;
                            }
                        }
                        continue;
                    }
                    if (marker == M_APP2) {
                        len = getShort(is) - 2;
                        byte[] byteapp2 = new byte[len];
                        for (int k = 0; k < len; ++k) {
                            byteapp2[k] = (byte)is.read();
                        }
                        if (byteapp2.length >= 14) {
                            String app2 = new String(byteapp2, 0, 11, "ISO-8859-1");
                            if (app2.equals("ICC_PROFILE")) {
                                int order = byteapp2[12] & 0xff;
                                int count = byteapp2[13] & 0xff;
                                
                                // some jpeg producers don't know how to count to 1
                                if (order < 1) {
                                	order = 1;
                                }
                                if (count < 1) {
                                	count = 1;
                                }
                                if (icc == null){
                                    icc = new byte[count][];
                                }
                                int idx = order - 1;
                                if( idx >= 0 ) {
                                	icc[idx] = byteapp2;
                                }                                
                            }
                        }
                        continue;
                    }
                    firstPass = false;
                    int markertype = marker(marker);
                    if (markertype == VALID_MARKER) {
                        Utilities.skip(is, 2);
                        if (is.read() != 0x08) {
                            throw new BadElementException(errorID + " must have 8 bits per component.");
                        }
                        scaledHeight = getShort(is);
                        setTop(scaledHeight);
                        scaledWidth = getShort(is);
                        setRight(scaledWidth);
                        colorspace = is.read();
                        bpc = 8;
                        break;
                    }
                    else if (markertype == UNSUPPORTED_MARKER) {
                        throw new BadElementException(errorID + ": unsupported JPEG marker: " + marker);
                    }
                    else if (markertype != NOPARAM_MARKER) {
                        Utilities.skip(is, getShort(is) - 2);
                    }
                }
            }
        }
        finally {
            if (is != null) {
                is.close();
            }
        }
        plainWidth = getWidth();
        plainHeight = getHeight();
        if (icc != null) {
            int total = 0;
            for (int k = 0; k < icc.length; ++k) {
                if (icc[k] == null) {
                    icc = null;
                    return;
                }
                total += icc[k].length - 14;
            }
            byte[] ficc = new byte[total];
            total = 0;
            for (int k = 0; k < icc.length; ++k) {
                System.arraycopy(icc[k], 14, ficc, total, icc[k].length - 14);
                total += icc[k].length - 14;
            }
            try {
            	ICC_Profile icc_prof = ICC_Profile.getInstance(ficc);
            	tagICC(icc_prof);
            }
            catch(IllegalArgumentException e) {
            	// ignore ICC profile if it's invalid.
            }
            icc = null;
        }
    }
1153958
function invoke(array, method) {
    var args = slice.call(arguments, 2), result = [ ];
    for (var i = 0, len = array.length; i < len; i++) {
      result[i] = args.length ? array[i][method].apply(array[i], args) : array[i][method].call(array[i]);
    }
    return result;
  }
68645
def call_method_with_optional_parameters(object, method_name, parameters)
        if object.respond_to?(method_name)
          if object.method(method_name).arity == -1
            object.send(method_name, parameters)
          else
            object.send(method_name)
          end
        end
      end
782295
def cast_param(param)
      if type.is_a?(Array)
        unless param.is_a?(Array) && param.size == type.size
          num_params = param.is_a?(Array) ? param.size : 1
          raise ArgumentError, "Parameters supplied to #{name} could not be type cast -- #{num_params} values supplied, #{type.size} expected"
        end
        type.each_with_index do |t, i|
          param[i] = cast_attributes(t, param[i])
        end
        param
      else
        cast_attributes(type, param)
      end
    end
318484
private void processIntegerReturn() {
        if ((sawConstant == null) && (stack.getStackDepth() == 0)) {
            throw new StopOpcodeParsingException();
        }

        Integer returnValue = null;
        if (sawConstant == null) {
            OpcodeStack.Item item = stack.getStackItem(0);
            returnValue = (Integer) item.getConstant();
        } else {
            returnValue = sawConstant;
        }

        if (returnValue == null) {
            throw new StopOpcodeParsingException();
        }
        int v = returnValue.intValue();
        if (v < 0) {
            seenNegative = true;
            if (getPC() > furthestBranchTarget) {
                seenUnconditionalNonZero = true;
            }
        } else if (v > 0) {
            seenPositive = true;
            if (getPC() > furthestBranchTarget) {
                seenUnconditionalNonZero = true;
            }
        } else {
            seenZero = true;
        }

        sawConstant = null;
    }
748219
private List<String> parseMethodParams(String methodParameters, Node methodSignature) {
    List<String> parsedParameters = new ArrayList<>();

    char nextDelimeter = ',';
    String currentTerm = "";
    for (int i = 0; i < methodParameters.length(); i++) {
      if (methodParameters.charAt(i) == nextDelimeter) {
        if (nextDelimeter == ',') {
          parsedParameters.add(currentTerm.trim());
          currentTerm = "";
        } else {
          currentTerm += nextDelimeter;
          nextDelimeter = ',';
        }
      } else {
        currentTerm += methodParameters.charAt(i);
        if (methodParameters.charAt(i) == '"' || methodParameters.charAt(i) == '\'') {
          nextDelimeter = methodParameters.charAt(i);
        }
      }
    }
    if (nextDelimeter != ',') {
      compiler.report(JSError.make(methodSignature, PolymerPassErrors.POLYMER_UNPARSABLE_STRING));
      return parsedParameters;
    }
    if (currentTerm.length() > 0) {
      parsedParameters.add(currentTerm.trim());
    }
    return parsedParameters;
  }
287726
private Object[] handleParameters(IoBuffer in, Notify notify, Input input) {
        Object[] params = new Object[] {};
        List<Object> paramList = new ArrayList<>();
        final Object obj = Deserializer.deserialize(input, Object.class);
        if (obj instanceof Map) {
            // Before the actual parameters we sometimes (connect) get a map of parameters, this is usually null, but if set should be
            // passed to the connection object.
            @SuppressWarnings("unchecked")
            final Map<String, Object> connParams = (Map<String, Object>) obj;
            notify.setConnectionParams(connParams);
        } else if (obj != null) {
            paramList.add(obj);
        }
        while (in.hasRemaining()) {
            paramList.add(Deserializer.deserialize(input, Object.class));
        }
        params = paramList.toArray();
        if (log.isDebugEnabled()) {
            log.debug("Num params: {}", paramList.size());
            for (int i = 0; i < params.length; i++) {
                log.debug(" > {}: {}", i, params[i]);
            }
        }
        return params;
    }
40615
private static boolean checkParameters(Method method, Object... data)
	{
		Parameter[] parameters = method.getParameters();
		if (ArrayUtils.isEmpty(data) && parameters.length != 0)
			return false;
		if (parameters.length != data.length)
			return false;

		for (int i = 0; i < parameters.length; i++)
		{
			Class<?> paramClass = parameters[i].getType();
			if (data[i] != null)
			{
				Class<?> dataClass = data[i].getClass();
				if (!ClassUtils.isAssignable(dataClass, paramClass, true))
					return false;
			}
		}

		return true;
	}
953748
private void handleMainMethodIfPresent(List methods) {
        boolean found = false;
        for (Iterator iter = methods.iterator(); iter.hasNext();) {
            MethodNode node = (MethodNode) iter.next();
            if(node.getName().equals("main")) {
                if (node.isStatic() && node.getParameters().length == 1) {
                    boolean retTypeMatches, argTypeMatches;
                    ClassNode argType = node.getParameters()[0].getType();
                    ClassNode retType = node.getReturnType();

                    argTypeMatches = (argType.equals(ClassHelper.OBJECT_TYPE) || argType.getName().contains("String[]"));
                    retTypeMatches = (retType == ClassHelper.VOID_TYPE || retType == ClassHelper.OBJECT_TYPE);
                    
                    if(retTypeMatches && argTypeMatches) {
                        if(found) {
                            throw new RuntimeException("Repetitive main method found.");
                        } else {
                            found = true;
                        }
                        // if script has both loose statements as well as main(), then main() is ignored
                        if(statementBlock.isEmpty()) {
                            addStatement(node.getCode());
                        }
                        iter.remove();
                    }
                }
            }
        }
    }
553760
protected function processFunctionCalls()
    {
        $returnStack = array();
        if (!file_exists($this->_traceFile . '.xt') || ($handle = fopen($this->_traceFile . '.xt', 'r')) === false) {
            return;
        }

        // See http://xdebug.org/docs/all_settings#trace_format
        // Note : classes are specified as 'class <classname>'
        while ($dataLine = fgetcsv($handle, null, "\t")) {
            if (is_numeric($dataLine[0])) {
                $minimumLevel = $dataLine[0];
                break;
            }
        }
        while ($dataLine = fgetcsv($handle, null, "\t")) {
            // For convenience and readability
            $tracedataLevel = $dataLine[0];
            if (!is_numeric($tracedataLevel)) { // We've reached the end of the trace file
                break;
            }
            if ($tracedataLevel > $minimumLevel + $this->_depth) { // We don't analyze this deep
                continue;
            }

            $tracedataIsReturn = $dataLine[2];
            if (isset($dataLine[5])) {
                $tracedataFunctionName = $dataLine[5];
                $splitClass = explode('->', $tracedataFunctionName);
                if (count($splitClass) > 1) { // It's a method
                    foreach ($this->_ignoredClassNames as $classname) {
                        if (strpos($splitClass[0], $classname) !== false) {
                            continue 2;
                        }
                    }
                    foreach ($this->_ignoredFunctions as $functionname) {
                        if (strpos($splitClass[1], $functionname) !== false) {
                            continue 2;
                        }
                    }
                } else {
                    foreach ($this->_ignoredFunctions as $functionname) {
                        if (strpos($splitClass[0], $functionname) !== false) {
                            continue 2;
                        }
                    }
                }
            } else {
                $tracedataFunctionName = '';
            }
            if (isset($dataLine[6])) {
                $tracedataUserDefined = $dataLine[6];
            } else {
                $tracedataUserDefined = '';
            }
            if (isset($dataLine[7])) {
                $tracedataIncludeFilename = $dataLine[7];
            } else {
                $tracedataIncludeFilename = '';
            }
            if (isset($dataLine[8])) {
                $tracedataFilename = $dataLine[8];
                foreach ($this->_ignoredFileNames as $filename) {
                    if (strpos($tracedataFilename, $filename) !== false) {
                        continue 2;
                    }
                }
            } else {
                $tracedataFilename = '';
            }
            if (isset($dataLine[9])) {
                $tracedataLinenumber = $dataLine[9];
            } else {
                $tracedataLinenumber = '';
            }

            if ($tracedataIsReturn == 0) { // It's a function/method call
				if (strpos($tracedataFunctionName, '{closure:') !== false) {
                    continue;
                }


                preg_match(
                '/(?P<classOrFunction>\w+){0,1}(?:\:\:|->){0,1}(?P<method>\w+){0,1}/',
                $tracedataFunctionName,
                $functionCall
                );

                $docBlock = false; // getDocComment will return false if no docblock is present
                if (!isset($functionCall['method']) && function_exists($functionCall['classOrFunction'])) { // It's a function
                    $calledFunction = $functionCall['classOrFunction'];
                    $func = new ReflectionFunction($functionCall['classOrFunction']);
                    $docBlock = $func->getDocComment();
                    $numberOfParameters = $func->getNumberOfParameters();
                    $functionParameters = $func->getParameters();
                } elseif (isset($functionCall['method']) && method_exists($functionCall['classOrFunction'], $functionCall['method'])) { // It's a method
                    $calledFunction = $functionCall['classOrFunction'] . '->' . $functionCall['method'];
                    $method = new ReflectionMethod($functionCall['classOrFunction'], $functionCall['method']);
                    $docBlock = $method->getDocComment();
                    $numberOfParameters = $method->getNumberOfParameters();
                    $functionParameters = $method->getParameters();
                } // else it's an internal function, which we're unable to verify at this point

                if ($docBlock !== false) {
                    $foundReturn = false;

                    preg_match_all('/\s*\*\s*@(?P<tag>phpconsistent-ignore)/', $docBlock, $noTypeCheck, PREG_SET_ORDER); // Check if @phpconsistent-ignore was in docblock
                    if (count($noTypeCheck) == 0) {
                        // Main docblock parameter and return type loop
                        preg_match_all('/\s*\*\s*@(?P<tag>param|return)\s+(?P<type>\S+)\s+(?P<paramName>\$?\w+)?/', $docBlock, $docBlockVars, PREG_SET_ORDER);
                        $documentedParameters = 0;
                        $docblockParams = array();
                        for ($cntDocBlockTag = 0; $cntDocBlockTag < count($docBlockVars); $cntDocBlockTag++) {
                            if ($docBlockVars[$cntDocBlockTag]['tag'] == "param") {
								$documentedParameters++;
								if (isset($docBlockVars[$cntDocBlockTag]['paramName'])) {
									$docblockParams[] = $docBlockVars[$cntDocBlockTag]['paramName'];
								} else {
									$docblockParams[] = '';
								}
								if (isset($dataLine[11 + $cntDocBlockTag])) { // Was the call made with this parameter ?
									$foundMatch = $this->compareTypes($dataLine[11 + $cntDocBlockTag], $docBlockVars[$cntDocBlockTag]['type']);

									if ($foundMatch === false) {
										$this->addParamTypeFailure(
											$tracedataFilename,
											$tracedataLinenumber,
											$calledFunction,
											($cntDocBlockTag + 1),
											$docBlockVars[$cntDocBlockTag]['paramName'],
											$docBlockVars[$cntDocBlockTag][2],
											$dataLine[11 + $cntDocBlockTag]
										);
									}
								}
                            } else { // Put the expected return type on the stack for later use
                                $returnStack[] = array(
                                    'fileName'        => $tracedataFilename,
                                    'fileLine'        => $tracedataLinenumber,
                                    'calledFunction'  => $calledFunction,
                                    'parameterNumber' => null,
                                    'parameterName'   => null,
                                    'expectedType'    => $docBlockVars[$cntDocBlockTag]['type'],
                                    'calledType'      => null,
                                    'noTypeCheck'     => 0
                                );
                                $foundReturn = true;
                            }
                        }
                    }

                    if ($numberOfParameters != $documentedParameters) {
                        $this->addParamCountMismatchFailure($tracedataFilename, $tracedataLinenumber, $calledFunction, $documentedParameters, $numberOfParameters);
                    }
                    for ($cntDocBlockParam = 0; $cntDocBlockParam < count($docblockParams); $cntDocBlockParam++) {
                        if (!isset($functionParameters[$cntDocBlockParam])) {
							$this->addParamMissingFailure($tracedataFilename, $tracedataLinenumber, $calledFunction, $cntDocBlockParam, $docblockParams[$cntDocBlockParam]);
						} elseif ($docblockParams[$cntDocBlockParam] != '$' . $functionParameters[$cntDocBlockParam]->getName()) {
                            $this->addParamNameMismatchFailure($tracedataFilename, $tracedataLinenumber, $calledFunction, $cntDocBlockParam, $docblockParams[$cntDocBlockParam], '$' . $functionParameters[$cntDocBlockParam]->getName());
                        }

                    }

                    if ($foundReturn === false) { // Put this function/method call on the stack
                        $returnStack[] = array(
                            'fileName'        => $tracedataFilename,
                            'fileLine'        => $tracedataLinenumber,
                            'calledFunction'  => $calledFunction,
                            'parameterNumber' => null,
                            'parameterName'   => null,
                            'expectedType'    => null,
                            'calledType'      => null,
                            'noTypeCheck'     => count($noTypeCheck)
                        );
                    }
                } else {
                    $returnStack[] = array(
                        'fileName'        => $tracedataFilename,
                        'fileLine'        => $tracedataLinenumber,
                        'calledFunction'  => $calledFunction,
                        'parameterNumber' => null,
                        'parameterName'   => null,
                        'expectedType'    => null,
                        'calledType'      => null,
                        'noTypeCheck'     => 1
                    );
                }
            } else { // It's a return
                // If this isn't set, we have a version of Xdebug that hasn't been patched for Xdebug bug #416
                // Requires Xdebug with code after https://github.com/xdebug/xdebug/pull/79
                if ($tracedataFunctionName != '') {

                    $returnPop = array_pop($returnStack);

                    if ($returnPop['noTypeCheck'] == 0 && $returnPop['expectedType'] != '') {
                        preg_match('/(?P<type>\w+)\s?(?P<class>\w+)?/', $tracedataFunctionName, $returnTypes);
                        if (preg_match('/^\'.*/', $tracedataFunctionName) > 0) { // Strings are not extracted with the above regular expression, but ALWAYS start with a quote in Xdebug trace output
                            $returnPop['calledType'] = 'string';
                        } elseif ($returnTypes['type'] == 'NULL') {
                            $returnPop['calledType'] = 'null';
                        } elseif ($returnTypes['type'] == 'class') {
                            $returnPop['calledType'] = 'class ' . $returnTypes['class'];
                        } elseif ($returnTypes['type'] == 'TRUE' || $returnTypes['type'] == 'FALSE') {
                            $returnPop['calledType'] = 'bool';
                        } elseif ($returnTypes['type'] == 'array') {
                            $returnPop['calledType'] = 'array';
                        } elseif (is_numeric($returnTypes['type'])) {
                            $returnPop['calledType'] = 'int';
                        } else {
                            $returnPop['calledType'] = 'unknown';
                        }
                        if (!$this->compareTypes($returnType, $returnPop['expectedType'])) {
                            $this->addParamTypeFailure($returnPop['fileName'], $returnPop['fileLine'], $returnPop['calledFunction'], null, null, $returnPop['expectedType'], $returnPop['calledType']);
                        }
                    }
                }
            }
        }
        fclose($handle);
    }
1020613
private static ParameterFiller parseParameter(String parameter) {
    String wrappedParameter = "{" + parameter + "}";
    String trimmedParameter = parameter.trim();
    ParameterFiller parameterFiller = parseDateParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseLevelParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseTagParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseMessageParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    return null;
  }
1287039
function wrapObject(object, methods) {
      if (!(methods instanceof Array)) methods = Array.prototype.slice.call(arguments, 1);
      methods.forEach(function (method) {
        object[method] = wrap(object[method]);
      });
    }
1045728
private void processMethodCall() {
        int numParams = SignatureUtils.getNumParameters(getSigConstantOperand());

        int depth = stack.getStackDepth();
        for (int i = 0; i < numParams; i++) {
            if (depth > i) {
                OpcodeStack.Item item = stack.getStackItem(i);
                XField xf = item.getXField();
                if (xf != null) {
                    removeField(item);
                }
            } else {
                return;
            }
        }
    }
1317855
def ea_passthrough(array_method):
    

    def method(self, *args, **kwargs):
        return array_method(self._data, *args, **kwargs)

    method.__name__ = array_method.__name__
    method.__doc__ = array_method.__doc__
    return method
290589
protected Object parseArray(GetterMethodCover method, 
            Object array) {
        if(method.isObjectArray()) {
            return parseObjectArray(method, (Object[])array);
        }
        else if(method.isPrimitiveBooleanArray()) {
            return primitiveArrayToBoolCollection((boolean[])array);
        }
        else if(method.isPrimitiveCharArray()) {
            return charArrayToByteArray((char[])array);
        }
        else if(method.isPrimitiveDoubleArray()) {
            return primitiveArrayToDoubleCollection((double[])array);
        }
        else if(method.isPrimitiveFloatArray()) {
            return primitiveArrayToFloatCollection((float[])array);
        }
        else if(method.isPrimitiveIntArray()) {
            return primitiveArrayToIntCollection((int[])array);
        }
        else if(method.isPrimitiveLongArray()) {
            return primitiveArrayToLongCollection((long[])array);
        }
        else if(method.isPrimitiveShortArray()) {
            return primitiveArrayToShortCollection((short[])array);
        }
        else if(method.isStringArray()) {
            return stringArrayToCollection((String[])array);
        }
        else if(method.isWrapperBooleanArray()) {
            return wrapperArrayToCollection((Boolean[])array);
        }
        else if(method.isWrapperByteArray()) {
            return toPrimitiveByteArray((Byte[])array);
        }
        else if(method.isWrapperCharArray()) {
            return charWrapperArrayToPrimitiveByteArray((Character[])array);
        }
        else if(method.isWrapperDoubleArray()) {
            return wrapperArrayToCollection((Double[])array);
        }
        else if(method.isWrapperFloatArray()) {
            return wrapperArrayToCollection((Float[])array);
        }
        else if(method.isWrapperIntArray()) {
            return wrapperArrayToCollection((Integer[])array);
        }
        else if(method.isWrapperLongArray()) {
            return wrapperArrayToCollection((Long[])array);
        }
        else if(method.isWrapperShortArray()) {
            return wrapperArrayToCollection((Short[])array);
        }
        return array;
    }