187 inline ConstMap<K, Const<V, v> > constMap() { |
187 inline ConstMap<K, Const<V, v> > constMap() { |
188 return ConstMap<K, Const<V, v> >(); |
188 return ConstMap<K, Const<V, v> >(); |
189 } |
189 } |
190 |
190 |
191 |
191 |
192 /// \brief Identity map. |
192 /// Identity map. |
193 /// |
193 |
194 /// This map gives back the given key as value without any |
194 /// This \ref concepts::ReadMap "read-only map" gives back the given |
195 /// modification. |
195 /// key as value without any modification. |
196 /// |
196 /// |
197 /// \sa ConstMap |
197 /// \sa ConstMap |
198 template <typename T> |
198 template <typename T> |
199 class IdentityMap : public MapBase<T, T> { |
199 class IdentityMap : public MapBase<T, T> { |
200 public: |
200 public: |
201 typedef MapBase<T, T> Parent; |
201 typedef MapBase<T, T> Parent; |
202 typedef typename Parent::Key Key; |
202 typedef typename Parent::Key Key; |
203 typedef typename Parent::Value Value; |
203 typedef typename Parent::Value Value; |
204 |
204 |
205 /// Gives back the given value without any modification. |
205 /// Gives back the given value without any modification. |
206 const T& operator[](const T& t) const { |
206 Value operator[](const Key &k) const { |
207 return t; |
207 return k; |
208 } |
208 } |
209 }; |
209 }; |
210 |
210 |
211 /// Returns an \ref IdentityMap class |
211 /// Returns an \ref IdentityMap class |
212 |
212 |
1309 template<typename M> |
1309 template<typename M> |
1310 inline AbsMap<M> absMap(const M &m) { |
1310 inline AbsMap<M> absMap(const M &m) { |
1311 return AbsMap<M>(m); |
1311 return AbsMap<M>(m); |
1312 } |
1312 } |
1313 |
1313 |
|
1314 /// @} |
|
1315 |
|
1316 // Logical maps and map adaptors: |
|
1317 |
|
1318 /// \addtogroup maps |
|
1319 /// @{ |
|
1320 |
|
1321 /// Constant \c true map. |
|
1322 |
|
1323 /// This \ref concepts::ReadMap "read-only map" assigns \c true to |
|
1324 /// each key. |
|
1325 /// |
|
1326 /// Note that |
|
1327 /// \code |
|
1328 /// TrueMap<K> tm; |
|
1329 /// \endcode |
|
1330 /// is equivalent to |
|
1331 /// \code |
|
1332 /// ConstMap<K,bool> tm(true); |
|
1333 /// \endcode |
|
1334 /// |
|
1335 /// \sa FalseMap |
|
1336 /// \sa ConstMap |
|
1337 template <typename K> |
|
1338 class TrueMap : public MapBase<K, bool> { |
|
1339 public: |
|
1340 typedef MapBase<K, bool> Parent; |
|
1341 typedef typename Parent::Key Key; |
|
1342 typedef typename Parent::Value Value; |
|
1343 |
|
1344 /// Gives back \c true. |
|
1345 Value operator[](const Key&) const { return true; } |
|
1346 }; |
|
1347 |
|
1348 /// Returns a \ref TrueMap class |
|
1349 |
|
1350 /// This function just returns a \ref TrueMap class. |
|
1351 /// \relates TrueMap |
|
1352 template<typename K> |
|
1353 inline TrueMap<K> trueMap() { |
|
1354 return TrueMap<K>(); |
|
1355 } |
|
1356 |
|
1357 |
|
1358 /// Constant \c false map. |
|
1359 |
|
1360 /// This \ref concepts::ReadMap "read-only map" assigns \c false to |
|
1361 /// each key. |
|
1362 /// |
|
1363 /// Note that |
|
1364 /// \code |
|
1365 /// FalseMap<K> fm; |
|
1366 /// \endcode |
|
1367 /// is equivalent to |
|
1368 /// \code |
|
1369 /// ConstMap<K,bool> fm(false); |
|
1370 /// \endcode |
|
1371 /// |
|
1372 /// \sa TrueMap |
|
1373 /// \sa ConstMap |
|
1374 template <typename K> |
|
1375 class FalseMap : public MapBase<K, bool> { |
|
1376 public: |
|
1377 typedef MapBase<K, bool> Parent; |
|
1378 typedef typename Parent::Key Key; |
|
1379 typedef typename Parent::Value Value; |
|
1380 |
|
1381 /// Gives back \c false. |
|
1382 Value operator[](const Key&) const { return false; } |
|
1383 }; |
|
1384 |
|
1385 /// Returns a \ref FalseMap class |
|
1386 |
|
1387 /// This function just returns a \ref FalseMap class. |
|
1388 /// \relates FalseMap |
|
1389 template<typename K> |
|
1390 inline FalseMap<K> falseMap() { |
|
1391 return FalseMap<K>(); |
|
1392 } |
|
1393 |
|
1394 /// @} |
|
1395 |
|
1396 /// \addtogroup map_adaptors |
|
1397 /// @{ |
|
1398 |
|
1399 /// Logical 'and' of two maps |
|
1400 |
|
1401 /// This \ref concepts::ReadMap "read-only map" returns the logical |
|
1402 /// 'and' of the values of the two given maps. |
|
1403 /// Its \c Key type is inherited from \c M1 and its \c Value type is |
|
1404 /// \c bool. \c M2::Key must be convertible to \c M1::Key. |
|
1405 /// |
|
1406 /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for |
|
1407 /// \code |
|
1408 /// AndMap<M1,M2> am(m1,m2); |
|
1409 /// \endcode |
|
1410 /// <tt>am[x]</tt> will be equal to <tt>m1[x]&&m2[x]</tt>. |
|
1411 /// |
|
1412 /// The simplest way of using this map is through the andMap() |
|
1413 /// function. |
|
1414 /// |
|
1415 /// \sa OrMap |
|
1416 /// \sa NotMap, NotWriteMap |
|
1417 template<typename M1, typename M2> |
|
1418 class AndMap : public MapBase<typename M1::Key, bool> { |
|
1419 const M1 &_m1; |
|
1420 const M2 &_m2; |
|
1421 public: |
|
1422 typedef MapBase<typename M1::Key, bool> Parent; |
|
1423 typedef typename Parent::Key Key; |
|
1424 typedef typename Parent::Value Value; |
|
1425 |
|
1426 /// Constructor |
|
1427 AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} |
|
1428 /// \e |
|
1429 Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; } |
|
1430 }; |
|
1431 |
|
1432 /// Returns an \ref AndMap class |
|
1433 |
|
1434 /// This function just returns an \ref AndMap class. |
|
1435 /// |
|
1436 /// For example, if \c m1 and \c m2 are both maps with \c bool values, |
|
1437 /// then <tt>andMap(m1,m2)[x]</tt> will be equal to |
|
1438 /// <tt>m1[x]&&m2[x]</tt>. |
|
1439 /// |
|
1440 /// \relates AndMap |
|
1441 template<typename M1, typename M2> |
|
1442 inline AndMap<M1, M2> andMap(const M1 &m1, const M2 &m2) { |
|
1443 return AndMap<M1, M2>(m1,m2); |
|
1444 } |
|
1445 |
|
1446 |
|
1447 /// Logical 'or' of two maps |
|
1448 |
|
1449 /// This \ref concepts::ReadMap "read-only map" returns the logical |
|
1450 /// 'or' of the values of the two given maps. |
|
1451 /// Its \c Key type is inherited from \c M1 and its \c Value type is |
|
1452 /// \c bool. \c M2::Key must be convertible to \c M1::Key. |
|
1453 /// |
|
1454 /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for |
|
1455 /// \code |
|
1456 /// OrMap<M1,M2> om(m1,m2); |
|
1457 /// \endcode |
|
1458 /// <tt>om[x]</tt> will be equal to <tt>m1[x]||m2[x]</tt>. |
|
1459 /// |
|
1460 /// The simplest way of using this map is through the orMap() |
|
1461 /// function. |
|
1462 /// |
|
1463 /// \sa AndMap |
|
1464 /// \sa NotMap, NotWriteMap |
|
1465 template<typename M1, typename M2> |
|
1466 class OrMap : public MapBase<typename M1::Key, bool> { |
|
1467 const M1 &_m1; |
|
1468 const M2 &_m2; |
|
1469 public: |
|
1470 typedef MapBase<typename M1::Key, bool> Parent; |
|
1471 typedef typename Parent::Key Key; |
|
1472 typedef typename Parent::Value Value; |
|
1473 |
|
1474 /// Constructor |
|
1475 OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} |
|
1476 /// \e |
|
1477 Value operator[](const Key &k) const { return _m1[k]||_m2[k]; } |
|
1478 }; |
|
1479 |
|
1480 /// Returns an \ref OrMap class |
|
1481 |
|
1482 /// This function just returns an \ref OrMap class. |
|
1483 /// |
|
1484 /// For example, if \c m1 and \c m2 are both maps with \c bool values, |
|
1485 /// then <tt>orMap(m1,m2)[x]</tt> will be equal to |
|
1486 /// <tt>m1[x]||m2[x]</tt>. |
|
1487 /// |
|
1488 /// \relates OrMap |
|
1489 template<typename M1, typename M2> |
|
1490 inline OrMap<M1, M2> orMap(const M1 &m1, const M2 &m2) { |
|
1491 return OrMap<M1, M2>(m1,m2); |
|
1492 } |
|
1493 |
1314 |
1494 |
1315 /// Logical 'not' of a map |
1495 /// Logical 'not' of a map |
1316 |
1496 |
1317 /// This \ref concepts::ReadMap "read only map" returns the logical |
1497 /// This \ref concepts::ReadMap "read-only map" returns the logical |
1318 /// negation of the values of the given map. |
1498 /// negation of the values of the given map. |
1319 /// Its \c Key is inherited from \c M and its \c Value is \c bool. |
1499 /// Its \c Key is inherited from \c M and its \c Value is \c bool. |
1320 /// |
1500 /// |
1321 /// The simplest way of using this map is through the notMap() |
1501 /// The simplest way of using this map is through the notMap() |
1322 /// function. |
1502 /// function. |
1389 template <typename M> |
1569 template <typename M> |
1390 inline NotWriteMap<M> notWriteMap(M &m) { |
1570 inline NotWriteMap<M> notWriteMap(M &m) { |
1391 return NotWriteMap<M>(m); |
1571 return NotWriteMap<M>(m); |
1392 } |
1572 } |
1393 |
1573 |
|
1574 |
|
1575 /// Combination of two maps using the \c == operator |
|
1576 |
|
1577 /// This \ref concepts::ReadMap "read-only map" assigns \c true to |
|
1578 /// the keys for which the corresponding values of the two maps are |
|
1579 /// equal. |
|
1580 /// Its \c Key type is inherited from \c M1 and its \c Value type is |
|
1581 /// \c bool. \c M2::Key must be convertible to \c M1::Key. |
|
1582 /// |
|
1583 /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for |
|
1584 /// \code |
|
1585 /// EqualMap<M1,M2> em(m1,m2); |
|
1586 /// \endcode |
|
1587 /// <tt>em[x]</tt> will be equal to <tt>m1[x]==m2[x]</tt>. |
|
1588 /// |
|
1589 /// The simplest way of using this map is through the equalMap() |
|
1590 /// function. |
|
1591 /// |
|
1592 /// \sa LessMap |
|
1593 template<typename M1, typename M2> |
|
1594 class EqualMap : public MapBase<typename M1::Key, bool> { |
|
1595 const M1 &_m1; |
|
1596 const M2 &_m2; |
|
1597 public: |
|
1598 typedef MapBase<typename M1::Key, bool> Parent; |
|
1599 typedef typename Parent::Key Key; |
|
1600 typedef typename Parent::Value Value; |
|
1601 |
|
1602 /// Constructor |
|
1603 EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} |
|
1604 /// \e |
|
1605 Value operator[](const Key &k) const { return _m1[k]==_m2[k]; } |
|
1606 }; |
|
1607 |
|
1608 /// Returns an \ref EqualMap class |
|
1609 |
|
1610 /// This function just returns an \ref EqualMap class. |
|
1611 /// |
|
1612 /// For example, if \c m1 and \c m2 are maps with keys and values of |
|
1613 /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to |
|
1614 /// <tt>m1[x]==m2[x]</tt>. |
|
1615 /// |
|
1616 /// \relates EqualMap |
|
1617 template<typename M1, typename M2> |
|
1618 inline EqualMap<M1, M2> equalMap(const M1 &m1, const M2 &m2) { |
|
1619 return EqualMap<M1, M2>(m1,m2); |
|
1620 } |
|
1621 |
|
1622 |
|
1623 /// Combination of two maps using the \c < operator |
|
1624 |
|
1625 /// This \ref concepts::ReadMap "read-only map" assigns \c true to |
|
1626 /// the keys for which the corresponding value of the first map is |
|
1627 /// less then the value of the second map. |
|
1628 /// Its \c Key type is inherited from \c M1 and its \c Value type is |
|
1629 /// \c bool. \c M2::Key must be convertible to \c M1::Key. |
|
1630 /// |
|
1631 /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for |
|
1632 /// \code |
|
1633 /// LessMap<M1,M2> lm(m1,m2); |
|
1634 /// \endcode |
|
1635 /// <tt>lm[x]</tt> will be equal to <tt>m1[x]<m2[x]</tt>. |
|
1636 /// |
|
1637 /// The simplest way of using this map is through the lessMap() |
|
1638 /// function. |
|
1639 /// |
|
1640 /// \sa EqualMap |
|
1641 template<typename M1, typename M2> |
|
1642 class LessMap : public MapBase<typename M1::Key, bool> { |
|
1643 const M1 &_m1; |
|
1644 const M2 &_m2; |
|
1645 public: |
|
1646 typedef MapBase<typename M1::Key, bool> Parent; |
|
1647 typedef typename Parent::Key Key; |
|
1648 typedef typename Parent::Value Value; |
|
1649 |
|
1650 /// Constructor |
|
1651 LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {} |
|
1652 /// \e |
|
1653 Value operator[](const Key &k) const { return _m1[k]<_m2[k]; } |
|
1654 }; |
|
1655 |
|
1656 /// Returns an \ref LessMap class |
|
1657 |
|
1658 /// This function just returns an \ref LessMap class. |
|
1659 /// |
|
1660 /// For example, if \c m1 and \c m2 are maps with keys and values of |
|
1661 /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to |
|
1662 /// <tt>m1[x]<m2[x]</tt>. |
|
1663 /// |
|
1664 /// \relates LessMap |
|
1665 template<typename M1, typename M2> |
|
1666 inline LessMap<M1, M2> lessMap(const M1 &m1, const M2 &m2) { |
|
1667 return LessMap<M1, M2>(m1,m2); |
|
1668 } |
|
1669 |
1394 /// @} |
1670 /// @} |
1395 } |
1671 } |
1396 |
1672 |
1397 #endif // LEMON_MAPS_H |
1673 #endif // LEMON_MAPS_H |