Changes in / [288:294]


Ignore:
Location:
/trunk
Files:
6 added
11 edited

Legend:

Unmodified
Added
Removed
  • /trunk/.svndigest/config

    r288 r294  
    1212### Section for setting trac environment
    1313[trac]
    14 # If trac-ticket is set, svndigest will create anchors for
    15 # ticket to the Trac page.
    16 trac-ticket = http://lev.thep.lu.se/trac/svndigest/ticket/
    17 # If trac-revision is set, svndigest will create anchors for
    18 # revisions to the Trac page.
    19 trac-revision = http://lev.thep.lu.se/trac/svndigest/changeset/
     14# If trac-root is set, svndigest will create anchors to # the Trac page.
     15# trac-root = http://lev.thep.lu.se/trac/svndigest/
     16trac-root = http://lev.thep.lu.se/trac/svndigest/
    2017
  • /trunk/bin/svndigest.cc

    r288 r294  
    6262
    6363  // Reading configuration file
    64   Configuration* config = Configuration::instance();
     64  Configuration& config = Configuration::instance();
    6565  if (node_exist(option->config_file())) {
    6666    std::ifstream is(option->config_file().c_str());
     
    7171      exit(-1);
    7272    }
    73     config->load(is);
     73    config.load(is);
    7474    is.close();
    7575  }
    7676  else
    77     config->load();
    78   assert(config);
     77    config.load();
    7978 
    8079  // write configuration
    8180  if (option->generate_config()) {
    82     std::cout << *config;
     81    std::cout << config;
    8382    exit(0);
    8483  }
     
    9291  }
    9392  catch (SVNException e) {
    94     std::cerr << "\nsvndigest: " << e.what() << "\nsvndigest: " << option->root()
     93    std::cerr << "\nsvndigest: " << e.what() << "\nsvndigest: "
     94              << option->root()
    9595              << " is not under subversion control\n" << std::endl;
    9696    exit(-1);
     
    180180      if (option->verbose())
    181181        std::cout << "Updating copyright statements" << std::endl;
    182       std::map<std::string, std::string> alias(config->copyright_alias());
     182      std::map<std::string, std::string> alias(config.copyright_alias());
    183183      tree.print_copyright(alias);
    184184    }
  • /trunk/lib/Configuration.cc

    r288 r294  
    7979        getline(ss, tmp);
    8080        std::string value = trim(tmp);
    81         if (key=="trac-ticket")
    82           trac_ticket_=value;
    83         if (key=="trac-revision")
    84           trac_revision_=value;
    85        
     81        if (key=="trac-ticket"){
     82          std::cerr << "svndigest: warning: config variable trac-ticket "
     83                    << "is deprecated. Use trac-root instead.\n";
     84          trac_root_ = value.substr(0,value.size()-7);
     85        }
     86        if (key=="trac-revision"){
     87          std::cerr << "svndigest: warning: config variable trac-revision "
     88                    << "is deprecated. Use trac-root instead.\n";
     89          trac_root_ = value.substr(0,value.size()-10);
     90        }
     91        if (key=="trac-root")
     92          trac_root_=value;
    8693      }
    8794    }
     
    8996
    9097
    91   Configuration* Configuration::instance(void)
     98  Configuration& Configuration::instance(void)
    9299  {
    93100    if (!instance_)
    94101      instance_ = new Configuration;
    95     return instance_;
     102    return *instance_;
    96103  }
    97104
     
    100107  {
    101108    copyright_alias_.clear();
    102     trac_ticket_ = "";
    103     trac_revision_ = "";
     109    trac_root_ = "";
     110  }
     111
     112
     113  std::string Configuration::trac_root(void) const
     114  {
     115    return trac_root_;
    104116  }
    105117
     
    124136       << "### Section for setting trac environment\n"
    125137       << "[trac]\n"
    126        << "# If trac-ticket is set, svndigest will create anchors for\n"
    127        << "# ticket to the Trac page.\n"
    128        << "trac-ticket = " << conf.trac_ticket() << "\n";
    129     os << "# If trac-revision is set, svndigest will create anchors for\n"
    130        << "# revisions to the Trac page.\n"
    131        << "trac-revision = " << conf.trac_revision() << "\n";
     138       << "# If trac-root is set, svndigest will create anchors to "
     139       << "the Trac page.\n"
     140       << "# trac-root = http://lev.thep.lu.se/trac/svndigest/\n";
     141    if (!conf.trac_root().empty())
     142      os << "trac-root = " << conf.trac_root() << "\n";
    132143
    133144    return os;
  • /trunk/lib/Configuration.h

    r288 r294  
    4040  {
    4141  public:
    42     static Configuration* instance(void);
     42    static Configuration& instance(void);
    4343
    4444    ///
     
    6060    ///
    6161    /// @return root for the trac envrionment, e.g.,
    62     /// http://lev.thep.lu.se/trac/svndigest/ticket/
     62    /// http://lev.thep.lu.se/trac/svndigest/
    6363    ///
    64     inline std::string trac_ticket(void) const { return trac_ticket_; }
    65 
    66     ///
    67     /// @return root for the trac envrionment, e.g.,
    68     /// http://lev.thep.lu.se/trac/svndigest/ticket/
    69     ///
    70     std::string trac_revision(void) const { return trac_revision_; }
     64    std::string trac_root(void) const;
    7165
    7266  private:
     
    7973    // Copy Constructor not implemented
    8074    Configuration(const Configuration&);
     75    // assignment not implemented because assignment is always self-assignment
     76    Configuration& operator=(const Configuration&);
    8177
    8278    void clear(void);
     
    8884    std::map<std::string, std::string> copyright_alias_;
    8985
    90     std::string trac_ticket_;
    91     std::string trac_revision_;
    92    
     86    std::string trac_root_;
    9387  };
    9488
  • /trunk/lib/Trac.cc

    r288 r294  
    2727#include "HtmlStream.h"
    2828#include "html_utility.h"
     29#include "utility.h"
    2930
    3031namespace theplu{
     
    3435    : hs_(hs)
    3536  {}
     37
     38  bool Trac::changeset(std::string::const_iterator& first,
     39                       const std::string::const_iterator& last)
     40  {
     41    if (changeset1(first, last))
     42      return true;
     43    if (changeset2(first, last))
     44      return true;
     45    if (changeset3(first, last))
     46      return true;
     47    return false;
     48  }
     49
     50
     51  bool Trac::changeset1(std::string::const_iterator& first,
     52                        const std::string::const_iterator& last)
     53  {
     54    if (first==last)
     55      return false;
     56    if (*first != 'r')
     57      return false;
     58    const std::string::const_iterator first_orig(first);
     59    ++first;
     60    std::string rev = match(first, last, Digit());
     61    if (rev.empty()){
     62      first = first_orig;
     63      return false;
     64    }
     65    std::string href(Configuration::instance().trac_root()+"changeset/"+rev);
     66    hs_.stream() << anchor(href, std::string(first_orig,first));
     67    return true;
     68  }
     69
     70
     71  bool Trac::changeset2(std::string::const_iterator& first,
     72                        const std::string::const_iterator& last)
     73  {
     74    if (first==last)
     75      return false;
     76    if (*first != '[')
     77      return false;
     78    const std::string::const_iterator first_orig(first);
     79    ++first;
     80    std::string rev = match(first, last, Digit());
     81    if (rev.empty() || first==last || *first!=']'){
     82      first = first_orig;
     83      return false;
     84    }
     85    ++first;
     86    std::string href(Configuration::instance().trac_root()+"changeset/"+rev);
     87    hs_.stream() << anchor(href, std::string(first_orig,first));
     88    return true;
     89  }
     90
     91
     92  bool Trac::changeset3(std::string::const_iterator& first,
     93                        const std::string::const_iterator& last)
     94  {
     95    if (first==last)
     96      return false;
     97    const std::string::const_iterator first_orig(first);
     98    if (match(first, last, Str("changeset:")).empty()){
     99      first = first_orig;
     100      return false;
     101    }
     102    std::string rev = match(first, last, Digit());
     103    if (rev.empty()){
     104      first = first_orig;
     105      return false;
     106    }
     107    std::string href(Configuration::instance().trac_root()+"changeset/"+rev);
     108    hs_.stream() << anchor(href, std::string(first_orig,first));
     109    return true;
     110  }
     111
    36112
    37113  void Trac::print(std::string str)
     
    43119      if (ticket(first, str.end()))
    44120        continue;
     121      if (comment(first, str.end()))
     122        continue;
     123      if (changeset(first, str.end()))
     124        continue;
     125      if (diff(first, str.end()))
     126        continue;
    45127      hs_ << *first;
    46128      ++first;
     
    49131
    50132
     133  bool Trac::comment(std::string::const_iterator& first,
     134                     const std::string::const_iterator& last)
     135  {
     136    if (first==last)
     137      return false;
     138
     139    const std::string::const_iterator first_orig(first);
     140    if (match(first, last, Str("comment:ticket:")).empty()){
     141      first = first_orig;
     142      return false;
     143    }
     144     
     145    std::string ticket = match(first, last, Digit());
     146    if (ticket.empty() || first == last || *first != ':') {
     147      first = first_orig;
     148      return false;
     149    }
     150    ++first;
     151    std::string comment = match(first, last, Digit());
     152    if (comment.empty() ) {
     153      first = first_orig;
     154      return false;
     155    }
     156    std::string href(Configuration::instance().trac_root()+"ticket/"+ticket+
     157                     "#comment:"+comment);
     158    std::string str(first_orig, first);
     159    hs_.stream() << anchor(href, str);
     160    return true;
     161
     162
     163    const Configuration& conf = Configuration::instance();
     164    hs_.stream() << anchor(conf.trac_root()+"ticket/"+ticket,"#"+ticket);
     165    return true;
     166
     167  }
     168
     169
    51170  bool Trac::ticket(std::string::const_iterator& first,
    52171                    const std::string::const_iterator& last)
    53172  {
     173    if (ticket1(first, last))
     174      return true;
     175    if (ticket2(first, last))
     176      return true;
     177    return false;
     178  }
     179
     180
     181  bool Trac::ticket1(std::string::const_iterator& first,
     182                     const std::string::const_iterator& last)
     183  {
    54184    if (first==last)
    55185      return false;
     
    59189      return false;
    60190    ++first;
    61     std::string ticket;
    62     for (;first!=last && isdigit(*first); ++first)
    63       ticket.append(1,*first);
    64 
    65     if (ticket.empty())
    66       return false;
    67 
    68     Configuration* conf = Configuration::instance();
    69     hs_.stream() << anchor(conf->trac_ticket()+ticket,"#"+ticket);
     191    std::string ticket = match(first, last, Digit());
     192
     193    if (ticket.empty()) {
     194      first = first_orig;
     195      return false;
     196    }
     197
     198    const Configuration& conf = Configuration::instance();
     199    hs_.stream() << anchor(conf.trac_root()+"ticket/"+ticket,"#"+ticket);
     200    return true;
     201  }
     202
     203
     204  bool Trac::ticket2(std::string::const_iterator& first,
     205                     const std::string::const_iterator& last)
     206  {
     207    if (first==last)
     208      return false;
     209
     210    const std::string::const_iterator first_orig(first);
     211
     212    if (match(first, last, Str("ticket:")).empty()){
     213      first = first_orig;
     214      return false;
     215    }
     216     
     217    std::string ticket = match(first, last, Digit());
     218
     219    const Configuration& conf = Configuration::instance();
     220    hs_.stream() << anchor(conf.trac_root()+"ticket/"+ticket,"#"+ticket);
     221    return true;
     222  }
     223
     224
     225  bool Trac::diff(std::string::const_iterator& first,
     226                  const std::string::const_iterator& last)
     227  {
     228    if (diff1(first, last))
     229      return true;
     230    if (diff3(first, last))
     231      return true;
     232    if (diff2(first, last))
     233      return true;
     234    return false;
     235  }
     236
     237
     238  bool Trac::diff1(std::string::const_iterator& first,
     239                   const std::string::const_iterator& last)
     240  {
     241    if (first==last)
     242      return false;
     243
     244    const std::string::const_iterator first_orig(first);
     245    if (match(first, last, Str("diff:")).empty()){
     246      first = first_orig;
     247      return false;
     248    }
     249    std::string node = match(first, last, notChar('@'));
     250    if (first==last){
     251      first = first_orig;
     252      return false;
     253    }
     254    ++first;
     255    std::string old_rev = match(first, last, Digit());
     256    if (old_rev.empty() || first == last || *first != ':') {
     257      first = first_orig;
     258      return false;
     259    }
     260    ++first;
     261    std::string new_rev = match(first, last, Digit());
     262    if (new_rev.empty() ) {
     263      first = first_orig;
     264      return false;
     265    }
     266    std::string href;
     267    if (node.empty())
     268      href = std::string(Configuration::instance().trac_root()+
     269                         "changeset?new="+new_rev+"&old="+old_rev);
     270    else
     271      href = std::string(Configuration::instance().trac_root()+
     272                         "changeset?new="+new_rev+"&new_path="+node+"&old="+
     273                         old_rev+"&oldpath="+node);
     274    hs_.stream() << anchor(href, std::string(first_orig, first));
     275    return true;
     276  }
     277
     278
     279  bool Trac::diff2(std::string::const_iterator& first,
     280                   const std::string::const_iterator& last)
     281  {
     282    if (first==last)
     283      return false;
     284
     285    const std::string::const_iterator first_orig(first);
     286    if (match(first, last, Str("diff:")).empty()){
     287      first = first_orig;
     288      return false;
     289    }
     290    std::string old_path(match(first, last, not2Str("//", " ")));
     291    std::string new_path;
     292    if (first==last || *first==' ')
     293      new_path = old_path;
     294    else {
     295      first += 2;
     296      new_path = match(first, last, notChar(' '));
     297    }
     298    if (new_path.empty() || old_path.empty()){
     299      first = first_orig;
     300      return false;
     301    }
     302    std::string href(Configuration::instance().trac_root()+
     303                     "changeset?new_path="+new_path+"&old_path="+old_path);
     304    hs_.stream() << anchor(href, std::string(first_orig, first));
     305    return true;
     306  }
     307
     308
     309  bool Trac::diff3(std::string::const_iterator& first,
     310                   const std::string::const_iterator& last)
     311  {
     312    if (first==last)
     313      return false;
     314
     315    const std::string::const_iterator first_orig(first);
     316    if (match(first, last, Str("diff:")).empty()){
     317      first = first_orig;
     318      return false;
     319    }
     320    std::string old_path(match(first, last, not2Char('@', ' ')));
     321    if (*first!='@'){
     322      first = first_orig;
     323      return false;
     324    }
     325    ++first;
     326    std::string old_rev(match(first, last, Digit()));
     327    if (!match_begin(first, first+1, std::string("//"))) {
     328      first = first_orig;
     329      return false;
     330    }
     331    first+2;
     332    std::string new_path = match(first, last, not2Char('@', ' '));
     333    if (*first!='@'){
     334      first = first_orig;
     335      return false;
     336    }
     337    ++first;
     338    std::string new_rev(match(first, last, Digit()));
     339    if (new_rev.empty()){
     340      first = first_orig;
     341      return false;
     342    }
     343   
     344    std::string href(Configuration::instance().trac_root()+
     345                     "changeset?new="+new_rev+"&new_path="+new_path+
     346                     "&old="+old_rev+"&old_path="+old_path);
     347    hs_.stream() << anchor(href, std::string(first_orig, first));
    70348    return true;
    71349  }
     
    75353                 const std::string::const_iterator& last)
    76354  {
    77     if (first==last)
    78       return false;
    79 
    80     const std::string::const_iterator first_orig(first);
    81     if (*first != '#')
    82       return false;
    83     ++first;
    84     std::string ticket;
    85     for (;first!=last && isdigit(*first); ++first)
    86       ticket.append(1,*first);
    87 
    88     if (ticket.empty())
    89       return false;
    90 
    91     Configuration* conf = Configuration::instance();
    92     hs_.stream() << anchor(conf->trac_ticket()+ticket,"#"+ticket);
     355    if (log1(first, last))
     356      return true;
     357    if (log2(first, last))
     358      return true;
     359    if (log3(first, last))
     360      return true;
     361    return false;
     362  }
     363
     364
     365  bool Trac::log1(std::string::const_iterator& first,
     366                     const std::string::const_iterator& last)
     367  {
     368    if (first==last)
     369      return false;
     370
     371    const std::string::const_iterator first_orig(first);
     372    if (*first != 'r')
     373      return false;
     374    ++first;
     375
     376    std::string stop_rev = match(first, last, Digit());
     377    if (stop_rev.empty() || first == last || *first != ':') {
     378      first = first_orig;
     379      return false;
     380    }
     381    ++first;
     382    std::string rev = match(first, last, Digit());
     383    if (rev.empty() ) {
     384      first = first_orig;
     385      return false;
     386    }
     387    std::string href(Configuration::instance().trac_root()+"log/?rev="+
     388                     rev+"&stop_rev="+stop_rev);
     389    hs_.stream() << anchor(href, std::string(first_orig, first));
     390    return true;
     391  }
     392
     393
     394  bool Trac::log2(std::string::const_iterator& first,
     395                     const std::string::const_iterator& last)
     396  {
     397    if (first==last)
     398      return false;
     399
     400    const std::string::const_iterator first_orig(first);
     401    if (*first != '[')
     402      return false;
     403    ++first;
     404
     405    std::string stop_rev = match(first, last, Digit());
     406    if (stop_rev.empty() || first == last || *first != ':') {
     407      first = first_orig;
     408      return false;
     409    }
     410    ++first;
     411    std::string rev = match(first, last, Digit());
     412    if (rev.empty() || first == last || *first != ']') {
     413      first = first_orig;
     414      return false;
     415    }
     416    std::string href(Configuration::instance().trac_root()+"log/?rev="+
     417                     rev+"&stop_rev="+stop_rev);
     418    hs_.stream() << anchor(href, std::string(first_orig, first));
     419    return true;
     420  }
     421
     422
     423  bool Trac::log3(std::string::const_iterator& first,
     424                  const std::string::const_iterator& last)
     425  {
     426    if (first==last)
     427      return false;
     428
     429    const std::string::const_iterator first_orig(first);
     430
     431    const std::string log_str("log:");
     432    if (!match_begin(first, last, log_str)) {
     433      first = first_orig;
     434      return false;
     435    }
     436    first += log_str.size();
     437    std::string node = match(first, last, not2Char('#', '@'));
     438    ++first;
     439    std::string stop_rev = match(first, last, Digit());
     440    if (stop_rev.empty() || first == last || *first != ':') {
     441      first = first_orig;
     442      return false;
     443    }
     444    ++first;
     445    std::string rev = match(first, last, Digit());
     446    if (rev.empty() ) {
     447      first = first_orig;
     448      return false;
     449    }
     450    std::string href;
     451    if (!node.empty() && node[0]=='/')
     452      href = std::string(Configuration::instance().trac_root()+"log"+node+
     453                         "?rev="+rev+"&stop_rev="+stop_rev);
     454    else
     455      href = std::string(Configuration::instance().trac_root()+"log/"+node+
     456                         "?rev="+rev+"&stop_rev="+stop_rev);
     457     
     458    hs_.stream() << anchor(href, std::string(first_orig, first));
    93459    return true;
    94460  }
  • /trunk/lib/Trac.h

    r288 r294  
    5353                   const std::string::const_iterator& last);
    5454
     55    bool changeset1(std::string::const_iterator& first,
     56                   const std::string::const_iterator& last);
     57
     58    bool changeset2(std::string::const_iterator& first,
     59                   const std::string::const_iterator& last);
     60
     61    bool changeset3(std::string::const_iterator& first,
     62                   const std::string::const_iterator& last);
     63
     64    bool diff(std::string::const_iterator& first,
     65              const std::string::const_iterator& last);
     66
     67    bool diff1(std::string::const_iterator& first,
     68               const std::string::const_iterator& last);
     69
     70    bool diff2(std::string::const_iterator& first,
     71               const std::string::const_iterator& last);
     72
     73    bool diff3(std::string::const_iterator& first,
     74               const std::string::const_iterator& last);
     75
    5576    bool comment(std::string::const_iterator& first,
    5677                 const std::string::const_iterator& last);
     
    5879    bool log(std::string::const_iterator& first,
    5980             const std::string::const_iterator& last);
     81
     82    bool log1(std::string::const_iterator& first,
     83              const std::string::const_iterator& last);
     84
     85    bool log2(std::string::const_iterator& first,
     86              const std::string::const_iterator& last);
     87
     88    bool log3(std::string::const_iterator& first,
     89              const std::string::const_iterator& last);
    6090
    6191    bool milestone(std::string::const_iterator& first,
     
    6595                const std::string::const_iterator& last);
    6696
     97    bool ticket(std::string::const_iterator& first,
     98                const std::string::const_iterator& last);
     99
    67100    /// if range (first, last) starts with /#[:digit:]*/ a ticket link
    68101    /// is written;
    69102    /// @return if ticket is found iterator pointing to after found
    70103    /// ticket; else first is returned.
    71     bool ticket(std::string::const_iterator& first,
    72                 const std::string::const_iterator& last);
     104    bool ticket1(std::string::const_iterator& first,
     105                 const std::string::const_iterator& last);
     106
     107    bool ticket2(std::string::const_iterator& first,
     108                 const std::string::const_iterator& last);
     109
    73110
    74111
  • /trunk/lib/first_page.cc

    r288 r294  
    164164    std::string timefmt("%b %d %H:%M:%S %Y");
    165165    const size_t maxlength = 80;
    166     const Configuration* conf = Configuration::instance();
     166    const Configuration& conf = Configuration::instance();
    167167    for (size_t i=0; i<10 && a!=log.author().rend(); ++i) {
    168168      os << "<tr><td>" << anchor(*a+"/total/index.html",*a) << "</td>";
     
    181181        mess = mess.substr(0,maxlength-3) + "...";
    182182
    183       if (conf->trac_ticket().empty())
     183      if (conf.trac_root().empty())
    184184        hs << mess;
    185185      else {// make anchors to trac
  • /trunk/lib/html_utility.cc

    r288 r294  
    130130  std::string trac_revision(size_t r)
    131131  {
    132     Configuration* conf = Configuration::instance();
     132    const Configuration& conf = Configuration::instance();
    133133    std::stringstream ss;
    134     if (conf->trac_revision().empty())
     134    if (conf.trac_root().empty())
    135135      ss << r;
    136136    else {
    137137      std::stringstream rev;
    138138      rev << r;
    139       ss << anchor(conf->trac_revision()+rev.str(), rev.str());
     139      ss << anchor(conf.trac_root()+"changeset/"+rev.str(), rev.str());
    140140    }
    141141    return ss.str();
  • /trunk/lib/utility.cc

    r288 r294  
    165165
    166166
     167  notChar::notChar(char c)
     168    : char_(c)
     169  {}
     170
     171
     172  not2Char::not2Char(char c1, char c2)
     173    : char1_(c1), char2_(c2)
     174  {}
     175   
     176
     177  Str::Str(std::string s)
     178    : str_(s)
     179  {}
     180
     181
     182  not2Str::not2Str(std::string s1, std::string s2)
     183    : str1_(s1), str2_(s2)
     184  {}
     185   
     186
    167187}} // end of namespace svndigest and namespace theplu
  • /trunk/lib/utility.h

    r288 r294  
    132132  ///
    133133  inline std::string trim(std::string str) { return htrim(ltrim(str)); }
     134
     135
     136  template <class T>
     137  std::string match(std::string::const_iterator& first,
     138                    const std::string::const_iterator& last,
     139                    const T& func)
     140  {
     141    std::string res;
     142    for (;first!=last && func(first); ++first)
     143      res.append(1,*first);
     144    return res;
     145  }
     146
     147  struct Digit
     148  {
     149    inline bool operator()(std::string::const_iterator i) const
     150    { return isdigit(*i); }
     151  };
     152
     153  class notChar
     154  {
     155  public:
     156    notChar(char);
     157    inline bool operator()(std::string::const_iterator i) const
     158    { return *i!=char_; }
     159  private:
     160    char char_;
     161  };
     162
     163  class not2Char
     164  {
     165  public:
     166    not2Char(char, char);
     167    inline bool operator()(std::string::const_iterator i) const
     168    { return *i!=char1_ && *i!=char2_; }
     169  private:
     170    const char char1_;
     171    const char char2_;
     172  };
     173
     174  class Str
     175  {
     176  public:
     177    Str(std::string);
     178    inline bool operator()(std::string::const_iterator i) const
     179    { return (std::equal(str_.begin(), str_.end(), i)); }
     180
     181  private:
     182    const std::string str_;
     183  };
     184
     185  class not2Str
     186  {
     187  public:
     188    not2Str(std::string, std::string);
     189    inline bool operator()(std::string::const_iterator i) const
     190    {
     191      return !(std::equal(str1_.begin(), str1_.end(), i) ||
     192              std::equal(str2_.begin(), str2_.end(), i));
     193    }
     194
     195  private:
     196    const std::string str1_;
     197    const std::string str2_;
     198  };
    134199
    135200  ///
  • /trunk/test/repo/db/current

    r288 r294  
    1 47 1i 1
     150 1i 1
Note: See TracChangeset for help on using the changeset viewer.