/*

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

using AppenderListPtr = std::shared_ptr<const AppenderList>;

/** A vector of appender pointers. */

struct AppenderAttachableImpl::priv_data

{

private: // Attributes

#ifdef __cpp_lib_atomic_shared_ptr

  std::atomic<AppenderListPtr> pAppenderList;

#else // !defined(__cpp_lib_atomic_shared_ptr)

  AppenderListPtr    pAppenderList;

  mutable std::mutex m_mutex;

#endif // !defined(__cpp_lib_atomic_shared_ptr)

public: // ...structors

  priv_data(const AppenderList& newList = {})

    : pAppenderList{ std::make_shared<const AppenderList>(newList) }

  {}

public: // Accessors

  AppenderListPtr getAppenders() const

  {

#ifdef __cpp_lib_atomic_shared_ptr

    return pAppenderList.load(std::memory_order_acquire);

#else // !defined(__cpp_lib_atomic_shared_ptr)

    std::lock_guard<std::mutex> lock( m_mutex );

    return pAppenderList;

#endif // !defined(__cpp_lib_atomic_shared_ptr)

  }

public: // Modifiers

  void setAppenders(const AppenderList& newList)

  {

#ifdef __cpp_lib_atomic_shared_ptr

    pAppenderList.store(std::make_shared<AppenderList>(newList), std::memory_order_release);

#else // !defined(__cpp_lib_atomic_shared_ptr)

    std::lock_guard<std::mutex> lock( m_mutex );

    pAppenderList = std::make_shared<const AppenderList>(newList);

#endif // !defined(__cpp_lib_atomic_shared_ptr)

  }

};

AppenderAttachableImpl::AppenderAttachableImpl()

{

}

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

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

#if LOG4CXX_ABI_VERSION <= 15

AppenderAttachableImpl::AppenderAttachableImpl(Pool& pool)

{

}

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)

{

  if (!newAppender)

    return;

  if (m_priv)

  {

    auto allAppenders = m_priv->getAppenders();

    if (allAppenders->end() == std::find(allAppenders->begin(), allAppenders->end(), newAppender))

    {

      auto newAppenders = *allAppenders;

      newAppenders.push_back(newAppender);

      m_priv->setAppenders(newAppenders);

    }

  }

  else

    m_priv = std::make_unique<priv_data>(AppenderList{newAppender});

}

int AppenderAttachableImpl::appendLoopOnAppenders(const spi::LoggingEventPtr& event, Pool& p)

{

  int result = 0;

  if (m_priv)

  {

    auto allAppenders = m_priv->getAppenders();

    for (auto& appender : *allAppenders)

    {

      appender->doAppend(event, p);

      ++result;

    }

  }

  return result;

}

AppenderList AppenderAttachableImpl::getAllAppenders() const

{

  AppenderList result;

  if (m_priv)

    result = *m_priv->getAppenders();

  return result;

}

AppenderPtr AppenderAttachableImpl::getAppender(const LogString& name) const

{

  AppenderPtr result;

  if (m_priv)

  {

    auto allAppenders = m_priv->getAppenders();

    for (auto& appender : *allAppenders)

    {

      if (name == appender->getName())

      {

        result = appender;

        break;

      }

    }

  }

  return result;

}

bool AppenderAttachableImpl::isAttached(const AppenderPtr appender) const

{

  bool result = false;

  if (m_priv && appender)

  {

    auto allAppenders = m_priv->getAppenders();

    result = allAppenders->end() != std::find(allAppenders->begin(), allAppenders->end(), appender);

  }

  return result;

}

void AppenderAttachableImpl::removeAllAppenders()

{

  if (m_priv)

  {

    auto allAppenders = m_priv->getAppenders();

    for (auto& appender : *allAppenders)

      appender->close();

    m_priv->setAppenders({});

  }

}

void AppenderAttachableImpl::removeAppender(const AppenderPtr appender)

{

  if (m_priv && appender)

  {

    auto newAppenders = *m_priv->getAppenders();

    auto pItem = std::find(newAppenders.begin(), newAppenders.end(), appender);

    if (newAppenders.end() != pItem)

    {

      newAppenders.erase(pItem);

      m_priv->setAppenders(newAppenders);

    }

  }

}

void AppenderAttachableImpl::removeAppender(const LogString& name)

{

  if (m_priv)

  {

    auto newAppenders = *m_priv->getAppenders();

    auto pItem = std::find_if(newAppenders.begin(), newAppenders.end()

      , [&name](const AppenderPtr& appender) -> bool

      {

        return name == appender->getName();

      });

    if (newAppenders.end() != pItem)

    {

      newAppenders.erase(pItem);

      m_priv->setAppenders(newAppenders);

    }

  }

}

bool AppenderAttachableImpl::replaceAppender(const AppenderPtr& oldAppender, const AppenderPtr& newAppender)

{

  bool found = false;

  if (m_priv && oldAppender && newAppender)

  {

    auto name = oldAppender->getName();

    auto newAppenders = *m_priv->getAppenders();

    auto pItem = std::find_if(newAppenders.begin(), newAppenders.end()

      , [&name](const AppenderPtr& appender) -> bool

      {

        return name == appender->getName();

      });

    if (newAppenders.end() != pItem)

    {

      *pItem = newAppender;

      m_priv->setAppenders(newAppenders);

      found = true;

    }

  }

  return found;

}

void AppenderAttachableImpl::replaceAppenders(const AppenderList& newList)

{

  if (m_priv)

  {

    auto allAppenders = m_priv->getAppenders();

    for (auto& a : *allAppenders)

      a->close();

    m_priv->setAppenders(newList);

  }

  else

    m_priv = std::make_unique<priv_data>(newList);

}