Fennel: CmdInterpreter Class Reference (original) (raw)
CmdInterpreter interprets command objects received via JNI from Farrago. More...
#include <[CmdInterpreter.h](CmdInterpreter%5F8h-source.html)>
Inheritance diagram for CmdInterpreter:
Detailed Description
CmdInterpreter interprets command objects received via JNI from Farrago.
It implements FemVisitor in order to process commands; a visit on a command results in its execution.
Definition at line 47 of file CmdInterpreter.h.
Member Function Documentation
Definition at line 79 of file CmdInterpreter.cpp.
Referenced by visit().
00081 { 00082 return reinterpret_cast<StreamGraphHandle *>(pHandle->getLongHandle()); 00083 }
Definition at line 85 of file CmdInterpreter.cpp.
Referenced by visit().
00086 { 00087 return SavepointId(pHandle->getLongHandle()); 00088 }
| void CmdInterpreter::deleteDbHandle | ( | DbHandle * | | ) | [protected] | | ----------------------------------- | - | -------------------------------------------------------- | | - | ------------- |
Definition at line 366 of file CmdInterpreter.cpp.
References ProxyIndexCmd::getIndexId(), ProxyIndexCmd::getKeyProj(), ProxyIndexCmd::getSegmentId(), ProxyIndexCmd::getTupleDesc(), ProxyTxnCmd::getTxnHandle(), getTxnHandle(), BTreeDescriptor::keyProjection, BTreeDescriptor::pageOwnerId, SegmentAccessor::pCacheAccessor, CmdInterpreter::TxnHandle::pDb, SegmentAccessor::pSegment, CmdInterpreter::TxnHandle::pSnapshotSegment, readTupleDescriptor(), readTupleProjection(), BTreeDescriptor::rootPageId, BTreeDescriptor::segmentAccessor, BTreeDescriptor::segmentId, and BTreeDescriptor::tupleDescriptor.
Referenced by dropOrTruncateIndex(), and visit().
| void CmdInterpreter::dropOrTruncateIndex | ( | ProxyCmdDropIndex & | cmd, |
|---|---|---|---|
| bool | drop | ||
| ) | [protected] |
| void CmdInterpreter::beginTxn | ( | ProxyBeginTxnCmd & | cmd, |
|---|---|---|---|
| bool | readOnly, | ||
| TxnId | csn | ||
| ) | [protected] |
Executes a begin txn command.
Parameters:
| cmd | the command |
|---|---|
| readOnly | true if the txn is read-only |
| csn | if non-null and snapshots are enabled, the commit sequence number for reads |
Definition at line 470 of file CmdInterpreter.cpp.
References ProxyDatabaseCmd::getDbHandle(), getDbHandle(), ProxyBeginTxnCmd::getResultHandle(), JniUtil::incrementHandleCount(), newTxnHandle(), NULL_TXN_ID, CmdInterpreter::DbHandle::pDb, CmdInterpreter::DbHandle::pResourceGovernor, and setTxnHandle().
Referenced by visit().
00471 {
00472 assert(readOnly || csn == NULL_TXN_ID);
00473
00474
00475 DbHandle *pDbHandle = getDbHandle(cmd.getDbHandle());
00476 SharedDatabase pDb = pDbHandle->pDb;
00477
00478 SXMutexSharedGuard actionMutexGuard(
00479 pDb->getCheckpointThread()->getActionMutex());
00480
00481 std::auto_ptr pTxnHandle(newTxnHandle());
00482 JniUtil::incrementHandleCount(TXNHANDLE_TRACE_TYPE_STR, pTxnHandle.get());
00483 pTxnHandle->pDb = pDb;
00484 pTxnHandle->readOnly = readOnly;
00485
00486 pTxnHandle->pTxn = pDb->getTxnLog()->newLogicalTxn(pDb->getCache());
00487 pTxnHandle->pResourceGovernor = pDbHandle->pResourceGovernor;
00488
00489
00490
00491 SegmentAccessor scratchAccessor;
00492
00493 pTxnHandle->pFtrsTableWriterFactory = SharedFtrsTableWriterFactory(
00494 new FtrsTableWriterFactory(
00495 pDb,
00496 pDb->getCache(),
00497 pDb->getTypeFactory(),
00498 scratchAccessor));
00499
00500
00501
00502
00503
00504 if (pDb->areSnapshotsEnabled()) {
00505 if (csn == NULL_TXN_ID) {
00506 csn = pTxnHandle->pTxn->getTxnId();
00507 }
00508 pTxnHandle->pSnapshotSegment =
00509 pDb->getSegmentFactory()->newSnapshotRandomAllocationSegment(
00510 pDb->getDataSegment(),
00511 pDb->getDataSegment(),
00512 csn,
00513 false);
00514 pTxnHandle->pReadCommittedSnapshotSegment =
00515 pDb->getSegmentFactory()->newSnapshotRandomAllocationSegment(
00516 pDb->getDataSegment(),
00517 pDb->getDataSegment(),
00518 csn,
00519 true);
00520 } else {
00521 assert(csn == NULL_TXN_ID);
00522 }
00523
00524 setTxnHandle(cmd.getResultHandle(),pTxnHandle.release());
00525 }
Reimplemented from FemVisitor.
Definition at line 648 of file CmdInterpreter.cpp.
References ProxyCmdCreateExecutionStreamGraph::getResultHandle(), ProxyTxnCmd::getTxnHandle(), getTxnHandle(), JniUtil::incrementHandleCount(), ExecStreamGraph::newExecStreamGraph(), CmdInterpreter::TxnHandle::pDb, CmdInterpreter::TxnHandle::pFtrsTableWriterFactory, CmdInterpreter::TxnHandle::pReadCommittedSnapshotSegment, CmdInterpreter::TxnHandle::pResourceGovernor, CmdInterpreter::TxnHandle::pSnapshotSegment, CmdInterpreter::TxnHandle::pTxn, and setStreamGraphHandle().
00649 {
00650 #if 0
00651 struct mallinfo minfo = mallinfo();
00652 std::cout << "Number of allocated bytes before stream graph construction = "
00653 << minfo.uordblks << " bytes" << std::endl;
00654 #endif
00655 TxnHandle *pTxnHandle = getTxnHandle(cmd.getTxnHandle());
00656 SharedDatabase pDb = pTxnHandle->pDb;
00657 SharedExecStreamGraph pGraph =
00658 ExecStreamGraph::newExecStreamGraph();
00659 pGraph->setTxn(pTxnHandle->pTxn);
00660 pGraph->setResourceGovernor(pTxnHandle->pResourceGovernor);
00661 std::auto_ptr pStreamGraphHandle(
00662 new StreamGraphHandle());
00663 JniUtil::incrementHandleCount(
00664 STREAMGRAPHHANDLE_TRACE_TYPE_STR, pStreamGraphHandle.get());
00665 pStreamGraphHandle->javaRuntimeContext = NULL;
00666 pStreamGraphHandle->pTxnHandle = pTxnHandle;
00667 pStreamGraphHandle->pExecStreamGraph = pGraph;
00668 pStreamGraphHandle->pExecStreamFactory.reset(
00669 new ExecStreamFactory(
00670 pDb,
00671 pTxnHandle->pFtrsTableWriterFactory,
00672 pStreamGraphHandle.get()));
00673
00674
00675
00676
00677 if (pDb->areSnapshotsEnabled()) {
00678 pStreamGraphHandle->pSegment =
00679 pDb->getSegmentFactory()->newDynamicDelegatingSegment(
00680 pTxnHandle->pSnapshotSegment);
00681 pStreamGraphHandle->pReadCommittedSegment =
00682 pDb->getSegmentFactory()->newDynamicDelegatingSegment(
00683 pTxnHandle->pReadCommittedSnapshotSegment);
00684 }
00685 setStreamGraphHandle(
00686 cmd.getResultHandle(),
00687 pStreamGraphHandle.release());
00688 }
Reimplemented from FemVisitor.
Definition at line 690 of file CmdInterpreter.cpp.
References ExecStreamBuilder::buildStreamGraph(), ProxyCmdPrepareExecutionStreamGraph::getDegreeOfParallelism(), ProxyTupleStreamGraphCmd::getStreamGraphHandle(), getStreamGraphHandle(), JniUtil::getThreadTracker(), CmdInterpreter::StreamGraphHandle::pExecStreamFactory, CmdInterpreter::StreamGraphHandle::pExecStreamGraph, CmdInterpreter::StreamGraphHandle::pScheduler, and CmdInterpreter::StreamGraphHandle::pTxnHandle.
00691 {
00692 StreamGraphHandle *pStreamGraphHandle = getStreamGraphHandle(
00693 cmd.getStreamGraphHandle());
00694 TxnHandle *pTxnHandle = pStreamGraphHandle->pTxnHandle;
00695
00696 SharedExecStreamScheduler pScheduler;
00697 std::string schedulerName = "xo.scheduler";
00698 if (cmd.getDegreeOfParallelism() == 1) {
00699 pScheduler.reset(
00700 new DfsTreeExecStreamScheduler(
00701 pTxnHandle->pDb->getSharedTraceTarget(),
00702 schedulerName));
00703 } else {
00704 pScheduler.reset(
00705 new ParallelExecStreamScheduler(
00706 pTxnHandle->pDb->getSharedTraceTarget(),
00707 schedulerName,
00708 JniUtil::getThreadTracker(),
00709 cmd.getDegreeOfParallelism()));
00710 }
00711 ExecStreamGraphEmbryo graphEmbryo(
00712 pStreamGraphHandle->pExecStreamGraph,
00713 pScheduler,
00714 pTxnHandle->pDb->getCache(),
00715 pTxnHandle->pDb->getSegmentFactory());
00716 pStreamGraphHandle->pExecStreamFactory->setGraphEmbryo(graphEmbryo);
00717 ExecStreamBuilder streamBuilder(
00718 graphEmbryo,
00719 *(pStreamGraphHandle->pExecStreamFactory));
00720 streamBuilder.buildStreamGraph(cmd, true);
00721 pStreamGraphHandle->pExecStreamFactory.reset();
00722 pStreamGraphHandle->pScheduler = pScheduler;
00723 #if 0
00724 struct mallinfo minfo = mallinfo();
00725 std::cout << "Number of allocated bytes after stream graph construction = "
00726 << minfo.uordblks << " bytes" << std::endl;
00727 #endif
00728 }
Reimplemented from FemVisitor.
Definition at line 412 of file CmdInterpreter.cpp.
References ProxyCmdVerifyIndex::clearResultUniqueKeyCount(), getBTreeForIndexCmd(), ProxyIndexCmd::getLeafPageIdProj(), ProxyIndexAccessCmd::getRootPageId(), BTreeVerifier::getStatistics(), ProxyTxnCmd::getTxnHandle(), getTxnHandle(), ProxyCmdVerifyIndex::isEstimate(), ProxyCmdVerifyIndex::isIncludeTuples(), BTreeStatistics::nLeafNodes, BTreeStatistics::nNonLeafNodes, BTreeStatistics::nTuples, BTreeStatistics::nUniqueKeys, CmdInterpreter::TxnHandle::pDb, readTupleProjection(), ProxyCmdVerifyIndex::setResultPageCount(), ProxyCmdVerifyIndex::setResultUniqueKeyCount(), and BTreeVerifier::verify().
Reimplemented from FemVisitor.
Definition at line 181 of file CmdInterpreter.cpp.
References ExecStreamResourceKnobs::cacheReservePercentage, JniUtil::configure(), DeviceMode::createNew, ExecStreamResourceKnobs::expectedConcurrentStatements, ConfigMap::getIntParam(), ProxyCmdOpenDatabase::getParams(), ProxyCmdOpenDatabase::getResultHandle(), JniUtil::incrementHandleCount(), ProxyCmdOpenDatabase::isCreateDatabase(), DeviceMode::load, ExecStreamResourceQuantity::nCachePages, Cache::newCache(), Database::newDatabase(), newDbHandle(), newTraceTarget(), CacheParams::nMemPagesInit, CacheParams::nMemPagesMax, JniUtilParams::readConfig(), CacheParams::readConfig(), setDbHandle(), ProxyCmdOpenDatabase::setResultRecoveryRequired(), ConfigMap::setStringParam(), AutoBacktrace::setTraceTarget(), and TRACE_WARNING.
00182 {
00183 ConfigMap configMap;
00184
00185 SharedProxyDatabaseParam pParam = cmd.getParams();
00186 for (; pParam; ++pParam) {
00187 configMap.setStringParam(pParam->getName(),pParam->getValue());
00188 }
00189
00190 CacheParams cacheParams;
00191 cacheParams.readConfig(configMap);
00192 SharedCache pCache = Cache::newCache(cacheParams);
00193
00194 JniUtilParams jniUtilParams;
00195 jniUtilParams.readConfig(configMap);
00196 JniUtil::configure(jniUtilParams);
00197
00198 DeviceMode openMode = cmd.isCreateDatabase()
00199 ? DeviceMode::createNew
00200 : DeviceMode::load;
00201
00202 std::auto_ptr pDbHandle(newDbHandle());
00203 JniUtil::incrementHandleCount(DBHANDLE_TRACE_TYPE_STR, pDbHandle.get());
00204
00205 JavaTraceTarget *pJavaTraceTarget = newTraceTarget();
00206 pDbHandle->pTraceTarget.reset(pJavaTraceTarget);
00207
00208 AutoBacktrace::setTraceTarget(pDbHandle->pTraceTarget);
00209
00210 SharedDatabase pDb;
00211 try {
00212 pDb = Database::newDatabase(
00213 pCache,
00214 configMap,
00215 openMode,
00216 pDbHandle->pTraceTarget,
00217 SharedPseudoUuidGenerator(new JniPseudoUuidGenerator()));
00218 } catch (...) {
00219 AutoBacktrace::setTraceTarget();
00220 throw;
00221 }
00222
00223 pDbHandle->pDb = pDb;
00224
00225 ExecStreamResourceKnobs knobSettings;
00226 knobSettings.cacheReservePercentage =
00227 configMap.getIntParam("cacheReservePercentage");
00228 knobSettings.expectedConcurrentStatements =
00229 configMap.getIntParam("expectedConcurrentStatements");
00230
00231 ExecStreamResourceQuantity resourcesAvailable;
00232 resourcesAvailable.nCachePages = pCache->getMaxLockedPages();
00233
00234 pDbHandle->pResourceGovernor =
00235 SharedExecStreamGovernor(
00236 new SimpleExecStreamGovernor(
00237 knobSettings, resourcesAvailable,
00238 pDbHandle->pTraceTarget,
00239 "xo.resourceGovernor"));
00240
00241 if (pDb->isRecoveryRequired()) {
00242 SegmentAccessor scratchAccessor =
00243 pDb->getSegmentFactory()->newScratchSegment(pDb->getCache());
00244 FtrsTableWriterFactory recoveryFactory(
00245 pDb,
00246 pDb->getCache(),
00247 pDb->getTypeFactory(),
00248 scratchAccessor);
00249 pDb->recover(recoveryFactory);
00250 cmd.setResultRecoveryRequired(true);
00251 } else {
00252 cmd.setResultRecoveryRequired(false);
00253 }
00254 pDbHandle->statsTimer.setTarget(*pJavaTraceTarget);
00255 pDbHandle->statsTimer.addSource(pDb);
00256 pDbHandle->statsTimer.addSource(pDbHandle->pResourceGovernor);
00257 pDbHandle->statsTimer.start();
00258
00259
00260
00261 if (pCache->getMaxAllocatedPageCount() != cacheParams.nMemPagesMax ||
00262 pCache->getAllocatedPageCount() != cacheParams.nMemPagesInit)
00263 {
00264 FENNEL_DELEGATE_TRACE(
00265 TRACE_WARNING,
00266 pDb,
00267 "Unable to allocate "
00268 << cacheParams.nMemPagesInit
00269 << " (of "
00270 << cacheParams.nMemPagesMax
00271 << " max) cache pages; allocated "
00272 << pCache->getAllocatedPageCount()
00273 << " cache pages.");
00274 }
00275
00276 setDbHandle(cmd.getResultHandle(),pDbHandle.release());
00277 }
Reimplemented from FemVisitor.
Definition at line 296 of file CmdInterpreter.cpp.
References ExecStreamResourceKnobs::cacheReservePercentage, EXEC_KNOB_CACHE_RESERVE_PERCENTAGE, EXEC_KNOB_EXPECTED_CONCURRENT_STATEMENTS, EXEC_RESOURCE_CACHE_PAGES, ExecStreamResourceKnobs::expectedConcurrentStatements, ProxyDatabaseCmd::getDbHandle(), getDbHandle(), ProxyCmdSetParam::getParam(), ExecStreamResourceQuantity::nCachePages, CmdInterpreter::DbHandle::pDb, and CmdInterpreter::DbHandle::pResourceGovernor.
00297 {
00298 DbHandle *pDbHandle = getDbHandle(cmd.getDbHandle());
00299 SharedProxyDatabaseParam pParam = cmd.getParam();
00300
00301 std::string paramName = pParam->getName();
00302
00303 if (paramName.compare("cachePagesInit") == 0) {
00304 int pageCount = boost::lexical_cast(pParam->getValue());
00305 SharedCache pCache = pDbHandle->pDb->getCache();
00306 if (pageCount <= 0 || pageCount > pCache->getMaxAllocatedPageCount()) {
00307 throw InvalidParamExcn("1", "'cachePagesMax'");
00308 }
00309
00310 bool decreasingPageCount = pageCount < pCache->getAllocatedPageCount();
00311 if (decreasingPageCount) {
00312
00313 ExecStreamResourceQuantity available;
00314 available.nCachePages = pageCount;
00315 if (!pDbHandle->pResourceGovernor->setResourceAvailability(
00316 available, EXEC_RESOURCE_CACHE_PAGES))
00317 {
00318 throw InvalidParamExcn(
00319 "the number of pages currently assigned (plus reserve)",
00320 "'cachePagesMax'");
00321 }
00322 }
00323
00324 pCache->setAllocatedPageCount(pageCount);
00325
00326 if (!decreasingPageCount) {
00327
00328 ExecStreamResourceQuantity available;
00329 available.nCachePages = pageCount;
00330 bool result =
00331 pDbHandle->pResourceGovernor->setResourceAvailability(
00332 available, EXEC_RESOURCE_CACHE_PAGES);
00333 assert(result);
00334 }
00335 } else if (paramName.compare("expectedConcurrentStatements") == 0) {
00336 int nStatements = boost::lexical_cast(pParam->getValue());
00337 SharedCache pCache = pDbHandle->pDb->getCache();
00338
00339 if (nStatements <= 0 ||
00340 nStatements > pCache->getMaxLockedPages() / 5)
00341 {
00342 throw InvalidParamExcn("1", "'cachePagesInit/5'");
00343 }
00344 ExecStreamResourceKnobs knob;
00345 knob.expectedConcurrentStatements = nStatements;
00346 pDbHandle->pResourceGovernor->setResourceKnob(
00347 knob, EXEC_KNOB_EXPECTED_CONCURRENT_STATEMENTS);
00348
00349 } else if (paramName.compare("cacheReservePercentage") == 0) {
00350 int percent = boost::lexical_cast(pParam->getValue());
00351 if (percent <= 0 || percent > 99) {
00352 throw InvalidParamExcn("1", "99");
00353 }
00354 ExecStreamResourceKnobs knob;
00355 knob.cacheReservePercentage = percent;
00356 if (!pDbHandle->pResourceGovernor->setResourceKnob(
00357 knob, EXEC_KNOB_CACHE_RESERVE_PERCENTAGE))
00358 {
00359 throw InvalidParamExcn(
00360 "1",
00361 "a percentage that sets aside fewer pages, to allow for pages already assigned");
00362 }
00363 }
00364 }
Reimplemented from FemVisitor.
Definition at line 814 of file CmdInterpreter.cpp.
References ProxyCmdInitiateBackup::getBackupPathname(), ProxyCmdInitiateBackup::getCompressionProgram(), ProxyDatabaseCmd::getDbHandle(), getDbHandle(), ProxyCmdInitiateBackup::getLowerBoundCsn(), ProxyCsnHandleReturningCmd::getResultHandle(), ProxyCmdInitiateBackup::getSpacePadding(), ProxyCmdInitiateBackup::isCheckSpaceRequirements(), isMAXU(), NULL_TXN_ID, CmdInterpreter::DbHandle::pDb, pExecHandle, setCsnHandle(), and ProxyCmdInitiateBackup::setResultDataDeviceSize().
Reimplemented from FemVisitor.
Definition at line 856 of file CmdInterpreter.cpp.
References CmdInterpreter::ExecutionHandle::aborted, ProxyCmdRestoreFromBackup::getBackupPathname(), ProxyCmdRestoreFromBackup::getCompressionProgram(), ProxyDatabaseCmd::getDbHandle(), getDbHandle(), ProxyCmdRestoreFromBackup::getFileSize(), ProxyCmdRestoreFromBackup::getLowerBoundCsn(), ProxyCmdRestoreFromBackup::getUpperBoundCsn(), isMAXU(), NULL_TXN_ID, CmdInterpreter::DbHandle::pDb, and pExecHandle.
| ExecStream & CmdInterpreter::getExecStreamFromLong | ( | jlong | | ) | [inline, static] | | -------------------------------------------------------------------------- | - | ----- | | - | ------------------ |
| jobject CmdInterpreter::getObjectFromLong | ( | jlong | jHandle | ) | [inline, static] |
|---|
Reads the Java representation of a TupleProjection.
Parameters:
Definition at line 775 of file CmdInterpreter.cpp.
Referenced by dropOrTruncateIndex(), getBTreeForIndexCmd(), ExecStreamFactory::implementSortWithBTree(), ExecStreamFactory::readBTreeParams(), ExecStreamFactory::readBTreeReadStreamParams(), ExecStreamFactory::readBTreeSearchStreamParams(), ExecStreamSubFactory_lu::readClusterAppendParams(), ExecStreamFactory::readTableWriterStreamParams(), ExecStreamSubFactory_lu::visit(), ExecStreamFactory::visit(), and visit().
00778 { 00779 tupleProj.clear(); 00780 SharedProxyTupleAttrProjection pAttr = pJavaTupleProj->getAttrProjection(); 00781 for (; pAttr; ++pAttr) { 00782 tupleProj.push_back(pAttr->getAttributeIndex()); 00783 } 00784 }
| SharedErrorTarget CmdInterpreter::newErrorTarget | ( | jobject | fennelJavaErrorTarget | ) | [static] |
|---|
| virtual void FemVisitor::visit | ( | ProxyBeginTxnCmd & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | ------------------------------------------------ | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyCmd & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | -------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyColumnName & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | ---------------------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyCorrelation & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | ------------------------------------------------ | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyCsnHandle & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | -------------------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyDatabaseCmd & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | ------------------------------------------------ | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyDbHandle & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | ------------------------------------------ | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyEndTxnCmd & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | -------------------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyHandle & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | -------------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyIndexCmd & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | ------------------------------------------ | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxySvptHandle & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | ---------------------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyTxnCmd & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | -------------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyTxnHandle & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | -------------------------------------------- | | - | ------------------------------ |
| virtual void FemVisitor::visit | ( | ProxyWindowDef & | | ) | [inline, virtual, inherited] | | ------------------------------ | - | -------------------------------------------- | | - | ------------------------------ |
| void JniProxyVisitor::unhandledVisit | ( | | ) | [virtual, inherited] | | ------------------------------------ | - | | - | ---------------------- |
Handles case when a visitor attempts to visit a proxy whose type's visit method has not been overridden.
Default action is to throw an assertion failure; subclasses may override to ignore or whatever.
Reimplemented in ExecStreamSubFactory_lu.
Definition at line 50 of file JniProxy.cpp.
Referenced by FemVisitor::visit().
00051 { 00052 permAssert(false); 00053 }
Member Data Documentation
The documentation for this class was generated from the following files:
- /home/pub/open/dev/fennel/farrago/CmdInterpreter.h
- /home/pub/open/dev/fennel/farrago/CmdInterpreter.cpp
Generated on Mon Jun 22 04:00:28 2009 for Fennel by 
1.5.1