1 /*
2  * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3  *           (C) 2020 Vladimir Sadovnikov <sadko4u@gmail.com>
4  *
5  * This file is part of lsp-plugins
6  * Created on: 14 июн. 2018 г.
7  *
8  * lsp-plugins is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * any later version.
12  *
13  * lsp-plugins is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with lsp-plugins. If not, see <https://www.gnu.org/licenses/>.
20  */
21 
22 #include <core/io/IOutSequence.h>
23 
24 namespace lsp
25 {
26     namespace io
27     {
IOutSequence()28         IOutSequence::IOutSequence()
29         {
30             nErrorCode      = STATUS_OK;
31         }
32 
~IOutSequence()33         IOutSequence::~IOutSequence()
34         {
35         }
36 
write(lsp_wchar_t c)37         status_t IOutSequence::write(lsp_wchar_t c)
38         {
39             return set_error(STATUS_NOT_IMPLEMENTED);
40         }
41 
write(const lsp_wchar_t * c,size_t count)42         status_t IOutSequence::write(const lsp_wchar_t *c, size_t count)
43         {
44             return set_error(STATUS_NOT_IMPLEMENTED);
45         }
46 
write_ascii(const char * s)47         status_t IOutSequence::write_ascii(const char *s)
48         {
49             if (s == NULL)
50                 return set_error(STATUS_BAD_ARGUMENTS);
51             return write_ascii(s, ::strlen(s));
52         }
53 
write_ascii(const char * s,size_t count)54         status_t IOutSequence::write_ascii(const char *s, size_t count)
55         {
56             return set_error(STATUS_NOT_IMPLEMENTED);
57         }
58 
write(const LSPString * s)59         status_t IOutSequence::write(const LSPString *s)
60         {
61             if (s == NULL)
62                 return set_error(STATUS_BAD_ARGUMENTS);
63             return write(s->characters(), s->length());
64         }
65 
write(const LSPString * s,ssize_t first)66         status_t IOutSequence::write(const LSPString *s, ssize_t first)
67         {
68             if (s == NULL)
69                 return set_error(STATUS_BAD_ARGUMENTS);
70 
71             ssize_t len = s->length();
72             if (first > len)
73                 return set_error(STATUS_OVERFLOW);
74 
75             const lsp_wchar_t *v = s->characters();
76             return write(&v[first], len - first);
77         }
78 
write(const LSPString * s,ssize_t first,ssize_t last)79         status_t IOutSequence::write(const LSPString *s, ssize_t first, ssize_t last)
80         {
81             if (s == NULL)
82                 return set_error(STATUS_BAD_ARGUMENTS);
83 
84             ssize_t len = s->length();
85             if (first > len)
86                 return set_error(STATUS_OVERFLOW);
87             else if (last > len)
88                 return set_error(STATUS_OVERFLOW);
89 
90             len = last - first;
91             if (len < 0)
92                 return set_error(STATUS_OVERFLOW);
93             else if (len == 0)
94                 return set_error(STATUS_OK);
95 
96             const lsp_wchar_t *v = s->characters();
97             return write(&v[first], len);
98         }
99 
writeln(lsp_wchar_t c)100         status_t IOutSequence::writeln(lsp_wchar_t c)
101         {
102             lsp_wchar_t w[2];
103             w[0] = c;
104             w[1] = '\n';
105             return write(w, 2);
106         }
107 
writeln(const lsp_wchar_t * c,size_t count)108         status_t IOutSequence::writeln(const lsp_wchar_t *c, size_t count)
109         {
110             LSP_STATUS_ASSERT(write(c, count));
111             return write('\n');
112         }
113 
writeln_ascii(const char * s)114         status_t IOutSequence::writeln_ascii(const char *s)
115         {
116             LSP_STATUS_ASSERT(write_ascii(s));
117             return write('\n');
118         }
119 
writeln(const LSPString * s)120         status_t IOutSequence::writeln(const LSPString *s)
121         {
122             LSP_STATUS_ASSERT(write(s));
123             return write('\n');
124         }
125 
writeln(const LSPString * s,ssize_t first)126         status_t IOutSequence::writeln(const LSPString *s, ssize_t first)
127         {
128             LSP_STATUS_ASSERT(write(s, first));
129             return write('\n');
130         }
131 
writeln(const LSPString * s,ssize_t first,ssize_t last)132         status_t IOutSequence::writeln(const LSPString *s, ssize_t first, ssize_t last)
133         {
134             LSP_STATUS_ASSERT(write(s, first, last));
135             return write('\n');
136         }
137 
flush()138         status_t IOutSequence::IOutSequence::flush()
139         {
140             return set_error(STATUS_NOT_IMPLEMENTED);
141         }
142 
close()143         status_t IOutSequence::close()
144         {
145             return set_error(STATUS_OK);
146         }
147     }
148 
149 } /* namespace lsp */
150