torc/generic/om/SimulationInfo.hpp

// Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
// $HeadURL: https://torc-isi.svn.sourceforge.net/svnroot/torc-isi/branches/staging/0.9/src/torc/generic/om/SimulationInfo.hpp $
// $Id: SimulationInfo.hpp 10 2011-10-12 18:40:16Z nsteiner $

// This program is free software: you can redistribute it and/or modify it under the terms of the 
// GNU General Public License as published by the Free Software Foundation, either version 3 of the 
// License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See 
// the GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License along with this program.  If 
// not, see <http://www.gnu.org/licenses/>.

#ifndef TORC_GENERIC_OM_SIMULATIONINFO_HPP
#define TORC_GENERIC_OM_SIMULATIONINFO_HPP

#include "torc/generic/om/PointerTypes.hpp"
#include "torc/generic/util/Error.hpp"
#include "torc/generic/om/Commentable.hpp"
#include "torc/generic/om/ParentedObject.hpp"
#include "torc/generic/om/Visitable.hpp"
#include "torc/generic/om/VisitorType.hpp"
#include "torc/generic/om/FactoryType.hpp"
#include "torc/generic/om/SelfReferencing.hpp"
#include "torc/generic/om/SymTab.hpp"
#include "torc/generic/om/UserDataContainer.hpp"

#include <list>
#include <vector>

namespace torc { namespace generic { class BaseVisitor; }  }
namespace torc { namespace generic { class Library; }  }
namespace torc { namespace generic { class LogicValue; }  } 

namespace torc {

namespace generic {

/**
 * @brief This class is used to hold all information about the logic values used 
 * within a library.
 */
class SimulationInfo : 
    public Commentable, 
    public Visitable,
    public ParentedObject<Library>, 
    public SelfReferencing<SimulationInfo>,
    public UserDataContainer {

    friend class FactoryType<SimulationInfo>;

  public:
    /**
     * Convenience typedef for visiting a simulation info
     */
    typedef VisitorType<SimulationInfo> Visitor;

    /**
     * Convenience class for creating a simulation info
     */
    class Factory: public FactoryType<SimulationInfo>
    {
        public:
            using FactoryType<SimulationInfo>::create;

        /**
         * Create a simulation info.
         *
         * @param[in] inLogicValues Vector of logic values to be appended to
         * @param[in] inLibraryPtr Pointer to parented(Library) object.
         *
         * @return Pointer to simulation info.
         **/
        virtual SimulationInfoSharedPtr
        newSimulationInfoPtr( const std::vector< LogicValueSharedPtr > & inLogicValues,
                const LibrarySharedPtr & inLibraryPtr ) throw(Error);
    };

    virtual void
    accept(BaseVisitor & inoutVisitor) throw(Error);

    /**
     * Add a logic value to the list of logic values. If an empty pointer is supplied, 
     * it returns without doing anything.
     * 
     * @param[in] inLogicValue A pointer to a logic value object.
     * 
     * @exception Error Logic value could not be added.
     */
    void 
    addLogicValue(const LogicValueSharedPtr & inLogicValue) throw(Error);

    /**
     * Find a logic value by name, in the list of logic values in simulationInfo.
     * 
     * @param[in] inName String value specifying the name of the logic value.
     * 
     * @return A pointer to the logic value if found, an empty pointer otherwise.
     */
    LogicValueSharedPtr 
    findLogicValue(const std::string & inName) throw();

    /**
     * Remove the specified logic value from the list of logic values. 
     * If an empty pointer is passed, it returns without doing anything
     * 
     * @param[in] inName name of the object to be removed
     * 
     * @exception Error Logic Value not preset in collection.
     */
    void
    removeLogicValue(const std::string &inName) throw(Error);

    /**
     * Get the list of logic values.
     *
     * @param[out] outLogicValues Vector of logic values to be appended to
     */    
    inline void 
    getLogicValues(
        std::vector< LogicValueSharedPtr > & outLogicValues) const throw();

    /**
     * Set the list of logic values.
     *
     * @param[in] inLogicValues Vector of logic values to be appended to
     */    
    void 
    setLogicValues(
        const std::vector< LogicValueSharedPtr > & inLogicValues) throw(Error);

   /**
    * Apply action on all logic values.
    * @param[in] action Action to be applied
    *
    */
    template<typename _Action>
    inline void
    applyOnAllLogicValues( const _Action &action ) throw(Error);

    virtual
    ~SimulationInfo() throw();

  protected:  
    SimulationInfo();

  private:
    SimulationInfo(const SimulationInfo & source) throw();

    SimulationInfo & 
    operator=(const SimulationInfo & source) throw();

    SymTab< std::string, LogicValueSharedPtr > mLogicValueSymTab;

};

/**
 * Get the list of logic values.
 *
 * @param[out] outLogicValues Vector of logic values to be appended to
 */    
inline void 
SimulationInfo::getLogicValues(
    std::vector< LogicValueSharedPtr > & outLogicValues) const throw() {
   mLogicValueSymTab.getValues( outLogicValues ); 
}

/**
 * Apply action on all logic values.
 * @param[in] action Action to be applied
 *
 */
template<typename _Action>
inline void
SimulationInfo::applyOnAllLogicValues( const _Action &action ) throw(Error) {
    try
    {
        mLogicValueSymTab.applyOnAll( action );
    }
    catch(Error &e)
    {
        e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
        throw;
    }
}

} // namespace torc::generic

} // namespace torc
#endif // TORC_GENERIC_OM_SIMULATIONINFO_HPP

---