/src/logging-log4cxx/src/main/cpp/level.cpp

Source (jump to first uncovered line)
/*
 * 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.
 */

#include <log4cxx/logstring.h>
#include <log4cxx/level.h>
#include <log4cxx/helpers/stringhelper.h>
#include <log4cxx/helpers/transcoder.h>
#if !defined(LOG4CXX)
  #define LOG4CXX 1
#endif
#include <log4cxx/helpers/aprinitializer.h>
#include <mutex>

using namespace LOG4CXX_NS;
using namespace LOG4CXX_NS::helpers;

IMPLEMENT_LOG4CXX_OBJECT_WITH_CUSTOM_CLASS(Level, LevelClass)

LevelPtr Level::getOff()
{
  static WideLife<LevelPtr> offLevel = std::make_shared<Level>(Level::OFF_INT, LOG4CXX_STR("OFF"), 0);
  return offLevel;
}

LevelPtr Level::getFatal()
{
  static WideLife<LevelPtr> fatalLevel = std::make_shared<Level>(Level::FATAL_INT, LOG4CXX_STR("FATAL"), 0);
  return fatalLevel;
}

LevelPtr Level::getError()
{
  static WideLife<LevelPtr> errorLevel = std::make_shared<Level>(Level::ERROR_INT, LOG4CXX_STR("ERROR"), 3);
  return errorLevel;
}

LevelPtr Level::getWarn()
{
  static WideLife<LevelPtr> warnLevel = std::make_shared<Level>(Level::WARN_INT, LOG4CXX_STR("WARN"), 4);
  return warnLevel;
}

LevelPtr Level::getInfo()
{
  static WideLife<LevelPtr> infoLevel = std::make_shared<Level>(Level::INFO_INT, LOG4CXX_STR("INFO"), 6);
  return infoLevel;
}

LevelPtr Level::getDebug()
{
  static WideLife<LevelPtr> debugLevel = std::make_shared<Level>(Level::DEBUG_INT, LOG4CXX_STR("DEBUG"), 7);
  return debugLevel;
}

LevelPtr Level::getTrace()
{
  static WideLife<LevelPtr> traceLevel = std::make_shared<Level>(Level::TRACE_INT, LOG4CXX_STR("TRACE"), 7);
  return traceLevel;
}


LevelPtr Level::getAll()
{
  static WideLife<LevelPtr> allLevel = std::make_shared<Level>(Level::ALL_INT, LOG4CXX_STR("ALL"), 7);
  return allLevel;
}



Level::Level(int level1,
  const LogString& name1, int syslogEquivalent1)
  : level(level1), name(name1), syslogEquivalent(syslogEquivalent1)
{
}


LevelPtr Level::toLevelLS(const LogString& sArg)
{
  return toLevelLS(sArg, Level::getDebug());
}

LogString Level::toString() const
{
  return name;
}


LevelPtr Level::toLevel(int val)
{
  return toLevel(val, Level::getDebug());
}

const Level::DataPtr& Level::getData()
{
  static WideLife<DataPtr> data = std::make_shared<Data>(Data
    { getOff()
    , getFatal()
    , getError()
    , getWarn()
    , getInfo()
    , getDebug()
    , getTrace()
    , getAll()
    });
  return data;
}


LevelPtr Level::toLevel(int val, const LevelPtr& defaultLevel)
{
  switch (val)
  {
    case ALL_INT:
      return getAll();

    case DEBUG_INT:
      return getDebug();

    case TRACE_INT:
      return getTrace();

    case INFO_INT:
      return getInfo();

    case WARN_INT:
      return getWarn();

    case ERROR_INT:
      return getError();

    case FATAL_INT:
      return getFatal();

    case OFF_INT:
      return getOff();

    default:
      return defaultLevel;
  }
}

LevelPtr Level::toLevel(const std::string& sArg)
{
  return toLevel(sArg, Level::getDebug());
}

LevelPtr Level::toLevel(const std::string& sArg, const LevelPtr& defaultLevel)
{
  LOG4CXX_DECODE_CHAR(s, sArg);
  return toLevelLS(s, defaultLevel);
}

void Level::toString(std::string& dst) const
{
  Transcoder::encode(name, dst);
}

#if LOG4CXX_WCHAR_T_API
LevelPtr Level::toLevel(const std::wstring& sArg)
{
  return toLevel(sArg, Level::getDebug());
}

LevelPtr Level::toLevel(const std::wstring& sArg, const LevelPtr& defaultLevel)
{
  LOG4CXX_DECODE_WCHAR(s, sArg);
  return toLevelLS(s, defaultLevel);
}

void Level::toString(std::wstring& dst) const
{
  Transcoder::encode(name, dst);
}

#endif

#if LOG4CXX_UNICHAR_API || LOG4CXX_LOGCHAR_IS_UNICHAR
LevelPtr Level::toLevel(const std::basic_string<UniChar>& sArg)
{
  return toLevel(sArg, Level::getDebug());
}

LevelPtr Level::toLevel(const std::basic_string<UniChar>& sArg, const LevelPtr& defaultLevel)
{
  LOG4CXX_DECODE_UNICHAR(s, sArg);
  return toLevelLS(s, defaultLevel);
}

void Level::toString(std::basic_string<UniChar>& dst) const
{
  Transcoder::encode(name, dst);
}

#endif

#if LOG4CXX_CFSTRING_API
LevelPtr Level::toLevel(const CFStringRef& sArg)
{
  return toLevel(sArg, Level::getDebug());
}

LevelPtr Level::toLevel(const CFStringRef& sArg, const LevelPtr& defaultLevel)
{
  LogString s;
  Transcoder::decode(sArg, s);
  return toLevelLS(s, defaultLevel);
}

void Level::toString(CFStringRef& dst) const
{
  dst = Transcoder::encode(name);
}
#endif


LevelPtr Level::toLevelLS(const LogString& sArg, const LevelPtr& defaultLevel)
{
  const LogString trimmed(StringHelper::trim(sArg));
  const size_t len = trimmed.length();

  if (len == 4)
  {
    if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("INFO"), LOG4CXX_STR("info")))
    {
      return getInfo();
    }

    if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("WARN"), LOG4CXX_STR("warn")))
    {
      return getWarn();
    }
  }
  else
  {
    if (len == 5)
    {
      if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("DEBUG"), LOG4CXX_STR("debug")))
      {
        return getDebug();
      }

      if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("TRACE"), LOG4CXX_STR("trace")))
      {
        return getTrace();
      }

      if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("ERROR"), LOG4CXX_STR("error")))
      {
        return getError();
      }

      if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("FATAL"), LOG4CXX_STR("fatal")))
      {
        return getFatal();
      }
    }
    else
    {
      if (len == 3)
      {
        if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("OFF"), LOG4CXX_STR("off")))
        {
          return getOff();
        }

        if (StringHelper::equalsIgnoreCase(trimmed, LOG4CXX_STR("ALL"), LOG4CXX_STR("all")))
        {
          return getAll();
        }
      }
    }
  }

  return defaultLevel;
}


bool Level::equals(const LevelPtr& level1) const
{
  return level1 && this->level == level1->level;
}

bool Level::isGreaterOrEqual(const LevelPtr& level1) const
{
  return level1 && this->level >= level1->level;
}


Coverage Report

Created: 2025-07-12 06:12