AttributeHelper.java

/*******************************************************************************
 * Copyright (C) 2014, International Business Machines Corporation
 * All Rights Reserved
 *******************************************************************************/

package com.ibm.streamsx.messaging.kafka;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.Set;

import com.ibm.streams.operator.Attribute;
import com.ibm.streams.operator.OutputTuple;
import com.ibm.streams.operator.StreamSchema;
import com.ibm.streams.operator.Tuple;
import com.ibm.streams.operator.Type.MetaType;
import com.ibm.streams.operator.types.Blob;
import com.ibm.streams.operator.types.ValueFactory;

//Helper to check if attributes have been specified explicitly
class AttributeHelper {
	static final Charset CS = Charset.forName("UTF-8");  //$NON-NLS-1$
	private boolean wasSet = false, isAvailable = false;
	private MetaType mType = null;
	private String name = null;
	private boolean isString = false;
	
	AttributeHelper(String n) {
		this.name = n;
	}
	
	boolean isWasSet() {
		return wasSet;
	}
	
	boolean isAvailable() {
		return isAvailable;
	}

	String getName() {
		return name;
	}

	void setName(String name) {
		this.name = name;
		wasSet = true;
	}

	void initialize(StreamSchema ss, boolean required, Set<MetaType> supportedTypes) throws Exception {
		Attribute a = ss.getAttribute(name);
		if(a == null) {
			if(wasSet)
				throw new IllegalArgumentException(Messages.getString("ATTRIBUTE_NOT_AVAILABLE", name)); //$NON-NLS-1$
			if(required)
				throw new IllegalArgumentException(Messages.getString("ATTRIBUTE_NOT_FOUND", name)); //$NON-NLS-1$
			return;
		}
		this.mType = a.getType().getMetaType();
		isString = (mType == MetaType.RSTRING) || (mType == MetaType.USTRING);
		
		if(!supportedTypes.contains(mType)){
			throw new Exception(Messages.getString("ATTRIBUTE_MUST_BE_ONE_OF", name, supportedTypes)); //$NON-NLS-1$
		}
		isAvailable = true;
	}
	boolean isString() {
		return isString;
	}
	
	void setValue(OutputTuple otup, String value) {
		if(!isAvailable) return;
		if (isString) {
			if (value == null)
				value = ""; //$NON-NLS-1$
			otup.setString(name, value);
		} else {
			if (value != null) {
				otup.setBlob(name, ValueFactory.newBlob(value.getBytes(CS)));
			}
		}
	}

	void setValue(OutputTuple otup, byte[] value) {
		if (!isAvailable)
			return;
		if (isString) {
			if (value == null)
				otup.setString(name, ""); //$NON-NLS-1$
			else
				otup.setString(name, new String(value, CS));
		} else {
			if (value != null) {
				otup.setBlob(name, ValueFactory.newBlob(value));
			}
		}
	}
	
	String getString(Tuple tuple) throws IOException {
		if(!isAvailable) return null;
		if(isString)
			return tuple.getString(name);
        return new String(getBytesFromBlob(tuple, name));
	}
	
	byte[] getBytes(Tuple tuple) throws IOException {
		if(!isAvailable) return null;
		if(isString)
			return tuple.getString(name).getBytes(CS);
		return getBytesFromBlob(tuple, name);
	}
	
	private static byte[] getBytesFromBlob(Tuple tuple, String name) throws IOException {
		Blob blockMsg = tuple.getBlob(name);
		ByteBuffer msgBuffer = blockMsg.getByteBuffer();
		byte[] msgBytes = new byte[(int) blockMsg.getLength()];
		msgBuffer.get(msgBytes);
        return msgBytes;
	}
}