TagIDAuthority.h

Go to the documentation of this file.

#ifndef CARMA_DBMS_TAGIDAUTHORITY_H
#define CARMA_DBMS_TAGIDAUTHORITY_H


#include <string>
#include <map>
#include <vector>

#include "carma/util/PthreadRWLock.h"
#include "carma/monitor/types.h"


namespace log4cpp {

class Category;

}  // namespace log4cpp


namespace carma {
namespace dbms {

class DBConfigurator;

class TagIDAuthority {
public:

    static TagIDAuthority & getAuthority( );

    virtual ~TagIDAuthority( );

    static ::std::string getDefaultCanonicalNamesToTagIDsConfFile( );

    static void configureAuthority(
        const bool            useDb,
        const ::std::string & dbConfFile,
        const bool            useConfFileIfDBIsDown = true,
        const ::std::string & canonicalNamesToTagIDsConfFile =
            getDefaultCanonicalNamesToTagIDsConfFile( ) );

    static void closeAuthority() ;

    carma::monitor::tagIDType lookupID( const ::std::string & name ) const;

    unsigned short lookupSubsystemID( const ::std::string & name ) const;

    bool tagIdAssignedOnTheFly( const ::std::string & name ) const;

    bool tagIdAssignedOnTheFly( carma::monitor::tagIDType tagId ) const;

    ::std::string lookupName( carma::monitor::tagIDType tagId ) const;

    static ::std::string
    getSubsystemName( const ::std::string & canonicalName );

    static ::std::string getSubsystemName( const unsigned subsysID );

    static int getSubsystemCount();

    static carma::monitor::tagIDType composeTagID( 
        unsigned short subsystemId, unsigned short monitorPointId );

    static unsigned short getSubsystemID( carma::monitor::tagIDType tagId );

    static unsigned short getPointID( carma::monitor::tagIDType tagId );

    static unsigned short maxPossiblePointID( unsigned short subsystemId );

    ::std::string tagIDNameMapSha1Sum() const;

    struct TagIdOriginStats {
        size_t total;
        size_t totalDb;
        size_t totalConfFile;
        size_t totalOtf;

        // These maps are sparse. They only have an entry for a subsystem ID
        // if the value for that subsystem ID is non-zero.
        ::std::map< unsigned short, size_t > subsystemTotal;
        ::std::map< unsigned short, size_t > subsystemDb;
        ::std::map< unsigned short, size_t > subsystemConfFile;
        ::std::map< unsigned short, size_t > subsystemOtf;
    };

    TagIdOriginStats collectTagIdOriginStats( ) const;

    void logTagIdOriginStats() const;

    void logNotableOnTheFlyCreationsThusFarAndInTheFuture();

    void
    logNotableOnTheFlyCreationsThusFarAndInTheFuture( size_t targetLineCount );

private:
    struct StrictlyWeakStringOrdering {
        bool operator()( const ::std::string & lhs,
                         const ::std::string & rhs ) const;
    };

public:

    typedef enum {
        SUBSYS_TABLE_ORIGIN,
        DB_ORIGIN,
        CONF_FILE_ORIGIN,
        ON_THE_FLY_ORIGIN
    } OriginType;

private:

    typedef enum {
        SUBSYS_DOES_NOT_EXIST,
        SUBSYS_ID_MISMATCH,
        SUBSYS_MATCHES
    } SubsysMatchType;

public:

    struct NameMapInfo {
        carma::monitor::tagIDType tagId_;
        OriginType origin_;

        NameMapInfo( carma::monitor::tagIDType id, OriginType origin );
    };

    bool retrieveTagInfo( const std::string & canonicalName, 
                          NameMapInfo & nameMapInfo ) const;

private:

    typedef ::std::map< ::std::string, NameMapInfo, StrictlyWeakStringOrdering >
            Name2InfoMap;

    typedef ::std::map< ::std::string, carma::monitor::tagIDType, StrictlyWeakStringOrdering >
            Name2IdMap;

    typedef ::std::map< carma::monitor::tagIDType, ::std::string > Id2NameMap;

    TagIDAuthority( bool                  canUseDb,
                    bool                  canUseConfFile,
                    const ::std::string & dbConfFile,
                    const ::std::string & tagsConfFile );

    void registerNameHoldingWriteLock( const ::std::string & name,
                                       carma::monitor::tagIDType tagId,
                                       OriginType            origin );

    void registerSubsystemNamesHoldingWriteLock( );

    void getNamesToTagIDsFromConfFile( const ::std::string & fileName );
    void getNamesToTagIDsFromBinaryConfFile( const ::std::string & fileName );
    void getNamesToTagIDsFromTextConfFile( const ::std::string & fileName );

    void registerNameIDsUsingDB( const dbms::DBConfigurator * dbconf );

    carma::monitor::tagIDType 
    convertNameToTagIdHoldingLock( const ::std::string & name ) const;

public:

    carma::monitor::tagIDType
    findIdOrAssignOtf( const ::std::string & name,
                       bool &                assignedOTF,
                       const ::std::string & subsysName );

private:

    TagIdOriginStats collectTagIdOriginStatsHoldingLock( ) const;

    SubsysMatchType checkSubsysMatchHoldingLock(
        const ::std::string &          canonicalName,
        carma::monitor::tagIDType      nonSubsysTagId,
        Name2InfoMap::const_iterator & hint ) const;

    size_t estimateMemHoldingLock() const;


    // subsysnames_ is initialized in subsystemnames.cc
    static const char * const subsysnames_[ ];

    // subsysnamesCount_ is initialized in subsystemnames.cc
    static const int subsysnamesCount_;


    mutable util::PthreadRWLock guard_;

    OriginType          masterOrigin_;
    ::std::string       sha1sum_;

    Name2InfoMap        name2Info_;
    Id2NameMap          id2Name_;
    Name2IdMap          subsys2NextOtfId_;

    bool                logNotableOtfCreations_;
    bool                haveUnloggedNotableOtfCreations_;
};


}  // namespace carma::dbms
}  // namespace carma


inline carma::monitor::tagIDType
carma::dbms::TagIDAuthority::composeTagID( const unsigned short subsystemId,
                                              const unsigned short monitorPointId )
{
    return ((static_cast< carma::monitor::tagIDType >( subsystemId ) << 16) |
            static_cast< carma::monitor::tagIDType >( monitorPointId ));
}

inline unsigned short 
carma::dbms::TagIDAuthority::getSubsystemID( const carma::monitor::tagIDType tagId )
{
    return (tagId >> 16);
}


inline unsigned short 
carma::dbms::TagIDAuthority::getPointID( const carma::monitor::tagIDType tagId )
{
    return (tagId & 0x0000FFFF);
}

inline unsigned short
carma::dbms::TagIDAuthority::maxPossiblePointID( const unsigned short subsystemId )
{
    return 0x0000FFFF;
}


#endif // CARMA_DBMS_TAGIDAUTHORITY_H