Tools/Xabsl2/GT/GTXabsl2Profiler/GTXabsl2ProfilerNameTable.h

Go to the documentation of this file.

/**
* @file GTXabsl2ProfilerNameTable.h
* 
* Definition and Implementation of classes GTXabsl2Profiler, GTXabsl2ProfilerNameTable
*
* @author Michael Spranger
*/
#ifndef __GTXabsl2ProfilerNameTable_h_
#define __GTXabsl2ProfilerNameTable_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/Xabsl2Array.h"
#include "Tools/Xabsl2/Xabsl2Engine/Xabsl2Engine.h"
#include "Tools/Debugging/Debugging.h"

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

/*
* @class GTXabsl2ProfilerNameTableEntry
* Class that encapsulates string representations for options, state in options and optionparameters
* @author Michael Spranger
*/
class GTXabsl2ProfilerNameTableEntry{
  public:
    /** The name of the Option represented by this entry */
    std::string optionName;
    /**The vector of state names */
    std::vector<std::string> states;
    /** A vector of parameter names */
    std::vector<std::string> parameters;
    /** The maximal depth of this option in the option-tree (XABSL)*/
    int maxDepth;
    
    /**
    * Constructor
    * Initializes the strings as zero length strings.
    */
    GTXabsl2ProfilerNameTableEntry(){};

    
    /**
    * Constructor
    * @param option The option name
    * @param state The names of all state within the corresponding option
    * @param params The names of all parameters for this Option
    * @param depth The maximal depth of this option in the option tree.
    */
    GTXabsl2ProfilerNameTableEntry(const std::string option,std::vector<std::string> state, std::vector<std::string> params, const int depth)
      : optionName(option), states(state), parameters(params), maxDepth(depth){}

};

/*
* @class GTXabsl2ProfilerNameTable
* Dynamic Array for keeping a correlation of Xabsl2Options and States to Numbers for profiling purposes (remembering activation paths).
* @author Michael Spranger
*/
class GTXabsl2ProfilerNameTable: public std::vector<GTXabsl2ProfilerNameTableEntry>
{
  /** The number of elements in the array */
  public:
     int maxDepth;

    /** Constructor 
    * Initializes all members with 0.
    */
    GTXabsl2ProfilerNameTable(): maxDepth(0)
    {}

    /**
    * Initializes the Array
    */
    void init(Xabsl2Engine& pEngine);
    
    /** 
    * Returns the Position for a given optionname
    * Note that the function crashes if the element does not exist.
    */
    int getOptionPosition(const std::string optionName) const
    {
      return findOption(optionName);
    }

    /** 
    * Returns the Position for a given state within the option
    * Note that the function crashes if the element does not exist.
    * @param optionName Name of the option the state is in
    * @param state Name of the state the position is returned for
    * @return The Position of the state within NameTableEntry
    */
    int getStatePosition(const std::string optionName, const std::string state){
      return findState(optionName, state);
    }
    
    /** Returns whether an element for the given name exists 
    * @param optionName Name of the option searched for
    * @param stateName Name of the state that in conjunction with optionName makes the request unique
    */
    bool exists(const std::string optionName, const std::string stateName) const
    {
      return find(optionName, stateName) >= 0;
    }

    /** Returns whether an element for the given namey exists 
    * @param option Name of the option searched for
    */
    bool existsOption(const std::string option){
      return findOption(option) >=0;
    }

    
   protected:
   /** 
   * Returns the index of an element with the given names.
   * @return The index of the element of -1 if the name does not exist.
   */
     int find(const std::string optionName, const std::string state) const;
     
     /** 
     * Returns the index of an element with the given names.
     * @return The index of the element of -1 if the name does not exist.
     */
     int findState(const std::string optionName, const std::string state) const;

     /** 
     * Returns the index of an element with the given names.
     * @return The index of the element of -1 if the name does not exist.
     */
     int findOption(const std::string optionName) const;
     
    /*
     * Registers Option, calls itself recursively for subsequent options, registering all subsequent options as well
     * @param  option Option to be registered
     * @param depth depth of the option to be registered
     */
    void registerOption(const Xabsl2Option* option, int depth);

    /*
     *  Does a depth count for the option, where depth is initial depth
     */
    void countDepth(const Xabsl2Option* option, int depth);

};
/**
* Streaming operator that reads KickCase from a stream.
* @param in The stream from which is read.
* @param nameTable The name table object.
* @return The stream.
*/ 
In& operator>>(In& in, GTXabsl2ProfilerNameTable& nameTable);

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

#endif// __GTXabsl2Profiler_h_

---