coriolis/vlsisapd/doc/dtr/Rule.dox

// -*- C++ -*-

namespace DTR {
/*! \class Rule
 *
 *  This class describes a symmetrical rule.
 *
 *  A symmetrical rule represents several type of rules:
 *   - a simple rule with only a name (e.g. transistorMinW: transistor minimum width)
 *   - a rule for a unique layer (e.g. minWidth.metal1: the minimum width for metal1 wire)
 *   - a rule associating two layers (e.g minSpace.poly.active: the minimum spacing between a poly shape and an active shape)
 *  In this last case the symmetrical characteristic is important since it implies that the value is the same if we invert the two layers : minSpacing poly vs active = minSpacing active vs poly.
 *
 *  Typical rules using no layer are:
 *  <i>transistorMinW, transsitorMaxW, transistorMinL transistorMaxL</i>
 *
 *  Typical rules using one layer are:
 *  <i>minWidth, minSpacing, minArea, minGateSpacing, minStrapEnclosure</i>
 *
 *  Typical rules using two layers are:
 *  <i>minSpacing</i>
 *
 */

/*! \fn Rule::Rule(const char* name, double value, const char* ref, const char* layer1, const char* layer2)
 *   \brief creates a new rule.
 *
 *   \param name   the name of the rule.
 *   \param value  the value of the rule.
 *   \param ref    the reference of the rule (helpful to find rule in design kit).
 *   \param layer1 the first layer.
 *   \param layer2 the second layer.
 */

/*! \fn inline const std::string& Rule::getName()
 *   \brief returns the name of the rule.
 */

/*! \fn inline const std::string& Rule::getType()
 *   \brief returns the type of the rule.
 *
 *   Rule's type allows to set a specific type for a rule especially the 'area' type to take into account that the value of the rule is to be considered in unit^2.
 */

/*! \fn inline double Rule::getValue()
 *   \brief returns the value of the rule.
 */

/*! \fn inline std::string Rule::getValueAsString()
 *   \brief returns the string corresponding to the value of the rule.
 */

/*! \fn inline const std::string& Rule::getRef()
 *   \brief returns the reference of the rule.
 */

/*! \fn inline const std::string& Rule::getLayer1()
 *   \brief returns the first layer of the rule.
 */

/*! \fn inline const std::string& Rule::getLayer2()
 *   \brief returns the second layer of the rule.
 */

/*! \fn inline void Rule::setType(const char* type)
 *   \brief sets the type of a rule.
 *
 *   \param type   the type of the rule.
 *
 *   \note By default the type of a rule is "".
 */

 /*! \class ARule
 *
 *  This class describes an asymmetrical rule.
 *
 *  An asymmetrical rule represents a two layers rule for which inverting layer1 and layer2 implies that the value of rule change.
 *  For example minimum enclosure rule is assymetrical.
 *
 *  Typical arules are:
 *  <i>minExtension, minEnclosure, minLengthEnclosure, minWidthEnclosure, lineExtension, minGateExtension, minGateEnclosure</i>
 *
 */
 
}