Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (C) 2011-2012 Barchart, Inc. <http://www.barchart.com/> All rights reserved. Licensed under the OSI BSD License. http://www.opensource.org/licenses/bsd-license.php
  
  package com.barchart.feed.ddf.market.provider;
  
 import static com.barchart.feed.base.provider.MarketConst.NULL_BOOK_ENTRY;
 
 import java.util.List;
 import java.util.Set;
 
 
 import  com.barchart.feed.api.model.data.Book;
 import  com.barchart.feed.api.model.meta.Instrument;
 import  com.barchart.feed.base.book.api.MarketBook;
 import  com.barchart.feed.base.book.api.MarketBookEntry;
 import  com.barchart.feed.base.book.api.MarketDoBook;
 import  com.barchart.feed.base.book.api.MarketDoBookEntry;
 import  com.barchart.feed.base.book.enums.UniBookResult;
 import  com.barchart.feed.base.provider.DefBook;
 import  com.barchart.feed.base.provider.MarketConst;
 import  com.barchart.feed.base.values.api.PriceValue;
 import  com.barchart.feed.base.values.api.SizeValue;
 import  com.barchart.feed.base.values.api.TimeValue;
 import  com.barchart.feed.base.values.provider.ValueBuilder;
 import  com.barchart.feed.base.values.provider.ValueFreezer;
 import  com.barchart.util.common.anno.Mutable;
 import  com.barchart.util.common.anno.ThreadSafe;
 import  com.barchart.util.value.api.Time;
 
 @Mutable
 @ThreadSafe(rule = "use in runSafe() only")
 public final class VarBookDDF extends ValueFreezer<MarketBook> implements
 		MarketDoBook {
 	
 	private static final Logger log = LoggerFactory.getLogger(VarBookDDF.class);
 	
 	protected volatile MarketBookEntry lastEntry = MarketConst.NULL_BOOK_ENTRY;
 	
 	private final Set<Component> changeSet = EnumSet.noneOf(Component.class);
 
 	@SuppressWarnings("serial")
 	private static class EntryMap extends TreeMap<PriceValue, MarketBookEntry> {
 		public EntryMap(final Comparator<PriceValue> comp) {
 			super(comp);
 		}
 	}
 
 	private long millisUTC;
 	
 	private static final Comparator<PriceValue> CMP_ASC = new Comparator<PriceValue>() {
 		public int compare(final PriceValue o1final PriceValue o2) {
 			return o1.compareTo(o2);
 		}
 	};
 
 	private static final Comparator<PriceValue> CMP_DES = new Comparator<PriceValue>() {
 		public int compare(final PriceValue o1final PriceValue o2) {
 			return o2.compareTo(o1);
 		}
 	};
 
 	private final EntryMap bids = new EntryMap();
 	private final EntryMap asks = new EntryMap();
 
 	private volatile MarketBookEntry topBid = MarketBookEntry.NULL;
 	private volatile MarketBookEntry topAsk = MarketBookEntry.NULL;
 
 	private final Instrument instrument;
 	
 	VarBookDDF(final Instrument instrumentfinal Book.Type type
 			final SizeValue sizefinal PriceValue step) {
 		// XXX
 		this. = instrument;
 	}
 
 	// #####################################
 
 	public final UniBookResult setEntry(final MarketDoBookEntry entry) {
 
 		if(entry != null) {
 			 = entry.freeze();
 		}
 		
 		.clear();
 		
 		final Book.Side side = entry.side();
		final int place = entry.place();
		// NOTE: This only updates top.  
		//final EntryMap map = map(side);
		switch (side) {
		case BID:
			if (place == ENTRY_TOP) {
				 = entry;
				.add(Component.TOP_BID);
			}
			break;
		case ASK:
			if (place == ENTRY_TOP) {
				 = entry;
				.add(Component.TOP_ASK);
			}
			break;
		default:
			return UniBookResult.ERROR;
		}
		if (place == ENTRY_TOP) {
			return UniBookResult.TOP;
else {
			return UniBookResult.NORMAL;
		}
	}
	private EntryMap map(final Book.Side side) {
		switch (side) {
		default:
		case BID:
			return ;
		case ASK:
			return ;
		}
	}
	public final MarketBookEntry[] entries(final Book.Side side) {
		final EntryMap map = map(side);
		final Collection<MarketBookEntry> values = map.values();
		final int size = values.size();
		if(size == 0) {
			if(side == Side.BID) {
				return new MarketBookEntry[]{};
else {
				return new MarketBookEntry[]{};
			}
		}
		final MarketBookEntry[] array = new MarketBookEntry[size];
		int index = 0;
		for (final MarketBookEntry entry : values) {
			array[index] = entry;
			index++;
		}
		return array;
	}
	public final DefBook freeze() {
		return new DefBook(time(), 
				entries(Book.Side.BID),
				entries(Book.Side.ASK),
	}
	public TimeValue time() {
		return ValueBuilder.newTime();
	}
	public final void setTime(final TimeValue time) {
		 = time.asMillisUTC();
	}
	public final boolean isFrozen() {
		return false;
	}
	public final MarketBookEntry last() {
//		log.debug("last called in VarBookDDF");
//		final DefBookEntry entry = (DefBookEntry) lastEntry.freeze();
//
//		return entry == null ? NULL_BOOK_ENTRY : entry;
		throw new UnsupportedOperationException("UNUSED");
	}
	public final MarketBookEntry top(final Book.Side side) {
		final MarketBookEntry entry;
		switch (side) {
		case BID:
			entry = ;
			break;
		case ASK:
			entry = ;
			break;
		default:
			entry = null;
			break;
		}
		// System.err.println("### TOP : " + side + " ### " + entry);
		return entry == null ? NULL_BOOK_ENTRY : entry;
	}
	/* #################################### */
	public PriceValue priceGap() {
		throw new UnsupportedOperationException("UNUSED");
	}
	public final SizeValue[] sizes(final Book.Side side) {
		throw new UnsupportedOperationException("UNUSED");
	}
	public PriceValue priceTop(final Book.Side side) {
		throw new UnsupportedOperationException("UNUSED");
	}
	public SizeValue sizeTop(final Book.Side side) {
		throw new UnsupportedOperationException("UNUSED");
	}
	public Top top() {
		throw new UnsupportedOperationException("UNUSED");
	}
	public Entry lastBookUpdate() {
		throw new UnsupportedOperationException("UNUSED");
	}
	public Time updated() {
		throw new UnsupportedOperationException("UNUSED");
	}
	/* #################################### */
	public void clear() {
	}
	public UniBookResult setSnapshot(final MarketDoBookEntry[] entries) {
		if(entries == null) {
			.error("SetSnapshot called with null book entries");
			return UniBookResult.ERROR;
		}
		// log.debug("SetSnapshot called");
		.add(Component.NORMAL_BID);
		.add(Component.NORMAL_ASK);
		.add(Component.TOP_BID);
		.add(Component.TOP_ASK);
		.add(Component.ANY_BID);
		.add(Component.ANY_ASK);
		for (final MarketDoBookEntry entry : entries) {
			if(entry != null && !entry.isNull()) {
				final EntryMap map = map(entry.side());
				map.put(entry.priceValue(), entry);
				/*
				 * Set top of book from snapshot update
				 */
				if(entry.level() == 1) {
					if(entry.side() == Book.Side.BID) {
						 = entry;
else {
						 = entry;
					}
				}
			}
		}
		/*
		 * 
		 */
		return UniBookResult.NORMAL;
	}
	public List<Entry> entryList(Book.Side side) {
		throw new UnsupportedOperationException("UNUSED");
	}
	public Instrument instrument() {
		return ;
	}
	public Set<Component> change() {
		throw new UnsupportedOperationException("UNUSED");
	}
New to GrepCode? Check out our FAQ X