%module li_std_auto_ptr

%{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
#pragma GCC diagnostic ignored "-Wdeprecated-declarations" // auto_ptr deprecation
#endif

#if defined(__clang__)
#pragma clang diagnostic push
// Suppress 'auto_ptr<>' is deprecated
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
%}

#if !(defined(SWIGGO) || defined(SWIGOCAML) || defined(SWIGR) || defined(SWIGSCILAB))

%warnfilter(509, 516) overloadTest(Klass);

%include "std_string.i"
//#include <iostream>
%include "std_auto_ptr.i"

%auto_ptr(Klass)

%inline %{
void show_cplusplus_version() {
  printf("__cplusplus %d\n", (int)__cplusplus);
}
%}

%{
#if __cplusplus < 201703L
#include <memory>
#else

// If <memory> has already been include (Octave does) then unfortunately gcc incorrectly still provides
// std::auto_ptr when _GLIBCXX_USE_DEPRECATED is defined by the compiler configuration/OS/who knows what!!
#include <memory> // Now need to include it in case _GLIBCXX_USE_DEPRECATED is defined and <memory> has not been included, argh
#if !defined(_GLIBCXX_USE_DEPRECATED)
// Simple std::auto_ptr implementation for testing after its removal in C++17
namespace std {
  template <class T> class auto_ptr {
    T *ptr;
    public:
      explicit auto_ptr(T *p = 0) : ptr(p) {}
      auto_ptr(auto_ptr&& a) : ptr(a.ptr) { a.ptr = 0;}
      ~auto_ptr() { delete ptr; }
      T *release() { T *p = ptr; ptr = 0; return p; }
      T* get() const { return ptr; }
      void reset(T *p = 0) { delete ptr; ptr = p; }
      T &operator*() const { return *ptr; }
      T *operator->() const { return ptr; }
      auto_ptr& operator=(auto_ptr&& a) { if (&a != this) { delete ptr; ptr = a.ptr; a.ptr = 0; } return *this; }
  };
}
#endif

#endif

#include <string>
#include "swig_examples_lock.h"
%}

%inline %{

class Klass {
public:
  explicit Klass(const char* label) :
    m_label(label)
  {
    SwigExamples::Lock lock(critical_section);
    total_count++;
  }

  const char* getLabel() const { return m_label.c_str(); }

  virtual ~Klass()
  {
    SwigExamples::Lock lock(critical_section);
    total_count--;
  }

  static int getTotal_count() { return total_count; }

private:
  static SwigExamples::CriticalSection critical_section;
  static int total_count;

  std::string m_label;
};

SwigExamples::CriticalSection Klass::critical_section;
int Klass::total_count = 0;

%}

%inline %{

// Virtual inheritance used as this usually results in different values for Klass* and KlassInheritance*
// for testing class inheritance and auto_ptr
struct KlassInheritance : virtual Klass {
  KlassInheritance(const char* label) : Klass(label) {
    // std::cout << "ptrs.... " << std::hex << (Klass*)this << " " << (KlassInheritance*)this << std::endl;
  }
};

std::string useKlassRawPtr(Klass* k) {
//  std::cout << "useKlassRawPtr " << std::hex << (Klass*)k << std::endl;
  std::string s(k->getLabel());
//  std::cout << "useKlassRawPtr string: " << s << std::endl;
  return s;
}

std::string takeKlassAutoPtr(std::auto_ptr<Klass> k) {
//  std::cout << "takeKlassAutoPtr " << std::hex << (Klass*)k.get() << std::endl;
  std::string s(k.get() ? k->getLabel() : "null smart pointer");
//  std::cout << "takeKlassAutoPtr string: " << s << std::endl;
  return s;
}

Klass *make_null() {
  return 0;
}

bool is_nullptr(Klass *p) {
  return p == 0;
}

Klass *get_not_owned_ptr(Klass *p) {
  return p;
}

std::auto_ptr<Klass> makeKlassAutoPtr(const char* label) {
  return std::auto_ptr<Klass>(new Klass(label));
}

std::auto_ptr<Klass> makeNullAutoPtr() {
  return std::auto_ptr<Klass>();
}

int overloadTest() {
  return 0;
}

int overloadTest(std::auto_ptr<Klass> kover) {
  return 1;
}

int overloadTest(Klass k) {
  return 2;
}

%}

#endif