Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.flume.channel.file;
 
 import java.util.Map;
 
Persistable wrapper for Event
 
 class FlumeEvent implements EventWritable {
 
   private static final byte EVENT_MAP_TEXT_WRITABLE_ID = Byte.valueOf(Integer.valueOf(-116).byteValue());
 
   private static ThreadLocal<CharsetEncoderENCODER_FACTORY =
       new ThreadLocal<CharsetEncoder>() {
     @Override
     protected CharsetEncoder initialValue() {
       return Charset.forName("UTF-8").newEncoder().
     }
   };
 
   private static ThreadLocal<CharsetDecoderDECODER_FACTORY =
       new ThreadLocal<CharsetDecoder>() {
     @Override
     protected CharsetDecoder initialValue() {
       return Charset.forName("UTF-8").newDecoder().
     }
   };
 
   private Map<StringStringheaders;
   private byte[] body;
 
   private FlumeEvent() {
     this(nullnull);
   }
   FlumeEvent(Map<StringStringheadersbyte[] body) {
     this. = headers;
     this. = body;
   }
 
   @Override
   public Map<StringStringgetHeaders() {
     return ;
   }
 
   @Override
   public void setHeaders(Map<StringStringheaders) {
     this. = headers;
   }
 
   @Override
   public byte[] getBody() {
     return ;
   }
 
   @Override
   public void setBody(byte[] body) {
     this. = body;
   }
 
 
   @Override
   public void write(DataOutput outthrows IOException {
 
     out.writeByte(0);
 
     Map<String,StringwriteHeaders = getHeaders();
    if (null != writeHeaders) {
      out.writeInt(.size());
      CharsetEncoder encoder = .get();
      for (String key : .keySet()) {
        ByteBuffer keyBytes = encoder.encode(CharBuffer.wrap(key.toCharArray()));
        int keyLength = keyBytes.limit();
        WritableUtils.writeVInt(outkeyLength);
        out.write(keyBytes.array(), 0, keyLength);
        String value = .get(key);
        out.write();
        ByteBuffer valueBytes = encoder.encode(CharBuffer.wrap(value.toCharArray()));
        int valueLength = valueBytes.limit();
        WritableUtils.writeVInt(outvalueLength );
        out.write(valueBytes.array(), 0, valueLength);
      }
    }
    else {
      out.writeInt( 0 );
    }
    byte[] body = getBody();
    if(body == null) {
      out.writeInt(-1);
    } else {
      out.writeInt(body.length);
      out.write(body);
    }
  }
  public void readFields(DataInput inthrows IOException {
    // newClasses from AbstractMapWritable in Hadoop Common
    byte newClasses = in.readByte();
    // skip over newClasses since only Text is used
    for (byte i = 0; i < newClassesi++) {
      in.readByte();
      in.readUTF();
    }
    Map<String,StringnewHeaders = new HashMap<String,String>();
    int numEntries = in.readInt();
    CharsetDecoder decoder = .get();
    for (int i = 0; i < numEntriesi++) {
      byte keyClassId = in.readByte();
      assert (keyClassId == );
      int keyLength = WritableUtils.readVInt(in);
      byte[] keyBytes = new bytekeyLength ];
      in.readFullykeyBytes, 0, keyLength );
      String key = decoder.decode( ByteBuffer.wrap(keyBytes) ).toString();
      byte valueClassId = in.readByte();
      assert (valueClassId == );
      int valueLength = WritableUtils.readVInt(in);
      byte[] valueBytes = new bytevalueLength ];
      in.readFully(valueBytes, 0, valueLength);
      String value = decoder.decode(ByteBuffer.wrap(valueBytes)).toString();
      newHeaders.put(key,  value);
    }
    setHeaders(newHeaders);
    byte[] body = null;
    int bodyLength = in.readInt();
    if(bodyLength != -1) {
      body = new byte[bodyLength];
      in.readFully(body);
    }
    setBody(body);
  }
  static FlumeEvent from(DataInput inthrows IOException {
    FlumeEvent event = new FlumeEvent();
    event.readFields(in);
    return event;
  }
New to GrepCode? Check out our FAQ X