CharEncoder.avt

Переключить прокрутку окна
Загрузить этот исходный код

/*
    Реализация среды исполнения языка программирования
    Объектно-ориентированный продвинутый векторный транслятор

    Copyright © 2021, 2024 Малик Разработчик

    Это свободная программа: вы можете перераспространять ее и/или изменять
    ее на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
    в каком она была опубликована Фондом свободного программного обеспечения;
    либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.

    Эта программа распространяется в надежде, что она будет полезной,
    но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
    или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
    общественной лицензии GNU.

    Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
    вместе с этой программой. Если это не так, см.
    <https://www.gnu.org/licenses/>.
*/

package avt.io.charset;

import avt.io.*;
import avt.io.extension.*;
import avt.lang.array.*;

public abstract class CharEncoder(Object)
{
    private static CharactersStorage toStream(CharArray src, int offset, int length) {
        char[] array = new char[length];
        for(int index = 0; index < length; index++) array[index] = src[offset++];
        return new CharactersStorage(array);
    }

    private static CharactersStorage toStream(CharReader src, int length) throws IOException {
        char[] array = new char[length];
        length = src.read(array, 0, length);
        return new CharactersStorage(array, length);
    }

    private long fldGivedBytes;
    private long fldAcceptedChars;
    private ErrorAction fldErrorAction;
    private CharacterEncodingErrorHandler fldErrorHandler;
    private final Object fldMonitor;
    private final Charset fldCharset;

    protected (Charset charset) {
        fldMonitor = new Object();
        fldCharset = charset;
        fldErrorAction = ErrorAction.replace;
    }

    public boolean canEncode(char src) { return true; }

    public final void reset() {
        synchronized(fldMonitor)
        {
            fldGivedBytes = fldAcceptedChars = 0L;
        }
    }

    public final void encodeToWriter(ByteWriter dst, CharArray src) throws CharacterEncodingException, IOException {
        if(dst == null)
        {
            throw new NullPointerException(String.format(avt.lang.package.getResourceString("null-pointer.argument"), new Object[] { "dst" }));
        }
        dst.write(encode(src));
    }

    public final void encodeToWriter(ByteWriter dst, CharArray src, int offset, int length) throws CharacterEncodingException, IOException {
        if(dst == null)
        {
            throw new NullPointerException(String.format(avt.lang.package.getResourceString("null-pointer.argument"), new Object[] { "dst" }));
        }
        dst.write(encode(src, offset, length));
    }

    public final void encodeToWriter(ByteWriter dst, CharReader src, int length) throws CharacterEncodingException, IOException {
        if(dst == null)
        {
            throw new NullPointerException(String.format(avt.lang.package.getResourceString("null-pointer.argument"), new Object[] { "dst" }));
        }
        dst.write(encode(src, length));
    }

    public final boolean canEncode(CharArray src) { return canEncode(src, 0, src == null ? 0 : src.length); }

    public final boolean canEncode(CharArray src, int offset, int length) {
        if(src == null)
        {
            throw new NullPointerException(String.format(avt.lang.package.getResourceString("null-pointer.argument"), new Object[] { "src" }));
        }
        Array.checkBounds(src, offset, length);
        while(length-- > 0) if(!canEncode(src[offset++])) return false;
        return true;
    }

    public final long givedBytes() { return fldGivedBytes; }

    public final long acceptedChars() { return fldAcceptedChars; }

    public final byte[] encode(CharArray src) throws CharacterEncodingException { return encode(src, 0, src == null ? 0 : src.length); }

    public final byte[] encode(CharArray src, int offset, int length) throws CharacterEncodingException {
        if(src == null)
        {
            throw new NullPointerException(String.format(avt.lang.package.getResourceString("null-pointer.argument"), new Object[] { "src" }));
        }
        Array.checkBounds(src, offset, length);
        if(length <= 0) return new byte[0];
        long deltaAcceptedChars = 0L;
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        try
        {
            if(src instanceof char[])
            {
                CharactersStorage stream = new CharactersStorage((char[]) src, offset + length, offset);
                encode(stream, length, result);
                deltaAcceptedChars = stream.position - offset;
            } else
            {
                CharactersStorage stream = toStream(src, offset, length);
                encode(stream, length, result);
                deltaAcceptedChars = stream.position;
            }
        }
        catch(IOException exception) {  }
        long deltaGivedBytes = result.position();
        synchronized(fldMonitor)
        {
            fldGivedBytes += deltaGivedBytes;
            fldAcceptedChars += deltaAcceptedChars;
        }
        return result.toByteArray();
    }

    public final byte[] encode(CharReader src, int length) throws CharacterEncodingException, IOException {
        if(src == null)
        {
            throw new NullPointerException(String.format(avt.lang.package.getResourceString("null-pointer.argument"), new Object[] { "src" }));
        }
        if(length <= 0) return new byte[0];
        long deltaAcceptedChars = 0L;
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        SeekExtension seekable = null;
        if(src instanceof CharactersStorage)
        {
            CharactersStorage stream = (CharactersStorage) src;
            long offset = stream.position;
            encode(src, length, result);
            deltaAcceptedChars = stream.position - offset;
        }
        else if((seekable = (SeekExtension) src.getExtension(SeekExtension.class)) != null)
        {
            long offset = seekable.position();
            encode(src, length, result);
            deltaAcceptedChars = seekable.position() - offset;
        }
        else
        {
            CharactersStorage stream = toStream(src, length);
            encode(stream, length, result);
            deltaAcceptedChars = stream.position;
        }
        long deltaGivedBytes = result.position();
        synchronized(fldMonitor)
        {
            fldGivedBytes += deltaGivedBytes;
            fldAcceptedChars += deltaAcceptedChars;
        }
        return result.toByteArray();
    }

    public final Charset charset { read = fldCharset }

    public final ErrorAction errorAction { read = fldErrorAction, write = setErrorAction }

    public final CharacterEncodingErrorHandler errorHandler { read = fldErrorHandler, write = fldErrorHandler }

    protected abstract void encode(CharReader src, int length, ByteWriter dst) throws CharacterEncodingException, IOException;

    protected final void report() {
        CharacterEncodingErrorHandler handler = fldErrorHandler;
        if(handler != null) handler.encodingError(this);
    }

    private void setErrorAction(ErrorAction newErrorAction) {
        fldErrorAction = newErrorAction == null ? ErrorAction.report : newErrorAction;
    }
}