contract LimitedTransferToken is ERC20 {

    /**
     * @dev Checks whether it can transfer or otherwise throws.
     */
    modifier canTransfer(address _sender, uint _value) {
        if (_value > transferableTokens(_sender, now, block.number)) revert();
        _;
    }

    /**
     * @dev Checks modifier and allows transfer if tokens are not locked.
     * @param _to The address that will recieve the tokens.
     * @param _value The amount of tokens to be transferred.
     */
    function transfer(address _to, uint _value) public canTransfer(msg.sender, _value) returns (bool) {
        return super.transfer(_to, _value);
    }

    /**
    * @dev Checks modifier and allows transfer if tokens are not locked.
    * @param _from The address that will send the tokens.
    * @param _to The address that will recieve the tokens.
    * @param _value The amount of tokens to be transferred.
    */
    function transferFrom(address _from, address _to, uint _value) public canTransfer(_from, _value) returns (bool) {
        return super.transferFrom(_from, _to, _value);
    }

    /**
     * @dev Default transferable tokens function returns all tokens for a holder (no limit).
     * @dev Overwriting transferableTokens(address holder, uint time, uint number) is the way to provide the 
     * specific logic for limiting token transferability for a holder over time or number.
     */
    function transferableTokens(address holder, uint /* time */, uint /* number */) view public returns (uint256) {
        return balanceOf(holder);
    }
}
/**
 * @title LimitedTransferToken
 * @dev LimitedTransferToken defines the generic interface and the implementation to limit token 
 * transferability for different events. It is intended to be used as a base class for other token 
 * contracts. 
 * LimitedTransferToken has been designed to allow for different limiting factors,
 * this can be achieved by recursively calling super.transferableTokens() until the base class is 
 * hit. For example:
 *         function transferableTokens(address holder, uint time, uint number) constant public returns (uint256) {
 *             return min256(unlockedTokens, super.transferableTokens(holder, time, number));
 *         }
 * A working example is VestedToken.sol:
 * https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/VestedToken.sol
 */
function transferableTokens(address holder, uint /* time */, uint /* number */) view public returns (uint256) {
    return balanceOf(holder);
}

/**
 * @dev Default transferable tokens function returns all tokens for a holder (no limit).
 * @dev Overwriting transferableTokens(address holder, uint time, uint number) is the way to provide the 
 * specific logic for limiting token transferability for a holder over time or number.
 */