Tools/Xabsl2/GT/GTXabsl2Profiler/GTXabsl2ProfilerLog.h

Go to the documentation of this file.

#ifndef __GTXabsl2ProfilerLog_h_
#define __GTXabsl2ProfilerLog_h_

#ifdef _WIN32
#pragma warning(disable:4786) 
// the constructor with all it's long parameter type names results in a too
// long debug identifier
#endif

#include <string>
#include <vector>
#include <deque>

#include "Platform/GTAssert.h"

#include "Tools/Streams/OutStreams.h"
#include "Platform/SystemCall.h"


#include "Tools/Xabsl2/Xabsl2Engine/Xabsl2Engine.h"
#include "Tools/Debugging/Debugging.h"

#include "Tools/Streams/InStreams.h"
#include "Tools/Module/SolutionRequest.h"

#include "GTXabsl2ProfilerNameTable.h"


class GTXabsl2ActiveOption{
public:
  /** Number of the option. Index within the NameTable used for lookup */
  int optionNumber;
  
  /** Number of the state that is active within the option. Index within a NameTableEntry used for lookup */
  int stateNumber;
  
  /** Values for parameters of the option, where the position is the same as the names within a NametableEntry */
  std::vector<double> parameters;

  /*
   *  Constructor
   * Initialises to non-possible values
   */
  GTXabsl2ActiveOption(): optionNumber(-1), stateNumber(-1){}
  
  /*
   * Constructor
   * Initialises to corresponding values
   */
  GTXabsl2ActiveOption(int o, int st, std::vector<double> p): optionNumber(o), stateNumber(st), parameters(p){}
  
  /*
   *  Equality operator. Based on memberwise comparison. 
   */
  bool operator ==(const GTXabsl2ActiveOption other)const
  {
    if(this->optionNumber == other.optionNumber && this->stateNumber == other.stateNumber
      && this->parameters == other.parameters)
      return true;
    return false;
  }
};

/**
* @class GTXabsl2LogEntry
* Class for keeping numerical activation paths and framenumbers
* @author Michael Spranger
*/
class GTXabsl2LogEntry{
public:
  /** framenumber of the entry */
  unsigned long frameNumber;

  /** decimalinputsymbolvalues */
  std::vector<double> inputSymbolValues;

  /** activation path within XABSL-tree */
  std::vector<GTXabsl2ActiveOption> activeOptions;

  /*
   *  Constructor
   */
  GTXabsl2LogEntry(){};
  GTXabsl2LogEntry(unsigned long fn):frameNumber(fn){}
  GTXabsl2LogEntry(unsigned long fn, std::vector<GTXabsl2ActiveOption> aO, std::vector<double>dI):frameNumber(fn), inputSymbolValues(dI), activeOptions(aO){}
  unsigned int getMaxNumberOfParameters(){
    unsigned int maxNumberOfParameters = 0;
    for(unsigned int i = 0; i < activeOptions.size(); ++i){
      if(activeOptions[i].parameters.size() > maxNumberOfParameters)
        maxNumberOfParameters = activeOptions[i].parameters.size();
    }
    return maxNumberOfParameters;
  }
  int differsInParameters(GTXabsl2LogEntry& entry);
};
/**
* Streaming operator that reads KickCase from a stream.
* @param in The stream from which is read.
* @param log The log object.
* @return The stream.
*/ 
In& operator>>(In& in, GTXabsl2LogEntry& log);

/**
* Streaming operator that writes KickCase to a stream.
* @param out The stream to write on.
* @param log The log object.
* @return The stream.
*/ 
Out& operator<<(Out& out, const GTXabsl2LogEntry& log);

/*
 * @class Class representing a log, including the nametable for XabslOptions, XablsStates, XabslOptionParameters and XabslInputSymbols
 * @author Michael Spranger
 */
class GTXabsl2Log: public std::deque<GTXabsl2LogEntry>
{
public:
  /** NameTable for keeping corresponding names to numerical logs */
  GTXabsl2ProfilerNameTable nameTable;

  /** Names of the DecimalInputSymbols */
  std::vector<std::string>   inputSymbolNames;

  /** Maximal depth of the XABSL-Option-Tree */
  //int maxDepth;

  /** Constructor */
  // GTXabsl2Log():maxDepth(0){}

  /**
   * Initialises the log for the a XabslEngine, creating NameTable and InputSymbolNameTable
   */
  void init(Xabsl2Engine& pEngine);

  /**
   * Appends a logentry to the current log 
   */
  void append(GTXabsl2LogEntry logentry);

  void clearAll();

  int getIndexOfFrameNumber(unsigned int frameNumber);

  int getActiveOptionNumberAtFrameNumber(unsigned int frameNumber, int optionMaxDepth);
  GTXabsl2ActiveOption getOption(int index, int optionMaxDepth);
};

/**
* Streaming operator that reads KickCase from a stream.
* @param in The stream from which is read.
* @param log The log object.
* @return The stream.
*/ 
In& operator>>(In& in, GTXabsl2Log& log);

/**
* Streaming operator that writes KickCase to a stream.
* @param out The stream to write on.
* @param log The log object.
* @return The stream.
*/ 
Out& operator<<(Out& out, const GTXabsl2Log& log);


#endif// __GTXabsl2ProfilerLog_h_

---