/*

 * 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()

{

}

Unexecuted instantiation: log4cxx::helpers::AppenderAttachableImpl::AppenderAttachableImpl()

Unexecuted instantiation: log4cxx::helpers::AppenderAttachableImpl::AppenderAttachableImpl()

#if LOG4CXX_ABI_VERSION <= 15

AppenderAttachableImpl::AppenderAttachableImpl(Pool& pool)

  : m_priv()

{

}

Unexecuted instantiation: log4cxx::helpers::AppenderAttachableImpl::AppenderAttachableImpl(log4cxx::helpers::Pool&)

Unexecuted instantiation: log4cxx::helpers::AppenderAttachableImpl::AppenderAttachableImpl(log4cxx::helpers::Pool&)

#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;

}