The function to process missing column information.

@throws UnsupportedEncodingException when unknown encoding.
4111
private void processMissingColumnInfo() throws UnsupportedEncodingException {
        for (ColumnMissingInfo columnMissingInfo : columnMissingInfoList) {
            String missedInfo = bytesToString(columnsNamesBytes.get(columnMissingInfo.getTextSubheaderIndex()),
                    columnMissingInfo.getOffset(), columnMissingInfo.getLength()).intern();
            Column column = columns.get(columnMissingInfo.getColumnId());
            switch (columnMissingInfo.getMissingInfoType()) {
                case NAME:
                    column.setName(missedInfo);
                    break;
                case FORMAT:
                    column.setFormat(new ColumnFormat(missedInfo));
                    break;
                case LABEL:
                    column.setLabel(missedInfo);
                    break;
                default:
                    break;
            }
        }
    }
1116925
public HppResponse decode(String charset) throws UnsupportedEncodingException {

		if (null != this.merchantId) {
			this.merchantId = new String(Base64.decodeBase64(this.merchantId.getBytes(charset)), charset);
		}
		if (null != this.account) {
			this.account = new String(Base64.decodeBase64(this.account.getBytes(charset)), charset);
		}
		if (null != this.amount) {
			this.amount = new String(Base64.decodeBase64(this.amount.getBytes(charset)), charset);
		}
		if (null != this.authCode) {
			this.authCode = new String(Base64.decodeBase64(this.authCode.getBytes(charset)), charset);
		}
		if (null != this.batchId) {
			this.batchId = new String(Base64.decodeBase64(this.batchId.getBytes(charset)), charset);
		}
		if (null != this.cavv) {
			this.cavv = new String(Base64.decodeBase64(this.cavv.getBytes(charset)), charset);
		}
		if (null != this.cvnResult) {
			this.cvnResult = new String(Base64.decodeBase64(this.cvnResult.getBytes(charset)), charset);
		}
		if (null != this.eci) {
			this.eci = new String(Base64.decodeBase64(this.eci.getBytes(charset)), charset);
		}
		if (null != this.commentOne) {
			this.commentOne = new String(Base64.decodeBase64(this.commentOne.getBytes(charset)), charset);
		}
		if (null != this.commentTwo) {
			this.commentTwo = new String(Base64.decodeBase64(this.commentTwo.getBytes(charset)), charset);
		}
		if (null != this.message) {
			this.message = new String(Base64.decodeBase64(this.message.getBytes(charset)), charset);
		}
		if (null != this.pasRef) {
			this.pasRef = new String(Base64.decodeBase64(this.pasRef.getBytes(charset)), charset);
		}
		if (null != this.hash) {
			this.hash = new String(Base64.decodeBase64(this.hash.getBytes(charset)), charset);
		}
		if (null != this.result) {
			this.result = new String(Base64.decodeBase64(this.result.getBytes(charset)), charset);
		}
		if (null != this.xid) {
			this.xid = new String(Base64.decodeBase64(this.xid.getBytes(charset)), charset);
		}
		if (null != this.orderId) {
			this.orderId = new String(Base64.decodeBase64(this.orderId.getBytes(charset)), charset);
		}
		if (null != this.timeStamp) {
			this.timeStamp = new String(Base64.decodeBase64(this.timeStamp.getBytes(charset)), charset);
		}
		if (null != this.tss) {
			Map<String, String> tssMap = new HashMap<String, String>();
			for (String key : tss.keySet()) {
				tssMap.put(key, new String(Base64.decodeBase64(tss.get(key).getBytes(charset)), charset));
			}
			this.tss = new HashMap<String, String>();
			this.tss = tssMap;
		}
		if (null != this.supplementaryData) {
			Map<String, String> supplementaryDataMap = new HashMap<String, String>();
			for (String key : supplementaryData.keySet()) {
				supplementaryDataMap.put(key, new String(Base64.decodeBase64(supplementaryData.get(key).getBytes(charset)), charset));
			}
			this.supplementaryData = new HashMap<String, String>();
			this.supplementaryData.putAll(supplementaryDataMap);
		}
		return this;
	}
768779
@Override
    protected void encode() {
        int l = content.length();
        String localstr;
        int zeroes, count = 0, check_digit;
        Code3Of9 c = new Code3Of9();

        if (l > 7) {
            throw new OkapiException("Input data too long");
        }

        if (!content.matches("[0-9]+")) {
            throw new OkapiException("Invalid characters in input");
        }

        localstr = "-";
        zeroes = 7 - l + 1;
        for (int i = 1; i < zeroes; i++)
            localstr += '0';

        localstr += content;

        for (int i = 1; i < 8; i++) {
            count += i * Character.getNumericValue(localstr.charAt(i));
        }

        check_digit = count % 11;
        if (check_digit == 11) {
            check_digit = 0;
        }
        if (check_digit == 10) {
            throw new OkapiException("Not a valid PZN identifier");
        }

        encodeInfo += "Check Digit: " + check_digit + "\n";

        localstr += (char)(check_digit + '0');

        c.setContent(localstr);

        readable = "PZN" + localstr;
        pattern = new String[1];
        pattern[0] = c.pattern[0];
        row_count = 1;
        row_height = new int[1];
        row_height[0] = -1;
    }
1013981
private function setUnsupportedMethodsIfExists()
    {
        if (!function_exists('mb_strpos')) {
            throw new \Exception('You must have php-mbstring extension installed in the server.');
        }

        /*
         * If the content is not passed from FORM then we will simply return corresponding
         * GLOBAL variable raw data
         */
        if (
            \mb_strpos($this->header->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded') === 0 &&
            in_array($this->getMethod(), [RequestMethods::PUT, RequestMethods::PATCH, RequestMethods::DELETE])
        ) {
            parse_str($this->getRawBody(), $array);

            switch ($this->getMethod()) {
                case RequestMethods::PUT:
                    $this->put->exchangeArray($array);
                    break;
                case RequestMethods::PATCH:
                    $this->patch->exchangeArray($array);
                    break;
                case RequestMethods::DELETE:
                    $this->delete->exchangeArray($array);
                    break;
            }
        }
    }
976649
def fix_e225(self, result):
        """"""
        target = self.source[result['line'] - 1]
        offset = result['column'] - 1
        fixed = target[:offset] + ' ' + target[offset:]

        # Only proceed if non-whitespace characters match.
        # And make sure we don't break the indentation.
        if (
            fixed.replace(' ', '') == target.replace(' ', '') and
            _get_indentation(fixed) == _get_indentation(target)
        ):
            self.source[result['line'] - 1] = fixed
        else:
            return []
669694
@Override
	public void updateCharacterStream(final int columnIndex, final Reader x) throws SQLException {
		wrapped.updateCharacterStream(columnIndex, x);
	}
647290
def _missing_(cls, value):
        """"""
        if not (isinstance(value, int) and 0x00 <= value <= 0xFF):
            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
        if 0x0D <= value <= 0xEF:
            extend_enum(cls, 'Unassigned [0x%s]' % hex(value)[2:].upper().zfill(2), value)
            return cls(value)
        if 0xF0 <= value <= 0xFF:
            # [RFC 7540]
            extend_enum(cls, 'Reserved for Experimental Use [0x%s]' % hex(value)[2:].upper().zfill(2), value)
            return cls(value)
        super()._missing_(value)
1326224
private void processPredecessors() throws SQLException
   {
      List<Row> rows = getTable("LINK");
      List<Row> completedSections = getTable("TASK_COMPLETED_SECTION");
      Collections.sort(rows, LINK_COMPARATOR);
      m_reader.processPredecessors(rows, completedSections);
   }
1359339
private char nextChar() throws IOException {
		if (missedChar != null) {
			// RETURNS THE PREVIOUS PARSED CHAR
			c = missedChar.charValue();
			missedChar = null;

		} else {
			c = (char) in.read();

			if (c == '\\') {
				char c2 = (char) in.read();
				if (c2 == 'u') {
					// DECODE UNICODE CHAR
					final StringBuilder buff = new StringBuilder();
					for (int i = 0; i < 4; ++i)
						buff.append((char) in.read());

					cursor += 6;

					return (char) Integer.parseInt(buff.toString(), 16);
				} else {
					// REMEMBER THE CURRENT CHAR TO RETURN NEXT TIME
					missedChar = c2;
				}
			}
		}

		cursor++;

		if (c == NEW_LINE) {
			++lineNumber;
			columnNumber = 0;
		} else
			++columnNumber;

		return c;
	}

	public char lastChar() {
		return c;
	}

	public String getValue() {
		return value;
	}

	public int getLineNumber() {
		return lineNumber;
	}

	public int getColumnNumber() {
		return columnNumber;
	}

	public boolean hasNext() throws IOException {
		return in.ready();
	}
}
615918
private void processColumnAnnotation() {
      Column columnAnnotation = field.getAnnotation(Column.class);
      String columnName = columnAnnotation.name();
      setColumnName(columnName);

      this.columnTableName = columnAnnotation.table();
      insertable = columnAnnotation.insertable();
      updatable = columnAnnotation.updatable();
   }
322635
private void checkColumn(int column) throws SQLException {

        if (column < 1 || column > columnCount) {
            throw Util.sqlException(ErrorCode.JDBC_COLUMN_NOT_FOUND,
                                    String.valueOf(column));
        }
    }
65409
public function encoding() {
		$db = $this->_getConnection();
		$config = $db->config();
		$database = $config['database'];
		$prefix = ''; //$config['prefix'];
		$encoding = 'utf8mb4';
		$collate = 'utf8mb4_unicode_ci';

		try {
			$script = "ALTER DATABASE $database CHARACTER SET $encoding COLLATE $collate;";
			if (!$this->params['dry-run']) {
				$db->query($script);
			} else {
				$this->out($script);
			}
		} catch (Exception $e) {
			$this->err('Could not alter database: ' . $e->getMessage() . ' - Skipping.');
		}

		$script = <<<SQL
SELECT  CONCAT('ALTER TABLE `', table_name, '` CONVERT TO CHARACTER SET $encoding COLLATE $collate;') AS statement
FROM    information_schema.tables AS tb
WHERE   table_schema = '$database'
AND     table_name LIKE '$prefix%'
AND     `TABLE_TYPE` = 'BASE TABLE';
SQL;
		/** @var \Cake\Database\Statement\StatementDecorator $res */
		$res = $db->query($script);
		if (!$res) {
			$this->abort('Nothing to do...');
		}

		$script = [];
		foreach ($res as $r) {
			$script[] = $r['statement'];
		}

		if (!$this->param('dry-run')) {
			$continue = $this->in(count($res) . ' tables will be altered.', ['Y', 'N'], 'N');
			if (strtoupper($continue) !== 'Y') {
				$this->abort('Aborted!');
			}
		}

		foreach ($script as $row) {
			preg_match('/`(.+)`/', $row, $matches);
			$table = $matches[1];
			$sql = "ALTER TABLE `$table` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;";

			if ($this->params['interactive']) {
				$in = $this->in('Fix table ' . $table . '?', ['y', 'n'], 'y');
				if ($in !== 'y') {
					$this->out(' - skipping ' . $table);
					continue;
				}
			}

			if (!$this->params['dry-run']) {
				$this->out(' - fixing table ' . $table, 1, Shell::VERBOSE);
				$db->query($row);
				$db->query($sql);
			} else {
				$this->out($row);
				$this->out($sql);
			}
		}
		$this->out('Done :)');
	}
200309
private static String translateEncoding(final String encodingName) throws UnsupportedEncodingException
	{
		try
		{
			String _encoding = encodingName.trim().toLowerCase();
			String _encodingCode = theEncodingResource.getString(_encoding);

			return _encodingCode;
		} // try
		catch (MissingResourceException _exception)
		{
			throw new UnsupportedEncodingException(theMessageUnsupportedEncoding + encodingName);
		} // catch(MissingResourceException _exception)
		catch (Exception _exception)
		{
			throw new UnsupportedEncodingException(theMessageErrorTranslatingEncoding + encodingName);
		} // catch (Exception _exception)
	}
645742
private static Charset toCharset(String csn)
        throws UnsupportedEncodingException
    {
        Objects.requireNonNull(csn, "charsetName");
        try {
            return Charset.forName(csn);
        } catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {
            // UnsupportedEncodingException should be thrown
            throw new UnsupportedEncodingException(csn);
        }
    }
461914
@Trivial
    @Override
    public String getCharacterEncoding() {
        if (null != this.encoding) {
            return this.encoding;
        }

        EncodingUtils encodingUtils = connection.getEncodingUtils();

        String enc = null;
        // parse content-type to see if it's set there
        String type = this.request.getHeader("Content-Type");
        if (null != type) {
            enc = encodingUtils.getCharsetFromContentType(type);
            if (!encodingUtils.isCharsetSupported(enc)) {
                enc = null;
            }
        }

        // now get the appropriate match (may be set in the properties)
        this.encoding = encodingUtils.getJvmConverter(enc);

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getCharacterEncoding: set to " + this.encoding);
        }
        return this.encoding;
    }
894654
@Override
    @Deprecated
    public InputStream getUnicodeStream(int columnIndex) throws SQLException {
        checkColumnBounds(columnIndex);
        throw SQLError.noSupport();
    }
57206
private void processOutlineCodeValues() throws IOException
   {
      DirectoryEntry outlineCodeDir = (DirectoryEntry) m_projectDir.getEntry("TBkndOutlCode");
      FixedMeta fm = new FixedMeta(new DocumentInputStream(((DocumentEntry) outlineCodeDir.getEntry("FixedMeta"))), 10);
      FixedData fd = new FixedData(fm, new DocumentInputStream(((DocumentEntry) outlineCodeDir.getEntry("FixedData"))));

      Map<Integer, FieldType> map = new HashMap<Integer, FieldType>();

      int items = fm.getItemCount();
      for (int loop = 0; loop < items; loop++)
      {
         byte[] data = fd.getByteArrayValue(loop);
         if (data.length < 18)
         {
            continue;
         }

         int index = MPPUtility.getShort(data, 0);
         int fieldID = MPPUtility.getInt(data, 12);
         FieldType fieldType = FieldTypeHelper.getInstance(fieldID);
         if (fieldType.getFieldTypeClass() != FieldTypeClass.UNKNOWN)
         {
            map.put(Integer.valueOf(index), fieldType);
         }
      }

      VarMeta outlineCodeVarMeta = new VarMeta9(new DocumentInputStream(((DocumentEntry) outlineCodeDir.getEntry("VarMeta"))));
      Var2Data outlineCodeVarData = new Var2Data(outlineCodeVarMeta, new DocumentInputStream(((DocumentEntry) outlineCodeDir.getEntry("Var2Data"))));

      Map<FieldType, List<Pair<String, String>>> valueMap = new HashMap<FieldType, List<Pair<String, String>>>();

      for (Integer id : outlineCodeVarMeta.getUniqueIdentifierArray())
      {
         FieldType fieldType = map.get(id);
         String value = outlineCodeVarData.getUnicodeString(id, VALUE);
         String description = outlineCodeVarData.getUnicodeString(id, DESCRIPTION);

         List<Pair<String, String>> list = valueMap.get(fieldType);
         if (list == null)
         {
            list = new ArrayList<Pair<String, String>>();
            valueMap.put(fieldType, list);
         }
         list.add(new Pair<String, String>(value, description));
      }

      for (Entry<FieldType, List<Pair<String, String>>> entry : valueMap.entrySet())
      {
         populateContainer(entry.getKey(), entry.getValue());
      }
   }