home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / software / pelne / optionp / iis4_07.cab / VariantToJava.java < prev    next >
Text File  |  1997-10-25  |  8KB  |  254 lines
  1. /*  ********************************************************************************
  2.     VariantToJava.java *************************************************************
  3.     ********************************************************************************  */
  4.  
  5. package aspcomp;
  6.  
  7. import com.ms.com.*;
  8. import java.util.*;
  9. import com.ms.asp.*;
  10.  
  11. /**
  12.  * Conversion routines.
  13.  */
  14.  
  15. public class VariantToJava 
  16. {
  17.  
  18. /*  ********************************************************************************
  19.     Internal (Private) Variables ***************************************************
  20.     ********************************************************************************  */
  21.  
  22.     // Half a second, expressed in days
  23.     private static double HALF_SECOND = (1.0/172800.0);
  24.     private static int rgMonthDays[] =
  25.         {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
  26.  
  27.  
  28. /*  ********************************************************************************
  29.     External (Public) Methods ******************************************************
  30.     ********************************************************************************  */
  31.  
  32.     public static boolean getBoolean(Variant v)        
  33.         throws ClassCastException 
  34.     {
  35.         return v.getBoolean();
  36.     }
  37.  
  38.     public static byte getByte(Variant v)            
  39.         throws ClassCastException 
  40.     {
  41.         return v.getByte();
  42.     }
  43.  
  44.     public static short getShort(Variant v)            
  45.         throws ClassCastException 
  46.     {
  47.         return v.getShort();
  48.     }
  49.  
  50.     public static char getChar(Variant v)            
  51.         throws ClassCastException 
  52.     {
  53.         return (char)v.getShort();
  54.     }
  55.  
  56.     public static int getInt(Variant v)                
  57.         throws ClassCastException 
  58.     {
  59.         return v.getInt();
  60.     }
  61.  
  62.     public static long getLong(Variant v)            
  63.         throws ClassCastException 
  64.     {
  65.         return (long)v.getInt();
  66.     }
  67.  
  68.     public static float getFloat(Variant v)            
  69.         throws ClassCastException 
  70.     {
  71.         return v.getFloat();
  72.     }
  73.  
  74.     public static double getDouble(Variant v)        
  75.         throws ClassCastException 
  76.     {
  77.         return v.getDouble();
  78.     }
  79.  
  80.     public static String getString(Variant v)        
  81.         throws ClassCastException 
  82.     {
  83.         if (v.getvt() != v.VariantString) 
  84.         {
  85.             if (v.getvt() == v.VariantDispatch) 
  86.             {
  87.                 IStringList slist = (IStringList)v.getDispatch();
  88.                 Variant p = new Variant();
  89.                 p.noParam();
  90.                 v = slist.getItem(p);
  91.                 if (v.getvt() == v.VariantString)
  92.                     return v.getString();
  93.             }
  94.             throw new ClassCastException();
  95.         }
  96.         return v.getString();
  97.     }
  98.  
  99.     public static Object getObject(Variant v)        
  100.         throws ClassCastException 
  101.     {
  102.         switch(v.getvt()) 
  103.         {
  104.         case Variant.VariantString:
  105.             String s = v.getString();
  106.             return s;
  107.         case Variant.VariantObject:
  108.             return v.getObject();
  109.         default:
  110.             break;
  111.         }
  112.         throw new ClassCastException();
  113.     }
  114.  
  115.     public static Date getDate(Variant v)            
  116.         throws ClassCastException 
  117.     {
  118.         // source code copied from MFC 4.21 and modified
  119.  
  120.         long nDays;                    // Number of days since Dec. 30, 1899
  121.         long nDaysAbsolute;            // Number of days since 1/1/0
  122.         long nSecsInDay;            // Time in seconds since midnight
  123.         long nMinutesInDay;            // Minutes in day
  124.  
  125.         long n400Years;                // Number of 400 year increments since 1/1/0
  126.         long n400Century;            // Century within 400 year block (0,1,2 or 3)
  127.         long n4Years;                // Number of 4 year increments since 1/1/0
  128.         long n4Day;                    // Day within 4 year block
  129.                                     //  (0 is 1/1/yr1, 1460 is 12/31/yr4)
  130.         long n4Yr;                    // Year within 4 year block (0,1,2 or 3)
  131.         boolean bLeap4 = true;        // TRUE if 4 year block includes leap year
  132.  
  133.         // values in terms of year month date.
  134.         int tm_sec;   
  135.         int tm_min;   
  136.         int tm_hour;  
  137.         int tm_mday;  
  138.         int tm_mon;   
  139.         int tm_year;  
  140.         int tm_wday;  
  141.         int tm_yday;  
  142.  
  143.         if (v.getvt() != v.VariantDate)
  144.             throw new ClassCastException();
  145.  
  146.         double dtSrc = v.getDate();
  147.         double dblDate = dtSrc; // temporary serial date
  148.  
  149.         // If a valid date, then this conversion should not overflow
  150.         nDays = (long)dblDate;
  151.  
  152.         // Round to the second
  153.         dblDate += ((dtSrc > 0.0) ? HALF_SECOND : -HALF_SECOND);
  154.  
  155.         // Add days from 1/1/0 to 12/30/1899
  156.         nDaysAbsolute = (long)dblDate + 693959L; 
  157.  
  158.         dblDate = Math.abs(dblDate);
  159.         nSecsInDay = (long)((dblDate - Math.floor(dblDate)) * 86400.);
  160.  
  161.         // Leap years every 4 yrs except centuries not multiples of 400.
  162.         n400Years = (long)(nDaysAbsolute / 146097L);
  163.  
  164.         // Set nDaysAbsolute to day within 400-year block
  165.         nDaysAbsolute %= 146097L;
  166.  
  167.         // -1 because first century has extra day
  168.         n400Century = (long)((nDaysAbsolute - 1) / 36524L);
  169.  
  170.         // Non-leap century
  171.         if (n400Century != 0)
  172.         {
  173.             // Set nDaysAbsolute to day within century
  174.             nDaysAbsolute = (nDaysAbsolute - 1) % 36524L;
  175.  
  176.             // +1 because 1st 4 year increment has 1460 days
  177.             n4Years = (long)((nDaysAbsolute + 1) / 1461L);
  178.  
  179.             if (n4Years != 0)
  180.                 n4Day = (long)((nDaysAbsolute + 1) % 1461L);
  181.             else
  182.             {
  183.                 bLeap4 = false;
  184.                 n4Day = (long)nDaysAbsolute;
  185.             }
  186.         }
  187.         else
  188.         {
  189.             // Leap century - not special case!
  190.             n4Years = (long)(nDaysAbsolute / 1461L);
  191.             n4Day = (long)(nDaysAbsolute % 1461L);
  192.         }
  193.  
  194.         if (bLeap4)
  195.         {
  196.             // -1 because first year has 366 days
  197.             n4Yr = (n4Day - 1) / 365;
  198.  
  199.             if (n4Yr != 0)
  200.                 n4Day = (n4Day - 1) % 365;
  201.         }
  202.         else
  203.         {
  204.             n4Yr = n4Day / 365;
  205.             n4Day %= 365;
  206.         }
  207.  
  208.         tm_year = (int)(n400Years * 400 + n400Century * 100 + 
  209.                         n4Years * 4 + n4Yr);
  210.  
  211.         // Handle leap year: before, on, and after Feb. 29.
  212.         if (n4Yr == 0 && bLeap4 && n4Day == 59)
  213.         {
  214.             /* Feb. 29 */ 
  215.             tm_mon = 2;
  216.             tm_mday = 29;
  217.         }
  218.         else 
  219.         {
  220.             if (n4Yr == 0 && bLeap4 && n4Day >= 59)
  221.                 --n4Day;
  222.  
  223.             // Make n4DaY a 1-based day of non-leap year and compute
  224.             //  month/day for everything but Feb. 29.
  225.             ++n4Day;
  226.  
  227.             // Month number always >= n/32, so save some loop time */ 
  228.             for (tm_mon = (int)((n4Day >> 5) + 1);
  229.                  n4Day > rgMonthDays[tm_mon]; tm_mon++);
  230.  
  231.             tm_mday = (int)(n4Day - rgMonthDays[tm_mon-1]);
  232.         }
  233.  
  234.         if (nSecsInDay == 0)
  235.             tm_hour = tm_min = tm_sec = 0;
  236.         else
  237.         {
  238.             tm_sec = (int)(nSecsInDay % 60L);
  239.             nMinutesInDay = nSecsInDay / 60L;
  240.             tm_min = (int)(nMinutesInDay % 60);
  241.             tm_hour = (int)(nMinutesInDay / 60);
  242.         }
  243.  
  244.         String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);
  245.         if (ids.length == 0) throw new AspComponentException(AspLocalizedStrings.ASP_E_INTERNAL_FAILURE);
  246.         SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);
  247.         pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
  248.         pdt.setEndRule  (Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
  249.         GregorianCalendar calendar = new GregorianCalendar(pdt);
  250.         calendar.set(tm_year, tm_mon - 1, tm_mday, tm_hour, tm_min, tm_sec);
  251.         return calendar.getTime();
  252.     }
  253. }
  254.