/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 18 июн. 2018 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#include
#include
#include
#include
#include
#include
#define CBUF_SIZE 0x1000
#define BBUF_SIZE 0x4000
namespace lsp
{
namespace io
{
OutSequence::OutSequence()
{
pOS = NULL;
nWrapFlags = 0;
}
OutSequence::~OutSequence()
{
// Close file descriptor
if (pOS != NULL)
{
flush_buffer_internal(true);
if (nWrapFlags & WRAP_CLOSE)
pOS->close();
if (nWrapFlags & WRAP_DELETE)
delete pOS;
pOS = NULL;
}
nWrapFlags = 0;
// Close encoder
sEncoder.close();
}
status_t OutSequence::close()
{
status_t res = STATUS_OK, tres;
// Close file descriptor
if (pOS != NULL)
{
// Flush buffers
res = flush();
// Perform close
if (nWrapFlags & WRAP_CLOSE)
{
tres = pOS->close();
if (res == STATUS_OK)
res = tres;
}
if (nWrapFlags & WRAP_DELETE)
delete pOS;
pOS = NULL;
}
nWrapFlags = 0;
// Close encoder
sEncoder.close();
// Return result
return set_error(res);
}
status_t OutSequence::wrap(FILE *fd, bool close, const char *charset)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (fd == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->wrap(fd, close);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
if (res != STATUS_OK)
{
f->close();
delete f;
}
return set_error(STATUS_OK);
}
status_t OutSequence::wrap_native(fhandle_t fd, bool close, const char *charset)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->wrap_native(fd, close);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
if (res != STATUS_OK)
{
f->close();
delete f;
}
return set_error(STATUS_OK);
}
status_t OutSequence::wrap(File *fd, size_t flags, const char *charset)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (fd == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->wrap(fd, flags);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
if (res != STATUS_OK)
{
f->close();
delete f;
}
return set_error(STATUS_OK);
}
status_t OutSequence::wrap(IOutStream *os, size_t flags, const char *charset)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (os == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
// Initialize decoder
status_t res = sEncoder.init(charset);
if (res != STATUS_OK)
{
sEncoder.close();
return set_error(res);
}
// Store pointers
pOS = os;
nWrapFlags = flags;
return set_error(STATUS_OK);
}
status_t OutSequence::open(const char *path, size_t mode, const char *charset)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
LSPString tmp;
if (!tmp.set_utf8(path))
return set_error(STATUS_NO_MEM);
return open(&tmp, mode, charset);
}
status_t OutSequence::open(const LSPString *path, size_t mode, const char *charset)
{
if (pOS != NULL)
return set_error(STATUS_BAD_STATE);
else if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
OutFileStream *f = new OutFileStream();
if (f == NULL)
return set_error(STATUS_NO_MEM);
status_t res = f->open(path, mode);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
res = wrap(f, WRAP_CLOSE | WRAP_DELETE, charset);
if (res != STATUS_OK)
{
f->close();
delete f;
return set_error(res);
}
return set_error(STATUS_OK);
}
status_t OutSequence::open(const Path *path, size_t mode, const char *charset)
{
return open(path->as_string(), mode, charset);
}
status_t OutSequence::flush_buffer_internal(bool force)
{
// Flush all character data to stream
ssize_t fetch;
do
{
fetch = sEncoder.fetch(pOS);
} while (fetch > 0);
if ((fetch < 0) && (fetch != -STATUS_EOF))
return set_error(status_t(-fetch));
return set_error((force) ? pOS->flush() : STATUS_OK);
}
status_t OutSequence::write(lsp_wchar_t c)
{
if (pOS == NULL)
return set_error(STATUS_CLOSED);
ssize_t filled = sEncoder.fill(c);
if (filled > 0)
return set_error(STATUS_OK);
status_t res = flush_buffer_internal(false);
if (res != STATUS_OK)
return set_error(res);
filled = sEncoder.fill(c);
return set_error((filled > 0) ? STATUS_OK : STATUS_UNKNOWN_ERR);
}
status_t OutSequence::write(const lsp_wchar_t *c, size_t count)
{
if (pOS == NULL)
return set_error(STATUS_CLOSED);
size_t written = 0;
while (written < count)
{
// Try to fill data
ssize_t filled = sEncoder.fill(c, count - written);
if (filled > 0)
{
c += filled;
written += filled;
continue;
}
// Try to fetch data
ssize_t fetched = sEncoder.fetch(pOS);
if (fetched > 0)
continue;
// Nothing to do more? Skip any errors if there was data processed
if (written > 0)
break;
// Analyze errors
if (filled < 0)
return -set_error(status_t(-filled));
else if (fetched < 0)
return -set_error(status_t(-fetched));
break;
}
return set_error(STATUS_OK);
}
status_t OutSequence::write_ascii(const char *s, size_t count)
{
if (pOS == NULL)
return set_error(STATUS_CLOSED);
size_t written = 0;
while (written < count)
{
// Try to fill data
ssize_t filled = sEncoder.fill(s, count - written);
if (filled > 0)
{
s += filled;
written += filled;
continue;
}
// Try to fetch data
ssize_t fetched = sEncoder.fetch(pOS);
if (fetched > 0)
continue;
// Nothing to do more? Skip any errors if there was data processed
if (written > 0)
break;
// Analyze errors
if (filled < 0)
return -set_error(status_t(-filled));
else if (fetched < 0)
return -set_error(status_t(-fetched));
break;
}
return set_error(STATUS_OK);
}
status_t OutSequence::flush()
{
if (pOS == NULL)
return set_error(STATUS_CLOSED);
return flush_buffer_internal(true);
}
}
} /* namespace lsp */