/src/logging-log4cxx/src/main/cpp/appenderattachableimpl.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/helpers/appenderattachableimpl.h>
#include <algorithm>
#include <mutex>

using namespace LOG4CXX_NS;
using namespace LOG4CXX_NS::helpers;

IMPLEMENT_LOG4CXX_OBJECT(AppenderAttachableImpl)

struct AppenderAttachableImpl::priv_data
{
  /** Array of appenders. */
  AppenderList  appenderList;
  mutable std::mutex m_mutex;
};

AppenderAttachableImpl::AppenderAttachableImpl()
{
}

#if LOG4CXX_ABI_VERSION <= 15
AppenderAttachableImpl::AppenderAttachableImpl(Pool& pool)
  : m_priv()
{
}
#endif

AppenderAttachableImpl::~AppenderAttachableImpl()
{

}

void AppenderAttachableImpl::addAppender(const AppenderPtr newAppender)
{
  // Null values for newAppender parameter are strictly forbidden.
  if (!newAppender)
  {
    return;
  }
  if (!m_priv)
    m_priv = std::make_unique<AppenderAttachableImpl::priv_data>();

  std::lock_guard<std::mutex> lock( m_priv->m_mutex );
  AppenderList::iterator it = std::find(
      m_priv->appenderList.begin(), m_priv->appenderList.end(), newAppender);

  if (it == m_priv->appenderList.end())
  {
    m_priv->appenderList.push_back(newAppender);
  }
}

int AppenderAttachableImpl::appendLoopOnAppenders(
  const spi::LoggingEventPtr& event,
  Pool& p)
{
  int numberAppended = 0;
  if (m_priv)
  {
    // FallbackErrorHandler::error() may modify our list of appenders
    // while we are iterating over them (if it holds the same logger).
    // So, make a local copy of the appenders that we want to iterate over
    // before actually iterating over them.
    AppenderList allAppenders = getAllAppenders();
    for (auto appender : allAppenders)
    {
      appender->doAppend(event, p);
      numberAppended++;
    }
  }

  return numberAppended;
}

AppenderList AppenderAttachableImpl::getAllAppenders() const
{
  AppenderList result;
  if (m_priv)
  {
    std::lock_guard<std::mutex> lock( m_priv->m_mutex );
    result = m_priv->appenderList;
  }
  return result;
}

AppenderPtr AppenderAttachableImpl::getAppender(const LogString& name) const
{
  AppenderPtr result;
  if (m_priv && !name.empty())
  {
    std::lock_guard<std::mutex> lock( m_priv->m_mutex );
    for (auto appender : m_priv->appenderList)
    {
      if (name == appender->getName())
      {
        result = appender;
        break;
      }
    }
  }
  return result;
}

bool AppenderAttachableImpl::isAttached(const AppenderPtr appender) const
{
  bool result = false;
  if (m_priv && appender)
  {
    std::lock_guard<std::mutex> lock( m_priv->m_mutex );
    result = std::find(m_priv->appenderList.begin(), m_priv->appenderList.end(), appender) != m_priv->appenderList.end();
  }
  return result;
}

void AppenderAttachableImpl::removeAllAppenders()
{
  if (m_priv)
  {
    for (auto a : getAllAppenders())
      a->close();
    std::lock_guard<std::mutex> lock( m_priv->m_mutex );
    m_priv->appenderList.clear();
  }
}

void AppenderAttachableImpl::removeAppender(const AppenderPtr appender)
{
  if (m_priv && appender)
  {
    std::lock_guard<std::mutex> lock( m_priv->m_mutex );
    auto it = std::find(m_priv->appenderList.begin(), m_priv->appenderList.end(), appender);
    if (it != m_priv->appenderList.end())
    {
      m_priv->appenderList.erase(it);
    }
  }
}

void AppenderAttachableImpl::removeAppender(const LogString& name)
{
  if (m_priv && !name.empty())
  {
    std::lock_guard<std::mutex> lock( m_priv->m_mutex );
    auto it = std::find_if(m_priv->appenderList.begin(), m_priv->appenderList.end()
      , [&name](const AppenderPtr& appender) -> bool
      {
        return name == appender->getName();
      });
    if (it != m_priv->appenderList.end())
      m_priv->appenderList.erase(it);
  }
}

bool AppenderAttachableImpl::replaceAppender(const AppenderPtr& oldAppender, const AppenderPtr& newAppender)
{
  bool found = false;
  if (m_priv && oldAppender && newAppender)
  {
    auto oldName = oldAppender->getName();
    std::lock_guard<std::mutex> lock( m_priv->m_mutex );
    auto it = std::find_if(m_priv->appenderList.begin(), m_priv->appenderList.end()
      , [&oldName](const AppenderPtr& appender) -> bool
      {
        return oldName == appender->getName();
      });
    if (it != m_priv->appenderList.end())
    {
      *it = newAppender;
      found = true;
    }
  }
  return found;
}

void AppenderAttachableImpl::replaceAppenders(const AppenderList& newList)
{
  auto oldAppenders = getAllAppenders();
  if (!m_priv)
    m_priv = std::make_unique<AppenderAttachableImpl::priv_data>();
  std::lock_guard<std::mutex> lock( m_priv->m_mutex );
  for (auto a : oldAppenders)
    a->close();
  m_priv->appenderList = newList;
}



Coverage Report

Created: 2025-07-18 06:17