| //===-- 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__ |