public string AddNewTokenToDatabase(TOKEN token)
        {
            _tokens.InsertOnSubmit(token);

            try
            {
                _dataContext.SubmitChanges();
            }
            catch (Exception ex)
            {
                _log.Error(ex.Message);
                return "Token has not been generated";

            }
            return token.UserToken;
        }

			object ParseByToken(TOKEN token) {
				switch (token) {
				case TOKEN.STRING:
					return ParseString();
				case TOKEN.NUMBER:
					return ParseNumber();
				case TOKEN.CURLY_OPEN:
					return ParseObject();
				case TOKEN.SQUARED_OPEN:
					return ParseArray();
				case TOKEN.TRUE:
					return true;
				case TOKEN.FALSE:
					return false;
				case TOKEN.NULL:
					return null;
				default:
					return null;
				}
			}

 public static extern bool OpenProcessToken(IntPtr ProcessHandle, TOKEN DesiredAccess, out IntPtr TokenHandle);

 public void RemoveTokenFromDatabase(TOKEN tokenToRemove)
 {
     System.Diagnostics.Contracts.Contract.Requires(tokenToRemove != null);
 }

 public string AddNewTokenToDatabase(TOKEN token)
 {
     System.Diagnostics.Contracts.Contract.Requires(token != null);
     return System.Diagnostics.Contracts.Contract.Result<string>();
 }

 private void Expect(TOKEN token)
 {
     if (PeekNextToken() != token) throw new InvalidDataException(token + " expected");
     index++; //move index
 }

            object ParseByToken(TOKEN token)
            {
                switch (token)
                {
                    case TOKEN.STRING:
                    {
                        return ParseString();
                    }
                    case TOKEN.NUMBER:
                    {
                        return ParseNumber();
                    }
                    case TOKEN.CURLY_OPEN:
                    {
                        return ParseObject();
                    }
                    case TOKEN.SQUARED_OPEN:
                    {
                        return ParseArray();
                    }
                    case TOKEN.TRUE:
                    {
                        return true;
                    }
                    case TOKEN.FALSE:
                    {
                        return false;
                    }
                    case TOKEN.NULL:
                    {
                        return null;
                    }
                    case TOKEN.NONE:
                    {
                        TOKEN nextToken =NextToken;
                        return ParseByToken(nextToken);

                    }
                    default:
                    {
                        return null;
                    }
                }
            }

 IEnumerator ParseByTokenAsync(TOKEN token)
 {
     switch (token) {
     case TOKEN.STRING:
         yield return ParseString();
         yield break;
     case TOKEN.NUMBER:
         yield return ParseNumber();
         yield break;
     case TOKEN.CURLY_OPEN: {
         IEnumerator e = ParseObjectAsync();
         while( e.MoveNext() ) {
             yield return null;
         }
          yield return e.Current;
         yield break;
     }
     case TOKEN.SQUARED_OPEN:
         yield return ParseArray();
         yield break;
     case TOKEN.TRUE:
         yield return true;
         yield break;
     case TOKEN.FALSE:
         yield return false;
         yield break;
     case TOKEN.NULL:
         yield break;
     default:
         yield break;
     }
 }

        public void RemoveTokenFromDatabase(TOKEN tokenToRemove)
        {
            _tokens.DeleteOnSubmit(tokenToRemove);

            try
            {
                _dataContext.SubmitChanges();
            }
            catch (Exception ex)
            {
                _log.Error(ex.Message);
            }
        }