Cell.hpp

Go to the documentation of this file.

// Torc - Copyright 2011-2013 University of Southern California.  All Rights Reserved.
// $HeadURL$
// $Id$

// 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_CELL_HPP
#define TORC_GENERIC_CELL_HPP

//BOOST
#ifdef GENOM_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif //GENOM_SERIALIZATION
#include "torc/generic/PointerTypes.hpp"
#include "torc/generic/Commentable.hpp"
#include "torc/generic/Error.hpp"
#include "torc/generic/Extern.hpp"
#include "torc/generic/FactoryType.hpp"
#include "torc/generic/Nameable.hpp"
#include "torc/generic/ParameterMap.hpp"
#include "torc/generic/ParentedObject.hpp"
#include "torc/generic/PropertyContainer.hpp"
#include "torc/generic/Renamable.hpp"
#include "torc/generic/SelfReferencing.hpp"
#include "torc/generic/Visitable.hpp"
#include "torc/generic/VisitorType.hpp"
#include "torc/generic/UserDataContainer.hpp"
#include "torc/generic/StatusContainer.hpp"

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

namespace torc {
namespace generic {

/**
 * @brief Represents an EDIF cell
 *
 * The Cell class is used to implement an EDIF cell object. It contains the different views of a
 * cell. A cell can be concrete or extern (black-box).
 *
 * @note  Currently parser performs semantic checks for GENERIC type only. Programattic creation
 * may be achieved. However, a warning may be emitted when cell type is set to TIE or RIPPER.
 */
class Cell : public Commentable, public Extern, public Nameable, public ParentedObject<Library>,
    public PropertyContainer, public Renamable, public Visitable, public SelfReferencing<Cell>,
    public UserDataContainer, public StatusContainer {
#ifdef GENOM_SERIALIZATION
    friend class boost::serialization::access;
    friend class RestoredCellUpdater;
#endif

    friend class FactoryType<Cell> ;

public:
    /**
     * @enum Type
     *
     * Type of cell.
     */
    enum Type {
        eTypeTie = 0, eTypeRipper, eTypeGeneric
    };

    /**
     * Convenience class to visit a Cell.
     */
    typedef VisitorType<Cell> Visitor;

    /**
     * Convenience class to create a cell.
     */
    class Factory : public FactoryType<Cell> {
    public:
        using FactoryType<Cell>::create;
        /**
         * Create a cell
         *
         * @param[in] inName Name of the cell to be created.
         * @param[in] inLibraryPtr Pointer to parented(Library) object.
         * @param[in] inCellType Cell Type.
         * @param[in] inOriginalName Original name of the cell [optional].
         *
         * @return Pointer to created cell.
         **/
        virtual CellSharedPtr newCellPtr(const std::string& inName,
            const LibrarySharedPtr& inLibraryPtr, const Cell::Type& inCellType = Cell::eTypeGeneric,
            const std::string& inOriginalName = std::string()) throw (Error);
    };

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

    /**
     * Get the type of cell
     *
     * @return Type of cell
     */
    inline const Type getType() const;

    /**
     * Set the type of cell
     *
     * @param[in] inSource Type of cell
     */
    void setType(const Type& inSource);

    /**
     * Add a view to the list of views. An empty pointer will be ignored.
     * If an view already exists in EDIF file in same cell, parser ignores the view.
     *
     * @param[in] inView Pointer to a view.
     *
     * @exception Error Empty View type
     *       <ul>
     *         <li>
     *             Id : eMessageIdErrorEmptyItemName
     *         </li>
     *       </ul>
     *
     * @exception Error View name already exists
     *       <ul>
     *         <li>
     *             Id : eMessageIdErrorItemAlreadyExists
     *         </li>
     *       </ul>
     *
     */

    void addView(const ViewSharedPtr& inView) throw (Error);

    /**
     * Find a view by name.
     *
     * @param[in] inName Name of the cell to be found.
     *
     * @return Pointer to cell if found, empty pointer otherwise.
     *
     * @exception Error Empty Cell name
     *       <ul>
     *         <li>
     *             Id : eMessageIdErrorEmptyItemName
     *         </li>
     *         <li> Context Data
     *           <ul>
     *               <li>Cell name - <i>String</i></li>
     *           </ul>
     *         </li>
     *       </ul>
     *
     */
    ViewSharedPtr findView(const std::string& inName);

    /**
     * Remove the specified pointer from the view. Empty pointer is ignored.
     *
     * @param[in] inName name of the object to be removed
     *
     * @exception Error View is not a member of the views list.
     */
    void removeView(const std::string& inName) throw (Error);

    /**
     * Get the views of this cell.
     *
     * @param[out] outViews List of views to be appended to
     */
    inline void getViews(std::vector<ViewSharedPtr>& outViews) const;

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

    virtual ~Cell() throw ();

protected:
    Cell();

private:
#ifdef GENOM_SERIALIZATION
    template <class Archive> void serialize(Archive& ar, unsigned int);

    void restoreActions() throw (Error);
#endif //GENOM_SERIALIZATION
    Cell(const Cell& rhs);

    Cell& operator =(const Cell& rhs);

    SymTab<std::string, ViewSharedPtr> mViewSymTab;
    Type mType;
    ParameterMapSharedPtr mParameters;
};

/**
 * Get the type of cell
 *
 * @return Type of cell
 */
inline const Cell::Type Cell::getType() const {
    return mType;
}

/**
 * Get the views of this cell.
 *
 * @return A list of views of this cell.
 */
inline void Cell::getViews(std::vector<ViewSharedPtr>& outViews) const {
    mViewSymTab.getValues(outViews);
}

template <typename _Action> inline void Cell::applyOnAllViews(const _Action& action) throw (Error) {
    try {
        mViewSymTab.applyOnAll(action);
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

} // namespace generic
} // namespace torc

#endif // TORC_GENERIC_CELL_HPP