src/bvar/mvariable.h

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

// Date: 2021/11/17 14:37:53

#ifndef BVAR_MVARIABLE_H
#define BVAR_MVARIABLE_H

#include <ostream>                      // std::ostream
#include <sstream>                      // std::ostringstream
#include <list>                         // std::list
#include <string>                       // std::string
#include "butil/macros.h"               // DISALLOW_COPY_AND_ASSIGN
#include "butil/strings/string_piece.h" // butil::StringPiece

namespace bvar {

class Dumper;
struct DumpOptions;

class MVariableBase {
public:
    MVariableBase() = default;

    virtual ~MVariableBase();

    // Implement this method to print the mvariable info into ostream.
    virtual void describe(std::ostream&) = 0;

    // string form of describe().
    std::string get_description();
   
    // Get mvariable name
    const std::string& name() const { return _name; }

    // Expose this mvariable globally so that it's counted in following
    // functions:
    //      list_exposed
    //      count_exposed
    // Return 0 on success, -1 otherwise.
    int expose(const butil::StringPiece& name) {
        return expose_impl(butil::StringPiece(), name);
    }

    // Expose this mvariable globally with a prefix
    // Return 0 on success, -1 otherwise.
    int expose_as(const butil::StringPiece& prefix,
                  const butil::StringPiece& name) {
        return expose_impl(prefix, name);
    }

    // Dump this mvariable
    virtual size_t dump(Dumper* dumper, const DumpOptions* options) = 0;

    // Hide this variable so that it's not counted in *_exposed functions.
    // Returns false if this variable is already hidden.
    // CAUTION!! Subclasses must call hide() manually to avoid displaying
    // a variable that is just destructing.
    bool hide();

    // Get number of exposed mvariables.
    static size_t count_exposed();

    // Put names of all exposed mvariable into `name'.
    static void list_exposed(std::vector<std::string> *names);

    // Find all exposed mvariables matching `white_wildcards' but
    // `black_wildcards' and send them to `dumper'.
    // Use default options when `options' is NULL.
    // Return number of dumped mvariables, -1 on error.
    static size_t dump_exposed(Dumper* dumper, const DumpOptions* options);

    // Find an exposed mvariable by `name' and put its description into `os'.
    // Returns 0 on found, -1 otherwise.
    static int describe_exposed(const std::string& name,
                                std::ostream& os);

    // String form. Returns empty string when not found.
    static std::string describe_exposed(const std::string& name);

#ifdef UNIT_TEST
    // Hide all mvariables so that all mvariables not counted in following
    // functions:
    //      list_exposed
    //      count_exposed
    // CAUTION!!! Just For Debug!!!
    static void hide_all();
#endif

protected:
    int expose_impl(const butil::StringPiece& prefix,
                    const butil::StringPiece& name);

protected:
    std::string _name;

    // mbvar uses bvar, bvar uses TLS, thus copying/assignment need to copy TLS stuff as well,
    // which is heavy. We disable copying/assignment now. 
    DISALLOW_COPY_AND_ASSIGN(MVariableBase);
};

template <typename KeyType>
class MVariable : public MVariableBase {
public:
    explicit MVariable(const KeyType& labels) : _labels(labels.cbegin(), labels.cend()) {
        static_assert(std::is_same<typename KeyType::value_type, std::string>::value,
                      "value_type of KeyType must be std::string");
    }

    // Get mvariable labels
    const KeyType& labels() const { return _labels; }

    // Get number of mvariable labels
    size_t count_labels() const { return _labels.size(); }

protected:
    KeyType  _labels;
};

} // namespace bvar

#endif  // BVAR_MVARIABLE_H