ResizableArray.sol

pragma experimental ABIEncoderV2;

struct ResizableArray {
    uint256[] data;
    uint256 size;
}

library ResizableArrayLibrary {
    function length(ResizableArray memory a) internal pure returns(uint256) { return a.size; }
    function capacity(ResizableArray memory a) internal pure returns(uint256) { return a.data.length; }
    function resize(ResizableArray memory a, uint256 len) internal pure
    {
        if (a.data.length >= len)
            a.size = len;
        else
        {
            uint256[] memory oldData = a.data;
            a.data = new uint256[](len);
            for (uint256 i = 0; i < a.data.length; ++i)
                a.data[i] = oldData[i];
        }
    }
    function at(ResizableArray memory a, uint256 offset) internal pure returns(uint256)
    {
        require(offset < a.size);
        return a.data[offset];
    }
    function push(ResizableArray memory a, uint256 value) internal pure
    {
        if (a.size >= a.data.length)
        {
            uint256 newCapacity = (a.size + 1) * 2;
            uint256[] memory oldData = a.data;
            a.data = new uint256[](newCapacity);
            for (uint256 i = 0; i < oldData.length; ++i)
                a.data[i] = oldData[i];
        }
        a.data[a.size++] = value;
    }
    function allocate(uint256 capa) internal pure returns (ResizableArray memory) {
        return ResizableArray(new uint256[](capa), 0);
    }
}

contract Test
{
    using ResizableArrayLibrary for ResizableArray;

    function f() public pure returns (uint256 length, uint256[] memory y) {
        ResizableArray memory x = ResizableArrayLibrary.allocate(2);
        x.push(1);
        x.push(2);
        x.push(3);
        return (x.size, x.data);
    }
}