/*
    tests/test_smart_ptr.cpp -- binding classes with custom reference counting,
    implicit conversions between types

    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

#if defined(_MSC_VER) && _MSC_VER < 1910
#  pragma warning(disable: 4702) // unreachable code in system header
#endif

#include "pybind11_tests.h"
#include "object.h"

// Make pybind aware of the ref-counted wrapper type (s):

// ref<T> is a wrapper for 'Object' which uses intrusive reference counting
// It is always possible to construct a ref<T> from an Object* pointer without
// possible inconsistencies, hence the 'true' argument at the end.
PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true);
// Make pybind11 aware of the non-standard getter member function
namespace pybind11 { namespace detail {
    template <typename T>
    struct holder_helper<ref<T>> {
        static const T *get(const ref<T> &p) { return p.get_ptr(); }
    };
} // namespace detail
} // namespace pybind11

// The following is not required anymore for std::shared_ptr, but it should compile without error:
PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);

// This is just a wrapper around unique_ptr, but with extra fields to deliberately bloat up the
// holder size to trigger the non-simple-layout internal instance layout for single inheritance with
// large holder type:
template <typename T> class huge_unique_ptr {
    std::unique_ptr<T> ptr;
    uint64_t padding[10];
public:
    huge_unique_ptr(T *p) : ptr(p) {};
    T *get() { return ptr.get(); }
};
PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>);

// Simple custom holder that works like unique_ptr
template <typename T>
class custom_unique_ptr {
    std::unique_ptr<T> impl;
public:
    custom_unique_ptr(T* p) : impl(p) { }
    T* get() const { return impl.get(); }
    T* release_ptr() { return impl.release(); }
};
PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>);

// Simple custom holder that works like shared_ptr and has operator& overload
// To obtain address of an instance of this holder pybind should use std::addressof
// Attempt to get address via operator& may leads to segmentation fault
template <typename T>
class shared_ptr_with_addressof_operator {
    std::shared_ptr<T> impl;
public:
    shared_ptr_with_addressof_operator( ) = default;
    shared_ptr_with_addressof_operator(T* p) : impl(p) { }
    T* get() const { return impl.get(); }
    T** operator&() { throw std::logic_error("Call of overloaded operator& is not expected"); }
};
PYBIND11_DECLARE_HOLDER_TYPE(T, shared_ptr_with_addressof_operator<T>);

// Simple custom holder that works like unique_ptr and has operator& overload
// To obtain address of an instance of this holder pybind should use std::addressof
// Attempt to get address via operator& may leads to segmentation fault
template <typename T>
class unique_ptr_with_addressof_operator {
    std::unique_ptr<T> impl;
public:
    unique_ptr_with_addressof_operator() = default;
    unique_ptr_with_addressof_operator(T* p) : impl(p) { }
    T* get() const { return impl.get(); }
    T* release_ptr() { return impl.release(); }
    T** operator&() { throw std::logic_error("Call of overloaded operator& is not expected"); }
};
PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator<T>);


TEST_SUBMODULE(smart_ptr, m) {

    // test_smart_ptr

    // Object implementation in `object.h`
    py::class_<Object, ref<Object>> obj(m, "Object");
    obj.def("getRefCount", &Object::getRefCount);

    // Custom object with builtin reference counting (see 'object.h' for the implementation)
    class MyObject1 : public Object {
    public:
        MyObject1(int value) : value(value) { print_created(this, toString()); }
        std::string toString() const override { return "MyObject1[" + std::to_string(value) + "]"; }
    protected:
        ~MyObject1() override { print_destroyed(this); }
    private:
        int value;
    };
    py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj)
        .def(py::init<int>());
    py::implicitly_convertible<py::int_, MyObject1>();

    m.def("make_object_1", []() -> Object * { return new MyObject1(1); });
    m.def("make_object_2", []() -> ref<Object> { return new MyObject1(2); });
    m.def("make_myobject1_1", []() -> MyObject1 * { return new MyObject1(4); });
    m.def("make_myobject1_2", []() -> ref<MyObject1> { return new MyObject1(5); });
    m.def("print_object_1", [](const Object *obj) { py::print(obj->toString()); });
    m.def("print_object_2", [](ref<Object> obj) { py::print(obj->toString()); });
    m.def("print_object_3", [](const ref<Object> &obj) { py::print(obj->toString()); });
    m.def("print_object_4", [](const ref<Object> *obj) { py::print((*obj)->toString()); });
    m.def("print_myobject1_1", [](const MyObject1 *obj) { py::print(obj->toString()); });
    m.def("print_myobject1_2", [](ref<MyObject1> obj) { py::print(obj->toString()); });
    m.def("print_myobject1_3", [](const ref<MyObject1> &obj) { py::print(obj->toString()); });
    m.def("print_myobject1_4", [](const ref<MyObject1> *obj) { py::print((*obj)->toString()); });

    // Expose constructor stats for the ref type
    m.def("cstats_ref", &ConstructorStats::get<ref_tag>);


    // Object managed by a std::shared_ptr<>
    class MyObject2 {
    public:
        MyObject2(const MyObject2 &) = default;
        MyObject2(int value) : value(value) { print_created(this, toString()); }
        std::string toString() const { return "MyObject2[" + std::to_string(value) + "]"; }
        virtual ~MyObject2() { print_destroyed(this); }
    private:
        int value;
    };
    py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2")
        .def(py::init<int>());
    m.def("make_myobject2_1", []() { return new MyObject2(6); });
    m.def("make_myobject2_2", []() { return std::make_shared<MyObject2>(7); });
    m.def("print_myobject2_1", [](const MyObject2 *obj) { py::print(obj->toString()); });
    m.def("print_myobject2_2", [](std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); });
    m.def("print_myobject2_3", [](const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); });
    m.def("print_myobject2_4", [](const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); });

    // Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<>
    class MyObject3 : public std::enable_shared_from_this<MyObject3> {
    public:
        MyObject3(const MyObject3 &) = default;
        MyObject3(int value) : value(value) { print_created(this, toString()); }
        std::string toString() const { return "MyObject3[" + std::to_string(value) + "]"; }
        virtual ~MyObject3() { print_destroyed(this); }
    private:
        int value;
    };
    py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3")
        .def(py::init<int>());
    m.def("make_myobject3_1", []() { return new MyObject3(8); });
    m.def("make_myobject3_2", []() { return std::make_shared<MyObject3>(9); });
    m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); });
    m.def("print_myobject3_2", [](std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); });
    m.def("print_myobject3_3", [](const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); });
    m.def("print_myobject3_4", [](const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); });

    // test_smart_ptr_refcounting
    m.def("test_object1_refcounting", []() {
        ref<MyObject1> o = new MyObject1(0);
        bool good = o->getRefCount() == 1;
        py::object o2 = py::cast(o, py::return_value_policy::reference);
        // always request (partial) ownership for objects with intrusive
        // reference counting even when using the 'reference' RVP
        good &= o->getRefCount() == 2;
        return good;
    });

    // test_unique_nodelete
    // Object with a private destructor
    class MyObject4 {
    public:
        MyObject4(int value) : value{value} { print_created(this); }
        int value;
    private:
        ~MyObject4() { print_destroyed(this); }<style>pre { line-height: 125%; margin: 0; }
td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight { background: #ffffff; }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="cm">/*</span>
<span class="cm">             LUFA Library</span>
<span class="cm">     Copyright (C) Dean Camera, 2017.</span>

<span class="cm">  dean [at] fourwalledcubicle [dot] com</span>
<span class="cm">           www.lufa-lib.org</span>
<span class="cm">*/</span>

<span class="cm">/*</span>
<span class="cm">  Copyright 2017  Dean Camera (dean [at] fourwalledcubicle [dot] com)</span>

<span class="cm">  Permission to use, copy, modify, distribute, and sell this</span>
<span class="cm">  software and its documentation for any purpose is hereby granted</span>
<span class="cm">  without fee, provided that the above copyright notice appear in</span>
<span class="cm">  all copies and that both that the copyright notice and this</span>
<span class="cm">  permission notice and warranty disclaimer appear in supporting</span>
<span class="cm">  documentation, and that the name of the author not be used in</span>
<span class="cm">  advertising or publicity pertaining to distribution of the</span>
<span class="cm">  software without specific, written prior permission.</span>

<span class="cm">  The author disclaims all warranties with regard to this</span>
<span class="cm">  software, including all implied warranties of merchantability</span>
<span class="cm">  and fitness.  In no event shall the author be liable for any</span>
<span class="cm">  special, indirect or consequential damages or any damages</span>
<span class="cm">  whatsoever resulting from loss of use, data or profits, whether</span>
<span class="cm">  in an action of contract, negligence or other tortious action,</span>
<span class="cm">  arising out of or in connection with the use or performance of</span>
<span class="cm">  this software.</span>
<span class="cm">*/</span>

<span class="cm">/** \file</span>
<span class="cm"> *</span>
<span class="cm"> *  Header file for XPROGTarget.c.</span>
<span class="cm"> */</span>

<span class="cp">#ifndef _XPROG_TARGET_</span>
<span class="cp">#define _XPROG_TARGET_</span>

	<span class="cm">/* Includes: */</span>
		<span class="cp">#include</span> <span class="cpf">&lt;avr/io.h&gt;</span><span class="cp"></span>
		<span class="cp">#include</span> <span class="cpf">&lt;avr/interrupt.h&gt;</span><span class="cp"></span>
		<span class="cp">#include</span> <span class="cpf">&lt;stdbool.h&gt;</span><span class="cp"></span>

		<span class="cp">#include</span> <span class="cpf">&lt;LUFA/Common/Common.h&gt;</span><span class="cp"></span>

		<span class="cp">#include</span> <span class="cpf">&quot;../V2Protocol.h&quot;</span><span class="cp"></span>
		<span class="cp">#include</span> <span class="cpf">&quot;XPROGProtocol.h&quot;</span><span class="cp"></span>
		<span class="cp">#include</span> <span class="cpf">&quot;Config/AppConfig.h&quot;</span><span class="cp"></span>

	<span class="cm">/* Preprocessor Checks: */</span>
		<span class="cp">#if ((BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1))</span>
			<span class="cp">#undef ENABLE_ISP_PROTOCOL</span>

			<span class="cp">#if !defined(ENABLE_XPROG_PROTOCOL)</span>
				<span class="cp">#define ENABLE_XPROG_PROTOCOL</span>
			<span class="cp">#endif</span>
		<span class="cp">#endif</span>

		<span class="cm">/** Serial carrier TPI/PDI speed in Hz, when hardware TPI/PDI mode is used. */</span>
		<span class="cp">#define XPROG_HARDWARE_SPEED       2000000</span>

		<span class="cm">/** Total number of bits in a single USART frame. */</span>
		<span class="cp">#define BITS_IN_USART_FRAME        12</span>

 		<span class="cm">/** \name PDI Related Constants</span>
<span class="cm"> 		 * @{</span>
<span class="cm"> 		 */</span>
		<span class="cp">#define PDI_CMD_LDS(AddressSize, DataSize)  (0x00 | (  AddressSize &lt;&lt; 2) | DataSize)</span>
		<span class="cp">#define PDI_CMD_LD(PointerAccess, DataSize) (0x20 | (PointerAccess &lt;&lt; 2) | DataSize)</span>
		<span class="cp">#define PDI_CMD_STS(AddressSize, DataSize)  (0x40 | (  AddressSize &lt;&lt; 2) | DataSize)</span>
		<span class="cp">#define PDI_CMD_ST(PointerAccess, DataSize) (0x60 | (PointerAccess &lt;&lt; 2) | DataSize)</span>
		<span class="cp">#define PDI_CMD_LDCS(PDIReg)                (0x80 | PDIReg)</span>
		<span class="cp">#define PDI_CMD_REPEAT(DataSize)            (0xA0 | DataSize)</span>
		<span class="cp">#define PDI_CMD_STCS(PDIReg)                (0xC0 | PDIReg)</span>
		<span class="cp">#define PDI_CMD_KEY                         0xE0</span>

		<span class="cp">#define PDI_REG_STATUS             0</span>
		<span class="cp">#define PDI_REG_RESET              1</span>
		<span class="cp">#define PDI_REG_CTRL               2</span>

		<span class="cp">#define PDI_STATUS_NVM             (1 &lt;&lt; 1)</span>

		<span class="cp">#define PDI_RESET_KEY              0x59</span>
		<span class="cp">#define PDI_NVMENABLE_KEY          (uint8_t[]){0x12, 0x89, 0xAB, 0x45, 0xCD, 0xD8, 0x88, 0xFF}</span>

		<span class="cp">#define PDI_DATASIZE_1BYTE         0</span>
		<span class="cp">#define PDI_DATASIZE_2BYTES        1</span>
		<span class="cp">#define PDI_DATASIZE_3BYTES        2</span>
		<span class="cp">#define PDI_DATASIZE_4BYTES        3</span>

		<span class="cp">#define PDI_POINTER_INDIRECT       0</span>
		<span class="cp">#define PDI_POINTER_INDIRECT_PI    1</span>
		<span class="cp">#define PDI_POINTER_DIRECT         2</span>
 		<span class="cm">/** @} */</span>

 		<span class="cm">/** \name TPI Related Constants</span>
<span class="cm"> 		 * @{</span>
<span class="cm"> 		 */</span>
 		<span class="cp">#define TPI_CMD_SLD(PointerAccess) (0x20 | PointerAccess)</span>
		<span class="cp">#define TPI_CMD_SST(PointerAccess) (0x60 | PointerAccess)</span>
		<span class="cp">#define TPI_CMD_SSTPR              0x68</span>
		<span class="cp">#define TPI_CMD_SIN(Address)       (0x10 | ((Address &amp; 0x30) &lt;&lt; 1) | (Address &amp; 0x0F))</span>
		<span class="cp">#define TPI_CMD_SOUT(Address)      (0x90 | ((Address &amp; 0x30) &lt;&lt; 1) | (Address &amp; 0x0F))</span>
		<span class="cp">#define TPI_CMD_SLDCS(TPIReg)      (0x80 | TPIReg)</span>
		<span class="cp">#define TPI_CMD_SSTCS(TPIReg)      (0xC0 | TPIReg)</span>
		<span class="cp">#define TPI_CMD_SKEY               0xE0</span>

		<span class="cp">#define TPI_REG_STATUS             0x00</span>
		<span class="cp">#define TPI_REG_CTRL               0x02</span>
		<span class="cp">#define TPI_REG_ID                 0x0F</span>

		<span class="cp">#define TPI_STATUS_NVM             (1 &lt;&lt; 1)</span>

		<span class="cp">#define TPI_NVMENABLE_KEY          (uint8_t[]){0x12, 0x89, 0xAB, 0x45, 0xCD, 0xD8, 0x88, 0xFF}</span>

		<span class="cp">#define TPI_POINTER_INDIRECT       0</span>
		<span class="cp">#define TPI_POINTER_INDIRECT_PI    4</span>
 		<span class="cm">/** @} */</span>

	<span class="cm">/* Function Prototypes: */</span>
		<span class="kt">void</span>    <span class="nf">XPROGTarget_EnableTargetPDI</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
		<span class="kt">void</span>    <span class="nf">XPROGTarget_EnableTargetTPI</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
		<span class="kt">void</span>    <span class="nf">XPROGTarget_DisableTargetPDI</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
		<span class="kt">void</span>    <span class="nf">XPROGTarget_DisableTargetTPI</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
		<span class="kt">void</span>    <span class="nf">XPROGTarget_SendByte</span><span class="p">(</span><span class="k">const</span> <span class="kt">uint8_t</span> <span class="n">Byte</span><span class="p">);</span>
		<span class="kt">uint8_t</span> <span class="nf">XPROGTarget_ReceiveByte</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
		<span class="kt">void</span>    <span class="nf">XPROGTarget_SendIdle</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
		<span class="kt">bool</span>    <span class="nf">XPROGTarget_WaitWhileNVMBusBusy</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>

		<span class="cp">#if (defined(INCLUDE_FROM_XPROGTARGET_C) &amp;&amp; defined(ENABLE_XPROG_PROTOCOL))</span>
			<span class="k">static</span> <span class="kt">void</span> <span class="n">XPROGTarget_SetTxMode</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
			<span class="k">static</span> <span class="kt">void</span> <span class="n">XPROGTarget_SetRxMode</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
		<span class="cp">#endif</span>

<span class="cp">#endif</span>
</pre></div>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.3</a> (<a href='https://git-scm.com/'>git 2.25.1</a>) at 2025-06-23 07:25:08 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>