cimsubcommand.h

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

    */
    String _getPersistenceType (
        const CIMInstance& handlerInstance);

    /**
        Get the subscription state string from a subscription instance

        @param  subscriptionNameSpace The subscription namespace

        @param  subPath               The ObjectPath of the subscription to 
                                      query

        @return the text string equivalent of the subscription state
    */
    String _getSubscriptionState (
        const CIMNamespaceName& subscriptionNamespace,
        const CIMObjectPath& subPath);

    /**
        Get the SNMP version string from a handler instance

        @param  handlerInstance  The snmp handler instance to query

        @return the text string equivalent of the snmp version
    */
    String _getSnmpVersion (
        const CIMInstance& handlerInstance);

    /**
        Print data in columns.

        @param  maxColumnWidth    The array of column widths. This is the fixed
                                  width for each column. This is used to lineup
                                  all the data in each column.

        @param  listOutputTable   The array of output strings to print. It is
                                  an array of columns. The first element in
                                  each column is the column title.

        @param  outPrintWriter    The stream to which command output is
                                  written.
    */
    void _printColumns (
        const Array <Uint32>& maxColumnWidth,
        const Array <ListColumnEntry>& listOutputTable,
        PEGASUS_STD(ostream)& outPrintWriter);

    /**

        Sort a string array by indexes

        @param  x                 The array of strings to be sorted

        @param  startIndex        Starting index for the sort

        @param  index             The array of indexes into the x array

    */
    void _bubbleIndexSort (
        const Array<String>& x,
        const Uint32 startIndex,
        Array<Uint32>& index);

    /**
        print a verbose listing of Filters
    
        @param  listOutputTable   The array of output strings to print.
                                  It is an array of columns. The first
                                  element in each column is the column
                                  title.

        @param  queryLangs        The array of query language strings to print.

        @param  outPrintWriter    The stream to which command output is
                                  written.
     */

    void _printFiltersVerbose (
        const Array <ListColumnEntry>& listOutputTable,
        const Array <String>& queryLangs,
        PEGASUS_STD(ostream)& outPrintWriter);
    
    /**
        print a verbose listing of Handlers
        
        @param  instancesFound    The array of matching handler instances
    
        @param  handlerTypesFound The type of handler found. This is an
                                  enumerated type of the handler
                                  creation class.

        @param  listOutputTable   The array of output strings to print.
                                  It is an array of columns. The first
                                  element in each column is the column
                                  title.
    
        @param  outPrintWriter    The stream to which command output is
                                  written.
     */

    void _printHandlersVerbose (
        const Array<CIMInstance>& instancesFound,
        const Array<Uint32>& handlerTypesFound,
        const Array <ListColumnEntry>& listOutputTable,
        PEGASUS_STD(ostream)& outPrintWriter);
    
    /**
        get the handler destination and type
    
        @param  handlerInstance    The handler instance to query
    
        @param  creationClassName  Return value of creation class for this
                                   handler
  
        @param  handlerTypesFound  The type of handler found. This is an
                                   enumerated type of the handler
                                   creation class.
    
        @param  destination        Return string value of destination for
                                   this handler
     */

    void _getHandlerDestination (
        const CIMInstance& handlerInstance,
        String& creationClassName,
        Uint32&  handlerTypeFound,
        String& destination);
    
    /**
        get the query string for a filter
    
        @param  filterNamespace     The filter namespace
    
        @param  filterPath          The filter's object path

        @param  queryString         The text string equivalent of the query string

        @param queryLanString       The text string equivalent of the querylanguage
                                    string
    */
    void _getQueryString (
        const CIMNamespaceName& filterNamespace,
        const CIMObjectPath& filterPath,
        String& queryString,
        String& queryLangString);
    
    /**
        print a verbose listing of subscriptions
    
            @param  handlerInstancesFound The array of matching handler
                                          instances
    

            @param  handlerTypesFound     The type of handler found. This is an
                                          enumerated type of the handler
                                          creation class.
   
            @param  querysFound           The array of handler query strings
    
            @param  listOutputTable       The array of output strings to
                                          print. It is an array of columns.
                                          The first element in each column
                                          is the column title.
    
            @param  outPrintWriter        The stream to which command output
                                          is written.
    */
    void _printSubscriptionsVerbose (
        const Array<CIMInstance>& handlerInstancesFound,
        const Array<Uint32>& handlerTypesFound,
        const Array<String>& querysFound,
        const Array <ListColumnEntry>& listOutputTable,
        PEGASUS_STD(ostream)& outPrintWriter);
    
    /**
        parse the filter option string
    
         @param  filterNameString  The value of the filter commandline 
                                   option
    
         @param  filterName        Return value of parsed filter name
    
         @param  filterNameSpace   Return value of parsed filter namespace
    */
    void _parseFilterName(
        const String& filterNameString,
        String& filterName,
        String& filterNamespace);
    
    /**
        parse the handler option string
    
        @param  handlerString          The value of the handler commandline
                                       option

        @param  handlerName            Return value of parsed handler name
    
        @param  handlerNameSpace       Return value of parsed handler
                                       namespace
 
        @param  handlerCreadionClass   Return value of parsed handler
                                       creation class
    */
    void _parseHandlerName(
        const String& handlerString,
        String& handlerName,
        String& handlerNamespace,
        String& handlerCreationClass);
    
    /**
        Values for the creation class type
     */
    enum _handlerCreationClassType {_HANDLER_CIMXML = 0,
        _HANDLER_EMAIL = 1, _HANDLER_SYSLOG = 2,
        _HANDLER_SNMP = 3};

    //
    // The CIM Client reference
    //
    AutoPtr<CIMClient> _client;

    //
    // The type of operation specified on the command line.
    //
    Uint32 _operationType;

    //
    // The subtype of operation to be done
    //
    String _operationArg;

    //
    // The Filter Name
    //
    String _filterName;

    //
    // The Filter Namespace
    //
    String _filterNamespace;

    //
    // The Handler Name
    //
    String _handlerName;

    //
    // The Handler Namespace
    //
    String _handlerNamespace;

    //
    // The Handler's creation class
    //
    String _handlerCreationClass;

    //
    // The namespace of the subscription
    //
    String _subscriptionNamespace;

    //
    // The flag to indicate a verbose listing
    //
    Boolean _verbose;

    Boolean _filterSet;

    Boolean _handlerSet;

    String usage;

    //
    //  These constants represent the operation modes supported by the CLI.
    //  Any new operation should be added here.
    //

    /**
        This constant signifies that an operation option has not been recorded
     */
    static const Uint32 OPERATION_TYPE_UNINITIALIZED;

    /**
        This constant represents a disable subscription operation
     */
    static const Uint32 OPERATION_TYPE_DISABLE;

    /**
        This constant represents a enable subscription operation
     */
    static const Uint32 OPERATION_TYPE_ENABLE;

    /**
        This constant represents a list operation
     */
    static const Uint32 OPERATION_TYPE_LIST;

    /**
        This constant represents a remove operation
     */
    static const Uint32 OPERATION_TYPE_REMOVE;

    /**
        This constant represents a help operation
     */
    static const Uint32 OPERATION_TYPE_HELP;

    /**
        This constant represents a verbose list operation
     */
    static const Uint32 OPERATION_TYPE_VERBOSE;

    /**
        This constant represents a version display operation
     */
    static const Uint32 OPERATION_TYPE_VERSION;

};

PEGASUS_NAMESPACE_END

#endif  /* Pegasus_CIMSubCommand_h */