IBlock.cs :  » Profilers » Prof-It » at » jku » ssw » ProfIt » Components » C# / CSharp Open Source

/*----------------------------------------------------------------------
Prof-It for C#
Copyright (c) 2004 Klaus Lehner, University of Linz

This program is free software; you can redistribute it and/or modify it 
under the terms of the GNU General Public License as published by the 
Free Software Foundation; either version 2, or (at your option) any 
later version.

This program is distributed in the hope that it will be useful, but 
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License 
for more details.

You should have received a copy of the GNU General Public License along 
with this program; if not, write to the Free Software Foundation, Inc., 
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
----------------------------------------------------------------------*/

using System;

namespace at.jku.ssw.ProfIt.Components{

  /// <summary>
  /// This is the basic class for each Basic Block
  /// </summary>
  [Serializable]
  public abstract class IBlock {
    private Position start;
    private Position end;
    private int statements;

    
    public IBlock(Position start) {
      this.start = start;
    }

    /// <summary>
    /// the start position of the block in the file
    /// </summary>
    public Position Start {
      get { return this.start; }
      set { this.start = value; }
    }

    /// <summary>
    /// the end position of the block in the file
    /// </summary>
    public Position End {
      get { return this.end; }
      set { this.end = value; }
    }

    /// <summary>
    /// determines how often the code inside the block has been executed
    /// </summary>
    public void AddStatement() {
      statements++;
    }

    /// <summary>
    /// the number of statements in the block
    /// </summary>
    public virtual int Statements {
      get { return statements; }
    }

    /// <summary>
    /// The number of statement executions. can be calculated as Counter*Statements
    /// </summary>
    public virtual int Executions {
      get { return Statements * Counter; }
    }

    public static IBlock operator + (IBlock b1, IBlock b2) {
      return new CompoundBlock(b1, b2, 1);
    }

    public static IBlock operator - (IBlock b1, IBlock b2) {
      return new CompoundBlock(b1, b2, -1);
    }

    public abstract int Counter { get; }

    public override string ToString() {
      string type = "[" + this.GetType().ToString() + "]";
      if (start != null && end != null) return type + " Start " + start.ToString() + " / End " + end.ToString();
      if (end == null && start != null) return type + " Start " + start.ToString();
      else return type;
    }


    [Serializable]
    private class CompoundBlock : IBlock {
      private IBlock b1, b2;
      int factor;

      public CompoundBlock(IBlock b1, IBlock b2, int factor) : base(null) {
        this.b1 = b1;
        this.b2 = b2;
        this.factor = factor;
      }

      public override int Counter {
        get {
          return b1.Counter + (factor*b2.Counter);
        }
      }
    }
  }



}