public void Fetch(Roar.Callback< IDictionary<string,Foo> > callback)
 {
     Hashtable data = new Hashtable();
     data.Add("board_id", boardId);
     data.Add("page", page.ToString());
     dataStore.ranking.Fetch(callback, data);
 }

 static void onShopFetch( Roar.CallbackInfo< IDictionary<string, Roar.DomainObjects.ShopEntry> > info )
 {
     Debug.Log( "onShopFetch Called" );
     Debug.Log(info);
     Debug.Log(info.code);
     Debug.Log(info.msg);
     Debug.Log(info.data);
 }

 static void onShopFetch( Roar.CallbackInfo info )
 {
     Debug.Log( "onShopFetch Called" );
     Debug.Log(info);
     Debug.Log(info.code);
     Debug.Log(info.msg);
     Debug.Log(info.d);
 }

 static void LoadChangedLeaderboard(Roar.WebObjects.Leaderboards.ViewResponse response)
 {
     foreach(LeaderboardEntry e in response.leaderboard_data.entries)
     {
         if(!playerIDleaderboardDict.ContainsKey(e.player_id))
         {
             playerIDleaderboardDict.Add(e.player_id, e.properties);
         }
     }
 }

 static void onLogin( Roar.CallbackInfo info )
 {
     Debug.Log( "onLogin Called" );
     Debug.Log(info);
     Debug.Log(info.code);
     Debug.Log(info.msg);
     Debug.Log(info.d);
     IRoar roar = DefaultRoar.Instance;
     roar.Shop.Fetch( onShopFetch );
 }

 static void onLogin( Roar.CallbackInfo< Roar.WebObjects.User.LoginResponse > info )
 {
     Debug.Log( "onLogin Called" );
     Debug.Log(info);
     Debug.Log(info.code);
     Debug.Log(info.msg);
     Debug.Log(info.data);
     IRoar roar = DefaultRoar.Instance;
     roar.Shop.Fetch( onShopFetch );
 }

        /**
        * Fetches details about `items` array and adds to item Cache Model
        */
        public bool AddToCache(ArrayList items, Roar.Callback cb=null)
        {
            ArrayList batch = ItemsNotInCache (items);

            // Make the call if there are new items to fetch,
            // passing the `batch` list and persisting the Model data (adding)
            // Returns `true` if items are to be added, `false` if nothing to add
            if (batch.Count > 0) {
                var keysAsJSON = Roar.Json.ArrayToJSON (batch) as string;
                Hashtable args = new Hashtable ();
                args ["item_ikeys"] = keysAsJSON;
                Fetch (cb, args, true);
                return true;
            } else
                return false;
        }

 public void _set( Roar.WebObjects.User.SetArguments args, ZWebAPI.Callback<Roar.WebObjects.User.SetResponse> cb)
 {
     api.MakeCall ("user/set", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.User.SetResponse>(cb, set_response_parser), true);
 }

 public void view( Roar.WebObjects.User.ViewArguments args, ZWebAPI.Callback<Roar.WebObjects.User.ViewResponse> cb)
 {
     api.MakeCall ("user/view", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.User.ViewResponse>(cb, view_response_parser), true);
 }

 public Hashtable GetAchievement(string ikey, Roar.Callback callback)
 {
     if (callback != null)
         callback (new Roar.CallbackInfo<object> (dataStore.achievements.Get (ikey)));
     return dataStore.achievements.Get (ikey);
 }

 void OnRoarPropertiesFetched(Roar.CallbackInfo< IDictionary<string,Roar.DomainObjects.PlayerAttribute> > info)
 {
     networkActionInProgress = false;
     if (OnFullyLoggedIn != null) OnFullyLoggedIn();
 }

 void OnRoarFetchTasksComplete( Roar.CallbackInfo< IDictionary<string,Roar.DomainObjects.Task> > data )
 {
     isFetching = false;
 }

 public void push( Roar.WebObjects.Urbanairship.PushArguments args, ZWebAPI.Callback<Roar.WebObjects.Urbanairship.PushResponse> cb)
 {
     api.MakeCall ("urbanairship/push", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.Urbanairship.PushResponse>(cb, push_response_parser), true);
 }

 public void ios_register( Roar.WebObjects.Urbanairship.IosRegisterArguments args, ZWebAPI.Callback<Roar.WebObjects.Urbanairship.IosRegisterResponse> cb)
 {
     api.MakeCall ("urbanairship/ios_register", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.Urbanairship.IosRegisterResponse>(cb, ios_register_response_parser), true);
 }

 public void start( Roar.WebObjects.Tasks.StartArguments args, ZWebAPI.Callback<Roar.WebObjects.Tasks.StartResponse> cb)
 {
     api.MakeCall ("tasks/start", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.Tasks.StartResponse>(cb, start_response_parser), true);
 }

 public void list( Roar.WebObjects.Shop.ListArguments args, ZWebAPI.Callback<Roar.WebObjects.Shop.ListResponse> cb)
 {
     api.MakeCall ("shop/list", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.Shop.ListResponse>(cb, list_response_parser), true);
 }

 public void buy( Roar.WebObjects.Shop.BuyArguments args, ZWebAPI.Callback<Roar.WebObjects.Shop.BuyResponse> cb)
 {
     api.MakeCall ("shop/buy", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.Shop.BuyResponse>(cb, buy_response_parser), true);
 }

 public MockRequestSender(Roar.IConfig config, IUnityObject unity_object, Roar.ILogger logger)
     : base(config, unity_object, logger)
 {
     responses = new Hashtable();
 }

 public void achievements( Roar.WebObjects.User.AchievementsArguments args, ZWebAPI.Callback<Roar.WebObjects.User.AchievementsResponse> cb)
 {
     api.MakeCall ("user/achievements", args.ToHashtable(), new CallbackBridge<Roar.WebObjects.User.AchievementsResponse>(cb, achievements_response_parser), true);
 }

 void OnRoarFetchRankingsComplete(Roar.CallbackInfo info)
 {
     activeLeaderboard.whenLastFetched = Time.realtimeSinceStartup;
     isFetching = false;
     activeLeaderboard.rankingRaw = activeLeaderboard.ranking.List();
     foreach (Hashtable data in activeLeaderboard.rankingRaw)
     {
         foreach (DictionaryEntry datum in data)
         {
             //Debug.Log(string.Format("{0} => {1}", entry.Key, entry.Value));
             if ((string)datum.Key == "entries")
             {
                 ArrayList entries = (ArrayList)datum.Value;
                 activeLeaderboard.ranks = new List<Rank>(entries.Count);
                 Rank rank;
                 foreach (Hashtable entry in entries)
                 {
                     rank = new Rank();
                     foreach (DictionaryEntry kv in entry)
                     {
                         //Debug.Log(string.Format("{0} => {1}", kv.Key, kv.Value));
                         string k = kv.Key as string;
                         if (k == "rank")
                         {
                             rank.rank = System.Convert.ToInt32(kv.Value);
                         }
                         else if (k == "player_id")
                         {
                             rank.playerId = kv.Value as string;
                         }
                         else if (k == "player_name")
                         {
                             rank.playerName = kv.Value as string;
                         }
                         else if (k == "value")
                         {
                             rank.value = kv.Value as string;
                         }
                     }
                     activeLeaderboard.ranks.Add(rank);
                 }
             }
             else if ((string)datum.Key == "properties")
             {
                 Hashtable properties = (Hashtable)datum.Value;
                 if (properties.ContainsKey("page"))
                     activeLeaderboard.page = System.Convert.ToInt32(properties["page"]);
                 if (properties.ContainsKey("num_results"))
                     activeLeaderboard.numResults = System.Convert.ToInt32(properties["num_results"]);
                 if (properties.ContainsKey("offset"))
                     activeLeaderboard.offset = System.Convert.ToInt32(properties["offset"]);
                 if (properties.ContainsKey("low_is_high"))
                     activeLeaderboard.lowIsHigh = System.Convert.ToBoolean(properties["low_is_high"]);
             }
         }
     }
 }