Page Speed Optimization Libraries  1.2.24.1
net/instaweb/util/public/statistics_template.h
Go to the documentation of this file.
00001 /*
00002  * Copyright 2010 Google Inc.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *      http:///www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00018 
00019 #ifndef NET_INSTAWEB_UTIL_PUBLIC_STATISTICS_TEMPLATE_H_
00020 #define NET_INSTAWEB_UTIL_PUBLIC_STATISTICS_TEMPLATE_H_
00021 
00022 #include <algorithm>
00023 #include <cstddef>
00024 #include <map>
00025 #include <vector>
00026 
00027 #include "net/instaweb/util/public/basictypes.h"
00028 #include "net/instaweb/util/public/statistics.h"
00029 #include "net/instaweb/util/public/stl_util.h"
00030 #include "net/instaweb/util/public/string.h"
00031 #include "net/instaweb/util/public/string_util.h"
00032 #include "net/instaweb/util/public/writer.h"
00033 
00034 namespace net_instaweb {
00035 class MessageHandler;
00036 
00040 template<class Var, class Hist, class TimedVar> class StatisticsTemplate
00041     : public Statistics {
00042  public:
00043   StatisticsTemplate() {}
00044   virtual ~StatisticsTemplate() {
00045     STLDeleteContainerPointers(variables_.begin(), variables_.end());
00046     STLDeleteContainerPointers(histograms_.begin(), histograms_.end());
00047     STLDeleteContainerPointers(timed_vars_.begin(), timed_vars_.end());
00048   }
00049 
00052   virtual Var* AddVariable(const StringPiece& name) {
00053     Var* var = FindVariable(name);
00054     if (var == NULL) {
00055       var = NewVariable(name, variables_.size());
00056       variables_.push_back(var);
00057       variable_names_.push_back(name.as_string());
00058       variable_map_[name.as_string()] = var;
00059     }
00060     return var;
00061   }
00062 
00063   virtual Var* AddGlobalVariable(const StringPiece& name) {
00064     Var* var = FindVariable(name);
00065     if (var == NULL) {
00066       var = NewGlobalVariable(name, variables_.size());
00067       variables_.push_back(var);
00068       variable_names_.push_back(name.as_string());
00069       variable_map_[name.as_string()] = var;
00070     }
00071     return var;
00072   }
00073 
00074   virtual Var* FindVariable(const StringPiece& name) const {
00075     typename VarMap::const_iterator p = variable_map_.find(name.as_string());
00076     Var* var = NULL;
00077     if (p != variable_map_.end()) {
00078       var = p->second;
00079     }
00080     return var;
00081   }
00082 
00083   virtual Hist* AddHistogram(const StringPiece& name) {
00084     Hist* hist = FindHistogram(name);
00085     if (hist == NULL) {
00086       hist = NewHistogram(name);
00087       histograms_.push_back(hist);
00088       histogram_names_.push_back(name.as_string());
00089       histogram_map_[name.as_string()] = hist;
00090     }
00091     return hist;
00092   }
00093 
00094   virtual Hist* FindHistogram(const StringPiece& name) const {
00095     typename HistMap::const_iterator p = histogram_map_.find(name.as_string());
00096     Hist* hist = NULL;
00097     if (p != histogram_map_.end()) {
00098       hist = p->second;
00099     }
00100     return hist;
00101   }
00102 
00103   virtual TimedVar* AddTimedVariable(const StringPiece& name,
00104                                      const StringPiece& group) {
00105     TimedVar* timedvar = FindTimedVariable(name);
00106     if (timedvar == NULL) {
00107       timedvar = NewTimedVariable(name, timed_vars_.size());
00108       timed_vars_.push_back(timedvar);
00109       timed_var_map_[name.as_string()] = timedvar;
00110       timed_var_group_map_[group.as_string()].push_back(name.as_string());
00111     }
00112     return timedvar;
00113   }
00114 
00115   virtual TimedVar* FindTimedVariable(const StringPiece& name) const {
00116     typename TimedVarMap::const_iterator p =
00117         timed_var_map_.find(name.as_string());
00118     TimedVar* timedvar = NULL;
00119     if (p != timed_var_map_.end()) {
00120       timedvar = p->second;
00121     }
00122     return timedvar;
00123   }
00124 
00125   virtual const StringVector& HistogramNames() {
00126     return histogram_names_;
00127   }
00128 
00129   virtual const std::map<GoogleString, StringVector>& TimedVariableMap() {
00130     return timed_var_group_map_;
00131   }
00132 
00133   virtual void Dump(Writer* writer, MessageHandler* message_handler) {
00134     int longest_string = 0;
00135     for (int i = 0, n = variables_.size(); i < n; ++i) {
00136       const GoogleString& var_name = variable_names_[i];
00137       int length_number = Integer64ToString(variables_[i]->Get()).size();
00138       int length_name = var_name.size();
00139       longest_string = std::max(longest_string, length_name + length_number);
00140     }
00141 
00142     GoogleString spaces_buffer = GoogleString(longest_string, ' ');
00143     StringPiece spaces(spaces_buffer);
00144     for (int i = 0, n = variables_.size(); i < n; ++i) {
00145       const GoogleString& var_name = variable_names_[i];
00146       GoogleString var_as_str = Integer64ToString(variables_[i]->Get());
00147       writer->Write(var_name, message_handler);
00148       writer->Write(": ", message_handler);
00149       int num_spaces = longest_string - var_name.size() - var_as_str.size();
00150       writer->Write(spaces.substr(0, num_spaces), message_handler);
00151       writer->Write(var_as_str, message_handler);
00152       writer->Write("\n", message_handler);
00153     }
00154   }
00155 
00156   virtual void Clear() {
00157     for (int i = 0, n = variables_.size(); i < n; ++i) {
00158       Variable* var = variables_[i];
00159       var->Clear();
00160     }
00161     for (int i = 0, n = histograms_.size(); i < n; ++i) {
00162       Histogram* hist = histograms_[i];
00163       hist->Clear();
00164     }
00165     for (int i = 0, n = timed_vars_.size(); i < n; ++i) {
00166       TimedVariable* timedvar = timed_vars_[i];
00167       timedvar->Clear();
00168     }
00169   }
00170 
00171  protected:
00173   virtual Var* NewVariable(const StringPiece& name, int index) = 0;
00174 
00176   virtual Var* NewGlobalVariable(const StringPiece& name, int index) {
00177     return NewVariable(name, index);
00178   }
00179 
00180   virtual Hist* NewHistogram(const StringPiece& name) = 0;
00181   virtual TimedVar* NewTimedVariable(const StringPiece& name, int index) = 0;
00182 
00183   size_t variables_size() const { return variables_.size(); }
00184   Var* variables(size_t pos) { return variables_.at(pos); }
00185 
00186   size_t histograms_size() const { return histograms_.size(); }
00187   Hist* histograms(size_t pos) { return histograms_.at(pos); }
00188 
00189   const GoogleString& histogram_names(size_t pos) const {
00190     return histogram_names_.at(pos);
00191   }
00192 
00193  private:
00194   typedef std::vector<Var*> VarVector;
00195   typedef std::map<GoogleString, Var*> VarMap;
00196   typedef std::vector<Hist*> HistVector;
00197   typedef std::map<GoogleString, Hist*> HistMap;
00198 
00199   typedef std::vector<TimedVar*> TimedVarVector;
00200   typedef std::map<GoogleString, TimedVar*> TimedVarMap;
00201   VarVector variables_;
00202   VarMap variable_map_;
00203   HistVector histograms_;
00204   HistMap histogram_map_;
00205   TimedVarVector timed_vars_;
00206   TimedVarMap timed_var_map_;
00208   std::map<GoogleString, StringVector> timed_var_group_map_;
00209   StringVector variable_names_;
00210   StringVector histogram_names_;
00211 
00212   DISALLOW_COPY_AND_ASSIGN(StatisticsTemplate);
00213 };
00214 
00217 template<class Var>
00218 class ScalarStatisticsTemplate
00219     : public StatisticsTemplate<Var, NullHistogram, FakeTimedVariable> {
00220  public:
00221   ScalarStatisticsTemplate() {}
00222   virtual ~ScalarStatisticsTemplate() {}
00223 
00224  protected:
00225   virtual NullHistogram* NewHistogram(const StringPiece& name) {
00226     return new NullHistogram;
00227   }
00228 
00229   virtual FakeTimedVariable* NewTimedVariable(const StringPiece& name,
00230                                               int index) {
00231     return this->NewFakeTimedVariable(name, index);
00232   }
00233 };
00234 
00235 }  
00236 
00237 #endif  ///< NET_INSTAWEB_UTIL_PUBLIC_STATISTICS_TEMPLATE_H_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines