tools/lldb-perf/lib/Results.h

   1 //===-- Results.h -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef __PerfTestDriver_Results_h__
  11 #define __PerfTestDriver_Results_h__
  12
  13 #include "lldb/lldb-forward.h"
  14 #include <map>
  15 #include <string>
  16 #include <vector>
  17
  18 namespace lldb_perf {
  19
  20 class Results
  21 {
  22 public:
  23     class Array;
  24     class Dictionary;
  25     class Double;
  26     class String;
  27     class Unsigned;
  28
  29     class Result
  30     {
  31     public:
  32         enum class Type
  33         {
  34             Invalid,
  35             Array,
  36             Dictionary,
  37             Double,
  38             String,
  39             Unsigned
  40         };
  41
  42         Result (Type type, const char *name, const char *description) :
  43             m_name (),
  44             m_description(),
  45             m_type (type)
  46         {
  47             if (name && name[0])
  48                 m_name = name;
  49             if (description && description[0])
  50                 m_description = description;
  51         }
  52
  53         virtual
  54         ~Result()
  55         {
  56         }
  57
  58         virtual void
  59         Write (Results &results) = 0;
  60
  61         Array *
  62         GetAsArray ()
  63         {
  64             if (m_type == Type::Array)
  65                 return (Array *)this;
  66             return NULL;
  67         }
  68         Dictionary *
  69         GetAsDictionary ()
  70         {
  71             if (m_type == Type::Dictionary)
  72                 return (Dictionary *)this;
  73             return NULL;
  74         }
  75         Double *
  76         GetAsDouble ()
  77         {
  78             if (m_type == Type::Double)
  79                 return (Double *)this;
  80             return NULL;
  81         }
  82
  83         String *
  84         GetAsString ()
  85         {
  86             if (m_type == Type::String)
  87                 return (String *)this;
  88             return NULL;
  89         }
  90         Unsigned *
  91         GetAsUnsigned ()
  92         {
  93             if (m_type == Type::Unsigned)
  94                 return (Unsigned *)this;
  95             return NULL;
  96         }
  97
  98         const char *
  99         GetName() const
 100         {
 101             if (m_name.empty())
 102                 return NULL;
 103             return m_name.c_str();
 104         }
 105
 106         const char *
 107         GetDescription() const
 108         {
 109             if (m_description.empty())
 110                 return NULL;
 111             return m_description.c_str();
 112         }
 113
 114         Type
 115         GetType() const
 116         {
 117             return m_type;
 118         }
 119
 120     protected:
 121         std::string m_name;
 122         std::string m_description;
 123         Type m_type;
 124     };
 125
 126     typedef std::shared_ptr<Result> ResultSP;
 127
 128     class Array : public Result
 129     {
 130     public:
 131         Array (const char *name, const char *description) :
 132             Result (Type::Array, name, description)
 133         {
 134         }
 135
 136         virtual
 137         ~Array()
 138         {
 139         }
 140
 141         ResultSP
 142         Append (const ResultSP &result_sp);
 143
 144         void
 145         ForEach (const std::function <bool (const ResultSP &)> &callback);
 146
 147         virtual void
 148         Write (Results &results)
 149         {
 150         }
 151     protected:
 152         typedef std::vector<ResultSP> collection;
 153         collection m_array;
 154     };
 155
 156     class Dictionary : public Result
 157     {
 158     public:
 159         Dictionary () :
 160             Result (Type::Dictionary, NULL, NULL)
 161         {
 162         }
 163
 164         Dictionary (const char *name, const char *description) :
 165             Result (Type::Dictionary, name, description)
 166         {
 167         }
 168
 169         virtual
 170         ~Dictionary()
 171         {
 172         }
 173
 174         virtual void
 175         Write (Results &results)
 176         {
 177         }
 178
 179         void
 180         ForEach (const std::function <bool (const std::string &, const ResultSP &)> &callback);
 181
 182         ResultSP
 183         Add (const char *name, const char *description, const ResultSP &result_sp);
 184
 185         ResultSP
 186         AddDouble (const char *name, const char *descriptiorn, double value);
 187
 188         ResultSP
 189         AddUnsigned (const char *name, const char *description, uint64_t value);
 190
 191         ResultSP
 192         AddString (const char *name, const char *description, const char *value);
 193
 194     protected:
 195
 196         typedef std::map<std::string, ResultSP> collection;
 197         collection m_dictionary;
 198     };
 199
 200     class String : public Result
 201     {
 202     public:
 203         String (const char *name, const char *description, const char *value) :
 204             Result (Type::String, name, description),
 205             m_string ()
 206         {
 207             if (value && value[0])
 208                 m_string = value;
 209         }
 210
 211         virtual
 212         ~String()
 213         {
 214         }
 215
 216         virtual void
 217         Write (Results &results)
 218         {
 219         }
 220
 221         const char *
 222         GetValue () const
 223         {
 224             return m_string.empty() ? NULL : m_string.c_str();
 225         }
 226
 227     protected:
 228         std::string m_string;
 229     };
 230
 231     class Double : public Result
 232     {
 233     public:
 234         Double (const char *name, const char *description, double value) :
 235             Result (Type::Double, name, description),
 236             m_double (value)
 237         {
 238         }
 239
 240         virtual
 241         ~Double()
 242         {
 243         }
 244
 245         virtual void
 246         Write (Results &results)
 247         {
 248         }
 249
 250         double
 251         GetValue () const
 252         {
 253             return m_double;
 254         }
 255
 256     protected:
 257         double m_double;
 258     };
 259
 260     class Unsigned : public Result
 261     {
 262     public:
 263         Unsigned (const char *name, const char *description, uint64_t value) :
 264             Result (Type::Unsigned, name, description),
 265             m_unsigned (value)
 266         {
 267         }
 268
 269         virtual
 270         ~Unsigned()
 271         {
 272         }
 273
 274         virtual void
 275         Write (Results &results)
 276         {
 277         }
 278
 279         uint64_t
 280         GetValue () const
 281         {
 282             return m_unsigned;
 283         }
 284
 285     protected:
 286         uint64_t m_unsigned;
 287     };
 288
 289     Results () :
 290         m_results ()
 291     {
 292     }
 293
 294     ~Results()
 295     {
 296     }
 297
 298     Dictionary &
 299     GetDictionary ()
 300     {
 301         return m_results;
 302     }
 303
 304     void
 305     Write (const char *path);
 306
 307 protected:
 308     Dictionary m_results;
 309 };
 310
 311 } // namespace lldb_perf
 312 #endif // #ifndef __PerfTestDriver_Results_h__