Java HGHandleFactory类代码示例

import org.hypergraphdb.HGHandleFactory; //导入依赖的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.HGHandleFactory; //导入依赖的package包/类
private static double lookupAll(HGHandleFactory handleFactory, Set<HGPersistentHandle> baseSet, HGAtomSet destination)
	{
		long start = System.currentTimeMillis();
//		int cnt = 0;
		for (int i = 0; i < 30; i++)
		for (HGHandle x : baseSet)
		{
			destination.contains(x);
			destination.contains(handleFactory.makeHandle());
/*			System.out.println(x);
			if (cnt % 100 == 0)
				System.out.println("cnt=" + cnt);
			cnt++; */
		}
		return (System.currentTimeMillis() - start)/1000.0;		
	}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public static void main(String []argv)
{
	HashSet<HGPersistentHandle> baseSet = new HashSet<HGPersistentHandle>();
	HGHandleFactory handleFactory = new UUIDHandleFactory();
	for (int i = 0; i < 10000; i++)
	{
		HGPersistentHandle h = handleFactory.makeHandle();
		baseSet.add(h);
	}
       SortedSet<HGHandle> tset = Collections.synchronizedSortedSet(new TreeSet<HGHandle>());
       System.out.println("treeset add:" + addAll(baseSet, tset));
       System.out.println("treeset lookup:" + lookupAll(handleFactory, baseSet, tset));
	HGAtomSet set = new HGAtomSet();
	System.out.println("atomset add:" + addAll(baseSet, set));
	System.out.println("atomset lookup:" + lookupAll(handleFactory, baseSet, set));
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public static HGPersistentHandle deserializePersistentHandle(InputStream in)
{
	//  TODO: we need to get the actual handle factory here, but it's annoying
	//  to have to pass the parameter everywhere.
	HGHandleFactory handleFactory = new UUIDHandleFactory();
	byte[] data = new byte[handleFactory.anyHandle().toByteArray().length];
	try
	{
		for (int i = 0; i < data.length;)
			i += in.read(data, i, data.length - i);
	}
	catch (IOException e)
	{
		throw new RuntimeException(e);
	}
	return handleFactory.makeHandle(data);
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public static HGPersistentHandle[] convertStringToHandleArray( String inputString, int handlesize,  HGHandleFactory hghandlefactory)
 {
HGPersistentHandle[] handles;

byte[] input = HGConverter.convertStringtoByteArray(inputString);
int size = input.length;

 		if (input == null)
 		  	return HyperGraph.EMPTY_PERSISTENT_HANDLE_SET;
 		else if (size == 0)
		   		return HyperGraph.EMPTY_PERSISTENT_HANDLE_SET;
 		else if (size % handleSize != 0)
 			throw new HGException("While reading link tuple: the value buffer size is not a multiple of the handle size.");
 		else 
 			{ 	int handle_count = size / handleSize;
 			  	handles = new HGPersistentHandle[handle_count];
 			  	for (int i = 0; i < handle_count; i++)  
 			  		handles[i] = hghandlefactory.makeHandle(input, i*handleSize);  // in LinkBinding.readHandle calls is called makeHandle with buffer, "offset + i*handleSize", whereas offset comes from entryToObject which is just 0
 			}  	
 		
 		return handles;
 }
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public static HGPersistentHandle[] convertByteArrayToHandleArray( byte[] input,  HGHandleFactory hghandlefactory)
{
     if (input == null)
		  	return null;
       int size = input.length;



       if (size == 0)
             return HyperGraph.EMPTY_PERSISTENT_HANDLE_SET;

       if (size % handleSize != 0)
         throw new HGException("While reading link tuple: the value buffer size is not a multiple of the handle size.");
   int handle_count = size / handleSize;
 HGPersistentHandle[] handles = new HGPersistentHandle[handle_count];
       for (int i = 0; i < handle_count; i++)  
           handles[i] = hghandlefactory.makeHandle(input, i*handleSize);  // in LinkBinding.readHandle calls is called makeHandle with buffer, "offset + i*handleSize", whereas offset comes from entryToObject which is just 0 ?
   return handles;
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public static PredefinedTypesConfig loadFromResource(HGHandleFactory handleFactory, String resource)
{
    InputStream in = PredefinedTypesConfig.class.getResourceAsStream(resource);
    try
    {
        PredefinedTypesConfig config = new PredefinedTypesConfig();
        config.loadTypes(handleFactory, readIt(in));
        return config;
    }
    catch (Exception ex)
    {
        throw new HGException(ex);
    }        
    finally
    {
        try {in.close();}catch (Throwable t) {}
    }
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public static PredefinedTypesConfig loadFromFile(HGHandleFactory handleFactory, File file)
{
    InputStream in = null;
    try
    {
        in = new FileInputStream(file);
        PredefinedTypesConfig config = new PredefinedTypesConfig();
        config.loadTypes(handleFactory, readIt(in));
        return config;
    }
    catch (Exception ex)
    {
        throw new HGException(ex);
    }        
    finally
    {
        try {if (in != null) in.close();}catch (Throwable t) {}
    }        
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public TransactionLmdbImpl(LmdbStorageImplementation storeImpl,
		HGHandleFactory handleFactory, Transaction t, Env env,
		boolean readOnly)
{
	this.storeImpl = storeImpl;
	this.handleFactory = handleFactory;
	this.env = env;
	this.t = t;
	this.readOnly = readOnly;

	if (storeImpl != null)
	{
		syncFrequency = storeImpl.getConfiguration().getSyncFrequency();
		syncForce = storeImpl.getConfiguration().isSyncForce();
	}
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public synchronized static ByteArrayConverter<HGPersistentHandle> getInstance(HGHandleFactory handleFactory)
{
    BAtoHandle instance = M.get(handleFactory);
    if (instance == null)
    {
        instance = new BAtoHandle();
        instance.handleFactory = handleFactory;
        M.put(handleFactory, instance);
    }
    return instance;
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public LinkBinding(HGStore store, HGHandleFactory handleFactory)
{
	this.handleFactory = handleFactory;
	handleSize = handleFactory.nullHandle().toByteArray().length;
	assert handleSize > 0;
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public HGHandleFactory hfactory()
{
	return config().getHandleFactory();
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public LinkBinding(HGHandleFactory handleFactory) {
	this.handleFactory = handleFactory;
	handleSize = handleFactory.nullHandle().toByteArray().length;
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public LinkBinding(HGHandleFactory handleFactory)
{
    this.handleFactory = handleFactory;
    handleSize = handleFactory.nullHandle().toByteArray().length;
}
 

import org.hypergraphdb.HGHandleFactory; //导入依赖的package包/类
public HandleConverter(HGHandleFactory hf) {
    this.hf = hf;
}