#include <FBase.h>
 | 
| enum   | FInputPolicy { One
, Many
 } | 
|   | Field with a policy of FInputPolicy::Many is not allowed to be connected to FInputPolicy::One Field with policy of FInputPolicy::One can either be connected to a field of FInputPolicy::One or FInputPolicy::Many.  More...
  | 
|   | 
 | 
| FieldTypeEnum  | m_fType = FieldTypeEnum::Param | 
|   | 
Definition at line 43 of file FBase.h.
 
◆ FInputPolicy
Field with a policy of FInputPolicy::Many is not allowed to be connected to FInputPolicy::One Field with policy of FInputPolicy::One can either be connected to a field of FInputPolicy::One or FInputPolicy::Many. 
Definition at line 54 of file FBase.h.
 
 
◆ FBase() [1/2]
◆ FBase() [2/2]
      
        
          | dyno::FBase::FBase  | 
          ( | 
          std::string |           name,  | 
        
        
           | 
           | 
          std::string |           description,  | 
        
        
           | 
           | 
          FieldTypeEnum |           type = FieldTypeEnum::Param,  | 
        
        
           | 
           | 
          OBase * |           parent = nullptr ) | 
        
      
 
 
◆ ~FBase()
◆ addSink()
  
  
      
        
          | bool dyno::FBase::addSink  | 
          ( | 
          FBase * |           f | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ addSource()
  
  
      
        
          | bool dyno::FBase::addSource  | 
          ( | 
          FBase * |           f | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ attach()
      
        
          | void dyno::FBase::attach  | 
          ( | 
          std::shared_ptr< FCallBackFunc > |           func | ) | 
           | 
        
      
 
 
◆ connect()
  
  
      
        
          | virtual bool dyno::FBase::connect  | 
          ( | 
          FBase * |           dst | ) | 
           | 
         
       
   | 
  
pure virtual   | 
  
 
 
◆ connectField()
  
  
      
        
          | bool dyno::FBase::connectField  | 
          ( | 
          FBase * |           dst | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ demoteInput()
      
        
          | FBase * dyno::FBase::demoteInput  | 
          ( | 
           | ) | 
           | 
        
      
 
Hide a state field from inputs. 
- Returns
 - state field 
 
Definition at line 93 of file FBase.cpp.
 
 
◆ demoteOuput()
      
        
          | FBase * dyno::FBase::demoteOuput  | 
          ( | 
           | ) | 
           | 
        
      
 
Hide a state field from outputs. 
- Returns
 - state field 
 
Definition at line 81 of file FBase.cpp.
 
 
◆ deserialize()
  
  
      
        
          | virtual bool dyno::FBase::deserialize  | 
          ( | 
          const std::string & |           str | ) | 
           | 
         
       
   | 
  
inlinevirtual   | 
  
 
 
◆ detach()
      
        
          | void dyno::FBase::detach  | 
          ( | 
          std::shared_ptr< FCallBackFunc > |           func | ) | 
           | 
        
      
 
 
◆ disconnect()
  
  
      
        
          | bool dyno::FBase::disconnect  | 
          ( | 
          FBase * |           dst | ) | 
           | 
         
       
   | 
  
virtual   | 
  
 
 
◆ disconnectField()
  
  
      
        
          | bool dyno::FBase::disconnectField  | 
          ( | 
          FBase * |           dst | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ getClassName()
  
  
      
        
          | virtual const std::string dyno::FBase::getClassName  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inlinevirtual   | 
  
 
 
◆ getDescription()
  
  
      
        
          | std::string dyno::FBase::getDescription  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getDeviceType()
  
  
      
        
          | virtual DeviceType dyno::FBase::getDeviceType  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inlinevirtual   | 
  
 
 
◆ getFieldType()
      
        
          | FieldTypeEnum dyno::FBase::getFieldType  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ getMax()
  
  
      
        
          | float dyno::FBase::getMax  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getMin()
  
  
      
        
          | float dyno::FBase::getMin  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getObjectName()
  
  
      
        
          | std::string dyno::FBase::getObjectName  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getSinks()
  
  
      
        
          | std::vector< FBase * > & dyno::FBase::getSinks  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getSource()
      
        
          | FBase * dyno::FBase::getSource  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ getSources()
  
  
      
        
          | std::vector< FBase * > & dyno::FBase::getSources  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getTemplateName()
  
  
      
        
          | virtual const std::string dyno::FBase::getTemplateName  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inlinevirtual   | 
  
 
 
◆ getTopField()
      
        
          | FBase * dyno::FBase::getTopField  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ inputPolicy()
◆ isActive()
      
        
          | bool dyno::FBase::isActive  | 
          ( | 
           | ) | 
           | 
        
      
 
A variable to control the visibility of the field. 
- Returns
 - true when the field is active, otherwise return false 
 
Definition at line 330 of file FBase.cpp.
 
 
◆ isAutoDestroyable()
      
        
          | bool dyno::FBase::isAutoDestroyable  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ isDerived()
      
        
          | bool dyno::FBase::isDerived  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ isEmpty()
  
  
      
        
          | virtual bool dyno::FBase::isEmpty  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
pure virtual   | 
  
 
 
◆ isModified()
      
        
          | bool dyno::FBase::isModified  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ isOptional()
      
        
          | bool dyno::FBase::isOptional  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ parent()
      
        
          | OBase * dyno::FBase::parent  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ promoteInput()
      
        
          | FBase * dyno::FBase::promoteInput  | 
          ( | 
           | ) | 
           | 
        
      
 
Display a state field as an input field. 
- Returns
 - state field 
 
Definition at line 69 of file FBase.cpp.
 
 
◆ promoteOuput()
      
        
          | FBase * dyno::FBase::promoteOuput  | 
          ( | 
           | ) | 
           | 
        
      
 
Display a state field as an ouput field. 
- Returns
 - state field 
 
Definition at line 57 of file FBase.cpp.
 
 
◆ removeSink()
  
  
      
        
          | bool dyno::FBase::removeSink  | 
          ( | 
          FBase * |           f | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ removeSource()
  
  
      
        
          | bool dyno::FBase::removeSource  | 
          ( | 
          FBase * |           f | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ requestValidSources()
      
        
          | void dyno::FBase::requestValidSources  | 
          ( | 
          std::vector< FBase * > & |           src | ) | 
           | 
        
      
 
 
◆ serialize()
  
  
      
        
          | virtual std::string dyno::FBase::serialize  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inlinevirtual   | 
  
 
 
◆ setActive()
      
        
          | void dyno::FBase::setActive  | 
          ( | 
          bool |           b | ) | 
           | 
        
      
 
 
◆ setAutoDestroy()
      
        
          | void dyno::FBase::setAutoDestroy  | 
          ( | 
          bool |           autoDestroy | ) | 
           | 
        
      
 
 
◆ setDerived()
      
        
          | void dyno::FBase::setDerived  | 
          ( | 
          bool |           derived | ) | 
           | 
        
      
 
 
◆ setDescription()
  
  
      
        
          | void dyno::FBase::setDescription  | 
          ( | 
          std::string |           description | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ setMax()
  
  
      
        
          | void dyno::FBase::setMax  | 
          ( | 
          float |           max_val | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ setMin()
  
  
      
        
          | void dyno::FBase::setMin  | 
          ( | 
          float |           min_val | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ setObjectName()
  
  
      
        
          | void dyno::FBase::setObjectName  | 
          ( | 
          std::string |           name | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ setParent()
      
        
          | void dyno::FBase::setParent  | 
          ( | 
          OBase * |           owner | ) | 
           | 
        
      
 
 
◆ setRange()
  
  
      
        
          | void dyno::FBase::setRange  | 
          ( | 
          float |           min_val,  | 
         
        
           | 
           | 
          float |           max_val ) | 
         
       
   | 
  
inline   | 
  
 
 
◆ setSource()
  
  
      
        
          | void dyno::FBase::setSource  | 
          ( | 
          FBase * |           source | ) | 
           | 
         
       
   | 
  
protected   | 
  
 
 
◆ size()
  
  
      
        
          | virtual uint dyno::FBase::size  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
pure virtual   | 
  
 
 
◆ sizeOfSinks()
      
        
          | uint dyno::FBase::sizeOfSinks  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ sizeOfValidSources()
      
        
          | uint dyno::FBase::sizeOfValidSources  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ tack()
      
        
          | void dyno::FBase::tack  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ tagOptional()
      
        
          | void dyno::FBase::tagOptional  | 
          ( | 
          bool |           optional | ) | 
           | 
        
      
 
 
◆ tick()
      
        
          | void dyno::FBase::tick  | 
          ( | 
           | ) | 
           | 
        
      
 
 
◆ update()
  
  
      
        
          | void dyno::FBase::update  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
virtual   | 
  
 
 
◆ m_autoDestroyable
  
  
      
        
          | bool dyno::FBase::m_autoDestroyable = true | 
         
       
   | 
  
private   | 
  
 
 
◆ m_derived
  
  
      
        
          | bool dyno::FBase::m_derived = false | 
         
       
   | 
  
private   | 
  
 
 
◆ m_description
  
  
      
        
          | std::string dyno::FBase::m_description | 
         
       
   | 
  
private   | 
  
 
 
◆ m_fType
  
  
      
        
          | FieldTypeEnum dyno::FBase::m_fType = FieldTypeEnum::Param | 
         
       
   | 
  
protected   | 
  
 
 
◆ m_max
  
  
      
        
          | float dyno::FBase::m_max = FLT_MAX | 
         
       
   | 
  
private   | 
  
 
 
◆ m_min
  
  
      
        
          | float dyno::FBase::m_min = -FLT_MAX | 
         
       
   | 
  
private   | 
  
 
 
◆ m_name
  
  
      
        
          | std::string dyno::FBase::m_name | 
         
       
   | 
  
private   | 
  
 
 
◆ m_optional
  
  
      
        
          | bool dyno::FBase::m_optional = false | 
         
       
   | 
  
private   | 
  
 
 
◆ mActive
  
  
      
        
          | bool dyno::FBase::mActive = true | 
         
       
   | 
  
private   | 
  
 
 
◆ mCallbackFunc
  
  
      
        
          | std::vector<std::shared_ptr<FCallBackFunc> > dyno::FBase::mCallbackFunc | 
         
       
   | 
  
private   | 
  
 
 
◆ mMultipleSources
  
  
      
        
          | std::vector<FBase*> dyno::FBase::mMultipleSources | 
         
       
   | 
  
private   | 
  
 
 
◆ mOwner
  
  
      
        
          | OBase* dyno::FBase::mOwner = nullptr | 
         
       
   | 
  
private   | 
  
 
 
◆ mSingleSource
  
  
      
        
          | FBase* dyno::FBase::mSingleSource = nullptr | 
         
       
   | 
  
private   | 
  
 
If the input policy is FInputPolicy::One, use mSource, otherwise use mMultipleSources for data traversal. 
Definition at line 198 of file FBase.h.
 
 
◆ mSinks
  
  
      
        
          | std::vector<FBase*> dyno::FBase::mSinks | 
         
       
   | 
  
private   | 
  
 
 
◆ mTackTime
  
  
      
        
          | TimeStamp dyno::FBase::mTackTime | 
         
       
   | 
  
private   | 
  
 
 
◆ mTickTime
  
  
      
        
          | TimeStamp dyno::FBase::mTickTime | 
         
       
   | 
  
private   | 
  
 
 
The documentation for this class was generated from the following files:
- D:/Peridyno/peridyno/src/Framework/FBase.h
 
- D:/Peridyno/peridyno/src/Framework/FBase.cpp