public void Remove()
{
var cacheFactory = CacheFactory.Create()
.SetProperty("log-level", "none")
.SetProperty("log-file", "SessionStateCacheIntegrationTests.log");
var cache = (Cache)cacheFactory.CreateCache();
PoolFactory poolFactory = cache.PoolFactory.AddLocator("localhost", 10334);
var pool = poolFactory.CreatePool("myPool");
var ssCache = new SessionStateCache(cache, _regionName);
var options = new DistributedCacheEntryOptions();
DateTime localTime = DateTime.Now.AddDays(1);
DateTimeOffset dateAndOffset = new DateTimeOffset(localTime,
TimeZoneInfo.Local.GetUtcOffset(localTime));
options.AbsoluteExpiration = dateAndOffset;
var testValue = new byte[] { 1, 2, 3, 4, 5 };
ssCache.Set("testKey", testValue, options);
byte[] value = ssCache.Get("testKey");
ssCache.Remove("testKey");
value = ssCache.Get("testKey");
Assert.Null(value);
}
public void TestGetTypeNotPresent()
{
RegisterPoolAndAssertion <TypeOne>(1);
TypeTwo obj = PoolFactory.GetObject <TypeTwo>();
Assert.IsNull(obj);
}
public void Refresh()
{
var cacheFactory = CacheFactory.Create()
.SetProperty("log-level", "none")
.SetProperty("log-file", "SessionStateCacheIntegrationTests.log");
var cache = (Cache)cacheFactory.CreateCache();
PoolFactory poolFactory = cache.PoolFactory.AddLocator("localhost", 10334);
var pool = poolFactory.CreatePool("myPool");
var ssCache = new SessionStateCache(cache, _regionName);
var options = new DistributedCacheEntryOptions();
int numSeconds = 20;
options.SlidingExpiration = new TimeSpan(0, 0, numSeconds);
var testValue = new byte[] { 1, 2, 3, 4, 5 };
// Set a value
ssCache.Set("testKey", testValue, options);
// Wait half a timeout then refresh
System.Threading.Thread.Sleep(numSeconds / 2 * 1000);
ssCache.Refresh("testKey");
// Wait beyond the original expiration
System.Threading.Thread.Sleep(numSeconds / 2 * 1000 + 1);
// Ensure it's not expired
byte[] value = ssCache.Get("testKey");
Assert.True(testValue.SequenceEqual(value));
}
private void ConnectToCloudCache()
{
JObject vcapJson = JObject.Parse(Environment.GetEnvironmentVariable("VCAP_SERVICES"));
Cache cache = new CacheFactory()
.SetAuthInitialize(
new UsernamePassword(
(string)vcapJson.SelectToken(Constants.jsonPathUsername),
(string)vcapJson.SelectToken(Constants.jsonPathPassword)))
.Create();
cache.TypeRegistry.PdxSerializer = new ReflectionBasedAutoSerializer();
PoolFactory pool = cache.GetPoolFactory();
foreach (string locator in vcapJson.SelectToken(Constants.jsonPathLocators).Select(s => (string)s).ToArray())
{
string[] hostPort = locator.Split('[', ']');
pool.AddLocator(hostPort[0], Int32.Parse(hostPort[1]));
}
pool.Create("pool");
region = cache.CreateRegionFactory(RegionShortcut.PROXY)
.SetPoolName("pool")
.Create <string, Book>("owinexample");
}
public static IVariablePool GetVariablePool(string sessionID, string keyID)
{
IVariablePool rVP = null;
PoolFactory.Get(sessionID, keyID, out rVP);
return(rVP);
}
public static void Spawn(EffectId id, Transform target, float durationTime, params object[] values)
{
var key = id.Id2key();
var entity = PoolFactory.Get <Effect>(key, Vector3.zero, Quaternion.identity);
entity.OnReturn = Return;
entity.Spawn(key, target, durationTime, values);
}
public void TestCreationAndGet()
{
RegisterPoolAndAssertion <TypeOne>(1, 10);
TypeOne obj = PoolFactory.GetObject <TypeOne>();
Assert.IsNotNull(obj);
}
protected virtual void OnHit(Cube owner, Monster target, Missile missile)
{
owner.Hit(missile);
target.Hit(owner, missile);
missiles.Remove(missile);
PoolFactory.Return("Missile", missile);
}
public void SetUp()
{
GameObject gameObject = new GameObject();
poolFactory = gameObject.AddComponent <PoolFactory>();
prefabTransform = Resources.Load <Transform>("TestResources/GameObject_OnlyTransform");
}
internal PoolFactory ApplyLocators(PoolFactory poolFactory)
{
foreach (var locator in locators_)
{
poolFactory.AddLocator(locator.Address.address, locator.Address.port);
}
return(poolFactory);
}
/// <summary>
/// 创建池
/// </summary>
/// <param name="resName"></param>
/// <param name="mode"></param>
/// <param name="pType"></param>
/// <param name="time"></param>
private void createPool(string resName, E_PoolMode mode = E_PoolMode.Time, E_PoolType pType = E_PoolType.None, float time = 60)
{
if (!pools.ContainsKey(resName))
{
string resPath = Path.Combine(Define.abPre, resName).ToLower();
BasePool p = PoolFactory.create(resName, resPath, mode, pType, time);
pools.Add(resName, p);
}
}
public virtual void DieMonster(int monsterSeq)
{
var monster = monsters.Find(x => x.seq == monsterSeq);
monster.Release();
monsters.Remove(monster);
PoolFactory.Return("Monster", monster);
user.SP += ServerDefine.MONSTER_DIE_SP;
}
public HomeController(PoolFactory poolFactory, Cache cache)
{
Console.WriteLine("HomeController constructor");
if (cacheRegion == null)
{
Console.WriteLine("Initializing stuff");
InitializeGemFireObjects(poolFactory, cache);
}
Console.WriteLine("Leaving HomeController constructor");
}
public virtual void EscapeMonster(int monsterSeq)
{
var monster = monsters.Find(x => x.seq == monsterSeq);
monster.Release();
monsters.Remove(monster);
PoolFactory.Return("Monster", monster);
user.Life -= 1;
}
void Start()
{
_powerSize = 0.0f;
_powerSizeOffset = 0.1f;
_arrowScaleOffset = 2.0f;
directionArrow.transform.position = new Vector2(transform.position.x - DirectionArrowOffset, transform.position.y + DirectionArrowOffset);
_ballFactory = new PoolFactory(baksetballPrefab);
StartCoroutine(UpdateAI());
}
public IPool CreatePool(string name)
{
var pool = PoolFactory.Create(name);
_pools.Add(name, pool);
EventSystem.Publish(new PoolAddedEvent(pool));
return(pool);
}
public void CreateBasicPool()
{
PoolFactory.InitializePool <BasicTestPool>(2, null);
var item1 = PoolFactory.Create <BasicTestPool>();
var item2 = PoolFactory.Create <BasicTestPool>();
Assert.AreNotEqual(item1, item2);
item1.Dispose();
item2.Dispose();
PoolFactory.DisposePool <BasicTestPool>();
}
public virtual void DeleteCube(List <int> deleteCubes)
{
deleteCubes.ForEach(x =>
{
var cube = cubes.Find(c => c.gameCube.CubeSeq == x);
user.Cubes.Remove(cube.gameCube);
cube.Release();
cubes.Remove(cube);
PoolFactory.Return("Cube", cube);
});
}
private ImagePipelineConfig(Builder builder)
{
_animatedImageFactory = builder.AnimatedImageFactory;
_bitmapMemoryCacheParamsSupplier = builder.BitmapMemoryCacheParamsSupplier ??
new DefaultBitmapMemoryCacheParamsSupplier();
_bitmapConfig = builder.BitmapConfig == default(BitmapPixelFormat) ?
BitmapPixelFormat.Bgra8 : builder.BitmapConfig;
_cacheKeyFactory = builder.CacheKeyFactory ?? DefaultCacheKeyFactory.Instance;
_decodeMemoryFileEnabled = builder.IsDecodeMemoryFileEnabled;
_fileCacheFactory = builder.FileCacheFactory ??
new DiskStorageCacheFactory(new DynamicDefaultDiskStorageFactory());
_downsampleEnabled = builder.IsDownsampleEnabled;
_encodedMemoryCacheParamsSupplier = builder.EncodedMemoryCacheParamsSupplier ??
new DefaultEncodedMemoryCacheParamsSupplier();
_imageCacheStatsTracker = builder.ImageCacheStatsTracker ??
NoOpImageCacheStatsTracker.Instance;
_imageDecoder = builder.ImageDecoder;
_isPrefetchEnabledSupplier = builder.IsPrefetchEnabledSupplier ??
new SupplierImpl <bool>(
() =>
{
return(true);
});
_mainDiskCacheConfig = builder.MainDiskCacheConfig ??
GetDefaultMainDiskCacheConfig();
_memoryTrimmableRegistry = builder.MemoryTrimmableRegistry ??
NoOpMemoryTrimmableRegistry.Instance;
_networkFetcher = builder.NetworkFetcher ?? new HttpUrlConnectionNetworkFetcher();
_platformBitmapFactory = builder.PlatformBitmapFactory;
_poolFactory = builder.PoolFactory ?? new PoolFactory(PoolConfig.NewBuilder().Build());
_progressiveJpegConfig = builder.ProgressiveJpegConfig == default(IProgressiveJpegConfig) ?
new SimpleProgressiveJpegConfig() : builder.ProgressiveJpegConfig;
_requestListeners = builder.RequestListeners ?? new HashSet <IRequestListener>();
_resizeAndRotateEnabledForNetwork = builder.ResizeAndRotateEnabledForNetwork;
_smallImageDiskCacheConfig = builder.SmallImageDiskCacheConfig ?? _mainDiskCacheConfig;
// Below this comment can't be built in alphabetical order, because of dependencies
int numCpuBoundThreads = _poolFactory.FlexByteArrayPoolMaxNumThreads;
_executorSupplier = builder.ExecutorSupplier ??
new DefaultExecutorSupplier(numCpuBoundThreads);
_imagePipelineExperiments = builder.Experiment.Build();
}
public void NullPoolFactory_Throws()
{
PoolFactory poolFactory = null;
var cacheFactory = CacheFactory.Create()
.SetProperty("log-level", "debug")
.SetProperty("log-file", "SessionStateCacheTests.log");
var cache = (Cache)cacheFactory.CreateCache();
Assert.Throws <ArgumentNullException>(() => new SessionStateCache(cache, _regionName));
}
private void Awake()
{
if (PoolData == null)
{
PoolData = this;
}
else
{
Destroy(this);
}
}
public void TestCreatWithNoObjectsAndGet()
{
RegisterPoolAndAssertion <TypeOne>(1, 0);
TypeOne obj = PoolFactory.GetObject <TypeOne>();
Assert.IsNotNull(obj);
Assert.AreEqual(0, PoolFactory.GetPoolSize <TypeOne>());
PoolFactory.Recycle(ref obj);
Assert.AreEqual(1, PoolFactory.GetPoolSize <TypeOne>());
}
public void TestRegisterOverload()
{
int toCompare = 55;
TypeTwo toClone = new TypeTwo(toCompare);
PoolFactory.RegisterPool(toClone, 2);
TypeTwo obj = PoolFactory.GetObject <TypeTwo>();
Assert.IsNotNull(obj);
Assert.AreEqual(toCompare, obj.testParam);
}
public void TestRecycle()
{
RegisterPoolAndAssertion <TypeOne>(1);
Assert.AreEqual(10, PoolFactory.GetPoolSize <TypeOne>());
TypeOne obj = PoolFactory.GetObject <TypeOne>();
Assert.AreEqual(9, PoolFactory.GetPoolSize <TypeOne>());
PoolFactory.Recycle(ref obj);
Assert.AreEqual(10, PoolFactory.GetPoolSize <TypeOne>());
}
public PoolGroup Build()
{
PoolFactory poolFactory = new PoolFactory();
TeamFactory teamFactory = new TeamFactory();
GameFactory gameFactory = new GameFactory();
_poolGroup.Pools = poolFactory.Create(_numOfPools);
_poolGroup.Pools = teamFactory.Create(_poolGroup.Pools, _numOfTeams, _seedMethod);
_poolGroup.Pools = gameFactory.Create(_poolGroup.Pools, _numOfRounds);
return(_poolGroup);
}
public MEntityManager(int capcity = 1024)
{
_singletonComponents = new MComponent[64];
_entities = new Dictionary <int, MEntity>(capcity);
_componentGroup = new ComponentGroup();
#if !RUNINSERVER
MEntity Create()
{
return(new MEntity(_nextEntityId++, this));
}
_entityPool = PoolFactory.Create(Create, null, null, null, 512);
#endif
}
public void TestCompleteFlow()
{
PoolFactory.RegisterPool <TypeTwo>();
// Specify a value to have some instances of objects according to your needs
PoolFactory.RegisterPool <TypeOne>(10);
TypeOne obj_0 = PoolFactory.GetObject <TypeOne>();
// Use methods with "_E" if you want throw Exception
TypeTwo obj_1 = PoolFactory.GetObject_E <TypeTwo>();
PoolFactory.Recycle(ref obj_0);
}
public void Initialize()
{
// Initializes the IFileCache
_fileCacheFactory = new DiskStorageCacheFactory(new DynamicDefaultDiskStorageFactory());
_fileCache = _fileCacheFactory.Get(DiskCacheConfig.NewBuilder().Build());
// Initializes the IPooledByteBufferFactory and PooledByteStreams
_poolFactory = new PoolFactory(PoolConfig.NewBuilder().Build());
_byteBufferFactory = _poolFactory.PooledByteBufferFactory;
_pooledByteStreams = _poolFactory.PooledByteStreams;
// Initializes the IPooledByteBuffer from an image
var file = StorageFile.GetFileFromApplicationUriAsync(
new Uri("ms-appx:///Assets/SplashScreen.scale-200.png")).GetAwaiter().GetResult();
using (var stream = file.OpenReadAsync().GetAwaiter().GetResult())
{
_pooledByteBuffer = _byteBufferFactory.NewByteBuffer(
ByteStreams.ToByteArray(stream.AsStream()));
}
_closeableReference = CloseableReference <IPooledByteBuffer> .of(_pooledByteBuffer);
_encodedImage = new EncodedImage(_closeableReference);
_stagingArea = StagingArea.Instance;
_imageCacheStatsTracker = NoOpImageCacheStatsTracker.Instance;
// Initializes the cache keys
IList <ICacheKey> keys = new List <ICacheKey>();
keys.Add(new SimpleCacheKey("http://test.uri"));
keys.Add(new SimpleCacheKey("http://tyrone.uri"));
keys.Add(new SimpleCacheKey("http://ian.uri"));
_cacheKey = new MultiCacheKey(keys);
// Initializes the executors
_isCancelled = new AtomicBoolean(false);
_readPriorityExecutor = Executors.NewFixedThreadPool(1);
_writePriorityExecutor = Executors.NewFixedThreadPool(1);
// Initializes the disk cache
_bufferedDiskCache = new BufferedDiskCache(
_fileCache,
_byteBufferFactory,
_pooledByteStreams,
_readPriorityExecutor,
_writePriorityExecutor,
_imageCacheStatsTracker);
}
static void TestDistributedSystem(Cache cache, String hostname, int port, String poolName, String regionName)
{
//create pool factory to create the pool.
PoolFactory fact = PoolManager.CreateFactory();
//adding host(endpoint) in pool
fact.AddServer(hostname, port);
//enabling subscription on pool
fact.SetSubscriptionEnabled(true);
//creating pool with name "examplePool"
fact.Create(poolName);
RegionFactory regionFactory = cache.CreateRegionFactory(RegionShortcut.CACHING_PROXY);
IRegion <string, string> region = regionFactory.SetPoolName(poolName).Create <string, string>(regionName);
Console.WriteLine("Created a generic Region.");
// Put an Entry (Key and Value pair) into the Region using the IDictionary interface.
region["Key1"] = "Value1";
Console.WriteLine("Put the first Entry into the Region");
// Put another Entry into the Region.
region["123"] = "123";
Console.WriteLine("Put the second Entry into the Region");
// Get Entries back out of the Region.
string result1 = region["Key1"];
Console.WriteLine("Obtained the first Entry from the Region");
string result2 = region["123"];
Console.WriteLine("Obtained the second Entry from the Region");
// Invalidate an Entry in the Region.
region.Invalidate("Key1");
Console.WriteLine("Invalidated the first Entry in the Region");
// Destroy an Entry in the Region using the IDictionary interface.
region.Remove("123");
Console.WriteLine("Destroyed the second Entry in the Region");
}
public EventManager(int expectedEventTypes, int expectedRegisterCalls)
{
// NW: Doing this because we cannot call the correct consturctor ourselves (AutoGeneratedSingleton!!).
// The Events (enum) EventManager is huge. Allocate here, ourselves, with massive capacity.
// Optimization / hack.
if (typeof(T).FullName == "Events")
{
expectedEventTypes = 70;
expectedRegisterCalls = 80;
}
m_listenerPool = new PoolFactory <List <Action <T, object[]> > >(
() => new List <Action <T, object[]> >(2), x => x.Clear(), expectedRegisterCalls);
m_events = new Dictionary <T, List <Action <T, object[]> > >(expectedEventTypes);
}
public void TestPooling() {
PoolFactory<object> factory = new PoolFactory<object>(10);
// We allocate 10 objects ahead because a valid pool factory implementation could
// decide to only start returning reused objects after the pool is full to quickly
// grow the pool at the beginning.
object[] objects = new object[10];
for(int index = 0; index < objects.Length; ++index) {
objects[index] = factory.Take();
}
for(int index = objects.Length - 1; index >= 0; --index) {
factory.Redeem(objects[index]);
}
for(int index = 0; index < objects.Length; ++index) {
Assert.Contains(factory.Take(), objects);
}
}
public void TestViaObjectFactoryInterface() {
IAbstractFactory factory = new PoolFactory<object>(10);
Assert.IsNotNull(factory.CreateInstance());
}
public void TestExplicitConstructor() {
PoolFactory<object> factory = new PoolFactory<object>(100);
Assert.IsNotNull(factory); // Nonsense; prevents compiler warning
}
