rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/RhoRubyLib/common/RhoParams.cs

@@ -0,0 +1,66 @@
+using System;
+using IronRuby.Builtins;
+using System.Collections.Generic;
+
+
+namespace rho.common
+{
+    public class RhoParams
+    {
+        protected Object m_pParams;
+
+        public RhoParams(Object p)
+        {
+            m_pParams = p;
+        }
+
+        public RhoParams(RhoParams copy)
+        {
+            m_pParams = copy.m_pParams;
+        }
+
+        protected Object findHashParam(String name)
+        {
+    	    if ( !(m_pParams is Hash) ) 
+    		    return null;
+            
+            Object val = null;
+            Hash values = (Hash)m_pParams;
+            values.TryGetValue((object)MutableString.Create(name), out val);
+            return (val != null) ? val : null;
+         }
+
+        public String getString(String szName)
+        {
+            return getString(szName, "");
+        }
+
+        public String getString(String szName, String szDefValue)
+        {
+            Object value = findHashParam(szName);
+            String strRes = value != null ? value.ToString() : "";
+            if (strRes.length() == 0 && szDefValue != null && szDefValue.length() > 0)
+                strRes = szDefValue;
+
+            return strRes;
+        }
+
+        public Hashtable<String, String> getHash(String szName)
+        {
+    	    Object value = findHashParam(szName);
+            if ( value == null || !(value is Hash))
+                return new Hashtable<String, String>();
+
+            return CRhoRuby.enum_strhash(value); 
+        }
+
+        public boolean getBool(String name)
+        {
+            String strValue = getString(name);
+            if (strValue.length() == 0)
+                return false;
+
+            return strValue.compareTo("1") == 0 || strValue.compareTo("true") == 0;
+        }
+    }
+}

data/platform/wp7/RhoRubyLib/common/RhoProfiler.cs

@@ -0,0 +1,145 @@
+using System;
+
+namespace rho.common
+{
+    public class RhoProfiler
+    {
+        public static boolean RHO_STRIP_PROFILER = true;
+	
+	    public static String FILE_READ = "FileRead";
+	    public static String FILE_WRITE = "FileWrite";
+	    public static String FILE_SYNC = "FileSync";
+	    public static String FILE_SET_SIZE = "FileSetSize";
+	    public static String FILE_DELETE = "FileDelete";
+	    public static String FILE_RENAME = "FileRename";
+	
+	    private static RhoLogger LOG = new RhoLogger("PROFILER");
+	
+        class CCounter
+        {
+            long  m_startTime;
+            boolean m_bWasStarted;
+        
+            public CCounter(boolean bStart){
+        	    m_bWasStarted = false;
+                if ( bStart )
+                    start();     
+            }
+
+            public virtual boolean isGlobal() { return false; }
+
+            long getCurTime(){
+        	    return DateTime.Now.ToFileTime();
+            }
+            public void start(){ 
+        	    m_startTime = getCurTime(); 
+        	    m_bWasStarted = true; 
+            }
+        
+            public virtual long stop(){
+                if ( m_startTime == 0 )
+                    return m_startTime;
+
+                long res = getCurTime()-m_startTime;
+                m_startTime = 0;
+                return res;
+            }
+            public virtual long flush() { return stop(); }
+
+            public boolean isWasStarted(){ return m_bWasStarted;}
+        };
+
+        class CGlobalCounter : CCounter
+        {
+    	    long m_sumGlobal;
+
+            public CGlobalCounter() : base(false)  { }
+            public override boolean isGlobal() { return true; }
+
+            public override long stop(){
+                m_sumGlobal += base.stop();
+
+                return m_sumGlobal;
+            }
+            public override long flush()
+            { 
+        	    long res = stop(); 
+                m_sumGlobal = 0;
+                return res;
+            }
+
+        };
+
+        private static Hashtable<String, CCounter> m_mapCounters = new Hashtable<String, CCounter>();
+    
+	    public virtual void START(String szCounterName){
+	        CCounter pCounter = (CCounter)m_mapCounters.get(szCounterName);
+	        if ( pCounter==null || !pCounter.isWasStarted() )
+	            LOG.INFO( szCounterName + " : START" );
+
+	        if ( pCounter == null)
+	            m_mapCounters.put( szCounterName, new CCounter(true) ); 
+	        else
+	            pCounter.start();
+	    }
+	
+	    private String intervalToString(long nInterval){
+            long nMin = nInterval/(60*1000);
+            long nSec = (nInterval - nMin*(60*1000))/1000;
+            long mSec = nInterval - nSec*1000 - nMin*(60*1000);
+
+            String strTime = nMin + ":" +
+        	    nSec + ":" +
+        	    mSec;
+        
+		    return strTime;
+	    }
+	
+	    private void stopCounter(String szCounterName, boolean bDestroy){
+	        CCounter pCounter = (CCounter)m_mapCounters.get(szCounterName);
+	        if ( pCounter==null ){
+	            LOG.ERROR( szCounterName + " : Cannot find counter." );
+	            return;
+	        }
+
+	        if ( bDestroy || !pCounter.isGlobal() )
+	        {
+	    	    long oInterval = pCounter.stop();
+	            LOG.INFO( szCounterName + " (" + intervalToString(oInterval) + ") : STOP" );
+
+	            m_mapCounters.remove(szCounterName);
+	        }else
+	            pCounter.stop();
+		
+	    }
+
+	    public virtual void STOP(String szCounterName){
+	        stopCounter(szCounterName,false);
+	    }
+	
+	    //Global accumulative counters
+        public virtual void CREATE_COUNTER(String szCounterName)
+        {
+	        m_mapCounters.put(szCounterName, new CGlobalCounter() ); 
+	    }
+
+        public virtual void DESTROY_COUNTER(String szCounterName)
+        {
+	        stopCounter( szCounterName, true );
+	    }
+
+        public virtual void FLUSH_COUNTER(String szCounterName, String msg)
+        {
+	        CCounter pCounter = (CCounter)m_mapCounters.get(szCounterName);
+	        if ( pCounter==null ){
+	            LOG.ERROR( szCounterName + " : Cannot find counter." );
+	            return;
+	        }
+
+	        long oInterval = pCounter.flush();
+	        LOG.INFO( szCounterName + (msg !=null&&msg.length()>0 ? " - " : "" ) + 
+	    	    (msg !=null&&msg.length()>0 ? msg : "" ) +
+	            " (" + intervalToString(oInterval) + ") : STOP" );
+	    }
+    }
+}

data/platform/wp7/RhoRubyLib/common/RhoResourceMap.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Ink;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+
+namespace rho.common
+{
+    public sealed class CRhoResourceMap
+    {
+        private static CRhodesApp RHODESAPP() { return CRhodesApp.Instance; }
+
+        private static void clearMap(String strMap)
+        {
+            string[] files = strMap.Split('\n');
+
+            for (int i = 0; i < files.Length - 1; i++)
+            {
+                String[] values = files[i].Split('|');
+
+                String strFile = RHODESAPP().canonicalizeRhoPath(values[0]);
+                if (CRhoFile.isFileExist(strFile))
+                {
+                    CRhoFile.deleteFile(strFile);
+                }
+            } 
+        }
+
+        private static void copyMap(String strMap)
+        {
+            string[] files = strMap.Split('\n');
+
+            for (int i = 0; i < files.Length - 1; i++)
+            {
+                String[] values = files[i].Split('|');
+
+                String strFile = RHODESAPP().canonicalizeRhoPath(values[0]);
+                CRhoFile.recursiveCreateDir(strFile);
+                CRhoFile.writeDataToFile(strFile, CRhoFile.readResourceFile(strFile));
+            }
+
+            CRhoFile.writeStringToFile(RHODESAPP().canonicalizeRhoPath("RhoBundleMap.txt"), strMap);
+        }
+
+        public static void deployContent() 
+        {
+            String newMap = CRhoFile.readStringFromResourceFile(RHODESAPP().canonicalizeRhoPath("RhoBundleMap.txt"));
+            String curMap = CRhoFile.readStringFromFile(RHODESAPP().canonicalizeRhoPath("RhoBundleMap.txt"));
+
+            if (curMap == "")
+            {
+                copyMap(newMap);
+            }
+            else if (curMap != newMap)
+            {
+                clearMap(curMap);
+                copyMap(newMap);   
+            }
+        }
+
+
+    }
+}

data/platform/wp7/RhoRubyLib/common/RhoStd.cs

@@ -0,0 +1,205 @@
+using System;
+
+namespace rho.common
+{
+    public struct boolean
+    {
+        private bool m_bValue;
+        public boolean(bool b) { m_bValue = b; }
+        public static implicit operator boolean(bool b) { return new boolean(b); }
+        public static implicit operator bool(boolean b) { return b.m_bValue; }
+    };
+
+    public static class ExtensionMethods
+    {
+        public static int length(this String str)
+        {
+            return str.Length;
+        }
+
+        public static String substring(this String str, int start, int end)
+        {
+            return str.Substring(start, end-start);
+        }
+
+        public static String substring(this String str, int start)
+        {
+            return str.Substring(start);
+        }
+
+        public static Char charAt(this String str, int pos)
+        {
+            return str[pos];
+        }
+
+        public static String toUpperCase(this String str)
+        {
+            return str.ToUpper();
+        }
+
+        public static String toLowerCase(this String str)
+        {
+            return str.ToLower();
+        }
+
+        public static int indexOf(this String str, Char ch)
+        {
+            return str.IndexOf(ch);
+        }
+        public static int indexOf(this String str, Char ch, int nStart)
+        {
+            return str.IndexOf(ch, nStart);
+        }
+        public static int indexOf(this String str, String test)
+        {
+            return str.IndexOf(test);
+        }
+        public static int indexOf(this String str, String test, int nStart)
+        {
+            return str.IndexOf(test, nStart);
+        }
+
+        public static int lastIndexOf(this String str, Char ch)
+        {
+            return str.LastIndexOf(ch);
+        }
+
+        public static int compareTo(this String str, String strToCmp)
+        {
+            return str.CompareTo(strToCmp);
+        }
+
+        public static String trim(this String str)
+        {
+            return str.Trim();
+        }
+
+        public static bool startsWith(this String str, String test)
+        {
+            return str.StartsWith(test);
+        }
+
+        public static bool endsWith(this String str, String test)
+        {
+            return str.EndsWith(test);
+        }
+
+        public static bool equalsIgnoreCase(this String str, String test)
+        {
+            return str.ToUpper().CompareTo(test.ToUpper()) == 0;
+        }
+
+        public static bool equals(this String str, String test)
+        {
+            return str.CompareTo(test) == 0;
+        }
+    }
+
+    public class Vector<TValue> : System.Collections.Generic.List<TValue>
+    {
+        public int size()
+        {
+            return base.Count;
+        }
+
+        public TValue elementAt(int pos)
+        {
+            return base[pos];
+        }
+
+        public void addElement(TValue value)
+        {
+            base.Add(value);
+        }
+
+        public void removeAllElements()
+        {
+            base.Clear();
+        }
+
+        public void removeElementAt(int nPos)
+        {
+            base.RemoveAt(nPos);
+        }
+
+        public void insertElementAt(TValue value, int nPos)
+        {
+            base.Insert(nPos, value);
+        }
+    }
+
+    public class Hashtable<TKey, TValue> : System.Collections.Generic.Dictionary<TKey, TValue>
+    {
+        public TValue get(TKey key)
+        {
+            TValue value;
+            if ( !base.TryGetValue( key, out value) )
+                return default(TValue);
+
+            return value;
+        }
+
+        public boolean containsKey(TKey key)
+        {
+            return base.ContainsKey(key);
+        }
+
+        public int size()
+        {
+            return base.Count;
+        }
+
+        public void clear()
+        {
+            base.Clear();
+        }
+
+        public void put(TKey key, TValue value)
+        {
+            base[key] = value;
+        }
+
+        public void remove(TKey key)
+        {
+            base.Remove(key);
+        }
+
+    }
+
+    public class LinkedList<TValue> : Vector<TValue>
+    {
+        public TValue get(int pos)
+        {
+            return base[pos];
+        }
+
+        public void add(TValue value)
+        {
+            base.Add(value);
+        }
+
+        public bool isEmpty()
+        {
+            return base.Count == 0;
+        }
+
+        public TValue removeFirst()
+        {
+            TValue res = base[0];
+            base.RemoveAt(0);
+
+            return res;
+        }
+    }
+
+    public class RhoClassFactory
+    {
+        public static rho.db.IDBStorage createDBStorage() { return new rho.db.CSqliteStorage(); }
+
+        public static rho.net.NetRequest createNetRequest() {  return new rho.net.NetRequest(); }
+
+        public static rho.net.CAsyncHttp createAsyncHttp() { return new rho.net.CAsyncHttp(); }
+
+        public static rho.common.CRhoFile createFile() { return new rho.common.CRhoFile(); }
+    }
+}