trace_argument.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2016 Couchbase, Inc
 *
 *   Licensed 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.
 */
#pragma once

#include <cstddef>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>

#include "inline_zstring.h"
#include "platform/core.h"

namespace phosphor {

    struct NoneType {
    };

    union TraceArgument {
        enum class Type : char {
            is_bool,
            is_uint,
            is_int,
            is_double,
            is_pointer,
            is_string,
            is_istring,
            is_none
        };

        bool as_bool;
        unsigned long long as_uint;
        long long as_int;
        double as_double;
        const char* as_string;
        const void* as_pointer;
        inline_zstring<8> as_istring;
        NoneType as_none;

        TraceArgument() = default;

        template <class T>
        inline constexpr TraceArgument(T src);

        inline std::string to_string(TraceArgument::Type type) const;

    private:
        template <TraceArgument::Type T>
        inline std::string internal_to_string();
    };

    template <typename T>
    class TraceArgumentConversion {
    public:
        inline static constexpr TraceArgument::Type getType();

        inline static constexpr TraceArgument asArgument(T arg);
    };

    static_assert(sizeof(TraceArgument) <= 8,
                  "TraceArgument must be 8 or less bytes");

#define ARGUMENT_CONVERSION(src, dst) \
    template <> \
    inline constexpr TraceArgument::TraceArgument(src arg) : as_##dst(arg) {} \
    template<> \
    class TraceArgumentConversion<src> { \
        public:\
        inline static constexpr TraceArgument::Type getType() { \
            return TraceArgument::Type::is_##dst; \
        } \
        \
        inline static constexpr TraceArgument asArgument(src arg) { \
            return TraceArgument(arg); \
        } \
    };

    ARGUMENT_CONVERSION(bool, bool)

    ARGUMENT_CONVERSION(char, int)

    ARGUMENT_CONVERSION(short, int)

    ARGUMENT_CONVERSION(int, int)

    ARGUMENT_CONVERSION(long, int)

    ARGUMENT_CONVERSION(long long, int)

    ARGUMENT_CONVERSION(unsigned char, uint)

    ARGUMENT_CONVERSION(unsigned short, uint)

    ARGUMENT_CONVERSION(unsigned int, uint)

    ARGUMENT_CONVERSION(unsigned long, uint)

    ARGUMENT_CONVERSION(unsigned long long, uint)

    ARGUMENT_CONVERSION(float, double)

    ARGUMENT_CONVERSION(double, double)

    ARGUMENT_CONVERSION(const void*, pointer)

    // A nullptr isn't particulary useful to store in the trace event;
    // but aids in use with generic code where a pointer type ends up
    // as nullptr.
    ARGUMENT_CONVERSION(std::nullptr_t, pointer)

    ARGUMENT_CONVERSION(const char*, string)

    ARGUMENT_CONVERSION(inline_zstring<8>, istring)

    ARGUMENT_CONVERSION(NoneType, none)

#undef ARGUMENT_CONVERSION

    template<typename T>
    class TraceArgumentConversion<T*> {
        public:

        inline static constexpr TraceArgument::Type getType() {
            return TraceArgument::Type::is_pointer;
        }

        inline static constexpr TraceArgument asArgument(T* arg) {

            // This relies on the 'const void*' -> pointer
            // conversion defined above.
            return TraceArgument(static_cast<const void*>(arg));
        }
    };

    inline std::string TraceArgument::to_string(
        TraceArgument::Type type) const {
        std::stringstream ss;
        switch (type) {
        case Type::is_bool:
            return as_bool ? "true" : "false";
        case Type::is_int:
            return std::to_string(as_int);
        case Type::is_uint:
            return std::to_string(as_uint);
        case Type::is_double:
            return std::to_string(as_double);
        case Type::is_pointer:
            ss << as_pointer;
            return "\"" + ss.str() + "\"";
        case Type::is_string:
            return "\"" + std::string(as_string) + "\"";
        case Type::is_istring:
            return "\"" + std::string(as_istring) + "\"";
        case Type::is_none:
            return std::string("\"Type::is_none\"");
        }
        throw std::invalid_argument("Invalid TraceArgument type");
    }
}  // namespace phosphor