public long getContentLength() { if (_buffer==null) return -1; return _buffer.length(); }
public void flush() throws IOException { // block until everything is flushed Buffer content = _generator._content; Buffer buffer = _generator._buffer; if (content!=null && content.length()>0 ||buffer!=null && buffer.length()>0) { _generator.flush(); while ((content!=null && content.length()>0 ||buffer!=null && buffer.length()>0) && _generator._endp.isOpen()) blockForOutput(); } }
public void invalidate() { synchronized(this) { // Invalidate it _cache.remove(_key); _key=null; _cachedSize=_cachedSize-(int)_buffer.length(); _cachedFiles--; if (_mostRecentlyUsed==this) _mostRecentlyUsed=_next; else _prev._next=_next; if (_leastRecentlyUsed==this) _leastRecentlyUsed=_prev; else _next._prev=_prev; _prev=null; _next=null; _resource=null; } }
public boolean isBufferFull() { // Should we flush the buffers? boolean full = (_buffer != null && _buffer.space() == 0) || (_content!=null && _content.length()>0); return full; }
public int flush(Buffer header, Buffer buffer, Buffer trailer) throws IOException { if (_closed) throw new IOException("CLOSED"); int flushed=0; if (header!=null && header.length()>0) flushed=flush(header); if (header==null || header.length()==0) { if (buffer!=null && buffer.length()>0) flushed+=flush(buffer); if (buffer==null || buffer.length()==0) { if (trailer!=null && trailer.length()>0) { flushed+=flush(trailer); } } } return flushed; }
public static String to8859_1_String(Buffer buffer) { if (buffer.isImmutable()) return buffer.toString(); try { byte[] bytes=buffer.array(); if (bytes!=null) return new String(bytes,buffer.getIndex(),buffer.length(),StringUtil.__ISO_8859_1); StringBuffer b = new StringBuffer(buffer.length()); for (int i=buffer.getIndex(),c=0;c<buffer.length();i++,c++) b.append((char)(0x7f&buffer.peek(i))); return b.toString(); } catch(UnsupportedEncodingException e) { e.printStackTrace(); return buffer.toString(); } } }
void cache(String pathInContext) { _key=pathInContext; _next=_mostRecentlyUsed; _mostRecentlyUsed=this; if (_next!=null) _next._prev=this; _prev=null; if (_leastRecentlyUsed==null) _leastRecentlyUsed=this; _cache.put(_key,this); _cachedSize+=_buffer.length(); _cachedFiles++; if (_lastModified!=-1) _lastModifiedBytes=new ByteArrayBuffer(HttpFields.formatDate(_lastModified,false)); }
public int flush(Buffer buffer) throws IOException { // TODO handle null array() if (_out==null) return -1; int length=buffer.length(); if (length>0) buffer.writeTo(_out); buffer.clear(); return length; }
void completeUncheckedAddContent() { if (_noContent) { if(_buffer!=null) _buffer.clear(); return; } else { _contentWritten+=_buffer.length(); if (_head) _buffer.clear(); } }
/** Skip any CRLFs in buffers * */ public void skipCRLF() { while (_header!=null && _header.length()>0) { byte ch = _header.peek(); if (ch==HttpTokens.CARRIAGE_RETURN || ch==HttpTokens.LINE_FEED) { _eol=ch; _header.skip(1); } else break; } while (_body!=null && _body.length()>0) { byte ch = _body.peek(); if (ch==HttpTokens.CARRIAGE_RETURN || ch==HttpTokens.LINE_FEED) { _eol=ch; _body.skip(1); } else break; } } /* ------------------------------------------------------------------------------- */
/** * Parse until END state. * This method will parse any remaining content in the current buffer. It does not care about the * {@link #getState current state} of the parser. * @see #parse * @see #parseNext */ public long parseAvailable() throws IOException { long len = parseNext(); long total=len>0?len:0; // continue parsing while (!isComplete() && _buffer!=null && _buffer.length()>0) { len = parseNext(); if (len>0) total+=len; } return total; }
public int flush(Buffer buffer) throws IOException { if (_closed) throw new IOException("CLOSED"); if (_growOutput && buffer.length()>_out.space()) { _out.compact(); if (buffer.length()>_out.space()) { ByteArrayBuffer n = new ByteArrayBuffer(_out.putIndex()+buffer.length()); n.put(_out.peek(0,_out.putIndex())); if (_out.getIndex()>0) { n.mark(); n.setGetIndex(_out.getIndex()); } _out=n; } } int len = _out.put(buffer); buffer.skip(len); return len; }
ByteBuffer b = ByteBuffer.wrap(buffer.array(), buffer.getIndex(), buffer.length()); len=_channel.write(b); if (len>0)
_uri.parse(uri.array(), uri.getIndex(), uri.length()); _request.setUri(_uri);
public boolean equalsIgnoreCase(Buffer b) { if (b==this) return true; // reject different lengths if (b.length() != length()) return false; // reject AbstractBuffer with different hash value if (_hash != 0 && b instanceof AbstractBuffer) { AbstractBuffer ab = (AbstractBuffer) b; if (ab._hash != 0 && _hash != ab._hash) return false; } // Nothing for it but to do the hard grind. for (int i = length(); i-- > 0;) { byte b1 = peek(getIndex() + i); byte b2 = b.peek(b.getIndex() + i); if (b1 != b2) { if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A'); if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A'); if (b1 != b2) return false; } } return true; }
public boolean equals(Object obj) { if (obj==this) return true; // reject non buffers; if (obj == null || !(obj instanceof Buffer)) return false; Buffer b = (Buffer) obj; if (this instanceof Buffer.CaseInsensitve || b instanceof Buffer.CaseInsensitve) return equalsIgnoreCase(b); // reject different lengths if (b.length() != length()) return false; // reject AbstractBuffer with different hash value if (_hash != 0 && obj instanceof AbstractBuffer) { AbstractBuffer ab = (AbstractBuffer) obj; if (ab._hash != 0 && _hash != ab._hash) return false; } // Nothing for it but to do the hard grind. for (int i = length(); i-- > 0;) { byte b1 = peek(getIndex() + i); byte b2 = b.peek(b.getIndex() + i); if (b1 != b2) return false; } return true; }
while (buffer.length() > 0 && _generator._endp.isOpen()) blockForOutput();