csonar_metricclass.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023-2025, an unpublished work by CodeSecure, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      Copyright (c) 2013-2023, an unpublished work by GrammaTech, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      This software is furnished under a license and may be used and
 *      copied only in accordance with the terms of such license and the
 *      inclusion of the above copyright notice.  This software or any
 *      other copies thereof may not be provided or otherwise made
 *      available to any other person.  Title to and ownership of the
 *      software is retained by CodeSecure, Inc.
 */

#ifndef CS_METRICCLASS_HPP
#define CS_METRICCLASS_HPP

#include "csurf/src/api/cpp/cs_api.hpp"
#include "codesonar/src/progtrav/csonar_plugin.h"

#if !DOXYGEN_ONLY
#define DOX_METRICCLASS_TYPEDEFS(gran, ...)  
#endif



#ifdef SWIG
#ifdef SWIGJAVA
%nojavaexception ~metricclass_flags;
%nojavaexception ~metricclass;
%nojavaexception ~metricclass_manager;
#endif
#endif

namespace cs{


    class metricclass_flags{
        CS_FLAGS_BOILERPLATE(
            metricclass_flags, cs_metricclass_flags, 
            csmetric_flags_all,
            "auto",
            "post-analysis"
            );  
        static const metricclass_flags NONE; 

        static const metricclass_flags AUTO; 

        static const metricclass_flags POST_ANALYSIS; 
    };
    CS_FLAGS_BOILERPLATE_FRIENDS(metricclass_flags,
                                 template<typename T> friend class metricclass_manager;
                                 template<typename T> friend class metricclass;,
                                 cs
        );
#ifdef CS_CPP_IMPL
    const metricclass_flags metricclass_flags::NONE = metricclass_flags(csmetric_flags_none);
    const metricclass_flags metricclass_flags::AUTO = metricclass_flags(csmetric_flags_auto);
    const metricclass_flags metricclass_flags::POST_ANALYSIS = metricclass_flags(csmetric_flags_post_analysis);
#endif

    template <typename T>
    class metricclass_manager{
        metricclass_manager();
    public:
        static metricclass<T> lookup(const std::string &tag);
        
        DISOWN_PARAMETER(metric_function<T> *metricclass_func_ptr)

          
       
        static metricclass<T> create(
            metric_function<T> *metricclass_func_ptr,
            const std::string &tag,
            const std::string &desc,
            metricclass_flags flags = metricclass_flags::AUTO);


        static metricclass<T> create(
            const std::string &tag,
            const std::string &desc,
            metricclass_flags flags = metricclass_flags::NONE);
      
        static iterator_adapter<metricclass_iterator_policy<T> > metricclasses();
    };

#ifdef SWIG
#ifdef SWIGPYTHON
/* Make some decorators -- see cs_metric.hpp */
METFUNC_DECORATOR(project_metricclass_function, project_metricclass_manager, _project_metric_function)
METFUNC_DECORATOR(compunit_metricclass_function, compunit_metricclass_manager, _compunit_metric_function)
METFUNC_DECORATOR(sfile_metricclass_function, sfile_metricclass_manager, _sfile_metric_function)
METFUNC_DECORATOR(procedure_metricclass_function, procedure_metricclass_manager, _procedure_metric_function)
#endif

    %template(project_metricclass_manager) metricclass_manager<project>;
    %template(compunit_metricclass_manager) metricclass_manager<compunit>;
    %template(sfile_metricclass_manager) metricclass_manager<sfile>;
    %template(procedure_metricclass_manager) metricclass_manager<procedure>;
#endif

    typedef metricclass_manager<project> project_metricclass_manager;

    typedef metricclass_manager<compunit> compunit_metricclass_manager;

    typedef metricclass_manager<sfile> sfile_metricclass_manager;

    typedef metricclass_manager<procedure> procedure_metricclass_manager;
    template<>
    class metricclass_granularity_policy<project>{
        friend class metricclass_manager<project>;
        friend class metricclass_iterator_policy<project>;
        friend class metricclass<project>;
        static cs_result delegate(double *val, const void *ctx)
        {
            metric_function<project> *func
                = static_cast<metric_function<project>*>(
                    const_cast<void*>(ctx));
            return func->delegate(val, cs::project::current());
        }

        static void report(cs_metricclass_t m, project p, double val)
        {
            check(csonar_report_metric_analysis(
                      m, val));
        }
        
        static double value(cs_metricclass_t m, project p)
        {
            double rv;
            check(csonar_metric_getvalue_analysis(
                      m, &rv));
            return rv;
        }
        
        static void retract(cs_metricclass_t m, project p)
        {}
        
        static cs_metricclass_t create(const char *tag, const char *desc, 
                                       metric_function<project> *func,
                                       cs_metricclass_flags flags)
        {
            cs_metricclass_t m;
            check(csonar_metric_create_class_analysis(
                      tag, desc, 
                      func ? delegate : NULL,
                      flags,
                      static_cast<void*>(func),
                      &m));
            return m;
        }
        
        static cs_metric_granularity granularity()
        { return csmetric_analysis; }
    
        static const char *name()
        { return "project"; }
    };
    
    template<>
    class metricclass_granularity_policy<compunit>{
        friend class metricclass_manager<compunit>;
        friend class metricclass_iterator_policy<compunit>;
        friend class metricclass<compunit>;
        static cs_result delegate(
            cglue<compunit>::ctype elt, 
            double *val, const void *ctx)
        {
            metric_function<compunit> *func
                = static_cast<metric_function<compunit>*>(
                    const_cast<void*>(ctx));
            return func->delegate(val, compunit::);
        }

        static void report(cs_metricclass_t m, compunit p, double val)
        {
            check(csonar_report_metric_compunit(
                      m, val, cglue<compunit>::unwrap(p)));
        }
        
        static double value(cs_metricclass_t m, compunit p)
        {
            double rv;
            check(csonar_metric_getvalue_compunit(
                      m, cglue<compunit>::unwrap(p), &rv));
            return rv;
        }
        
        static void retract(cs_metricclass_t m, compunit p)
        {
            check(csonar_metric_retract_compunit(
                      m, cglue<compunit>::unwrap(p)));
        }
        
        static cs_metricclass_t create(const char *tag, const char *desc, 
                                       metric_function<compunit> *func,
                                       cs_metricclass_flags flags)
        {
            cs_metricclass_t m;
            check(csonar_metric_create_class_compunit(
                      tag, desc, 
                      func ? delegate : NULL,
                      flags,
                      static_cast<void*>(func),
                      &m));
            return m;
        }
        
        static cs_metric_granularity granularity()
        { return csmetric_compunit; }
    
        static const char *name()
        { return "compunit"; }
    };

    template<>
    class metricclass_granularity_policy<sfile>{
        friend class metricclass_manager<sfile>;
        friend class metricclass_iterator_policy<sfile>;
        friend class metricclass<sfile>;
        static cs_result delegate(
            cglue<sfile>::ctype elt, 
            double *val, const void *ctx)
        {
            metric_function<sfile> *func
                = static_cast<metric_function<sfile>*>(
                    const_cast<void*>(ctx));
            return func->delegate(val, sfile::);
        }

        static void report(cs_metricclass_t m, sfile p, double val)
        {
            check(csonar_report_metric_file(
                      m, val, cglue<sfile>::unwrap(p)));
        }
        
        static double value(cs_metricclass_t m, sfile p)
        {
            double rv;
            check(csonar_metric_getvalue_file(
                      m, cglue<sfile>::unwrap(p), &rv));
            return rv;
        }
        
        static void retract(cs_metricclass_t m, sfile p)
        {
            check(csonar_metric_retract_file(
                      m, cglue<sfile>::unwrap(p)));
        }

        static cs_metricclass_t create(const char *tag, const char *desc, 
                                       metric_function<sfile> *func,
                                       cs_metricclass_flags flags)
        {
            cs_metricclass_t m;
            check(csonar_metric_create_class_file(
                      tag, desc, 
                      func ? delegate : NULL,
                      flags,
                      static_cast<void*>(func),
                      &m));
            return m;
        }
        
        static cs_metric_granularity granularity()
        { return csmetric_file; }
    
        static const char *name()
        { return "sfile"; }
    };
    
    template<>
    class metricclass_granularity_policy<procedure>{
        friend class metricclass_manager<procedure>;
        friend class metricclass_iterator_policy<procedure>;
        friend class metricclass<procedure>;
        static cs_result delegate(
            cglue<procedure>::ctype elt, 
            double *val, const void *ctx)
        {
            metric_function<procedure> *func
                = static_cast<metric_function<procedure>*>(
                    const_cast<void*>(ctx));
            return func->delegate(val, procedure::);
        }

        static void report(cs_metricclass_t m, procedure p, double val)
        {
            check(csonar_report_metric_procedure(
                      m, val, cglue<procedure>::unwrap(p)));
        }
        
        static double value(cs_metricclass_t m, procedure p)
        {
            double rv;
            check(csonar_metric_getvalue_procedure(
                      m, cglue<procedure>::unwrap(p), &rv));
            return rv;
        }
        
        static void retract(cs_metricclass_t m, procedure p)
        {
            check(csonar_metric_retract_procedure(
                      m, cglue<procedure>::unwrap(p)));
        }

        static cs_metricclass_t create(const char *tag, const char *desc, 
                                       metric_function<procedure> *func,
                                       cs_metricclass_flags flags)
        {
            cs_metricclass_t m;
            check(csonar_metric_create_class_procedure(
                      tag, desc, 
                      func ? delegate : NULL,
                      flags,
                      static_cast<void*>(func),
                      &m));
            return m;
        }
        
        static cs_metric_granularity granularity()
        { return csmetric_procedure; }
    
        static const char *name()
        { return "procedure"; }
    };

    CS_NODEFCTOR_TYPE(metricclass);
    template<typename T>
    class cglue<metricclass<T> >
    {
        friend class metricclass_manager<T>;
        friend class iterator_adapter<metricclass_iterator_policy<T> >;
        friend class metricclass<T>;
        friend class scratchpad<metricclass<T> >;
        friend class metricclass_iterator_policy<T>;
        cglue();
    public:
        typedef cs_metricclass_t ctype;
        typedef metricclass<T> type;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static type wrap(const ctype &c)
        { return type(c); }
        static ctype unwrap(const type &c)
        { return c.unwrap(); }
    private:
        static int ccmp(const ctype &a, const ctype &b)
        { return csonar_metric_compare(a,b); }
        static int chash(const ctype &a)
        { return csonar_metric_hash(a); }
    };


    template <typename T>
    class metricclass{
        CS_IR_BOILERPLATE_TYPENAME(metricclass);

        std::string as_string() const
        { return csonar_metric_tag( inner ); }
        
        std::string as_repr() const
        { return CS_AS_REPR_FROM_STRING(metricclass); }
        

        std::string tag() const
        { return csonar_metric_tag( inner ); }
        

        std::string description() const
        {
            const char *rv = csonar_metric_description( inner );
            if( !rv )
                return "";
            return rv;
        }

        bool always_discarded() const
        {
            if( !inner )
                check(CS_ERROR_INVALID_ARGUMENT);
            return !!csonar_metricclass_always_discarded(inner);
        }
        
        bool allowed() const
        {
            if( !inner )
                check(CS_ERROR_INVALID_ARGUMENT);
            return !!csonar_metricclass_allowed(inner);
        }

        
        void report(T  elt, double val) const
        { return metricclass_granularity_policy<T>::report(inner, elt, val); }


        double value(T  elt) const
        { return metricclass_granularity_policy<T>::value(inner, elt); }
        

       void retract(T  elt) const
        { return metricclass_granularity_policy<T>::retract(inner, elt); }


        metricclass_flags flags() const
        { return cglue<metricclass_flags>::wrap( csonar_metric_flags( inner ) ); } 
    };


#ifdef SWIG

   /* Analysis (\ref project) granularity metric class (\ref metricclass).
    */
    %template(project_metricclass) metricclass<project>;

   /* Compilation unit (\ref compunit) granularity metric class (\ref
    *  metricclass).
    */
    %template(compunit_metricclass) metricclass<compunit>;

   /* Source file (\ref sfile) granularity metric class (\ref metricclass).
    */
    %template(sfile_metricclass) metricclass<sfile>;
   /* Procedure (\ref procedure) granularity metric class (\ref metricclass).
    */
    %template(procedure_metricclass) metricclass<procedure>;
#endif

    typedef metricclass<project> project_metricclass;

    typedef metricclass<compunit> compunit_metricclass;

    typedef metricclass<sfile> sfile_metricclass;

    typedef metricclass<procedure> procedure_metricclass;
    template<typename T>
    class metricclass_iterator_policy{
    public:
        typedef cs_metric_class_iterator iterator_impl;
        typedef metricclass<T> key;
        typedef char ctype;
        
        static cs_result iter_first(
            ctype container,
            typename cglue<key>::ctype *val,
            iterator_impl *it)
        { return csonar_metric_class_iter_first( 
              metricclass_granularity_policy<T>::granularity(), 
              val, it ); }
        static cs_result iter_next(
            ctype container, 
            typename cglue<key>::ctype *val, 
            iterator_impl *it)
        { return csonar_metric_class_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return csonar_metric_class_iter_close( it ); }
        static std::string name()
        { return std::string(metricclass_granularity_policy<T>::name())
                + std::string("_metricclass_iterator"); }
    };
    
#ifdef SWIG
    %template() metricclass_iterator_policy<project>;
    %template() metricclass_iterator_policy<compunit>;
    %template() metricclass_iterator_policy<sfile>;
    %template() metricclass_iterator_policy<procedure>;
#endif

    NOT_SWIG_BUILD_ONLY(      \ \
    template<typename T>
    inline bool operator==(const metricclass<T>& a, const metricclass<T>& b)
    { return a.cmp(b) == 0; }
      \ \
    template<typename T>
    inline bool operator!=(const metricclass<T>& a, const metricclass<T>& b)
    { return a.cmp(b) != 0; }
      \ \
    template<typename T>
    inline bool operator<(const metricclass<T>& a, const metricclass<T>& b)
    { return a.cmp(b) < 0; }
      \ \
    template<typename T>
    inline bool operator<=(const metricclass<T>& a, const metricclass<T>& b)
    { return a.cmp(b) <= 0; }
      \ \
    template<typename T>
    inline bool operator>(const metricclass<T>& a, const metricclass<T>& b)
    { return a.cmp(b) > 0; }
      \ \
    template<typename T>
    inline bool operator>=(const metricclass<T>& a, const metricclass<T>& b)
    { return a.cmp(b) >= 0; } )

    template<typename T>
    inline std::ostream &operator<<( std::ostream &out, const metricclass<T> &a )
    {
        return out << CS_AS_REPR_PREFIX << "metricclass "
                   << metricclass_granularity_policy<T>::name()
                   << a.as_string() << CS_AS_REPR_SUFFIX;
    }
    
    template <typename T>
    inline metricclass<T> metricclass_manager<T>::lookup(
        const std::string &tag)
    {
        cs_metricclass_t m;
        check(csonar_metric_get_class(
                  tag.c_str(),
                  metricclass_granularity_policy<T>::granularity(),
                  &m));
        return cglue<metricclass<T> >::wrap(m);
    }
    
    template <typename T>
    inline  metricclass<T> metricclass_manager<T>::create(
        metric_function<T> *metricclass_func_ptr,
        const std::string &tag,
        const std::string &desc,
        metricclass_flags flags)
    {
        /* Since they are providing a metric_function, it seems
         * reasonable to assume they want us to use it. 
         */
        flags |= metricclass_flags::AUTO;
        metricclass<T> rv(
            cglue<metricclass<T> >::wrap(
                metricclass_granularity_policy<T>::create(
                    tag.c_str(), 
                    desc.size() 
                    ? desc.c_str() 
                    : /* NULL here will make codesonar crash, so don't
                       * do it */ 
                    tag.c_str(), 
                    metricclass_func_ptr,
                    cglue<metricclass_flags>::unwrap(flags))));
        metricclass_func_ptr->registered = true;
        return rv;
    }

    template <typename T>
    inline  metricclass<T> metricclass_manager<T>::create(
        const std::string &tag,
        const std::string &desc,
        metricclass_flags flags)
    {
        /* Since there is no metric_function, it can't be auto. */
        flags &= ~metricclass_flags::AUTO;
        metricclass<T> rv(
            cglue<metricclass<T> >::wrap(
                metricclass_granularity_policy<T>::create(
                    tag.c_str(), 
                    desc.size() 
                    ? desc.c_str() 
                    : /* NULL here will make codesonar crash, so don't
                       * do it */ 
                    tag.c_str(), 
                    NULL,
                    cglue<metricclass_flags>::unwrap(flags))));
        return rv;
    }

    template <typename T>
    inline iterator_adapter<metricclass_iterator_policy<T> > 
    metricclass_manager<T>::metricclasses()
    {
        return iterator_adapter<metricclass_iterator_policy<T> >(
            /* template demands a container */42);
    }


#ifdef SWIG
}
#define CS_SWIG_METRICCLASS_TEMPLATES(elt)         \
    %template(elt ## _metricclass_iterator_mixin) cs::iterator_adapter_mixin<cs::metricclass_iterator_policy<cs::elt> >; \
    %template(elt ## _metricclass_iterator) cs::iterator_adapter<cs::metricclass_iterator_policy<cs::elt> >

CS_SWIG_METRICCLASS_TEMPLATES(project);
CS_SWIG_METRICCLASS_TEMPLATES(compunit);
CS_SWIG_METRICCLASS_TEMPLATES(sfile);
CS_SWIG_METRICCLASS_TEMPLATES(procedure);

#undef CS_SWIG_METRICCLASS_TEMPLATES
namespace cs {
#else

    typedef iterator_adapter<metricclass_iterator_policy<project> >
    project_metricclass_iterator;

    typedef iterator_adapter<metricclass_iterator_policy<compunit> >
    compunit_metricclass_iterator;

    typedef iterator_adapter<metricclass_iterator_policy<sfile> >
    sfile_metricclass_iterator;

    typedef iterator_adapter<metricclass_iterator_policy<procedure> >
    procedure_metricclass_iterator;

  DOX_METRICCLASS_TYPEDEFS(project)  

  
  DOX_METRICCLASS_TYPEDEFS(compunit)  
  DOX_METRICCLASS_TYPEDEFS(sfile) 
 
  
  DOX_METRICCLASS_TYPEDEFS(procedure)  

#endif

    }

#undef DOX_METRICCLASS_TYPEDEFS

#endif /* CS_METRICCLASS_HPP */