Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package divconq.io.stream;
  
 
 public class StreamMessage extends CtpMessage {
 	static public StreamMessage FINAL = new StreamMessage();
 	
 	static public StreamMessage fromFileStore(IFileStoreFile file) {
 		StreamMessage ref = new StreamMessage();
 		ref.path = file.path();
 		ref.isfolder = file.isFolder();
 		ref.filesize = file.getSize();
 		ref.modified = file.getModificationTime().getMillis();
 		
 		// TODO permission
 		
 		return ref;
 	}
 	
 	static public StreamMessage fromMessage(StreamMessage msg) {
 		StreamMessage ref = new StreamMessage();
 		ref.path = msg.getPath();
 		ref.isfolder = msg.isFolder();
 		ref.filesize = msg.getFileSize();
 		ref.modified = msg.getModified();
 		ref.permission = msg.getPermission();
 		
 		return ref;
 	}
 	
 	protected CommonPath path = null;
 	protected boolean eof = false;
 	protected boolean isfolder = false;
 	protected long filesize = 0;
 	protected long modified = 0;
 	protected byte permission = 0x40;  
 	protected long payloadoffset = 0;
 	protected ByteBuf payload = null;
 	
 	public StreamMessage() {
 		this. = 4;
 	}
 	
 	public boolean isFolder() {
 		return this.;
 	}
 	
 	public void setIsFolder(boolean v) {
 		this. = v;
 	}
 	
 	public boolean isEof() {
 		return this.;
 	}
 	
 	public void setEof(boolean v) {
 		this. = v;
 	}
 	
 	public CommonPath getPath() {
 		return this.;
 	}
 	
 	public void setPath(CommonPath v) {
 		this. = v;
 	}
 	
 	public void setPath(String v) {
 		this. = new CommonPath(v);
 	}
 	
 	public ByteBuf getPayload() {
 		return this.;
 	}
 	
 	public void setPayload(ByteBuf v) {
 		this. = v;
 	}
 	
 	public long getFileSize() {
 		return this.;
 	}
 	
 	public void setFileSize(long v) {
 		this. = v;
 	}
 	
 	public long getModified() {
 		return this.;
 	}
 	
 	public void setModified(long v) {
		this. = v;
	}
	public long getPayloadoffset() {
		return this.;
	}
	public void setPayloadoffset(long v) {
		this. = v;
	}
	public byte getPermission() {
		return this.;
	}
	public void setPermission(byte v) {
		this. = v;
	}
		int size = 1  // type
				+ 2  // name size
				+ 1   // flag
				+ 4   // size
				+ 8   // modified
				+ 3   // permissions
				+ 8   // offset
				+ 3;   // payload size
		int nsize = 0;
		int psize = 0;
		if (this. != null)
			nsize = Utf8Encoder.size(this..getFull());
		if (this. != null)
			psize += this..readableBytes();
		ByteBuf bb = ba.buffer(size + nsize + psize);
		bb.writeShort(nsize);
		Utf8Encoder.encode(this..getFull(), bb);
		byte flg = 0;
		flg += (this. ? 1 : 0);
		flg += (this. ? 1 : 0) << 1;
		bb.writeByte(flg);
		bb.writeByte(0);		// unused byte
		bb.writeByte(0);		// unused byte
		if (this. != null) {
		}
		else
		return bb;
	}
	////////////////////////////////////////////////////////////////////
	// decode support
	////////////////////////////////////////////////////////////////////
    enum State {
        PATH_SIZE,
        PATH,
        FLAGS,
        SIZE,
        MODIFIED,
        PERMISSION,
        PAYLOAD_OFFSET,
        PAYLOAD_SIZE,
        PAYLOAD
    }
    protected State state = .;
	protected int pathsize = 0;
	protected int paysize = 0;
	public boolean decode(ChannelHandlerContext ctxByteBuf in) {
		switch (this.) {
		case : {
            if (in.readableBytes() < 2) 
                return false;
            this. = in.readShort();
			this. = .;
			// deliberate fall through 
		}
		case : {
			// return here, without any state reset, means we need more before we can decide what to do
            if (in.readableBytes() < this.
                return false;
            
            if (this. > 0)
            	this.setPath(Utf8Decoder.decode(inthis.).toString());
            
			this. = .;
			// deliberate fall through 
		}
		case : {
            if (in.readableBytes() < 1) 
                return false;
            int flags = in.readByte();
            
            // TODO decode flags properly
            
            if (flags == 1)
            	this. = true;
            else if (flags == 2)
            	this. = true;
            
			this. = .;
			// deliberate fall through 
		}
		case : {
            if (in.readableBytes() < 8) 
                return false;
            this. = in.readLong();
            
            // decode flags
            
			// deliberate fall through 
		}
		case : {
            if (in.readableBytes() < 8) 
                return false;
            this. = in.readLong();
            
			// deliberate fall through 
		}
		case : {
            if (in.readableBytes() < 3) 
                return false;
            this. = in.readByte();
            
            in.skipBytes(2);
            
			// deliberate fall through 
		}
            if (in.readableBytes() < 8) 
                return false;
            this. = in.readLong();
            
			// deliberate fall through 
		}
		case : {
            if (in.readableBytes() < 3) 
                return false;
            
            this. = in.readMedium();
			// deliberate fall through 
		}
		case : {
			// return here, without any state reset, means we need more before we can decide what to do
            if (in.readableBytes() < this.
                return false;
            
            // add Data only if there are some bytes, otherwise skip buffer allocation
            if (this. > 0) {
            	ByteBuf bb = in.readSlice(this.);
            	bb.retain();
            	this. = bb;
            }
		}
		}
		return true;
	}
	public void release() {
		if (this. != null) {
			this. = null;
		}
	}
	public void retain() {
		if (this. != null
	}
New to GrepCode? Check out our FAQ X