stilsignalblock.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 STILSignalBlock_H
#define STILSignalBlock_H

#include <vector>

#include "stilblock.h"        // Base class for all STIL objects
#include "stiltermination.h"  // STILTermination enumeration
#include "stilwfcs.h"


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class STILSignalBlock : public STILBlock {

  // - Global ostream << operator as friend to output STILSignalBlock object
  friend std::ostream& operator<<( std::ostream &os, const STILSignalBlock &);

  // - Public members
  public:

    // - DefaultState attribute
    enum STILDefaultState {
               UndefinedDefaultState,  
               ForceUp,                
               ForceDown,              
               ForceOff                
    };

    // - Base attribute
    enum STILBase {
               UndefinedBase,          
               Hex,                    
               Dec                     
               //WFC    // WFC is the default base
    };

    // - Alignment attribute
    enum STILAlignment {
      UndefinedAlignment,    
      MSB,                   
      LSB                    
    };

    // This needs work... The hex/dec translations not working, and not setup
    //  to translate quickly.
    struct WFCSTranslateStruct  {
      char wfc;       
      char * binstr;  
    };
    typedef struct WFCSTranslateStruct WFCSTranslator;

    // - Default Constructor
    STILSignalBlock();

    // - Construct given a Type
    STILSignalBlock(Type);

    // - Copy Constructor
    STILSignalBlock(const STILSignalBlock &);

    // - Destructor
    virtual ~STILSignalBlock();

    // - Assignment Operator
    STILSignalBlock & operator=(const STILSignalBlock &);

    // - Initialize this STILSignalBlock object.
    void              init();

    // - Member functions to set/get Termination
    void              setTermination(STILTermination);
    STILTermination   getTermination() const;

    // - Member functions to set/get DefaultState
    void              setDefaultState(STILDefaultState);
    STILDefaultState  getDefaultState() const;

    // - Member functions to set/get STILBase
    void              setBase(STILBase b, const STILWFCS & wfcs);
    STILBase          getBase() const;
    const STILWFCS &  getBaseWFCS() const;
    // - Member function to return the number of base bits
    LONG              getBaseNumBits() const;

    // - Member functions to set/get Alignment
    void              setAlignment(STILAlignment);
    STILAlignment     getAlignment() const;

    // - Member functions to set/get the ScanIn length
    //        -1 : signal not defined as ScanIn
    //         0 : signal defined as ScanIn with undefined default length
    //        >0 : signal defined as ScanIn with defined default length
    void              setScanIn(LONG length);
    LONG              getScanIn() const;

    // - Member functions to set/get the ScanOut length
    //        -1 : signal not defined as ScanOut
    //         0 : signal defined as ScanOut with undefined default length
    //        >0 : signal defined as ScanOut with defined default length
    void              setScanOut(LONG length);
    LONG              getScanOut() const;

    // - Member functions to set/get the DataBitCount
    //         0 : signal not defined as multiple data bit
    //        >0 : signal defined with multiple data bits
    void              setDataBitCount(LONG count);
    LONG              getDataBitCount() const;

    // - Static Member functions to convert enumerations to sstring values
    static const sstring &    convertTermination(STILTermination);
    static const sstring &    convertDefaultState(STILDefaultState);
    static const sstring &    convertBase(STILBase);
    static const sstring &    convertAlignment(STILAlignment);

    void print_vectortrans() const;
    void print_vectortrans(std::ofstream& ttofs) const;
    char evalTrans (sstring &, LONG ln=0) const ;

  // Protected members (accessable from derived classes)
  protected:

    // Translate a WFC character into a binary
    const sstring WFC2Bin(const char) const;
    // Translate a binary sstring into a WFC character
    const sstring Bin2WFC(const sstring) const;

    // SignalBlock attributes
    STILTermination             m_termination;
    STILDefaultState            m_defaultState;
    STILBase                    m_base;
    STILWFCS                    m_baseWFCS;
    STILAlignment               m_alignment;
    LONG                        m_scanin;
    LONG                        m_scanout;
    LONG                        m_databitcount;


    int                         m_numbits; // number of bits to represent the baseWFCS
    std::vector<WFCSTranslator> m_WFCSTransVec;


}; // end STILSignalBlock class

// Inline functions
// - Member function to return the number of base bits
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline    LONG  STILSignalBlock::getBaseNumBits() const { return m_numbits; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void                             STILSignalBlock::setTermination(STILTermination t) {
  m_termination = t;
  addEntity(Termination,"Termination",convertTermination(t));
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline STILTermination  STILSignalBlock::getTermination() const { return m_termination; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void                             STILSignalBlock::setDefaultState(STILDefaultState ds) {
  m_defaultState = ds;
  addEntity(DefaultState,"DefaultState",convertDefaultState(ds));
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline STILSignalBlock::STILDefaultState STILSignalBlock::getDefaultState() const { return m_defaultState; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline STILSignalBlock::STILBase        STILSignalBlock::getBase() const { return m_base; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline const STILWFCS &                 STILSignalBlock::getBaseWFCS() const { return m_baseWFCS; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void                             STILSignalBlock::setAlignment(STILAlignment a) {
  m_alignment = a;
  addEntity(Alignment,"Alignment",convertAlignment(a));
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline STILSignalBlock::STILAlignment    STILSignalBlock::getAlignment() const { return m_alignment; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void                             STILSignalBlock::setScanIn(LONG si) {
  m_scanin = si;
  char tmp[32];
  sprintf(tmp,"%d",si);
  addEntity(ScanIn,"ScanIn",tmp);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline LONG                             STILSignalBlock::getScanIn() const { return m_scanin; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void                             STILSignalBlock::setScanOut(LONG so) {
  m_scanout = so;
  char tmp[32];
  sprintf(tmp,"%d",so);
  addEntity(ScanOut,"ScanOut",tmp);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline LONG                             STILSignalBlock::getScanOut() const { return m_scanout; }

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void                             STILSignalBlock::setDataBitCount(LONG dbc) {
  m_databitcount = dbc;
  char tmp[32];
  sprintf(tmp,"%d",dbc);
  addEntity(DataBitCount,"DataBitCount",tmp);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline LONG                             STILSignalBlock::getDataBitCount() const { return m_databitcount; }

inline void destroy(STILSignalBlock::WFCSTranslateStruct*) { /* Let the class destructor free up the space */ }
//inline void                             STILSignalBlock::setBase(STILBase b, const sstring & wfcs) {
//  m_base     = b;
//  m_baseWFCS = wfcs;
//  addEntity(Base,"Base",convertBase(b) + " " + wfcs);
//}

#endif

---

This page last updated on 6 Jul 2007