stilblock.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 STILBlock_H
#define STILBlock_H

#include "stilcomstr.h"
#include <list>                // ANSI C++ STL list class

#include "stilcom.h"               // Common include
#include "stilentity.h"        // Common STIL base class for most STIL classes

// At one point, the iterator & const iterator classes were contained in this
//  .h file. I've broken them out now, but instead of adding
//  "#include stilblockiterator.h" everywhere, for now I'll just put these includes
//   here. At some point, remove them and update the rest of the code that uses
//   iterators...
#include "stilblockiterator.h"
#include "stilblockconstiterator.h"

// Following inline function will prevent errors when compiling the
// template code for the STL lists of the pointers to STILEntities
// This is needed because the compiler does not know how to ignore
// delete when called on pointers with one level of indirection too much
//inline void destroy(STILEntity**) { }


// Integer value to place in the linenumber field
// of a STILEntity object when it's derived class
// contents are not copied correctly.
//const LONG STILBLOCK_BAD_COPY (-99);
// SWIG doesnt seem to like 'const'- change to #define:
#define STILBLOCK_BAD_COPY -99

class STILBlockIterator;                 // Prototype of iterator class
class STILBlockConstIterator;            // Prototype of iterator class

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class STILBlock : public STILEntity {


  // - Make iterator class a friend for access to
friend class STILBlockIterator;
friend class STILBlockConstIterator;

  // - Public members
  public:

    typedef STILBlockIterator               Iterator;
    typedef STILBlockConstIterator          ConstIterator;

    // - Default Constructor
    STILBlock();

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

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

    // - Destructor
    virtual ~STILBlock();

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

    // - Equality Operator
    bool operator==(const STILBlock &) const;

    // - Less Than Operator
    bool operator<(const STILBlock &) const;

    // - Initialize this STILBlock object specifying the type.
    void        init(Type t);

    // - Clear out this block of any stored up entities.
    void        clear();

    // - Write out Header to a given FILE
    virtual void write(FILE * pOutFile, LONG indentation=0) const;

    // - Get an iterator to iterate over all entities in this block
    Iterator                iterator();

    // - Get a const iterator to iterate over all entities in this block
    ConstIterator           constIterator() const;

    // - Add a UserKeywords entry
    void           addUserKeywords(const sstring & keyword,
                                   const sstring & label = "",
                                         LONG linenumber = 0,
                                   const sstring & filename = "" );

    // - Add an Annotation
    void           addAnn(const sstring & ann,
                                LONG linenumber = 0,
                          const sstring & filename = "" );

    // - Add a STILEntity to the entity order list
    void           addEntity(STILEntity &);
    void           addEntity(Type t,
                             const sstring & name,
                             const sstring & value,
                             const sstring & label="",
                                   LONG linenumber = 0,
                             const sstring & filename = "" );

    // - Add/Get a UserStatement entry
    //const sstring & getUserStatement(const sstring & keyword) const;
    void           addUserStatement(const sstring & keyword,
                                    const sstring & value,
                                    const sstring & label = "",
                                          LONG linenumber = 0,
                                    const sstring & filename = "" );

    // - Add/Get a UserBlock
    //const sstring & getUserBlock(const sstring & keyword) const;
    void           addUserBlock(const sstring & keyword,
                                const sstring & value,
                                const sstring & label = "",
                                      LONG linenumber = 0,
                                const sstring & filename = "" );

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

    //----------------------- protected members ------------------------------
    // Ordered list of entities in this block.  This list is just a list of
    // pointers to the ordered set of entities.  The simple entities are
    // actually stored in the next list declared in this class
    // "simple_entity_list".  The complex entities are stored in the
    // derived class which contains them.
    std::list<STILEntity *>  m_entityList;

    // List of simple entities which are allocated by calls to the
    // addEntity member functions which has the simple entity data elements.
    // NOTE: Complex entities are actually stored in the derived class
    // which contains them
    std::list<STILEntity>    m_simpleEntityList;

    // List of entity objects for which a copy at the base class level
    // has occured so entries were put into this list (and pointed to by
    // the regular list of entity pointers) which have the linenumber field
    // marked to indicate as objects which currently have a bad copy
    std::list<STILEntity>    m_badCopyEntityList;


}; // end STILBlock class

//----------------------------- inline functions -----------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void             STILBlock::addUserStatement(const sstring & k,
                                                    const sstring & v,
                                                    const sstring & l,
                                                          LONG     ln,
                                                    const sstring & fn) {
  addEntity(UserStatement,k,v,l,ln,fn);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void             STILBlock::addUserKeywords(const sstring & k,
                                                   const sstring & l,
                                                         LONG     ln,
                                                   const sstring & fn) {
  addEntity(UserKeywords,"UserKeywords",k,l,ln,fn);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void             STILBlock::addUserBlock(const sstring & k,
                                                const sstring & v,
                                                const sstring & l,
                                                      LONG     ln,
                                                const sstring & fn) {
  addEntity(UserBlock,k,v,l,ln,fn);
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
inline void             STILBlock::addAnn(const sstring & ann,
                                                LONG     ln,
                                          const sstring & fn) {
  addEntity(Ann,"Ann",ann,"",ln,fn);
}





#endif

---

This page last updated on 6 Jul 2007