MonitorContainer.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_MONITORCONTAINER_H
#define CARMA_MONITOR_MONITORCONTAINER_H


#include <string>
#include <vector>

#include "carma/monitor/types.h"
#include "carma/monitor/MonitorComponent.h"
#include "carma/monitor/MonitorPoint.h"


namespace carma {
namespace monitor {


class MonitorSubsystem;


class MonitorContainer: public MonitorComponent {
public:

    explicit MonitorContainer( const ::std::string & name );

    ~MonitorContainer() ;


    class Child {
        friend class MonitorContainer;
        
        public:
            explicit Child( );
            
            bool isNull( ) const;

            MonitorComponent * componentPtr( ) const;
            MonitorComponent & componentRef( ) const;

            bool isMp( ) const;
            MonitorPoint * mpPtr( ) const;
            MonitorPoint & mpRef( ) const;

            bool isContainer( ) const;
            MonitorContainer * containerPtr( ) const;
            MonitorContainer & containerRef( ) const;
            
            bool isSubsystem( ) const;
            MonitorSubsystem * subsystemPtr( ) const;
            MonitorSubsystem & subsystemRef( ) const;
            
        private:
            Child( MonitorComponent & component );
            
            MonitorComponent & handleBadComponentDeref( ) const;
            MonitorPoint & handleBadMpDeref( ) const;
            MonitorContainer & handleBadContainerDeref( ) const;
            MonitorSubsystem & handleBadSubsystemDeref( ) const;

            static const unsigned char kMpBitMask = 1;
            static const unsigned char kContainerBitMask = 2;
            static const unsigned char kSubsystemBitMask = 4;
        
            MonitorComponent * componentPtr_;
            unsigned char      flags_;
    };

    int getNumChildren( ) const;

    const Child & getChild( int index ) const;

    ::std::vector< Child > getChildVec( ) const;

    int getNumMonitorPoints( bool recurse = false ) const;

    virtual int getNumContainerChildren( ) const;

    virtual int getNumDescendants( ) const;

    virtual int getNumContainerDescendants( ) const;


    MonitorComponent *
    getComponentPtr( const ::std::string & name,
                     bool                  caseSensitive ) const;

    MonitorPoint &
    getMonitorPoint( const std::string & name,
                     bool                caseSensitive ) const;
    
    MonitorPoint *
    getMonitorPointPtr( const std::string & name,
                        bool                caseSensitive ) const;

    MonitorPoint & getMonitorPoint( tagIDType tagID ) const;

    MonitorPoint * getMonitorPointPtr( tagIDType tagID ) const;
    
    void add(MonitorComponent& component);
    
    MonitorPoint& getFirstMonitorPoint();
    
    void setValidity(MonitorPoint::VALIDITY validity);
    
    int getNumMonitorPoints();
    
    int getNumSamples();

    void setArchivePriority(
        const MonitorComponent::ARCHIVE_PRIORITY priority, 
        bool onlyDEFAULT=true);


// ---------- Virtual methods that make this a MonitorComponent
      
    // Specialize the docs for this one..
    virtual bool operator==(const MonitorComponent& component) const ;
    
    // Virtual, so doc is inherited
    void setNoData() const ;

    // Virtual methods of MonitorComponent so docs are inherited
    bool hasAllData() const ;

    // The sampleIndex is not used for this class
    std::string toString(bool canonicalName = false, bool verbose = false, 
        bool value = true, int sampleIndex=0, int indent = 0) const ;

    std::string toStringAverage(bool canonicalName = false, bool verbose = false, 
        bool value = true, int indent = 0) const ;

    void setPersistent(bool persistent) ;

    virtual void setMonitorPointAttributes();

    // Virtual, so doc is inherited
    virtual ::std::string monitorPointTags( bool untagged = false ) const;

    // Virtual, so doc is inherited
    virtual ::std::string hierarchyToString(
        bool canonical = false,
        bool verbose = false,
        bool value = true,
        int  sampleIndex = 0,
        int  indent = 0,
        int  levels = -1 ) const;

    // Virtual, so doc is inherited
    virtual void hierarchyToVector(
        ::std::vector< ::std::string > & hierarchyList,
        bool                             canonical = false,
        bool                             verbose = false,
        int                              sampleIndex = 0 ) const;

    // Virtual, so doc is inherited
    virtual ::std::string hierarchyToStringAverage(
        bool canonical = false,
        bool verbose = false,
        bool value = true, 
        int  indent = 0,
        int  levels = -1 ) const;

    // Virtual, so doc is inherited
    virtual std::string leafToString( bool verbose = false,
                                      bool value = true,
                                      int sampleIndex = 0 ) const;

    // Virtual, so doc is inherited
    virtual void setCanonicalName( const std::string & parents );

protected:

    virtual void setLocalMonitorPointAttributes();
    
    static Child findDescendant( const MonitorContainer & rootContainer,
                                 const ::std::string &    name,
                                 bool                     caseSensitive );
    
private:
    // No copying
    MonitorContainer & operator=( const MonitorContainer & rhs );
    MonitorContainer( const MonitorContainer & rhs );

    MonitorContainer( );  // Private default constructor!!

    static const Child kNullChild;

    ::std::vector< Child > children_;
};


}  // namespace carma::monitor
}  // namespace carma


// The default c'tor gives the correct answers for a NULL pointer
inline
carma::monitor::MonitorContainer::Child::Child( ) :
componentPtr_( 0 ),
flags_( 0 )
{
}


inline bool
carma::monitor::MonitorContainer::Child::isNull( ) const
{
    return (componentPtr_ == 0);
}


inline carma::monitor::MonitorComponent *
carma::monitor::MonitorContainer::Child::componentPtr( ) const
{
    return componentPtr_;
}


inline carma::monitor::MonitorComponent &
carma::monitor::MonitorContainer::Child::componentRef( ) const
{
    if ( componentPtr_ != 0 )
        return *componentPtr_;
    else
        return handleBadComponentDeref();
}


inline bool
carma::monitor::MonitorContainer::Child::isMp( ) const
{
    return (flags_ & kMpBitMask);
}


inline carma::monitor::MonitorPoint *
carma::monitor::MonitorContainer::Child::mpPtr( ) const
{
    if ( flags_ & kMpBitMask )
        return static_cast< MonitorPoint * >( componentPtr_ );
    else
        return 0;
}


inline carma::monitor::MonitorPoint &
carma::monitor::MonitorContainer::Child::mpRef( ) const
{
    if ( flags_ & kMpBitMask )
        return *static_cast< MonitorPoint * >( componentPtr_ );
    else
        return handleBadMpDeref();
}


inline bool
carma::monitor::MonitorContainer::Child::isContainer( ) const
{
    return (flags_ & kContainerBitMask);
}


inline carma::monitor::MonitorContainer *
carma::monitor::MonitorContainer::Child::containerPtr( ) const
{
    if ( flags_ & kContainerBitMask )
        return static_cast< MonitorContainer * >( componentPtr_ );
    else
        return 0;
}


inline carma::monitor::MonitorContainer &
carma::monitor::MonitorContainer::Child::containerRef( ) const
{
    if ( flags_ & kContainerBitMask )
        return *static_cast< MonitorContainer * >( componentPtr_ );
    else
        return handleBadContainerDeref();
}


inline bool
carma::monitor::MonitorContainer::Child::isSubsystem( ) const
{
    return (flags_ & kSubsystemBitMask);
}


inline int
carma::monitor::MonitorContainer::getNumChildren( ) const
{
    return children_.size();
}


inline const carma::monitor::MonitorContainer::Child &
carma::monitor::MonitorContainer::getChild( const int index ) const
{
    if ( (index >= 0) && (static_cast< size_t >( index ) < children_.size()) )
        return children_[ index ];
    else
        return kNullChild;
}


inline ::std::vector< carma::monitor::MonitorContainer::Child >
carma::monitor::MonitorContainer::getChildVec( ) const
{
    return children_;
}


#endif