qadevOOo/runner/convwatch/PerformanceContainer.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PerformanceContainer.java,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 package convwatch;
  32
  33 import java.io.File;
  34 import java.io.FileWriter;
  35 import java.io.RandomAccessFile;
  36 import java.lang.Double;
  37
  38
  39 public class PerformanceContainer /* extends *//* implements */ {
  40     private long m_nStartTime;
  41
  42     /*
  43       simple helper functions to start/stop a timer, to know how long a process need in milliseconds
  44      */
  45     public long getStartTime()
  46         {
  47             return System.currentTimeMillis();
  48         }
  49     public void setStartTime(long _nStartTime)
  50         {
  51             m_nStartTime = _nStartTime;
  52         }
  53
  54     /*
  55       return the time, which is done until last startTime()
  56      */
  57     private long meanTime(long _nCurrentTimer)
  58         {
  59             if (_nCurrentTimer == 0)
  60             {
  61                 GlobalLogWriter.get().println("Forgotten to initialise a start timer.");
  62                 return 0;
  63             }
  64             long nMeanTime = System.currentTimeMillis();
  65             return nMeanTime - _nCurrentTimer;
  66         }
  67
  68     /*
  69       public long stopTimer()
  70         {
  71             if (m_nStartTime == 0)
  72             {
  73                 System.out.println("Forgotten to initialise start timer.");
  74                 return 0;
  75             }
  76             long nStopTime = System.currentTimeMillis();
  77             return nStopTime - m_nStartTime;
  78         }
  79     */
  80
  81     final static int Load = 0;
  82     final static int Store = 1;
  83     final static int Print = 2;
  84     final static int OfficeStart = 3;
  85     final static int StoreAsPDF = 4;
  86
  87     private long m_nTime[];
  88     private String m_sMSOfficeVersion;
  89
  90     public PerformanceContainer()
  91         {
  92             m_nTime = new long[5];
  93             // @todo: is this need?
  94             for (int i=0;i<5;i++)
  95             {
  96                 m_nTime[i] = 0;
  97             }
  98         }
  99
 100     public void setTime(int _nIndex, long _nValue)
 101         {
 102             m_nTime[_nIndex] = _nValue;
 103         }
 104     public long getTime(int _nIndex)
 105         {
 106             return m_nTime[_nIndex];
 107         }
 108
 109     public void startTime(int _nIndex)
 110         {
 111             m_nTime[_nIndex] = getStartTime();
 112         }
 113
 114     public void stopTime(int _nIndex)
 115         {
 116             m_nTime[_nIndex] = meanTime(m_nTime[_nIndex]);
 117         }
 118
 119     public String getMSOfficeVersion()
 120     {
 121         return m_sMSOfficeVersion;
 122     }
 123     public void print(FileWriter out) throws java.io.IOException
 124         {
 125             String ls = System.getProperty("line.separator");
 126
 127             out.write("loadtime="        + String.valueOf(m_nTime[ Load ]) + ls);
 128             out.write("storetime="       + String.valueOf(m_nTime[ Store ]) + ls);
 129             out.write("printtime="       + String.valueOf(m_nTime[ Print ]) + ls);
 130             out.write("officestarttime=" + String.valueOf(m_nTime[ OfficeStart ]) + ls);
 131             out.write("storeaspdftime="  + String.valueOf(m_nTime[ StoreAsPDF ]) + ls);
 132         }
 133
 134     public static double stringToDouble(String _sStr)
 135         {
 136             double nValue = 0;
 137             try
 138             {
 139                 nValue = Double.parseDouble( _sStr );
 140             }
 141             catch (NumberFormatException e)
 142             {
 143                 GlobalLogWriter.get().println("Can't convert string to double " + _sStr);
 144             }
 145             return nValue;
 146         }
 147
 148     public static long secondsToMilliSeconds(double _nSeconds)
 149         {
 150             return (long)(_nSeconds * 1000.0);
 151         }
 152
 153     /*
 154       Helper function, which read some values from a given file
 155
 156       sample of wordinfofile
 157     name=c:\doc-pool\wntmsci\samples\msoffice\word\LineSpacing.doc
 158     WordVersion=11.0
 159     WordStartTime=0.340490102767944
 160     WordLoadTime=0.650935888290405
 161     WordPrintTime=0.580835103988647
 162      */
 163     public void readWordValuesFromFile(String sFilename)
 164         {
 165             File aFile = new File(sFilename);
 166             if (! aFile.exists())
 167             {
 168                 GlobalLogWriter.get().println("couldn't find file " + sFilename);
 169                 return;
 170             }
 171
 172             RandomAccessFile aRandomAccessFile = null;
 173             try
 174             {
 175                 aRandomAccessFile = new RandomAccessFile(aFile,"r");
 176                 String sLine = "";
 177                 while (sLine != null)
 178                 {
 179                     sLine = aRandomAccessFile.readLine();
 180                     if ( (sLine != null) &&
 181                          (! (sLine.length() < 2) ) &&
 182                          (! sLine.startsWith("#")))
 183                     {
 184                         if (sLine.startsWith("WordStartTime="))
 185                         {
 186                             String sTime = sLine.substring(14);
 187                             m_nTime[OfficeStart] = secondsToMilliSeconds(stringToDouble(sTime));
 188                         }
 189                         else if (sLine.startsWith("WordLoadTime="))
 190                         {
 191                             String sTime = sLine.substring(13);
 192                             m_nTime[Load] = secondsToMilliSeconds(stringToDouble(sTime));
 193                         }
 194                         else if (sLine.startsWith("WordPrintTime="))
 195                         {
 196                             String sTime = sLine.substring(14);
 197                             m_nTime[Print] = secondsToMilliSeconds(stringToDouble(sTime));
 198                         }
 199                         else if (sLine.startsWith("WordVersion="))
 200                         {
 201                             String sMSOfficeVersion = sLine.substring(12);
 202                             m_sMSOfficeVersion = "Word:" + sMSOfficeVersion;
 203                         }
 204                         else if (sLine.startsWith("ExcelVersion="))
 205                         {
 206                             String sMSOfficeVersion = sLine.substring(13);
 207                             m_sMSOfficeVersion = "Excel:" + sMSOfficeVersion;
 208                         }
 209                         else if (sLine.startsWith("PowerPointVersion="))
 210                         {
 211                             String sMSOfficeVersion = sLine.substring(18);
 212                             m_sMSOfficeVersion = "PowerPoint:" + sMSOfficeVersion;
 213                         }
 214                     }
 215                 }
 216             }
 217             catch (java.io.FileNotFoundException fne)
 218             {
 219                 GlobalLogWriter.get().println("couldn't open file " + sFilename);
 220                 GlobalLogWriter.get().println("Message: " + fne.getMessage());
 221             }
 222             catch (java.io.IOException ie)
 223             {
 224                 GlobalLogWriter.get().println("Exception while reading file " + sFilename);
 225                 GlobalLogWriter.get().println("Message: " + ie.getMessage());
 226             }
 227             try
 228             {
 229                 aRandomAccessFile.close();
 230             }
 231             catch (java.io.IOException ie)
 232             {
 233                 GlobalLogWriter.get().println("Couldn't close file " + sFilename);
 234                 GlobalLogWriter.get().println("Message: " + ie.getMessage());
 235             }
 236         }
 237
 238     public static void main(String[] args) {
 239
 240 /*
 241  BorderRemover a = new BorderRemover();
 242         try
 243         {
 244             a.createNewImageWithoutBorder(args[0], args[1]);
 245         }
 246         catch(java.io.IOException e)
 247         {
 248             System.out.println("Exception caught.");
 249         }
 250  */
 251     }
 252 }