OSSForks/react
1
0
Fork 0
mirror of https://github.com/zebrajr/react.git synced 2026-01-15 12:15:22 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Removed PooledClass (and tests) (#11053)

Browse Source
This commit is contained in:
Brian Vaughn
2017-10-02 16:54:40 -07:00
committed by GitHub
parent ad1709a394
commit 07b1da8964
3 changed files with 0 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/rollup/packaging.js
View File

@@ -24,8 +24,6 @@ const facebookWWWSrcDependencies = [
// these files need to be copied to the react-native build
const reactNativeSrcDependencies = [
// TODO: copy this to RN repository and delete from React
'src/renderers/native/PooledClass.js',
'src/renderers/shared/fiber/isomorphic/ReactTypes.js',
'src/renderers/native/ReactNativeTypes.js',
];

121
src/renderers/native/PooledClass.js
View File

@@ -1,121 +0,0 @@
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @providesModule PooledClass
* @flow
*/
'use strict';
var invariant = require('fbjs/lib/invariant');
/**
* Static poolers. Several custom versions for each potential number of
* arguments. A completely generic pooler is easy to implement, but would
* require accessing the `arguments` object. In each of these, `this` refers to
* the Class itself, not an instance. If any others are needed, simply add them
* here, or in their own files.
*/
var oneArgumentPooler = function(copyFieldsFrom) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, copyFieldsFrom);
return instance;
} else {
return new Klass(copyFieldsFrom);
}
};
var twoArgumentPooler = function(a1, a2) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2);
return instance;
} else {
return new Klass(a1, a2);
}
};
var threeArgumentPooler = function(a1, a2, a3) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2, a3);
return instance;
} else {
return new Klass(a1, a2, a3);
}
};
var fourArgumentPooler = function(a1, a2, a3, a4) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2, a3, a4);
return instance;
} else {
return new Klass(a1, a2, a3, a4);
}
};
var standardReleaser = function(instance) {
var Klass = this;
invariant(
instance instanceof Klass,
'Trying to release an instance into a pool of a different type.',
);
instance.destructor();
if (Klass.instancePool.length < Klass.poolSize) {
Klass.instancePool.push(instance);
}
};
var DEFAULT_POOL_SIZE = 10;
var DEFAULT_POOLER = oneArgumentPooler;
type Pooler = any;
/**
* Augments `CopyConstructor` to be a poolable class, augmenting only the class
* itself (statically) not adding any prototypical fields. Any CopyConstructor
* you give this may have a `poolSize` property, and will look for a
* prototypical `destructor` on instances.
*
* @param {Function} CopyConstructor Constructor that can be used to reset.
* @param {Function} pooler Customizable pooler.
*/
var addPoolingTo = function<T>(
CopyConstructor: Class<T>,
pooler: Pooler,
): Class<T> & {
getPooled(
...args: $ReadOnlyArray<mixed>
): /* arguments of the constructor */ T,
release(instance: mixed): void,
} {
// Casting as any so that flow ignores the actual implementation and trusts
// it to match the type we declared
var NewKlass = (CopyConstructor: any);
NewKlass.instancePool = [];
NewKlass.getPooled = pooler || DEFAULT_POOLER;
if (!NewKlass.poolSize) {
NewKlass.poolSize = DEFAULT_POOL_SIZE;
}
NewKlass.release = standardReleaser;
return NewKlass;
};
var PooledClass = {
addPoolingTo: addPoolingTo,
oneArgumentPooler: (oneArgumentPooler: Pooler),
twoArgumentPooler: (twoArgumentPooler: Pooler),
threeArgumentPooler: (threeArgumentPooler: Pooler),
fourArgumentPooler: (fourArgumentPooler: Pooler),
};
module.exports = PooledClass;

117
src/renderers/native/__tests__/PooledClass-test.js
View File

@@ -1,117 +0,0 @@
/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @emails react-core
*/
'use strict';
var PooledClass;
var PoolableClass;
describe('Pooled class', () => {
beforeEach(() => {
PooledClass = require('PooledClass');
PoolableClass = function() {};
PoolableClass.prototype.destructor = function() {};
PooledClass.addPoolingTo(PoolableClass);
});
it('should initialize a pool correctly', () => {
expect(PoolableClass.instancePool).toBeDefined();
});
it('should return a new instance when the pool is empty', () => {
var instance = PoolableClass.getPooled();
expect(instance instanceof PoolableClass).toBe(true);
});
it('should return the instance back into the pool when it gets released', () => {
var instance = PoolableClass.getPooled();
PoolableClass.release(instance);
expect(PoolableClass.instancePool.length).toBe(1);
expect(PoolableClass.instancePool[0]).toBe(instance);
});
it('should return an old instance if available in the pool', () => {
var instance = PoolableClass.getPooled();
PoolableClass.release(instance);
var instance2 = PoolableClass.getPooled();
expect(instance).toBe(instance2);
});
it('should call the destructor when instance gets released', () => {
var log = [];
var PoolableClassWithDestructor = function() {};
PoolableClassWithDestructor.prototype.destructor = function() {
log.push('released');
};
PooledClass.addPoolingTo(PoolableClassWithDestructor);
var instance = PoolableClassWithDestructor.getPooled();
PoolableClassWithDestructor.release(instance);
expect(log).toEqual(['released']);
});
it('should accept poolers with different arguments', () => {
var log = [];
var PoolableClassWithMultiArguments = function(a, b) {
log.push(a, b);
};
PoolableClassWithMultiArguments.prototype.destructor = function() {};
PooledClass.addPoolingTo(
PoolableClassWithMultiArguments,
PooledClass.twoArgumentPooler,
);
PoolableClassWithMultiArguments.getPooled('a', 'b', 'c');
expect(log).toEqual(['a', 'b']);
});
it('should call a new constructor with arguments', () => {
var log = [];
var PoolableClassWithOneArgument = function(a) {
log.push(a);
};
PoolableClassWithOneArgument.prototype.destructor = function() {};
PooledClass.addPoolingTo(PoolableClassWithOneArgument);
PoolableClassWithOneArgument.getPooled('new');
expect(log).toEqual(['new']);
});
it('should call an old constructor with arguments', () => {
var log = [];
var PoolableClassWithOneArgument = function(a) {
log.push(a);
};
PoolableClassWithOneArgument.prototype.destructor = function() {};
PooledClass.addPoolingTo(PoolableClassWithOneArgument);
var instance = PoolableClassWithOneArgument.getPooled('new');
PoolableClassWithOneArgument.release(instance);
PoolableClassWithOneArgument.getPooled('old');
expect(log).toEqual(['new', 'old']);
});
it('should throw when the class releases an instance of a different type', () => {
var RandomClass = function() {};
RandomClass.prototype.destructor = function() {};
PooledClass.addPoolingTo(RandomClass);
var randomInstance = RandomClass.getPooled();
PoolableClass.getPooled();
expect(function() {
PoolableClass.release(randomInstance);
}).toThrowError(
'Trying to release an instance into a pool of a different type.',
);
});
it('should throw if no destructor is defined', () => {
var ImmortalClass = function() {};
PooledClass.addPoolingTo(ImmortalClass);
var inst = ImmortalClass.getPooled();
expect(function() {
ImmortalClass.release(inst);
}).toThrow();
});
});