llvm-project/lldb/tools/lldb-perf/lib/Results.h

//===-- Results.h -----------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef __PerfTestDriver_Results_h__
#define __PerfTestDriver_Results_h__

#include "lldb/lldb-forward.h"
#include <map>
#include <string>
#include <vector>

namespace lldb_perf {

class Results
{
public:
    class Array;
    class Dictionary;
    class Double;
    class String;
    class Unsigned;

    class Result
    {
    public:
        enum class Type
        {
            Invalid,
            Array,
            Dictionary,
            Double,
            String,
            Unsigned
        };

        Result (Type type, const char *name, const char *description) :
            m_name (),
            m_description(),
            m_type (type)
        {
            if (name && name[0])
                m_name = name;
            if (description && description[0])
                m_description = description;
        }

        virtual
        ~Result()
        {
        }

        virtual void
        Write (Results &results) = 0;

        Array *
        GetAsArray ()
        {
            if (m_type == Type::Array)
                return (Array *)this;
            return NULL;
        }
        Dictionary *
        GetAsDictionary ()
        {
            if (m_type == Type::Dictionary)
                return (Dictionary *)this;
            return NULL;
        }
        Double *
        GetAsDouble ()
        {
            if (m_type == Type::Double)
                return (Double *)this;
            return NULL;
        }

        String *
        GetAsString ()
        {
            if (m_type == Type::String)
                return (String *)this;
            return NULL;
        }
        Unsigned *
        GetAsUnsigned ()
        {
            if (m_type == Type::Unsigned)
                return (Unsigned *)this;
            return NULL;
        }
        
        const char *
        GetName() const
        {
            if (m_name.empty())
                return NULL;
            return m_name.c_str();
        }

        const char *
        GetDescription() const
        {
            if (m_description.empty())
                return NULL;
            return m_description.c_str();
        }

        Type
        GetType() const
        {
            return m_type;
        }
    
    protected:
        std::string m_name;
        std::string m_description;
        Type m_type;
    };
    
    typedef std::shared_ptr<Result> ResultSP;

    class Array : public Result
    {
    public:
        Array (const char *name, const char *description) :
            Result (Type::Array, name, description)
        {
        }
        
        virtual
        ~Array()
        {
        }
        
        ResultSP
        Append (const ResultSP &result_sp);

        void
        ForEach (const std::function <bool (const ResultSP &)> &callback);

        virtual void
        Write (Results &results)
        {
        }
    protected:
        typedef std::vector<ResultSP> collection;
        collection m_array;
    };

    class Dictionary : public Result
    {
    public:
        Dictionary () :
            Result (Type::Dictionary, NULL, NULL)
        {
        }

        Dictionary (const char *name, const char *description) :
            Result (Type::Dictionary, name, description)
        {
        }

        virtual
        ~Dictionary()
        {
        }

        virtual void
        Write (Results &results)
        {
        }

        void
        ForEach (const std::function <bool (const std::string &, const ResultSP &)> &callback);
    
        ResultSP
        Add (const char *name, const char *description, const ResultSP &result_sp);
        
        ResultSP
        AddDouble (const char *name, const char *descriptiorn, double value);
        
        ResultSP
        AddUnsigned (const char *name, const char *description, uint64_t value);

        ResultSP
        AddString (const char *name, const char *description, const char *value);

    protected:

        typedef std::map<std::string, ResultSP> collection;
        collection m_dictionary;
    };
    
    class String : public Result
    {
    public:
        String (const char *name, const char *description, const char *value) :
            Result (Type::String, name, description),
            m_string ()
        {
            if (value && value[0])
                m_string = value;
        }

        virtual
        ~String()
        {
        }

        virtual void
        Write (Results &results)
        {
        }

        const char *
        GetValue () const
        {
            return m_string.empty() ? NULL : m_string.c_str();
        }
        
    protected:
        std::string m_string;
    };

    class Double : public Result
    {
    public:
        Double (const char *name, const char *description, double value) :
            Result (Type::Double, name, description),
            m_double (value)
        {
        }
        
        virtual
        ~Double()
        {
        }
        
        virtual void
        Write (Results &results)
        {
        }
        
        double
        GetValue () const
        {
            return m_double;
        }
        
    protected:
        double m_double;
    };

    class Unsigned : public Result
    {
    public:
        Unsigned (const char *name, const char *description, uint64_t value) :
            Result (Type::Unsigned, name, description),
            m_unsigned (value)
        {
        }
        
        virtual
        ~Unsigned()
        {
        }

        virtual void
        Write (Results &results)
        {
        }
        
        uint64_t
        GetValue () const
        {
            return m_unsigned;
        }

    protected:
        uint64_t m_unsigned;
    };

    Results () :
        m_results ()
    {
    }
    
    ~Results()
    {
    }
    
    Dictionary &
    GetDictionary ()
    {
        return m_results;
    }

    void
    Write (const char *path);
    
protected:
    Dictionary m_results;
};
    
} // namespace lldb_perf
#endif // #ifndef __PerfTestDriver_Results_h__