Total Supply reading in as zero for deployed Ether Token contract - ethernet

Question

I tried editing this contract I made dozens of time with Ethereum's solidity platform and it keeps reading in the total supply as zero. Infact here are the variables it reads in:
name Sample Token string
totalSupply 0 uint256
decimals 3 uint8
_totalSupply 10000000 uint256
RATE 350 uint256
symbol SAMP string
I did constant returns total supply, and I know there is an error but can't figure out where. I need help fixing this issue so the total supply reads in the actual amount, and have tried 15 times both on the regular and test network.
Code:
pragma solidity ^0.4.11;
interface IERC20 {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve (address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed_to, uint256 _value);
event Approval(address indexed_owner, address indexed_spender, uint256 _value);
}
contract SampleToken is IERC20 {
using SafeMath for uint256;
uint public _totalSupply = 10000000;
string public constant symbol ="SAMP";
string public constant name = "Sample Token";
uint8 public constant decimals = 3;
//1 ether = 350 SAMP
uint256 public constant RATE = 350;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function () payable {
createTokens();
}
function SampleToken () {
owner = msg.sender;
}
function createTokens() payable {
require(msg.value > 0);
uint256 tokens = msg.value.mul(RATE);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = _totalSupply.add(tokens);
owner.transfer(msg.value);
}
function totalSupply() constant returns (uint256 _totalSupply) {
return _totalSupply;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) returns (bool success) {
require(
balances[msg.sender] >= _value
&& _value > 0
);
balances[msg.sender] -= balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require(
allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& _value > 0
);
balances[_from] = balances[_from].sub( _value);
balances[_to] = balances [_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve (address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] =_value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
event Transfer(address indexed _from, address indexed_to, uint256 _value);
event Approval(address indexed_owner, address indexed_spender, uint256 _value);
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function bytes32ToString(bytes32 x) constant returns (string) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}

Answer 1

You've got a scoping issue in totalSupply.
function totalSupply() constant returns (uint256 _totalSupply) {
return _totalSupply;
}
Basically, in your returns you've defined _totalSupply as a local variable which is going to take precedence over the instance version of _totalSupply and the local value is never set so it will always return 0
You could change this to
function totalSupply() constant returns (uint256) {
return _totalSupply;
}
or
function totalSupply() constant returns (uint256 _totalSupply) {
_totalSupply = __totalSupply;
}
and change
uint public _totalSupply = 10000000;
to
uint private __totalSupply = 10000000;
This is important to do anyway as if you set your total supply to public anyone can change its value.