I want to change this logLine format?

[Varuna Seneviratna]

I want to add the following

SUCCESSFUL_ACCESS=200, ACCESS_FORBIDDEN=403, DOCUMENT_NOT_FOUND=404

to the logLine created by the following code
Below are the four classes associated with this program.in addition to the information that is given now they are 1Accesses pre hour(0-23) 2 Accesses per day(days 1-31) and so on. I want to add using the above mentioned access status indicators how many accesses were successful and unsuccessful.This is from the book objects first with blueJ.Please explain to me how this can be done and how it is actually getting implemented.

   
 
public class LogAnalyzer
{
    // Where to calculate the hourly access counts.
    private int[] hourCounts;
    //Where to calculate yearly access
    private int[] yearCounts;
    // Use a LogfileReader to access the data.
    private int[] monthCounts;
    private int[] dayCounts;
    private LogfileReader reader;
 
    /**
     * Create an object to analyze hourly web accesses.
     */
    public LogAnalyzer()
    { 
        
       
        // Create the array object to hold the hourly
        // access counts.
        hourCounts = new int[24];
        //Create the array object to hold the yearly
        // access counts
        
       // yearCounts=new long[];
        // Create the reader to obtain the data.
         reader = new LogfileReader();
         int maxYear=0;
         while(reader.hasMoreEntries()) {
            LogEntry entry = reader.nextEntry();
            int currentYear = entry.getYear();
            maxYear=currentYear;
            while(reader.hasMoreEntries())
            {
                  if(currentYear > maxYear)
                  {
                     maxYear=currentYear; 
                    }
                    
                    entry=reader.nextEntry();
                    currentYear=entry.getYear();
            }
                
            
        }
       
        yearCounts=new int[maxYear];
        
        
        monthCounts=new int[12];
        dayCounts=new int[31];
        
       
        
        
        
    }
 
    /**
     * Analyze the hourly access data from the log file.
     */
    public void analyzeHourlyData()
    {
        reader = new LogfileReader();
        while(reader.hasMoreEntries()) {
            LogEntry entry = reader.nextEntry();
            int hour = entry.getHour();
            hourCounts[hour]++;
            
        }
    }
    /**
     * Analyze yearly access data from the log file
     */
    public void analyzeYearlyData()
    { 
        reader = new LogfileReader();
        while(reader.hasMoreEntries()) {
            LogEntry entry = reader.nextEntry();
            int year = entry.getYear();
            yearCounts[--year]++;
        }
    }
     public void analyzeMonthlyData()
    { 
        reader = new LogfileReader();
        while(reader.hasMoreEntries()) {
            LogEntry entry = reader.nextEntry();
            int month = entry.getMonth();
            monthCounts[--month]++;
        }
    }
    public void analyzedailydata()
    {
        reader =new LogfileReader();
        while(reader.hasMoreEntries())
        {
            LogEntry entry=reader.nextEntry();
            int day=entry.getDay();
            dayCounts[--day]++;
            
        }
    }
 
    /**
     * Print the hourly counts.
     * These should have been set with a prior
     * call to analyzeHourlyData.
     */
    public void printHourlyCounts()
    {
        
        System.out.println("Hr: Count");
        for(int hour = 0; hour < hourCounts.length; hour++) {
            System.out.println(hour + ": " + hourCounts[hour]);
           
        }
        
        
    }
    /**
     * Print the yearly counts.
     * These should have been set with a a prior
     * call to analyzeYearlyData.
     */
    public void printYearlyCounts()
    {
        System.out.println("Year: Count");
        for(int year=0; year < yearCounts.length; year++)
        {
            System.out.println((year + 1) + ": " + yearCounts[year]);   
        }
    }
    public void printMonthlyCounts()
    {
        System.out.println("Month: Count");
        for(int month=0; month < monthCounts.length; month++)
        {
            System.out.println((month + 1) + ": " + monthCounts[month]);   
        }
    }
    
    public void printDailyCounts()
    {
        System.out.println("Day: Count");
        for(int day=0; day < dayCounts.length; day++)
        {
           System.out.println((day + 1) + ": " + dayCounts[day]);
           
        }
    }
    
    /**
     * Print the lines of data read by the LogfileReader
     */
    public void printData()
    {
        reader.printData();
    }
    
    /** 
     * Return the number of accesses recorded in the log
     * file
     */
    public int numberOfAccesses()
    {  
       int total=0;
       for( int hour =0; hour < hourCounts.length; hour++)
       {
           total +=hourCounts[hour];  
        }
        
        return total;
    }
    public int busiestHour()
    {
        int temp=0;
         int busiestHour=0;
        for( int hour =0; hour < hourCounts.length; hour++)
        {
           int busiestHourCount = hourCounts[hour];
           if(busiestHourCount > temp)
           {
                temp =busiestHourCount;
                busiestHour=hour;
                
            }
        }
        return busiestHour; 
    }
    public int quitestHour()
    {
        int hour=0;
        int quitestHourCount =hourCounts[hour];
        int quitestHour=0;
        hour=1;
        while(hour < hourCounts.length)
        {
            
            int temp = hourCounts[hour];
            if(temp < quitestHourCount)
            {
               quitestHour=hour; 
               quitestHourCount=hourCounts[quitestHour];
            }
            hour++;
        }
        
        return quitestHour;
       
    }
    public int firstHourOfBusiestTwoHours()
    {
        
        int index=0;
       
        
        
        
        
        int tempBusiestTwoHoursCounts= hourCounts[index] +  hourCounts[index++];
        int busiestHour1=--index;
        int busiestHour2=++index;
        int busiestTwoHoursCounts=tempBusiestTwoHoursCounts;
        while(index < hourCounts.length)
        {
            
               
               
               if(tempBusiestTwoHoursCounts > busiestTwoHoursCounts)
               {
                   
                    busiestTwoHoursCounts=tempBusiestTwoHoursCounts;
                    busiestHour1=--index;
                    busiestHour2=++index;
                }
                  
                   tempBusiestTwoHoursCounts= hourCounts[index] +  hourCounts[index++];
                   
                   
        }
        
        return busiestHour1;
        
    }
  }
 
 
 

   
public class LogfileReader
{
    // The data format in the log file.
    private String format;
    // Where the file's contents are stored in the form
    // of LogEntry objects.
    private ArrayList entries;
    // An iterator over entries.
    private Iterator dataIterator;
    
    /**
     * Create a LogfileReader to supply data from a default file.
     */
    public LogfileReader()
    {
        this("weblog.txt");
    }
    
    /**
     * Create a LogfileReader that will supply data
     * from a particular log file. 
     * @param filename The file of log data.
     */
    public LogfileReader(String filename)
    {
        // The format for the data.
        format = "Year Month(1-12) Day Hour Minute";       
        // Locate the file with respect to the current environment.
        URL fileURL = getClass().getClassLoader().getResource(filename);
        // Where to store the data.
        entries = new ArrayList();
        
        // Attempt to read the complete set of data from file.
        try{
            BufferedReader logfile =
                new BufferedReader(new FileReader(fileURL.getFile()));
            // Read the data lines until the end of file.
            String logline;
            logline = logfile.readLine();
            while(logline != null) {
                // Break up the line.
                LogEntry entry = new LogEntry(logline);
                entries.add(entry);
                logline = logfile.readLine();
            }
            logfile.close();
        }
        catch(IOException e) {
            System.out.println("Failed to read the data file: " +
                               filename);
            System.out.println("Using simulated data instead.");
            createSimulatedData(entries);
        }
        // Sort the entries into ascending order.
        Collections.sort(entries);
        reset();
    }
    
    /**
     * Does the reader have more data to supply?
     * @return true if there is more data available,
     *         false otherwise.
     */
    public boolean hasMoreEntries()
    {
        return dataIterator.hasNext();
    }
    
    /**
     * Analyze the next line from the log file and
     * make it available via a LogEntry object.
     * 
     * @return A LogEntry containing the data from the
     *         next log line.
     */
    public LogEntry nextEntry()
    {
        // Create a LogEntry from the contents of the next
        // log line.
        return (LogEntry) dataIterator.next();
    }
    
    /**
     * @return A string explaining the format of the data
     *         in the log file.
     */
    public String getFormat()
    {
        return format;
    }
    
    /**
     * Set up a fresh iterator to provide access to the data.
     * This allows a single file of data to be processed
     * more than once.
     */
    public void reset()
    {
        dataIterator = entries.iterator();
    }
    
    public void printData()
    {
        Iterator it = entries.iterator();
        while(it.hasNext()) {
            System.out.println((LogEntry) it.next());
        }
    }
 
    /**
     * Provide a sample of simulated data.
     * NB: To simplify the creation of this data, no
     * days after the 28th of a month are ever generated.
     * @param data Where to store the simulated LogEntry objects.
     */
    private void createSimulatedData(ArrayList data)
    {
        // For each data item (year, month, day, hour, min) the lowest
        // valid value is listed.
        int[] lowest = { 2001, 1, 1, 0, 0, };
        // For each data item (year, month, day, hour, min) the range of
        // valid values is listed. (Note the simplification of having
        // only 28 days in any month to avoid generating invalid dates.)
        int[] range = { 3, 12, 28, 24, 60 };
        // Use a fixed seed to generate the random data, so
        // that the data is reproducable.
        Random rand = new Random(12345);
        // Build each simulated line in a string buffer.
        StringBuffer line = new StringBuffer();
        // How many simulated lines we want.
        int numLines = 100;
        // The number of data values per simulated line.
        int itemsPerLine = lowest.length;
        for(int i = 0; i < numLines; i++) {
            for(int j = 0; j < itemsPerLine; j++) {
                int value = lowest[j]+rand.nextInt(range[j]);
                line.append(value);
                line.append(' ');
            }
            // Convert the line to a LogEntry.
            LogEntry entry = new LogEntry(line.toString());
            data.add(entry);
            line.setLength(0);
        }
    }
}
 
 
 
 
 
 
 

  
public class LogEntry implements Comparable
{
    // Where the data values extracted from a single
    // log line are stored.
    private int[] dataValues;
    
    // At which index in dataValues the different fields
    // from a log line are stored.
    private final int YEAR = 0, MONTH = 1, DAY = 2,
                      HOUR = 3, MINUTE = 4;
                      
    
                      
    
                      
    /**
     * Decompose a log line so that the individual fields
     * are available.
     * @param logline A single line from the log.
     */
    public LogEntry(String logline)
    {
        // The array to store the data for a single line.
        dataValues = new int[5];
       
        // Break up the log line.
        LoglineTokenizer tokenizer = new LoglineTokenizer();
        tokenizer.tokenize(logline,dataValues);
    }
   
    
    /**
     * @return the year field from the log line
     */
    public int getYear()
    {
        return dataValues[YEAR];   
    }
    
    /**
     * @return the month field from the log line
     */
    public int getMonth()
    {
        return dataValues[MONTH];   
    }
    /**
     * @returns the day field from the log line
     */
    public int getDay()
    {
        return dataValues[DAY];   
    }
    
    /**
     * @return The hour field from the log line.
     */
    public int getHour()
    {
        return dataValues[HOUR];
    }
 
    /**
     * @return The minute field from the log line.
     */
    public int getMinute()
    {
        return dataValues[MINUTE];
    }
    
    /**
     * Create a string representation of the data.
     * This is not necessarily identical with the
     * text of the original log line.
     *
     * @return A string representing the data of this entry.
     */
    public String toString()
    {
        StringBuffer buffer = new StringBuffer();
        for(int i = 0; i < dataValues.length; i++) {
            int value = dataValues[i];
            // Prefix a leading zero on single digit numbers.
            if(value < 10) {
                buffer.append('0');
            }
            buffer.append(value);
            buffer.append(' ');
        }
        // Drop any trailing space.
        return buffer.toString().trim();
    }
    
    /**
     * Compare the date/time combination of this log entry
     * with another.
     * @param other The other entry to compare against.
     * @return A negative value if this entry comes before the other.
     *         A positive value if this entry comes after the other.
     *         Zero if the entries are the same.
     */
    public int compareTo(Object other)
    {
        if(other == this) {
            // They are the same object.
            return 0;
        }
        else {
            LogEntry otherEntry = (LogEntry) other;
            // Compare corresponding fields.
            for(int i = 0; i < dataValues.length; i++) {
                int difference = dataValues[i] - otherEntry.dataValues[i];
                if(difference != 0) {
                    return difference;
                }
            }
            // No value is different, so the two entries represent
            // identical times.
            return 0;
        }
    }
}
 
 
 
  

   
 
public class LoglineTokenizer
{
    /**
     * Construct a LogLineAnalyzer
     */
    public LoglineTokenizer()
    {
    }
 
    /**
     * Tokenize a log line. Place the integer values from
     * it into an array. The length of the array must match
     * the number of tokens on the line.
     *
     * @param logline The line to be tokenized.
     * @param dataLine Where to store the values.
     */
    public void tokenize(String logline, int[] dataLine)
    {
        StringTokenizer tokens = new StringTokenizer(logline);
        if(tokens.countTokens() == dataLine.length) {
            String number = "";
            try{
                StringTokenizer tokenizer = new StringTokenizer(logline);
                int numTokens = tokenizer.countTokens();
                for(int i = 0; i < numTokens; i++) {
                    number = tokenizer.nextToken();
                    dataLine[i] = Integer.parseInt(number);
                }
            }
            catch(NumberFormatException e) {
                System.out.println("Badly formatted number: " + number);
                System.out.println("In log line: " + logline);
            }
        }
        else {
            System.out.println("Invalid log line: " + logline);
        }
    }
}
 
 
 
 

Guide me how to do That?


Varuna

[ November 06, 2008: Message edited by: Varuna Seneviratna ]
[ November 06, 2008: Message edited by: Varuna Seneviratna ]

[fred rosenberger]

 
String logline;
logline = logfile.readLine();
logline = logline.append("SUCCESSFUL_ACCESS=200, ACCESS_FORBIDDEN=403, DOCUMENT_NOT_FOUND=404")
while(logline != null) {
   

I doubt that's what you want, but it's what you asked for. Can you elaborate on exactly what you DO want?