GlobalObjects
Loading...
Searching...
No Matches
GloTAllSet.h
Go to the documentation of this file.
1#ifndef INC_GLOTALLSET_H
2#define INC_GLOTALLSET_H
3//-----------------------------------------------------------------------------
43//-----------------------------------------------------------------------------
44#include <list>
45#include "GloTypes.h"
46#include "GloBaseAllSet.h"
47#include "GloBasePersistent.h"
48#include "GloBase.h"
49#include "GloObjectMaker.h"
50//-----------------------------------------------------------------------------
51namespace glo
52{
53 //---------------------------------------------------------------------------
191 template < class T > class TAllSet : public BaseAllSet
192 {
193 public:
194 //============== Konstruktoren
195 //-----------------------------------------------------------------------
205 TAllSet();
206 //-----------------------------------------------------------------------
224 TAllSet( Base & rBase, bool bWithSubClasses = true );
225 //-----------------------------------------------------------------------
245 TAllSet( Base & rBase, const std::string & rsFullIndexName );
246 //-----------------------------------------------------------------------
256 virtual ~TAllSet();
257 //-----------------------------------------------------------------------
258
259 private:
260 //============== Konstruktoren
261 //-----------------------------------------------------------------------
271 TAllSet( const TAllSet & );
272 //-----------------------------------------------------------------------
273
274 public:
275 //============== Methoden
276 //-----------------------------------------------------------------------
322 int get( T *& prRetVal, EnSeekMode eMode );
323 //-----------------------------------------------------------------------
359 int get( std::shared_ptr<T> & rRetVal, EnSeekMode eMode );
360 //-----------------------------------------------------------------------
413 int get( glo::ObjID & rObjID, T *& prRetVal, EnSeekMode eMode );
414 //-----------------------------------------------------------------------
456 int get( glo::ObjID & rObjID, std::shared_ptr<T> & rRetVal, EnSeekMode eMode );
457 //-----------------------------------------------------------------------
459
487 virtual int getPersistent( BasePersistent *& prRetVal, const glo::ObjID & rObjID );
488 int get( T *& prRetVal, const glo::ObjID & rObjID );
490 //-----------------------------------------------------------------------
508 int get( std::shared_ptr<T> & rRetVal, const glo::ObjID & rObjID );
509 //-----------------------------------------------------------------------
525 virtual int getPersistent( std::shared_ptr<BasePersistent> & rRetVal,
526 const glo::ObjID & rObjID );
527 //-----------------------------------------------------------------------
579 int getOndemand( glo::TOndemand<T> *& prRetVal, EnSeekMode eMode );
580 //-----------------------------------------------------------------------
616 int getOndemand( std::shared_ptr< glo::TOndemand<T> > & rRetVal, EnSeekMode eMode );
617 //-----------------------------------------------------------------------
654 int getOndemand( glo::TOndemand<T> & rRetVal, EnSeekMode eMode );
655 //-----------------------------------------------------------------------
688 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
689 const std::string & rsIndexSearchValue,
690 EnQueryType eQuerryType );
691 //-----------------------------------------------------------------------
730 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
731 const std::string & rsFullIndexName,
732 const std::string & rsIndexSearchValue,
733 EnQueryType eQuerryType );
734 //-----------------------------------------------------------------------
778 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
779 const std::string & rsIndexName,
780 unsigned long ulIndexClassID,
781 const std::string & rsIndexSearchValue,
782 EnQueryType eQuerryType );
783 //-----------------------------------------------------------------------
824 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
825 const std::string & rsIndexSearchValue,
826 EnComparisionOp eComparisionOp );
827 //-----------------------------------------------------------------------
873 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
874 const std::string & rsFullIndexName,
875 const std::string & rsIndexSearchValue,
876 EnComparisionOp eComparisionOp );
877 //-----------------------------------------------------------------------
928 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
929 const std::string & rsIndexName,
930 unsigned long ulIndexClassID,
931 const std::string & rsIndexSearchValue,
932 EnComparisionOp eComparisionOp );
933 //-----------------------------------------------------------------------
966 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
967 const std::string & rsRangeStartIndex,
968 const std::string & rsRangeEndIndex );
969 //-----------------------------------------------------------------------
1010 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
1011 const std::string & rsFullIndexName,
1012 const std::string & rsRangeStartIndexSearchValue,
1013 const std::string & rsRangeEndIndexSearchValue );
1014 //-----------------------------------------------------------------------
1061 int getIndexedOndemands( std::vector< glo::TOndemand<T> > & rOndemandVector,
1062 const std::string & rsIndexName,
1063 unsigned long ulIndexClassID,
1064 const std::string & rsRangeStartIndexSearchValue,
1065 const std::string & rsRangeEndIndexSearchValue );
1066 //-----------------------------------------------------------------------
1119 virtual int setWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack = 0 );
1120 //-----------------------------------------------------------------------
1164 virtual int unsetWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack = 0 );
1165 //-----------------------------------------------------------------------
1166
1167 private:
1168 //============== Methoden
1169 //-----------------------------------------------------------------------
1185 void transferObjIListIntoOndemandVector( const std::vector< glo::ObjID > & rSourceContainer,
1186 std::vector< glo::TOndemand<T> > & rTargetVevtor );
1187 //-----------------------------------------------------------------------
1188
1189 //============== Operatoren
1190 //-----------------------------------------------------------------------
1200 TAllSet< T > & operator= ( const TAllSet & );
1201 //-----------------------------------------------------------------------
1202 };
1203 //---------------------------------------------------------------------------
1204 #define SUPER BaseAllSet
1205 //---------------------------------------------------------------------------
1206 template < class T >
1207 TAllSet< T >::TAllSet()
1208 : SUPER()
1209 {
1210 #ifdef _DEBUG
1211 m_strDebugInfo = "TAllSet";
1212 #endif
1213 std::shared_ptr<T> t_TempT( new T, Forgetter<T>() );
1214 SUPER::setClassIDFromTemplate( t_TempT->getGloClassID() );
1215 }
1216 //---------------------------------------------------------------------------
1217 template < class T >
1218 TAllSet< T >::TAllSet( Base & rBase, bool bWithSubClasses )
1219 : SUPER( rBase, 0, bWithSubClasses )
1220 {
1221 #ifdef _DEBUG
1222 m_strDebugInfo = "TAllSet";
1223 #endif
1224 std::shared_ptr<T> t_TempT( new T, Forgetter<T>() );
1225 SUPER::setClassIDFromTemplate( t_TempT->getGloClassID() );
1226 }
1227 //---------------------------------------------------------------------------
1228 template < class T >
1229 TAllSet< T >::TAllSet( Base & rBase, const std::string & rsFullIndexName )
1230 : SUPER( rBase, 0 )
1231 {
1232 #ifdef _DEBUG
1233 m_strDebugInfo = "TAllSet";
1234 #endif
1235 std::shared_ptr<T> t_TempT( new T, Forgetter<T>() );
1236 SUPER::setClassIDFromTemplate( t_TempT->getGloClassID() );
1237 int t_iErr = SUPER::setFullIndexName( rsFullIndexName );
1238 if ( t_iErr )
1239 {
1240 throw eut::ErrorNException( "TAllSet::setBase(Base * pBase, unsigned long ulClassID, const std::string & rsFullIndexName)", t_iErr, __FILE__, __LINE__ );
1241 }
1242 }
1243 //---------------------------------------------------------------------------
1244 template < class T >
1245 TAllSet< T >::~TAllSet()
1246 {
1247 }
1248 //---------------------------------------------------------------------------
1249 template < class T >
1250 int TAllSet< T >::get( T *& prRetVal, EnSeekMode eMode )
1251 {
1252 ObjID t_TempObjID;
1253 return this->get( t_TempObjID, prRetVal, eMode );
1254 }
1255 //---------------------------------------------------------------------------
1256 template < class T >
1257 int TAllSet< T >::get( std::shared_ptr<T> & rRetVal, EnSeekMode eMode )
1258 {
1259 ObjID t_TempObjID;
1260 return this->get( t_TempObjID, rRetVal, eMode );
1261 }
1262 //---------------------------------------------------------------------------
1263 template < class T >
1264 int TAllSet< T >::get( ObjID & rObjID, T *& prRetVal, EnSeekMode eMode )
1265 {
1266 int t_iErr = 0;
1267
1268 prRetVal = nullptr;
1269 t_iErr = this->open();
1270 if ( ! t_iErr )
1271 {
1272 BasePersistent * t_pGetObj = nullptr;
1273
1274 t_iErr = this->getBase()->getObjectFromAllSet( rObjID, t_pGetObj, *this, eMode );
1275 if ( ! t_iErr )
1276 {
1277 do
1278 {
1279 prRetVal = dynamic_cast<T*>( t_pGetObj );
1280 if ( ! prRetVal )
1281 {
1282 t_pGetObj->forget();
1283
1284 if ( eMode == glo::START || eMode == glo::NEXT )
1285 {
1286 t_iErr = this->getBase()->getObjectFromAllSet( rObjID, t_pGetObj, *this, glo::NEXT );
1287 }
1288 else if ( eMode == glo::END || eMode == glo::PREVIOUS )
1289 {
1290 t_iErr = this->getBase()->getObjectFromAllSet( rObjID, t_pGetObj, *this, glo::PREVIOUS );
1291 }
1292 }
1293 else
1294 {
1295 break;
1296 }
1297 } while ( ! t_iErr );
1298 }
1299 }
1300 return t_iErr;
1301 }
1302 //---------------------------------------------------------------------------
1303 template < class T >
1304 int TAllSet< T >::get( ObjID & rObjID, std::shared_ptr<T> & rRetVal, EnSeekMode eMode )
1305 {
1306 T * t_pPersistent = nullptr;
1307 int t_iErr = this->get( rObjID, t_pPersistent, eMode );
1308
1309 if ( t_pPersistent )
1310 {
1311 rRetVal = std::shared_ptr<T>( t_pPersistent, Forgetter<T>() );
1312 }
1313 else
1314 {
1315 rRetVal.reset();
1316 }
1317 return t_iErr;
1318 }
1319 //---------------------------------------------------------------------------
1320 template < class T >
1321 int TAllSet< T >::getPersistent( BasePersistent *& prRetVal, const ObjID & rObjID )
1322 {
1323 int t_iErr = 0;
1324
1325 prRetVal = nullptr;
1326 if ( ! this->getBase() ) return ERR_NO_BASE;
1327 //if ( this->getBase()->objIDInAllSet( rObjID, *this ) )
1328 //{
1329 t_iErr = this->getBase()->getAnObject( prRetVal, rObjID );
1330 //}
1331 //else
1332 //{
1333 // return ERR_OBJID_NOT_IN_ALLSET;
1334 //}
1335 return t_iErr;
1336 }
1337 //---------------------------------------------------------------------------
1338 template < class T >
1339 int TAllSet< T >::get( T *& prRetVal, const ObjID & rObjID )
1340 {
1341 int t_iErr = 0;
1342
1343 prRetVal = nullptr;
1344 t_iErr = this->open();
1345 if ( ! t_iErr )
1346 {
1347 BasePersistent * t_pReceivedObject = nullptr;
1348 //if ( this->getBase()->objIDInAllSet( rObjID, *this ) )
1349 //{
1350 t_iErr = this->getBase()->getAnObject( t_pReceivedObject, rObjID );
1351 if ( ! t_iErr )
1352 {
1353 prRetVal = dynamic_cast<T*>( t_pReceivedObject );
1354 if ( ! prRetVal )
1355 {
1356 t_pReceivedObject->forget();
1357 t_iErr = ERR_WRONG_TYPE;
1358 }
1359 }
1360 //}
1361 //else
1362 //{
1363 // return ERR_OBJID_NOT_IN_ALLSET;
1364 //}
1365 }
1366 return t_iErr;
1367 }
1368 //---------------------------------------------------------------------------
1369 template < class T >
1370 int TAllSet< T >::get( std::shared_ptr<T> & rRetVal, const ObjID & rObjID )
1371 {
1372 T * t_pPersistent = nullptr;
1373 int t_iErr = this->get( t_pPersistent, rObjID );
1374
1375 if ( t_pPersistent )
1376 {
1377 rRetVal = std::shared_ptr<T>( t_pPersistent, Forgetter<T>() );
1378 }
1379 else
1380 {
1381 rRetVal.reset();
1382 }
1383 return t_iErr;
1384 }
1385 //---------------------------------------------------------------------------
1386 template < class T >
1387 int TAllSet< T >::getPersistent( std::shared_ptr<BasePersistent> & rRetVal,
1388 const ObjID & rObjID )
1389 {
1390 return SUPER::getPersistent( rRetVal, rObjID );
1391 }
1392 //---------------------------------------------------------------------------
1393 template < class T >
1394 int TAllSet< T >::getOndemand( TOndemand<T> *& prRetVal, EnSeekMode eMode )
1395 {
1396 int t_iErr = 0;
1397
1398 t_iErr = this->open();
1399 if ( ! t_iErr )
1400 {
1401 ObjID t_ObjID;
1402
1403 t_iErr = this->getBase()->getObjIdFromAllSet( t_ObjID, *this, eMode );
1404 if ( ! t_iErr )
1405 {
1406 // Erfragen, ob ObjID-Klasse hier verarbeitbar
1407 bool t_bIsKnownClassID = false;
1408
1409 t_iErr = this->getBase()->isKnownClassID( t_bIsKnownClassID, t_ObjID.getClassID() );
1410 if ( ! t_iErr )
1411 {
1412 if ( ! t_bIsKnownClassID )
1413 {
1414 // Unbekannte Klasse! Auch OK, dann nächstes oder vorheriges Objekt
1415 if ( eMode == START || eMode == NEXT )
1416 {
1417 t_iErr = this->getOndemand( prRetVal, NEXT );
1418 }
1419 else if ( eMode == END || eMode == PREVIOUS )
1420 {
1421 t_iErr = this->getOndemand( prRetVal, PREVIOUS );
1422 }
1423 }
1424 else
1425 {
1426 prRetVal = new TOndemand<T>( t_ObjID, * this->getBase() );
1427 }
1428 }
1429 }
1430 }
1431 return t_iErr;
1432 }
1433 //---------------------------------------------------------------------------
1434 template < class T >
1435 int TAllSet< T >::getOndemand( std::shared_ptr< TOndemand<T> > & rRetVal, EnSeekMode eMode )
1436 {
1437 TOndemand<T> * t_pTempGloTOndemand = nullptr;
1438 int t_iErr = this->getOndemand( t_pTempGloTOndemand, eMode );
1439
1440 if ( t_pTempGloTOndemand )
1441 {
1442 rRetVal = std::shared_ptr<T>( t_pTempGloTOndemand );
1443 }
1444 else
1445 {
1446 rRetVal.reset();
1447 }
1448 return t_iErr;
1449 }
1450 //---------------------------------------------------------------------------
1451 template < class T >
1452 int TAllSet< T >::getOndemand( TOndemand<T> & rRetVal, EnSeekMode eMode )
1453 {
1454 TOndemand<T> * t_pTempGloTOndemand = nullptr;
1455 int t_iErr = this->getOndemand( t_pTempGloTOndemand, eMode );
1456
1457 if ( t_pTempGloTOndemand )
1458 {
1459 rRetVal = * t_pTempGloTOndemand;
1460 delete t_pTempGloTOndemand;
1461 }
1462 return t_iErr;
1463 }
1464 //---------------------------------------------------------------------------
1465 template < class T >
1466 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1467 const std::string & rsIndexSearchValue,
1468 EnQueryType eQuerryType )
1469 {
1470 int t_iErr = 0;
1471 std::vector< ObjID > t_ObjIDContainer;
1472
1473 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1474 rsIndexSearchValue,
1475 eQuerryType );
1476 if ( ! t_iErr )
1477 {
1478 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1479 }
1480 return t_iErr;
1481 }
1482 //---------------------------------------------------------------------------
1483 template < class T >
1484 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1485 const std::string & rsFullIndexName,
1486 const std::string & rsIndexSearchValue,
1487 EnQueryType eQuerryType )
1488 {
1489 int t_iErr = 0;
1490 std::vector< ObjID > t_ObjIDContainer;
1491
1492 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1493 rsFullIndexName,
1494 rsIndexSearchValue,
1495 eQuerryType );
1496 if ( ! t_iErr )
1497 {
1498 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1499 }
1500 return t_iErr;
1501 }
1502 //---------------------------------------------------------------------------
1503 template < class T >
1504 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1505 const std::string & rsIndexName,
1506 unsigned long ulIndexClassID,
1507 const std::string & rsIndexSearchValue,
1508 EnQueryType eQuerryType )
1509 {
1510 int t_iErr = 0;
1511 std::vector< ObjID > t_ObjIDContainer;
1512
1513 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1514 rsIndexName,
1515 ulIndexClassID,
1516 rsIndexSearchValue,
1517 eQuerryType );
1518 if ( ! t_iErr )
1519 {
1520 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1521 }
1522 return t_iErr;
1523 }
1524 //---------------------------------------------------------------------------
1525 template < class T >
1526 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1527 const std::string & rsIndexSearchValue,
1528 EnComparisionOp eComparisionOp )
1529 {
1530 int t_iErr = 0;
1531 std::vector< ObjID > t_ObjIDContainer;
1532
1533 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1534 rsIndexSearchValue,
1535 eComparisionOp );
1536
1537 if ( ! t_iErr )
1538 {
1539 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1540 }
1541 return t_iErr;
1542 }
1543 //---------------------------------------------------------------------------
1544 template < class T >
1545 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1546 const std::string & rsFullIndexName,
1547 const std::string & rsIndexSearchValue,
1548 EnComparisionOp eComparisionOp )
1549 {
1550 int t_iErr = 0;
1551 std::vector< ObjID > t_ObjIDContainer;
1552
1553 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1554 rsFullIndexName,
1555 rsIndexSearchValue,
1556 eComparisionOp );
1557
1558 if ( ! t_iErr )
1559 {
1560 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1561 }
1562 return t_iErr;
1563 }
1564 //---------------------------------------------------------------------------
1565 template < class T >
1566 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1567 const std::string & rsIndexName,
1568 unsigned long ulIndexClassID,
1569 const std::string & rsIndexSearchValue,
1570 EnComparisionOp eComparisionOp )
1571 {
1572 int t_iErr = 0;
1573 std::vector< ObjID > t_ObjIDContainer;
1574
1575 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1576 rsIndexName,
1577 ulIndexClassID,
1578 rsIndexSearchValue,
1579 eComparisionOp );
1580
1581 if ( ! t_iErr )
1582 {
1583 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1584 }
1585 return t_iErr;
1586 }
1587 //---------------------------------------------------------------------------
1588 template < class T >
1589 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1590 const std::string & rsRangeStartIndex,
1591 const std::string & rsRangeEndIndex )
1592 {
1593 int t_iErr = 0;
1594 std::vector< ObjID > t_ObjIDContainer;
1595
1596 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1597 rsRangeStartIndex,
1598 rsRangeEndIndex );
1599
1600 if ( ! t_iErr )
1601 {
1602 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1603 }
1604 return t_iErr;
1605 }
1606 //---------------------------------------------------------------------------
1607 template < class T >
1608 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1609 const std::string & rsFullIndexName,
1610 const std::string & rsRangeStartIndexSearchValue,
1611 const std::string & rsRangeEndIndexSearchValue )
1612 {
1613 int t_iErr = 0;
1614 std::vector< ObjID > t_ObjIDContainer;
1615
1616 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1617 rsFullIndexName,
1618 rsRangeStartIndexSearchValue,
1619 rsRangeEndIndexSearchValue );
1620
1621 if ( ! t_iErr )
1622 {
1623 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1624 }
1625 return t_iErr;
1626 }
1627 //---------------------------------------------------------------------------
1628 template < class T >
1629 int TAllSet< T >::getIndexedOndemands( std::vector< TOndemand<T> > & rOndemandVector,
1630 const std::string & rsIndexName,
1631 unsigned long ulIndexClassID,
1632 const std::string & rsRangeStartIndexSearchValue,
1633 const std::string & rsRangeEndIndexSearchValue )
1634 {
1635 int t_iErr = 0;
1636 std::vector< ObjID > t_ObjIDContainer;
1637
1638 t_iErr = this->getIndexedObjIds( t_ObjIDContainer,
1639 rsIndexName,
1640 ulIndexClassID,
1641 rsRangeStartIndexSearchValue,
1642 rsRangeEndIndexSearchValue );
1643
1644 if ( ! t_iErr )
1645 {
1646 this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
1647 }
1648 return t_iErr;
1649 }
1650 //---------------------------------------------------------------------------
1651 template < class T >
1652 int TAllSet< T >::setWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack )
1653 {
1654 int t_iErr = this->open();
1655
1656 if ( ! t_iErr )
1657 {
1658 if ( ! this->getBase()->getObjectMaker() ) t_iErr = ERR_BASE_NOT_OPEN;
1659 if ( ! t_iErr )
1660 {
1661 if ( ! pCallBack )
1662 {
1663 TAllSet< T > * t_pConstCastThis = const_cast<TAllSet< T >*>( this );
1664
1665 pCallBack = t_pConstCastThis;
1666 }
1667 t_iErr = this->getBase()->setWatchClass( this->getBase()->getObjectMaker()->getClassID( this ),
1668 ulWatchMode,
1669 pCallBack );
1670 }
1671 }
1672 return t_iErr;
1673 }
1674 //---------------------------------------------------------------------------
1675 template < class T >
1676 int TAllSet< T >::unsetWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack )
1677 {
1678 if ( ! this->getBase() ) return ERR_NO_BASE;
1679 if ( ! this->getBase()->getObjectMaker() ) return ERR_BASE_NOT_OPEN;
1680
1681 if ( ! pCallBack )
1682 {
1683 TAllSet< T > * t_pConstCastThis = const_cast<TAllSet< T >*>( this );
1684
1685 pCallBack = t_pConstCastThis;
1686 }
1687 return this->getBase()->unsetWatchClass( this->getBase()->getObjectMaker()->getClassID( this ),
1688 ulWatchMode, pCallBack );
1689 }
1690 //---------------------------------------------------------------------------
1691 template < class T >
1692 void TAllSet< T >::transferObjIListIntoOndemandVector( const std::vector< glo::ObjID > & rSourceContainer,
1693 std::vector< TOndemand<T> > & rTargetVevtor )
1694 {
1695 for ( std::vector<ObjID>::const_iterator t_Iterator = rSourceContainer.begin();
1696 t_Iterator != rSourceContainer.end();
1697 ++t_Iterator )
1698 {
1699 rTargetVevtor.push_back( TOndemand<T>( * t_Iterator, * this->getBase() ) );
1700 }
1701 }
1702 //---------------------------------------------------------------------------
1703 #undef SUPER
1704 //---------------------------------------------------------------------------
1705} // namespace glo
1706#endif
GloBase.h
Header for Base
GloBaseAllSet.h
Header for BaseAllSet
GloBasePersistent.h
Header for BasePersistent
GloObjectMaker.h
Header for ObjectMaker
SUPER
#define SUPER
Definition GloTAllSet.h:1204
GloTypes.h
For each library, here 'GlobalObjects' there is a type file.
eut::ErrorNException
This exception class has an integer attribute for an error number in addition to the message.
Definition EuException.h:73
glo::BaseAllSet
Is the base class of template AllSets and the generic AllSet.
Definition GloBaseAllSet.h:87
glo::Base
Definition GloBase.h:263
glo::BasePersistent
Abstract base class for Persistent and the generic GenericPersistent.
Definition GloBasePersistent.h:124
glo::BasePersistent::forget
virtual unsigned int forget()
glo::CallBack
Superclass for the classes that are 'connected' to a Base.
Definition GloCallBack.h:81
glo::CallBack::m_strDebugInfo
std::string m_strDebugInfo
Definition GloCallBack.h:111
glo::Forgetter
Especially for GenericPersistent or derived classes of Persistent the Forget method for std::shared_p...
Definition GloTypes.h:1234
glo::ObjID
An object ID consists of the class ID, a database ID and the actual unique object number (all unsigne...
Definition GloObjID.h:84
glo::ObjID::getClassID
unsigned long getClassID() const
glo::TAllSet
AllSet, which returns objects from the database.
Definition GloTAllSet.h:192
glo::TAllSet::getPersistent
virtual int getPersistent(BasePersistent *&prRetVal, const glo::ObjID &rObjID)
Returns an object from the AllSet of the database with passed object ID.
Definition GloTAllSet.h:1321
glo::TAllSet::get
int get(T *&prRetVal, EnSeekMode eMode)
Definition GloTAllSet.h:1250
glo::TAllSet::TAllSet
TAllSet()
Definition GloTAllSet.h:1207
glo::TAllSet::setWatch
virtual int setWatch(TdWatchNotifyMode ulWatchMode, CallBack *pCallBack=0)
Definition GloTAllSet.h:1652
glo::TAllSet::TAllSet
TAllSet(const TAllSet &)
glo::TAllSet::~TAllSet
virtual ~TAllSet()
Definition GloTAllSet.h:1245
glo::TAllSet::unsetWatch
virtual int unsetWatch(TdWatchNotifyMode ulWatchMode, CallBack *pCallBack=0)
Definition GloTAllSet.h:1676
glo::TAllSet::transferObjIListIntoOndemandVector
void transferObjIListIntoOndemandVector(const std::vector< glo::ObjID > &rSourceContainer, std::vector< glo::TOndemand< T > > &rTargetVevtor)
Definition GloTAllSet.h:1692
glo::TAllSet::operator=
TAllSet< T > & operator=(const TAllSet &)
glo::TAllSet::getOndemand
int getOndemand(glo::TOndemand< T > *&prRetVal, EnSeekMode eMode)
Definition GloTAllSet.h:1394
glo::TAllSet::getIndexedOndemands
int getIndexedOndemands(std::vector< glo::TOndemand< T > > &rOndemandVector, const std::string &rsIndexSearchValue, EnQueryType eQuerryType)
Definition GloTAllSet.h:1466
glo::TOndemand
A reference (as attribute) of a persistent object to another persistent object in the database.
Definition GloTOndemand.h:102
glo
Definition GloAbstractBaseLot.h:49
glo::ERR_NO_BASE
@ ERR_NO_BASE
Definition GloErrors.h:584
glo::ERR_BASE_NOT_OPEN
@ ERR_BASE_NOT_OPEN
Definition GloErrors.h:617
glo::ERR_WRONG_TYPE
@ ERR_WRONG_TYPE
Definition GloErrors.h:551
glo::EnComparisionOp
EnComparisionOp
Definition GloTypes.h:1567
glo::EnSeekMode
EnSeekMode
Definition GloTypes.h:173
glo::END
@ END
Definition GloTypes.h:195
glo::START
@ START
Definition GloTypes.h:184
glo::PREVIOUS
@ PREVIOUS
Definition GloTypes.h:228
glo::NEXT
@ NEXT
Definition GloTypes.h:217
glo::EnQueryType
EnQueryType
Definition GloTypes.h:1164
glo::TdWatchNotifyMode
unsigned long TdWatchNotifyMode
Definition GloTypes.h:558