just show hdd info when there is one
[enigma2.git] / lib / base / buffer.cpp
1 #include <lib/base/buffer.h>
2 #include <lib/base/eerror.h>
3 #include <stdio.h>
4 #include <unistd.h>
5 #include <errno.h>
6
7 void eIOBuffer::removeblock()
8 {
9         ASSERT(!buffer.empty());
10         eIOBufferData &b=buffer.front();
11         delete[] b.data;
12         buffer.pop_front();
13         ptr=0;
14 }
15
16 eIOBuffer::eIOBufferData &eIOBuffer::addblock()
17 {
18         eIOBufferData s;
19         s.data=new __u8[allocationsize];
20         s.len=0;
21         buffer.push_back(s);
22         return buffer.back();
23 }
24
25 eIOBuffer::~eIOBuffer()
26 {
27         clear();
28 }
29
30 void eIOBuffer::clear()
31 {
32         while (!buffer.empty())
33                 removeblock();
34 }
35
36 int eIOBuffer::size() const
37 {
38         int total=0;
39         for (std::list<eIOBufferData>::const_iterator i(buffer.begin()); i != buffer.end(); ++i)
40                 total+=i->len;
41         total-=ptr;
42         return total;
43 }
44
45 int eIOBuffer::empty() const
46 {
47         return buffer.empty();
48 }
49
50 int eIOBuffer::peek(void *dest, int len) const
51 {
52         __u8 *dst=(__u8*)dest;
53         std::list<eIOBufferData>::const_iterator i(buffer.begin());
54         int p=ptr;
55         int written=0;
56         while (len)
57         {       
58                 if (i == buffer.end())
59                         break;
60                 int tc=i->len-p;
61                 if (tc > len)
62                         tc = len;
63         
64                 memcpy(dst, i->data+p, tc);
65                 dst+=tc;
66                 written+=tc;
67         
68                 ++i;
69                 p=0;
70                         
71                 len-=tc;
72         }
73         return written;
74 }
75
76 void eIOBuffer::skip(int len)
77 {
78         while (len)
79         {
80                 ASSERT(! buffer.empty());
81                 int tn=len;
82                 if (tn > (buffer.front().len-ptr))
83                         tn=buffer.front().len-ptr;
84
85                 ptr+=tn;
86                 if (ptr == buffer.front().len)
87                         removeblock();
88                 len-=tn;
89         }
90 }
91
92 int eIOBuffer::read(void *dest, int len)
93 {
94         __u8 *dst=(__u8*)dest;
95         len=peek(dst, len);
96         skip(len);
97         return len;
98 }
99
100 void eIOBuffer::write(const void *source, int len)
101 {
102         const __u8 *src=(const __u8*)source;
103         while (len)
104         {
105                 int tc=len;
106                 if (buffer.empty() || (allocationsize == buffer.back().len))
107                         addblock();
108                 if (tc > allocationsize-buffer.back().len)
109                         tc=allocationsize-buffer.back().len;
110                 memcpy(buffer.back().data+buffer.back().len, src, tc);
111                 src+=tc;
112                 buffer.back().len+=tc;
113                 len-=tc;
114         }
115 }
116
117 int eIOBuffer::fromfile(int fd, int len)
118 {
119         int re=0;
120         while (len)
121         {
122                 int tc=len;
123                 int r=0;
124                 if (buffer.empty() || (allocationsize == buffer.back().len))
125                         addblock();
126                 if (tc > allocationsize-buffer.back().len)
127                         tc=allocationsize-buffer.back().len;
128                 r=::read(fd, buffer.back().data+buffer.back().len, tc);
129                 buffer.back().len+=r;
130                 if (r < 0 && errno != EWOULDBLOCK )
131                         eDebug("couldn't read: %m");
132                 else
133                 {
134                         len-=r;
135                         re+=r;
136                         if (r != tc)
137                                 break;
138                 }
139         }
140         return re;
141 }
142
143 int eIOBuffer::tofile(int fd, int len)
144 {
145         int written=0;
146         int w;
147         while (len && !buffer.empty())
148         {       
149                 if (buffer.begin() == buffer.end())
150                         break;
151                 int tc=buffer.front().len-ptr;
152                 if (tc > len)
153                         tc = len;
154         
155                 w=::write(fd, buffer.front().data+ptr, tc);
156                 if (w < 0)
157                 {
158                         if (errno != EWOULDBLOCK)
159                                 eDebug("write: %m");
160                         w=0;
161                 }
162                 ptr+=w;
163                 if (ptr == buffer.front().len)
164                         removeblock();
165                 written+=w;     
166
167                 len-=w;
168                 if (tc != w)
169                         break;
170         }
171         return written;
172 }
173
174 int eIOBuffer::searchchr(char ch) const
175 {
176         std::list<eIOBufferData>::const_iterator i(buffer.begin());
177         int p=ptr;
178         int c=0;
179         while (1)
180         {       
181                 if (i == buffer.end())
182                         break;
183                 while (p < i->len)
184                 {
185                         if (i->data[p] == ch)
186                                 return c;
187                         else
188                                 c++, p++;
189                 }
190                 ++i;
191                 p=0;
192         }
193         return -1;
194 }
195