Java ByteArrayConverter类代码示例

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public void singleValueUUID(int count)
{
	HGStore store = graph.getStore();
	ByteArrayConverter<HGPersistentHandle> conv = BAtoHandle.getInstance(graph.getHandleFactory());
	if (store.getIndex("benchUUIDs", conv, conv, null, null, false) != null)
			store.removeIndex("benchUUIDs");
	HGIndex<HGPersistentHandle, HGPersistentHandle> idx = store.getIndex("benchUUIDs", 
				   BAtoHandle.getInstance(graph.getHandleFactory()), 
				   BAtoHandle.getInstance(graph.getHandleFactory()), 
				   null,
				   null,
				   true);
	HGHandleFactory hFactory = graph.getHandleFactory();
	long start = System.currentTimeMillis();
	for (int i = 0; i < count; i++)
	{
		idx.addEntry(hFactory.makeHandle(), hFactory.makeHandle());
	}
	System.out.println("" + count + "," + (System.currentTimeMillis() - start)/1000.0);
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
/**
 * <p>Construct a result set matching a specific key.</p>
 * 
 * @param cursor
 * @param key
 */
public IndexResultSet(LmdbTxCursor cursor, DatabaseEntry keyIn, ByteArrayConverter<T> converter)
{
	checkArgNotNull(cursor, "cursor");
	
  this.converter = converter;
  this.cursor = cursor;
  this.key = new DatabaseEntry();
  this.data = new DatabaseEntry();
  if (keyIn != null)
  	assignData(this.key, keyIn.getData());

  try
 {
     cursor.cursor().get(CursorOp.GET_CURRENT, key, data);
     next = converter.fromByteArray(data.getData(), 0, data.getData().length);
     lookahead = 1;
 }
 catch (Throwable t)
 {
     throw new HGException(t);
 }
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public SingleValueResultSet(LmdbTxCursor cursor, DatabaseEntry keyIn,
		ByteArrayConverter<T> converter)
{
	this.converter = converter;
	this.cursor = cursor;
	this.key = new DatabaseEntry();
	this.data = new DatabaseEntry();
	if (keyIn != null)
		assignData(key, keyIn.getData());
	try
	{
		((SecondaryCursor) cursor.cursor()).get(CursorOp.GET_CURRENT, key,
				pkey, data);
		next = converter.fromByteArray(pkey.getData(), 0, pkey.getData().length);
		lookahead = 1;
	}
	catch (Throwable t)
	{
		throw new HGException(t);
	}

}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public KeyScanResultSet(LmdbTxCursor cursor, DatabaseEntry keyIn, ByteArrayConverter<T> converter)
{
    this.converter = converter;
    this.cursor = cursor;
    this.key = new DatabaseEntry();
    this.data = new DatabaseEntry();

    if (keyIn != null)
    	assignData(key, keyIn.getData());
  try
  {
      cursor.cursor().get(CursorOp.GET_CURRENT, key, data);
      next = converter.fromByteArray(key.getData(), 0, key.getData().length);
      lookahead = 1;
  }
  catch (Throwable t)
  {
      throw new HGException(t);
  }         
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public DefaultIndexImpl(String indexName, 
		BJEStorageImplementation storage, 
		HGTransactionManager transactionManager,
		ByteArrayConverter<KeyType> keyConverter, 
		ByteArrayConverter<ValueType> valueConverter, 
		Comparator<byte[]> keyComparator,
		Comparator<byte[]> valueComparator)
{
	this.name = indexName;
	this.storage = storage;
	this.transactionManager = transactionManager;
	this.keyConverter = keyConverter;
	this.valueConverter = valueConverter;
	this.keyComparator = keyComparator;
	this.valueComparator = valueComparator;
	owndb = true;
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
/**
 * <p>
 * Construct a result set matching a specific key.
 * </p>
 * 
 * @param cursor
 * @param key
 */
public IndexResultSet(BJETxCursor cursor, DatabaseEntry keyIn, ByteArrayConverter<T> converter) {
	/*
	 * id = idcounter++; System.out.println("Constructing index set with id " + id); StackTraceElement
	 * e[]=Thread.currentThread().getStackTrace(); for (int i=0; i <e.length; i++) { System.out.println(e[i]);
	 * }
	 */
	this.converter = converter;
	this.cursor = cursor;
	this.key = new DatabaseEntry();
	
	if (keyIn != null) {
		assignData(this.key, keyIn.getData());
	}
	
	try {
		cursor.cursor().getCurrent(key, data, LockMode.DEFAULT);
		next = converter.fromByteArray(data.getData(), data.getOffset(), data.getSize());
		lookahead = 1;
	}
	catch (Throwable t) {
		throw new HGException(t);
	}
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public SingleValueResultSet(BJETxCursor cursor, DatabaseEntry keyIn, ByteArrayConverter<T> converter) {
	//
	// The following is bit hacky because we want to avoid some of the default behavior
	// of the super constructor, which is incorrect when the "values" we are interested in 
	// are the DB's primary keys. So we duplicate its bebavior and override instantiation
	// of the current value.
	this.converter = converter;
	this.cursor = cursor;
	this.key = new DatabaseEntry();
	if (keyIn != null) {
		assignData(key, keyIn.getData());
	}
	
	try {
		((SecondaryCursor)cursor.cursor()).getCurrent(key, pkey, data, LockMode.DEFAULT);
		next = converter.fromByteArray(pkey.getData(), pkey.getOffset(), pkey.getSize());
		lookahead = 1;
	}
	catch (Throwable t) {
		throw new HGException(t);
	}

}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public KeyScanResultSet(BJETxCursor cursor, DatabaseEntry keyIn, ByteArrayConverter<T> converter) {
	this.converter = converter;
	this.cursor = cursor;
	this.key = new DatabaseEntry();
	
	if (keyIn != null) {
		assignData(key, keyIn.getData());
	}
	
	try {
		cursor.cursor().getCurrent(key, data, LockMode.DEFAULT);
		next = converter.fromByteArray(key.getData(), key.getOffset(), key.getSize());
		lookahead = 1;
	}
	catch (Throwable t) {
		throw new HGException(t);
	}
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public KeyScanResultSet(BDBTxCursor cursor, DatabaseEntry keyIn, ByteArrayConverter<T> converter)
{
    this.converter = converter;
    this.cursor = cursor;
    this.key = new DatabaseEntry();
    this.data = new DatabaseEntry();
    // TODO: for fixed size key and data,we should actually reuse the buffers, but
    // this has to be passed somehow as a configuration parameter to the HGIndex
    // implementation and down to result sets. It's a worthwhile optimization.
    this.key.setReuseBuffer(false);
    this.data.setReuseBuffer(false);

    if (keyIn != null)
    	assignData(key, keyIn.getData());
 try
 {
     cursor.cursor().getCurrent(key, data, LockMode.DEFAULT);
     next = converter.fromByteArray(key.getData(), key.getOffset(), key.getSize());
     lookahead = 1;
 }
 catch (Throwable t)
 {
     throw new HGException(t);
 }         
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
private <KeyType extends Object, ValueType extends Object> 
		HGIndex<KeyType, ValueType> getOrCreateIndex(HGIndexer indexer)
	{
		HGIndex<KeyType, ValueType> result = (HGIndex<KeyType, ValueType>)indices.get(indexer);
		if (result == null)			
		{
			String name = getIndexName(indexer);
			ByteArrayConverter<ValueType> converter = null;
			if (indexer instanceof HGValueIndexer)
				converter = (ByteArrayConverter<ValueType>)((HGValueIndexer)indexer).getValueConverter(graph);
			else
				converter = (ByteArrayConverter<ValueType>)BAtoHandle.getInstance(graph.getHandleFactory());
			result = graph.getStore().getIndex(name, 
											   (ByteArrayConverter<KeyType>)indexer.getConverter(graph), 
											   converter, 
											   indexer.getComparator(graph),
											   true);
//			if (result == null)
//				result = graph.getStore().createIndex(name, 
//													  (ByteArrayConverter<KeyType>)indexer.getConverter(graph), 
//													  converter, 
//													  indexer.getComparator(graph));
			indices.put(indexer, result);
		}
		return result;
	}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public <KeyType, ValueType> HGIndex<KeyType, ValueType> getIndex(
		String name, ByteArrayConverter<KeyType> keyConverter,
		ByteArrayConverter<ValueType> valueConverter,
		Comparator<?> comparator, boolean isBidirectional,
		boolean createIfNecessary)
{
	// TODO Auto-generated method stub
	return null;
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public DefaultIndexImpl(String indexName, LmdbStorageImplementation storage,
		HGTransactionManager transactionManager,
		ByteArrayConverter<KeyType> keyConverter,
		ByteArrayConverter<ValueType> valueConverter,
		Comparator<byte[]> comparator)
{
	this.name = indexName;
	this.storage = storage;
	this.transactionManager = transactionManager;
	this.keyConverter = keyConverter;
	this.valueConverter = valueConverter;
	this.comparator = comparator;
	owndb = true;
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public DefaultBiIndexImpl(String indexName,
		LmdbStorageImplementation storage,
		HGTransactionManager transactionManager,
		ByteArrayConverter<KeyType> keyConverter,
		ByteArrayConverter<ValueType> valueConverter,
		Comparator<byte[]> comparator)
{
	super(indexName, storage, transactionManager, keyConverter,
			valueConverter, comparator);
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public SingleKeyResultSet(LmdbTxCursor cursor, DatabaseEntry key,
		ByteArrayConverter<T> converter)
{
	super(cursor, key, converter);
	try
	{
		ordered = cursor.cursor().getDatabase()
				.getConfig(cursor.txn().getDbTransaction()).isDupSort();
	}
	catch (Throwable t)
	{
		throw new HGException(t);
	}
}
 

import org.hypergraphdb.storage.ByteArrayConverter; //导入依赖的package包/类
public SingleKeyResultSet(BJETxCursor cursor, DatabaseEntry key, ByteArrayConverter<T> converter) {
	super(cursor, key, converter);
	try {
		ordered = cursor.cursor().getDatabase().getConfig().getSortedDuplicates();
	}
	catch (Throwable t) {
		throw new HGException(t);
	}
}