traceElement.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_TRACE_ELEMENT_HPP_INCLUDED
#define _STRUS_TRACE_ELEMENT_HPP_INCLUDED
#include <string>
#include <cstring>
#include "strus/base/stdint.h"

namespace strus
{

typedef unsigned int TraceObjectId;             
typedef unsigned int TraceTimeCounter;          
typedef std::size_t TraceLogRecordHandle;       

struct TraceElement
{
        typedef int64_t IntType;
        typedef uint64_t UIntType;

        enum Type
        {
                TypeVoid,
                TypeInt,
                TypeUInt,
                TypeDouble,
                TypeBool,
                TypeObject,
                TypeString,
                TypeOpenIndex,
                TypeOpenTag,
                TypeClose
        };

        union Value
        {
                UIntType UInt;
                IntType Int;
                double Double;
                bool Bool;
                std::size_t Index;
                struct { TraceObjectId Id; const char* Class; } Obj;
                struct { const char* Ptr; std::size_t Size; } String;
        };

        Type type() const
        {
                return m_type;
        }
        Value value() const
        {
                return m_value;
        }

        TraceElement() :m_type(TypeVoid)                                {m_value.UInt = 0;}
        TraceElement( IntType value_) :m_type(TypeInt)                  {m_value.Int = value_;}
        TraceElement( UIntType value_) :m_type(TypeUInt)                {m_value.UInt = value_;}
        TraceElement( double value_) :m_type(TypeDouble)                {m_value.Double = value_;}
        TraceElement( float value_) :m_type(TypeDouble)                 {m_value.Double = value_;}
        TraceElement( bool value_) :m_type(TypeBool)                    {m_value.Bool = value_;}
        TraceElement( Type type_, std::size_t index_) :m_type(type_)    {m_value.Index = index_;}
        TraceElement( Type type_, TraceObjectId oid_, const char* cid_)
                :m_type(type_) {m_value.Obj.Class = cid_; m_value.Obj.Id = oid_;}
        TraceElement( Type type_, const char* ptr_, std::size_t size_)
                :m_type(type_) {m_value.String.Ptr = ptr_; m_value.String.Size = size_;}
        TraceElement( Type type_, const char* ptr_)
                :m_type(type_) {m_value.String.Ptr = ptr_; m_value.String.Size = ptr_?std::strlen(ptr_):0;}
        TraceElement( Type type_)
                :m_type(type_) {m_value.UInt = 0;}

        TraceElement( const TraceElement& o)
        {
                std::memcpy( this, &o, sizeof(*this));
        }

private:
        Type m_type;
        Value m_value;
};

} //namespace
#endif