Showing the changes to src/core/chuck_vm.cpp (1 of 2 files). Show all
Unified · Split
| @@ -154,6 +154,7 @@ Chuck_VM::Chuck_VM() · 153 unmodified lines | |||
| 154 | 154 | ||
| 155 | // REFACTOR-2017: TODO might want to dynamically grow queue? | 155 | // REFACTOR-2017: TODO might want to dynamically grow queue? |
| 156 | m_global_request_queue.init( 16384 ); | 156 | m_global_request_queue.init( 16384 ); |
| 157 | m_global_request_retry_queue.init( 16384 ); | ||
| 157 | } | 158 | } |
| 158 | 159 | ||
| 159 | 160 | ||
| @@ -1888,6 +1889,8 @@ t_CKBOOL Chuck_VM::broadcast_global_event( std::string name ) · 1728 unmodified lines | |||
| 1888 | Chuck_Global_Request r; | 1889 | Chuck_Global_Request r; |
| 1889 | r.type = signal_global_event_request; | 1890 | r.type = signal_global_event_request; |
| 1890 | r.signalEventRequest = signal_event_message; | 1891 | r.signalEventRequest = signal_event_message; |
| 1892 | // chuck object might not be constructed on time. retry only once | ||
| 1893 | r.retries = 1; | ||
| 1891 | 1894 | ||
| 1892 | m_global_request_queue.put( r ); | 1895 | m_global_request_queue.put( r ); |
| 1893 | 1896 | ||
| @@ -1913,6 +1916,8 @@ t_CKBOOL Chuck_VM::listen_for_global_event( std::string name, · 19 unmodified lines | |||
| 1913 | Chuck_Global_Request r; | 1916 | Chuck_Global_Request r; |
| 1914 | r.type = listen_for_global_event_request; | 1917 | r.type = listen_for_global_event_request; |
| 1915 | r.listenForEventRequest = listen_event_message; | 1918 | r.listenForEventRequest = listen_event_message; |
| 1919 | // chuck object might not be constructed on time. retry only once | ||
| 1920 | r.retries = 1; | ||
| 1916 | 1921 | ||
| 1917 | m_global_request_queue.put( r ); | 1922 | m_global_request_queue.put( r ); |
| 1918 | 1923 | ||
| @@ -2127,6 +2132,8 @@ t_CKBOOL Chuck_VM::set_global_int_array( std::string name, t_CKINT arrayValues[] · 208 unmodified lines | |||
| 2127 | Chuck_Global_Request r; | 2132 | Chuck_Global_Request r; |
| 2128 | r.type = set_global_int_array_request; | 2133 | r.type = set_global_int_array_request; |
| 2129 | r.setIntArrayRequest = message; | 2134 | r.setIntArrayRequest = message; |
| 2135 | // chuck object might not be constructed on time. retry only once | ||
| 2136 | r.retries = 1; | ||
| 2130 | 2137 | ||
| 2131 | m_global_request_queue.put( r ); | 2138 | m_global_request_queue.put( r ); |
| 2132 | 2139 | ||
| @@ -2150,6 +2157,8 @@ t_CKBOOL Chuck_VM::get_global_int_array( std::string name, void (* callback)(t_C · 17 unmodified lines | |||
| 2150 | Chuck_Global_Request r; | 2157 | Chuck_Global_Request r; |
| 2151 | r.type = get_global_int_array_request; | 2158 | r.type = get_global_int_array_request; |
| 2152 | r.getIntArrayRequest = message; | 2159 | r.getIntArrayRequest = message; |
| 2160 | // chuck object might not be constructed on time. retry only once | ||
| 2161 | r.retries = 1; | ||
| 2153 | 2162 | ||
| 2154 | m_global_request_queue.put( r ); | 2163 | m_global_request_queue.put( r ); |
| 2155 | 2164 | ||
| @@ -2174,6 +2183,8 @@ t_CKBOOL Chuck_VM::set_global_int_array_value( std::string name, t_CKUINT index, · 18 unmodified lines | |||
| 2174 | Chuck_Global_Request r; | 2183 | Chuck_Global_Request r; |
| 2175 | r.type = set_global_int_array_value_request; | 2184 | r.type = set_global_int_array_value_request; |
| 2176 | r.setIntArrayValueRequest = message; | 2185 | r.setIntArrayValueRequest = message; |
| 2186 | // chuck object might not be constructed on time. retry only once | ||
| 2187 | r.retries = 1; | ||
| 2177 | 2188 | ||
| 2178 | m_global_request_queue.put( r ); | 2189 | m_global_request_queue.put( r ); |
| 2179 | 2190 | ||
| @@ -2198,6 +2209,8 @@ t_CKBOOL Chuck_VM::get_global_int_array_value( std::string name, t_CKUINT index, · 18 unmodified lines | |||
| 2198 | Chuck_Global_Request r; | 2209 | Chuck_Global_Request r; |
| 2199 | r.type = get_global_int_array_value_request; | 2210 | r.type = get_global_int_array_value_request; |
| 2200 | r.getIntArrayValueRequest = message; | 2211 | r.getIntArrayValueRequest = message; |
| 2212 | // chuck object might not be constructed on time. retry only once | ||
| 2213 | r.retries = 1; | ||
| 2201 | 2214 | ||
| 2202 | m_global_request_queue.put( r ); | 2215 | m_global_request_queue.put( r ); |
| 2203 | 2216 | ||
| @@ -2222,6 +2235,8 @@ t_CKBOOL Chuck_VM::set_global_associative_int_array_value( std::string name, std · 18 unmodified lines | |||
| 2222 | Chuck_Global_Request r; | 2235 | Chuck_Global_Request r; |
| 2223 | r.type = set_global_associative_int_array_value_request; | 2236 | r.type = set_global_associative_int_array_value_request; |
| 2224 | r.setAssociativeIntArrayValueRequest = message; | 2237 | r.setAssociativeIntArrayValueRequest = message; |
| 2238 | // chuck object might not be constructed on time. retry only once | ||
| 2239 | r.retries = 1; | ||
| 2225 | 2240 | ||
| 2226 | m_global_request_queue.put( r ); | 2241 | m_global_request_queue.put( r ); |
| 2227 | 2242 | ||
| @@ -2246,6 +2261,8 @@ t_CKBOOL Chuck_VM::get_global_associative_int_array_value( std::string name, std · 18 unmodified lines | |||
| 2246 | Chuck_Global_Request r; | 2261 | Chuck_Global_Request r; |
| 2247 | r.type = get_global_associative_int_array_value_request; | 2262 | r.type = get_global_associative_int_array_value_request; |
| 2248 | r.getAssociativeIntArrayValueRequest = message; | 2263 | r.getAssociativeIntArrayValueRequest = message; |
| 2264 | // chuck object might not be constructed on time. retry only once | ||
| 2265 | r.retries = 1; | ||
| 2249 | 2266 | ||
| 2250 | m_global_request_queue.put( r ); | 2267 | m_global_request_queue.put( r ); |
| 2251 | 2268 | ||
| @@ -2273,6 +2290,8 @@ t_CKBOOL Chuck_VM::set_global_float_array( std::string name, t_CKFLOAT arrayValu · 21 unmodified lines | |||
| 2273 | Chuck_Global_Request r; | 2290 | Chuck_Global_Request r; |
| 2274 | r.type = set_global_float_array_request; | 2291 | r.type = set_global_float_array_request; |
| 2275 | r.setFloatArrayRequest = message; | 2292 | r.setFloatArrayRequest = message; |
| 2293 | // chuck object might not be constructed on time. retry only once | ||
| 2294 | r.retries = 1; | ||
| 2276 | 2295 | ||
| 2277 | m_global_request_queue.put( r ); | 2296 | m_global_request_queue.put( r ); |
| 2278 | 2297 | ||
| @@ -2296,6 +2315,8 @@ t_CKBOOL Chuck_VM::get_global_float_array( std::string name, void (* callback)(t · 17 unmodified lines | |||
| 2296 | Chuck_Global_Request r; | 2315 | Chuck_Global_Request r; |
| 2297 | r.type = get_global_float_array_request; | 2316 | r.type = get_global_float_array_request; |
| 2298 | r.getFloatArrayRequest = message; | 2317 | r.getFloatArrayRequest = message; |
| 2318 | // chuck object might not be constructed on time. retry only once | ||
| 2319 | r.retries = 1; | ||
| 2299 | 2320 | ||
| 2300 | m_global_request_queue.put( r ); | 2321 | m_global_request_queue.put( r ); |
| 2301 | 2322 | ||
| @@ -2320,6 +2341,8 @@ t_CKBOOL Chuck_VM::set_global_float_array_value( std::string name, t_CKUINT inde · 18 unmodified lines | |||
| 2320 | Chuck_Global_Request r; | 2341 | Chuck_Global_Request r; |
| 2321 | r.type = set_global_float_array_value_request; | 2342 | r.type = set_global_float_array_value_request; |
| 2322 | r.setFloatArrayValueRequest = message; | 2343 | r.setFloatArrayValueRequest = message; |
| 2344 | // chuck object might not be constructed on time. retry only once | ||
| 2345 | r.retries = 1; | ||
| 2323 | 2346 | ||
| 2324 | m_global_request_queue.put( r ); | 2347 | m_global_request_queue.put( r ); |
| 2325 | 2348 | ||
| @@ -2344,6 +2367,8 @@ t_CKBOOL Chuck_VM::get_global_float_array_value( std::string name, t_CKUINT inde · 18 unmodified lines | |||
| 2344 | Chuck_Global_Request r; | 2367 | Chuck_Global_Request r; |
| 2345 | r.type = get_global_float_array_value_request; | 2368 | r.type = get_global_float_array_value_request; |
| 2346 | r.getFloatArrayValueRequest = message; | 2369 | r.getFloatArrayValueRequest = message; |
| 2370 | // chuck object might not be constructed on time. retry only once | ||
| 2371 | r.retries = 1; | ||
| 2347 | 2372 | ||
| 2348 | m_global_request_queue.put( r ); | 2373 | m_global_request_queue.put( r ); |
| 2349 | 2374 | ||
| @@ -2368,6 +2393,8 @@ t_CKBOOL Chuck_VM::set_global_associative_float_array_value( std::string name, s · 18 unmodified lines | |||
| 2368 | Chuck_Global_Request r; | 2393 | Chuck_Global_Request r; |
| 2369 | r.type = set_global_associative_float_array_value_request; | 2394 | r.type = set_global_associative_float_array_value_request; |
| 2370 | r.setAssociativeFloatArrayValueRequest = message; | 2395 | r.setAssociativeFloatArrayValueRequest = message; |
| 2396 | // chuck object might not be constructed on time. retry only once | ||
| 2397 | r.retries = 1; | ||
| 2371 | 2398 | ||
| 2372 | m_global_request_queue.put( r ); | 2399 | m_global_request_queue.put( r ); |
| 2373 | 2400 | ||
| @@ -2392,6 +2419,8 @@ t_CKBOOL Chuck_VM::get_global_associative_float_array_value( std::string name, s · 18 unmodified lines | |||
| 2392 | Chuck_Global_Request r; | 2419 | Chuck_Global_Request r; |
| 2393 | r.type = get_global_associative_float_array_value_request; | 2420 | r.type = get_global_associative_float_array_value_request; |
| 2394 | r.getAssociativeFloatArrayValueRequest = message; | 2421 | r.getAssociativeFloatArrayValueRequest = message; |
| 2422 | // chuck object might not be constructed on time. retry only once | ||
| 2423 | r.retries = 1; | ||
| 2395 | 2424 | ||
| 2396 | m_global_request_queue.put( r ); | 2425 | m_global_request_queue.put( r ); |
| 2397 | 2426 | ||
| @@ -2591,8 +2620,12 @@ void Chuck_VM::cleanup_global_variables() · 193 unmodified lines | |||
| 2591 | //----------------------------------------------------------------------------- | 2620 | //----------------------------------------------------------------------------- |
| 2592 | void Chuck_VM::handle_global_queue_messages() | 2621 | void Chuck_VM::handle_global_queue_messages() |
| 2593 | { | 2622 | { |
| 2623 | bool should_retry_this_request = false; | ||
| 2624 | |||
| 2594 | while( m_global_request_queue.more() ) | 2625 | while( m_global_request_queue.more() ) |
| 2595 | { | 2626 | { |
| 2627 | should_retry_this_request = false; | ||
| 2628 | |||
| 2596 | Chuck_Global_Request message; | 2629 | Chuck_Global_Request message; |
| 2597 | if( m_global_request_queue.get( & message ) ) | 2630 | if( m_global_request_queue.get( & message ) ) |
| 2598 | { | 2631 | { |
| @@ -2689,8 +2722,24 @@ void Chuck_VM::handle_global_queue_messages() · 90 unmodified lines | |||
| 2689 | event->signal_global(); | 2722 | event->signal_global(); |
| 2690 | } | 2723 | } |
| 2691 | } | 2724 | } |
| 2725 | else | ||
| 2726 | { | ||
| 2727 | // name does not exist. possible that object just doesn't exist yet. | ||
| 2728 | if( message.retries > 0 ) | ||
| 2729 | { | ||
| 2730 | should_retry_this_request = true; | ||
| 2731 | } | ||
| 2732 | } | ||
| 2733 | |||
| 2692 | // clean up request storage | 2734 | // clean up request storage |
| 2693 | delete message.signalEventRequest; | 2735 | if( should_retry_this_request ) |
| 2736 | { | ||
| 2737 | m_global_request_retry_queue.put( message ); | ||
| 2738 | } | ||
| 2739 | else | ||
| 2740 | { | ||
| 2741 | delete message.signalEventRequest; | ||
| 2742 | } | ||
| 2694 | break; | 2743 | break; |
| 2695 | 2744 | ||
| 2696 | case listen_for_global_event_request: | 2745 | case listen_for_global_event_request: |
| @@ -2714,9 +2763,24 @@ void Chuck_VM::handle_global_queue_messages() · 17 unmodified lines | |||
| 2714 | message.listenForEventRequest->listen_forever ); | 2763 | message.listenForEventRequest->listen_forever ); |
| 2715 | } | 2764 | } |
| 2716 | } | 2765 | } |
| 2766 | else | ||
| 2767 | { | ||
| 2768 | // name does not exist. possible that object just doesn't exist yet. | ||
| 2769 | if( message.retries > 0 ) | ||
| 2770 | { | ||
| 2771 | should_retry_this_request = true; | ||
| 2772 | } | ||
| 2773 | } | ||
| 2717 | } | 2774 | } |
| 2718 | // clean up request storage | 2775 | // clean up request storage |
| 2719 | delete message.listenForEventRequest; | 2776 | if( should_retry_this_request ) |
| 2777 | { | ||
| 2778 | m_global_request_retry_queue.put( message ); | ||
| 2779 | } | ||
| 2780 | else | ||
| 2781 | { | ||
| 2782 | delete message.listenForEventRequest; | ||
| 2783 | } | ||
| 2720 | break; | 2784 | break; |
| 2721 | case set_global_int_array_request: | 2785 | case set_global_int_array_request: |
| 2722 | { | 2786 | { |
| @@ -2742,10 +2806,25 @@ void Chuck_VM::handle_global_queue_messages() · 19 unmodified lines | |||
| 2742 | } | 2806 | } |
| 2743 | } | 2807 | } |
| 2744 | } | 2808 | } |
| 2809 | else | ||
| 2810 | { | ||
| 2811 | // name does not exist. possible that object just doesn't exist yet. | ||
| 2812 | if( message.retries > 0 ) | ||
| 2813 | { | ||
| 2814 | should_retry_this_request = true; | ||
| 2815 | } | ||
| 2816 | } | ||
| 2745 | } | 2817 | } |
| 2746 | 2818 | ||
| 2747 | // clean up request storage | 2819 | // clean up request storage |
| 2748 | delete message.setIntArrayRequest; | 2820 | if( should_retry_this_request ) |
| 2821 | { | ||
| 2822 | m_global_request_retry_queue.put( message ); | ||
| 2823 | } | ||
| 2824 | else | ||
| 2825 | { | ||
| 2826 | delete message.setIntArrayRequest; | ||
| 2827 | } | ||
| 2749 | break; | 2828 | break; |
| 2750 | case get_global_int_array_request: | 2829 | case get_global_int_array_request: |
| 2751 | { | 2830 | { |
| @@ -2768,10 +2847,25 @@ void Chuck_VM::handle_global_queue_messages() · 16 unmodified lines | |||
| 2768 | ); | 2847 | ); |
| 2769 | } | 2848 | } |
| 2770 | } | 2849 | } |
| 2850 | else | ||
| 2851 | { | ||
| 2852 | // name does not exist. possible that object just doesn't exist yet. | ||
| 2853 | if( message.retries > 0 ) | ||
| 2854 | { | ||
| 2855 | should_retry_this_request = true; | ||
| 2856 | } | ||
| 2857 | } | ||
| 2771 | } | 2858 | } |
| 2772 | 2859 | ||
| 2773 | // clean up request storage | 2860 | // clean up request storage |
| 2774 | delete message.getIntArrayRequest; | 2861 | if( should_retry_this_request ) |
| 2862 | { | ||
| 2863 | m_global_request_retry_queue.put( message ); | ||
| 2864 | } | ||
| 2865 | else | ||
| 2866 | { | ||
| 2867 | delete message.getIntArrayRequest; | ||
| 2868 | } | ||
| 2775 | break; | 2869 | break; |
| 2776 | case set_global_int_array_value_request: | 2870 | case set_global_int_array_value_request: |
| 2777 | { | 2871 | { |
| @@ -2794,10 +2888,25 @@ void Chuck_VM::handle_global_queue_messages() · 16 unmodified lines | |||
| 2794 | } | 2888 | } |
| 2795 | } | 2889 | } |
| 2796 | } | 2890 | } |
| 2891 | else | ||
| 2892 | { | ||
| 2893 | // name does not exist. possible that object just doesn't exist yet. | ||
| 2894 | if( message.retries > 0 ) | ||
| 2895 | { | ||
| 2896 | should_retry_this_request = true; | ||
| 2897 | } | ||
| 2898 | } | ||
| 2797 | } | 2899 | } |
| 2798 | 2900 | ||
| 2799 | // clean up request storage | 2901 | // clean up request storage |
| 2800 | delete message.setIntArrayValueRequest; | 2902 | if( should_retry_this_request ) |
| 2903 | { | ||
| 2904 | m_global_request_retry_queue.put( message ); | ||
| 2905 | } | ||
| 2906 | else | ||
| 2907 | { | ||
| 2908 | delete message.setIntArrayValueRequest; | ||
| 2909 | } | ||
| 2801 | break; | 2910 | break; |
| 2802 | case get_global_int_array_value_request: | 2911 | case get_global_int_array_value_request: |
| 2803 | { | 2912 | { |
| @@ -2820,10 +2929,25 @@ void Chuck_VM::handle_global_queue_messages() · 16 unmodified lines | |||
| 2820 | request->callback( result ); | 2929 | request->callback( result ); |
| 2821 | } | 2930 | } |
| 2822 | } | 2931 | } |
| 2932 | else | ||
| 2933 | { | ||
| 2934 | // name does not exist. possible that object just doesn't exist yet. | ||
| 2935 | if( message.retries > 0 ) | ||
| 2936 | { | ||
| 2937 | should_retry_this_request = true; | ||
| 2938 | } | ||
| 2939 | } | ||
| 2823 | } | 2940 | } |
| 2824 | 2941 | ||
| 2825 | // clean up request storage | 2942 | // clean up request storage |
| 2826 | delete message.getIntArrayValueRequest; | 2943 | if( should_retry_this_request ) |
| 2944 | { | ||
| 2945 | m_global_request_retry_queue.put( message ); | ||
| 2946 | } | ||
| 2947 | else | ||
| 2948 | { | ||
| 2949 | delete message.getIntArrayValueRequest; | ||
| 2950 | } | ||
| 2827 | break; | 2951 | break; |
| 2828 | case set_global_associative_int_array_value_request: | 2952 | case set_global_associative_int_array_value_request: |
| 2829 | { | 2953 | { |
| @@ -2843,10 +2967,25 @@ void Chuck_VM::handle_global_queue_messages() · 13 unmodified lines | |||
| 2843 | intArray->set( request->key, request->value ); | 2967 | intArray->set( request->key, request->value ); |
| 2844 | } | 2968 | } |
| 2845 | } | 2969 | } |
| 2970 | else | ||
| 2971 | { | ||
| 2972 | // name does not exist. possible that object just doesn't exist yet. | ||
| 2973 | if( message.retries > 0 ) | ||
| 2974 | { | ||
| 2975 | should_retry_this_request = true; | ||
| 2976 | } | ||
| 2977 | } | ||
| 2846 | } | 2978 | } |
| 2847 | 2979 | ||
| 2848 | // clean up request storage | 2980 | // clean up request storage |
| 2849 | delete message.setAssociativeIntArrayValueRequest; | 2981 | if( should_retry_this_request ) |
| 2982 | { | ||
| 2983 | m_global_request_retry_queue.put( message ); | ||
| 2984 | } | ||
| 2985 | else | ||
| 2986 | { | ||
| 2987 | delete message.setAssociativeIntArrayValueRequest; | ||
| 2988 | } | ||
| 2850 | break; | 2989 | break; |
| 2851 | case get_global_associative_int_array_value_request: | 2990 | case get_global_associative_int_array_value_request: |
| 2852 | { | 2991 | { |
| @@ -2869,10 +3008,25 @@ void Chuck_VM::handle_global_queue_messages() · 16 unmodified lines | |||
| 2869 | request->callback( result ); | 3008 | request->callback( result ); |
| 2870 | } | 3009 | } |
| 2871 | } | 3010 | } |
| 3011 | else | ||
| 3012 | { | ||
| 3013 | // name does not exist. possible that object just doesn't exist yet. | ||
| 3014 | if( message.retries > 0 ) | ||
| 3015 | { | ||
| 3016 | should_retry_this_request = true; | ||
| 3017 | } | ||
| 3018 | } | ||
| 2872 | } | 3019 | } |
| 2873 | 3020 | ||
| 2874 | // clean up request storage | 3021 | // clean up request storage |
| 2875 | delete message.getAssociativeIntArrayValueRequest; | 3022 | if( should_retry_this_request ) |
| 3023 | { | ||
| 3024 | m_global_request_retry_queue.put( message ); | ||
| 3025 | } | ||
| 3026 | else | ||
| 3027 | { | ||
| 3028 | delete message.getAssociativeIntArrayValueRequest; | ||
| 3029 | } | ||
| 2876 | break; | 3030 | break; |
| 2877 | case set_global_float_array_request: | 3031 | case set_global_float_array_request: |
| 2878 | { | 3032 | { |
| @@ -2898,10 +3052,25 @@ void Chuck_VM::handle_global_queue_messages() · 19 unmodified lines | |||
| 2898 | } | 3052 | } |
| 2899 | } | 3053 | } |
| 2900 | } | 3054 | } |
| 3055 | else | ||
| 3056 | { | ||
| 3057 | // name does not exist. possible that object just doesn't exist yet. | ||
| 3058 | if( message.retries > 0 ) | ||
| 3059 | { | ||
| 3060 | should_retry_this_request = true; | ||
| 3061 | } | ||
| 3062 | } | ||
| 2901 | } | 3063 | } |
| 2902 | 3064 | ||
| 2903 | // clean up request storage | 3065 | // clean up request storage |
| 2904 | delete message.setFloatArrayRequest; | 3066 | if( should_retry_this_request ) |
| 3067 | { | ||
| 3068 | m_global_request_retry_queue.put( message ); | ||
| 3069 | } | ||
| 3070 | else | ||
| 3071 | { | ||
| 3072 | delete message.setFloatArrayRequest; | ||
| 3073 | } | ||
| 2905 | break; | 3074 | break; |
| 2906 | case get_global_float_array_request: | 3075 | case get_global_float_array_request: |
| 2907 | { | 3076 | { |
| @@ -2923,10 +3092,25 @@ void Chuck_VM::handle_global_queue_messages() · 15 unmodified lines | |||
| 2923 | ); | 3092 | ); |
| 2924 | } | 3093 | } |
| 2925 | } | 3094 | } |
| 3095 | else | ||
| 3096 | { | ||
| 3097 | // name does not exist. possible that object just doesn't exist yet. | ||
| 3098 | if( message.retries > 0 ) | ||
| 3099 | { | ||
| 3100 | should_retry_this_request = true; | ||
| 3101 | } | ||
| 3102 | } | ||
| 2926 | } | 3103 | } |
| 2927 | 3104 | ||
| 2928 | // clean up request storage | 3105 | // clean up request storage |
| 2929 | delete message.getFloatArrayRequest; | 3106 | if( should_retry_this_request ) |
| 3107 | { | ||
| 3108 | m_global_request_retry_queue.put( message ); | ||
| 3109 | } | ||
| 3110 | else | ||
| 3111 | { | ||
| 3112 | delete message.getFloatArrayRequest; | ||
| 3113 | } | ||
| 2930 | break; | 3114 | break; |
| 2931 | case set_global_float_array_value_request: | 3115 | case set_global_float_array_value_request: |
| 2932 | { | 3116 | { |
| @@ -2949,10 +3133,25 @@ void Chuck_VM::handle_global_queue_messages() · 16 unmodified lines | |||
| 2949 | } | 3133 | } |
| 2950 | } | 3134 | } |
| 2951 | } | 3135 | } |
| 3136 | else | ||
| 3137 | { | ||
| 3138 | // name does not exist. possible that object just doesn't exist yet. | ||
| 3139 | if( message.retries > 0 ) | ||
| 3140 | { | ||
| 3141 | should_retry_this_request = true; | ||
| 3142 | } | ||
| 3143 | } | ||
| 2952 | } | 3144 | } |
| 2953 | 3145 | ||
| 2954 | // clean up request storage | 3146 | // clean up request storage |
| 2955 | delete message.setFloatArrayValueRequest; | 3147 | if( should_retry_this_request ) |
| 3148 | { | ||
| 3149 | m_global_request_retry_queue.put( message ); | ||
| 3150 | } | ||
| 3151 | else | ||
| 3152 | { | ||
| 3153 | delete message.setFloatArrayValueRequest; | ||
| 3154 | } | ||
| 2956 | break; | 3155 | break; |
| 2957 | case get_global_float_array_value_request: | 3156 | case get_global_float_array_value_request: |
| 2958 | { | 3157 | { |
| @@ -2974,10 +3173,25 @@ void Chuck_VM::handle_global_queue_messages() · 15 unmodified lines | |||
| 2974 | request->callback( result ); | 3173 | request->callback( result ); |
| 2975 | } | 3174 | } |
| 2976 | } | 3175 | } |
| 3176 | else | ||
| 3177 | { | ||
| 3178 | // name does not exist. possible that object just doesn't exist yet. | ||
| 3179 | if( message.retries > 0 ) | ||
| 3180 | { | ||
| 3181 | should_retry_this_request = true; | ||
| 3182 | } | ||
| 3183 | } | ||
| 2977 | } | 3184 | } |
| 2978 | 3185 | ||
| 2979 | // clean up request storage | 3186 | // clean up request storage |
| 2980 | delete message.getFloatArrayValueRequest; | 3187 | if( should_retry_this_request ) |
| 3188 | { | ||
| 3189 | m_global_request_retry_queue.put( message ); | ||
| 3190 | } | ||
| 3191 | else | ||
| 3192 | { | ||
| 3193 | delete message.getFloatArrayValueRequest; | ||
| 3194 | } | ||
| 2981 | break; | 3195 | break; |
| 2982 | case set_global_associative_float_array_value_request: | 3196 | case set_global_associative_float_array_value_request: |
| 2983 | { | 3197 | { |
| @@ -2997,10 +3211,25 @@ void Chuck_VM::handle_global_queue_messages() · 13 unmodified lines | |||
| 2997 | floatArray->set( request->key, request->value ); | 3211 | floatArray->set( request->key, request->value ); |
| 2998 | } | 3212 | } |
| 2999 | } | 3213 | } |
| 3214 | else | ||
| 3215 | { | ||
| 3216 | // name does not exist. possible that object just doesn't exist yet. | ||
| 3217 | if( message.retries > 0 ) | ||
| 3218 | { | ||
| 3219 | should_retry_this_request = true; | ||
| 3220 | } | ||
| 3221 | } | ||
| 3000 | } | 3222 | } |
| 3001 | 3223 | ||
| 3002 | // clean up request storage | 3224 | // clean up request storage |
| 3003 | delete message.setAssociativeFloatArrayValueRequest; | 3225 | if( should_retry_this_request ) |
| 3226 | { | ||
| 3227 | m_global_request_retry_queue.put( message ); | ||
| 3228 | } | ||
| 3229 | else | ||
| 3230 | { | ||
| 3231 | delete message.setAssociativeFloatArrayValueRequest; | ||
| 3232 | } | ||
| 3004 | break; | 3233 | break; |
| 3005 | case get_global_associative_float_array_value_request: | 3234 | case get_global_associative_float_array_value_request: |
| 3006 | { | 3235 | { |
| @@ -3022,10 +3251,25 @@ void Chuck_VM::handle_global_queue_messages() · 15 unmodified lines | |||
| 3022 | request->callback( result ); | 3251 | request->callback( result ); |
| 3023 | } | 3252 | } |
| 3024 | } | 3253 | } |
| 3254 | else | ||
| 3255 | { | ||
| 3256 | // name does not exist. possible that object just doesn't exist yet. | ||
| 3257 | if( message.retries > 0 ) | ||
| 3258 | { | ||
| 3259 | should_retry_this_request = true; | ||
| 3260 | } | ||
| 3261 | } | ||
| 3025 | } | 3262 | } |
| 3026 | 3263 | ||
| 3027 | // clean up request storage | 3264 | // clean up request storage |
| 3028 | delete message.getAssociativeFloatArrayValueRequest; | 3265 | if( should_retry_this_request ) |
| 3266 | { | ||
| 3267 | m_global_request_retry_queue.put( message ); | ||
| 3268 | } | ||
| 3269 | else | ||
| 3270 | { | ||
| 3271 | delete message.getAssociativeFloatArrayValueRequest; | ||
| 3272 | } | ||
| 3029 | break; | 3273 | break; |
| 3030 | } | 3274 | } |
| 3031 | } | 3275 | } |
| @@ -3035,6 +3279,32 @@ void Chuck_VM::handle_global_queue_messages() · 3 unmodified lines | |||
| 3035 | break; | 3279 | break; |
| 3036 | } | 3280 | } |
| 3037 | } | 3281 | } |
| 3282 | |||
| 3283 | // process retries | ||
| 3284 | while( m_global_request_retry_queue.more() ) | ||
| 3285 | { | ||
| 3286 | // get the request | ||
| 3287 | Chuck_Global_Request message; | ||
| 3288 | if( m_global_request_retry_queue.get( &message ) ) | ||
| 3289 | { | ||
| 3290 | // make sure it should be retried | ||
| 3291 | if( message.retries == 0 ) | ||
| 3292 | { | ||
| 3293 | // trying to retry something that shouldn't be. | ||
| 3294 | continue; | ||
| 3295 | } | ||
| 3296 | |||
| 3297 | // decrement the number of retries | ||
| 3298 | message.retries--; | ||
| 3299 | // add it back to the queue for next time | ||
| 3300 | m_global_request_queue.put( message ); | ||
| 3301 | } | ||
| 3302 | else | ||
| 3303 | { | ||
| 3304 | // get failed. problem? | ||
| 3305 | break; | ||
| 3306 | } | ||
| 3307 | } | ||
| 3038 | } | 3308 | } |
| 3039 | 3309 | ||
| 3040 | 3310 | ||