stilpatterneval.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2006 International Business Machines Corporation
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * Contributors:
 *    Douglas Sprague, Joel Wheeler - initial API and implementation
 *
 *****************************************************************************/

#ifndef STILPATTERNEVAL_H
#define STILPATTERNEVAL_H

#include <string>
#include <vector>

#include "stil.h"

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

class STILPatternEval
{

  public:

    // - Virtual dtor
    virtual ~STILPatternEval();

    // - Open/Close a STIL file to be processed
    void open(const std::string & filename);
    void close();

    // - Load up the Pattern to be processed
    //loadpattern(by #)
    bool loadPattern(LONG patNum);
    //loadpattern(by name)

    // - Return the number of the environment currently being processed
    LONG getEnvIdx() { return m_currEnvIdx; }

    // - Start evaluating the Pattern block
    void evaluate();

    // Sometimes we'll need access directly to the STIL object, or even at
    //  the evalengine level. I dont think theres any way to completely hide
    //  these...
    // - Get the STIL block
    const STIL* getSTIL() { return ((const STIL*)(&m_stilobj)); }
    // - Get the currently loaded eval engine
    STILEvalEngine * getCurrEvalEngine() { return m_pCurrEvalEng; }

    // Maybe return some context about where the current block is found??
    // const STILEntity* getParentBlock()


    // Overloadable functions:
    // Through these virtual functions, a user can re-implement just those functions
    //  for which he needs processing capability. By re-implementing these
    //  member functions in a derived class, the user says that they dont care
    //  about iterating thru pattern statments or eval engines- all they want
    //  to do is have a certain function called when a certain type of data
    //  is encountered. They'll take care of the details of what happens when
    //  that data type is encountered. And leave all of the evalengine switching
    //  and iterating up to this parent class...

    // - Call this once for each eval engine, before processing any data
    virtual void init();

    // Every type of entity in a Pattern block should eventually have a
    // 'process<EntityType>' function. When that type is encountered, it's
    //  derived implementation will be called.
    // Any 'block' object (one that may be iterated over) will have a
    //  'process<EntityType>' and 'process<EntityType>End' pair of functions.
    // If the object is a simple entity (no iteration), then there will only
    //  be a 'process<EntityType>' member function.
    // Block entity (may be iterated over):
    virtual void processVector(const STILVector*);
    virtual void processVectorEnd(const STILVector*);

    virtual void processCondition(const STILCondition*);
    virtual void processConditionEnd(const STILCondition*);

    virtual void processShift(const STILShift*);
    virtual void processShiftEnd(const STILShift*);

    // Base entity (no iteration):
    virtual void processVectorItem(const STILVectorItem*);
    virtual void processWaveformTableRef(const std::string &);


  private:

    // Dont allow protected access here for any derived classes.
    // The implementation is to stay hidden.
    STILPattern* getPattern(LONG patNum);

    // Iterate thru the various blocks
    void iterPatternBlock();
    void iterSubPatternBlock(const STILPatternBlock *);
    void iterPatternBlockStatements(const STILEntity &);
    void iterVectorBlock(const STILVectorBlock*);


    STIL  m_stilobj;                          // base STIL object
    STILPattern * m_pPattern;                 // ptr to desired Pattern block

    STILEvalEngine* m_pCurrEvalEng;           // the active EE
    std::vector<STILEvalEngine*> m_pEvalEngs; // array of EE's- one per env
    LONG m_currEnvIdx;                        // index of active EE

};


#endif

---

This page last updated on 6 Jul 2007