From b9844006dee8f8095c791a363fe3258ac94fe0f3 Mon Sep 17 00:00:00 2001 From: cyjseagull Date: Fri, 27 Sep 2024 15:56:57 +0800 Subject: [PATCH 1/2] implement wedpr-python-gateway-sdk --- cpp/ppc-framework/front/IFront.h | 6 +- cpp/ppc-framework/protocol/Message.h | 6 +- .../protocol/src/v1/MessagePayloadImpl.cpp | 1 + .../wedpr/sdk/jni/generated/IFront.java | 6 +- .../jni/generated/MessageOptionalHeader.java | 6 +- .../generated/wedpr_java_transportJNI.java | 8 +- .../sdk/jni/transport/impl/TransportImpl.java | 10 +- .../src/wedpr_java_transportJAVA_wrap.cxx | 12 +- .../sdk-wrapper/python/bindings/__init__.py | 1 + .../python/bindings/libs/__init__.py | 0 .../bindings/libs/_wedpr_python_transport.py | 19 + .../python/bindings/transport/api/__init__.py | 0 .../bindings/transport/api/message_api.py | 84 + .../bindings/transport/api/transport_api.py | 50 + .../bindings/transport/demo/__init__.py | 0 .../bindings/transport/demo/transport_demo.py | 65 + .../bindings/transport/generated/__init__.py | 0 .../generated/wedpr_python_transport.py | 1595 +++++++++++++++++ .../bindings/transport/impl/__init__.py | 0 .../transport/impl/message_factory.py | 11 + .../bindings/transport/impl/message_impl.py | 87 + .../transport/impl/route_info_builder.py | 20 + .../bindings/transport/impl/transport.py | 100 ++ .../transport/impl/transport_config.py | 49 + .../transport/impl/transport_loader.py | 15 + .../python/bindings/utils/lib_loader.py | 8 - .../bindings/utils/tests/test_lib_loader.py | 3 +- .../python/swig/wedpr_python_transport.i | 17 +- 28 files changed, 2143 insertions(+), 36 deletions(-) create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/__init__.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/libs/__init__.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/libs/_wedpr_python_transport.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/__init__.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/message_api.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/transport_api.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/demo/__init__.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/demo/transport_demo.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/generated/__init__.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/generated/wedpr_python_transport.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/__init__.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_factory.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_impl.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/route_info_builder.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_config.py create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_loader.py diff --git a/cpp/ppc-framework/front/IFront.h b/cpp/ppc-framework/front/IFront.h index dfa8e95..5e0a249 100644 --- a/cpp/ppc-framework/front/IFront.h +++ b/cpp/ppc-framework/front/IFront.h @@ -211,7 +211,11 @@ class IFront : virtual public IFrontClient long timeout) = 0; // TODO: optmize here - virtual bcos::Error::Ptr push(uint16_t routeType, + // Note: the python not support function overload, for different interfaces with the same + // functionality, it is best to define methods with different names the 'payload', 'payloadSize' + // should not been changed any more, since the swig has defined by the name to convert python + // bytes to cpp (char*, uint64_t) %pybuffer_binary(char* payload, uint64_t payloadSize) + virtual bcos::Error::Ptr push_msg(uint16_t routeType, ppc::protocol::MessageOptionalHeader::Ptr const& routeInfo, char* payload, uint64_t payloadSize, int seq, long timeout) { diff --git a/cpp/ppc-framework/protocol/Message.h b/cpp/ppc-framework/protocol/Message.h index 291b1d2..55a73dd 100644 --- a/cpp/ppc-framework/protocol/Message.h +++ b/cpp/ppc-framework/protocol/Message.h @@ -73,7 +73,11 @@ class MessageOptionalHeader // !!! Note: the first paramater type(char*) should not been changed, for it's used for pass-in // java byte[] into c bytes - virtual void setDstNode(char* data, uint64_t length) { m_dstNode.assign(data, data + length); } + // Note: the python not support function override + virtual void setDstNodeBuffer(char* data, uint64_t length) + { + m_dstNode.assign(data, data + length); + } // the target agency that need receive the message virtual std::string const& dstInst() const { return m_dstInst; } diff --git a/cpp/wedpr-protocol/protocol/src/v1/MessagePayloadImpl.cpp b/cpp/wedpr-protocol/protocol/src/v1/MessagePayloadImpl.cpp index 07c4327..e43124d 100644 --- a/cpp/wedpr-protocol/protocol/src/v1/MessagePayloadImpl.cpp +++ b/cpp/wedpr-protocol/protocol/src/v1/MessagePayloadImpl.cpp @@ -58,6 +58,7 @@ int64_t MessagePayloadImpl::decode(bcos::bytesConstRef buffer) BOOST_THROW_EXCEPTION( WeDPRException() << errinfo_comment("Malform payload for too small!")); } + m_length = buffer.size(); auto pointer = buffer.data(); // the version m_version = boost::asio::detail::socket_ops::network_to_host_short(*((uint16_t*)pointer)); diff --git a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/IFront.java b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/IFront.java index 1fcf80c..935dd71 100644 --- a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/IFront.java +++ b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/IFront.java @@ -122,7 +122,7 @@ public void async_send_response( public Error push( int routeType, MessageOptionalHeader routeInfo, ubytes payload, int seq, int timeout) { long cPtr = - wedpr_java_transportJNI.IFront_push__SWIG_0( + wedpr_java_transportJNI.IFront_push( swigCPtr, this, routeType, @@ -135,7 +135,7 @@ public Error push( return (cPtr == 0) ? null : new Error(cPtr, true); } - public Error push( + public Error push_msg( int routeType, MessageOptionalHeader routeInfo, byte[] payload, @@ -143,7 +143,7 @@ public Error push( int seq, int timeout) { long cPtr = - wedpr_java_transportJNI.IFront_push__SWIG_1( + wedpr_java_transportJNI.IFront_push_msg( swigCPtr, this, routeType, diff --git a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/MessageOptionalHeader.java b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/MessageOptionalHeader.java index 2e09fca..892922b 100644 --- a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/MessageOptionalHeader.java +++ b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/MessageOptionalHeader.java @@ -89,12 +89,12 @@ public byte[] dstNodeBuffer() { } public void setDstNode(ubytes dstNode) { - wedpr_java_transportJNI.MessageOptionalHeader_setDstNode__SWIG_0( + wedpr_java_transportJNI.MessageOptionalHeader_setDstNode( swigCPtr, this, ubytes.getCPtr(dstNode), dstNode); } - public void setDstNode(byte[] data, java.math.BigInteger length) { - wedpr_java_transportJNI.MessageOptionalHeader_setDstNode__SWIG_1( + public void setDstNodeBuffer(byte[] data, java.math.BigInteger length) { + wedpr_java_transportJNI.MessageOptionalHeader_setDstNodeBuffer( swigCPtr, this, data, length); } diff --git a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/wedpr_java_transportJNI.java b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/wedpr_java_transportJNI.java index 311ec4f..81c85a3 100644 --- a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/wedpr_java_transportJNI.java +++ b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/generated/wedpr_java_transportJNI.java @@ -353,10 +353,10 @@ public static final native long MessageOptionalHeader_dstNode( public static final native byte[] MessageOptionalHeader_dstNodeBuffer( long jarg1, MessageOptionalHeader jarg1_); - public static final native void MessageOptionalHeader_setDstNode__SWIG_0( + public static final native void MessageOptionalHeader_setDstNode( long jarg1, MessageOptionalHeader jarg1_, long jarg2, ubytes jarg2_); - public static final native void MessageOptionalHeader_setDstNode__SWIG_1( + public static final native void MessageOptionalHeader_setDstNodeBuffer( long jarg1, MessageOptionalHeader jarg1_, byte[] jarg2, java.math.BigInteger jarg3); public static final native String MessageOptionalHeader_dstInst( @@ -703,7 +703,7 @@ public static final native void IFront_async_send_response( long jarg8, ErrorCallback jarg8_); - public static final native long IFront_push__SWIG_0( + public static final native long IFront_push( long jarg1, IFront jarg1_, int jarg2, @@ -714,7 +714,7 @@ public static final native long IFront_push__SWIG_0( int jarg5, int jarg6); - public static final native long IFront_push__SWIG_1( + public static final native long IFront_push_msg( long jarg1, IFront jarg1_, int jarg2, diff --git a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/transport/impl/TransportImpl.java b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/transport/impl/TransportImpl.java index d2d497b..c1e4eb4 100644 --- a/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/transport/impl/TransportImpl.java +++ b/cpp/wedpr-transport/sdk-wrapper/java/bindings/src/main/java/com/webank/wedpr/sdk/jni/transport/impl/TransportImpl.java @@ -158,7 +158,7 @@ public void asyncSendMessageByNodeID( MessageCallback msgCallback) { MessageOptionalHeader routeInfo = IMessageBuilder.buildRouteInfo(this.transport.routeInfoBuilder(), topic); - routeInfo.setDstNode(dstNode, BigInteger.valueOf(dstNode.length)); + routeInfo.setDstNodeBuffer(dstNode, BigInteger.valueOf(dstNode.length)); this.transport .getFront() .async_send_message( @@ -302,11 +302,11 @@ public void pushByNodeID(String topic, byte[] dstNodeID, int seq, byte[] payload throws WeDPRSDKException { MessageOptionalHeader routeInfo = IMessageBuilder.buildRouteInfo(this.transport.routeInfoBuilder(), topic); - routeInfo.setDstNode(dstNodeID, BigInteger.valueOf(dstNodeID.length)); + routeInfo.setDstNodeBuffer(dstNodeID, BigInteger.valueOf(dstNodeID.length)); Error result = this.transport .getFront() - .push( + .push_msg( RouteType.ROUTE_THROUGH_NODEID.ordinal(), routeInfo, payload, @@ -327,7 +327,7 @@ public void pushByComponent( Error result = this.transport .getFront() - .push( + .push_msg( RouteType.ROUTE_THROUGH_COMPONENT.ordinal(), routeInfo, payload, @@ -346,7 +346,7 @@ public void pushByInst(String topic, String dstInst, int seq, byte[] payload, in Error result = this.transport .getFront() - .push( + .push_msg( RouteType.ROUTE_THROUGH_TOPIC.ordinal(), routeInfo, payload, diff --git a/cpp/wedpr-transport/sdk-wrapper/java/src/wedpr_java_transportJAVA_wrap.cxx b/cpp/wedpr-transport/sdk-wrapper/java/src/wedpr_java_transportJAVA_wrap.cxx index 5624a7c..36134a4 100644 --- a/cpp/wedpr-transport/sdk-wrapper/java/src/wedpr_java_transportJAVA_wrap.cxx +++ b/cpp/wedpr-transport/sdk-wrapper/java/src/wedpr_java_transportJAVA_wrap.cxx @@ -3935,7 +3935,7 @@ SWIGEXPORT jbyteArray JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1jav } -SWIGEXPORT void JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_MessageOptionalHeader_1setDstNode_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { +SWIGEXPORT void JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_MessageOptionalHeader_1setDstNode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; bcos::bytes *arg2 = 0 ; std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; @@ -3957,7 +3957,7 @@ SWIGEXPORT void JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1tra } -SWIGEXPORT void JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_MessageOptionalHeader_1setDstNode_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyteArray jarg2, jobject jarg3) { +SWIGEXPORT void JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_MessageOptionalHeader_1setDstNodeBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyteArray jarg2, jobject jarg3) { ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; char *arg2 = (char *) 0 ; uint64_t arg3 ; @@ -3998,7 +3998,7 @@ SWIGEXPORT void JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1tra } jenv->ReleaseByteArrayElements(ba, bae, 0); } - (arg1)->setDstNode(arg2,arg3); + (arg1)->setDstNodeBuffer(arg2,arg3); { jenv->ReleaseByteArrayElements(jarg2, (jbyte *) arg2, 0); } @@ -6393,7 +6393,7 @@ SWIGEXPORT void JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1tra } -SWIGEXPORT jlong JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_IFront_1push_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jint jarg5, jint jarg6) { +SWIGEXPORT jlong JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_IFront_1push(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jint jarg5, jint jarg6) { jlong jresult = 0 ; ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; uint16_t arg2 ; @@ -6430,7 +6430,7 @@ SWIGEXPORT jlong JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1tr } -SWIGEXPORT jlong JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_IFront_1push_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_, jbyteArray jarg4, jobject jarg5, jint jarg6, jint jarg7) { +SWIGEXPORT jlong JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1transportJNI_IFront_1push_1msg(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_, jbyteArray jarg4, jobject jarg5, jint jarg6, jint jarg7) { jlong jresult = 0 ; ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; uint16_t arg2 ; @@ -6483,7 +6483,7 @@ SWIGEXPORT jlong JNICALL Java_com_webank_wedpr_sdk_jni_generated_wedpr_1java_1tr } arg6 = (int)jarg6; arg7 = (long)jarg7; - result = (arg1)->push(arg2,(ppc::protocol::MessageOptionalHeader::Ptr const &)*arg3,arg4,arg5,arg6,arg7); + result = (arg1)->push_msg(arg2,(ppc::protocol::MessageOptionalHeader::Ptr const &)*arg3,arg4,arg5,arg6,arg7); *(bcos::Error::Ptr **)&jresult = result ? new bcos::Error::Ptr(result) : 0; { jenv->ReleaseByteArrayElements(jarg4, (jbyte *) arg4, 0); diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/__init__.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/__init__.py new file mode 100644 index 0000000..5becc17 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/__init__.py @@ -0,0 +1 @@ +__version__ = "1.0.0" diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/libs/__init__.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/libs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/libs/_wedpr_python_transport.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/libs/_wedpr_python_transport.py new file mode 100644 index 0000000..1605caa --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/libs/_wedpr_python_transport.py @@ -0,0 +1,19 @@ +# -*- coding: utf-8 -*- +import shutil +import pkg_resources +from utils.lib_loader import LibLoader + + +def __bootstrap__(): + global __bootstrap__, __loader__, __file__ + import sys + import pkg_resources + import imp + __file__ = pkg_resources.resource_filename( + __name__, LibLoader.get_lib_name()) + __loader__ = None + del __bootstrap__, __loader__ + imp.load_dynamic(__name__, __file__) + + +__bootstrap__() diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/__init__.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/message_api.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/message_api.py new file mode 100644 index 0000000..036c006 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/message_api.py @@ -0,0 +1,84 @@ +# -*- coding: utf-8 -*- + +from abc import ABC, abstractmethod + + +class MessageHeaderAPI(ABC): + @abstractmethod + def get_version(self) -> str: + pass + + @abstractmethod + def get_trace_id(self) -> str: + pass + + @abstractmethod + def get_src_gw_node(self) -> str: + pass + + @abstractmethod + def get_dst_gw_node(self) -> str: + pass + + @abstractmethod + def get_packet_type(self) -> int: + pass + + @abstractmethod + def get_ttl(self) -> int: + pass + + @abstractmethod + def get_ext(self) -> int: + pass + + @abstractmethod + def is_resp_packet(self) -> bool: + pass + + @abstractmethod + def get_route_type(self) -> int: + pass + + @abstractmethod + def get_component_type(self) -> str: + pass + + @abstractmethod + def get_src_node(self) -> bytes: + pass + + @abstractmethod + def get_dst_node(self) -> bytes: + pass + + @abstractmethod + def get_dst_inst(self) -> str: + pass + + @abstractmethod + def get_src_inst(self) -> str: + pass + + @abstractmethod + def get_topic(self) -> str: + pass + + +class MessageAPI(ABC): + + @abstractmethod + def get_header(self) -> MessageHeaderAPI: + pass + + @abstractmethod + def get_seq(self) -> int: + pass + + @abstractmethod + def get_payload(self) -> bytes: + pass + + @abstractmethod + def get_length(self) -> int: + pass diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/transport_api.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/transport_api.py new file mode 100644 index 0000000..8167f87 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/api/transport_api.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- + +from abc import ABC, abstractmethod +from transport.api.message_api import MessageAPI + + +class TransportAPI(ABC): + @abstractmethod + def start(self): + pass + + @abstractmethod + def stop(self): + pass + + @abstractmethod + def push_by_nodeid(topic: str, dstNode: bytes, seq: int, payload: bytes, timeout: int): + pass + + @abstractmethod + def push_by_inst(topic: str, dstInst: str, seq: int, payload: bytes, timeout: int): + pass + + @abstractmethod + def push_by_component(topic: str, dstInst: str, component: str, seq: int, payload: bytes, timeout: int): + pass + + @abstractmethod + def pop(self, topic, timeoutMs) -> MessageAPI: + pass + + @abstractmethod + def peek(self, topic) -> MessageAPI: + pass + + @abstractmethod + def register_topic(self, topic): + pass + + @abstractmethod + def unregister_topic(self, topic): + pass + + @abstractmethod + def register_component(self, component): + pass + + @abstractmethod + def unregister_component(self, component): + pass diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/demo/__init__.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/demo/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/demo/transport_demo.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/demo/transport_demo.py new file mode 100644 index 0000000..55571d5 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/demo/transport_demo.py @@ -0,0 +1,65 @@ +# -*- coding: utf-8 -*- +# Note: here can't be refactored by autopep +import os +import sys +root_path = os.path.abspath(os.path.dirname(__file__)) +sys.path.append(os.path.join(root_path, "../..")) + + +import argparse +from transport.impl.transport import Transport +from transport.impl.transport_config import TransportConfig +from transport.impl.transport_loader import TransportLoader +import time + + +def parse_args(): + parser = argparse.ArgumentParser(prog=sys.argv[0]) + parser.add_argument("-t", '--threadpool_size', + help='the threadpool size', default=4, required=True) + parser.add_argument("-n", '--node_id', + help='the nodeID', required=False) + parser.add_argument("-g", '--gateway_targets', + help='the gateway targets, e.g: ipv4:127.0.0.1:40620,127.0.0.1:40621', required=True) + parser.add_argument("-i", '--host_ip', + help='the host ip, e.g.: 127.0.0.1', required=True) + parser.add_argument("-p", "--listen_port", + help="the listen port", required=True) + parser.add_argument("-d", "--dst_node", + help="the dst node", required=True) + args = parser.parse_args() + return args + + +def message_event_loop(args): + transport_config = TransportConfig( + int(args.threadpool_size), args.node_id, args.gateway_targets) + transport_config.set_self_endpoint( + args.host_ip, int(args.listen_port), "0.0.0.0") + transport = TransportLoader.load(transport_config) + print(f"Create transport success, config: {transport_config.desc()}") + transport.start() + print(f"Start transport success") + test_topic = "sync_message_event_loop_test" + while Transport.should_exit is False: + try: + payload = b"test" + transport.push_by_nodeid(topic=test_topic, dstNode=bytes(args.dst_node, encoding="utf-8"), + seq=0, payload=payload, timeout=6000) + msg = transport.pop(test_topic, timeout_ms=6000) + if msg is None: + print("Receive message timeout") + continue + print( + f"Receive message: {msg.detail()}, buffer: {str(msg.get_payload())}") + except Exception as e: + print(f"exception: {e}") + time.sleep(2) + print(f"stop the transport") + transport.stop() + print(f"stop the transport successfully") + + +if __name__ == "__main__": + args = parse_args() + message_event_loop(args) diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/generated/__init__.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/generated/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/generated/wedpr_python_transport.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/generated/wedpr_python_transport.py new file mode 100644 index 0000000..16d734a --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/generated/wedpr_python_transport.py @@ -0,0 +1,1595 @@ +# This file was automatically generated by SWIG (https://www.swig.org). +# Version 4.2.1 +# +# Do not make changes to this file unless you know what you are doing - modify +# the SWIG interface file instead. + +import weakref +from sys import version_info as _swig_python_version_info + +# Import the low-level C/C++ module +from libs import _wedpr_python_transport + + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +def _swig_setattr_nondynamic_instance_variable(set): + def set_instance_attr(self, name, value): + if name == "this": + set(self, name, value) + elif name == "thisown": + self.this.own(value) + elif hasattr(self, name) and isinstance(getattr(type(self), name), property): + set(self, name, value) + else: + raise AttributeError( + "You cannot add instance attributes to %s" % self) + return set_instance_attr + + +def _swig_setattr_nondynamic_class_variable(set): + def set_class_attr(cls, name, value): + if hasattr(cls, name) and not isinstance(getattr(cls, name), property): + set(cls, name, value) + else: + raise AttributeError("You cannot add class attributes to %s" % cls) + return set_class_attr + + +def _swig_add_metaclass(metaclass): + """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" + def wrapper(cls): + return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) + return wrapper + + +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) + + +class SwigPyIterator(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_SwigPyIterator + + def value(self): + return _wedpr_python_transport.SwigPyIterator_value(self) + + def incr(self, n=1): + return _wedpr_python_transport.SwigPyIterator_incr(self, n) + + def decr(self, n=1): + return _wedpr_python_transport.SwigPyIterator_decr(self, n) + + def distance(self, x): + return _wedpr_python_transport.SwigPyIterator_distance(self, x) + + def equal(self, x): + return _wedpr_python_transport.SwigPyIterator_equal(self, x) + + def copy(self): + return _wedpr_python_transport.SwigPyIterator_copy(self) + + def next(self): + return _wedpr_python_transport.SwigPyIterator_next(self) + + def __next__(self): + return _wedpr_python_transport.SwigPyIterator___next__(self) + + def previous(self): + return _wedpr_python_transport.SwigPyIterator_previous(self) + + def advance(self, n): + return _wedpr_python_transport.SwigPyIterator_advance(self, n) + + def __eq__(self, x): + return _wedpr_python_transport.SwigPyIterator___eq__(self, x) + + def __ne__(self, x): + return _wedpr_python_transport.SwigPyIterator___ne__(self, x) + + def __iadd__(self, n): + return _wedpr_python_transport.SwigPyIterator___iadd__(self, n) + + def __isub__(self, n): + return _wedpr_python_transport.SwigPyIterator___isub__(self, n) + + def __add__(self, n): + return _wedpr_python_transport.SwigPyIterator___add__(self, n) + + def __sub__(self, *args): + return _wedpr_python_transport.SwigPyIterator___sub__(self, *args) + + def __iter__(self): + return self + + +# Register SwigPyIterator in _wedpr_python_transport: +_wedpr_python_transport.SwigPyIterator_swigregister(SwigPyIterator) +SHARED_PTR_DISOWN = _wedpr_python_transport.SHARED_PTR_DISOWN + + +class SharedBcosError(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedBcosError_swiginit( + self, _wedpr_python_transport.new_SharedBcosError()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedBcosError + + +# Register SharedBcosError in _wedpr_python_transport: +_wedpr_python_transport.SharedBcosError_swigregister(SharedBcosError) + + +class SharedFrontConfig(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedFrontConfig_swiginit( + self, _wedpr_python_transport.new_SharedFrontConfig()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedFrontConfig + + +# Register SharedFrontConfig in _wedpr_python_transport: +_wedpr_python_transport.SharedFrontConfig_swigregister(SharedFrontConfig) + + +class SharedGrpcConfig(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedGrpcConfig_swiginit( + self, _wedpr_python_transport.new_SharedGrpcConfig()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedGrpcConfig + + +# Register SharedGrpcConfig in _wedpr_python_transport: +_wedpr_python_transport.SharedGrpcConfig_swigregister(SharedGrpcConfig) + + +class SharedFront(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedFront_swiginit( + self, _wedpr_python_transport.new_SharedFront()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedFront + + +# Register SharedFront in _wedpr_python_transport: +_wedpr_python_transport.SharedFront_swigregister(SharedFront) + + +class SharedFrontClient(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedFrontClient_swiginit( + self, _wedpr_python_transport.new_SharedFrontClient()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedFrontClient + + +# Register SharedFrontClient in _wedpr_python_transport: +_wedpr_python_transport.SharedFrontClient_swigregister(SharedFrontClient) + + +class SharedErrorCallback(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedErrorCallback_swiginit( + self, _wedpr_python_transport.new_SharedErrorCallback()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedErrorCallback + + +# Register SharedErrorCallback in _wedpr_python_transport: +_wedpr_python_transport.SharedErrorCallback_swigregister(SharedErrorCallback) + + +class SharedMessageDispatcherHandler(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedMessageDispatcherHandler_swiginit( + self, _wedpr_python_transport.new_SharedMessageDispatcherHandler()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedMessageDispatcherHandler + + +# Register SharedMessageDispatcherHandler in _wedpr_python_transport: +_wedpr_python_transport.SharedMessageDispatcherHandler_swigregister( + SharedMessageDispatcherHandler) + + +class SharedIMessageHandler(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedIMessageHandler_swiginit( + self, _wedpr_python_transport.new_SharedIMessageHandler()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedIMessageHandler + + +# Register SharedIMessageHandler in _wedpr_python_transport: +_wedpr_python_transport.SharedIMessageHandler_swigregister( + SharedIMessageHandler) + + +class SharedGetPeersInfoHandler(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedGetPeersInfoHandler_swiginit( + self, _wedpr_python_transport.new_SharedGetPeersInfoHandler()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedGetPeersInfoHandler + + +# Register SharedGetPeersInfoHandler in _wedpr_python_transport: +_wedpr_python_transport.SharedGetPeersInfoHandler_swigregister( + SharedGetPeersInfoHandler) + + +class SharedGateway(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedGateway_swiginit( + self, _wedpr_python_transport.new_SharedGateway()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedGateway + + +# Register SharedGateway in _wedpr_python_transport: +_wedpr_python_transport.SharedGateway_swigregister(SharedGateway) + + +class SharedMessage(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedMessage_swiginit( + self, _wedpr_python_transport.new_SharedMessage()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedMessage + + +# Register SharedMessage in _wedpr_python_transport: +_wedpr_python_transport.SharedMessage_swigregister(SharedMessage) + + +class SharedMessageHeader(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedMessageHeader_swiginit( + self, _wedpr_python_transport.new_SharedMessageHeader()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedMessageHeader + + +# Register SharedMessageHeader in _wedpr_python_transport: +_wedpr_python_transport.SharedMessageHeader_swigregister(SharedMessageHeader) + + +class SharedMessagePayload(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedMessagePayload_swiginit( + self, _wedpr_python_transport.new_SharedMessagePayload()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedMessagePayload + + +# Register SharedMessagePayload in _wedpr_python_transport: +_wedpr_python_transport.SharedMessagePayload_swigregister(SharedMessagePayload) + + +class SharedRouteInfo(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedRouteInfo_swiginit( + self, _wedpr_python_transport.new_SharedRouteInfo()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedRouteInfo + + +# Register SharedRouteInfo in _wedpr_python_transport: +_wedpr_python_transport.SharedRouteInfo_swigregister(SharedRouteInfo) + + +class SharedMessageBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedMessageBuilder_swiginit( + self, _wedpr_python_transport.new_SharedMessageBuilder()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedMessageBuilder + + +# Register SharedMessageBuilder in _wedpr_python_transport: +_wedpr_python_transport.SharedMessageBuilder_swigregister(SharedMessageBuilder) + + +class SharedMessageHeaderBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedMessageHeaderBuilder_swiginit( + self, _wedpr_python_transport.new_SharedMessageHeaderBuilder()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedMessageHeaderBuilder + + +# Register SharedMessageHeaderBuilder in _wedpr_python_transport: +_wedpr_python_transport.SharedMessageHeaderBuilder_swigregister( + SharedMessageHeaderBuilder) + + +class SharedMessagePayloadBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedMessagePayloadBuilder_swiginit( + self, _wedpr_python_transport.new_SharedMessagePayloadBuilder()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedMessagePayloadBuilder + + +# Register SharedMessagePayloadBuilder in _wedpr_python_transport: +_wedpr_python_transport.SharedMessagePayloadBuilder_swigregister( + SharedMessagePayloadBuilder) + + +class SharedRouteInfoBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.SharedRouteInfoBuilder_swiginit( + self, _wedpr_python_transport.new_SharedRouteInfoBuilder()) + __swig_destroy__ = _wedpr_python_transport.delete_SharedRouteInfoBuilder + + +# Register SharedRouteInfoBuilder in _wedpr_python_transport: +_wedpr_python_transport.SharedRouteInfoBuilder_swigregister( + SharedRouteInfoBuilder) + + +class ubytes(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def iterator(self): + return _wedpr_python_transport.ubytes_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + return _wedpr_python_transport.ubytes___nonzero__(self) + + def __bool__(self): + return _wedpr_python_transport.ubytes___bool__(self) + + def __len__(self): + return _wedpr_python_transport.ubytes___len__(self) + + def __getslice__(self, i, j): + return _wedpr_python_transport.ubytes___getslice__(self, i, j) + + def __setslice__(self, *args): + return _wedpr_python_transport.ubytes___setslice__(self, *args) + + def __delslice__(self, i, j): + return _wedpr_python_transport.ubytes___delslice__(self, i, j) + + def __delitem__(self, *args): + return _wedpr_python_transport.ubytes___delitem__(self, *args) + + def __getitem__(self, *args): + return _wedpr_python_transport.ubytes___getitem__(self, *args) + + def __setitem__(self, *args): + return _wedpr_python_transport.ubytes___setitem__(self, *args) + + def pop(self): + return _wedpr_python_transport.ubytes_pop(self) + + def append(self, x): + return _wedpr_python_transport.ubytes_append(self, x) + + def empty(self): + return _wedpr_python_transport.ubytes_empty(self) + + def size(self): + return _wedpr_python_transport.ubytes_size(self) + + def swap(self, v): + return _wedpr_python_transport.ubytes_swap(self, v) + + def begin(self): + return _wedpr_python_transport.ubytes_begin(self) + + def end(self): + return _wedpr_python_transport.ubytes_end(self) + + def rbegin(self): + return _wedpr_python_transport.ubytes_rbegin(self) + + def rend(self): + return _wedpr_python_transport.ubytes_rend(self) + + def clear(self): + return _wedpr_python_transport.ubytes_clear(self) + + def get_allocator(self): + return _wedpr_python_transport.ubytes_get_allocator(self) + + def pop_back(self): + return _wedpr_python_transport.ubytes_pop_back(self) + + def erase(self, *args): + return _wedpr_python_transport.ubytes_erase(self, *args) + + def __init__(self, *args): + _wedpr_python_transport.ubytes_swiginit( + self, _wedpr_python_transport.new_ubytes(*args)) + + def push_back(self, x): + return _wedpr_python_transport.ubytes_push_back(self, x) + + def front(self): + return _wedpr_python_transport.ubytes_front(self) + + def back(self): + return _wedpr_python_transport.ubytes_back(self) + + def assign(self, n, x): + return _wedpr_python_transport.ubytes_assign(self, n, x) + + def resize(self, *args): + return _wedpr_python_transport.ubytes_resize(self, *args) + + def insert(self, *args): + return _wedpr_python_transport.ubytes_insert(self, *args) + + def reserve(self, n): + return _wedpr_python_transport.ubytes_reserve(self, n) + + def capacity(self): + return _wedpr_python_transport.ubytes_capacity(self) + __swig_destroy__ = _wedpr_python_transport.delete_ubytes + + +# Register ubytes in _wedpr_python_transport: +_wedpr_python_transport.ubytes_swigregister(ubytes) + + +class ibytes(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def iterator(self): + return _wedpr_python_transport.ibytes_iterator(self) + + def __iter__(self): + return self.iterator() + + def __nonzero__(self): + return _wedpr_python_transport.ibytes___nonzero__(self) + + def __bool__(self): + return _wedpr_python_transport.ibytes___bool__(self) + + def __len__(self): + return _wedpr_python_transport.ibytes___len__(self) + + def __getslice__(self, i, j): + return _wedpr_python_transport.ibytes___getslice__(self, i, j) + + def __setslice__(self, *args): + return _wedpr_python_transport.ibytes___setslice__(self, *args) + + def __delslice__(self, i, j): + return _wedpr_python_transport.ibytes___delslice__(self, i, j) + + def __delitem__(self, *args): + return _wedpr_python_transport.ibytes___delitem__(self, *args) + + def __getitem__(self, *args): + return _wedpr_python_transport.ibytes___getitem__(self, *args) + + def __setitem__(self, *args): + return _wedpr_python_transport.ibytes___setitem__(self, *args) + + def pop(self): + return _wedpr_python_transport.ibytes_pop(self) + + def append(self, x): + return _wedpr_python_transport.ibytes_append(self, x) + + def empty(self): + return _wedpr_python_transport.ibytes_empty(self) + + def size(self): + return _wedpr_python_transport.ibytes_size(self) + + def swap(self, v): + return _wedpr_python_transport.ibytes_swap(self, v) + + def begin(self): + return _wedpr_python_transport.ibytes_begin(self) + + def end(self): + return _wedpr_python_transport.ibytes_end(self) + + def rbegin(self): + return _wedpr_python_transport.ibytes_rbegin(self) + + def rend(self): + return _wedpr_python_transport.ibytes_rend(self) + + def clear(self): + return _wedpr_python_transport.ibytes_clear(self) + + def get_allocator(self): + return _wedpr_python_transport.ibytes_get_allocator(self) + + def pop_back(self): + return _wedpr_python_transport.ibytes_pop_back(self) + + def erase(self, *args): + return _wedpr_python_transport.ibytes_erase(self, *args) + + def __init__(self, *args): + _wedpr_python_transport.ibytes_swiginit( + self, _wedpr_python_transport.new_ibytes(*args)) + + def push_back(self, x): + return _wedpr_python_transport.ibytes_push_back(self, x) + + def front(self): + return _wedpr_python_transport.ibytes_front(self) + + def back(self): + return _wedpr_python_transport.ibytes_back(self) + + def assign(self, n, x): + return _wedpr_python_transport.ibytes_assign(self, n, x) + + def resize(self, *args): + return _wedpr_python_transport.ibytes_resize(self, *args) + + def insert(self, *args): + return _wedpr_python_transport.ibytes_insert(self, *args) + + def reserve(self, n): + return _wedpr_python_transport.ibytes_reserve(self, n) + + def capacity(self): + return _wedpr_python_transport.ibytes_capacity(self) + __swig_destroy__ = _wedpr_python_transport.delete_ibytes + + +# Register ibytes in _wedpr_python_transport: +_wedpr_python_transport.ibytes_swigregister(ibytes) + + +class Error(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + @staticmethod + def buildError(*args): + return _wedpr_python_transport.Error_buildError(*args) + + def __init__(self, *args): + _wedpr_python_transport.Error_swiginit( + self, _wedpr_python_transport.new_Error(*args)) + __swig_destroy__ = _wedpr_python_transport.delete_Error + + def errorCode(self): + return _wedpr_python_transport.Error_errorCode(self) + + def errorMessage(self): + return _wedpr_python_transport.Error_errorMessage(self) + + def setErrorCode(self, _errorCode): + return _wedpr_python_transport.Error_setErrorCode(self, _errorCode) + + def setErrorMessage(self, _errorMessage): + return _wedpr_python_transport.Error_setErrorMessage(self, _errorMessage) + + +# Register Error in _wedpr_python_transport: +_wedpr_python_transport.Error_swigregister(Error) + + +class InputBuffer(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + data = property(_wedpr_python_transport.InputBuffer_data_get, + _wedpr_python_transport.InputBuffer_data_set) + len = property(_wedpr_python_transport.InputBuffer_len_get, + _wedpr_python_transport.InputBuffer_len_set) + + def __init__(self): + _wedpr_python_transport.InputBuffer_swiginit( + self, _wedpr_python_transport.new_InputBuffer()) + __swig_destroy__ = _wedpr_python_transport.delete_InputBuffer + + +# Register InputBuffer in _wedpr_python_transport: +_wedpr_python_transport.InputBuffer_swigregister(InputBuffer) + + +class OutputBuffer(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + data = property(_wedpr_python_transport.OutputBuffer_data_get, + _wedpr_python_transport.OutputBuffer_data_set) + len = property(_wedpr_python_transport.OutputBuffer_len_get, + _wedpr_python_transport.OutputBuffer_len_set) + + def __init__(self): + _wedpr_python_transport.OutputBuffer_swiginit( + self, _wedpr_python_transport.new_OutputBuffer()) + __swig_destroy__ = _wedpr_python_transport.delete_OutputBuffer + + +# Register OutputBuffer in _wedpr_python_transport: +_wedpr_python_transport.OutputBuffer_swigregister(OutputBuffer) + + +class FrontConfig(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_FrontConfig + + def threadPoolSize(self): + return _wedpr_python_transport.FrontConfig_threadPoolSize(self) + + def setThreadPoolSize(self, threadPoolSize): + return _wedpr_python_transport.FrontConfig_setThreadPoolSize(self, threadPoolSize) + + def nodeID(self): + return _wedpr_python_transport.FrontConfig_nodeID(self) + + def setNodeID(self, nodeID): + return _wedpr_python_transport.FrontConfig_setNodeID(self, nodeID) + + def selfEndPoint(self): + return _wedpr_python_transport.FrontConfig_selfEndPoint(self) + + def mutableSelfEndPoint(self): + return _wedpr_python_transport.FrontConfig_mutableSelfEndPoint(self) + + def setSelfEndPoint(self, endPoint): + return _wedpr_python_transport.FrontConfig_setSelfEndPoint(self, endPoint) + + def setGatewayGrpcTarget(self, gatewayGrpcTarget): + return _wedpr_python_transport.FrontConfig_setGatewayGrpcTarget(self, gatewayGrpcTarget) + + def gatewayGrpcTarget(self): + return _wedpr_python_transport.FrontConfig_gatewayGrpcTarget(self) + + def setGrpcConfig(self, grpcConfig): + return _wedpr_python_transport.FrontConfig_setGrpcConfig(self, grpcConfig) + + def grpcConfig(self): + return _wedpr_python_transport.FrontConfig_grpcConfig(self) + + def generateNodeInfo(self): + return _wedpr_python_transport.FrontConfig_generateNodeInfo(self) + + def getComponents(self): + return _wedpr_python_transport.FrontConfig_getComponents(self) + + def setComponents(self, components): + return _wedpr_python_transport.FrontConfig_setComponents(self, components) + + def addComponent(self, component): + return _wedpr_python_transport.FrontConfig_addComponent(self, component) + + def mutableComponents(self): + return _wedpr_python_transport.FrontConfig_mutableComponents(self) + + +# Register FrontConfig in _wedpr_python_transport: +_wedpr_python_transport.FrontConfig_swigregister(FrontConfig) + + +class FrontConfigBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_FrontConfigBuilder + + def build(self, *args): + return _wedpr_python_transport.FrontConfigBuilder_build(self, *args) + + +# Register FrontConfigBuilder in _wedpr_python_transport: +_wedpr_python_transport.FrontConfigBuilder_swigregister(FrontConfigBuilder) + + +def printFrontDesc(config): + return _wedpr_python_transport.printFrontDesc(config) + + +class EndPoint(object): + r"""the endpoint""" + + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + _wedpr_python_transport.EndPoint_swiginit( + self, _wedpr_python_transport.new_EndPoint(*args)) + __swig_destroy__ = _wedpr_python_transport.delete_EndPoint + + def host(self): + return _wedpr_python_transport.EndPoint_host(self) + + def port(self): + return _wedpr_python_transport.EndPoint_port(self) + + def setHost(self, host): + return _wedpr_python_transport.EndPoint_setHost(self, host) + + def setPort(self, port): + return _wedpr_python_transport.EndPoint_setPort(self, port) + + def setListenIp(self, listenIp): + return _wedpr_python_transport.EndPoint_setListenIp(self, listenIp) + + def entryPoint(self): + return _wedpr_python_transport.EndPoint_entryPoint(self) + + def listenEndPoint(self): + return _wedpr_python_transport.EndPoint_listenEndPoint(self) + + def listenIp(self): + return _wedpr_python_transport.EndPoint_listenIp(self) + + +# Register EndPoint in _wedpr_python_transport: +_wedpr_python_transport.EndPoint_swigregister(EndPoint) + + +class GrpcServerConfig(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + _wedpr_python_transport.GrpcServerConfig_swiginit( + self, _wedpr_python_transport.new_GrpcServerConfig(*args)) + + def listenEndPoint(self): + return _wedpr_python_transport.GrpcServerConfig_listenEndPoint(self) + + def setEndPoint(self, endPoint): + return _wedpr_python_transport.GrpcServerConfig_setEndPoint(self, endPoint) + + def setEnableHealthCheck(self, enableHealthCheck): + return _wedpr_python_transport.GrpcServerConfig_setEnableHealthCheck(self, enableHealthCheck) + + def endPoint(self): + return _wedpr_python_transport.GrpcServerConfig_endPoint(self) + + def mutableEndPoint(self): + return _wedpr_python_transport.GrpcServerConfig_mutableEndPoint(self) + + def enableHealthCheck(self): + return _wedpr_python_transport.GrpcServerConfig_enableHealthCheck(self) + __swig_destroy__ = _wedpr_python_transport.delete_GrpcServerConfig + + +# Register GrpcServerConfig in _wedpr_python_transport: +_wedpr_python_transport.GrpcServerConfig_swigregister(GrpcServerConfig) + + +class GrpcConfig(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.GrpcConfig_swiginit( + self, _wedpr_python_transport.new_GrpcConfig()) + __swig_destroy__ = _wedpr_python_transport.delete_GrpcConfig + + def loadBalancePolicy(self): + return _wedpr_python_transport.GrpcConfig_loadBalancePolicy(self) + + def setLoadBalancePolicy(self, loadBalancePolicy): + return _wedpr_python_transport.GrpcConfig_setLoadBalancePolicy(self, loadBalancePolicy) + + def enableHealthCheck(self): + return _wedpr_python_transport.GrpcConfig_enableHealthCheck(self) + + def setEnableHealthCheck(self, enableHealthCheck): + return _wedpr_python_transport.GrpcConfig_setEnableHealthCheck(self, enableHealthCheck) + + def setEnableDnslookup(self, enableDnslookup): + return _wedpr_python_transport.GrpcConfig_setEnableDnslookup(self, enableDnslookup) + + def enableDnslookup(self): + return _wedpr_python_transport.GrpcConfig_enableDnslookup(self) + + +# Register GrpcConfig in _wedpr_python_transport: +_wedpr_python_transport.GrpcConfig_swigregister(GrpcConfig) + + +class MessageOptionalHeader(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_MessageOptionalHeader + + def encode(self, buffer): + return _wedpr_python_transport.MessageOptionalHeader_encode(self, buffer) + + def decode(self, data, _offset): + return _wedpr_python_transport.MessageOptionalHeader_decode(self, data, _offset) + + def componentType(self): + return _wedpr_python_transport.MessageOptionalHeader_componentType(self) + + def setComponentType(self, componentType): + return _wedpr_python_transport.MessageOptionalHeader_setComponentType(self, componentType) + + def srcNode(self): + return _wedpr_python_transport.MessageOptionalHeader_srcNode(self) + + def srcNodeBuffer(self): + r""" for swig-wrapper(pass the binary data)""" + return _wedpr_python_transport.MessageOptionalHeader_srcNodeBuffer(self) + + def setSrcNode(self, *args): + return _wedpr_python_transport.MessageOptionalHeader_setSrcNode(self, *args) + + def dstNode(self): + return _wedpr_python_transport.MessageOptionalHeader_dstNode(self) + + def dstNodeBuffer(self): + return _wedpr_python_transport.MessageOptionalHeader_dstNodeBuffer(self) + + def setDstNode(self, dstNode): + return _wedpr_python_transport.MessageOptionalHeader_setDstNode(self, dstNode) + + def setDstNodeBuffer(self, data): + return _wedpr_python_transport.MessageOptionalHeader_setDstNodeBuffer(self, data) + + def dstInst(self): + return _wedpr_python_transport.MessageOptionalHeader_dstInst(self) + + def setDstInst(self, dstInst): + return _wedpr_python_transport.MessageOptionalHeader_setDstInst(self, dstInst) + + def topic(self): + return _wedpr_python_transport.MessageOptionalHeader_topic(self) + + def setTopic(self, *args): + return _wedpr_python_transport.MessageOptionalHeader_setTopic(self, *args) + + def srcInst(self): + return _wedpr_python_transport.MessageOptionalHeader_srcInst(self) + + def setSrcInst(self, srcInst): + return _wedpr_python_transport.MessageOptionalHeader_setSrcInst(self, srcInst) + + +# Register MessageOptionalHeader in _wedpr_python_transport: +_wedpr_python_transport.MessageOptionalHeader_swigregister( + MessageOptionalHeader) + + +class MessageHeader(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_MessageHeader + + def encode(self, buffer): + return _wedpr_python_transport.MessageHeader_encode(self, buffer) + + def decode(self, data): + return _wedpr_python_transport.MessageHeader_decode(self, data) + + def version(self): + return _wedpr_python_transport.MessageHeader_version(self) + + def setVersion(self, version): + return _wedpr_python_transport.MessageHeader_setVersion(self, version) + + def traceID(self): + return _wedpr_python_transport.MessageHeader_traceID(self) + + def setTraceID(self, traceID): + return _wedpr_python_transport.MessageHeader_setTraceID(self, traceID) + + def srcGwNode(self): + return _wedpr_python_transport.MessageHeader_srcGwNode(self) + + def setSrcGwNode(self, srcGwNode): + return _wedpr_python_transport.MessageHeader_setSrcGwNode(self, srcGwNode) + + def dstGwNode(self): + return _wedpr_python_transport.MessageHeader_dstGwNode(self) + + def setDstGwNode(self, dstGwNode): + return _wedpr_python_transport.MessageHeader_setDstGwNode(self, dstGwNode) + + def packetType(self): + return _wedpr_python_transport.MessageHeader_packetType(self) + + def setPacketType(self, packetType): + return _wedpr_python_transport.MessageHeader_setPacketType(self, packetType) + + def ttl(self): + return _wedpr_python_transport.MessageHeader_ttl(self) + + def setTTL(self, ttl): + return _wedpr_python_transport.MessageHeader_setTTL(self, ttl) + + def ext(self): + return _wedpr_python_transport.MessageHeader_ext(self) + + def setExt(self, ext): + return _wedpr_python_transport.MessageHeader_setExt(self, ext) + + def optionalField(self): + return _wedpr_python_transport.MessageHeader_optionalField(self) + + def setOptionalField(self, optionalField): + return _wedpr_python_transport.MessageHeader_setOptionalField(self, optionalField) + + def length(self): + return _wedpr_python_transport.MessageHeader_length(self) + + def isRespPacket(self): + return _wedpr_python_transport.MessageHeader_isRespPacket(self) + + def setRespPacket(self): + return _wedpr_python_transport.MessageHeader_setRespPacket(self) + + def srcP2PNodeIDView(self): + return _wedpr_python_transport.MessageHeader_srcP2PNodeIDView(self) + + def dstP2PNodeIDView(self): + return _wedpr_python_transport.MessageHeader_dstP2PNodeIDView(self) + + def routeType(self): + return _wedpr_python_transport.MessageHeader_routeType(self) + + def setRouteType(self, type): + return _wedpr_python_transport.MessageHeader_setRouteType(self, type) + + def hasOptionalField(self): + return _wedpr_python_transport.MessageHeader_hasOptionalField(self) + + +# Register MessageHeader in _wedpr_python_transport: +_wedpr_python_transport.MessageHeader_swigregister(MessageHeader) + + +class Message(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_Message + + def header(self): + return _wedpr_python_transport.Message_header(self) + + def setHeader(self, header): + return _wedpr_python_transport.Message_setHeader(self, header) + + def version(self): + r""" the overloaed implementation ===""" + return _wedpr_python_transport.Message_version(self) + + def setVersion(self, version): + return _wedpr_python_transport.Message_setVersion(self, version) + + def packetType(self): + return _wedpr_python_transport.Message_packetType(self) + + def setPacketType(self, packetType): + return _wedpr_python_transport.Message_setPacketType(self, packetType) + + def seq(self): + return _wedpr_python_transport.Message_seq(self) + + def setSeq(self, traceID): + return _wedpr_python_transport.Message_setSeq(self, traceID) + + def ext(self): + return _wedpr_python_transport.Message_ext(self) + + def setExt(self, ext): + return _wedpr_python_transport.Message_setExt(self, ext) + + def isRespPacket(self): + return _wedpr_python_transport.Message_isRespPacket(self) + + def setRespPacket(self): + return _wedpr_python_transport.Message_setRespPacket(self) + + def length(self): + return _wedpr_python_transport.Message_length(self) + + def payload(self): + return _wedpr_python_transport.Message_payload(self) + + def payloadBuffer(self): + return _wedpr_python_transport.Message_payloadBuffer(self) + + def setPayload(self, _payload): + return _wedpr_python_transport.Message_setPayload(self, _payload) + + def setFrontMessage(self, frontMessage): + return _wedpr_python_transport.Message_setFrontMessage(self, frontMessage) + + def frontMessage(self): + return _wedpr_python_transport.Message_frontMessage(self) + + def encode(self, *args): + return _wedpr_python_transport.Message_encode(self, *args) + + def decode(self, _buffer): + return _wedpr_python_transport.Message_decode(self, _buffer) + + +# Register Message in _wedpr_python_transport: +_wedpr_python_transport.Message_swigregister(Message) + + +class MessageHeaderBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_MessageHeaderBuilder + + def build(self, *args): + return _wedpr_python_transport.MessageHeaderBuilder_build(self, *args) + + +# Register MessageHeaderBuilder in _wedpr_python_transport: +_wedpr_python_transport.MessageHeaderBuilder_swigregister(MessageHeaderBuilder) + + +class MessageBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_MessageBuilder + + def build(self, *args): + return _wedpr_python_transport.MessageBuilder_build(self, *args) + + +# Register MessageBuilder in _wedpr_python_transport: +_wedpr_python_transport.MessageBuilder_swigregister(MessageBuilder) + + +class MessageOptionalHeaderBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_MessageOptionalHeaderBuilder + + def build(self, *args): + return _wedpr_python_transport.MessageOptionalHeaderBuilder_build(self, *args) + + +# Register MessageOptionalHeaderBuilder in _wedpr_python_transport: +_wedpr_python_transport.MessageOptionalHeaderBuilder_swigregister( + MessageOptionalHeaderBuilder) + + +def printOptionalField(optionalHeader): + return _wedpr_python_transport.printOptionalField(optionalHeader) + + +def printMessage(_msg): + return _wedpr_python_transport.printMessage(_msg) + + +def printWsMessage(_msg): + return _wedpr_python_transport.printWsMessage(_msg) + + +FrontMsgExtFlag_Response = _wedpr_python_transport.FrontMsgExtFlag_Response + + +class MessagePayload(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_MessagePayload + + def encode(self, buffer): + return _wedpr_python_transport.MessagePayload_encode(self, buffer) + + def decode(self, data): + return _wedpr_python_transport.MessagePayload_decode(self, data) + + def version(self): + return _wedpr_python_transport.MessagePayload_version(self) + + def setVersion(self, version): + return _wedpr_python_transport.MessagePayload_setVersion(self, version) + + def data(self): + return _wedpr_python_transport.MessagePayload_data(self) + + def dataBuffer(self): + return _wedpr_python_transport.MessagePayload_dataBuffer(self) + + def setData(self, *args): + return _wedpr_python_transport.MessagePayload_setData(self, *args) + + def seq(self): + return _wedpr_python_transport.MessagePayload_seq(self) + + def setSeq(self, seq): + return _wedpr_python_transport.MessagePayload_setSeq(self, seq) + + def length(self): + return _wedpr_python_transport.MessagePayload_length(self) + + def traceID(self): + return _wedpr_python_transport.MessagePayload_traceID(self) + + def setTraceID(self, traceID): + return _wedpr_python_transport.MessagePayload_setTraceID(self, traceID) + + def ext(self): + return _wedpr_python_transport.MessagePayload_ext(self) + + def setExt(self, ext): + return _wedpr_python_transport.MessagePayload_setExt(self, ext) + + def setRespPacket(self): + return _wedpr_python_transport.MessagePayload_setRespPacket(self) + + def isRespPacket(self): + return _wedpr_python_transport.MessagePayload_isRespPacket(self) + + +# Register MessagePayload in _wedpr_python_transport: +_wedpr_python_transport.MessagePayload_swigregister(MessagePayload) + + +class MessagePayloadBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_MessagePayloadBuilder + + def build(self, *args): + return _wedpr_python_transport.MessagePayloadBuilder_build(self, *args) + + +# Register MessagePayloadBuilder in _wedpr_python_transport: +_wedpr_python_transport.MessagePayloadBuilder_swigregister( + MessagePayloadBuilder) + + +class IFrontClient(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_IFrontClient + + def onReceiveMessage(self, _msg, _callback): + r""" + : receive message from gateway, call by gateway + :param _message:: received ppc message + :rtype: void + :return: void + """ + return _wedpr_python_transport.IFrontClient_onReceiveMessage(self, _msg, _callback) + + +# Register IFrontClient in _wedpr_python_transport: +_wedpr_python_transport.IFrontClient_swigregister(IFrontClient) + + +class ErrorCallback(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + if self.__class__ == ErrorCallback: + _self = None + else: + _self = self + _wedpr_python_transport.ErrorCallback_swiginit( + self, _wedpr_python_transport.new_ErrorCallback(_self, )) + __swig_destroy__ = _wedpr_python_transport.delete_ErrorCallback + + def onError(self, error): + return _wedpr_python_transport.ErrorCallback_onError(self, error) + + def __disown__(self): + self.this.disown() + _wedpr_python_transport.disown_ErrorCallback(self) + return weakref.proxy(self) + + +# Register ErrorCallback in _wedpr_python_transport: +_wedpr_python_transport.ErrorCallback_swigregister(ErrorCallback) + + +class MessageDispatcherHandler(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + if self.__class__ == MessageDispatcherHandler: + _self = None + else: + _self = self + _wedpr_python_transport.MessageDispatcherHandler_swiginit( + self, _wedpr_python_transport.new_MessageDispatcherHandler(_self, )) + __swig_destroy__ = _wedpr_python_transport.delete_MessageDispatcherHandler + + def onMessage(self, msg): + return _wedpr_python_transport.MessageDispatcherHandler_onMessage(self, msg) + + def __disown__(self): + self.this.disown() + _wedpr_python_transport.disown_MessageDispatcherHandler(self) + return weakref.proxy(self) + + +# Register MessageDispatcherHandler in _wedpr_python_transport: +_wedpr_python_transport.MessageDispatcherHandler_swigregister( + MessageDispatcherHandler) + + +class SendResponseHandler(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, responseFunc): + _wedpr_python_transport.SendResponseHandler_swiginit( + self, _wedpr_python_transport.new_SendResponseHandler(responseFunc)) + __swig_destroy__ = _wedpr_python_transport.delete_SendResponseHandler + + def sendResponse(self, payload): + return _wedpr_python_transport.SendResponseHandler_sendResponse(self, payload) + + +# Register SendResponseHandler in _wedpr_python_transport: +_wedpr_python_transport.SendResponseHandler_swigregister(SendResponseHandler) + + +class IMessageHandler(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + if self.__class__ == IMessageHandler: + _self = None + else: + _self = self + _wedpr_python_transport.IMessageHandler_swiginit( + self, _wedpr_python_transport.new_IMessageHandler(_self, )) + __swig_destroy__ = _wedpr_python_transport.delete_IMessageHandler + + def onMessage(self, e, msg, sendResponseHandler): + return _wedpr_python_transport.IMessageHandler_onMessage(self, e, msg, sendResponseHandler) + + def __disown__(self): + self.this.disown() + _wedpr_python_transport.disown_IMessageHandler(self) + return weakref.proxy(self) + + +# Register IMessageHandler in _wedpr_python_transport: +_wedpr_python_transport.IMessageHandler_swigregister(IMessageHandler) + + +class GetPeersInfoHandler(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + if self.__class__ == GetPeersInfoHandler: + _self = None + else: + _self = self + _wedpr_python_transport.GetPeersInfoHandler_swiginit( + self, _wedpr_python_transport.new_GetPeersInfoHandler(_self, )) + __swig_destroy__ = _wedpr_python_transport.delete_GetPeersInfoHandler + + def onPeersInfo(self, e, peersInfo): + return _wedpr_python_transport.GetPeersInfoHandler_onPeersInfo(self, e, peersInfo) + + def __disown__(self): + self.this.disown() + _wedpr_python_transport.disown_GetPeersInfoHandler(self) + return weakref.proxy(self) + + +# Register GetPeersInfoHandler in _wedpr_python_transport: +_wedpr_python_transport.GetPeersInfoHandler_swigregister(GetPeersInfoHandler) + + +class IFront(IFrontClient): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_IFront + + def start(self): + r""" + start the IFront + + :param front: the IFront to start + """ + return _wedpr_python_transport.IFront_start(self) + + def stop(self): + r""" + stop the IFront + + :param front: the IFront to stop + """ + return _wedpr_python_transport.IFront_stop(self) + + def register_topic_handler(self, topic, callback): + return _wedpr_python_transport.IFront_register_topic_handler(self, topic, callback) + + def register_msg_handler(self, componentType, callback): + return _wedpr_python_transport.IFront_register_msg_handler(self, componentType, callback) + + def async_send_message(self, routeType, routeInfo, payload, seq, timeout, errorCallback, msgHandler): + return _wedpr_python_transport.IFront_async_send_message(self, routeType, routeInfo, payload, seq, timeout, errorCallback, msgHandler) + + def async_send_response(self, dstNode, dstNodeSize, traceID, payload, seq, errorCallback): + return _wedpr_python_transport.IFront_async_send_response(self, dstNode, dstNodeSize, traceID, payload, seq, errorCallback) + + def push(self, routeType, routeInfo, payload, seq, timeout): + return _wedpr_python_transport.IFront_push(self, routeType, routeInfo, payload, seq, timeout) + + def push_msg(self, routeType, routeInfo, payload, seq, timeout): + return _wedpr_python_transport.IFront_push_msg(self, routeType, routeInfo, payload, seq, timeout) + + def pop(self, topic, timeoutMs): + return _wedpr_python_transport.IFront_pop(self, topic, timeoutMs) + + def peek(self, topic): + return _wedpr_python_transport.IFront_peek(self, topic) + + def asyncGetPeers(self, getPeersCallback): + return _wedpr_python_transport.IFront_asyncGetPeers(self, getPeersCallback) + + def registerNodeInfo(self, nodeInfo): + r""" + register the nodeInfo to the gateway + :type nodeInfo: ppc::protocol::INodeInfo::Ptr + :param nodeInfo: the nodeInfo + """ + return _wedpr_python_transport.IFront_registerNodeInfo(self, nodeInfo) + + def unRegisterNodeInfo(self): + r"""unRegister the nodeInfo to the gateway""" + return _wedpr_python_transport.IFront_unRegisterNodeInfo(self) + + def nodeInfo(self): + return _wedpr_python_transport.IFront_nodeInfo(self) + + def registerTopic(self, topic): + r""" + register the topic + + :type topic: string + :param topic: the topic to register + """ + return _wedpr_python_transport.IFront_registerTopic(self, topic) + + def unRegisterTopic(self, topic): + r""" + unRegister the topic + + :type topic: string + :param topic: the topic to unregister + """ + return _wedpr_python_transport.IFront_unRegisterTopic(self, topic) + + def registerComponent(self, component): + return _wedpr_python_transport.IFront_registerComponent(self, component) + + def unRegisterComponent(self, component): + return _wedpr_python_transport.IFront_unRegisterComponent(self, component) + + +# Register IFront in _wedpr_python_transport: +_wedpr_python_transport.IFront_swigregister(IFront) + + +class IFrontBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _wedpr_python_transport.delete_IFrontBuilder + + def buildClient(self, endPoint, onUnHealthHandler, removeHandlerOnUnhealth): + return _wedpr_python_transport.IFrontBuilder_buildClient(self, endPoint, onUnHealthHandler, removeHandlerOnUnhealth) + + +# Register IFrontBuilder in _wedpr_python_transport: +_wedpr_python_transport.IFrontBuilder_swigregister(IFrontBuilder) +SDKMode_AIR = _wedpr_python_transport.SDKMode_AIR +SDKMode_PRO = _wedpr_python_transport.SDKMode_PRO + + +class TransportBuilder(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _wedpr_python_transport.TransportBuilder_swiginit( + self, _wedpr_python_transport.new_TransportBuilder()) + __swig_destroy__ = _wedpr_python_transport.delete_TransportBuilder + + def buildProTransport(self, config): + return _wedpr_python_transport.TransportBuilder_buildProTransport(self, config) + + def buildConfig(self, threadPoolSize, nodeID): + return _wedpr_python_transport.TransportBuilder_buildConfig(self, threadPoolSize, nodeID) + + def frontConfigBuilder(self): + return _wedpr_python_transport.TransportBuilder_frontConfigBuilder(self) + + +# Register TransportBuilder in _wedpr_python_transport: +_wedpr_python_transport.TransportBuilder_swigregister(TransportBuilder) + + +class Transport(object): + thisown = property(lambda x: x.this.own(), lambda x, + v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, config): + _wedpr_python_transport.Transport_swiginit( + self, _wedpr_python_transport.new_Transport(config)) + __swig_destroy__ = _wedpr_python_transport.delete_Transport + + def start(self): + return _wedpr_python_transport.Transport_start(self) + + def stop(self): + return _wedpr_python_transport.Transport_stop(self) + + def getFront(self): + return _wedpr_python_transport.Transport_getFront(self) + + def gateway(self): + return _wedpr_python_transport.Transport_gateway(self) + + def msgPayloadBuilder(self): + return _wedpr_python_transport.Transport_msgPayloadBuilder(self) + + def msgBuilder(self): + return _wedpr_python_transport.Transport_msgBuilder(self) + + def msgHeaderBuilder(self): + return _wedpr_python_transport.Transport_msgHeaderBuilder(self) + + def routeInfoBuilder(self): + return _wedpr_python_transport.Transport_routeInfoBuilder(self) + + def getConfig(self): + return _wedpr_python_transport.Transport_getConfig(self) + + +# Register Transport in _wedpr_python_transport: +_wedpr_python_transport.Transport_swigregister(Transport) diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/__init__.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_factory.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_factory.py new file mode 100644 index 0000000..59f5ef6 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_factory.py @@ -0,0 +1,11 @@ +from transport.impl.message_impl import MessageImpl +from transport.api.message_api import MessageAPI +from transport.generated.wedpr_python_transport import Message + + +class MessageFactory: + @staticmethod + def build(message: Message) -> MessageAPI: + if message is None: + return None + return MessageImpl(message) diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_impl.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_impl.py new file mode 100644 index 0000000..218462b --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/message_impl.py @@ -0,0 +1,87 @@ +# -*- coding: utf-8 -*- + +from transport.api.message_api import MessageHeaderAPI +from transport.api.message_api import MessageAPI +from transport.generated.wedpr_python_transport import Message +from transport.generated.wedpr_python_transport import MessageHeader + + +class MessageHeaderImpl(MessageHeaderAPI): + + def __init__(self, header: MessageHeader): + if header is None: + raise Exception( + "Build MessageHeader failed for empty header object passed in") + self.__header = header + + def get_version(self) -> str: + return self.__header.version() + + def get_trace_id(self) -> str: + return self.__header.traceID() + + def get_src_gw_node(self) -> str: + return self.__header.srcGwNode() + + def get_dst_gw_node(self) -> str: + return self.__header.dstGwNode() + + def get_packet_type(self) -> int: + return self.__header.packetType() + + def get_ttl(self) -> int: + return self.__header.ttl() + + def get_ext(self) -> int: + return self.__header.exit() + + def is_resp_packet(self) -> bool: + return self.__header.isRespPacket() + + def get_route_type(self) -> int: + return self.__header.routeType() + + def get_component_type(self) -> str: + return self.__header.optionalField().componentType() + + def get_src_node(self) -> bytes: + return self.__header.optionalField().srcNodeBuffer() + + def get_dst_node(self) -> bytes: + return self.__header.optionalField().dstNodeBuffer() + + def get_dst_inst(self) -> str: + return self.__header.optionalField().dstInst() + + def get_src_inst(self) -> str: + return self.__header.optionalField().srcInst() + + def get_topic(self) -> str: + return self.__header.optionalField().topic() + + def detail(self) -> str: + return f"version: {self.get_version()}, topic: {self.get_topic()}, src_inst: {self.get_src_inst()},src_node: {str(self.get_src_node())}, dst_inst: {self.get_dst_inst()}, dst_node: {str(self.get_dst_node())}" + + +class MessageImpl(MessageAPI): + def __init__(self, message: Message): + if message is None: + raise Exception( + "Build Message failed for empty message object passed in") + self.__message = message + self.__message_header = MessageHeaderImpl(self.__message.header()) + + def get_header(self) -> MessageHeaderAPI: + return self.__message_header + + def get_seq(self) -> int: + return self.__message.frontMessage().seq() + + def get_payload(self) -> bytes: + return self.__message.frontMessage().dataBuffer() + + def get_length(self) -> int: + return self.__message.frontMessage().length() + + def detail(self) -> str: + return f"seq: {self.get_seq()}, header: {self.get_header().detail()}, length: {self.get_length()}" diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/route_info_builder.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/route_info_builder.py new file mode 100644 index 0000000..d7fe803 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/route_info_builder.py @@ -0,0 +1,20 @@ +# -*- coding: utf-8 -*- +from transport.generated.wedpr_python_transport import MessageOptionalHeaderBuilder +from transport.generated.wedpr_python_transport import MessageOptionalHeader + + +class RouteInfoBuilder: + def __init__(self, builder: MessageOptionalHeaderBuilder): + self.__route_info_builder = builder + + def build(self, topic: str, dst_node: bytes, dst_inst: str, component: str) -> MessageOptionalHeader: + routeInfo = self.__route_info_builder.build() + if topic is not None: + routeInfo.setTopic(topic) + if dst_node is not None: + routeInfo.setDstNodeBuffer(dst_node) + if dst_inst is not None: + routeInfo.setDstInst(dst_inst) + if component is not None: + routeInfo.setComponentType(component) + return routeInfo diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport.py new file mode 100644 index 0000000..b6239b6 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport.py @@ -0,0 +1,100 @@ +# -*- coding: utf-8 -*- + +from transport.generated.wedpr_python_transport import TransportBuilder +from transport.generated.wedpr_python_transport import Transport +from transport.generated.wedpr_python_transport import Error +from transport.api.message_api import MessageAPI +from transport.impl.route_info_builder import RouteInfoBuilder +from transport.impl.message_factory import MessageFactory +from transport.generated.wedpr_python_transport import MessageOptionalHeader +from transport.api.transport_api import TransportAPI + +from enum import Enum +import signal + + +class RouteType(Enum): + ROUTE_THROUGH_NODEID = 0 + ROUTE_THROUGH_COMPONENT = 1 + ROUTE_THROUGH_AGENCY = 2 + ROUTE_THROUGH_TOPIC = 3 + + +class Transport(TransportAPI): + should_exit = False + + def __init__(self, transport: Transport): + self.__transport = transport + self.__route_info_builder = RouteInfoBuilder( + self.__transport.routeInfoBuilder()) + + def start(self): + self.__transport.start() + + def stop(self): + self.__transport.stop() + + def _push_msg(self, route_type: int, route_info: MessageOptionalHeader, payload: bytes, seq: int, timeout: int): + try: + return self.__transport.getFront().push_msg(route_type, route_info, payload, seq, timeout) + except Exception as e: + raise e + + def push_by_nodeid(self, topic: str, dstNode: bytes, seq: int, payload: bytes, timeout: int): + route_info = self.__route_info_builder.build( + topic=topic, dst_node=dstNode, dst_inst=None, component=None) + result = self._push_msg( + RouteType.ROUTE_THROUGH_NODEID.value, route_info, payload, seq, timeout) + Transport.check_result("push_by_nodeid", result) + + def push_by_inst(self, topic: str, dstInst: str, seq: int, payload: bytes, timeout: int): + route_info = self.__route_info_builder.build( + topic=topic, dst_node=None, dst_inst=dstInst, component=None) + result = self._push_msg( + RouteType.ROUTE_THROUGH_AGENCY.value, route_info, payload, len(payload), seq, timeout) + Transport.check_result("push_by_inst", result) + + def push_by_component(self, topic: str, dstInst: str, component: str, seq: int, payload: bytes, timeout: int): + route_info = self.__route_info_builder.build( + topic=topic, dst_node=None, dst_inst=dstInst, component=component) + result = self._push_msg( + RouteType.ROUTE_THROUGH_COMPONENT.value, route_info, payload, len(payload), seq, timeout) + Transport.check_result("push_by_component", result) + + def pop(self, topic, timeout_ms) -> MessageAPI: + return MessageFactory.build(self.__transport.getFront().pop(topic, timeout_ms)) + + def peek(self, topic): + return self.__transport.peek(topic) + + @staticmethod + def check_result(method: str, result: Error): + if result is None: + return + if result.errorCode() != 0: + raise Exception( + f"call {method} failed for {result.errorMessage()}, code: {result.errorCode()}") + + def register_topic(self, topic): + result = self.__transport.getFront().registerTopic(topic) + Transport.check_result("register_topic", result) + + def unregister_topic(self, topic): + result = self.__transport.getFront().unRegisterTopic(topic) + Transport.check_result("unregister_topic", result) + + def register_component(self, component): + result = self.__transport.getFront().registerComponent(component) + Transport.check_result("register_component", result) + + def unregister_component(self, component): + result = self.__transport.getFront().unRegisterComponent(component) + Transport.check_result("unregister_component", result) + + +def signal_handler(sig, frame): + print('You pressed Ctrl+C! Exiting gracefully.') + Transport.should_exit = True + + +signal.signal(signal.SIGINT, signal_handler) diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_config.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_config.py new file mode 100644 index 0000000..9b7d748 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_config.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- + +from transport.generated.wedpr_python_transport import FrontConfig +from transport.generated.wedpr_python_transport import TransportBuilder +from transport.generated.wedpr_python_transport import EndPoint +from transport.generated.wedpr_python_transport import GrpcConfig + + +class TransportConfig: + """ + the transport config + """ + + def __init__(self, threadpool_size: int, nodeID: str, gateway_targets: str): + self.__transport_builder = TransportBuilder() + self.__front_config = self.__transport_builder.buildConfig( + threadpool_size, nodeID) + self.__front_config.setGatewayGrpcTarget(gateway_targets) + + def get_front_config(self) -> FrontConfig: + return self.__front_config + + def set_self_endpoint(self, host: str, port: int, listen_ip: str = None): + endPoint = EndPoint(host, port) + if listen_ip is None: + listen_ip = "0.0.0.0" + endPoint.setListenIp(listen_ip) + self.__front_config.setSelfEndPoint(endPoint) + + def set_grpc_config(self, grpc_config: GrpcConfig): + self.__front_config.set_grpc_config(grpc_config) + + def get_thread_pool_size(self) -> int: + return self.__front_config.threadPoolSize() + + def get_node_id(self) -> str: + return self.__front_config.nodeID() + + def get_gateway_targets(self) -> str: + return self.__front_config.gatewayGrpcTarget() + + def get_self_endpoint(self) -> EndPoint: + return self.__front_config.selfEndPoint() + + def desc(self): + return f"thread_pool_size: {self.get_thread_pool_size()}, \ + nodeID: {self.get_node_id()}, \ + gatewayTargets: {self.get_gateway_targets()}, \ + endPoint: {self.get_self_endpoint().entryPoint()}" diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_loader.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_loader.py new file mode 100644 index 0000000..02b0c54 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/transport/impl/transport_loader.py @@ -0,0 +1,15 @@ +# -*- coding: utf-8 -*- +from transport.impl.transport_config import TransportConfig +from transport.generated.wedpr_python_transport import TransportBuilder +from transport.impl.transport import Transport +import signal + + +class TransportLoader: + transport_builder = TransportBuilder() + + @staticmethod + def load(transport_config: TransportConfig) -> Transport: + transport = TransportLoader.transport_builder.buildProTransport( + transport_config.get_front_config()) + return Transport(transport) diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/lib_loader.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/lib_loader.py index dbc9a78..e469aca 100644 --- a/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/lib_loader.py +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/lib_loader.py @@ -79,11 +79,3 @@ def get_lib_name(): return "{}{}.{}".format(LibLoader.LIB_PREFIX, LibLoader.TRANSPORT_LIB_NAME, LibLoader.LINUX_LIB_PORSTFIX) raise Exception( f"get_lib_name failed for not support the os_type: {os_type}") - - @staticmethod - def load_lib(): - lib_path = os.path.join( - LibLoader.TRANSPORT_LIB_PATH, LibLoader.get_lib_name()) - print(f"#### lib_path: {lib_path}") - lib = ctypes.cdll.LoadLibrary(lib_path) - return lib diff --git a/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/tests/test_lib_loader.py b/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/tests/test_lib_loader.py index 2f287a8..8de1e1c 100644 --- a/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/tests/test_lib_loader.py +++ b/cpp/wedpr-transport/sdk-wrapper/python/bindings/utils/tests/test_lib_loader.py @@ -4,8 +4,7 @@ class TestLibLoader(unittest.TestCase): def test_load_lib(self): - from utils.lib_loader import LibLoader - _wedpr_python_transport = LibLoader.load_lib() + LibLoader.get_lib_name() if __name__ == '__main__': diff --git a/cpp/wedpr-transport/sdk-wrapper/python/swig/wedpr_python_transport.i b/cpp/wedpr-transport/sdk-wrapper/python/swig/wedpr_python_transport.i index 60e4f35..242d681 100644 --- a/cpp/wedpr-transport/sdk-wrapper/python/swig/wedpr_python_transport.i +++ b/cpp/wedpr-transport/sdk-wrapper/python/swig/wedpr_python_transport.i @@ -1,18 +1,19 @@ %define MODULEIMPORT " -from utils.lib_loader import LibLoader -_wedpr_python_transport = LibLoader.load_lib() +# Import the low-level C/C++ module +from libs import _wedpr_python_transport " %enddef %module(moduleimport=MODULEIMPORT) wedpr_python_transport +%module(directors="1") wedpr_python_transport %include %include %include %include %include - +%include "typemaps.i" // shared_ptr definition %shared_ptr(ppc::front::FrontConfig); @@ -40,6 +41,8 @@ _wedpr_python_transport = LibLoader.load_lib() %{ #define SWIG_FILE_WITH_INIT +#include +#include #include #include #include @@ -130,6 +133,14 @@ namespace bcos{ %template(ubytes) std::vector; %template(ibytes) std::vector; +%include +%pybuffer_binary(char* data, uint64_t length) +%pybuffer_binary(char* payload, uint64_t payloadSize) + +%typemap(out) OutputBuffer { + $result = PyBytes_FromStringAndSize((const char *)$1.data, $1.len); +} + /// callbacks %feature("director") ppc::front::ErrorCallback; %feature("director") ppc::front::MessageDispatcherHandler; From e3b79b63f3de3933339f084b84c32c39e832bdf3 Mon Sep 17 00:00:00 2001 From: cyjseagull Date: Fri, 27 Sep 2024 18:53:10 +0800 Subject: [PATCH 2/2] add generated cxx file --- .../src/wedpr_python_transportPYTHON_wrap.cxx | 23571 ++++++++++++++++ .../src/wedpr_python_transportPYTHON_wrap.h | 184 + 2 files changed, 23755 insertions(+) create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.cxx create mode 100644 cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.h diff --git a/cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.cxx b/cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.cxx new file mode 100644 index 0000000..12d60c0 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.cxx @@ -0,0 +1,23571 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.2.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +#define SWIG_VERSION 0x040201 +#define SWIGPYTHON +#define SWIG_DIRECTORS +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + +#if defined(__cplusplus) && __cplusplus >=201103L +# define SWIG_NULLPTR nullptr +#else +# define SWIG_NULLPTR NULL +#endif + +/* ----------------------------------------------------------------------------- + * swigcompat.swg + * + * Macros to provide support compatibility with older C and C++ standards. + * ----------------------------------------------------------------------------- */ + +/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF + * if you're missing it. + */ +#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \ + (defined __cplusplus && __cplusplus >= 201103L) || \ + defined SWIG_HAVE_SNPRINTF) && \ + !defined SWIG_NO_SNPRINTF +# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A) +# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B) +#else +/* Fallback versions ignore the buffer size, but most of our uses either have a + * fixed maximum possible size or dynamically allocate a buffer that's large + * enough. + */ +# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A) +# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B) +#endif + + +#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) +/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ +# include +#endif + +#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN) +#define PY_SSIZE_T_CLEAN +#endif + +#if __GNUC__ >= 7 +#pragma GCC diagnostic push +#if defined(__cplusplus) && __cplusplus >=201703L +#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */ +#endif +#endif + +#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) +/* Use debug wrappers with the Python release dll */ + +#if defined(_MSC_VER) && _MSC_VER >= 1929 +/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later + * See https://github.com/swig/swig/issues/2090 */ +# include +#endif + +# undef _DEBUG +# include +# define _DEBUG 1 +#else +# include +#endif + +#if __GNUC__ >= 7 +#pragma GCC diagnostic pop +#endif + +#include + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 +#define SWIG_POINTER_CLEAR 0x8 +#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN) + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows returning the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +/* Runtime errors are < 0 */ +#define SWIG_ERROR (-1) +/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */ +/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */ +/* Errors < -200 are generic runtime specific errors */ +#define SWIG_ERROR_RELEASE_NOT_OWNED (-200) + +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporary objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del object mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. Choose the last + name. It should be the most specific; a fully resolved name + but not necessarily with default template parameters expanded. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = (unsigned char)((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = (unsigned char)((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (unsigned char)(d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (unsigned char)(d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */ +SWIGINTERN const char * +SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes) +{ +#if PY_VERSION_HEX >= 0x03030000 +# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 + *pbytes = NULL; + return PyUnicode_AsUTF8AndSize(str, psize); +# else + *pbytes = PyUnicode_AsUTF8String(str); + const char *chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL; + if (chars && psize) + *psize = PyBytes_Size(*pbytes); + return chars; +# endif +#else + char *chars = NULL; + *pbytes = NULL; + PyString_AsStringAndSize(str, &chars, psize); + return chars; +#endif +} + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */ +# define SWIGPY_USE_CAPSULE +#ifdef SWIGPYTHON_BUILTIN +# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME +#else +# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME +#endif +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME) + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define Py_hash_t long +#endif + +#ifdef Py_LIMITED_API +# define PyTuple_GET_ITEM PyTuple_GetItem +/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used + interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */ +# define PyTuple_SET_ITEM PyTuple_SetItem +# define PyTuple_GET_SIZE PyTuple_Size +# define PyCFunction_GET_FLAGS PyCFunction_GetFlags +# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction +# define PyCFunction_GET_SELF PyCFunction_GetSelf +# define PyList_GET_ITEM PyList_GetItem +# define PyList_SET_ITEM PyList_SetItem +# define PySliceObject PyObject +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + PyObject *bytes = NULL; + const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes); + PyErr_Clear(); + Py_XINCREF(type); + if (tmp) + PyErr_Format(type, "%s %s", tmp, mesg); + else + PyErr_Format(type, "%s", mesg); + Py_XDECREF(bytes); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +SWIGRUNTIME int +SWIG_Python_TypeErrorOccurred(PyObject *obj) +{ + PyObject *error; + if (obj) + return 0; + error = PyErr_Occurred(); + return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError); +} + +SWIGRUNTIME void +SWIG_Python_RaiseOrModifyTypeError(const char *message) +{ + if (SWIG_Python_TypeErrorOccurred(NULL)) { + /* Use existing TypeError to preserve stacktrace and enhance with given message */ + PyObject *newvalue; + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); +#if PY_VERSION_HEX >= 0x03000000 + newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message); +#else + newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); +#endif + if (newvalue) { + Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + PyErr_Restore(type, value, traceback); + } + } else { + /* Raise TypeError using given message */ + PyErr_SetString(PyExc_TypeError, message); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# define SWIG_PYTHON_USE_GIL +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# if PY_VERSION_HEX < 0x03070000 +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# else +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { status = false; PyEval_RestoreThread(save); }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + const char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */ +# error "This version of SWIG only supports Python >= 2.7" +#endif + +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000 +# error "This version of SWIG only supports Python 3 >= 3.3" +#endif + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + if (result) { + PyList_SET_ITEM(result, 0, o2); + } else { + Py_DECREF(obj); + return o2; + } + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +} + +/* Unpack the argument tuple */ + +SWIGINTERN Py_ssize_t +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + Py_ssize_t i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + Py_ssize_t i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +SWIGINTERN int +SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) { + int no_kwargs = 1; + if (kwargs) { + assert(PyDict_Check(kwargs)); + if (PyDict_Size(kwargs) > 0) { + PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name); + no_kwargs = 0; + } + } + return no_kwargs; +} + +/* A functor is a function object with one single object argument */ +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + +/* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + +typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; +} swig_globalvar; + +typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; +} swig_varlinkobject; + +SWIGINTERN PyObject * +swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif +} + +SWIGINTERN PyObject * +swig_varlink_str(PyObject *o) { + swig_varlinkobject *v = (swig_varlinkobject *) o; +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; +} + +SWIGINTERN void +swig_varlink_dealloc(PyObject *o) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } +} + +SWIGINTERN PyObject * +swig_varlink_getattr(PyObject *o, char *n) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; +} + +SWIGINTERN int +swig_varlink_setattr(PyObject *o, char *n, PyObject *p) { + swig_varlinkobject *v = (swig_varlinkobject *) o; + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; +} + +SWIGINTERN PyTypeObject* +swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; +#ifndef Py_LIMITED_API + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)swig_varlink_dealloc }, + { Py_tp_repr, (void *)swig_varlink_repr }, + { Py_tp_getattr, (void *)swig_varlink_getattr }, + { Py_tp_setattr, (void *)swig_varlink_setattr }, + { Py_tp_str, (void *)swig_varlink_str }, + { Py_tp_doc, (void *)varlink__doc__ }, + { 0, NULL } + }; + PyType_Spec spec = { + "swigvarlink", + sizeof(swig_varlinkobject), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif +} + +/* Create a variable linking object for use later */ +SWIGINTERN PyObject * +SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); +} + +SWIGINTERN void +SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; +} + + +static PyObject *Swig_Globals_global = NULL; + +SWIGINTERN PyObject * +SWIG_globals(void) { + if (Swig_Globals_global == NULL) { + Swig_Globals_global = SWIG_newvarlink(); + } + return Swig_Globals_global; +} + +#ifdef __cplusplus +} +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + int fail = data ? data->implicitconv : 0; + if (fail) + PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors."); + return fail; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + Py_INCREF(obj); + data->newargs = obj; + } else { + data->newraw = PyObject_GetAttrString(data->klass, "__new__"); + if (data->newraw) { + data->newargs = PyTuple_New(1); + if (data->newargs) { + Py_INCREF(obj); + PyTuple_SET_ITEM(data->newargs, 0, obj); + } else { + Py_DECREF(data->newraw); + Py_DECREF(data->klass); + free(data); + return 0; + } + } else { + Py_INCREF(obj); + data->newargs = obj; + } + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O); + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) +{ + Py_XDECREF(data->klass); + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); + free(data); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + + +#ifdef SWIGPYTHON_BUILTIN + +SWIGRUNTIME PyObject * +SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + + if (!sobj->dict) + sobj->dict = PyDict_New(); + + Py_XINCREF(sobj->dict); + return sobj->dict; +} + +#endif + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + PyObject *val = SwigPyObject_long(v); + if (val) { + PyObject *ofmt; + PyTuple_SET_ITEM(args, 0, val); + ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + } + Py_DECREF(args); + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_repr(SwigPyObject *v) +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (repr && v->next) { + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); + if (nrep) { +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } else { + Py_DecRef(repr); + repr = NULL; + } + } + return repr; +} + +/* We need a version taking two PyObject* parameters so it's a valid + * PyCFunction to use in swigobject_methods[]. */ +SWIGRUNTIME PyObject * +SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + return SwigPyObject_repr((SwigPyObject*)v); +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res = NULL; + if (!PyErr_Occurred()) { + if (op != Py_EQ && op != Py_NE) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + } + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { + PyTypeObject *target_tp = SwigPyObject_type(); + PyTypeObject *op_type = Py_TYPE(op); +#ifdef SWIGPYTHON_BUILTIN + if (PyType_IsSubtype(op_type, target_tp)) + return 1; + return (strcmp(op_type->tp_name, "SwigPyObject") == 0); +#else + if (op_type == target_tp) + return 1; +# ifdef Py_LIMITED_API + int cmp; + PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); + if (!tp_name) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject"); + Py_DECREF(tp_name); + return cmp == 0; +# else + return (strcmp(op_type->tp_name, "SwigPyObject") == 0); +# endif +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +static PyObject* Swig_Capsule_global = NULL; + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + + /* PyObject_CallFunction() has the potential to silently drop + the active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); + + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + if (tmp) { + res = SWIG_Python_CallFunctor(destroy, tmp); + } else { + res = 0; + } + Py_XDECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if (!res) + PyErr_WriteUnraisable(destroy); + + PyErr_Restore(type, value, traceback); + + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + Py_XDECREF(Swig_Capsule_global); + } + Py_XDECREF(next); +#ifdef SWIGPYTHON_BUILTIN + Py_XDECREF(sobj->dict); +#endif + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (!SwigPyObject_Check(next)) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + ((SwigPyObject *)next)->next = sobj->next; + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) { + return NULL; + } else { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { + if (PyObject_IsTrue(val)) { + Py_DECREF(SwigPyObject_acquire(v,args)); + } else { + Py_DECREF(SwigPyObject_disown(v,args)); + } + } + return obj; + } +} + +static PyMethodDef +swigobject_methods[] = { + {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"}, + {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"}, + {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"}, + {"append", SwigPyObject_append, METH_O, "appends another 'this' object"}, + {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"}, + {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"}, + {0, 0, 0, 0} +}; + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; +#ifndef Py_LIMITED_API + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ +#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#else + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpyobject_type) != 0) + return NULL; + } + return &swigpyobject_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)SwigPyObject_dealloc }, + { Py_tp_repr, (void *)SwigPyObject_repr }, + { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, + { Py_tp_doc, (void *)swigobject_doc }, + { Py_tp_richcompare, (void *)SwigPyObject_richcompare }, + { Py_tp_methods, (void *)swigobject_methods }, + { Py_nb_int, (void *)SwigPyObject_long }, + { 0, NULL } + }; + PyType_Spec spec = { + "SwigPyObject", + sizeof(SwigPyObject), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; +#ifdef SWIGPYTHON_BUILTIN + sobj->dict = 0; +#endif + if (own == SWIG_POINTER_OWN) { + /* Obtain a reference to the Python capsule wrapping the module information, so that the + * module information is correctly destroyed after all SWIG python objects have been freed + * by the GC (and corresponding destructors invoked) */ + Py_XINCREF(Swig_Capsule_global); + } + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + PyTypeObject* op_type = Py_TYPE(op); + if (op_type == SwigPyPacked_TypeOnce()) + return 1; +#ifdef Py_LIMITED_API + int cmp; + PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__"); + if (!tp_name) + return 0; + cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked"); + Py_DECREF(tp_name); + return cmp == 0; +#else + return (strcmp(op_type->tp_name, "SwigPyPacked") == 0); +#endif +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; +#ifndef Py_LIMITED_API + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ +#if PY_VERSION_HEX < 0x030800b4 + (printfunc)0, /*tp_print*/ +#else + (Py_ssize_t)0, /*tp_vectorcall_offset*/ +#endif + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, /* tp_watched */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpypacked_type) != 0) + return NULL; + } + return &swigpypacked_type; +#else + PyType_Slot slots[] = { + { Py_tp_dealloc, (void *)SwigPyPacked_dealloc }, + { Py_tp_repr, (void *)SwigPyPacked_repr }, + { Py_tp_str, (void *)SwigPyPacked_str }, + { Py_tp_getattro, (void *)PyObject_GenericGetAttr }, + { Py_tp_doc, (void *)swigpacked_doc }, + { 0, NULL } + }; + PyType_Spec spec = { + "SwigPyPacked", + sizeof(SwigPyPacked), + 0, + Py_TPFLAGS_DEFAULT, + slots + }; + return (PyTypeObject *)PyType_FromSpec(&spec); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +static PyObject *Swig_This_global = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (Swig_This_global == NULL) + Swig_This_global = SWIG_Python_str_FromChar("this"); + return Swig_This_global; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None && !implicit_conv) { + if (ptr) + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) { + res = SWIG_ERROR_RELEASE_NOT_OWNED; + } else { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + if (flags & SWIG_POINTER_CLEAR) { + sobj->ptr = 0; + } + res = SWIG_OK; + } + } else { + if (implicit_conv) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + swig_cast_info *tc; + + /* here we get the method pointer for callbacks */ +#ifndef Py_LIMITED_API + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); +#else + PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__"); + PyObject *bytes = NULL; + const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0; +#endif + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; +#ifdef Py_LIMITED_API + Py_XDECREF(bytes); + Py_XDECREF(pystr_doc); +#endif + if (!desc) + return SWIG_ERROR; + tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + return SWIG_OK; + } +} + +/* Convert a packed pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + Py_DECREF(inst); + inst = 0; + } + } +#else + if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { + Py_DECREF(inst); + inst = 0; + } +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *empty_args = PyTuple_New(0); + if (empty_args) { + PyObject *empty_kwargs = PyDict_New(); + if (empty_kwargs) { +#ifndef Py_LIMITED_API + newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new; +#else + newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new); +#endif + inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + Py_DECREF(empty_kwargs); + if (inst) { + if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { + Py_DECREF(inst); + inst = 0; + } else { + PyType_Modified(Py_TYPE(inst)); + } + } + } + Py_DECREF(empty_args); + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +} + +SWIGRUNTIME int +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + if (dict) { + return PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + return -1; + } + } +#endif + return PyObject_SetAttr(inst, SWIG_This(), swig_this); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1])); + } else { + if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0) + return NULL; + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { +#ifndef Py_LIMITED_API + allocfunc alloc = clientdata->pytype->tp_alloc; +#else + allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc); +#endif + PyObject *next_self = alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); +#ifdef SWIGPYTHON_BUILTIN + if (newobj) { + newobj->dict = 0; + } +#endif + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +static PyObject *Swig_TypeCache_global = NULL; + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + if (Swig_TypeCache_global == NULL) { + Swig_TypeCache_global = PyDict_New(); + } + return Swig_TypeCache_global; +} + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { +#ifdef SWIG_LINK_RUNTIME + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); + } +#else + void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + return (swig_module_info *) type_pointer; +} + + +static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */ + +SWIGRUNTIME void +SWIG_Python_DestroyModule(PyObject *obj) +{ + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); + swig_type_info **types = swig_module->types; + size_t i; + if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */ + return; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + ty->clientdata = 0; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + Swig_This_global = NULL; + Py_DECREF(SWIG_globals()); + Swig_Globals_global = NULL; + Py_DECREF(SWIG_Python_TypeCache()); + Swig_TypeCache_global = NULL; + Swig_Capsule_global = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) { + ++interpreter_counter; + Swig_Capsule_global = pointer; + } else { + Py_DECREF(pointer); + } + } else { + Py_XDECREF(pointer); + } +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { + obj = PyCapsule_New((void*) descriptor, NULL, NULL); + if (obj) { + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + PyObject *bytes = NULL; + const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes); + const char *errmesg = tmp ? tmp : "Invalid error message"; + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, errmesg); + } else { + PyErr_Format(type, "%s %s", errmesg, mesg); + } + Py_XDECREF(bytes); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { +#ifndef Py_LIMITED_API + /* tp_name is not accessible */ + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + PyObject *bytes = NULL; + const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(bytes); + Py_XDECREF(str); + return; + } +#endif + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res = -1; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) != 0) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + if (!encoded_name) + goto done; + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) + + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Python proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ +#define SWIG_DIRECTOR_PYTHON_HEADER_ + +#include +#include +#include +#include +#include + +#if defined(SWIG_PYTHON_THREADS) +/* __THREAD__ is the old macro to activate some thread support */ +# if !defined(__THREAD__) +# define __THREAD__ 1 +# endif +#endif + +#ifdef __THREAD__ +#ifndef Py_LIMITED_API +# include "pythread.h" +#else +# if defined(_WIN32) +# include +# else +# include +# endif +#endif +#endif + +/* + Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual + table', and avoid multiple GetAttr calls to retrieve the python + methods. +*/ + +#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE +#ifndef SWIG_PYTHON_DIRECTOR_VTABLE +#define SWIG_PYTHON_DIRECTOR_VTABLE +#endif +#endif + + + +/* + Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the + Undefined Exception Handler provided by swig. +*/ +#ifndef SWIG_DIRECTOR_NO_UEH +#ifndef SWIG_DIRECTOR_UEH +#define SWIG_DIRECTOR_UEH +#endif +#endif + + +/* + Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the + native C++ RTTI and dynamic_cast<>. But be aware that directors + could stop working when using this option. +*/ +#ifdef SWIG_DIRECTOR_NORTTI +/* + When we don't use the native C++ RTTI, we implement a minimal one + only for Directors. +*/ +# ifndef SWIG_DIRECTOR_RTDIR +# define SWIG_DIRECTOR_RTDIR + +namespace Swig { + class Director; + SWIGINTERN std::map& get_rtdir_map() { + static std::map rtdir_map; + return rtdir_map; + } + + SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { + get_rtdir_map()[vptr] = rtdir; + } + + SWIGINTERNINLINE Director *get_rtdir(void *vptr) { + std::map::const_iterator pos = get_rtdir_map().find(vptr); + Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; + return rtdir; + } +} +# endif /* SWIG_DIRECTOR_RTDIR */ + +# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) + +#else + +# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) + +#endif /* SWIG_DIRECTOR_NORTTI */ + +extern "C" { + struct swig_type_info; +} + +namespace Swig { + + /* memory handler */ + struct GCItem { + virtual ~GCItem() {} + + virtual int get_own() const { + return 0; + } + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem * operator->() const { + return _item; + } + + private: + GCItem *_item; + }; + + struct GCItem_Object : GCItem { + GCItem_Object(int own) : _own(own) { + } + + virtual ~GCItem_Object() { + } + + int get_own() const { + return _own; + } + + private: + int _own; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; + + template + struct GCArray_T : GCItem { + GCArray_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCArray_T() { + delete[] _ptr; + } + + private: + Type *_ptr; + }; + + /* base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + public: + DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (msg[0]) { + swig_msg += " "; + swig_msg += msg; + } + if (!PyErr_Occurred()) { + PyErr_SetString(error, swig_msg.c_str()); + } + SWIG_PYTHON_THREAD_END_BLOCK; + } + + virtual ~DirectorException() throw() { + } + + /* Deprecated, use what() instead */ + const char *getMessage() const { + return what(); + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorException(error, msg); + } + + static void raise(const char *msg) { + raise(PyExc_RuntimeError, msg); + } + }; + + /* type mismatch in the return value from a python method call */ + class DirectorTypeMismatchException : public DirectorException { + public: + DirectorTypeMismatchException(PyObject *error, const char *msg="") + : DirectorException(error, "SWIG director type mismatch", msg) { + } + + DirectorTypeMismatchException(const char *msg="") + : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorTypeMismatchException(error, msg); + } + + static void raise(const char *msg) { + throw DirectorTypeMismatchException(msg); + } + }; + + /* any python exception that occurs during a director method call */ + class DirectorMethodException : public DirectorException { + public: + DirectorMethodException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { + } + + static void raise(const char *msg) { + throw DirectorMethodException(msg); + } + }; + + /* attempt to call a pure virtual method via a director method */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { + } + + static void raise(const char *msg) { + throw DirectorPureVirtualException(msg); + } + }; + + +#ifdef __THREAD__ +#ifndef Py_LIMITED_API + class Mutex + { + public: + Mutex() { + mutex_ = PyThread_allocate_lock(); + } + + ~Mutex() { + PyThread_release_lock(mutex_); + } + + private: + void Lock() { + PyThread_acquire_lock(mutex_, WAIT_LOCK); + } + + void Unlock() { + PyThread_free_lock(mutex_); + } + + PyThread_type_lock mutex_; + + friend class Guard; + }; +#elif defined(_WIN32) + class Mutex : private CRITICAL_SECTION { + public: + Mutex() { + InitializeCriticalSection(this); + } + + ~Mutex() { + DeleteCriticalSection(this); + } + + private: + void Lock() { + EnterCriticalSection(this); + } + + void Unlock() { + LeaveCriticalSection(this); + } + + friend class Guard; + }; +#else + class Mutex { + public: + Mutex() { + pthread_mutex_init(&mutex_, NULL); + } + + ~Mutex() { + pthread_mutex_destroy(&mutex_); + } + + private: + void Lock() { + pthread_mutex_lock(&mutex_); + } + + void Unlock() { + pthread_mutex_unlock(&mutex_); + } + + friend class Guard; + + pthread_mutex_t mutex_; + }; +#endif + class Guard { + Mutex &mutex_; + + public: + Guard(Mutex & mutex) : mutex_(mutex) { + mutex_.Lock(); + } + + ~Guard() { + mutex_.Unlock(); + } + }; +# define SWIG_GUARD(mutex) Guard _guard(mutex) +#else +# define SWIG_GUARD(mutex) +#endif + + /* director base class */ + class Director { + private: + /* pointer to the wrapped python object */ + PyObject *swig_self; + /* flag indicating whether the object is owned by python or c++ */ + mutable bool swig_disown_flag; + + /* decrement the reference count of the wrapped python object */ + void swig_decref() const { + if (swig_disown_flag) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_DECREF(swig_self); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + public: + /* wrap a python object. */ + Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { + } + + /* discard our reference at destruction */ + virtual ~Director() { + swig_decref(); + } + + /* return a pointer to the wrapped python object */ + PyObject *swig_get_self() const { + return swig_self; + } + + /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); + } + } + + /* increase the reference count of the wrapped python object */ + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); + } + } + + /* methods to implement pseudo protected director members */ + virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { + return true; + } + + virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { + } + + /* ownership management */ + private: + typedef std::map swig_ownership_map; + mutable swig_ownership_map swig_owner; +#ifdef __THREAD__ + static Mutex swig_mutex_own; +#endif + + public: + template + void swig_acquire_ownership_array(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCArray_T(vptr); + } + } + + template + void swig_acquire_ownership(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_T(vptr); + } + } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_Object(own); + } + } + + int swig_release_ownership(void *vptr) const { + int own = 0; + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_ownership_map::iterator iter = swig_owner.find(vptr); + if (iter != swig_owner.end()) { + own = iter->second->get_own(); + swig_owner.erase(iter); + } + } + return own; + } + + template + static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { + SwigPyObject *sobj = (SwigPyObject *)pyobj; + sobj->own = 0; + Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); + if (d) + d->swig_disown(); + return PyWeakref_NewProxy(pyobj, NULL); + } + }; + +#ifdef __THREAD__ + Mutex Director::swig_mutex_own; +#endif +} + +#endif + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_ConstPtr swig_types[0] +#define SWIGTYPE_p_InputBuffer swig_types[1] +#define SWIGTYPE_p_OutputBuffer swig_types[2] +#define SWIGTYPE_p_PrevStdError swig_types[3] +#define SWIGTYPE_p_Ptr swig_types[4] +#define SWIGTYPE_p_UniqueConstPtr swig_types[5] +#define SWIGTYPE_p_UniquePtr swig_types[6] +#define SWIGTYPE_p_allocator_type swig_types[7] +#define SWIGTYPE_p_bcos__Error swig_types[8] +#define SWIGTYPE_p_bcos__boostssl__EncodedMsg swig_types[9] +#define SWIGTYPE_p_bcos__boostssl__MessageFace__Ptr swig_types[10] +#define SWIGTYPE_p_bcos__bytesConstRef swig_types[11] +#define SWIGTYPE_p_char swig_types[12] +#define SWIGTYPE_p_difference_type swig_types[13] +#define SWIGTYPE_p_int swig_types[14] +#define SWIGTYPE_p_long_long swig_types[15] +#define SWIGTYPE_p_p_PyObject swig_types[16] +#define SWIGTYPE_p_ppc__front__ErrorCallback swig_types[17] +#define SWIGTYPE_p_ppc__front__FrontConfig swig_types[18] +#define SWIGTYPE_p_ppc__front__FrontConfigBuilder swig_types[19] +#define SWIGTYPE_p_ppc__front__GetPeersInfoHandler swig_types[20] +#define SWIGTYPE_p_ppc__front__IFront swig_types[21] +#define SWIGTYPE_p_ppc__front__IFrontBuilder swig_types[22] +#define SWIGTYPE_p_ppc__front__IFrontClient swig_types[23] +#define SWIGTYPE_p_ppc__front__IMessageHandler swig_types[24] +#define SWIGTYPE_p_ppc__front__MessageDispatcherHandler swig_types[25] +#define SWIGTYPE_p_ppc__front__SendResponseHandler swig_types[26] +#define SWIGTYPE_p_ppc__gateway__IGateway__Ptr swig_types[27] +#define SWIGTYPE_p_ppc__protocol__EndPoint swig_types[28] +#define SWIGTYPE_p_ppc__protocol__GrpcConfig swig_types[29] +#define SWIGTYPE_p_ppc__protocol__GrpcServerConfig swig_types[30] +#define SWIGTYPE_p_ppc__protocol__INodeInfo__Ptr swig_types[31] +#define SWIGTYPE_p_ppc__protocol__Message swig_types[32] +#define SWIGTYPE_p_ppc__protocol__MessageBuilder swig_types[33] +#define SWIGTYPE_p_ppc__protocol__MessageHeader swig_types[34] +#define SWIGTYPE_p_ppc__protocol__MessageHeaderBuilder swig_types[35] +#define SWIGTYPE_p_ppc__protocol__MessageOptionalHeader swig_types[36] +#define SWIGTYPE_p_ppc__protocol__MessageOptionalHeaderBuilder swig_types[37] +#define SWIGTYPE_p_ppc__protocol__MessagePayload swig_types[38] +#define SWIGTYPE_p_ppc__protocol__MessagePayloadBuilder swig_types[39] +#define SWIGTYPE_p_ppc__protocol__RouteType swig_types[40] +#define SWIGTYPE_p_ppc__sdk__Transport swig_types[41] +#define SWIGTYPE_p_ppc__sdk__TransportBuilder swig_types[42] +#define SWIGTYPE_p_short swig_types[43] +#define SWIGTYPE_p_signed_char swig_types[44] +#define SWIGTYPE_p_size_type swig_types[45] +#define SWIGTYPE_p_std__allocatorT_signed_char_t swig_types[46] +#define SWIGTYPE_p_std__allocatorT_unsigned_char_t swig_types[47] +#define SWIGTYPE_p_std__exception swig_types[48] +#define SWIGTYPE_p_std__functionT_void_fF_t swig_types[49] +#define SWIGTYPE_p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t swig_types[50] +#define SWIGTYPE_p_std__functionT_void_fstd__shared_ptrT_bcos__Error_t_std__shared_ptrT_ppc__protocol__Message_t_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_tF_t swig_types[51] +#define SWIGTYPE_p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t swig_types[52] +#define SWIGTYPE_p_std__functionT_void_fstd__shared_ptrT_ppc__protocol__Message_tF_t swig_types[53] +#define SWIGTYPE_p_std__invalid_argument swig_types[54] +#define SWIGTYPE_p_std__shared_ptrT_bcos__Error_t swig_types[55] +#define SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t swig_types[56] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t swig_types[57] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t swig_types[58] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t swig_types[59] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t swig_types[60] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t swig_types[61] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t swig_types[62] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t swig_types[63] +#define SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t swig_types[64] +#define SWIGTYPE_p_std__shared_ptrT_ppc__gateway__IGateway_t swig_types[65] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t swig_types[66] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t swig_types[67] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t swig_types[68] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t swig_types[69] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t swig_types[70] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t swig_types[71] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t swig_types[72] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t swig_types[73] +#define SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t swig_types[74] +#define SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t swig_types[75] +#define SWIGTYPE_p_std__string swig_types[76] +#define SWIGTYPE_p_std__string_view swig_types[77] +#define SWIGTYPE_p_std__vectorT_int8_t_t swig_types[78] +#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[79] +#define SWIGTYPE_p_std__vectorT_uint8_t_t swig_types[80] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[81] +#define SWIGTYPE_p_unsigned_char swig_types[82] +#define SWIGTYPE_p_unsigned_int swig_types[83] +#define SWIGTYPE_p_unsigned_long_long swig_types[84] +#define SWIGTYPE_p_unsigned_short swig_types[85] +#define SWIGTYPE_p_value_type swig_types[86] +static swig_type_info *swig_types[88]; +static swig_module_info swig_module = {swig_types, 87, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#ifdef SWIG_TypeQuery +# undef SWIG_TypeQuery +#endif +#define SWIG_TypeQuery SWIG_Python_TypeQuery + +/*----------------------------------------------- + @(target):= _wedpr_python_transport.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__wedpr_python_transport + +#else +# define SWIG_init init_wedpr_python_transport + +#endif +#define SWIG_name "_wedpr_python_transport" + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include // Use the C99 official header + + +#include + +#if PY_VERSION_HEX >= 0x03020000 +# define SWIGPY_SLICEOBJECT PyObject +#else +# define SWIGPY_SLICEOBJECT PySliceObject +#endif + + +#include +#include + + +#if defined(__GNUC__) +# if __GNUC__ == 2 && __GNUC_MINOR <= 96 +# define SWIG_STD_NOMODERN_STL +# endif +#endif + + +#include + + +#include + + +namespace swig { + struct stop_iteration { + }; + + struct SwigPyIterator { + private: + SwigPtr_PyObject _seq; + + protected: + SwigPyIterator(PyObject *seq) : _seq(seq) + { + } + + public: + virtual ~SwigPyIterator() {} + + // Access iterator method, required by Python + virtual PyObject *value() const = 0; + + // Forward iterator method, required by Python + virtual SwigPyIterator *incr(size_t n = 1) = 0; + + // Backward iterator method, very common in C++, but not required in Python + virtual SwigPyIterator *decr(size_t /*n*/ = 1) + { + throw stop_iteration(); + } + + // Random access iterator methods, but not required in Python + virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const + { + throw std::invalid_argument("operation not supported"); + } + + virtual bool equal (const SwigPyIterator &/*x*/) const + { + throw std::invalid_argument("operation not supported"); + } + + // C++ common/needed methods + virtual SwigPyIterator *copy() const = 0; + + PyObject *next() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads + PyObject *obj = value(); + incr(); + SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads + return obj; + } + + /* Make an alias for Python 3.x */ + PyObject *__next__() + { + return next(); + } + + PyObject *previous() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads + decr(); + PyObject *obj = value(); + SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads + return obj; + } + + SwigPyIterator *advance(ptrdiff_t n) + { + return (n > 0) ? incr(n) : decr(-n); + } + + bool operator == (const SwigPyIterator& x) const + { + return equal(x); + } + + bool operator != (const SwigPyIterator& x) const + { + return ! operator==(x); + } + + SwigPyIterator& operator += (ptrdiff_t n) + { + return *advance(n); + } + + SwigPyIterator& operator -= (ptrdiff_t n) + { + return *advance(-n); + } + + SwigPyIterator* operator + (ptrdiff_t n) const + { + return copy()->advance(n); + } + + SwigPyIterator* operator - (ptrdiff_t n) const + { + return copy()->advance(-n); + } + + ptrdiff_t operator - (const SwigPyIterator& x) const + { + return x.distance(*this); + } + + static swig_type_info* descriptor() { + static int init = 0; + static swig_type_info* desc = 0; + if (!init) { + desc = SWIG_TypeQuery("swig::SwigPyIterator *"); + init = 1; + } + return desc; + } + }; + +#if defined(SWIGPYTHON_BUILTIN) + inline PyObject* make_output_iterator_builtin (PyObject *pyself) + { + Py_INCREF(pyself); + return pyself; + } +#endif +} + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx, cx, rd; + errno = 0; + fx = floor(x); + cx = ceil(x); + rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + long v = PyInt_AsLong(obj); + if (v >= 0) { + if (val) *val = v; + return SWIG_OK; + } else { + return SWIG_OverflowError; + } + } else +#endif + if (PyLong_Check(obj)) { + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + // Largest double not larger than ULONG_MAX (not portably calculated easily) + // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long) + // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0)) + const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) { + if (val) *val = (unsigned long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE) +# define SWIG_LONG_LONG_AVAILABLE +#endif + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERN int +SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val) +{ + int res = SWIG_TypeError; + if (PyLong_Check(obj)) { + unsigned long long v = PyLong_AsUnsignedLongLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + res = SWIG_OverflowError; + } + } else { + unsigned long v; + res = SWIG_AsVal_unsigned_SS_long (obj,&v); + if (SWIG_IsOK(res)) { + if (val) *val = v; + return res; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + const double mant_max = 1LL << DBL_MANT_DIG; + double d; + res = SWIG_AsVal_double (obj,&d); + if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max)) + return SWIG_OverflowError; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) { + if (val) *val = (unsigned long long)(d); + return SWIG_AddCast(res); + } + res = SWIG_TypeError; + } +#endif + return res; +} +#endif + + +SWIGINTERNINLINE int +SWIG_AsVal_size_t (PyObject * obj, size_t *val) +{ + int res = SWIG_TypeError; +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(size_t) <= sizeof(unsigned long)) { +#endif + unsigned long v; + res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else if (sizeof(size_t) <= sizeof(unsigned long long)) { + unsigned long long v; + res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v); + } +#endif + return res; +} + + + #define SWIG_From_long PyInt_FromLong + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERNINLINE PyObject* +SWIG_From_long_SS_long (long long value) +{ + return ((value < LONG_MIN) || (value > LONG_MAX)) ? + PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value)); +} +#endif + + +SWIGINTERNINLINE PyObject * +SWIG_From_ptrdiff_t (ptrdiff_t value) +{ +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(ptrdiff_t) <= sizeof(long)) { +#endif + return SWIG_From_long (static_cast< long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else { + /* assume sizeof(ptrdiff_t) <= sizeof(long long) */ + return SWIG_From_long_SS_long (static_cast< long long >(value)); + } +#endif +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + // Largest double not larger than LONG_MAX (not portably calculated easily) + // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long) + // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0)) + const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX; + // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERN int +SWIG_AsVal_long_SS_long (PyObject *obj, long long *val) +{ + int res = SWIG_TypeError; + if (PyLong_Check(obj)) { + long long v = PyLong_AsLongLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + res = SWIG_OverflowError; + } + } else { + long v; + res = SWIG_AsVal_long (obj,&v); + if (SWIG_IsOK(res)) { + if (val) *val = v; + return res; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + const double mant_max = 1LL << DBL_MANT_DIG; + const double mant_min = -mant_max; + double d; + res = SWIG_AsVal_double (obj,&d); + if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max)) + return SWIG_OverflowError; + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) { + if (val) *val = (long long)(d); + return SWIG_AddCast(res); + } + res = SWIG_TypeError; + } +#endif + return res; +} +#endif + + +SWIGINTERNINLINE int +SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val) +{ + int res = SWIG_TypeError; +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(ptrdiff_t) <= sizeof(long)) { +#endif + long v; + res = SWIG_AsVal_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else if (sizeof(ptrdiff_t) <= sizeof(long long)) { + long long v; + res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v); + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +#define SWIG_FILE_WITH_INIT +#include +#include +#include +#include +#include +#include "wedpr-transport/sdk/src/TransportBuilder.h" +#include "wedpr-transport/sdk/src/Transport.h" +#include "ppc-framework/libwrapper/Buffer.h" +#include "ppc-framework/front/IFront.h" +#include "ppc-framework/protocol/RouteType.h" +#include "ppc-framework/front/FrontConfig.h" +#include "ppc-framework/protocol/GrpcConfig.h" +#include +#include "ppc-framework/protocol/EndPoint.h" +#include "ppc-framework/protocol/Message.h" +#include "ppc-framework/protocol/MessagePayload.h" + + +namespace swig { + template + struct noconst_traits { + typedef Type noconst_type; + }; + + template + struct noconst_traits { + typedef Type noconst_type; + }; + + /* + type categories + */ + struct pointer_category { }; + struct value_category { }; + + /* + General traits that provides type_name and type_info + */ + template struct traits { }; + + template + inline const char* type_name() { + return traits::noconst_type >::type_name(); + } + + template struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; + } + }; + + /* + Partial specialization for pointers (traits_info) + */ + template struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; + } + }; + + template + inline swig_type_info *type_info() { + return traits_info::type_info(); + } + + /* + Partial specialization for pointers (traits) + */ + template struct traits { + typedef pointer_category category; + static std::string make_ptr_name(const char* name) { + std::string ptrname = name; + ptrname += " *"; + return ptrname; + } + static const char* type_name() { + static std::string name = make_ptr_name(swig::type_name()); + return name.c_str(); + } + }; + + template + struct traits_as { }; + + template + struct traits_check { }; + +} + + +namespace swig { + /* + Traits that provides the from method + */ + template struct traits_from_ptr { + static PyObject *from(Type *val, int owner = 0) { + return SWIG_InternalNewPointerObj(val, type_info(), owner); + } + }; + + template struct traits_from { + static PyObject *from(const Type& val) { + return traits_from_ptr::from(new Type(val), 1); + } + }; + + template struct traits_from { + static PyObject *from(Type* val) { + return traits_from_ptr::from(val, 0); + } + }; + + template struct traits_from { + static PyObject *from(const Type* val) { + return traits_from_ptr::from(const_cast(val), 0); + } + }; + + + template + inline PyObject *from(const Type& val) { + return traits_from::from(val); + } + + template + inline PyObject *from_ptr(Type* val, int owner) { + return traits_from_ptr::from(val, owner); + } + + /* + Traits that provides the asval/as/check method + */ + template + struct traits_asptr { + static int asptr(PyObject *obj, Type **val) { + int res = SWIG_ERROR; + swig_type_info *descriptor = type_info(); + if (val) { + Type *p = 0; + int newmem = 0; + res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR; + if (SWIG_IsOK(res)) { + if (newmem & SWIG_CAST_NEW_MEMORY) { + res |= SWIG_NEWOBJMASK; + } + *val = p; + } + } else { + res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR; + } + return res; + } + }; + + template + inline int asptr(PyObject *obj, Type **vptr) { + return traits_asptr::asptr(obj, vptr); + } + + template + struct traits_asval { + static int asval(PyObject *obj, Type *val) { + if (val) { + Type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (!SWIG_IsOK(res)) return res; + if (p) { + typedef typename noconst_traits::noconst_type noconst_type; + *(const_cast(val)) = *p; + if (SWIG_IsNewObj(res)){ + delete p; + res = SWIG_DelNewMask(res); + } + return res; + } else { + return SWIG_ERROR; + } + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template struct traits_asval { + static int asval(PyObject *obj, Type **val) { + if (val) { + typedef typename noconst_traits::noconst_type noconst_type; + noconst_type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) { + *(const_cast(val)) = p; + } + return res; + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template + inline int asval(PyObject *obj, Type *val) { + return traits_asval::asval(obj, val); + } + + template + struct traits_as { + static Type as(PyObject *obj) { + Type v; + int res = asval(obj, &v); + if (!obj || !SWIG_IsOK(res)) { + if (!PyErr_Occurred()) { + ::SWIG_Error(SWIG_TypeError, swig::type_name()); + } + throw std::invalid_argument("bad type"); + } + return v; + } + }; + + template + struct traits_as { + static Type as(PyObject *obj) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res) && v) { + if (SWIG_IsNewObj(res)) { + Type r(*v); + delete v; + return r; + } else { + return *v; + } + } else { + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + throw std::invalid_argument("bad type"); + } + } + }; + + template + struct traits_as { + static Type* as(PyObject *obj) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res)) { + return v; + } else { + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + throw std::invalid_argument("bad type"); + } + } + }; + + template + inline Type as(PyObject *obj) { + return traits_as::category>::as(obj); + } + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + inline bool check(PyObject *obj) { + return traits_check::category>::check(obj); + } +} + + +#if defined(__SUNPRO_CC) && defined(_RWSTD_VER) +# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL) +# define SWIG_STD_NOITERATOR_TRAITS_STL +# endif +#endif + +#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL) +#include +#else +namespace std { + template + struct iterator_traits { + typedef ptrdiff_t difference_type; + typedef typename Iterator::value_type value_type; + }; + + template + struct iterator_traits<__reverse_bi_iterator > { + typedef Distance difference_type; + typedef T value_type; + }; + + template + struct iterator_traits { + typedef T value_type; + typedef ptrdiff_t difference_type; + }; + + template + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) { + ++__first; ++__n; + } + return __n; + } +} +#endif + + +namespace swig { + template + class SwigPyIterator_T : public SwigPyIterator + { + public: + typedef OutIterator out_iterator; + typedef typename std::iterator_traits::value_type value_type; + typedef SwigPyIterator_T self_type; + + SwigPyIterator_T(out_iterator curr, PyObject *seq) + : SwigPyIterator(seq), current(curr) + { + } + + const out_iterator& get_current() const + { + return current; + } + + + bool equal (const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return (current == iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + ptrdiff_t distance(const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return std::distance(current, iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + protected: + out_iterator current; + }; + + template + struct from_oper + { + typedef const ValueType& argument_type; + typedef PyObject *result_type; + result_type operator()(argument_type v) const + { + return swig::from(v); + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyForwardIteratorOpen_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyForwardIteratorOpen_T self_type; + + SwigPyForwardIteratorOpen_T(out_iterator curr, PyObject *seq) + : SwigPyIterator_T(curr, seq) + { + } + + PyObject *value() const { + return from(static_cast(*(base::current))); + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + ++base::current; + } + return this; + } + + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorOpen_T : public SwigPyForwardIteratorOpen_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyIteratorOpen_T self_type; + + SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq) + : SwigPyForwardIteratorOpen_T(curr, seq) + { + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + --base::current; + } + return this; + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyForwardIteratorClosed_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyForwardIteratorClosed_T self_type; + + SwigPyForwardIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) + : SwigPyIterator_T(curr, seq), begin(first), end(last) + { + } + + PyObject *value() const { + if (base::current == end) { + throw stop_iteration(); + } else { + return from(static_cast(*(base::current))); + } + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + if (base::current == end) { + throw stop_iteration(); + } else { + ++base::current; + } + } + return this; + } + + protected: + out_iterator begin; + out_iterator end; + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorClosed_T : public SwigPyForwardIteratorClosed_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyForwardIteratorClosed_T base0; + typedef SwigPyIteratorClosed_T self_type; + + SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) + : SwigPyForwardIteratorClosed_T(curr, first, last, seq) + { + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + if (base::current == base0::begin) { + throw stop_iteration(); + } else { + --base::current; + } + } + return this; + } + }; + + + template + inline SwigPyIterator* + make_output_forward_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) + { + return new SwigPyForwardIteratorClosed_T(current, begin, end, seq); + } + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) + { + return new SwigPyIteratorClosed_T(current, begin, end, seq); + } + + template + inline SwigPyIterator* + make_output_forward_iterator(const OutIter& current, PyObject *seq = 0) + { + return new SwigPyForwardIteratorOpen_T(current, seq); + } + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, PyObject *seq = 0) + { + return new SwigPyIteratorOpen_T(current, seq); + } + +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > UCHAR_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< unsigned char >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long (unsigned long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_unsigned_SS_char (unsigned char value) +{ + return SWIG_From_unsigned_SS_long (value); +} + + +namespace swig { + template <> struct traits< unsigned char > { + typedef value_category category; + static const char* type_name() { return"unsigned char"; } + }; + template <> struct traits_asval< unsigned char > { + typedef unsigned char value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_unsigned_SS_char (obj, val); + } + }; + template <> struct traits_from< unsigned char > { + typedef unsigned char value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_unsigned_SS_char (val); + } + }; +} + + +#include + +namespace std { + template <> + struct less + { + bool + operator()(PyObject * v, PyObject *w) const + { + bool res; + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false; + /* This may fall into a case of inconsistent + eg. ObjA > ObjX > ObjB + but ObjA < ObjB + */ + if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) ) + { + /* Objects can't be compared, this mostly occurred in Python 3.0 */ + /* Compare their ptr directly for a workaround */ + res = (v < w); + PyErr_Clear(); + } + SWIG_PYTHON_THREAD_END_BLOCK; + return res; + } + }; + + template <> + struct less + { + bool + operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const + { + return std::less()(v, w); + } + }; + + template <> + struct less + { + bool + operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const + { + return std::less()(v, w); + } + }; + +} + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return "PyObject *"; } + }; + + template <> struct traits_asval { + typedef PyObject * value_type; + static int asval(PyObject *obj, value_type *val) { + if (val) *val = obj; + return SWIG_OK; + } + }; + + template <> + struct traits_check { + static bool check(PyObject *) { + return true; + } + }; + + template <> struct traits_from { + typedef PyObject * value_type; + static PyObject *from(const value_type& val) { + Py_XINCREF(val); + return val; + } + }; + +} + +namespace swig { + template + inline size_t + check_index(Difference i, size_t size, bool insert = false) { + if ( i < 0 ) { + if ((size_t) (-i) <= size) + return (size_t) (i + size); + } else if ( (size_t) i < size ) { + return (size_t) i; + } else if (insert && ((size_t) i == size)) { + return size; + } + throw std::out_of_range("index out of range"); + } + + template + void + slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) { + if (step == 0) { + throw std::invalid_argument("slice step cannot be zero"); + } else if (step > 0) { + // Required range: 0 <= i < size, 0 <= j < size, i <= j + if (i < 0) { + ii = 0; + } else if (i < (Difference)size) { + ii = i; + } else if (insert && (i >= (Difference)size)) { + ii = (Difference)size; + } + if (j < 0) { + jj = 0; + } else { + jj = (j < (Difference)size) ? j : (Difference)size; + } + if (jj < ii) + jj = ii; + } else { + // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j + if (i < -1) { + ii = -1; + } else if (i < (Difference) size) { + ii = i; + } else if (i >= (Difference)(size-1)) { + ii = (Difference)(size-1); + } + if (j < -1) { + jj = -1; + } else { + jj = (j < (Difference)size ) ? j : (Difference)(size-1); + } + if (ii < jj) + ii = jj; + } + } + + template + inline typename Sequence::iterator + getpos(Sequence* self, Difference i) { + typename Sequence::iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline typename Sequence::const_iterator + cgetpos(const Sequence* self, Difference i) { + typename Sequence::const_iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline void + erase(Sequence* seq, const typename Sequence::iterator& position) { + seq->erase(position); + } + + template + struct traits_reserve { + static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) { + // This should be specialized for types that support reserve + } + }; + + template + inline Sequence* + getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj); + + if (step > 0) { + typename Sequence::const_iterator sb = self->begin(); + typename Sequence::const_iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + if (step == 1) { + return new Sequence(sb, se); + } else { + Sequence *sequence = new Sequence(); + swig::traits_reserve::reserve(*sequence, (jj - ii + step - 1) / step); + typename Sequence::const_iterator it = sb; + while (it!=se) { + sequence->push_back(*it); + for (Py_ssize_t c=0; c::reserve(*sequence, (ii - jj - step - 1) / -step); + typename Sequence::const_reverse_iterator sb = self->rbegin(); + typename Sequence::const_reverse_iterator se = self->rbegin(); + std::advance(sb,size-ii-1); + std::advance(se,size-jj-1); + typename Sequence::const_reverse_iterator it = sb; + while (it!=se) { + sequence->push_back(*it); + for (Py_ssize_t c=0; c<-step && it!=se; ++c) + it++; + } + return sequence; + } + } + + template + inline void + setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj, true); + if (step > 0) { + if (step == 1) { + size_t ssize = jj - ii; + if (ssize <= is.size()) { + // expanding/staying the same size + swig::traits_reserve::reserve(*self, self->size() - ssize + is.size()); + typename Sequence::iterator sb = self->begin(); + typename InputSeq::const_iterator isit = is.begin(); + std::advance(sb,ii); + std::advance(isit, jj - ii); + self->insert(std::copy(is.begin(), isit, sb), isit, is.end()); + } else { + // shrinking + typename Sequence::iterator sb = self->begin(); + typename Sequence::iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + self->erase(sb,se); + sb = self->begin(); + std::advance(sb,ii); + self->insert(sb, is.begin(), is.end()); + } + } else { + size_t replacecount = (jj - ii + step - 1) / step; + if (is.size() != replacecount) { + char msg[1024]; + PyOS_snprintf(msg, sizeof(msg), "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); + throw std::invalid_argument(msg); + } + typename Sequence::const_iterator isit = is.begin(); + typename Sequence::iterator it = self->begin(); + std::advance(it,ii); + for (size_t rc=0; rcend(); ++rc) { + *it++ = *isit++; + for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) + it++; + } + } + } else { + size_t replacecount = (ii - jj - step - 1) / -step; + if (is.size() != replacecount) { + char msg[1024]; + PyOS_snprintf(msg, sizeof(msg), "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount); + throw std::invalid_argument(msg); + } + typename Sequence::const_iterator isit = is.begin(); + typename Sequence::reverse_iterator it = self->rbegin(); + std::advance(it,size-ii-1); + for (size_t rc=0; rcrend(); ++rc) { + *it++ = *isit++; + for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) + it++; + } + } + } + + template + inline void + delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) { + typename Sequence::size_type size = self->size(); + Difference ii = 0; + Difference jj = 0; + swig::slice_adjust(i, j, step, size, ii, jj, true); + if (step > 0) { + typename Sequence::iterator sb = self->begin(); + std::advance(sb,ii); + if (step == 1) { + typename Sequence::iterator se = self->begin(); + std::advance(se,jj); + self->erase(sb,se); + } else { + typename Sequence::iterator it = sb; + size_t delcount = (jj - ii + step - 1) / step; + while (delcount) { + it = self->erase(it); + for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c) + it++; + delcount--; + } + } + } else { + typename Sequence::reverse_iterator sb = self->rbegin(); + std::advance(sb,size-ii-1); + typename Sequence::reverse_iterator it = sb; + size_t delcount = (ii - jj - step - 1) / -step; + while (delcount) { + it = typename Sequence::reverse_iterator(self->erase((++it).base())); + for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c) + it++; + delcount--; + } + } + } +} + + +namespace swig { + template + struct IteratorProtocol { + static void assign(PyObject *obj, Seq *seq) { + SwigVar_PyObject iter = PyObject_GetIter(obj); + if (iter) { + SwigVar_PyObject item = PyIter_Next(iter); + while (item) { + seq->insert(seq->end(), swig::as(item)); + item = PyIter_Next(iter); + } + } + } + + static bool check(PyObject *obj) { + bool ret = false; + SwigVar_PyObject iter = PyObject_GetIter(obj); + if (iter) { + SwigVar_PyObject item = PyIter_Next(iter); + ret = true; + while (item) { + ret = swig::check(item); + item = ret ? PyIter_Next(iter) : 0; + } + } + return ret; + } + }; + + template + struct traits_asptr_stdseq { + typedef Seq sequence; + typedef T value_type; + + static bool is_iterable(PyObject *obj) { + SwigVar_PyObject iter = PyObject_GetIter(obj); + PyErr_Clear(); + return iter != 0; + } + + static int asptr(PyObject *obj, sequence **seq) { + int ret = SWIG_ERROR; + if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) { + sequence *p; + swig_type_info *descriptor = swig::type_info(); + if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) { + if (seq) *seq = p; + return SWIG_OLDOBJ; + } + } else if (is_iterable(obj)) { + try { + if (seq) { + *seq = new sequence(); + IteratorProtocol::assign(obj, *seq); + if (!PyErr_Occurred()) + return SWIG_NEWOBJ; + } else { + return IteratorProtocol::check(obj) ? SWIG_OK : SWIG_ERROR; + } + } catch (std::exception& e) { + if (seq && !PyErr_Occurred()) + PyErr_SetString(PyExc_TypeError, e.what()); + } + if (seq) + delete *seq; + return SWIG_ERROR; + } + return ret; + } + }; + + template + struct traits_from_stdseq { + typedef Seq sequence; + typedef T value_type; + typedef typename Seq::size_type size_type; + typedef typename sequence::const_iterator const_iterator; + + static PyObject *from(const sequence& seq) { +#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS + swig_type_info *desc = swig::type_info(); + if (desc && desc->clientdata) { + return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); + } +#endif + size_type size = seq.size(); + if (size <= (size_type)INT_MAX) { + PyObject *obj = PyTuple_New((Py_ssize_t)size); + Py_ssize_t i = 0; + for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) { + PyTuple_SetItem(obj,i,swig::from(*it)); + } + return obj; + } else { + PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python"); + return NULL; + } + } + }; +} + + + namespace swig { + template + struct traits_reserve > { + static void reserve(std::vector &seq, typename std::vector::size_type n) { + seq.reserve(n); + } + }; + + template + struct traits_asptr > { + static int asptr(PyObject *obj, std::vector **vec) { + return traits_asptr_stdseq >::asptr(obj, vec); + } + }; + + template + struct traits_from > { + static PyObject *from(const std::vector& vec) { + return traits_from_stdseq >::from(vec); + } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "unsigned char" "," "std::allocator< unsigned char >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_uint8_t_Sg__iterator(std::vector< uint8_t > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_uint8_t_Sg____nonzero__(std::vector< uint8_t > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_uint8_t_Sg____bool__(std::vector< uint8_t > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< unsigned char >::size_type std_vector_Sl_uint8_t_Sg____len__(std::vector< uint8_t > const *self){ + return self->size(); + } + +#ifdef SWIG_LONG_LONG_AVAILABLE +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long_SS_long (unsigned long long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value)); +} +#endif + + +SWIGINTERNINLINE PyObject * +SWIG_From_size_t (size_t value) +{ +#ifdef SWIG_LONG_LONG_AVAILABLE + if (sizeof(size_t) <= sizeof(unsigned long)) { +#endif + return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); +#ifdef SWIG_LONG_LONG_AVAILABLE + } else { + /* assume sizeof(size_t) <= sizeof(unsigned long long) */ + return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value)); + } +#endif +} + +SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *std_vector_Sl_uint8_t_Sg____getslice__(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg____setslice____SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< unsigned char,std::allocator< unsigned char > >()); + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg____setslice____SWIG_1(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j,std::vector< unsigned char,std::allocator< unsigned char > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg____delslice__(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg____delitem____SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *std_vector_Sl_uint8_t_Sg____getitem____SWIG_0(std::vector< uint8_t > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i; + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg____setitem____SWIG_0(std::vector< uint8_t > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned char,std::allocator< unsigned char > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i; + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg____setitem____SWIG_1(std::vector< uint8_t > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i; + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg____delitem____SWIG_1(std::vector< uint8_t > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type id = i; + std::vector< unsigned char,std::allocator< unsigned char > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< unsigned char >::value_type const &std_vector_Sl_uint8_t_Sg____getitem____SWIG_1(std::vector< uint8_t > const *self,std::vector< unsigned char >::difference_type i){ + return *(swig::cgetpos(self, i)); + } + +namespace swig { + static PyObject* container_owner_attribute() { + static PyObject* attr = SWIG_Python_str_FromChar("__swig_container"); + return attr; + } + + template + struct container_owner { + // By default, do not add the back-reference (for value types) + // Specialization below will check the reference for pointer types. + static bool back_reference(PyObject* /*child*/, PyObject* /*owner*/) { + return false; + } + }; + + template <> + struct container_owner { + /* + * Call to add a back-reference to the owning object when returning a + * reference from a container. Will only set the reference if child + * is a SWIG wrapper object that does not own the pointer. + * + * returns whether the reference was set or not + */ + static bool back_reference(PyObject* child, PyObject* owner) { + SwigPyObject* swigThis = SWIG_Python_GetSwigThis(child); + if (swigThis && (swigThis->own & SWIG_POINTER_OWN) != SWIG_POINTER_OWN) { + return PyObject_SetAttr(child, container_owner_attribute(), owner) != -1; + } + return false; + } + }; +} + +SWIGINTERN void std_vector_Sl_uint8_t_Sg____setitem____SWIG_2(std::vector< uint8_t > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< unsigned char >::value_type std_vector_Sl_uint8_t_Sg__pop(std::vector< uint8_t > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< unsigned char,std::allocator< unsigned char > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_uint8_t_Sg__append(std::vector< uint8_t > *self,std::vector< unsigned char >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< unsigned char >::iterator std_vector_Sl_uint8_t_Sg__erase__SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< unsigned char >::iterator std_vector_Sl_uint8_t_Sg__erase__SWIG_1(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator first,std::vector< unsigned char >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< unsigned char >::iterator std_vector_Sl_uint8_t_Sg__insert__SWIG_0(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator pos,std::vector< unsigned char >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_uint8_t_Sg__insert__SWIG_1(std::vector< uint8_t > *self,std::vector< unsigned char >::iterator pos,std::vector< unsigned char >::size_type n,std::vector< unsigned char >::value_type const &x){ self->insert(pos, n, x); } + +SWIGINTERN int +SWIG_AsVal_signed_SS_char (PyObject * obj, signed char *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < SCHAR_MIN || v > SCHAR_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< signed char >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_signed_SS_char (signed char value) +{ + return SWIG_From_long (value); +} + + +namespace swig { + template <> struct traits< signed char > { + typedef value_category category; + static const char* type_name() { return"signed char"; } + }; + template <> struct traits_asval< signed char > { + typedef signed char value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_signed_SS_char (obj, val); + } + }; + template <> struct traits_from< signed char > { + typedef signed char value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_signed_SS_char (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "signed char" "," "std::allocator< signed char >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int8_t_Sg__iterator(std::vector< int8_t > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_int8_t_Sg____nonzero__(std::vector< int8_t > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_int8_t_Sg____bool__(std::vector< int8_t > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< signed char >::size_type std_vector_Sl_int8_t_Sg____len__(std::vector< int8_t > const *self){ + return self->size(); + } +SWIGINTERN std::vector< signed char,std::allocator< signed char > > *std_vector_Sl_int8_t_Sg____getslice__(std::vector< int8_t > *self,std::vector< signed char >::difference_type i,std::vector< signed char >::difference_type j){ + return swig::getslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____setslice____SWIG_0(std::vector< int8_t > *self,std::vector< signed char >::difference_type i,std::vector< signed char >::difference_type j){ + swig::setslice(self, i, j, 1, std::vector< signed char,std::allocator< signed char > >()); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____setslice____SWIG_1(std::vector< int8_t > *self,std::vector< signed char >::difference_type i,std::vector< signed char >::difference_type j,std::vector< signed char,std::allocator< signed char > > const &v){ + swig::setslice(self, i, j, 1, v); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____delslice__(std::vector< int8_t > *self,std::vector< signed char >::difference_type i,std::vector< signed char >::difference_type j){ + swig::delslice(self, i, j, 1); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____delitem____SWIG_0(std::vector< int8_t > *self,std::vector< signed char >::difference_type i){ + swig::erase(self, swig::getpos(self, i)); + } +SWIGINTERN std::vector< signed char,std::allocator< signed char > > *std_vector_Sl_int8_t_Sg____getitem____SWIG_0(std::vector< int8_t > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< signed char,std::allocator< signed char > >::difference_type id = i; + std::vector< signed char,std::allocator< signed char > >::difference_type jd = j; + return swig::getslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____setitem____SWIG_0(std::vector< int8_t > *self,SWIGPY_SLICEOBJECT *slice,std::vector< signed char,std::allocator< signed char > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< signed char,std::allocator< signed char > >::difference_type id = i; + std::vector< signed char,std::allocator< signed char > >::difference_type jd = j; + swig::setslice(self, id, jd, step, v); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____setitem____SWIG_1(std::vector< int8_t > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< signed char,std::allocator< signed char > >::difference_type id = i; + std::vector< signed char,std::allocator< signed char > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____delitem____SWIG_1(std::vector< int8_t > *self,SWIGPY_SLICEOBJECT *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step); + std::vector< signed char,std::allocator< signed char > >::difference_type id = i; + std::vector< signed char,std::allocator< signed char > >::difference_type jd = j; + swig::delslice(self, id, jd, step); + } +SWIGINTERN std::vector< signed char >::value_type const &std_vector_Sl_int8_t_Sg____getitem____SWIG_1(std::vector< int8_t > const *self,std::vector< signed char >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_int8_t_Sg____setitem____SWIG_2(std::vector< int8_t > *self,std::vector< signed char >::difference_type i,std::vector< signed char >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN std::vector< signed char >::value_type std_vector_Sl_int8_t_Sg__pop(std::vector< int8_t > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector< signed char,std::allocator< signed char > >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN void std_vector_Sl_int8_t_Sg__append(std::vector< int8_t > *self,std::vector< signed char >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN std::vector< signed char >::iterator std_vector_Sl_int8_t_Sg__erase__SWIG_0(std::vector< int8_t > *self,std::vector< signed char >::iterator pos){ return self->erase(pos); } +SWIGINTERN std::vector< signed char >::iterator std_vector_Sl_int8_t_Sg__erase__SWIG_1(std::vector< int8_t > *self,std::vector< signed char >::iterator first,std::vector< signed char >::iterator last){ return self->erase(first, last); } +SWIGINTERN std::vector< signed char >::iterator std_vector_Sl_int8_t_Sg__insert__SWIG_0(std::vector< int8_t > *self,std::vector< signed char >::iterator pos,std::vector< signed char >::value_type const &x){ return self->insert(pos, x); } +SWIGINTERN void std_vector_Sl_int8_t_Sg__insert__SWIG_1(std::vector< int8_t > *self,std::vector< signed char >::iterator pos,std::vector< signed char >::size_type n,std::vector< signed char >::value_type const &x){ self->insert(pos, n, x); } + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor(void) +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +/* Return string from Python obj. NOTE: obj must remain in scope in order + to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */ +SWIGINTERN int +SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc) +{ +#if PY_VERSION_HEX>=0x03000000 +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + if (PyBytes_Check(obj)) +#else + if (PyUnicode_Check(obj)) +#endif +#else + if (PyString_Check(obj)) +#endif + { + char *cstr; Py_ssize_t len; + PyObject *bytes = NULL; + int ret = SWIG_OK; + if (alloc) + *alloc = SWIG_OLDOBJ; +#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1) + return SWIG_TypeError; +#else + cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes); + if (!cstr) + return SWIG_TypeError; + /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */ + if (bytes && cptr) { + if (alloc) { + cstr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); + *alloc = SWIG_NEWOBJ; + } else { + /* alloc must be set in order to clean up allocated memory */ + return SWIG_RuntimeError; + } + } +#endif + if (cptr) *cptr = cstr; + if (psize) *psize = len + 1; + Py_XDECREF(bytes); + return ret; + } else { +#if defined(SWIG_PYTHON_2_UNICODE) +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) +#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once" +#endif +#if PY_VERSION_HEX<0x03000000 + if (PyUnicode_Check(obj)) { + char *cstr; Py_ssize_t len; + if (!alloc && cptr) { + return SWIG_RuntimeError; + } + obj = PyUnicode_AsUTF8String(obj); + if (!obj) + return SWIG_TypeError; + if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) { + if (cptr) { + if (alloc) *alloc = SWIG_NEWOBJ; + *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); + } + if (psize) *psize = len + 1; + + Py_XDECREF(obj); + return SWIG_OK; + } else { + Py_XDECREF(obj); + } + } +#endif +#endif + + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + if (pchar_descriptor) { + void* vptr = 0; + if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { + if (cptr) *cptr = (char *) vptr; + if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; + if (alloc) *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + } + } + return SWIG_TypeError; +} + + + + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + +SWIGINTERN int +SWIG_AsPtr_std_string (PyObject * obj, std::string **val) +{ + char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ; + if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) { + if (buf) { + if (val) *val = new std::string(buf, size - 1); + if (alloc == SWIG_NEWOBJ) delete[] buf; + return SWIG_NEWOBJ; + } else { + if (val) *val = 0; + return SWIG_OLDOBJ; + } + } else { + static int init = 0; + static swig_type_info* descriptor = 0; + if (!init) { + descriptor = SWIG_TypeQuery("std::string" " *"); + init = 1; + } + if (descriptor) { + std::string *vptr; + int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0); + if (SWIG_IsOK(res) && val) *val = vptr; + return res; + } + } + return SWIG_ERROR; +} + + +struct SWIG_null_deleter { + void operator() (void const *) const { + } +}; +#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter() +#define SWIG_NO_NULL_DELETER_1 +#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW +#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN + + +#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + if (carray) { + if (size > INT_MAX) { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + return pchar_descriptor ? + SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { +#if PY_VERSION_HEX >= 0x03000000 +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#else + return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); +#endif +#else + return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#endif + } + } else { + return SWIG_Py_Void(); + } +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_std_string (const std::string& s) +{ + return SWIG_FromCharPtrAndSize(s.data(), s.size()); +} + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > USHRT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< unsigned short >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_unsigned_SS_short (unsigned short value) +{ + return SWIG_From_unsigned_SS_long (value); +} + + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + +#include + + +SWIGINTERNINLINE PyObject * +SWIG_From_short (short value) +{ + return SWIG_From_long (value); +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_unsigned_SS_int (unsigned int value) +{ + return PyInt_FromSize_t((size_t) value); +} + + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "wedpr_python_transportPYTHON_wrap.h" + +SwigDirector_ErrorCallback::SwigDirector_ErrorCallback(PyObject *self): ppc::front::ErrorCallback(), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((ppc::front::ErrorCallback *)this, this); +} + + + + +SwigDirector_ErrorCallback::~SwigDirector_ErrorCallback() { +} + +void SwigDirector_ErrorCallback::onError(bcos::Error::Ptr error) { + std::shared_ptr< bcos::Error > *smartarg1 = 0 ; + + swig::SwigVar_PyObject obj0; + + smartarg1 = error ? new std::shared_ptr< bcos::Error >(error) : 0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(smartarg1), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN | 0 ); + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ErrorCallback.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 0; + const char *const swig_method_name = "onError"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onError"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + if (error) { + Swig::DirectorMethodException::raise("Error detected when calling 'ErrorCallback.onError'"); + } + } +} + + +SwigDirector_MessageDispatcherHandler::SwigDirector_MessageDispatcherHandler(PyObject *self): ppc::front::MessageDispatcherHandler(), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((ppc::front::MessageDispatcherHandler *)this, this); +} + + + + +SwigDirector_MessageDispatcherHandler::~SwigDirector_MessageDispatcherHandler() { +} + +void SwigDirector_MessageDispatcherHandler::onMessage(ppc::protocol::Message::Ptr msg) { + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + + swig::SwigVar_PyObject obj0; + + smartarg1 = msg ? new std::shared_ptr< ppc::protocol::Message >(msg) : 0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(smartarg1), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN | 0 ); + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MessageDispatcherHandler.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 0; + const char *const swig_method_name = "onMessage"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onMessage"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + if (error) { + Swig::DirectorMethodException::raise("Error detected when calling 'MessageDispatcherHandler.onMessage'"); + } + } +} + + +SwigDirector_IMessageHandler::SwigDirector_IMessageHandler(PyObject *self): ppc::front::IMessageHandler(), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((ppc::front::IMessageHandler *)this, this); +} + + + + +SwigDirector_IMessageHandler::~SwigDirector_IMessageHandler() { +} + +void SwigDirector_IMessageHandler::onMessage(bcos::Error::Ptr e,ppc::protocol::Message::Ptr msg,ppc::front::SendResponseHandler sendResponseHandler) { + std::shared_ptr< bcos::Error > *smartarg1 = 0 ; + std::shared_ptr< ppc::protocol::Message > *smartarg2 = 0 ; + + swig::SwigVar_PyObject obj0; + + smartarg1 = e ? new std::shared_ptr< bcos::Error >(e) : 0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(smartarg1), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN | 0 ); + + swig::SwigVar_PyObject obj1; + + smartarg2 = msg ? new std::shared_ptr< ppc::protocol::Message >(msg) : 0; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(smartarg2), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN | 0 ); + + swig::SwigVar_PyObject obj2; + obj2 = SWIG_NewPointerObj((new ppc::front::SendResponseHandler(SWIG_STD_MOVE(sendResponseHandler))), SWIGTYPE_p_ppc__front__SendResponseHandler, SWIG_POINTER_OWN | 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call IMessageHandler.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 0; + const char *const swig_method_name = "onMessage"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onMessage"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + if (error) { + Swig::DirectorMethodException::raise("Error detected when calling 'IMessageHandler.onMessage'"); + } + } +} + + +SwigDirector_GetPeersInfoHandler::SwigDirector_GetPeersInfoHandler(PyObject *self): ppc::front::GetPeersInfoHandler(), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((ppc::front::GetPeersInfoHandler *)this, this); +} + + + + +SwigDirector_GetPeersInfoHandler::~SwigDirector_GetPeersInfoHandler() { +} + +void SwigDirector_GetPeersInfoHandler::onPeersInfo(bcos::Error::Ptr e,std::string const &peersInfo) { + std::shared_ptr< bcos::Error > *smartarg1 = 0 ; + + swig::SwigVar_PyObject obj0; + + smartarg1 = e ? new std::shared_ptr< bcos::Error >(e) : 0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(smartarg1), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN | 0 ); + + swig::SwigVar_PyObject obj1; + obj1 = SWIG_From_std_string(static_cast< std::string >(peersInfo)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call GetPeersInfoHandler.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 0; + const char *const swig_method_name = "onPeersInfo"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("onPeersInfo"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + if (error) { + Swig::DirectorMethodException::raise("Error detected when calling 'GetPeersInfoHandler.onPeersInfo'"); + } + } +} + + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n" + " Possible C/C++ prototypes are:\n" + " swig::SwigPyIterator::incr(size_t)\n" + " swig::SwigPyIterator::incr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n" + " Possible C/C++ prototypes are:\n" + " swig::SwigPyIterator::decr(size_t)\n" + " swig::SwigPyIterator::decr()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + ptrdiff_t result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2); + } catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2); + } catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->next(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->__next__(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->previous(); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->advance(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) { + return NULL; + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bool result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) { + return NULL; + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) { + return NULL; + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + swig::SwigPyIterator *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); + } catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) { + return NULL; + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + ptrdiff_t result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) { + return NULL; + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_SharedBcosError(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< bcos::Error > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedBcosError", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< bcos::Error > *)new std::shared_ptr< bcos::Error >(); + { + std::shared_ptr< bcos::Error > *smartresult = (result && *result) ? new std::shared_ptr< bcos::Error >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedBcosError(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< bcos::Error > *arg1 = (std::shared_ptr< bcos::Error > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< bcos::Error > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedBcosError" "', argument " "1"" of type '" "std::shared_ptr< bcos::Error > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + delete reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedBcosError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedBcosError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedFrontConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::FrontConfig > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedFrontConfig", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::front::FrontConfig > *)new std::shared_ptr< ppc::front::FrontConfig >(); + { + std::shared_ptr< ppc::front::FrontConfig > *smartresult = (result && *result) ? new std::shared_ptr< ppc::front::FrontConfig >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedFrontConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::FrontConfig > *arg1 = (std::shared_ptr< ppc::front::FrontConfig > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedFrontConfig" "', argument " "1"" of type '" "std::shared_ptr< ppc::front::FrontConfig > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedFrontConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedFrontConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedGrpcConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::GrpcConfig > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedGrpcConfig", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::GrpcConfig > *)new std::shared_ptr< ppc::protocol::GrpcConfig >(); + { + std::shared_ptr< ppc::protocol::GrpcConfig > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::GrpcConfig >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedGrpcConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::GrpcConfig > *arg1 = (std::shared_ptr< ppc::protocol::GrpcConfig > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedGrpcConfig" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::GrpcConfig > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedGrpcConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedGrpcConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedFront(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::IFront > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedFront", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::front::IFront > *)new std::shared_ptr< ppc::front::IFront >(); + { + std::shared_ptr< ppc::front::IFront > *smartresult = (result && *result) ? new std::shared_ptr< ppc::front::IFront >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedFront(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::IFront > *arg1 = (std::shared_ptr< ppc::front::IFront > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedFront" "', argument " "1"" of type '" "std::shared_ptr< ppc::front::IFront > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedFront_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedFront_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedFrontClient(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::IFrontClient > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedFrontClient", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::front::IFrontClient > *)new std::shared_ptr< ppc::front::IFrontClient >(); + { + std::shared_ptr< ppc::front::IFrontClient > *smartresult = (result && *result) ? new std::shared_ptr< ppc::front::IFrontClient >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedFrontClient(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::IFrontClient > *arg1 = (std::shared_ptr< ppc::front::IFrontClient > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFrontClient > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedFrontClient" "', argument " "1"" of type '" "std::shared_ptr< ppc::front::IFrontClient > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedFrontClient_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedFrontClient_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedErrorCallback(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::ErrorCallback > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedErrorCallback", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::front::ErrorCallback > *)new std::shared_ptr< ppc::front::ErrorCallback >(); + { + std::shared_ptr< ppc::front::ErrorCallback > *smartresult = (result && *result) ? new std::shared_ptr< ppc::front::ErrorCallback >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedErrorCallback(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::ErrorCallback > *arg1 = (std::shared_ptr< ppc::front::ErrorCallback > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::ErrorCallback > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedErrorCallback" "', argument " "1"" of type '" "std::shared_ptr< ppc::front::ErrorCallback > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedErrorCallback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedErrorCallback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedMessageDispatcherHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::MessageDispatcherHandler > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedMessageDispatcherHandler", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::front::MessageDispatcherHandler > *)new std::shared_ptr< ppc::front::MessageDispatcherHandler >(); + { + std::shared_ptr< ppc::front::MessageDispatcherHandler > *smartresult = (result && *result) ? new std::shared_ptr< ppc::front::MessageDispatcherHandler >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedMessageDispatcherHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::MessageDispatcherHandler > *arg1 = (std::shared_ptr< ppc::front::MessageDispatcherHandler > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::MessageDispatcherHandler > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedMessageDispatcherHandler" "', argument " "1"" of type '" "std::shared_ptr< ppc::front::MessageDispatcherHandler > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedMessageDispatcherHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedMessageDispatcherHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedIMessageHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::IMessageHandler > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedIMessageHandler", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::front::IMessageHandler > *)new std::shared_ptr< ppc::front::IMessageHandler >(); + { + std::shared_ptr< ppc::front::IMessageHandler > *smartresult = (result && *result) ? new std::shared_ptr< ppc::front::IMessageHandler >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedIMessageHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::IMessageHandler > *arg1 = (std::shared_ptr< ppc::front::IMessageHandler > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IMessageHandler > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedIMessageHandler" "', argument " "1"" of type '" "std::shared_ptr< ppc::front::IMessageHandler > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedIMessageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedIMessageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedGetPeersInfoHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::GetPeersInfoHandler > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedGetPeersInfoHandler", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::front::GetPeersInfoHandler > *)new std::shared_ptr< ppc::front::GetPeersInfoHandler >(); + { + std::shared_ptr< ppc::front::GetPeersInfoHandler > *smartresult = (result && *result) ? new std::shared_ptr< ppc::front::GetPeersInfoHandler >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedGetPeersInfoHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::front::GetPeersInfoHandler > *arg1 = (std::shared_ptr< ppc::front::GetPeersInfoHandler > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::GetPeersInfoHandler > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedGetPeersInfoHandler" "', argument " "1"" of type '" "std::shared_ptr< ppc::front::GetPeersInfoHandler > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedGetPeersInfoHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedGetPeersInfoHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedGateway(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::gateway::IGateway > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedGateway", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::gateway::IGateway > *)new std::shared_ptr< ppc::gateway::IGateway >(); + { + std::shared_ptr< ppc::gateway::IGateway > *smartresult = (result && *result) ? new std::shared_ptr< ppc::gateway::IGateway >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__gateway__IGateway_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedGateway(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::gateway::IGateway > *arg1 = (std::shared_ptr< ppc::gateway::IGateway > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::gateway::IGateway > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__gateway__IGateway_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedGateway" "', argument " "1"" of type '" "std::shared_ptr< ppc::gateway::IGateway > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::gateway::IGateway > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::gateway::IGateway > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::gateway::IGateway > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedGateway_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__gateway__IGateway_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedGateway_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::Message > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedMessage", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::Message > *)new std::shared_ptr< ppc::protocol::Message >(); + { + std::shared_ptr< ppc::protocol::Message > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::Message >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::Message > *arg1 = (std::shared_ptr< ppc::protocol::Message > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedMessage" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::Message > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedMessage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedMessageHeader(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageHeader > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedMessageHeader", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::MessageHeader > *)new std::shared_ptr< ppc::protocol::MessageHeader >(); + { + std::shared_ptr< ppc::protocol::MessageHeader > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::MessageHeader >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedMessageHeader(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageHeader > *arg1 = (std::shared_ptr< ppc::protocol::MessageHeader > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedMessageHeader" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::MessageHeader > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedMessageHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedMessageHeader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedMessagePayload(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessagePayload > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedMessagePayload", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::MessagePayload > *)new std::shared_ptr< ppc::protocol::MessagePayload >(); + { + std::shared_ptr< ppc::protocol::MessagePayload > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::MessagePayload >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedMessagePayload(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessagePayload > *arg1 = (std::shared_ptr< ppc::protocol::MessagePayload > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedMessagePayload" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::MessagePayload > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedMessagePayload_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedMessagePayload_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedRouteInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedRouteInfo", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::MessageOptionalHeader > *)new std::shared_ptr< ppc::protocol::MessageOptionalHeader >(); + { + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::MessageOptionalHeader >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedRouteInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *arg1 = (std::shared_ptr< ppc::protocol::MessageOptionalHeader > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedRouteInfo" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::MessageOptionalHeader > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedRouteInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedRouteInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedMessageBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageBuilder > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedMessageBuilder", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::MessageBuilder > *)new std::shared_ptr< ppc::protocol::MessageBuilder >(); + { + std::shared_ptr< ppc::protocol::MessageBuilder > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::MessageBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedMessageBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageBuilder > *arg1 = (std::shared_ptr< ppc::protocol::MessageBuilder > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageBuilder > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedMessageBuilder" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::MessageBuilder > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedMessageBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedMessageBuilder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedMessageHeaderBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedMessageHeaderBuilder", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *)new std::shared_ptr< ppc::protocol::MessageHeaderBuilder >(); + { + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::MessageHeaderBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedMessageHeaderBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *arg1 = (std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedMessageHeaderBuilder" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedMessageHeaderBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedMessageHeaderBuilder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedMessagePayloadBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedMessagePayloadBuilder", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *)new std::shared_ptr< ppc::protocol::MessagePayloadBuilder >(); + { + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::MessagePayloadBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedMessagePayloadBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *arg1 = (std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedMessagePayloadBuilder" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedMessagePayloadBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedMessagePayloadBuilder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SharedRouteInfoBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_SharedRouteInfoBuilder", 0, 0, 0)) SWIG_fail; + result = (std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *)new std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder >(); + { + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *smartresult = (result && *result) ? new std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, SWIG_POINTER_OWN); + if (SWIG_POINTER_NEW) delete result; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SharedRouteInfoBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *arg1 = (std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *) 0 ; + void *argp1 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > tempshared1 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedRouteInfoBuilder" "', argument " "1"" of type '" "std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1) : &tempshared1; + } + } + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SharedRouteInfoBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SharedRouteInfoBuilder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_ubytes_iterator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &swig_obj[0]; + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_iterator" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_uint8_t_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___nonzero__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___nonzero__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (bool)std_vector_Sl_uint8_t_Sg____nonzero__((std::vector< unsigned char > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___bool__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___bool__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (bool)std_vector_Sl_uint8_t_Sg____bool__((std::vector< unsigned char > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___len__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< unsigned char >::size_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___len__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = std_vector_Sl_uint8_t_Sg____len__((std::vector< unsigned char > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___getslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::difference_type arg2 ; + std::vector< unsigned char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + std::vector< unsigned char,std::allocator< unsigned char > > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ubytes___getslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___getslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes___getslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes___getslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3); + try { + result = (std::vector< unsigned char,std::allocator< unsigned char > > *)std_vector_Sl_uint8_t_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::difference_type arg2 ; + std::vector< unsigned char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___setslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes___setslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes___setslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3); + try { + std_vector_Sl_uint8_t_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::difference_type arg2 ; + std::vector< unsigned char >::difference_type arg3 ; + std::vector< unsigned char,std::allocator< unsigned char > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + + (void)self; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___setslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes___setslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes___setslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3); + { + std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0; + res4 = swig::asptr(swig_obj[3], &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ubytes___setslice__" "', argument " "4"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ubytes___setslice__" "', argument " "4"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_uint8_t_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< unsigned char,std::allocator< unsigned char > > const &)*arg4); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ubytes___setslice__", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes___setslice____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ubytes___setslice____SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ubytes___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::__setslice__(std::vector< unsigned char >::difference_type,std::vector< unsigned char >::difference_type)\n" + " std::vector< uint8_t >::__setslice__(std::vector< unsigned char >::difference_type,std::vector< unsigned char >::difference_type,std::vector< unsigned char,std::allocator< unsigned char > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ubytes___delslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::difference_type arg2 ; + std::vector< unsigned char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ubytes___delslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___delslice__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes___delslice__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes___delslice__" "', argument " "3"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg3 = static_cast< std::vector< unsigned char >::difference_type >(val3); + try { + std_vector_Sl_uint8_t_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___delitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes___delitem__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2); + try { + std_vector_Sl_uint8_t_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< unsigned char,std::allocator< unsigned char > > *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___getitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + result = (std::vector< unsigned char,std::allocator< unsigned char > > *)std_vector_Sl_uint8_t_Sg____getitem____SWIG_0(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + std::vector< unsigned char,std::allocator< unsigned char > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___setitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + { + std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0; + res3 = swig::asptr(swig_obj[2], &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ubytes___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ubytes___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_uint8_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< unsigned char,std::allocator< unsigned char > > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___setitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_uint8_t_Sg____setitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___delitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_uint8_t_Sg____delitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ubytes___delitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ubytes___delitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes___delitem____SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ubytes___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::__delitem__(std::vector< unsigned char >::difference_type)\n" + " std::vector< uint8_t >::__delitem__(SWIGPY_SLICEOBJECT *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ubytes___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< unsigned char >::value_type *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___getitem__" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes___getitem__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2); + try { + result = (std::vector< unsigned char >::value_type *) &std_vector_Sl_uint8_t_Sg____getitem____SWIG_1((std::vector< unsigned char > const *)arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ubytes___getitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ubytes___getitem____SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes___getitem____SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ubytes___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< uint8_t >::__getitem__(std::vector< unsigned char >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ubytes___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::difference_type arg2 ; + std::vector< unsigned char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< unsigned char >::value_type temp3 ; + unsigned char val3 ; + int ecode3 = 0 ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes___setitem__" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes___setitem__" "', argument " "2"" of type '" "std::vector< unsigned char >::difference_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::difference_type >(val2); + ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes___setitem__" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp3 = static_cast< std::vector< unsigned char >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_uint8_t_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(unsigned char const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ubytes___setitem__", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ubytes___setitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ubytes___setitem____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes___setitem____SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ubytes___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned char,std::allocator< unsigned char > > const &)\n" + " std::vector< uint8_t >::__setitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< uint8_t >::__setitem__(std::vector< unsigned char >::difference_type,std::vector< unsigned char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ubytes_pop(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< unsigned char >::value_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_pop" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + try { + result = (std::vector< unsigned char >::value_type)std_vector_Sl_uint8_t_Sg__pop(arg1); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_append(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< unsigned char >::value_type temp2 ; + unsigned char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ubytes_append", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_append" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes_append" "', argument " "2"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp2 = static_cast< std::vector< unsigned char >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_uint8_t_Sg__append(arg1,(unsigned char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ubytes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + std::vector< uint8_t > *result = 0 ; + + (void)self; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (std::vector< uint8_t > *)new std::vector< uint8_t >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ubytes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + std::vector< uint8_t > *result = 0 ; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + std::vector< unsigned char,std::allocator< unsigned char > > *ptr = (std::vector< unsigned char,std::allocator< unsigned char > > *)0; + res1 = swig::asptr(swig_obj[0], &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ubytes" "', argument " "1"" of type '" "std::vector< uint8_t > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ubytes" "', argument " "1"" of type '" "std::vector< uint8_t > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< uint8_t > *)new std::vector< uint8_t >((std::vector< uint8_t > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_empty(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_empty" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (bool)((std::vector< uint8_t > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_size(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< unsigned char >::size_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_size" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = ((std::vector< uint8_t > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_swap(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< uint8_t > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ubytes_swap", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_swap" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_uint8_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ubytes_swap" "', argument " "2"" of type '" "std::vector< uint8_t > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ubytes_swap" "', argument " "2"" of type '" "std::vector< uint8_t > &""'"); + } + arg2 = reinterpret_cast< std::vector< uint8_t > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_begin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< unsigned char >::iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_begin" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_end(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< unsigned char >::iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_end" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_rbegin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< unsigned char >::reverse_iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_rbegin" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_rend(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< unsigned char >::reverse_iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_rend" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_clear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_clear" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_get_allocator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::allocator< unsigned char > > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_get_allocator" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = ((std::vector< uint8_t > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< unsigned char >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_unsigned_char_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ubytes__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< unsigned char >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< uint8_t > *result = 0 ; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ubytes" "', argument " "1"" of type '" "std::vector< unsigned char >::size_type""'"); + } + arg1 = static_cast< std::vector< unsigned char >::size_type >(val1); + result = (std::vector< uint8_t > *)new std::vector< uint8_t >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_pop_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_pop_back" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_resize" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes_resize" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_erase" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } + } + result = std_vector_Sl_uint8_t_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > result; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_erase" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_erase" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_erase" "', argument " "3"" of type '" "std::vector< unsigned char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_erase" "', argument " "3"" of type '" "std::vector< unsigned char >::iterator""'"); + } + } + result = std_vector_Sl_uint8_t_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ubytes_erase", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_ubytes_erase__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_ubytes_erase__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ubytes_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::erase(std::vector< unsigned char >::iterator)\n" + " std::vector< uint8_t >::erase(std::vector< unsigned char >::iterator,std::vector< unsigned char >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_ubytes__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< unsigned char >::size_type arg1 ; + std::vector< unsigned char >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< unsigned char >::value_type temp2 ; + unsigned char val2 ; + int ecode2 = 0 ; + std::vector< uint8_t > *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ubytes" "', argument " "1"" of type '" "std::vector< unsigned char >::size_type""'"); + } + arg1 = static_cast< std::vector< unsigned char >::size_type >(val1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ubytes" "', argument " "2"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp2 = static_cast< std::vector< unsigned char >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< uint8_t > *)new std::vector< uint8_t >(arg1,(std::vector< unsigned char >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ubytes(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ubytes", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_ubytes__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ubytes__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ubytes__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ubytes__SWIG_3(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ubytes'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::vector()\n" + " std::vector< uint8_t >::vector(std::vector< uint8_t > const &)\n" + " std::vector< uint8_t >::vector(std::vector< unsigned char >::size_type)\n" + " std::vector< uint8_t >::vector(std::vector< unsigned char >::size_type,std::vector< unsigned char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ubytes_push_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< unsigned char >::value_type temp2 ; + unsigned char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ubytes_push_back", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_push_back" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes_push_back" "', argument " "2"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp2 = static_cast< std::vector< unsigned char >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< unsigned char >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_front(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< unsigned char >::value_type *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_front" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (std::vector< unsigned char >::value_type *) &((std::vector< uint8_t > const *)arg1)->front(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< unsigned char >::value_type *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_back" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = (std::vector< unsigned char >::value_type *) &((std::vector< uint8_t > const *)arg1)->back(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_assign(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::size_type arg2 ; + std::vector< unsigned char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< unsigned char >::value_type temp3 ; + unsigned char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ubytes_assign", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_assign" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes_assign" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::size_type >(val2); + ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes_assign" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp3 = static_cast< std::vector< unsigned char >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< unsigned char >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::size_type arg2 ; + std::vector< unsigned char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< unsigned char >::value_type temp3 ; + unsigned char val3 ; + int ecode3 = 0 ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_resize" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes_resize" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::size_type >(val2); + ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes_resize" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp3 = static_cast< std::vector< unsigned char >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< unsigned char >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ubytes_resize", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes_resize__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes_resize__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ubytes_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::resize(std::vector< unsigned char >::size_type)\n" + " std::vector< uint8_t >::resize(std::vector< unsigned char >::size_type,std::vector< unsigned char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ubytes_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ; + std::vector< unsigned char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< unsigned char >::value_type temp3 ; + unsigned char val3 ; + int ecode3 = 0 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > result; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_insert" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes_insert" "', argument " "3"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp3 = static_cast< std::vector< unsigned char >::value_type >(val3); + arg3 = &temp3; + result = std_vector_Sl_uint8_t_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(unsigned char const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + SwigValueWrapper< std::vector< unsigned char >::iterator > arg2 ; + std::vector< unsigned char >::size_type arg3 ; + std::vector< unsigned char >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< unsigned char >::value_type temp4 ; + unsigned char val4 ; + int ecode4 = 0 ; + + (void)self; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_insert" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ubytes_insert" "', argument " "2"" of type '" "std::vector< unsigned char >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubytes_insert" "', argument " "3"" of type '" "std::vector< unsigned char >::size_type""'"); + } + arg3 = static_cast< std::vector< unsigned char >::size_type >(val3); + ecode4 = SWIG_AsVal_unsigned_SS_char(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ubytes_insert" "', argument " "4"" of type '" "std::vector< unsigned char >::value_type""'"); + } + temp4 = static_cast< std::vector< unsigned char >::value_type >(val4); + arg4 = &temp4; + std_vector_Sl_uint8_t_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(unsigned char const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ubytes_insert", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes_insert__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< unsigned char,std::allocator< unsigned char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ubytes_insert__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ubytes_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< uint8_t >::insert(std::vector< unsigned char >::iterator,std::vector< unsigned char >::value_type const &)\n" + " std::vector< uint8_t >::insert(std::vector< unsigned char >::iterator,std::vector< unsigned char >::size_type,std::vector< unsigned char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ubytes_reserve(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + std::vector< unsigned char >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ubytes_reserve", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_reserve" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubytes_reserve" "', argument " "2"" of type '" "std::vector< unsigned char >::size_type""'"); + } + arg2 = static_cast< std::vector< unsigned char >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ubytes_capacity(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< unsigned char >::size_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ubytes_capacity" "', argument " "1"" of type '" "std::vector< uint8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + result = ((std::vector< uint8_t > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ubytes(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ubytes" "', argument " "1"" of type '" "std::vector< uint8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< uint8_t > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ubytes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ubytes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_ibytes_iterator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &swig_obj[0]; + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_iterator" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_int8_t_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___nonzero__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___nonzero__" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (bool)std_vector_Sl_int8_t_Sg____nonzero__((std::vector< signed char > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___bool__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___bool__" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (bool)std_vector_Sl_int8_t_Sg____bool__((std::vector< signed char > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___len__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< signed char >::size_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___len__" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = std_vector_Sl_int8_t_Sg____len__((std::vector< signed char > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___getslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::difference_type arg2 ; + std::vector< signed char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + std::vector< signed char,std::allocator< signed char > > *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ibytes___getslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___getslice__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes___getslice__" "', argument " "2"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg2 = static_cast< std::vector< signed char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes___getslice__" "', argument " "3"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg3 = static_cast< std::vector< signed char >::difference_type >(val3); + try { + result = (std::vector< signed char,std::allocator< signed char > > *)std_vector_Sl_int8_t_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::difference_type arg2 ; + std::vector< signed char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___setslice__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes___setslice__" "', argument " "2"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg2 = static_cast< std::vector< signed char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes___setslice__" "', argument " "3"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg3 = static_cast< std::vector< signed char >::difference_type >(val3); + try { + std_vector_Sl_int8_t_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::difference_type arg2 ; + std::vector< signed char >::difference_type arg3 ; + std::vector< signed char,std::allocator< signed char > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + + (void)self; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___setslice__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes___setslice__" "', argument " "2"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg2 = static_cast< std::vector< signed char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes___setslice__" "', argument " "3"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg3 = static_cast< std::vector< signed char >::difference_type >(val3); + { + std::vector< signed char,std::allocator< signed char > > *ptr = (std::vector< signed char,std::allocator< signed char > > *)0; + res4 = swig::asptr(swig_obj[3], &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ibytes___setslice__" "', argument " "4"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ibytes___setslice__" "', argument " "4"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_int8_t_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< signed char,std::allocator< signed char > > const &)*arg4); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___setslice__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ibytes___setslice__", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes___setslice____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = swig::asptr(argv[3], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ibytes___setslice____SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ibytes___setslice__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::__setslice__(std::vector< signed char >::difference_type,std::vector< signed char >::difference_type)\n" + " std::vector< int8_t >::__setslice__(std::vector< signed char >::difference_type,std::vector< signed char >::difference_type,std::vector< signed char,std::allocator< signed char > > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ibytes___delslice__(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::difference_type arg2 ; + std::vector< signed char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ibytes___delslice__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___delslice__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes___delslice__" "', argument " "2"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg2 = static_cast< std::vector< signed char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes___delslice__" "', argument " "3"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg3 = static_cast< std::vector< signed char >::difference_type >(val3); + try { + std_vector_Sl_int8_t_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___delitem__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes___delitem__" "', argument " "2"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg2 = static_cast< std::vector< signed char >::difference_type >(val2); + try { + std_vector_Sl_int8_t_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< signed char,std::allocator< signed char > > *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___getitem__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + result = (std::vector< signed char,std::allocator< signed char > > *)std_vector_Sl_int8_t_Sg____getitem____SWIG_0(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + std::vector< signed char,std::allocator< signed char > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___setitem__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + { + std::vector< signed char,std::allocator< signed char > > *ptr = (std::vector< signed char,std::allocator< signed char > > *)0; + res3 = swig::asptr(swig_obj[2], &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ibytes___setitem__" "', argument " "3"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ibytes___setitem__" "', argument " "3"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_int8_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< signed char,std::allocator< signed char > > const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___setitem__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_int8_t_Sg____setitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___delitem__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + { + if (!PySlice_Check(swig_obj[1])) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'"); + } + arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1]; + } + try { + std_vector_Sl_int8_t_Sg____delitem____SWIG_1(arg1,arg2); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___delitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ibytes___delitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ibytes___delitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes___delitem____SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ibytes___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::__delitem__(std::vector< signed char >::difference_type)\n" + " std::vector< int8_t >::__delitem__(SWIGPY_SLICEOBJECT *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ibytes___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< signed char >::value_type *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___getitem__" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes___getitem__" "', argument " "2"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg2 = static_cast< std::vector< signed char >::difference_type >(val2); + try { + result = (std::vector< signed char >::value_type *) &std_vector_Sl_int8_t_Sg____getitem____SWIG_1((std::vector< signed char > const *)arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___getitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ibytes___getitem__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ibytes___getitem____SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes___getitem____SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ibytes___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< int8_t >::__getitem__(std::vector< signed char >::difference_type) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ibytes___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::difference_type arg2 ; + std::vector< signed char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< signed char >::value_type temp3 ; + signed char val3 ; + int ecode3 = 0 ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes___setitem__" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes___setitem__" "', argument " "2"" of type '" "std::vector< signed char >::difference_type""'"); + } + arg2 = static_cast< std::vector< signed char >::difference_type >(val2); + ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes___setitem__" "', argument " "3"" of type '" "std::vector< signed char >::value_type""'"); + } + temp3 = static_cast< std::vector< signed char >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_int8_t_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(signed char const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes___setitem__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ibytes___setitem__", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ibytes___setitem____SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ibytes___setitem____SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_signed_SS_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes___setitem____SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ibytes___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< signed char,std::allocator< signed char > > const &)\n" + " std::vector< int8_t >::__setitem__(SWIGPY_SLICEOBJECT *)\n" + " std::vector< int8_t >::__setitem__(std::vector< signed char >::difference_type,std::vector< signed char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ibytes_pop(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< signed char >::value_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_pop" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + try { + result = (std::vector< signed char >::value_type)std_vector_Sl_int8_t_Sg__pop(arg1); + } catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_append(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< signed char >::value_type temp2 ; + signed char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ibytes_append", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_append" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes_append" "', argument " "2"" of type '" "std::vector< signed char >::value_type""'"); + } + temp2 = static_cast< std::vector< signed char >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_int8_t_Sg__append(arg1,(signed char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ibytes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + std::vector< int8_t > *result = 0 ; + + (void)self; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (std::vector< int8_t > *)new std::vector< int8_t >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ibytes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + std::vector< int8_t > *result = 0 ; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + std::vector< signed char,std::allocator< signed char > > *ptr = (std::vector< signed char,std::allocator< signed char > > *)0; + res1 = swig::asptr(swig_obj[0], &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ibytes" "', argument " "1"" of type '" "std::vector< int8_t > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ibytes" "', argument " "1"" of type '" "std::vector< int8_t > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< int8_t > *)new std::vector< int8_t >((std::vector< int8_t > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_empty(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_empty" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (bool)((std::vector< int8_t > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_size(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< signed char >::size_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_size" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = ((std::vector< int8_t > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_swap(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< int8_t > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ibytes_swap", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_swap" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int8_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ibytes_swap" "', argument " "2"" of type '" "std::vector< int8_t > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ibytes_swap" "', argument " "2"" of type '" "std::vector< int8_t > &""'"); + } + arg2 = reinterpret_cast< std::vector< int8_t > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_begin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< signed char >::iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_begin" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< signed char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_end(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< signed char >::iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_end" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< signed char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_rbegin(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< signed char >::reverse_iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_rbegin" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< signed char >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_rend(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::vector< signed char >::reverse_iterator > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_rend" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< signed char >::reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_clear(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_clear" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_get_allocator(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + SwigValueWrapper< std::allocator< signed char > > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_get_allocator" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = ((std::vector< int8_t > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< signed char >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_signed_char_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ibytes__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< signed char >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< int8_t > *result = 0 ; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ibytes" "', argument " "1"" of type '" "std::vector< signed char >::size_type""'"); + } + arg1 = static_cast< std::vector< signed char >::size_type >(val1); + result = (std::vector< int8_t > *)new std::vector< int8_t >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_pop_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_pop_back" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_resize" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes_resize" "', argument " "2"" of type '" "std::vector< signed char >::size_type""'"); + } + arg2 = static_cast< std::vector< signed char >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SwigValueWrapper< std::vector< signed char >::iterator > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + SwigValueWrapper< std::vector< signed char >::iterator > result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_erase" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_erase" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_erase" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } + } + result = std_vector_Sl_int8_t_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< signed char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SwigValueWrapper< std::vector< signed char >::iterator > arg2 ; + SwigValueWrapper< std::vector< signed char >::iterator > arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + SwigValueWrapper< std::vector< signed char >::iterator > result; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_erase" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_erase" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_erase" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_erase" "', argument " "3"" of type '" "std::vector< signed char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_erase" "', argument " "3"" of type '" "std::vector< signed char >::iterator""'"); + } + } + result = std_vector_Sl_int8_t_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< signed char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_erase(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ibytes_erase", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_ibytes_erase__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_ibytes_erase__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ibytes_erase'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::erase(std::vector< signed char >::iterator)\n" + " std::vector< int8_t >::erase(std::vector< signed char >::iterator,std::vector< signed char >::iterator)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_ibytes__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< signed char >::size_type arg1 ; + std::vector< signed char >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< signed char >::value_type temp2 ; + signed char val2 ; + int ecode2 = 0 ; + std::vector< int8_t > *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ibytes" "', argument " "1"" of type '" "std::vector< signed char >::size_type""'"); + } + arg1 = static_cast< std::vector< signed char >::size_type >(val1); + ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ibytes" "', argument " "2"" of type '" "std::vector< signed char >::value_type""'"); + } + temp2 = static_cast< std::vector< signed char >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< int8_t > *)new std::vector< int8_t >(arg1,(std::vector< signed char >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ibytes(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ibytes", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_ibytes__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ibytes__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ibytes__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_signed_SS_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ibytes__SWIG_3(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ibytes'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::vector()\n" + " std::vector< int8_t >::vector(std::vector< int8_t > const &)\n" + " std::vector< int8_t >::vector(std::vector< signed char >::size_type)\n" + " std::vector< int8_t >::vector(std::vector< signed char >::size_type,std::vector< signed char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ibytes_push_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< signed char >::value_type temp2 ; + signed char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ibytes_push_back", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_push_back" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes_push_back" "', argument " "2"" of type '" "std::vector< signed char >::value_type""'"); + } + temp2 = static_cast< std::vector< signed char >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< signed char >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_front(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< signed char >::value_type *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_front" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (std::vector< signed char >::value_type *) &((std::vector< int8_t > const *)arg1)->front(); + resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_back(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< signed char >::value_type *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_back" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = (std::vector< signed char >::value_type *) &((std::vector< int8_t > const *)arg1)->back(); + resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(*result)); + (void)swig::container_owner::value_type>::category>::back_reference(resultobj, swig_obj[0]); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_assign(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::size_type arg2 ; + std::vector< signed char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< signed char >::value_type temp3 ; + signed char val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ibytes_assign", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_assign" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes_assign" "', argument " "2"" of type '" "std::vector< signed char >::size_type""'"); + } + arg2 = static_cast< std::vector< signed char >::size_type >(val2); + ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes_assign" "', argument " "3"" of type '" "std::vector< signed char >::value_type""'"); + } + temp3 = static_cast< std::vector< signed char >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< signed char >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::size_type arg2 ; + std::vector< signed char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< signed char >::value_type temp3 ; + signed char val3 ; + int ecode3 = 0 ; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_resize" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes_resize" "', argument " "2"" of type '" "std::vector< signed char >::size_type""'"); + } + arg2 = static_cast< std::vector< signed char >::size_type >(val2); + ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes_resize" "', argument " "3"" of type '" "std::vector< signed char >::value_type""'"); + } + temp3 = static_cast< std::vector< signed char >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< signed char >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_resize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ibytes_resize", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes_resize__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_signed_SS_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes_resize__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ibytes_resize'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::resize(std::vector< signed char >::size_type)\n" + " std::vector< int8_t >::resize(std::vector< signed char >::size_type,std::vector< signed char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ibytes_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SwigValueWrapper< std::vector< signed char >::iterator > arg2 ; + std::vector< signed char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< signed char >::value_type temp3 ; + signed char val3 ; + int ecode3 = 0 ; + SwigValueWrapper< std::vector< signed char >::iterator > result; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_insert" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_insert" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_insert" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes_insert" "', argument " "3"" of type '" "std::vector< signed char >::value_type""'"); + } + temp3 = static_cast< std::vector< signed char >::value_type >(val3); + arg3 = &temp3; + result = std_vector_Sl_int8_t_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(signed char const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< signed char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + SwigValueWrapper< std::vector< signed char >::iterator > arg2 ; + std::vector< signed char >::size_type arg3 ; + std::vector< signed char >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< signed char >::value_type temp4 ; + signed char val4 ; + int ecode4 = 0 ; + + (void)self; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_insert" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_insert" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ibytes_insert" "', argument " "2"" of type '" "std::vector< signed char >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ibytes_insert" "', argument " "3"" of type '" "std::vector< signed char >::size_type""'"); + } + arg3 = static_cast< std::vector< signed char >::size_type >(val3); + ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ibytes_insert" "', argument " "4"" of type '" "std::vector< signed char >::value_type""'"); + } + temp4 = static_cast< std::vector< signed char >::value_type >(val4); + arg4 = &temp4; + std_vector_Sl_int8_t_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(signed char const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_insert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ibytes_insert", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_signed_SS_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes_insert__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v = 0; + int res = swig::asptr(argv[0], (std::vector< signed char,std::allocator< signed char > >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_signed_SS_char(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ibytes_insert__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ibytes_insert'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int8_t >::insert(std::vector< signed char >::iterator,std::vector< signed char >::value_type const &)\n" + " std::vector< int8_t >::insert(std::vector< signed char >::iterator,std::vector< signed char >::size_type,std::vector< signed char >::value_type const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ibytes_reserve(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + std::vector< signed char >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ibytes_reserve", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_reserve" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ibytes_reserve" "', argument " "2"" of type '" "std::vector< signed char >::size_type""'"); + } + arg2 = static_cast< std::vector< signed char >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ibytes_capacity(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< signed char >::size_type result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ibytes_capacity" "', argument " "1"" of type '" "std::vector< int8_t > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + result = ((std::vector< int8_t > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ibytes(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ibytes" "', argument " "1"" of type '" "std::vector< int8_t > *""'"); + } + arg1 = reinterpret_cast< std::vector< int8_t > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ibytes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int8_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ibytes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_Error_buildError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int32_t arg4 ; + std::string *arg5 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 = SWIG_OLDOBJ ; + bcos::Error result; + + (void)self; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_buildError" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Error_buildError" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Error_buildError" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Error_buildError" "', argument " "4"" of type '" "int32_t""'"); + } + arg4 = static_cast< int32_t >(val4); + { + std::string *ptr = (std::string *)0; + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Error_buildError" "', argument " "5"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Error_buildError" "', argument " "5"" of type '" "std::string const &""'"); + } + arg5 = ptr; + } + result = bcos::Error::buildError((char const *)arg1,(char const *)arg2,arg3,arg4,(std::string const &)*arg5); + { + std::shared_ptr< bcos::Error > *smartresult = new std::shared_ptr< bcos::Error >(new bcos::Error(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res5)) delete arg5; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res5)) delete arg5; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Error_buildError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int32_t arg4 ; + std::string *arg5 = 0 ; + bcos::Error *arg6 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 = SWIG_OLDOBJ ; + void *argp6 = 0 ; + int res6 = 0 ; + std::shared_ptr< bcos::Error const > tempshared6 ; + bcos::Error result; + + (void)self; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_buildError" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Error_buildError" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Error_buildError" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Error_buildError" "', argument " "4"" of type '" "int32_t""'"); + } + arg4 = static_cast< int32_t >(val4); + { + std::string *ptr = (std::string *)0; + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Error_buildError" "', argument " "5"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Error_buildError" "', argument " "5"" of type '" "std::string const &""'"); + } + arg5 = ptr; + } + { + int newmem = 0; + res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 , &newmem); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Error_buildError" "', argument " "6"" of type '" "bcos::Error const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Error_buildError" "', argument " "6"" of type '" "bcos::Error const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared6 = *reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp6); + delete reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp6); + arg6 = const_cast< bcos::Error * >(tempshared6.get()); + } else { + arg6 = const_cast< bcos::Error * >(reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp6)->get()); + } + } + result = bcos::Error::buildError((char const *)arg1,(char const *)arg2,arg3,arg4,(std::string const &)*arg5,(bcos::Error const &)*arg6); + { + std::shared_ptr< bcos::Error > *smartresult = new std::shared_ptr< bcos::Error >(new bcos::Error(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res5)) delete arg5; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res5)) delete arg5; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Error_buildError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int32_t arg4 ; + std::string *arg5 = 0 ; + std::exception *arg6 = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 = SWIG_OLDOBJ ; + void *argp6 = 0 ; + int res6 = 0 ; + bcos::Error result; + + (void)self; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_buildError" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Error_buildError" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Error_buildError" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Error_buildError" "', argument " "4"" of type '" "int32_t""'"); + } + arg4 = static_cast< int32_t >(val4); + { + std::string *ptr = (std::string *)0; + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Error_buildError" "', argument " "5"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Error_buildError" "', argument " "5"" of type '" "std::string const &""'"); + } + arg5 = ptr; + } + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_std__exception, 0 | 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Error_buildError" "', argument " "6"" of type '" "std::exception const &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Error_buildError" "', argument " "6"" of type '" "std::exception const &""'"); + } + arg6 = reinterpret_cast< std::exception * >(argp6); + result = bcos::Error::buildError((char const *)arg1,(char const *)arg2,arg3,arg4,(std::string const &)*arg5,(std::exception const &)*arg6); + { + std::shared_ptr< bcos::Error > *smartresult = new std::shared_ptr< bcos::Error >(new bcos::Error(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res5)) delete arg5; + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res5)) delete arg5; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Error_buildError(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Error_buildError", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v = 0; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Error_buildError__SWIG_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Error_buildError__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__exception, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Error_buildError__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Error_buildError'.\n" + " Possible C/C++ prototypes are:\n" + " bcos::Error::buildError(char const *,char const *,int,int32_t,std::string const &)\n" + " bcos::Error::buildError(char const *,char const *,int,int32_t,std::string const &,bcos::Error const &)\n" + " bcos::Error::buildError(char const *,char const *,int,int32_t,std::string const &,std::exception const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_Error__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + bcos::Error *result = 0 ; + + (void)self; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (bcos::Error *)new bcos::Error(); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Error__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int64_t arg1 ; + std::string arg2 ; + long long val1 ; + int ecode1 = 0 ; + bcos::Error *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_long_SS_long(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Error" "', argument " "1"" of type '" "int64_t""'"); + } + arg1 = static_cast< int64_t >(val1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Error" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (bcos::Error *)new bcos::Error(arg1,arg2); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Error(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Error", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_Error__SWIG_0(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + { + int res = SWIG_AsVal_long_SS_long(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Error__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Error'.\n" + " Possible C/C++ prototypes are:\n" + " bcos::Error::Error()\n" + " bcos::Error::Error(int64_t,std::string)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_Error(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + bcos::Error *arg1 = (bcos::Error *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< bcos::Error > tempshared1 ; + std::shared_ptr< bcos::Error > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Error" "', argument " "1"" of type '" "bcos::Error *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + delete reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Error_errorCode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + bcos::Error *arg1 = (bcos::Error *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< bcos::Error const > tempshared1 ; + std::shared_ptr< bcos::Error const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + int64_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_errorCode" "', argument " "1"" of type '" "bcos::Error const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (int64_t)((bcos::Error const *)arg1)->errorCode(); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Error_errorMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + bcos::Error *arg1 = (bcos::Error *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< bcos::Error const > tempshared1 ; + std::shared_ptr< bcos::Error const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_errorMessage" "', argument " "1"" of type '" "bcos::Error const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((bcos::Error const *)arg1)->errorMessage(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Error_setErrorCode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + bcos::Error *arg1 = (bcos::Error *) 0 ; + int64_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< bcos::Error > tempshared1 ; + std::shared_ptr< bcos::Error > *smartarg1 = 0 ; + long long val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Error_setErrorCode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_setErrorCode" "', argument " "1"" of type '" "bcos::Error *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + delete reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Error_setErrorCode" "', argument " "2"" of type '" "int64_t""'"); + } + arg2 = static_cast< int64_t >(val2); + (arg1)->setErrorCode(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Error_setErrorMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + bcos::Error *arg1 = (bcos::Error *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< bcos::Error > tempshared1 ; + std::shared_ptr< bcos::Error > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Error_setErrorMessage", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_setErrorMessage" "', argument " "1"" of type '" "bcos::Error *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + delete reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< bcos::Error > * >(argp1); + arg1 = const_cast< bcos::Error * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Error_setErrorMessage" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Error_setErrorMessage" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setErrorMessage((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *Error_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *Error_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_InputBuffer_data_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + InputBuffer *arg1 = (InputBuffer *) 0 ; + unsigned char *arg2 = (unsigned char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "InputBuffer_data_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputBuffer_data_set" "', argument " "1"" of type '" "InputBuffer *""'"); + } + arg1 = reinterpret_cast< InputBuffer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InputBuffer_data_set" "', argument " "2"" of type '" "unsigned char const *""'"); + } + arg2 = reinterpret_cast< unsigned char * >(argp2); + if (arg1) (arg1)->data = (unsigned char const *)arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_InputBuffer_data_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + InputBuffer *arg1 = (InputBuffer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + unsigned char *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputBuffer_data_get" "', argument " "1"" of type '" "InputBuffer *""'"); + } + arg1 = reinterpret_cast< InputBuffer * >(argp1); + result = (unsigned char *) ((arg1)->data); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_InputBuffer_len_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + InputBuffer *arg1 = (InputBuffer *) 0 ; + uint64_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "InputBuffer_len_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputBuffer_len_set" "', argument " "1"" of type '" "InputBuffer *""'"); + } + arg1 = reinterpret_cast< InputBuffer * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputBuffer_len_set" "', argument " "2"" of type '" "uint64_t""'"); + } + arg2 = static_cast< uint64_t >(val2); + if (arg1) (arg1)->len = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_InputBuffer_len_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + InputBuffer *arg1 = (InputBuffer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint64_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputBuffer_len_get" "', argument " "1"" of type '" "InputBuffer *""'"); + } + arg1 = reinterpret_cast< InputBuffer * >(argp1); + result = (uint64_t) ((arg1)->len); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_InputBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + InputBuffer *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_InputBuffer", 0, 0, 0)) SWIG_fail; + result = (InputBuffer *)new InputBuffer(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InputBuffer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_InputBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + InputBuffer *arg1 = (InputBuffer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InputBuffer, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputBuffer" "', argument " "1"" of type '" "InputBuffer *""'"); + } + arg1 = reinterpret_cast< InputBuffer * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *InputBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_InputBuffer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *InputBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_OutputBuffer_data_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + OutputBuffer *arg1 = (OutputBuffer *) 0 ; + unsigned char *arg2 = (unsigned char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "OutputBuffer_data_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OutputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputBuffer_data_set" "', argument " "1"" of type '" "OutputBuffer *""'"); + } + arg1 = reinterpret_cast< OutputBuffer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutputBuffer_data_set" "', argument " "2"" of type '" "unsigned char *""'"); + } + arg2 = reinterpret_cast< unsigned char * >(argp2); + if (arg1) (arg1)->data = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OutputBuffer_data_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + OutputBuffer *arg1 = (OutputBuffer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + unsigned char *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OutputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputBuffer_data_get" "', argument " "1"" of type '" "OutputBuffer *""'"); + } + arg1 = reinterpret_cast< OutputBuffer * >(argp1); + result = (unsigned char *) ((arg1)->data); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OutputBuffer_len_set(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + OutputBuffer *arg1 = (OutputBuffer *) 0 ; + uint64_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "OutputBuffer_len_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OutputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputBuffer_len_set" "', argument " "1"" of type '" "OutputBuffer *""'"); + } + arg1 = reinterpret_cast< OutputBuffer * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OutputBuffer_len_set" "', argument " "2"" of type '" "uint64_t""'"); + } + arg2 = static_cast< uint64_t >(val2); + if (arg1) (arg1)->len = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OutputBuffer_len_get(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + OutputBuffer *arg1 = (OutputBuffer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint64_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OutputBuffer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputBuffer_len_get" "', argument " "1"" of type '" "OutputBuffer *""'"); + } + arg1 = reinterpret_cast< OutputBuffer * >(argp1); + result = (uint64_t) ((arg1)->len); + resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_OutputBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + OutputBuffer *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_OutputBuffer", 0, 0, 0)) SWIG_fail; + result = (OutputBuffer *)new OutputBuffer(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OutputBuffer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_OutputBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + OutputBuffer *arg1 = (OutputBuffer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_OutputBuffer, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutputBuffer" "', argument " "1"" of type '" "OutputBuffer *""'"); + } + arg1 = reinterpret_cast< OutputBuffer * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *OutputBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_OutputBuffer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *OutputBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_delete_FrontConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FrontConfig" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_threadPoolSize(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig const > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_threadPoolSize" "', argument " "1"" of type '" "ppc::front::FrontConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (int)((ppc::front::FrontConfig const *)arg1)->threadPoolSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_setThreadPoolSize(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "FrontConfig_setThreadPoolSize", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_setThreadPoolSize" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrontConfig_setThreadPoolSize" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setThreadPoolSize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_nodeID(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig const > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_nodeID" "', argument " "1"" of type '" "ppc::front::FrontConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::front::FrontConfig const *)arg1)->nodeID(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_setNodeID(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "FrontConfig_setNodeID", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_setNodeID" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrontConfig_setNodeID" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FrontConfig_setNodeID" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setNodeID((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_selfEndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig const > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::EndPoint *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_selfEndPoint" "', argument " "1"" of type '" "ppc::front::FrontConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::EndPoint *) &((ppc::front::FrontConfig const *)arg1)->selfEndPoint(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_mutableSelfEndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::EndPoint *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_mutableSelfEndPoint" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::EndPoint *) &(arg1)->mutableSelfEndPoint(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_setSelfEndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + ppc::protocol::EndPoint *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "FrontConfig_setSelfEndPoint", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_setSelfEndPoint" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrontConfig_setSelfEndPoint" "', argument " "2"" of type '" "ppc::protocol::EndPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FrontConfig_setSelfEndPoint" "', argument " "2"" of type '" "ppc::protocol::EndPoint const &""'"); + } + arg2 = reinterpret_cast< ppc::protocol::EndPoint * >(argp2); + (arg1)->setSelfEndPoint((ppc::protocol::EndPoint const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_setGatewayGrpcTarget(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "FrontConfig_setGatewayGrpcTarget", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_setGatewayGrpcTarget" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrontConfig_setGatewayGrpcTarget" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FrontConfig_setGatewayGrpcTarget" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setGatewayGrpcTarget((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_gatewayGrpcTarget(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig const > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_gatewayGrpcTarget" "', argument " "1"" of type '" "ppc::front::FrontConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::front::FrontConfig const *)arg1)->gatewayGrpcTarget(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_setGrpcConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + ppc::protocol::GrpcConfig::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "FrontConfig_setGrpcConfig", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_setGrpcConfig" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrontConfig_setGrpcConfig" "', argument " "2"" of type '" "ppc::protocol::GrpcConfig::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< ppc::protocol::GrpcConfig::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::protocol::GrpcConfig::Ptr * >(argp2); + } + (arg1)->setGrpcConfig(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_grpcConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig const > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::GrpcConfig::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_grpcConfig" "', argument " "1"" of type '" "ppc::front::FrontConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::GrpcConfig::Ptr *) &((ppc::front::FrontConfig const *)arg1)->grpcConfig(); + { + std::shared_ptr< ppc::protocol::GrpcConfig > *smartresult = *result ? new std::shared_ptr< ppc::protocol::GrpcConfig >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_generateNodeInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig const > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::INodeInfo::Ptr result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_generateNodeInfo" "', argument " "1"" of type '" "ppc::front::FrontConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::front::FrontConfig const *)arg1)->generateNodeInfo(); + resultobj = SWIG_NewPointerObj((new ppc::protocol::INodeInfo::Ptr(result)), SWIGTYPE_p_ppc__protocol__INodeInfo__Ptr, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_getComponents(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig const > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< std::string,std::allocator< std::string > > *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_getComponents" "', argument " "1"" of type '" "ppc::front::FrontConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::vector< std::string,std::allocator< std::string > > *) &((ppc::front::FrontConfig const *)arg1)->getComponents(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_setComponents(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "FrontConfig_setComponents", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_setComponents" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrontConfig_setComponents" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FrontConfig_setComponents" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); + } + arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2); + (arg1)->setComponents((std::vector< std::string,std::allocator< std::string > > const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_addComponent(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "FrontConfig_addComponent", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_addComponent" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrontConfig_addComponent" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FrontConfig_addComponent" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->addComponent((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfig_mutableComponents(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig *arg1 = (ppc::front::FrontConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::FrontConfig > tempshared1 ; + std::shared_ptr< ppc::front::FrontConfig > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::vector< std::string,std::allocator< std::string > > *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfig_mutableComponents" "', argument " "1"" of type '" "ppc::front::FrontConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::FrontConfig > * >(argp1); + arg1 = const_cast< ppc::front::FrontConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::vector< std::string,std::allocator< std::string > > *) &(arg1)->mutableComponents(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *FrontConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_FrontConfigBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfigBuilder *arg1 = (ppc::front::FrontConfigBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__front__FrontConfigBuilder, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FrontConfigBuilder" "', argument " "1"" of type '" "ppc::front::FrontConfigBuilder *""'"); + } + arg1 = reinterpret_cast< ppc::front::FrontConfigBuilder * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfigBuilder_build__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::front::FrontConfigBuilder *arg1 = (ppc::front::FrontConfigBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ppc::front::FrontConfig::Ptr result; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__front__FrontConfigBuilder, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfigBuilder_build" "', argument " "1"" of type '" "ppc::front::FrontConfigBuilder const *""'"); + } + arg1 = reinterpret_cast< ppc::front::FrontConfigBuilder * >(argp1); + result = ((ppc::front::FrontConfigBuilder const *)arg1)->build(); + { + std::shared_ptr< ppc::front::FrontConfig > *smartresult = result ? new std::shared_ptr< ppc::front::FrontConfig >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfigBuilder_build__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::front::FrontConfigBuilder *arg1 = (ppc::front::FrontConfigBuilder *) 0 ; + int arg2 ; + std::string arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + ppc::front::FrontConfig::Ptr result; + + (void)self; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__front__FrontConfigBuilder, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrontConfigBuilder_build" "', argument " "1"" of type '" "ppc::front::FrontConfigBuilder const *""'"); + } + arg1 = reinterpret_cast< ppc::front::FrontConfigBuilder * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FrontConfigBuilder_build" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FrontConfigBuilder_build" "', argument " "3"" of type '" "std::string""'"); + } + arg3 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = ((ppc::front::FrontConfigBuilder const *)arg1)->build(arg2,arg3); + { + std::shared_ptr< ppc::front::FrontConfig > *smartresult = result ? new std::shared_ptr< ppc::front::FrontConfig >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FrontConfigBuilder_build(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "FrontConfigBuilder_build", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ppc__front__FrontConfigBuilder, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FrontConfigBuilder_build__SWIG_0(self, argc, argv); + } + } + if (argc == 3) { + int _v = 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ppc__front__FrontConfigBuilder, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FrontConfigBuilder_build__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FrontConfigBuilder_build'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::front::FrontConfigBuilder::build() const\n" + " ppc::front::FrontConfigBuilder::build(int,std::string) const\n"); + return 0; +} + + +SWIGINTERN PyObject *FrontConfigBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ppc__front__FrontConfigBuilder, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_printFrontDesc(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig::Ptr *arg1 = 0 ; + void *argp1 ; + int res1 = 0 ; + ppc::front::FrontConfig::Ptr tempshared1 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printFrontDesc" "', argument " "1"" of type '" "ppc::front::FrontConfig::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< ppc::front::FrontConfig::Ptr * >(argp1); + delete reinterpret_cast< ppc::front::FrontConfig::Ptr * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< ppc::front::FrontConfig::Ptr * >(argp1) : &tempshared1; + } + } + result = ppc::front::printFrontDesc((std::shared_ptr< ppc::front::FrontConfig > const &)*arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_EndPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *result = 0 ; + + (void)self; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (ppc::protocol::EndPoint *)new ppc::protocol::EndPoint(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__EndPoint, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_EndPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::string *arg1 = 0 ; + uint16_t arg2 ; + int res1 = SWIG_OLDOBJ ; + unsigned short val2 ; + int ecode2 = 0 ; + ppc::protocol::EndPoint *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + std::string *ptr = (std::string *)0; + res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndPoint" "', argument " "1"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndPoint" "', argument " "1"" of type '" "std::string const &""'"); + } + arg1 = ptr; + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EndPoint" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + result = (ppc::protocol::EndPoint *)new ppc::protocol::EndPoint((std::string const &)*arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__EndPoint, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_EndPoint(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_EndPoint", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_EndPoint__SWIG_0(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_EndPoint__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EndPoint'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::EndPoint::EndPoint()\n" + " ppc::protocol::EndPoint::EndPoint(std::string const &,uint16_t)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_EndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndPoint" "', argument " "1"" of type '" "ppc::protocol::EndPoint *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_host(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_host" "', argument " "1"" of type '" "ppc::protocol::EndPoint const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + result = (std::string *) &((ppc::protocol::EndPoint const *)arg1)->host(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_port(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_port" "', argument " "1"" of type '" "ppc::protocol::EndPoint const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + result = (uint16_t)((ppc::protocol::EndPoint const *)arg1)->port(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_setHost(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "EndPoint_setHost", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_setHost" "', argument " "1"" of type '" "ppc::protocol::EndPoint *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "EndPoint_setHost" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setHost(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_setPort(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "EndPoint_setPort", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_setPort" "', argument " "1"" of type '" "ppc::protocol::EndPoint *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EndPoint_setPort" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setPort(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_setListenIp(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "EndPoint_setListenIp", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_setListenIp" "', argument " "1"" of type '" "ppc::protocol::EndPoint *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EndPoint_setListenIp" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EndPoint_setListenIp" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setListenIp((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_entryPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_entryPoint" "', argument " "1"" of type '" "ppc::protocol::EndPoint const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + result = ((ppc::protocol::EndPoint const *)arg1)->entryPoint(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_listenEndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_listenEndPoint" "', argument " "1"" of type '" "ppc::protocol::EndPoint const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + result = ((ppc::protocol::EndPoint const *)arg1)->listenEndPoint(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_EndPoint_listenIp(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint *arg1 = (ppc::protocol::EndPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndPoint_listenIp" "', argument " "1"" of type '" "ppc::protocol::EndPoint const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + result = (std::string *) &((ppc::protocol::EndPoint const *)arg1)->listenIp(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *EndPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ppc__protocol__EndPoint, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *EndPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GrpcServerConfig__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *result = 0 ; + + (void)self; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + result = (ppc::protocol::GrpcServerConfig *)new ppc::protocol::GrpcServerConfig(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__GrpcServerConfig, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GrpcServerConfig__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::EndPoint arg1 ; + bool arg2 ; + void *argp1 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + ppc::protocol::GrpcServerConfig *result = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GrpcServerConfig" "', argument " "1"" of type '" "ppc::protocol::EndPoint""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GrpcServerConfig" "', argument " "1"" of type '" "ppc::protocol::EndPoint""'"); + } else { + ppc::protocol::EndPoint * temp = reinterpret_cast< ppc::protocol::EndPoint * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; + } + } + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GrpcServerConfig" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + result = (ppc::protocol::GrpcServerConfig *)new ppc::protocol::GrpcServerConfig(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__GrpcServerConfig, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GrpcServerConfig(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GrpcServerConfig", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_GrpcServerConfig__SWIG_0(self, argc, argv); + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ppc__protocol__EndPoint, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_GrpcServerConfig__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GrpcServerConfig'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::GrpcServerConfig::GrpcServerConfig()\n" + " ppc::protocol::GrpcServerConfig::GrpcServerConfig(ppc::protocol::EndPoint,bool)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GrpcServerConfig_listenEndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *arg1 = (ppc::protocol::GrpcServerConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__GrpcServerConfig, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcServerConfig_listenEndPoint" "', argument " "1"" of type '" "ppc::protocol::GrpcServerConfig const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::GrpcServerConfig * >(argp1); + result = ((ppc::protocol::GrpcServerConfig const *)arg1)->listenEndPoint(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcServerConfig_setEndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *arg1 = (ppc::protocol::GrpcServerConfig *) 0 ; + ppc::protocol::EndPoint arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "GrpcServerConfig_setEndPoint", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__GrpcServerConfig, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcServerConfig_setEndPoint" "', argument " "1"" of type '" "ppc::protocol::GrpcServerConfig *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::GrpcServerConfig * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GrpcServerConfig_setEndPoint" "', argument " "2"" of type '" "ppc::protocol::EndPoint""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GrpcServerConfig_setEndPoint" "', argument " "2"" of type '" "ppc::protocol::EndPoint""'"); + } else { + ppc::protocol::EndPoint * temp = reinterpret_cast< ppc::protocol::EndPoint * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setEndPoint(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcServerConfig_setEnableHealthCheck(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *arg1 = (ppc::protocol::GrpcServerConfig *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "GrpcServerConfig_setEnableHealthCheck", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__GrpcServerConfig, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcServerConfig_setEnableHealthCheck" "', argument " "1"" of type '" "ppc::protocol::GrpcServerConfig *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::GrpcServerConfig * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GrpcServerConfig_setEnableHealthCheck" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->setEnableHealthCheck(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcServerConfig_endPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *arg1 = (ppc::protocol::GrpcServerConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::EndPoint *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__GrpcServerConfig, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcServerConfig_endPoint" "', argument " "1"" of type '" "ppc::protocol::GrpcServerConfig const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::GrpcServerConfig * >(argp1); + result = (ppc::protocol::EndPoint *) &((ppc::protocol::GrpcServerConfig const *)arg1)->endPoint(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcServerConfig_mutableEndPoint(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *arg1 = (ppc::protocol::GrpcServerConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::EndPoint *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__GrpcServerConfig, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcServerConfig_mutableEndPoint" "', argument " "1"" of type '" "ppc::protocol::GrpcServerConfig *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::GrpcServerConfig * >(argp1); + result = (ppc::protocol::EndPoint *) &(arg1)->mutableEndPoint(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__EndPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcServerConfig_enableHealthCheck(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *arg1 = (ppc::protocol::GrpcServerConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__GrpcServerConfig, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcServerConfig_enableHealthCheck" "', argument " "1"" of type '" "ppc::protocol::GrpcServerConfig const *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::GrpcServerConfig * >(argp1); + result = (bool)((ppc::protocol::GrpcServerConfig const *)arg1)->enableHealthCheck(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GrpcServerConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcServerConfig *arg1 = (ppc::protocol::GrpcServerConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__protocol__GrpcServerConfig, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GrpcServerConfig" "', argument " "1"" of type '" "ppc::protocol::GrpcServerConfig *""'"); + } + arg1 = reinterpret_cast< ppc::protocol::GrpcServerConfig * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GrpcServerConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ppc__protocol__GrpcServerConfig, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GrpcServerConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GrpcConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_GrpcConfig", 0, 0, 0)) SWIG_fail; + result = (ppc::protocol::GrpcConfig *)new ppc::protocol::GrpcConfig(); + { + std::shared_ptr< ppc::protocol::GrpcConfig > *smartresult = result ? new std::shared_ptr< ppc::protocol::GrpcConfig >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GrpcConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *arg1 = (ppc::protocol::GrpcConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig > tempshared1 ; + std::shared_ptr< ppc::protocol::GrpcConfig > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GrpcConfig" "', argument " "1"" of type '" "ppc::protocol::GrpcConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcConfig_loadBalancePolicy(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *arg1 = (ppc::protocol::GrpcConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig const > tempshared1 ; + std::shared_ptr< ppc::protocol::GrpcConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcConfig_loadBalancePolicy" "', argument " "1"" of type '" "ppc::protocol::GrpcConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::GrpcConfig const *)arg1)->loadBalancePolicy(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcConfig_setLoadBalancePolicy(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *arg1 = (ppc::protocol::GrpcConfig *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig > tempshared1 ; + std::shared_ptr< ppc::protocol::GrpcConfig > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "GrpcConfig_setLoadBalancePolicy", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcConfig_setLoadBalancePolicy" "', argument " "1"" of type '" "ppc::protocol::GrpcConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GrpcConfig_setLoadBalancePolicy" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GrpcConfig_setLoadBalancePolicy" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setLoadBalancePolicy((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcConfig_enableHealthCheck(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *arg1 = (ppc::protocol::GrpcConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig const > tempshared1 ; + std::shared_ptr< ppc::protocol::GrpcConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcConfig_enableHealthCheck" "', argument " "1"" of type '" "ppc::protocol::GrpcConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bool)((ppc::protocol::GrpcConfig const *)arg1)->enableHealthCheck(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcConfig_setEnableHealthCheck(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *arg1 = (ppc::protocol::GrpcConfig *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig > tempshared1 ; + std::shared_ptr< ppc::protocol::GrpcConfig > *smartarg1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "GrpcConfig_setEnableHealthCheck", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcConfig_setEnableHealthCheck" "', argument " "1"" of type '" "ppc::protocol::GrpcConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GrpcConfig_setEnableHealthCheck" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->setEnableHealthCheck(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcConfig_setEnableDnslookup(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *arg1 = (ppc::protocol::GrpcConfig *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig > tempshared1 ; + std::shared_ptr< ppc::protocol::GrpcConfig > *smartarg1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "GrpcConfig_setEnableDnslookup", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcConfig_setEnableDnslookup" "', argument " "1"" of type '" "ppc::protocol::GrpcConfig *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GrpcConfig_setEnableDnslookup" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->setEnableDnslookup(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GrpcConfig_enableDnslookup(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::GrpcConfig *arg1 = (ppc::protocol::GrpcConfig *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::GrpcConfig const > tempshared1 ; + std::shared_ptr< ppc::protocol::GrpcConfig const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GrpcConfig_enableDnslookup" "', argument " "1"" of type '" "ppc::protocol::GrpcConfig const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::GrpcConfig > * >(argp1); + arg1 = const_cast< ppc::protocol::GrpcConfig * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bool)((ppc::protocol::GrpcConfig const *)arg1)->enableDnslookup(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GrpcConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GrpcConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_delete_MessageOptionalHeader(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageOptionalHeader" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_encode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::shared_ptr< bcos::bytes > tempshared2 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_encode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_encode" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared2 = *reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + delete reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + arg2 = const_cast< bcos::bytes * >(tempshared2.get()); + } else { + arg2 = const_cast< bcos::bytes * >(reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2)->get()); + } + } + ((ppc::protocol::MessageOptionalHeader const *)arg1)->encode(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_decode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + bcos::bytesConstRef arg2 ; + uint64_t arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + unsigned long long val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + int64_t result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_decode", 3, 3, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_decode" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__bytesConstRef, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } else { + bcos::bytesConstRef * temp = reinterpret_cast< bcos::bytesConstRef * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageOptionalHeader_decode" "', argument " "3"" of type '" "uint64_t""'"); + } + arg3 = static_cast< uint64_t >(val3); + result = (int64_t)(arg1)->decode(arg2,arg3); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_componentType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_componentType" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessageOptionalHeader const *)arg1)->componentType(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setComponentType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_setComponentType", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setComponentType" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MessageOptionalHeader_setComponentType" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setComponentType(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_srcNode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bcos::bytes *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_srcNode" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bcos::bytes *) &((ppc::protocol::MessageOptionalHeader const *)arg1)->srcNode(); + { + std::shared_ptr< const bcos::bytes > *smartresult = new std::shared_ptr< const bcos::bytes >(result SWIG_NO_NULL_DELETER_0); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_srcNodeBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + OutputBuffer result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_srcNodeBuffer" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessageOptionalHeader const *)arg1)->srcNodeBuffer(); + { + resultobj = PyBytes_FromStringAndSize((const char *)(&result)->data, (&result)->len); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setSrcNode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::shared_ptr< bcos::bytes const > tempshared2 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setSrcNode" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_setSrcNode" "', argument " "2"" of type '" "bcos::bytes const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_setSrcNode" "', argument " "2"" of type '" "bcos::bytes const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared2 = *reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2); + delete reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2); + arg2 = const_cast< bcos::bytes * >(tempshared2.get()); + } else { + arg2 = const_cast< bcos::bytes * >(reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2)->get()); + } + } + (arg1)->setSrcNode((bcos::bytes const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setSrcNode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + char *arg2 = (char *) 0 ; + uint64_t arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setSrcNode" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int res; Py_ssize_t size = 0; const void *buf = 0; +#ifndef Py_LIMITED_API + Py_buffer view; + res = PyObject_GetBuffer(swig_obj[1], &view, PyBUF_CONTIG_RO); +#else +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated" +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable: 4996) +#endif + res = PyObject_AsReadBuffer(swig_obj[1], &buf, &size); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +#endif + if (res < 0) { + PyErr_Clear(); + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "MessageOptionalHeader_setSrcNode" "', argument " "2"" of type '" "(char* data, uint64_t length)""'"); + } +#ifndef Py_LIMITED_API + size = view.len; + buf = view.buf; + PyBuffer_Release(&view); +#endif + arg2 = (char *) buf; + arg3 = (uint64_t) (size / sizeof(char)); + } + (arg1)->setSrcNode(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setSrcNode(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_setSrcNode", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageOptionalHeader_setSrcNode__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_MessageOptionalHeader_setSrcNode__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MessageOptionalHeader_setSrcNode__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MessageOptionalHeader_setSrcNode'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::MessageOptionalHeader::setSrcNode(bcos::bytes const &)\n" + " ppc::protocol::MessageOptionalHeader::setSrcNode(char *,uint64_t)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_dstNode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bcos::bytes *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_dstNode" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bcos::bytes *) &((ppc::protocol::MessageOptionalHeader const *)arg1)->dstNode(); + { + std::shared_ptr< const bcos::bytes > *smartresult = new std::shared_ptr< const bcos::bytes >(result SWIG_NO_NULL_DELETER_0); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_dstNodeBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + OutputBuffer result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_dstNodeBuffer" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessageOptionalHeader const *)arg1)->dstNodeBuffer(); + { + resultobj = PyBytes_FromStringAndSize((const char *)(&result)->data, (&result)->len); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setDstNode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::shared_ptr< bcos::bytes const > tempshared2 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_setDstNode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setDstNode" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_setDstNode" "', argument " "2"" of type '" "bcos::bytes const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_setDstNode" "', argument " "2"" of type '" "bcos::bytes const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared2 = *reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2); + delete reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2); + arg2 = const_cast< bcos::bytes * >(tempshared2.get()); + } else { + arg2 = const_cast< bcos::bytes * >(reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2)->get()); + } + } + (arg1)->setDstNode((bcos::bytes const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setDstNodeBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + char *arg2 = (char *) 0 ; + uint64_t arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_setDstNodeBuffer", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setDstNodeBuffer" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int res; Py_ssize_t size = 0; const void *buf = 0; +#ifndef Py_LIMITED_API + Py_buffer view; + res = PyObject_GetBuffer(swig_obj[1], &view, PyBUF_CONTIG_RO); +#else +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated" +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable: 4996) +#endif + res = PyObject_AsReadBuffer(swig_obj[1], &buf, &size); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +#endif + if (res < 0) { + PyErr_Clear(); + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "MessageOptionalHeader_setDstNodeBuffer" "', argument " "2"" of type '" "(char* data, uint64_t length)""'"); + } +#ifndef Py_LIMITED_API + size = view.len; + buf = view.buf; + PyBuffer_Release(&view); +#endif + arg2 = (char *) buf; + arg3 = (uint64_t) (size / sizeof(char)); + } + (arg1)->setDstNodeBuffer(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_dstInst(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_dstInst" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::MessageOptionalHeader const *)arg1)->dstInst(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setDstInst(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_setDstInst", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setDstInst" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_setDstInst" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_setDstInst" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setDstInst((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_topic(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_topic" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::MessageOptionalHeader const *)arg1)->topic(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setTopic__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::unique_ptr< std::string > rvrdeleter2 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setTopic" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, SWIG_POINTER_RELEASE | 0 ); + if (!SWIG_IsOK(res2)) { + if (res2 == SWIG_ERROR_RELEASE_NOT_OWNED) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_setTopic" "', cannot release ownership as memory is not owned for argument " "2"" of type '" "std::string &&""'"); + } else { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_setTopic" "', argument " "2"" of type '" "std::string &&""'"); + } + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_setTopic" "', argument " "2"" of type '" "std::string &&""'"); + } + arg2 = reinterpret_cast< std::string * >(argp2); + rvrdeleter2.reset(arg2); + (arg1)->setTopic((std::string &&)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setTopic__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setTopic" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_setTopic" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_setTopic" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setTopic((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setTopic(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_setTopic", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageOptionalHeader_setTopic__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageOptionalHeader_setTopic__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MessageOptionalHeader_setTopic'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::MessageOptionalHeader::setTopic(std::string &&)\n" + " ppc::protocol::MessageOptionalHeader::setTopic(std::string const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_srcInst(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_srcInst" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessageOptionalHeader const *)arg1)->srcInst(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeader_setSrcInst(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader *arg1 = (ppc::protocol::MessageOptionalHeader *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageOptionalHeader_setSrcInst", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeader_setSrcInst" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeader_setSrcInst" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageOptionalHeader_setSrcInst" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setSrcInst((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *MessageOptionalHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_MessageHeader(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageHeader" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_encode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::shared_ptr< bcos::bytes > tempshared2 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_encode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_encode" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeader_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageHeader_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared2 = *reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + delete reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + arg2 = const_cast< bcos::bytes * >(tempshared2.get()); + } else { + arg2 = const_cast< bcos::bytes * >(reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2)->get()); + } + } + ((ppc::protocol::MessageHeader const *)arg1)->encode(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_decode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + bcos::bytesConstRef arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int64_t result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_decode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_decode" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__bytesConstRef, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeader_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageHeader_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } else { + bcos::bytesConstRef * temp = reinterpret_cast< bcos::bytesConstRef * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (int64_t)(arg1)->decode(arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_version(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_version" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint8_t)((ppc::protocol::MessageHeader const *)arg1)->version(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setVersion(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setVersion", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setVersion" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageHeader_setVersion" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setVersion(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_traceID(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_traceID" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::MessageHeader const *)arg1)->traceID(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setTraceID(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setTraceID", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setTraceID" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MessageHeader_setTraceID" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setTraceID(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_srcGwNode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_srcGwNode" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::MessageHeader const *)arg1)->srcGwNode(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setSrcGwNode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setSrcGwNode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setSrcGwNode" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeader_setSrcGwNode" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageHeader_setSrcGwNode" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setSrcGwNode((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_dstGwNode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_dstGwNode" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::MessageHeader const *)arg1)->dstGwNode(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setDstGwNode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setDstGwNode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setDstGwNode" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeader_setDstGwNode" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageHeader_setDstGwNode" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setDstGwNode((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_packetType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_packetType" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::MessageHeader const *)arg1)->packetType(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setPacketType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setPacketType", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setPacketType" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageHeader_setPacketType" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setPacketType(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_ttl(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + int16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_ttl" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (int16_t)((ppc::protocol::MessageHeader const *)arg1)->ttl(); + resultobj = SWIG_From_short(static_cast< short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setTTL(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setTTL", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setTTL" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageHeader_setTTL" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setTTL(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_ext(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_ext" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::MessageHeader const *)arg1)->ext(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setExt(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setExt", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setExt" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageHeader_setExt" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setExt(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_optionalField(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::MessageOptionalHeader::Ptr result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_optionalField" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessageHeader const *)arg1)->optionalField(); + { + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessageOptionalHeader >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setOptionalField(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + ppc::protocol::MessageOptionalHeader::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setOptionalField", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setOptionalField" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeader_setOptionalField" "', argument " "2"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2); + } + (arg1)->setOptionalField(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_length(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_length" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::MessageHeader const *)arg1)->length(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_isRespPacket(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_isRespPacket" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bool)((ppc::protocol::MessageHeader const *)arg1)->isRespPacket(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setRespPacket(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setRespPacket" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (arg1)->setRespPacket(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_srcP2PNodeIDView(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string_view result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_srcP2PNodeIDView" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessageHeader const *)arg1)->srcP2PNodeIDView(); + resultobj = SWIG_NewPointerObj((new std::string_view(result)), SWIGTYPE_p_std__string_view, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_dstP2PNodeIDView(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string_view result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_dstP2PNodeIDView" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessageHeader const *)arg1)->dstP2PNodeIDView(); + resultobj = SWIG_NewPointerObj((new std::string_view(result)), SWIGTYPE_p_std__string_view, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_routeType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_routeType" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::MessageHeader const *)arg1)->routeType(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_setRouteType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + ppc::protocol::RouteType arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageHeader_setRouteType", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_setRouteType" "', argument " "1"" of type '" "ppc::protocol::MessageHeader *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ppc__protocol__RouteType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeader_setRouteType" "', argument " "2"" of type '" "ppc::protocol::RouteType""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageHeader_setRouteType" "', argument " "2"" of type '" "ppc::protocol::RouteType""'"); + } else { + ppc::protocol::RouteType * temp = reinterpret_cast< ppc::protocol::RouteType * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setRouteType(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeader_hasOptionalField(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeader *arg1 = (ppc::protocol::MessageHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeader const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeader const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeader_hasOptionalField" "', argument " "1"" of type '" "ppc::protocol::MessageHeader const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessageHeader > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeader * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bool)((ppc::protocol::MessageHeader const *)arg1)->hasOptionalField(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MessageHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_Message(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_header(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::MessageHeader::Ptr result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_header" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::Message const *)arg1)->header(); + { + std::shared_ptr< ppc::protocol::MessageHeader > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessageHeader >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setHeader(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + ppc::protocol::MessageHeader::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_setHeader", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setHeader" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_setHeader" "', argument " "2"" of type '" "ppc::protocol::MessageHeader::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< ppc::protocol::MessageHeader::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::protocol::MessageHeader::Ptr * >(argp2); + } + (arg1)->setHeader(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_version(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_version" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::Message const *)arg1)->version(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setVersion(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_setVersion", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setVersion" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_setVersion" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setVersion(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_packetType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_packetType" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::Message const *)arg1)->packetType(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setPacketType(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_setPacketType", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setPacketType" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_setPacketType" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setPacketType(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_seq(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_seq" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::Message const *)arg1)->seq(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setSeq(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + std::string arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_setSeq", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setSeq" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Message_setSeq" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + (arg1)->setSeq(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_ext(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_ext" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::Message const *)arg1)->ext(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setExt(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_setExt", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setExt" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_setExt" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setExt(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_isRespPacket(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isRespPacket" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bool)((ppc::protocol::Message const *)arg1)->isRespPacket(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setRespPacket(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setRespPacket" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (arg1)->setRespPacket(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_length(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint32_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_length" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint32_t)((ppc::protocol::Message const *)arg1)->length(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_payload(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::shared_ptr< bcos::bytes > result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_payload" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::Message const *)arg1)->payload(); + { + std::shared_ptr< bcos::bytes > *smartresult = result ? new std::shared_ptr< bcos::bytes >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_payloadBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + OutputBuffer result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_payloadBuffer" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::Message const *)arg1)->payloadBuffer(); + { + resultobj = PyBytes_FromStringAndSize((const char *)(&result)->data, (&result)->len); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setPayload(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + std::shared_ptr< bcos::bytes > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_setPayload", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setPayload" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_setPayload" "', argument " "2"" of type '" "std::shared_ptr< bcos::bytes >""'"); + } + if (argp2) arg2 = *(reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + } + (arg1)->setPayload(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_setFrontMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + ppc::protocol::MessagePayload::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_setFrontMessage", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setFrontMessage" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_setFrontMessage" "', argument " "2"" of type '" "ppc::protocol::MessagePayload::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< ppc::protocol::MessagePayload::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::protocol::MessagePayload::Ptr * >(argp2); + } + (arg1)->setFrontMessage(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_frontMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message const > tempshared1 ; + std::shared_ptr< ppc::protocol::Message const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::MessagePayload::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_frontMessage" "', argument " "1"" of type '" "ppc::protocol::Message const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::MessagePayload::Ptr *) &((ppc::protocol::Message const *)arg1)->frontMessage(); + { + std::shared_ptr< ppc::protocol::MessagePayload > *smartresult = *result ? new std::shared_ptr< ppc::protocol::MessagePayload >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_encode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::shared_ptr< bcos::bytes > tempshared2 ; + bool result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_encode" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared2 = *reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + delete reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + arg2 = const_cast< bcos::bytes * >(tempshared2.get()); + } else { + arg2 = const_cast< bcos::bytes * >(reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2)->get()); + } + } + result = (bool)(arg1)->encode(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_encode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + bcos::boostssl::EncodedMsg *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_encode" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__boostssl__EncodedMsg, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_encode" "', argument " "2"" of type '" "bcos::boostssl::EncodedMsg &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_encode" "', argument " "2"" of type '" "bcos::boostssl::EncodedMsg &""'"); + } + arg2 = reinterpret_cast< bcos::boostssl::EncodedMsg * >(argp2); + result = (bool)(arg1)->encode(*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Message_encode(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Message_encode", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Message_encode__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bcos__boostssl__EncodedMsg, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Message_encode__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Message_encode'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::Message::encode(bcos::bytes &)\n" + " ppc::protocol::Message::encode(bcos::boostssl::EncodedMsg &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Message_decode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message *arg1 = (ppc::protocol::Message *) 0 ; + bcos::bytesConstRef arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::Message > tempshared1 ; + std::shared_ptr< ppc::protocol::Message > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int64_t result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "Message_decode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_decode" "', argument " "1"" of type '" "ppc::protocol::Message *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::Message > * >(argp1); + arg1 = const_cast< ppc::protocol::Message * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__bytesConstRef, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } else { + bcos::bytesConstRef * temp = reinterpret_cast< bcos::bytesConstRef * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (int64_t)(arg1)->decode(arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_MessageHeaderBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeaderBuilder *arg1 = (ppc::protocol::MessageHeaderBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageHeaderBuilder" "', argument " "1"" of type '" "ppc::protocol::MessageHeaderBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeaderBuilder_build__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeaderBuilder *arg1 = (ppc::protocol::MessageHeaderBuilder *) 0 ; + bcos::bytesConstRef arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + ppc::protocol::MessageHeader::Ptr result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeaderBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageHeaderBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__bytesConstRef, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeaderBuilder_build" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageHeaderBuilder_build" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } else { + bcos::bytesConstRef * temp = reinterpret_cast< bcos::bytesConstRef * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (arg1)->build(arg2); + { + std::shared_ptr< ppc::protocol::MessageHeader > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessageHeader >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeaderBuilder_build__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeaderBuilder *arg1 = (ppc::protocol::MessageHeaderBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *smartarg1 = 0 ; + ppc::protocol::MessageHeader::Ptr result; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeaderBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageHeaderBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (arg1)->build(); + { + std::shared_ptr< ppc::protocol::MessageHeader > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessageHeader >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeader_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeaderBuilder_build__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageHeaderBuilder *arg1 = (ppc::protocol::MessageHeaderBuilder *) 0 ; + ppc::protocol::MessageOptionalHeader::Ptr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + ppc::protocol::MessageOptionalHeader::Ptr tempshared2 ; + ppc::protocol::MessageOptionalHeader::Ptr result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageHeaderBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageHeaderBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageHeaderBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageHeaderBuilder_build" "', argument " "2"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp2) tempshared2 = *reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2); + delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2); + arg2 = &tempshared2; + } else { + arg2 = (argp2) ? reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2) : &tempshared2; + } + } + result = (arg1)->build((ppc::protocol::MessageOptionalHeader::Ptr const &)*arg2); + { + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessageOptionalHeader >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageHeaderBuilder_build(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MessageHeaderBuilder_build", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageHeaderBuilder_build__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bcos__bytesConstRef, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageHeaderBuilder_build__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageHeaderBuilder_build__SWIG_2(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MessageHeaderBuilder_build'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::MessageHeaderBuilder::build(bcos::bytesConstRef)\n" + " ppc::protocol::MessageHeaderBuilder::build()\n" + " ppc::protocol::MessageHeaderBuilder::build(ppc::protocol::MessageOptionalHeader::Ptr const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *MessageHeaderBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_MessageBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageBuilder *arg1 = (ppc::protocol::MessageBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageBuilder > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageBuilder" "', argument " "1"" of type '" "ppc::protocol::MessageBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageBuilder_build__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageBuilder *arg1 = (ppc::protocol::MessageBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageBuilder > *smartarg1 = 0 ; + ppc::protocol::Message::Ptr result; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (arg1)->build(); + { + std::shared_ptr< ppc::protocol::Message > *smartresult = result ? new std::shared_ptr< ppc::protocol::Message >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageBuilder_build__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageBuilder *arg1 = (ppc::protocol::MessageBuilder *) 0 ; + bcos::bytesConstRef arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageBuilder > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + ppc::protocol::Message::Ptr result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__bytesConstRef, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageBuilder_build" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageBuilder_build" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } else { + bcos::bytesConstRef * temp = reinterpret_cast< bcos::bytesConstRef * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (arg1)->build(arg2); + { + std::shared_ptr< ppc::protocol::Message > *smartresult = result ? new std::shared_ptr< ppc::protocol::Message >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageBuilder_build__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageBuilder *arg1 = (ppc::protocol::MessageBuilder *) 0 ; + ppc::protocol::RouteType arg2 ; + ppc::protocol::MessageOptionalHeader::Ptr *arg3 = 0 ; + bcos::bytes *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageBuilder > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + ppc::protocol::MessageOptionalHeader::Ptr tempshared3 ; + void *argp4 = 0 ; + int res4 = 0 ; + std::unique_ptr< bcos::bytes > rvrdeleter4 ; + ppc::protocol::Message::Ptr result; + + (void)self; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ppc__protocol__RouteType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageBuilder_build" "', argument " "2"" of type '" "ppc::protocol::RouteType""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageBuilder_build" "', argument " "2"" of type '" "ppc::protocol::RouteType""'"); + } else { + ppc::protocol::RouteType * temp = reinterpret_cast< ppc::protocol::RouteType * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + { + int newmem = 0; + res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageBuilder_build" "', argument " "3"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp3) tempshared3 = *reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + arg3 = &tempshared3; + } else { + arg3 = (argp3) ? reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3) : &tempshared3; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_RELEASE | 0 ); + if (!SWIG_IsOK(res4)) { + if (res4 == SWIG_ERROR_RELEASE_NOT_OWNED) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBuilder_build" "', cannot release ownership as memory is not owned for argument " "4"" of type '" "bcos::bytes &&""'"); + } else { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBuilder_build" "', argument " "4"" of type '" "bcos::bytes &&""'"); + } + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageBuilder_build" "', argument " "4"" of type '" "bcos::bytes &&""'"); + } + arg4 = reinterpret_cast< bcos::bytes * >(argp4); + rvrdeleter4.reset(arg4); + result = (arg1)->build(arg2,(ppc::protocol::MessageOptionalHeader::Ptr const &)*arg3,(bcos::bytes &&)*arg4); + { + std::shared_ptr< ppc::protocol::Message > *smartresult = result ? new std::shared_ptr< ppc::protocol::Message >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageBuilder_build(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MessageBuilder_build", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageBuilder_build__SWIG_0(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bcos__bytesConstRef, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageBuilder_build__SWIG_1(self, argc, argv); + } + } + } + if (argc == 4) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ppc__protocol__RouteType, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageBuilder_build__SWIG_2(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MessageBuilder_build'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::MessageBuilder::build()\n" + " ppc::protocol::MessageBuilder::build(bcos::bytesConstRef)\n" + " ppc::protocol::MessageBuilder::build(ppc::protocol::RouteType,ppc::protocol::MessageOptionalHeader::Ptr const &,bcos::bytes &&)\n"); + return 0; +} + + +SWIGINTERN PyObject *MessageBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_MessageOptionalHeaderBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeaderBuilder *arg1 = (ppc::protocol::MessageOptionalHeaderBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageOptionalHeaderBuilder" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeaderBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeaderBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeaderBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeaderBuilder_build__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeaderBuilder *arg1 = (ppc::protocol::MessageOptionalHeaderBuilder *) 0 ; + ppc::protocol::MessageOptionalHeader::Ptr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + ppc::protocol::MessageOptionalHeader::Ptr tempshared2 ; + ppc::protocol::MessageOptionalHeader::Ptr result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeaderBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeaderBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeaderBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeaderBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageOptionalHeaderBuilder_build" "', argument " "2"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp2) tempshared2 = *reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2); + delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2); + arg2 = &tempshared2; + } else { + arg2 = (argp2) ? reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp2) : &tempshared2; + } + } + result = (arg1)->build((ppc::protocol::MessageOptionalHeader::Ptr const &)*arg2); + { + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessageOptionalHeader >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeaderBuilder_build__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeaderBuilder *arg1 = (ppc::protocol::MessageOptionalHeaderBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *smartarg1 = 0 ; + ppc::protocol::MessageOptionalHeader::Ptr result; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageOptionalHeaderBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeaderBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeaderBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessageOptionalHeaderBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (arg1)->build(); + { + std::shared_ptr< ppc::protocol::MessageOptionalHeader > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessageOptionalHeader >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageOptionalHeaderBuilder_build(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MessageOptionalHeaderBuilder_build", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageOptionalHeaderBuilder_build__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessageOptionalHeaderBuilder_build__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MessageOptionalHeaderBuilder_build'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::MessageOptionalHeaderBuilder::build(ppc::protocol::MessageOptionalHeader::Ptr const &)\n" + " ppc::protocol::MessageOptionalHeaderBuilder::build()\n"); + return 0; +} + + +SWIGINTERN PyObject *MessageOptionalHeaderBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_printOptionalField(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessageOptionalHeader::Ptr arg1 ; + void *argp1 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printOptionalField" "', argument " "1"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr""'"); + } + if (argp1) arg1 = *(reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp1)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp1); + } + result = ppc::protocol::printOptionalField(SWIG_STD_MOVE(arg1)); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_printMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::Message::Ptr *arg1 = 0 ; + void *argp1 ; + int res1 = 0 ; + ppc::protocol::Message::Ptr tempshared1 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printMessage" "', argument " "1"" of type '" "ppc::protocol::Message::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp1) tempshared1 = *reinterpret_cast< ppc::protocol::Message::Ptr * >(argp1); + delete reinterpret_cast< ppc::protocol::Message::Ptr * >(argp1); + arg1 = &tempshared1; + } else { + arg1 = (argp1) ? reinterpret_cast< ppc::protocol::Message::Ptr * >(argp1) : &tempshared1; + } + } + result = ppc::protocol::printMessage((std::shared_ptr< ppc::protocol::Message > const &)*arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_printWsMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + bcos::boostssl::MessageFace::Ptr *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + std::string result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bcos__boostssl__MessageFace__Ptr, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printWsMessage" "', argument " "1"" of type '" "bcos::boostssl::MessageFace::Ptr const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "printWsMessage" "', argument " "1"" of type '" "bcos::boostssl::MessageFace::Ptr const &""'"); + } + arg1 = reinterpret_cast< bcos::boostssl::MessageFace::Ptr * >(argp1); + result = ppc::protocol::printWsMessage((bcos::boostssl::MessageFace::Ptr const &)*arg1); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MessagePayload(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessagePayload" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_encode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::shared_ptr< bcos::bytes > tempshared2 ; + PyObject *swig_obj[2] ; + int64_t result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessagePayload_encode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_encode" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessagePayload_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessagePayload_encode" "', argument " "2"" of type '" "bcos::bytes &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared2 = *reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + delete reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + arg2 = const_cast< bcos::bytes * >(tempshared2.get()); + } else { + arg2 = const_cast< bcos::bytes * >(reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2)->get()); + } + } + result = (int64_t)((ppc::protocol::MessagePayload const *)arg1)->encode(*arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_decode(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + bcos::bytesConstRef arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + int64_t result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessagePayload_decode", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_decode" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__bytesConstRef, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessagePayload_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessagePayload_decode" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } else { + bcos::bytesConstRef * temp = reinterpret_cast< bcos::bytesConstRef * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (int64_t)(arg1)->decode(arg2); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_version(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint8_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_version" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint8_t)((ppc::protocol::MessagePayload const *)arg1)->version(); + resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setVersion(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + uint8_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + unsigned char val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessagePayload_setVersion", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_setVersion" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessagePayload_setVersion" "', argument " "2"" of type '" "uint8_t""'"); + } + arg2 = static_cast< uint8_t >(val2); + (arg1)->setVersion(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_data(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bcos::bytes *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_data" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bcos::bytes *) &((ppc::protocol::MessagePayload const *)arg1)->data(); + { + std::shared_ptr< const bcos::bytes > *smartresult = new std::shared_ptr< const bcos::bytes >(result SWIG_NO_NULL_DELETER_0); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_dataBuffer(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + OutputBuffer result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_dataBuffer" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = ((ppc::protocol::MessagePayload const *)arg1)->dataBuffer(); + { + resultobj = PyBytes_FromStringAndSize((const char *)(&result)->data, (&result)->len); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setData__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::unique_ptr< bcos::bytes > rvrdeleter2 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_setData" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_RELEASE | 0 ); + if (!SWIG_IsOK(res2)) { + if (res2 == SWIG_ERROR_RELEASE_NOT_OWNED) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessagePayload_setData" "', cannot release ownership as memory is not owned for argument " "2"" of type '" "bcos::bytes &&""'"); + } else { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessagePayload_setData" "', argument " "2"" of type '" "bcos::bytes &&""'"); + } + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessagePayload_setData" "', argument " "2"" of type '" "bcos::bytes &&""'"); + } + arg2 = reinterpret_cast< bcos::bytes * >(argp2); + rvrdeleter2.reset(arg2); + (arg1)->setData((bcos::bytes &&)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setData__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + bcos::bytes *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::shared_ptr< bcos::bytes const > tempshared2 ; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_setData" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessagePayload_setData" "', argument " "2"" of type '" "bcos::bytes const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessagePayload_setData" "', argument " "2"" of type '" "bcos::bytes const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared2 = *reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2); + delete reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2); + arg2 = const_cast< bcos::bytes * >(tempshared2.get()); + } else { + arg2 = const_cast< bcos::bytes * >(reinterpret_cast< std::shared_ptr< const bcos::bytes > * >(argp2)->get()); + } + } + (arg1)->setData((bcos::bytes const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MessagePayload_setData", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessagePayload_setData__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessagePayload_setData__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MessagePayload_setData'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::MessagePayload::setData(bcos::bytes &&)\n" + " ppc::protocol::MessagePayload::setData(bcos::bytes const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_seq(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_seq" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::MessagePayload const *)arg1)->seq(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setSeq(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessagePayload_setSeq", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_setSeq" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessagePayload_setSeq" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setSeq(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_length(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + int64_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_length" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (int64_t)((ppc::protocol::MessagePayload const *)arg1)->length(); + resultobj = SWIG_From_long_SS_long(static_cast< long long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_traceID(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + std::string *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_traceID" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (std::string *) &((ppc::protocol::MessagePayload const *)arg1)->traceID(); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setTraceID(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessagePayload_setTraceID", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_setTraceID" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessagePayload_setTraceID" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessagePayload_setTraceID" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setTraceID((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_ext(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload const > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + uint16_t result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_ext" "', argument " "1"" of type '" "ppc::protocol::MessagePayload const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (uint16_t)((ppc::protocol::MessagePayload const *)arg1)->ext(); + resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setExt(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + uint16_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessagePayload_setExt", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_setExt" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessagePayload_setExt" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + (arg1)->setExt(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_setRespPacket(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_setRespPacket" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (arg1)->setRespPacket(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayload_isRespPacket(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayload *arg1 = (ppc::protocol::MessagePayload *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayload > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayload > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayload_isRespPacket" "', argument " "1"" of type '" "ppc::protocol::MessagePayload *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayload > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayload * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (bool)(arg1)->isRespPacket(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MessagePayload_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_MessagePayloadBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayloadBuilder *arg1 = (ppc::protocol::MessagePayloadBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessagePayloadBuilder" "', argument " "1"" of type '" "ppc::protocol::MessagePayloadBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayloadBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayloadBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayloadBuilder_build__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayloadBuilder *arg1 = (ppc::protocol::MessagePayloadBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *smartarg1 = 0 ; + ppc::protocol::MessagePayload::Ptr result; + + (void)self; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayloadBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessagePayloadBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayloadBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayloadBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (arg1)->build(); + { + std::shared_ptr< ppc::protocol::MessagePayload > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessagePayload >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayloadBuilder_build__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + ppc::protocol::MessagePayloadBuilder *arg1 = (ppc::protocol::MessagePayloadBuilder *) 0 ; + bcos::bytesConstRef arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > tempshared1 ; + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + ppc::protocol::MessagePayload::Ptr result; + + (void)self; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessagePayloadBuilder_build" "', argument " "1"" of type '" "ppc::protocol::MessagePayloadBuilder *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayloadBuilder * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::protocol::MessagePayloadBuilder > * >(argp1); + arg1 = const_cast< ppc::protocol::MessagePayloadBuilder * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bcos__bytesConstRef, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessagePayloadBuilder_build" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessagePayloadBuilder_build" "', argument " "2"" of type '" "bcos::bytesConstRef""'"); + } else { + bcos::bytesConstRef * temp = reinterpret_cast< bcos::bytesConstRef * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + result = (arg1)->build(arg2); + { + std::shared_ptr< ppc::protocol::MessagePayload > *smartresult = result ? new std::shared_ptr< ppc::protocol::MessagePayload >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayload_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessagePayloadBuilder_build(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MessagePayloadBuilder_build", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessagePayloadBuilder_build__SWIG_0(self, argc, argv); + } + } + if (argc == 2) { + int _v = 0; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bcos__bytesConstRef, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MessagePayloadBuilder_build__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MessagePayloadBuilder_build'.\n" + " Possible C/C++ prototypes are:\n" + " ppc::protocol::MessagePayloadBuilder::build()\n" + " ppc::protocol::MessagePayloadBuilder::build(bcos::bytesConstRef)\n"); + return 0; +} + + +SWIGINTERN PyObject *MessagePayloadBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_IFrontClient(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFrontClient *arg1 = (ppc::front::IFrontClient *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFrontClient > tempshared1 ; + std::shared_ptr< ppc::front::IFrontClient > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IFrontClient" "', argument " "1"" of type '" "ppc::front::IFrontClient *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + arg1 = const_cast< ppc::front::IFrontClient * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + arg1 = const_cast< ppc::front::IFrontClient * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFrontClient_onReceiveMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFrontClient *arg1 = (ppc::front::IFrontClient *) 0 ; + ppc::protocol::Message::Ptr *arg2 = 0 ; + SwigValueWrapper< std::function< void (std::shared_ptr< bcos::Error >) > > arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFrontClient > tempshared1 ; + std::shared_ptr< ppc::front::IFrontClient > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + ppc::protocol::Message::Ptr tempshared2 ; + void *argp3 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFrontClient_onReceiveMessage", 3, 3, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrontClient_onReceiveMessage" "', argument " "1"" of type '" "ppc::front::IFrontClient *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + arg1 = const_cast< ppc::front::IFrontClient * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFrontClient > * >(argp1); + arg1 = const_cast< ppc::front::IFrontClient * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFrontClient_onReceiveMessage" "', argument " "2"" of type '" "ppc::protocol::Message::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp2) tempshared2 = *reinterpret_cast< ppc::protocol::Message::Ptr * >(argp2); + delete reinterpret_cast< ppc::protocol::Message::Ptr * >(argp2); + arg2 = &tempshared2; + } else { + arg2 = (argp2) ? reinterpret_cast< ppc::protocol::Message::Ptr * >(argp2) : &tempshared2; + } + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFrontClient_onReceiveMessage" "', argument " "3"" of type '" "ppc::protocol::ReceiveMsgFunc""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFrontClient_onReceiveMessage" "', argument " "3"" of type '" "ppc::protocol::ReceiveMsgFunc""'"); + } else { + ppc::protocol::ReceiveMsgFunc * temp = reinterpret_cast< ppc::protocol::ReceiveMsgFunc * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + (arg1)->onReceiveMessage((ppc::protocol::Message::Ptr const &)*arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IFrontClient_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_ErrorCallback(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + PyObject *arg1 = (PyObject *) 0 ; + PyObject *swig_obj[1] ; + ppc::front::ErrorCallback *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + arg1 = swig_obj[0]; + if ( arg1 != Py_None ) { + /* subclassed */ + result = (ppc::front::ErrorCallback *)new SwigDirector_ErrorCallback(arg1); + } else { + SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); + SWIG_fail; + } + + { + std::shared_ptr< ppc::front::ErrorCallback > *smartresult = result ? new std::shared_ptr< ppc::front::ErrorCallback >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ErrorCallback(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::ErrorCallback *arg1 = (ppc::front::ErrorCallback *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::ErrorCallback > tempshared1 ; + std::shared_ptr< ppc::front::ErrorCallback > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ErrorCallback" "', argument " "1"" of type '" "ppc::front::ErrorCallback *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + arg1 = const_cast< ppc::front::ErrorCallback * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + arg1 = const_cast< ppc::front::ErrorCallback * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ErrorCallback_onError(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::ErrorCallback *arg1 = (ppc::front::ErrorCallback *) 0 ; + bcos::Error::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::ErrorCallback > tempshared1 ; + std::shared_ptr< ppc::front::ErrorCallback > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "ErrorCallback_onError", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorCallback_onError" "', argument " "1"" of type '" "ppc::front::ErrorCallback *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + arg1 = const_cast< ppc::front::ErrorCallback * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + arg1 = const_cast< ppc::front::ErrorCallback * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ErrorCallback_onError" "', argument " "2"" of type '" "bcos::Error::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< bcos::Error::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< bcos::Error::Ptr * >(argp2); + } + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + if (upcall) { + Swig::DirectorPureVirtualException::raise("ppc::front::ErrorCallback::onError"); + } else { + (arg1)->onError(arg2); + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_disown_ErrorCallback(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::ErrorCallback *arg1 = (ppc::front::ErrorCallback *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::ErrorCallback > tempshared1 ; + std::shared_ptr< ppc::front::ErrorCallback > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ErrorCallback" "', argument " "1"" of type '" "ppc::front::ErrorCallback *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + arg1 = const_cast< ppc::front::ErrorCallback * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::ErrorCallback > * >(argp1); + arg1 = const_cast< ppc::front::ErrorCallback * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ErrorCallback_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ErrorCallback_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MessageDispatcherHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + PyObject *arg1 = (PyObject *) 0 ; + PyObject *swig_obj[1] ; + ppc::front::MessageDispatcherHandler *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + arg1 = swig_obj[0]; + if ( arg1 != Py_None ) { + /* subclassed */ + result = (ppc::front::MessageDispatcherHandler *)new SwigDirector_MessageDispatcherHandler(arg1); + } else { + SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); + SWIG_fail; + } + + { + std::shared_ptr< ppc::front::MessageDispatcherHandler > *smartresult = result ? new std::shared_ptr< ppc::front::MessageDispatcherHandler >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MessageDispatcherHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::MessageDispatcherHandler *arg1 = (ppc::front::MessageDispatcherHandler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::MessageDispatcherHandler > tempshared1 ; + std::shared_ptr< ppc::front::MessageDispatcherHandler > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageDispatcherHandler" "', argument " "1"" of type '" "ppc::front::MessageDispatcherHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + arg1 = const_cast< ppc::front::MessageDispatcherHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + arg1 = const_cast< ppc::front::MessageDispatcherHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MessageDispatcherHandler_onMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::MessageDispatcherHandler *arg1 = (ppc::front::MessageDispatcherHandler *) 0 ; + ppc::protocol::Message::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::MessageDispatcherHandler > tempshared1 ; + std::shared_ptr< ppc::front::MessageDispatcherHandler > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "MessageDispatcherHandler_onMessage", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageDispatcherHandler_onMessage" "', argument " "1"" of type '" "ppc::front::MessageDispatcherHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + arg1 = const_cast< ppc::front::MessageDispatcherHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + arg1 = const_cast< ppc::front::MessageDispatcherHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageDispatcherHandler_onMessage" "', argument " "2"" of type '" "ppc::protocol::Message::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< ppc::protocol::Message::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::protocol::Message::Ptr * >(argp2); + } + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + if (upcall) { + Swig::DirectorPureVirtualException::raise("ppc::front::MessageDispatcherHandler::onMessage"); + } else { + (arg1)->onMessage(arg2); + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_disown_MessageDispatcherHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::MessageDispatcherHandler *arg1 = (ppc::front::MessageDispatcherHandler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::MessageDispatcherHandler > tempshared1 ; + std::shared_ptr< ppc::front::MessageDispatcherHandler > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MessageDispatcherHandler" "', argument " "1"" of type '" "ppc::front::MessageDispatcherHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + arg1 = const_cast< ppc::front::MessageDispatcherHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::MessageDispatcherHandler > * >(argp1); + arg1 = const_cast< ppc::front::MessageDispatcherHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MessageDispatcherHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MessageDispatcherHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SendResponseHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< std::function< void (std::shared_ptr< bcos::bytes > &&) > > arg1 ; + void *argp1 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ppc::front::SendResponseHandler *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SendResponseHandler" "', argument " "1"" of type '" "ppc::protocol::SendResponseFunction""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SendResponseHandler" "', argument " "1"" of type '" "ppc::protocol::SendResponseFunction""'"); + } else { + ppc::protocol::SendResponseFunction * temp = reinterpret_cast< ppc::protocol::SendResponseFunction * >(argp1); + arg1 = *temp; + if (SWIG_IsNewObj(res1)) delete temp; + } + } + result = (ppc::front::SendResponseHandler *)new ppc::front::SendResponseHandler(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__front__SendResponseHandler, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SendResponseHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::SendResponseHandler *arg1 = (ppc::front::SendResponseHandler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__front__SendResponseHandler, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SendResponseHandler" "', argument " "1"" of type '" "ppc::front::SendResponseHandler *""'"); + } + arg1 = reinterpret_cast< ppc::front::SendResponseHandler * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SendResponseHandler_sendResponse(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::SendResponseHandler *arg1 = (ppc::front::SendResponseHandler *) 0 ; + std::shared_ptr< bcos::bytes > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::unique_ptr< std::shared_ptr< bcos::bytes > > rvrdeleter2 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "SendResponseHandler_sendResponse", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__front__SendResponseHandler, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SendResponseHandler_sendResponse" "', argument " "1"" of type '" "ppc::front::SendResponseHandler *""'"); + } + arg1 = reinterpret_cast< ppc::front::SendResponseHandler * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__bytes_t, SWIG_POINTER_RELEASE | 0 ); + if (!SWIG_IsOK(res2)) { + if (res2 == SWIG_ERROR_RELEASE_NOT_OWNED) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SendResponseHandler_sendResponse" "', cannot release ownership as memory is not owned for argument " "2"" of type '" "std::shared_ptr< bcos::bytes > &&""'"); + } else { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SendResponseHandler_sendResponse" "', argument " "2"" of type '" "std::shared_ptr< bcos::bytes > &&""'"); + } + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SendResponseHandler_sendResponse" "', argument " "2"" of type '" "std::shared_ptr< bcos::bytes > &&""'"); + } + arg2 = reinterpret_cast< std::shared_ptr< bcos::bytes > * >(argp2); + rvrdeleter2.reset(arg2); + (arg1)->sendResponse((std::shared_ptr< bcos::bytes > &&)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SendResponseHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ppc__front__SendResponseHandler, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SendResponseHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_IMessageHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + PyObject *arg1 = (PyObject *) 0 ; + PyObject *swig_obj[1] ; + ppc::front::IMessageHandler *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + arg1 = swig_obj[0]; + if ( arg1 != Py_None ) { + /* subclassed */ + result = (ppc::front::IMessageHandler *)new SwigDirector_IMessageHandler(arg1); + } else { + SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); + SWIG_fail; + } + + { + std::shared_ptr< ppc::front::IMessageHandler > *smartresult = result ? new std::shared_ptr< ppc::front::IMessageHandler >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_IMessageHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IMessageHandler *arg1 = (ppc::front::IMessageHandler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IMessageHandler > tempshared1 ; + std::shared_ptr< ppc::front::IMessageHandler > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IMessageHandler" "', argument " "1"" of type '" "ppc::front::IMessageHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + arg1 = const_cast< ppc::front::IMessageHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + arg1 = const_cast< ppc::front::IMessageHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IMessageHandler_onMessage(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IMessageHandler *arg1 = (ppc::front::IMessageHandler *) 0 ; + bcos::Error::Ptr arg2 ; + ppc::protocol::Message::Ptr arg3 ; + SwigValueWrapper< ppc::front::SendResponseHandler > arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IMessageHandler > tempshared1 ; + std::shared_ptr< ppc::front::IMessageHandler > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + Swig::Director *director = 0; + bool upcall = false; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IMessageHandler_onMessage", 4, 4, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMessageHandler_onMessage" "', argument " "1"" of type '" "ppc::front::IMessageHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + arg1 = const_cast< ppc::front::IMessageHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + arg1 = const_cast< ppc::front::IMessageHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IMessageHandler_onMessage" "', argument " "2"" of type '" "bcos::Error::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< bcos::Error::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< bcos::Error::Ptr * >(argp2); + } + { + int newmem = 0; + res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, 0 , &newmem); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IMessageHandler_onMessage" "', argument " "3"" of type '" "ppc::protocol::Message::Ptr""'"); + } + if (argp3) arg3 = *(reinterpret_cast< ppc::protocol::Message::Ptr * >(argp3)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::protocol::Message::Ptr * >(argp3); + } + { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ppc__front__SendResponseHandler, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IMessageHandler_onMessage" "', argument " "4"" of type '" "ppc::front::SendResponseHandler""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMessageHandler_onMessage" "', argument " "4"" of type '" "ppc::front::SendResponseHandler""'"); + } else { + ppc::front::SendResponseHandler * temp = reinterpret_cast< ppc::front::SendResponseHandler * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + if (upcall) { + Swig::DirectorPureVirtualException::raise("ppc::front::IMessageHandler::onMessage"); + } else { + (arg1)->onMessage(arg2,arg3,arg4); + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_disown_IMessageHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IMessageHandler *arg1 = (ppc::front::IMessageHandler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IMessageHandler > tempshared1 ; + std::shared_ptr< ppc::front::IMessageHandler > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_IMessageHandler" "', argument " "1"" of type '" "ppc::front::IMessageHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + arg1 = const_cast< ppc::front::IMessageHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IMessageHandler > * >(argp1); + arg1 = const_cast< ppc::front::IMessageHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IMessageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *IMessageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GetPeersInfoHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + PyObject *arg1 = (PyObject *) 0 ; + PyObject *swig_obj[1] ; + ppc::front::GetPeersInfoHandler *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + arg1 = swig_obj[0]; + if ( arg1 != Py_None ) { + /* subclassed */ + result = (ppc::front::GetPeersInfoHandler *)new SwigDirector_GetPeersInfoHandler(arg1); + } else { + SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); + SWIG_fail; + } + + { + std::shared_ptr< ppc::front::GetPeersInfoHandler > *smartresult = result ? new std::shared_ptr< ppc::front::GetPeersInfoHandler >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GetPeersInfoHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::GetPeersInfoHandler *arg1 = (ppc::front::GetPeersInfoHandler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::GetPeersInfoHandler > tempshared1 ; + std::shared_ptr< ppc::front::GetPeersInfoHandler > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetPeersInfoHandler" "', argument " "1"" of type '" "ppc::front::GetPeersInfoHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + arg1 = const_cast< ppc::front::GetPeersInfoHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + arg1 = const_cast< ppc::front::GetPeersInfoHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GetPeersInfoHandler_onPeersInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::GetPeersInfoHandler *arg1 = (ppc::front::GetPeersInfoHandler *) 0 ; + bcos::Error::Ptr arg2 ; + std::string *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::GetPeersInfoHandler > tempshared1 ; + std::shared_ptr< ppc::front::GetPeersInfoHandler > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject *swig_obj[3] ; + Swig::Director *director = 0; + bool upcall = false; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "GetPeersInfoHandler_onPeersInfo", 3, 3, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetPeersInfoHandler_onPeersInfo" "', argument " "1"" of type '" "ppc::front::GetPeersInfoHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + arg1 = const_cast< ppc::front::GetPeersInfoHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + arg1 = const_cast< ppc::front::GetPeersInfoHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetPeersInfoHandler_onPeersInfo" "', argument " "2"" of type '" "bcos::Error::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< bcos::Error::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< bcos::Error::Ptr * >(argp2); + } + { + std::string *ptr = (std::string *)0; + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GetPeersInfoHandler_onPeersInfo" "', argument " "3"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetPeersInfoHandler_onPeersInfo" "', argument " "3"" of type '" "std::string const &""'"); + } + arg3 = ptr; + } + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + if (upcall) { + Swig::DirectorPureVirtualException::raise("ppc::front::GetPeersInfoHandler::onPeersInfo"); + } else { + (arg1)->onPeersInfo(arg2,(std::string const &)*arg3); + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_disown_GetPeersInfoHandler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::GetPeersInfoHandler *arg1 = (ppc::front::GetPeersInfoHandler *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::GetPeersInfoHandler > tempshared1 ; + std::shared_ptr< ppc::front::GetPeersInfoHandler > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_GetPeersInfoHandler" "', argument " "1"" of type '" "ppc::front::GetPeersInfoHandler *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + arg1 = const_cast< ppc::front::GetPeersInfoHandler * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::GetPeersInfoHandler > * >(argp1); + arg1 = const_cast< ppc::front::GetPeersInfoHandler * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GetPeersInfoHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GetPeersInfoHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_delete_IFront(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IFront" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_start(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_start" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (arg1)->start(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_stop(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_stop" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (arg1)->stop(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_register_topic_handler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + ppc::front::MessageDispatcherHandler::Ptr arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + void *argp3 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_register_topic_handler", 3, 3, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_register_topic_handler" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_register_topic_handler" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_register_topic_handler" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + { + int newmem = 0; + res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, 0 , &newmem); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFront_register_topic_handler" "', argument " "3"" of type '" "ppc::front::MessageDispatcherHandler::Ptr""'"); + } + if (argp3) arg3 = *(reinterpret_cast< ppc::front::MessageDispatcherHandler::Ptr * >(argp3)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::MessageDispatcherHandler::Ptr * >(argp3); + } + (arg1)->register_topic_handler((std::string const &)*arg2,arg3); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_register_msg_handler(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + ppc::front::MessageDispatcherHandler::Ptr arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + void *argp3 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_register_msg_handler", 3, 3, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_register_msg_handler" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_register_msg_handler" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_register_msg_handler" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + { + int newmem = 0; + res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, 0 , &newmem); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFront_register_msg_handler" "', argument " "3"" of type '" "ppc::front::MessageDispatcherHandler::Ptr""'"); + } + if (argp3) arg3 = *(reinterpret_cast< ppc::front::MessageDispatcherHandler::Ptr * >(argp3)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::MessageDispatcherHandler::Ptr * >(argp3); + } + (arg1)->register_msg_handler((std::string const &)*arg2,arg3); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_async_send_message(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + uint16_t arg2 ; + ppc::protocol::MessageOptionalHeader::Ptr *arg3 = 0 ; + char *arg4 = (char *) 0 ; + uint64_t arg5 ; + int arg6 ; + long arg7 ; + ppc::front::ErrorCallback::Ptr arg8 ; + ppc::front::IMessageHandler::Ptr arg9 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + ppc::protocol::MessageOptionalHeader::Ptr tempshared3 ; + int val6 ; + int ecode6 = 0 ; + long val7 ; + int ecode7 = 0 ; + void *argp8 ; + int res8 = 0 ; + void *argp9 ; + int res9 = 0 ; + PyObject *swig_obj[8] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_async_send_message", 8, 8, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_async_send_message" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFront_async_send_message" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + { + int newmem = 0; + res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFront_async_send_message" "', argument " "3"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp3) tempshared3 = *reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + arg3 = &tempshared3; + } else { + arg3 = (argp3) ? reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3) : &tempshared3; + } + } + { + int res; Py_ssize_t size = 0; const void *buf = 0; +#ifndef Py_LIMITED_API + Py_buffer view; + res = PyObject_GetBuffer(swig_obj[3], &view, PyBUF_CONTIG_RO); +#else +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated" +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable: 4996) +#endif + res = PyObject_AsReadBuffer(swig_obj[3], &buf, &size); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +#endif + if (res < 0) { + PyErr_Clear(); + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "IFront_async_send_message" "', argument " "4"" of type '" "(char* payload, uint64_t payloadSize)""'"); + } +#ifndef Py_LIMITED_API + size = view.len; + buf = view.buf; + PyBuffer_Release(&view); +#endif + arg4 = (char *) buf; + arg5 = (uint64_t) (size / sizeof(char)); + } + ecode6 = SWIG_AsVal_int(swig_obj[4], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IFront_async_send_message" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + ecode7 = SWIG_AsVal_long(swig_obj[5], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IFront_async_send_message" "', argument " "7"" of type '" "long""'"); + } + arg7 = static_cast< long >(val7); + { + int newmem = 0; + res8 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp8, SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, 0 , &newmem); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "IFront_async_send_message" "', argument " "8"" of type '" "ppc::front::ErrorCallback::Ptr""'"); + } + if (argp8) arg8 = *(reinterpret_cast< ppc::front::ErrorCallback::Ptr * >(argp8)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::ErrorCallback::Ptr * >(argp8); + } + { + int newmem = 0; + res9 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp9, SWIGTYPE_p_std__shared_ptrT_ppc__front__IMessageHandler_t, 0 , &newmem); + if (!SWIG_IsOK(res9)) { + SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "IFront_async_send_message" "', argument " "9"" of type '" "ppc::front::IMessageHandler::Ptr""'"); + } + if (argp9) arg9 = *(reinterpret_cast< ppc::front::IMessageHandler::Ptr * >(argp9)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::IMessageHandler::Ptr * >(argp9); + } + (arg1)->async_send_message(arg2,(ppc::protocol::MessageOptionalHeader::Ptr const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_async_send_response(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + char *arg2 = (char *) 0 ; + uint64_t arg3 ; + std::string *arg4 = 0 ; + char *arg5 = (char *) 0 ; + uint64_t arg6 ; + int arg7 ; + ppc::front::ErrorCallback::Ptr arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + unsigned long long val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + int val7 ; + int ecode7 = 0 ; + void *argp8 ; + int res8 = 0 ; + PyObject *swig_obj[7] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_async_send_response", 7, 7, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_async_send_response" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_async_send_response" "', argument " "2"" of type '" "char *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IFront_async_send_response" "', argument " "3"" of type '" "uint64_t""'"); + } + arg3 = static_cast< uint64_t >(val3); + { + std::string *ptr = (std::string *)0; + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IFront_async_send_response" "', argument " "4"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_async_send_response" "', argument " "4"" of type '" "std::string const &""'"); + } + arg4 = ptr; + } + { + int res; Py_ssize_t size = 0; const void *buf = 0; +#ifndef Py_LIMITED_API + Py_buffer view; + res = PyObject_GetBuffer(swig_obj[4], &view, PyBUF_CONTIG_RO); +#else +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated" +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable: 4996) +#endif + res = PyObject_AsReadBuffer(swig_obj[4], &buf, &size); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +#endif + if (res < 0) { + PyErr_Clear(); + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "IFront_async_send_response" "', argument " "5"" of type '" "(char* payload, uint64_t payloadSize)""'"); + } +#ifndef Py_LIMITED_API + size = view.len; + buf = view.buf; + PyBuffer_Release(&view); +#endif + arg5 = (char *) buf; + arg6 = (uint64_t) (size / sizeof(char)); + } + ecode7 = SWIG_AsVal_int(swig_obj[5], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IFront_async_send_response" "', argument " "7"" of type '" "int""'"); + } + arg7 = static_cast< int >(val7); + { + int newmem = 0; + res8 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp8, SWIGTYPE_p_std__shared_ptrT_ppc__front__ErrorCallback_t, 0 , &newmem); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "IFront_async_send_response" "', argument " "8"" of type '" "ppc::front::ErrorCallback::Ptr""'"); + } + if (argp8) arg8 = *(reinterpret_cast< ppc::front::ErrorCallback::Ptr * >(argp8)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::ErrorCallback::Ptr * >(argp8); + } + (arg1)->async_send_response(arg2,arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_push(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + uint16_t arg2 ; + ppc::protocol::MessageOptionalHeader::Ptr *arg3 = 0 ; + bcos::bytes *arg4 = 0 ; + int arg5 ; + long arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + ppc::protocol::MessageOptionalHeader::Ptr tempshared3 ; + void *argp4 = 0 ; + int res4 = 0 ; + std::unique_ptr< bcos::bytes > rvrdeleter4 ; + int val5 ; + int ecode5 = 0 ; + long val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + bcos::Error::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_push", 6, 6, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_push" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFront_push" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + { + int newmem = 0; + res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFront_push" "', argument " "3"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp3) tempshared3 = *reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + arg3 = &tempshared3; + } else { + arg3 = (argp3) ? reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3) : &tempshared3; + } + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_uint8_t_t, SWIG_POINTER_RELEASE | 0 ); + if (!SWIG_IsOK(res4)) { + if (res4 == SWIG_ERROR_RELEASE_NOT_OWNED) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IFront_push" "', cannot release ownership as memory is not owned for argument " "4"" of type '" "bcos::bytes &&""'"); + } else { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IFront_push" "', argument " "4"" of type '" "bcos::bytes &&""'"); + } + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_push" "', argument " "4"" of type '" "bcos::bytes &&""'"); + } + arg4 = reinterpret_cast< bcos::bytes * >(argp4); + rvrdeleter4.reset(arg4); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IFront_push" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_long(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IFront_push" "', argument " "6"" of type '" "long""'"); + } + arg6 = static_cast< long >(val6); + result = (arg1)->push(arg2,(ppc::protocol::MessageOptionalHeader::Ptr const &)*arg3,(bcos::bytes &&)*arg4,arg5,arg6); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_push_msg(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + uint16_t arg2 ; + ppc::protocol::MessageOptionalHeader::Ptr *arg3 = 0 ; + char *arg4 = (char *) 0 ; + uint64_t arg5 ; + int arg6 ; + long arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + unsigned short val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + ppc::protocol::MessageOptionalHeader::Ptr tempshared3 ; + int val6 ; + int ecode6 = 0 ; + long val7 ; + int ecode7 = 0 ; + PyObject *swig_obj[6] ; + bcos::Error::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_push_msg", 6, 6, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_push_msg" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFront_push_msg" "', argument " "2"" of type '" "uint16_t""'"); + } + arg2 = static_cast< uint16_t >(val2); + { + int newmem = 0; + res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0 , &newmem); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFront_push_msg" "', argument " "3"" of type '" "ppc::protocol::MessageOptionalHeader::Ptr const &""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + if (argp3) tempshared3 = *reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + delete reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3); + arg3 = &tempshared3; + } else { + arg3 = (argp3) ? reinterpret_cast< ppc::protocol::MessageOptionalHeader::Ptr * >(argp3) : &tempshared3; + } + } + { + int res; Py_ssize_t size = 0; const void *buf = 0; +#ifndef Py_LIMITED_API + Py_buffer view; + res = PyObject_GetBuffer(swig_obj[3], &view, PyBUF_CONTIG_RO); +#else +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated" +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#elif defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable: 4996) +#endif + res = PyObject_AsReadBuffer(swig_obj[3], &buf, &size); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +#endif + if (res < 0) { + PyErr_Clear(); + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "IFront_push_msg" "', argument " "4"" of type '" "(char* payload, uint64_t payloadSize)""'"); + } +#ifndef Py_LIMITED_API + size = view.len; + buf = view.buf; + PyBuffer_Release(&view); +#endif + arg4 = (char *) buf; + arg5 = (uint64_t) (size / sizeof(char)); + } + ecode6 = SWIG_AsVal_int(swig_obj[4], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IFront_push_msg" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + ecode7 = SWIG_AsVal_long(swig_obj[5], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IFront_push_msg" "', argument " "7"" of type '" "long""'"); + } + arg7 = static_cast< long >(val7); + result = (arg1)->push_msg(arg2,(ppc::protocol::MessageOptionalHeader::Ptr const &)*arg3,arg4,arg5,arg6,arg7); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_pop(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + long arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + long val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + ppc::protocol::Message::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_pop", 3, 3, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_pop" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_pop" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_pop" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + ecode3 = SWIG_AsVal_long(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IFront_pop" "', argument " "3"" of type '" "long""'"); + } + arg3 = static_cast< long >(val3); + result = (arg1)->pop((std::string const &)*arg2,arg3); + { + std::shared_ptr< ppc::protocol::Message > *smartresult = result ? new std::shared_ptr< ppc::protocol::Message >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN); + } + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_peek(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + ppc::protocol::Message::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_peek", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_peek" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_peek" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_peek" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + result = (arg1)->peek((std::string const &)*arg2); + { + std::shared_ptr< ppc::protocol::Message > *smartresult = result ? new std::shared_ptr< ppc::protocol::Message >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__Message_t, SWIG_POINTER_OWN); + } + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_asyncGetPeers(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + ppc::front::GetPeersInfoHandler::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_asyncGetPeers", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_asyncGetPeers" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_asyncGetPeers" "', argument " "2"" of type '" "ppc::front::GetPeersInfoHandler::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< ppc::front::GetPeersInfoHandler::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::GetPeersInfoHandler::Ptr * >(argp2); + } + (arg1)->asyncGetPeers(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_registerNodeInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + ppc::protocol::INodeInfo::Ptr *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + bcos::Error::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_registerNodeInfo", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_registerNodeInfo" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ppc__protocol__INodeInfo__Ptr, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_registerNodeInfo" "', argument " "2"" of type '" "ppc::protocol::INodeInfo::Ptr const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_registerNodeInfo" "', argument " "2"" of type '" "ppc::protocol::INodeInfo::Ptr const &""'"); + } + arg2 = reinterpret_cast< ppc::protocol::INodeInfo::Ptr * >(argp2); + result = (arg1)->registerNodeInfo((ppc::protocol::INodeInfo::Ptr const &)*arg2); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_unRegisterNodeInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + bcos::Error::Ptr result; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_unRegisterNodeInfo" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (arg1)->unRegisterNodeInfo(); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_nodeInfo(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::INodeInfo::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_nodeInfo" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::INodeInfo::Ptr *) &(arg1)->nodeInfo(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__protocol__INodeInfo__Ptr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_registerTopic(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + bcos::Error::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_registerTopic", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_registerTopic" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_registerTopic" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_registerTopic" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + result = (arg1)->registerTopic((std::string const &)*arg2); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_unRegisterTopic(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + bcos::Error::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_unRegisterTopic", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_unRegisterTopic" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_unRegisterTopic" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_unRegisterTopic" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + result = (arg1)->unRegisterTopic((std::string const &)*arg2); + { + std::shared_ptr< bcos::Error > *smartresult = result ? new std::shared_ptr< bcos::Error >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_bcos__Error_t, SWIG_POINTER_OWN); + } + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_registerComponent(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_registerComponent", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_registerComponent" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_registerComponent" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_registerComponent" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->registerComponent((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFront_unRegisterComponent(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFront *arg1 = (ppc::front::IFront *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::front::IFront > tempshared1 ; + std::shared_ptr< ppc::front::IFront > *smartarg1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFront_unRegisterComponent", 2, 2, swig_obj)) SWIG_fail; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFront_unRegisterComponent" "', argument " "1"" of type '" "ppc::front::IFront *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::front::IFront > * >(argp1); + arg1 = const_cast< ppc::front::IFront * >((smartarg1 ? smartarg1->get() : 0)); + } + } + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFront_unRegisterComponent" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFront_unRegisterComponent" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->unRegisterComponent((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *IFront_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_IFrontBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFrontBuilder *arg1 = (ppc::front::IFrontBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__front__IFrontBuilder, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IFrontBuilder" "', argument " "1"" of type '" "ppc::front::IFrontBuilder *""'"); + } + arg1 = reinterpret_cast< ppc::front::IFrontBuilder * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IFrontBuilder_buildClient(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::IFrontBuilder *arg1 = (ppc::front::IFrontBuilder *) 0 ; + std::string arg2 ; + std::function< void () > arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + ppc::front::IFrontClient::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "IFrontBuilder_buildClient", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__front__IFrontBuilder, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrontBuilder_buildClient" "', argument " "1"" of type '" "ppc::front::IFrontBuilder const *""'"); + } + arg1 = reinterpret_cast< ppc::front::IFrontBuilder * >(argp1); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "IFrontBuilder_buildClient" "', argument " "2"" of type '" "std::string""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__functionT_void_fF_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFrontBuilder_buildClient" "', argument " "3"" of type '" "std::function< void () >""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFrontBuilder_buildClient" "', argument " "3"" of type '" "std::function< void () >""'"); + } else { + std::function< void () > * temp = reinterpret_cast< std::function< void () > * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IFrontBuilder_buildClient" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + result = ((ppc::front::IFrontBuilder const *)arg1)->buildClient(arg2,arg3,arg4); + { + std::shared_ptr< ppc::front::IFrontClient > *smartresult = result ? new std::shared_ptr< ppc::front::IFrontClient >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__IFrontClient_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IFrontBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ppc__front__IFrontBuilder, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_TransportBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::TransportBuilder *result = 0 ; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "new_TransportBuilder", 0, 0, 0)) SWIG_fail; + result = (ppc::sdk::TransportBuilder *)new ppc::sdk::TransportBuilder(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__sdk__TransportBuilder, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TransportBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::TransportBuilder *arg1 = (ppc::sdk::TransportBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__sdk__TransportBuilder, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransportBuilder" "', argument " "1"" of type '" "ppc::sdk::TransportBuilder *""'"); + } + arg1 = reinterpret_cast< ppc::sdk::TransportBuilder * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransportBuilder_buildProTransport(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::TransportBuilder *arg1 = (ppc::sdk::TransportBuilder *) 0 ; + ppc::front::FrontConfig::Ptr arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + ppc::sdk::Transport::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "TransportBuilder_buildProTransport", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__sdk__TransportBuilder, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportBuilder_buildProTransport" "', argument " "1"" of type '" "ppc::sdk::TransportBuilder *""'"); + } + arg1 = reinterpret_cast< ppc::sdk::TransportBuilder * >(argp1); + { + int newmem = 0; + res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 , &newmem); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransportBuilder_buildProTransport" "', argument " "2"" of type '" "ppc::front::FrontConfig::Ptr""'"); + } + if (argp2) arg2 = *(reinterpret_cast< ppc::front::FrontConfig::Ptr * >(argp2)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::FrontConfig::Ptr * >(argp2); + } + result = (arg1)->buildProTransport(arg2); + { + std::shared_ptr< ppc::sdk::Transport > *smartresult = result ? new std::shared_ptr< ppc::sdk::Transport >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransportBuilder_buildConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::TransportBuilder *arg1 = (ppc::sdk::TransportBuilder *) 0 ; + int arg2 ; + std::string arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[3] ; + ppc::front::FrontConfig::Ptr result; + + (void)self; + if (!SWIG_Python_UnpackTuple(args, "TransportBuilder_buildConfig", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__sdk__TransportBuilder, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportBuilder_buildConfig" "', argument " "1"" of type '" "ppc::sdk::TransportBuilder *""'"); + } + arg1 = reinterpret_cast< ppc::sdk::TransportBuilder * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TransportBuilder_buildConfig" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + std::string *ptr = (std::string *)0; + int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TransportBuilder_buildConfig" "', argument " "3"" of type '" "std::string""'"); + } + arg3 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + result = (arg1)->buildConfig(arg2,arg3); + { + std::shared_ptr< ppc::front::FrontConfig > *smartresult = result ? new std::shared_ptr< ppc::front::FrontConfig >(result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransportBuilder_frontConfigBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::TransportBuilder *arg1 = (ppc::sdk::TransportBuilder *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ppc::front::FrontConfigBuilder::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ppc__sdk__TransportBuilder, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportBuilder_frontConfigBuilder" "', argument " "1"" of type '" "ppc::sdk::TransportBuilder *""'"); + } + arg1 = reinterpret_cast< ppc::sdk::TransportBuilder * >(argp1); + result = (ppc::front::FrontConfigBuilder::Ptr *) &(arg1)->frontConfigBuilder(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TransportBuilder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ppc__sdk__TransportBuilder, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TransportBuilder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_Transport(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::front::FrontConfig::Ptr arg1 ; + void *argp1 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + ppc::sdk::Transport *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Transport" "', argument " "1"" of type '" "ppc::front::FrontConfig::Ptr""'"); + } + if (argp1) arg1 = *(reinterpret_cast< ppc::front::FrontConfig::Ptr * >(argp1)); + if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ppc::front::FrontConfig::Ptr * >(argp1); + } + result = (ppc::sdk::Transport *)new ppc::sdk::Transport(arg1); + { + std::shared_ptr< ppc::sdk::Transport > *smartresult = result ? new std::shared_ptr< ppc::sdk::Transport >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Transport(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Transport" "', argument " "1"" of type '" "ppc::sdk::Transport *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (void)arg1; delete smartarg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_start(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_start" "', argument " "1"" of type '" "ppc::sdk::Transport *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (arg1)->start(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_stop(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_stop" "', argument " "1"" of type '" "ppc::sdk::Transport *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + (arg1)->stop(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_getFront(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport const > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::front::IFront::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_getFront" "', argument " "1"" of type '" "ppc::sdk::Transport const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::front::IFront::Ptr *) &((ppc::sdk::Transport const *)arg1)->getFront(); + { + std::shared_ptr< ppc::front::IFront > *smartresult = *result ? new std::shared_ptr< ppc::front::IFront >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__IFront_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_gateway(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport const > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::gateway::IGateway::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_gateway" "', argument " "1"" of type '" "ppc::sdk::Transport const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::gateway::IGateway::Ptr *) &((ppc::sdk::Transport const *)arg1)->gateway(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ppc__gateway__IGateway__Ptr, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_msgPayloadBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport const > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::MessagePayloadBuilder::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_msgPayloadBuilder" "', argument " "1"" of type '" "ppc::sdk::Transport const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::MessagePayloadBuilder::Ptr *) &((ppc::sdk::Transport const *)arg1)->msgPayloadBuilder(); + { + std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *smartresult = *result ? new std::shared_ptr< ppc::protocol::MessagePayloadBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_msgBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport const > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::MessageBuilder::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_msgBuilder" "', argument " "1"" of type '" "ppc::sdk::Transport const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::MessageBuilder::Ptr *) &((ppc::sdk::Transport const *)arg1)->msgBuilder(); + { + std::shared_ptr< ppc::protocol::MessageBuilder > *smartresult = *result ? new std::shared_ptr< ppc::protocol::MessageBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_msgHeaderBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport const > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::MessageHeaderBuilder::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_msgHeaderBuilder" "', argument " "1"" of type '" "ppc::sdk::Transport const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::MessageHeaderBuilder::Ptr *) &((ppc::sdk::Transport const *)arg1)->msgHeaderBuilder(); + { + std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *smartresult = *result ? new std::shared_ptr< ppc::protocol::MessageHeaderBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_routeInfoBuilder(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport const > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::protocol::MessageOptionalHeaderBuilder::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_routeInfoBuilder" "', argument " "1"" of type '" "ppc::sdk::Transport const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::protocol::MessageOptionalHeaderBuilder::Ptr *) &((ppc::sdk::Transport const *)arg1)->routeInfoBuilder(); + { + std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *smartresult = *result ? new std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Transport_getConfig(PyObject *self, PyObject *args) { + PyObject *resultobj = 0; + ppc::sdk::Transport *arg1 = (ppc::sdk::Transport *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::shared_ptr< ppc::sdk::Transport const > tempshared1 ; + std::shared_ptr< ppc::sdk::Transport const > *smartarg1 = 0 ; + PyObject *swig_obj[1] ; + ppc::front::FrontConfig::Ptr *result = 0 ; + + (void)self; + if (!args) SWIG_fail; + swig_obj[0] = args; + { + int newmem = 0; + res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, 0 | 0 , &newmem); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transport_getConfig" "', argument " "1"" of type '" "ppc::sdk::Transport const *""'"); + } + if (newmem & SWIG_CAST_NEW_MEMORY) { + tempshared1 = *reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + delete reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >(tempshared1.get()); + } else { + smartarg1 = reinterpret_cast< std::shared_ptr< const ppc::sdk::Transport > * >(argp1); + arg1 = const_cast< ppc::sdk::Transport * >((smartarg1 ? smartarg1->get() : 0)); + } + } + result = (ppc::front::FrontConfig::Ptr *) &((ppc::sdk::Transport const *)arg1)->getConfig(); + { + std::shared_ptr< ppc::front::FrontConfig > *smartresult = *result ? new std::shared_ptr< ppc::front::FrontConfig >(*result) : 0; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_ppc__front__FrontConfig_t, SWIG_POINTER_OWN); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Transport_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_ppc__sdk__Transport_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *Transport_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +static PyMethodDef SwigMethods[] = { + { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL}, + { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL}, + { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL}, + { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL}, + { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL}, + { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL}, + { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL}, + { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL}, + { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL}, + { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL}, + { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL}, + { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL}, + { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL}, + { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL}, + { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL}, + { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL}, + { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL}, + { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL}, + { "new_SharedBcosError", _wrap_new_SharedBcosError, METH_NOARGS, NULL}, + { "delete_SharedBcosError", _wrap_delete_SharedBcosError, METH_O, NULL}, + { "SharedBcosError_swigregister", SharedBcosError_swigregister, METH_O, NULL}, + { "SharedBcosError_swiginit", SharedBcosError_swiginit, METH_VARARGS, NULL}, + { "new_SharedFrontConfig", _wrap_new_SharedFrontConfig, METH_NOARGS, NULL}, + { "delete_SharedFrontConfig", _wrap_delete_SharedFrontConfig, METH_O, NULL}, + { "SharedFrontConfig_swigregister", SharedFrontConfig_swigregister, METH_O, NULL}, + { "SharedFrontConfig_swiginit", SharedFrontConfig_swiginit, METH_VARARGS, NULL}, + { "new_SharedGrpcConfig", _wrap_new_SharedGrpcConfig, METH_NOARGS, NULL}, + { "delete_SharedGrpcConfig", _wrap_delete_SharedGrpcConfig, METH_O, NULL}, + { "SharedGrpcConfig_swigregister", SharedGrpcConfig_swigregister, METH_O, NULL}, + { "SharedGrpcConfig_swiginit", SharedGrpcConfig_swiginit, METH_VARARGS, NULL}, + { "new_SharedFront", _wrap_new_SharedFront, METH_NOARGS, NULL}, + { "delete_SharedFront", _wrap_delete_SharedFront, METH_O, NULL}, + { "SharedFront_swigregister", SharedFront_swigregister, METH_O, NULL}, + { "SharedFront_swiginit", SharedFront_swiginit, METH_VARARGS, NULL}, + { "new_SharedFrontClient", _wrap_new_SharedFrontClient, METH_NOARGS, NULL}, + { "delete_SharedFrontClient", _wrap_delete_SharedFrontClient, METH_O, NULL}, + { "SharedFrontClient_swigregister", SharedFrontClient_swigregister, METH_O, NULL}, + { "SharedFrontClient_swiginit", SharedFrontClient_swiginit, METH_VARARGS, NULL}, + { "new_SharedErrorCallback", _wrap_new_SharedErrorCallback, METH_NOARGS, NULL}, + { "delete_SharedErrorCallback", _wrap_delete_SharedErrorCallback, METH_O, NULL}, + { "SharedErrorCallback_swigregister", SharedErrorCallback_swigregister, METH_O, NULL}, + { "SharedErrorCallback_swiginit", SharedErrorCallback_swiginit, METH_VARARGS, NULL}, + { "new_SharedMessageDispatcherHandler", _wrap_new_SharedMessageDispatcherHandler, METH_NOARGS, NULL}, + { "delete_SharedMessageDispatcherHandler", _wrap_delete_SharedMessageDispatcherHandler, METH_O, NULL}, + { "SharedMessageDispatcherHandler_swigregister", SharedMessageDispatcherHandler_swigregister, METH_O, NULL}, + { "SharedMessageDispatcherHandler_swiginit", SharedMessageDispatcherHandler_swiginit, METH_VARARGS, NULL}, + { "new_SharedIMessageHandler", _wrap_new_SharedIMessageHandler, METH_NOARGS, NULL}, + { "delete_SharedIMessageHandler", _wrap_delete_SharedIMessageHandler, METH_O, NULL}, + { "SharedIMessageHandler_swigregister", SharedIMessageHandler_swigregister, METH_O, NULL}, + { "SharedIMessageHandler_swiginit", SharedIMessageHandler_swiginit, METH_VARARGS, NULL}, + { "new_SharedGetPeersInfoHandler", _wrap_new_SharedGetPeersInfoHandler, METH_NOARGS, NULL}, + { "delete_SharedGetPeersInfoHandler", _wrap_delete_SharedGetPeersInfoHandler, METH_O, NULL}, + { "SharedGetPeersInfoHandler_swigregister", SharedGetPeersInfoHandler_swigregister, METH_O, NULL}, + { "SharedGetPeersInfoHandler_swiginit", SharedGetPeersInfoHandler_swiginit, METH_VARARGS, NULL}, + { "new_SharedGateway", _wrap_new_SharedGateway, METH_NOARGS, NULL}, + { "delete_SharedGateway", _wrap_delete_SharedGateway, METH_O, NULL}, + { "SharedGateway_swigregister", SharedGateway_swigregister, METH_O, NULL}, + { "SharedGateway_swiginit", SharedGateway_swiginit, METH_VARARGS, NULL}, + { "new_SharedMessage", _wrap_new_SharedMessage, METH_NOARGS, NULL}, + { "delete_SharedMessage", _wrap_delete_SharedMessage, METH_O, NULL}, + { "SharedMessage_swigregister", SharedMessage_swigregister, METH_O, NULL}, + { "SharedMessage_swiginit", SharedMessage_swiginit, METH_VARARGS, NULL}, + { "new_SharedMessageHeader", _wrap_new_SharedMessageHeader, METH_NOARGS, NULL}, + { "delete_SharedMessageHeader", _wrap_delete_SharedMessageHeader, METH_O, NULL}, + { "SharedMessageHeader_swigregister", SharedMessageHeader_swigregister, METH_O, NULL}, + { "SharedMessageHeader_swiginit", SharedMessageHeader_swiginit, METH_VARARGS, NULL}, + { "new_SharedMessagePayload", _wrap_new_SharedMessagePayload, METH_NOARGS, NULL}, + { "delete_SharedMessagePayload", _wrap_delete_SharedMessagePayload, METH_O, NULL}, + { "SharedMessagePayload_swigregister", SharedMessagePayload_swigregister, METH_O, NULL}, + { "SharedMessagePayload_swiginit", SharedMessagePayload_swiginit, METH_VARARGS, NULL}, + { "new_SharedRouteInfo", _wrap_new_SharedRouteInfo, METH_NOARGS, NULL}, + { "delete_SharedRouteInfo", _wrap_delete_SharedRouteInfo, METH_O, NULL}, + { "SharedRouteInfo_swigregister", SharedRouteInfo_swigregister, METH_O, NULL}, + { "SharedRouteInfo_swiginit", SharedRouteInfo_swiginit, METH_VARARGS, NULL}, + { "new_SharedMessageBuilder", _wrap_new_SharedMessageBuilder, METH_NOARGS, NULL}, + { "delete_SharedMessageBuilder", _wrap_delete_SharedMessageBuilder, METH_O, NULL}, + { "SharedMessageBuilder_swigregister", SharedMessageBuilder_swigregister, METH_O, NULL}, + { "SharedMessageBuilder_swiginit", SharedMessageBuilder_swiginit, METH_VARARGS, NULL}, + { "new_SharedMessageHeaderBuilder", _wrap_new_SharedMessageHeaderBuilder, METH_NOARGS, NULL}, + { "delete_SharedMessageHeaderBuilder", _wrap_delete_SharedMessageHeaderBuilder, METH_O, NULL}, + { "SharedMessageHeaderBuilder_swigregister", SharedMessageHeaderBuilder_swigregister, METH_O, NULL}, + { "SharedMessageHeaderBuilder_swiginit", SharedMessageHeaderBuilder_swiginit, METH_VARARGS, NULL}, + { "new_SharedMessagePayloadBuilder", _wrap_new_SharedMessagePayloadBuilder, METH_NOARGS, NULL}, + { "delete_SharedMessagePayloadBuilder", _wrap_delete_SharedMessagePayloadBuilder, METH_O, NULL}, + { "SharedMessagePayloadBuilder_swigregister", SharedMessagePayloadBuilder_swigregister, METH_O, NULL}, + { "SharedMessagePayloadBuilder_swiginit", SharedMessagePayloadBuilder_swiginit, METH_VARARGS, NULL}, + { "new_SharedRouteInfoBuilder", _wrap_new_SharedRouteInfoBuilder, METH_NOARGS, NULL}, + { "delete_SharedRouteInfoBuilder", _wrap_delete_SharedRouteInfoBuilder, METH_O, NULL}, + { "SharedRouteInfoBuilder_swigregister", SharedRouteInfoBuilder_swigregister, METH_O, NULL}, + { "SharedRouteInfoBuilder_swiginit", SharedRouteInfoBuilder_swiginit, METH_VARARGS, NULL}, + { "ubytes_iterator", _wrap_ubytes_iterator, METH_O, NULL}, + { "ubytes___nonzero__", _wrap_ubytes___nonzero__, METH_O, NULL}, + { "ubytes___bool__", _wrap_ubytes___bool__, METH_O, NULL}, + { "ubytes___len__", _wrap_ubytes___len__, METH_O, NULL}, + { "ubytes___getslice__", _wrap_ubytes___getslice__, METH_VARARGS, NULL}, + { "ubytes___setslice__", _wrap_ubytes___setslice__, METH_VARARGS, NULL}, + { "ubytes___delslice__", _wrap_ubytes___delslice__, METH_VARARGS, NULL}, + { "ubytes___delitem__", _wrap_ubytes___delitem__, METH_VARARGS, NULL}, + { "ubytes___getitem__", _wrap_ubytes___getitem__, METH_VARARGS, NULL}, + { "ubytes___setitem__", _wrap_ubytes___setitem__, METH_VARARGS, NULL}, + { "ubytes_pop", _wrap_ubytes_pop, METH_O, NULL}, + { "ubytes_append", _wrap_ubytes_append, METH_VARARGS, NULL}, + { "ubytes_empty", _wrap_ubytes_empty, METH_O, NULL}, + { "ubytes_size", _wrap_ubytes_size, METH_O, NULL}, + { "ubytes_swap", _wrap_ubytes_swap, METH_VARARGS, NULL}, + { "ubytes_begin", _wrap_ubytes_begin, METH_O, NULL}, + { "ubytes_end", _wrap_ubytes_end, METH_O, NULL}, + { "ubytes_rbegin", _wrap_ubytes_rbegin, METH_O, NULL}, + { "ubytes_rend", _wrap_ubytes_rend, METH_O, NULL}, + { "ubytes_clear", _wrap_ubytes_clear, METH_O, NULL}, + { "ubytes_get_allocator", _wrap_ubytes_get_allocator, METH_O, NULL}, + { "ubytes_pop_back", _wrap_ubytes_pop_back, METH_O, NULL}, + { "ubytes_erase", _wrap_ubytes_erase, METH_VARARGS, NULL}, + { "new_ubytes", _wrap_new_ubytes, METH_VARARGS, NULL}, + { "ubytes_push_back", _wrap_ubytes_push_back, METH_VARARGS, NULL}, + { "ubytes_front", _wrap_ubytes_front, METH_O, NULL}, + { "ubytes_back", _wrap_ubytes_back, METH_O, NULL}, + { "ubytes_assign", _wrap_ubytes_assign, METH_VARARGS, NULL}, + { "ubytes_resize", _wrap_ubytes_resize, METH_VARARGS, NULL}, + { "ubytes_insert", _wrap_ubytes_insert, METH_VARARGS, NULL}, + { "ubytes_reserve", _wrap_ubytes_reserve, METH_VARARGS, NULL}, + { "ubytes_capacity", _wrap_ubytes_capacity, METH_O, NULL}, + { "delete_ubytes", _wrap_delete_ubytes, METH_O, NULL}, + { "ubytes_swigregister", ubytes_swigregister, METH_O, NULL}, + { "ubytes_swiginit", ubytes_swiginit, METH_VARARGS, NULL}, + { "ibytes_iterator", _wrap_ibytes_iterator, METH_O, NULL}, + { "ibytes___nonzero__", _wrap_ibytes___nonzero__, METH_O, NULL}, + { "ibytes___bool__", _wrap_ibytes___bool__, METH_O, NULL}, + { "ibytes___len__", _wrap_ibytes___len__, METH_O, NULL}, + { "ibytes___getslice__", _wrap_ibytes___getslice__, METH_VARARGS, NULL}, + { "ibytes___setslice__", _wrap_ibytes___setslice__, METH_VARARGS, NULL}, + { "ibytes___delslice__", _wrap_ibytes___delslice__, METH_VARARGS, NULL}, + { "ibytes___delitem__", _wrap_ibytes___delitem__, METH_VARARGS, NULL}, + { "ibytes___getitem__", _wrap_ibytes___getitem__, METH_VARARGS, NULL}, + { "ibytes___setitem__", _wrap_ibytes___setitem__, METH_VARARGS, NULL}, + { "ibytes_pop", _wrap_ibytes_pop, METH_O, NULL}, + { "ibytes_append", _wrap_ibytes_append, METH_VARARGS, NULL}, + { "ibytes_empty", _wrap_ibytes_empty, METH_O, NULL}, + { "ibytes_size", _wrap_ibytes_size, METH_O, NULL}, + { "ibytes_swap", _wrap_ibytes_swap, METH_VARARGS, NULL}, + { "ibytes_begin", _wrap_ibytes_begin, METH_O, NULL}, + { "ibytes_end", _wrap_ibytes_end, METH_O, NULL}, + { "ibytes_rbegin", _wrap_ibytes_rbegin, METH_O, NULL}, + { "ibytes_rend", _wrap_ibytes_rend, METH_O, NULL}, + { "ibytes_clear", _wrap_ibytes_clear, METH_O, NULL}, + { "ibytes_get_allocator", _wrap_ibytes_get_allocator, METH_O, NULL}, + { "ibytes_pop_back", _wrap_ibytes_pop_back, METH_O, NULL}, + { "ibytes_erase", _wrap_ibytes_erase, METH_VARARGS, NULL}, + { "new_ibytes", _wrap_new_ibytes, METH_VARARGS, NULL}, + { "ibytes_push_back", _wrap_ibytes_push_back, METH_VARARGS, NULL}, + { "ibytes_front", _wrap_ibytes_front, METH_O, NULL}, + { "ibytes_back", _wrap_ibytes_back, METH_O, NULL}, + { "ibytes_assign", _wrap_ibytes_assign, METH_VARARGS, NULL}, + { "ibytes_resize", _wrap_ibytes_resize, METH_VARARGS, NULL}, + { "ibytes_insert", _wrap_ibytes_insert, METH_VARARGS, NULL}, + { "ibytes_reserve", _wrap_ibytes_reserve, METH_VARARGS, NULL}, + { "ibytes_capacity", _wrap_ibytes_capacity, METH_O, NULL}, + { "delete_ibytes", _wrap_delete_ibytes, METH_O, NULL}, + { "ibytes_swigregister", ibytes_swigregister, METH_O, NULL}, + { "ibytes_swiginit", ibytes_swiginit, METH_VARARGS, NULL}, + { "Error_buildError", _wrap_Error_buildError, METH_VARARGS, NULL}, + { "new_Error", _wrap_new_Error, METH_VARARGS, NULL}, + { "delete_Error", _wrap_delete_Error, METH_O, NULL}, + { "Error_errorCode", _wrap_Error_errorCode, METH_O, NULL}, + { "Error_errorMessage", _wrap_Error_errorMessage, METH_O, NULL}, + { "Error_setErrorCode", _wrap_Error_setErrorCode, METH_VARARGS, NULL}, + { "Error_setErrorMessage", _wrap_Error_setErrorMessage, METH_VARARGS, NULL}, + { "Error_swigregister", Error_swigregister, METH_O, NULL}, + { "Error_swiginit", Error_swiginit, METH_VARARGS, NULL}, + { "InputBuffer_data_set", _wrap_InputBuffer_data_set, METH_VARARGS, NULL}, + { "InputBuffer_data_get", _wrap_InputBuffer_data_get, METH_O, NULL}, + { "InputBuffer_len_set", _wrap_InputBuffer_len_set, METH_VARARGS, NULL}, + { "InputBuffer_len_get", _wrap_InputBuffer_len_get, METH_O, NULL}, + { "new_InputBuffer", _wrap_new_InputBuffer, METH_NOARGS, NULL}, + { "delete_InputBuffer", _wrap_delete_InputBuffer, METH_O, NULL}, + { "InputBuffer_swigregister", InputBuffer_swigregister, METH_O, NULL}, + { "InputBuffer_swiginit", InputBuffer_swiginit, METH_VARARGS, NULL}, + { "OutputBuffer_data_set", _wrap_OutputBuffer_data_set, METH_VARARGS, NULL}, + { "OutputBuffer_data_get", _wrap_OutputBuffer_data_get, METH_O, NULL}, + { "OutputBuffer_len_set", _wrap_OutputBuffer_len_set, METH_VARARGS, NULL}, + { "OutputBuffer_len_get", _wrap_OutputBuffer_len_get, METH_O, NULL}, + { "new_OutputBuffer", _wrap_new_OutputBuffer, METH_NOARGS, NULL}, + { "delete_OutputBuffer", _wrap_delete_OutputBuffer, METH_O, NULL}, + { "OutputBuffer_swigregister", OutputBuffer_swigregister, METH_O, NULL}, + { "OutputBuffer_swiginit", OutputBuffer_swiginit, METH_VARARGS, NULL}, + { "delete_FrontConfig", _wrap_delete_FrontConfig, METH_O, NULL}, + { "FrontConfig_threadPoolSize", _wrap_FrontConfig_threadPoolSize, METH_O, NULL}, + { "FrontConfig_setThreadPoolSize", _wrap_FrontConfig_setThreadPoolSize, METH_VARARGS, NULL}, + { "FrontConfig_nodeID", _wrap_FrontConfig_nodeID, METH_O, NULL}, + { "FrontConfig_setNodeID", _wrap_FrontConfig_setNodeID, METH_VARARGS, NULL}, + { "FrontConfig_selfEndPoint", _wrap_FrontConfig_selfEndPoint, METH_O, NULL}, + { "FrontConfig_mutableSelfEndPoint", _wrap_FrontConfig_mutableSelfEndPoint, METH_O, NULL}, + { "FrontConfig_setSelfEndPoint", _wrap_FrontConfig_setSelfEndPoint, METH_VARARGS, NULL}, + { "FrontConfig_setGatewayGrpcTarget", _wrap_FrontConfig_setGatewayGrpcTarget, METH_VARARGS, NULL}, + { "FrontConfig_gatewayGrpcTarget", _wrap_FrontConfig_gatewayGrpcTarget, METH_O, NULL}, + { "FrontConfig_setGrpcConfig", _wrap_FrontConfig_setGrpcConfig, METH_VARARGS, NULL}, + { "FrontConfig_grpcConfig", _wrap_FrontConfig_grpcConfig, METH_O, NULL}, + { "FrontConfig_generateNodeInfo", _wrap_FrontConfig_generateNodeInfo, METH_O, NULL}, + { "FrontConfig_getComponents", _wrap_FrontConfig_getComponents, METH_O, NULL}, + { "FrontConfig_setComponents", _wrap_FrontConfig_setComponents, METH_VARARGS, NULL}, + { "FrontConfig_addComponent", _wrap_FrontConfig_addComponent, METH_VARARGS, NULL}, + { "FrontConfig_mutableComponents", _wrap_FrontConfig_mutableComponents, METH_O, NULL}, + { "FrontConfig_swigregister", FrontConfig_swigregister, METH_O, NULL}, + { "delete_FrontConfigBuilder", _wrap_delete_FrontConfigBuilder, METH_O, NULL}, + { "FrontConfigBuilder_build", _wrap_FrontConfigBuilder_build, METH_VARARGS, NULL}, + { "FrontConfigBuilder_swigregister", FrontConfigBuilder_swigregister, METH_O, NULL}, + { "printFrontDesc", _wrap_printFrontDesc, METH_O, NULL}, + { "new_EndPoint", _wrap_new_EndPoint, METH_VARARGS, NULL}, + { "delete_EndPoint", _wrap_delete_EndPoint, METH_O, NULL}, + { "EndPoint_host", _wrap_EndPoint_host, METH_O, NULL}, + { "EndPoint_port", _wrap_EndPoint_port, METH_O, NULL}, + { "EndPoint_setHost", _wrap_EndPoint_setHost, METH_VARARGS, NULL}, + { "EndPoint_setPort", _wrap_EndPoint_setPort, METH_VARARGS, NULL}, + { "EndPoint_setListenIp", _wrap_EndPoint_setListenIp, METH_VARARGS, NULL}, + { "EndPoint_entryPoint", _wrap_EndPoint_entryPoint, METH_O, NULL}, + { "EndPoint_listenEndPoint", _wrap_EndPoint_listenEndPoint, METH_O, NULL}, + { "EndPoint_listenIp", _wrap_EndPoint_listenIp, METH_O, NULL}, + { "EndPoint_swigregister", EndPoint_swigregister, METH_O, NULL}, + { "EndPoint_swiginit", EndPoint_swiginit, METH_VARARGS, NULL}, + { "new_GrpcServerConfig", _wrap_new_GrpcServerConfig, METH_VARARGS, NULL}, + { "GrpcServerConfig_listenEndPoint", _wrap_GrpcServerConfig_listenEndPoint, METH_O, NULL}, + { "GrpcServerConfig_setEndPoint", _wrap_GrpcServerConfig_setEndPoint, METH_VARARGS, NULL}, + { "GrpcServerConfig_setEnableHealthCheck", _wrap_GrpcServerConfig_setEnableHealthCheck, METH_VARARGS, NULL}, + { "GrpcServerConfig_endPoint", _wrap_GrpcServerConfig_endPoint, METH_O, NULL}, + { "GrpcServerConfig_mutableEndPoint", _wrap_GrpcServerConfig_mutableEndPoint, METH_O, NULL}, + { "GrpcServerConfig_enableHealthCheck", _wrap_GrpcServerConfig_enableHealthCheck, METH_O, NULL}, + { "delete_GrpcServerConfig", _wrap_delete_GrpcServerConfig, METH_O, NULL}, + { "GrpcServerConfig_swigregister", GrpcServerConfig_swigregister, METH_O, NULL}, + { "GrpcServerConfig_swiginit", GrpcServerConfig_swiginit, METH_VARARGS, NULL}, + { "new_GrpcConfig", _wrap_new_GrpcConfig, METH_NOARGS, NULL}, + { "delete_GrpcConfig", _wrap_delete_GrpcConfig, METH_O, NULL}, + { "GrpcConfig_loadBalancePolicy", _wrap_GrpcConfig_loadBalancePolicy, METH_O, NULL}, + { "GrpcConfig_setLoadBalancePolicy", _wrap_GrpcConfig_setLoadBalancePolicy, METH_VARARGS, NULL}, + { "GrpcConfig_enableHealthCheck", _wrap_GrpcConfig_enableHealthCheck, METH_O, NULL}, + { "GrpcConfig_setEnableHealthCheck", _wrap_GrpcConfig_setEnableHealthCheck, METH_VARARGS, NULL}, + { "GrpcConfig_setEnableDnslookup", _wrap_GrpcConfig_setEnableDnslookup, METH_VARARGS, NULL}, + { "GrpcConfig_enableDnslookup", _wrap_GrpcConfig_enableDnslookup, METH_O, NULL}, + { "GrpcConfig_swigregister", GrpcConfig_swigregister, METH_O, NULL}, + { "GrpcConfig_swiginit", GrpcConfig_swiginit, METH_VARARGS, NULL}, + { "delete_MessageOptionalHeader", _wrap_delete_MessageOptionalHeader, METH_O, NULL}, + { "MessageOptionalHeader_encode", _wrap_MessageOptionalHeader_encode, METH_VARARGS, NULL}, + { "MessageOptionalHeader_decode", _wrap_MessageOptionalHeader_decode, METH_VARARGS, NULL}, + { "MessageOptionalHeader_componentType", _wrap_MessageOptionalHeader_componentType, METH_O, NULL}, + { "MessageOptionalHeader_setComponentType", _wrap_MessageOptionalHeader_setComponentType, METH_VARARGS, NULL}, + { "MessageOptionalHeader_srcNode", _wrap_MessageOptionalHeader_srcNode, METH_O, NULL}, + { "MessageOptionalHeader_srcNodeBuffer", _wrap_MessageOptionalHeader_srcNodeBuffer, METH_O, " for swig-wrapper(pass the binary data)"}, + { "MessageOptionalHeader_setSrcNode", _wrap_MessageOptionalHeader_setSrcNode, METH_VARARGS, NULL}, + { "MessageOptionalHeader_dstNode", _wrap_MessageOptionalHeader_dstNode, METH_O, NULL}, + { "MessageOptionalHeader_dstNodeBuffer", _wrap_MessageOptionalHeader_dstNodeBuffer, METH_O, NULL}, + { "MessageOptionalHeader_setDstNode", _wrap_MessageOptionalHeader_setDstNode, METH_VARARGS, NULL}, + { "MessageOptionalHeader_setDstNodeBuffer", _wrap_MessageOptionalHeader_setDstNodeBuffer, METH_VARARGS, NULL}, + { "MessageOptionalHeader_dstInst", _wrap_MessageOptionalHeader_dstInst, METH_O, NULL}, + { "MessageOptionalHeader_setDstInst", _wrap_MessageOptionalHeader_setDstInst, METH_VARARGS, NULL}, + { "MessageOptionalHeader_topic", _wrap_MessageOptionalHeader_topic, METH_O, NULL}, + { "MessageOptionalHeader_setTopic", _wrap_MessageOptionalHeader_setTopic, METH_VARARGS, NULL}, + { "MessageOptionalHeader_srcInst", _wrap_MessageOptionalHeader_srcInst, METH_O, NULL}, + { "MessageOptionalHeader_setSrcInst", _wrap_MessageOptionalHeader_setSrcInst, METH_VARARGS, NULL}, + { "MessageOptionalHeader_swigregister", MessageOptionalHeader_swigregister, METH_O, NULL}, + { "delete_MessageHeader", _wrap_delete_MessageHeader, METH_O, NULL}, + { "MessageHeader_encode", _wrap_MessageHeader_encode, METH_VARARGS, NULL}, + { "MessageHeader_decode", _wrap_MessageHeader_decode, METH_VARARGS, NULL}, + { "MessageHeader_version", _wrap_MessageHeader_version, METH_O, NULL}, + { "MessageHeader_setVersion", _wrap_MessageHeader_setVersion, METH_VARARGS, NULL}, + { "MessageHeader_traceID", _wrap_MessageHeader_traceID, METH_O, NULL}, + { "MessageHeader_setTraceID", _wrap_MessageHeader_setTraceID, METH_VARARGS, NULL}, + { "MessageHeader_srcGwNode", _wrap_MessageHeader_srcGwNode, METH_O, NULL}, + { "MessageHeader_setSrcGwNode", _wrap_MessageHeader_setSrcGwNode, METH_VARARGS, NULL}, + { "MessageHeader_dstGwNode", _wrap_MessageHeader_dstGwNode, METH_O, NULL}, + { "MessageHeader_setDstGwNode", _wrap_MessageHeader_setDstGwNode, METH_VARARGS, NULL}, + { "MessageHeader_packetType", _wrap_MessageHeader_packetType, METH_O, NULL}, + { "MessageHeader_setPacketType", _wrap_MessageHeader_setPacketType, METH_VARARGS, NULL}, + { "MessageHeader_ttl", _wrap_MessageHeader_ttl, METH_O, NULL}, + { "MessageHeader_setTTL", _wrap_MessageHeader_setTTL, METH_VARARGS, NULL}, + { "MessageHeader_ext", _wrap_MessageHeader_ext, METH_O, NULL}, + { "MessageHeader_setExt", _wrap_MessageHeader_setExt, METH_VARARGS, NULL}, + { "MessageHeader_optionalField", _wrap_MessageHeader_optionalField, METH_O, NULL}, + { "MessageHeader_setOptionalField", _wrap_MessageHeader_setOptionalField, METH_VARARGS, NULL}, + { "MessageHeader_length", _wrap_MessageHeader_length, METH_O, NULL}, + { "MessageHeader_isRespPacket", _wrap_MessageHeader_isRespPacket, METH_O, NULL}, + { "MessageHeader_setRespPacket", _wrap_MessageHeader_setRespPacket, METH_O, NULL}, + { "MessageHeader_srcP2PNodeIDView", _wrap_MessageHeader_srcP2PNodeIDView, METH_O, NULL}, + { "MessageHeader_dstP2PNodeIDView", _wrap_MessageHeader_dstP2PNodeIDView, METH_O, NULL}, + { "MessageHeader_routeType", _wrap_MessageHeader_routeType, METH_O, NULL}, + { "MessageHeader_setRouteType", _wrap_MessageHeader_setRouteType, METH_VARARGS, NULL}, + { "MessageHeader_hasOptionalField", _wrap_MessageHeader_hasOptionalField, METH_O, NULL}, + { "MessageHeader_swigregister", MessageHeader_swigregister, METH_O, NULL}, + { "delete_Message", _wrap_delete_Message, METH_O, NULL}, + { "Message_header", _wrap_Message_header, METH_O, NULL}, + { "Message_setHeader", _wrap_Message_setHeader, METH_VARARGS, NULL}, + { "Message_version", _wrap_Message_version, METH_O, " the overloaed implementation ==="}, + { "Message_setVersion", _wrap_Message_setVersion, METH_VARARGS, NULL}, + { "Message_packetType", _wrap_Message_packetType, METH_O, NULL}, + { "Message_setPacketType", _wrap_Message_setPacketType, METH_VARARGS, NULL}, + { "Message_seq", _wrap_Message_seq, METH_O, NULL}, + { "Message_setSeq", _wrap_Message_setSeq, METH_VARARGS, NULL}, + { "Message_ext", _wrap_Message_ext, METH_O, NULL}, + { "Message_setExt", _wrap_Message_setExt, METH_VARARGS, NULL}, + { "Message_isRespPacket", _wrap_Message_isRespPacket, METH_O, NULL}, + { "Message_setRespPacket", _wrap_Message_setRespPacket, METH_O, NULL}, + { "Message_length", _wrap_Message_length, METH_O, NULL}, + { "Message_payload", _wrap_Message_payload, METH_O, NULL}, + { "Message_payloadBuffer", _wrap_Message_payloadBuffer, METH_O, NULL}, + { "Message_setPayload", _wrap_Message_setPayload, METH_VARARGS, NULL}, + { "Message_setFrontMessage", _wrap_Message_setFrontMessage, METH_VARARGS, NULL}, + { "Message_frontMessage", _wrap_Message_frontMessage, METH_O, NULL}, + { "Message_encode", _wrap_Message_encode, METH_VARARGS, NULL}, + { "Message_decode", _wrap_Message_decode, METH_VARARGS, NULL}, + { "Message_swigregister", Message_swigregister, METH_O, NULL}, + { "delete_MessageHeaderBuilder", _wrap_delete_MessageHeaderBuilder, METH_O, NULL}, + { "MessageHeaderBuilder_build", _wrap_MessageHeaderBuilder_build, METH_VARARGS, NULL}, + { "MessageHeaderBuilder_swigregister", MessageHeaderBuilder_swigregister, METH_O, NULL}, + { "delete_MessageBuilder", _wrap_delete_MessageBuilder, METH_O, NULL}, + { "MessageBuilder_build", _wrap_MessageBuilder_build, METH_VARARGS, NULL}, + { "MessageBuilder_swigregister", MessageBuilder_swigregister, METH_O, NULL}, + { "delete_MessageOptionalHeaderBuilder", _wrap_delete_MessageOptionalHeaderBuilder, METH_O, NULL}, + { "MessageOptionalHeaderBuilder_build", _wrap_MessageOptionalHeaderBuilder_build, METH_VARARGS, NULL}, + { "MessageOptionalHeaderBuilder_swigregister", MessageOptionalHeaderBuilder_swigregister, METH_O, NULL}, + { "printOptionalField", _wrap_printOptionalField, METH_O, NULL}, + { "printMessage", _wrap_printMessage, METH_O, NULL}, + { "printWsMessage", _wrap_printWsMessage, METH_O, NULL}, + { "delete_MessagePayload", _wrap_delete_MessagePayload, METH_O, NULL}, + { "MessagePayload_encode", _wrap_MessagePayload_encode, METH_VARARGS, NULL}, + { "MessagePayload_decode", _wrap_MessagePayload_decode, METH_VARARGS, NULL}, + { "MessagePayload_version", _wrap_MessagePayload_version, METH_O, NULL}, + { "MessagePayload_setVersion", _wrap_MessagePayload_setVersion, METH_VARARGS, NULL}, + { "MessagePayload_data", _wrap_MessagePayload_data, METH_O, NULL}, + { "MessagePayload_dataBuffer", _wrap_MessagePayload_dataBuffer, METH_O, NULL}, + { "MessagePayload_setData", _wrap_MessagePayload_setData, METH_VARARGS, NULL}, + { "MessagePayload_seq", _wrap_MessagePayload_seq, METH_O, NULL}, + { "MessagePayload_setSeq", _wrap_MessagePayload_setSeq, METH_VARARGS, NULL}, + { "MessagePayload_length", _wrap_MessagePayload_length, METH_O, NULL}, + { "MessagePayload_traceID", _wrap_MessagePayload_traceID, METH_O, NULL}, + { "MessagePayload_setTraceID", _wrap_MessagePayload_setTraceID, METH_VARARGS, NULL}, + { "MessagePayload_ext", _wrap_MessagePayload_ext, METH_O, NULL}, + { "MessagePayload_setExt", _wrap_MessagePayload_setExt, METH_VARARGS, NULL}, + { "MessagePayload_setRespPacket", _wrap_MessagePayload_setRespPacket, METH_O, NULL}, + { "MessagePayload_isRespPacket", _wrap_MessagePayload_isRespPacket, METH_O, NULL}, + { "MessagePayload_swigregister", MessagePayload_swigregister, METH_O, NULL}, + { "delete_MessagePayloadBuilder", _wrap_delete_MessagePayloadBuilder, METH_O, NULL}, + { "MessagePayloadBuilder_build", _wrap_MessagePayloadBuilder_build, METH_VARARGS, NULL}, + { "MessagePayloadBuilder_swigregister", MessagePayloadBuilder_swigregister, METH_O, NULL}, + { "delete_IFrontClient", _wrap_delete_IFrontClient, METH_O, NULL}, + { "IFrontClient_onReceiveMessage", _wrap_IFrontClient_onReceiveMessage, METH_VARARGS, "\n" + ": receive message from gateway, call by gateway\n" + ":param _message:: received ppc message\n" + ":rtype: void\n" + ":return: void\n" + ""}, + { "IFrontClient_swigregister", IFrontClient_swigregister, METH_O, NULL}, + { "new_ErrorCallback", _wrap_new_ErrorCallback, METH_O, NULL}, + { "delete_ErrorCallback", _wrap_delete_ErrorCallback, METH_O, NULL}, + { "ErrorCallback_onError", _wrap_ErrorCallback_onError, METH_VARARGS, NULL}, + { "disown_ErrorCallback", _wrap_disown_ErrorCallback, METH_O, NULL}, + { "ErrorCallback_swigregister", ErrorCallback_swigregister, METH_O, NULL}, + { "ErrorCallback_swiginit", ErrorCallback_swiginit, METH_VARARGS, NULL}, + { "new_MessageDispatcherHandler", _wrap_new_MessageDispatcherHandler, METH_O, NULL}, + { "delete_MessageDispatcherHandler", _wrap_delete_MessageDispatcherHandler, METH_O, NULL}, + { "MessageDispatcherHandler_onMessage", _wrap_MessageDispatcherHandler_onMessage, METH_VARARGS, NULL}, + { "disown_MessageDispatcherHandler", _wrap_disown_MessageDispatcherHandler, METH_O, NULL}, + { "MessageDispatcherHandler_swigregister", MessageDispatcherHandler_swigregister, METH_O, NULL}, + { "MessageDispatcherHandler_swiginit", MessageDispatcherHandler_swiginit, METH_VARARGS, NULL}, + { "new_SendResponseHandler", _wrap_new_SendResponseHandler, METH_O, NULL}, + { "delete_SendResponseHandler", _wrap_delete_SendResponseHandler, METH_O, NULL}, + { "SendResponseHandler_sendResponse", _wrap_SendResponseHandler_sendResponse, METH_VARARGS, NULL}, + { "SendResponseHandler_swigregister", SendResponseHandler_swigregister, METH_O, NULL}, + { "SendResponseHandler_swiginit", SendResponseHandler_swiginit, METH_VARARGS, NULL}, + { "new_IMessageHandler", _wrap_new_IMessageHandler, METH_O, NULL}, + { "delete_IMessageHandler", _wrap_delete_IMessageHandler, METH_O, NULL}, + { "IMessageHandler_onMessage", _wrap_IMessageHandler_onMessage, METH_VARARGS, NULL}, + { "disown_IMessageHandler", _wrap_disown_IMessageHandler, METH_O, NULL}, + { "IMessageHandler_swigregister", IMessageHandler_swigregister, METH_O, NULL}, + { "IMessageHandler_swiginit", IMessageHandler_swiginit, METH_VARARGS, NULL}, + { "new_GetPeersInfoHandler", _wrap_new_GetPeersInfoHandler, METH_O, NULL}, + { "delete_GetPeersInfoHandler", _wrap_delete_GetPeersInfoHandler, METH_O, NULL}, + { "GetPeersInfoHandler_onPeersInfo", _wrap_GetPeersInfoHandler_onPeersInfo, METH_VARARGS, NULL}, + { "disown_GetPeersInfoHandler", _wrap_disown_GetPeersInfoHandler, METH_O, NULL}, + { "GetPeersInfoHandler_swigregister", GetPeersInfoHandler_swigregister, METH_O, NULL}, + { "GetPeersInfoHandler_swiginit", GetPeersInfoHandler_swiginit, METH_VARARGS, NULL}, + { "delete_IFront", _wrap_delete_IFront, METH_O, NULL}, + { "IFront_start", _wrap_IFront_start, METH_O, "\n" + "start the IFront\n" + "\n" + ":param front: the IFront to start\n" + ""}, + { "IFront_stop", _wrap_IFront_stop, METH_O, "\n" + "stop the IFront\n" + "\n" + ":param front: the IFront to stop\n" + ""}, + { "IFront_register_topic_handler", _wrap_IFront_register_topic_handler, METH_VARARGS, NULL}, + { "IFront_register_msg_handler", _wrap_IFront_register_msg_handler, METH_VARARGS, NULL}, + { "IFront_async_send_message", _wrap_IFront_async_send_message, METH_VARARGS, NULL}, + { "IFront_async_send_response", _wrap_IFront_async_send_response, METH_VARARGS, NULL}, + { "IFront_push", _wrap_IFront_push, METH_VARARGS, NULL}, + { "IFront_push_msg", _wrap_IFront_push_msg, METH_VARARGS, NULL}, + { "IFront_pop", _wrap_IFront_pop, METH_VARARGS, NULL}, + { "IFront_peek", _wrap_IFront_peek, METH_VARARGS, NULL}, + { "IFront_asyncGetPeers", _wrap_IFront_asyncGetPeers, METH_VARARGS, NULL}, + { "IFront_registerNodeInfo", _wrap_IFront_registerNodeInfo, METH_VARARGS, "\n" + "register the nodeInfo to the gateway\n" + ":type nodeInfo: ppc::protocol::INodeInfo::Ptr\n" + ":param nodeInfo: the nodeInfo\n" + ""}, + { "IFront_unRegisterNodeInfo", _wrap_IFront_unRegisterNodeInfo, METH_O, "unRegister the nodeInfo to the gateway"}, + { "IFront_nodeInfo", _wrap_IFront_nodeInfo, METH_O, NULL}, + { "IFront_registerTopic", _wrap_IFront_registerTopic, METH_VARARGS, "\n" + "register the topic\n" + "\n" + ":type topic: string\n" + ":param topic: the topic to register\n" + ""}, + { "IFront_unRegisterTopic", _wrap_IFront_unRegisterTopic, METH_VARARGS, "\n" + "unRegister the topic\n" + "\n" + ":type topic: string\n" + ":param topic: the topic to unregister\n" + ""}, + { "IFront_registerComponent", _wrap_IFront_registerComponent, METH_VARARGS, NULL}, + { "IFront_unRegisterComponent", _wrap_IFront_unRegisterComponent, METH_VARARGS, NULL}, + { "IFront_swigregister", IFront_swigregister, METH_O, NULL}, + { "delete_IFrontBuilder", _wrap_delete_IFrontBuilder, METH_O, NULL}, + { "IFrontBuilder_buildClient", _wrap_IFrontBuilder_buildClient, METH_VARARGS, NULL}, + { "IFrontBuilder_swigregister", IFrontBuilder_swigregister, METH_O, NULL}, + { "new_TransportBuilder", _wrap_new_TransportBuilder, METH_NOARGS, NULL}, + { "delete_TransportBuilder", _wrap_delete_TransportBuilder, METH_O, NULL}, + { "TransportBuilder_buildProTransport", _wrap_TransportBuilder_buildProTransport, METH_VARARGS, NULL}, + { "TransportBuilder_buildConfig", _wrap_TransportBuilder_buildConfig, METH_VARARGS, NULL}, + { "TransportBuilder_frontConfigBuilder", _wrap_TransportBuilder_frontConfigBuilder, METH_O, NULL}, + { "TransportBuilder_swigregister", TransportBuilder_swigregister, METH_O, NULL}, + { "TransportBuilder_swiginit", TransportBuilder_swiginit, METH_VARARGS, NULL}, + { "new_Transport", _wrap_new_Transport, METH_O, NULL}, + { "delete_Transport", _wrap_delete_Transport, METH_O, NULL}, + { "Transport_start", _wrap_Transport_start, METH_O, NULL}, + { "Transport_stop", _wrap_Transport_stop, METH_O, NULL}, + { "Transport_getFront", _wrap_Transport_getFront, METH_O, NULL}, + { "Transport_gateway", _wrap_Transport_gateway, METH_O, NULL}, + { "Transport_msgPayloadBuilder", _wrap_Transport_msgPayloadBuilder, METH_O, NULL}, + { "Transport_msgBuilder", _wrap_Transport_msgBuilder, METH_O, NULL}, + { "Transport_msgHeaderBuilder", _wrap_Transport_msgHeaderBuilder, METH_O, NULL}, + { "Transport_routeInfoBuilder", _wrap_Transport_routeInfoBuilder, METH_O, NULL}, + { "Transport_getConfig", _wrap_Transport_getConfig, METH_O, NULL}, + { "Transport_swigregister", Transport_swigregister, METH_O, NULL}, + { "Transport_swiginit", Transport_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_ppc__front__IFrontTo_p_ppc__front__IFrontClient(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ppc::front::IFrontClient *) ((ppc::front::IFront *) x)); +} +static void *_p_std__shared_ptrT_ppc__front__IFront_tTo_p_std__shared_ptrT_ppc__front__IFrontClient_t(void *x, int *newmemory) { + *newmemory = SWIG_CAST_NEW_MEMORY; + return (void *) new std::shared_ptr< ppc::front::IFrontClient >(*(std::shared_ptr< ppc::front::IFront > *)x); +} +static swig_type_info _swigt__p_ConstPtr = {"_p_ConstPtr", "ConstPtr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_InputBuffer = {"_p_InputBuffer", "InputBuffer *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_OutputBuffer = {"_p_OutputBuffer", "OutputBuffer *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PrevStdError = {"_p_PrevStdError", "PrevStdError *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Ptr = {"_p_Ptr", "Ptr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_UniqueConstPtr = {"_p_UniqueConstPtr", "UniqueConstPtr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_UniquePtr = {"_p_UniquePtr", "UniquePtr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_bcos__Error = {"_p_bcos__Error", "bcos::Error *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_bcos__boostssl__EncodedMsg = {"_p_bcos__boostssl__EncodedMsg", "bcos::boostssl::EncodedMsg *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_bcos__boostssl__MessageFace__Ptr = {"_p_bcos__boostssl__MessageFace__Ptr", "bcos::boostssl::MessageFace::Ptr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_bcos__bytesConstRef = {"_p_bcos__bytesConstRef", "bcos::bytesConstRef *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__ErrorCallback = {"_p_ppc__front__ErrorCallback", "ppc::front::ErrorCallback *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__FrontConfig = {"_p_ppc__front__FrontConfig", "ppc::front::FrontConfig *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__FrontConfigBuilder = {"_p_ppc__front__FrontConfigBuilder", "ppc::front::FrontConfigBuilder *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__GetPeersInfoHandler = {"_p_ppc__front__GetPeersInfoHandler", "ppc::front::GetPeersInfoHandler *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__IFront = {"_p_ppc__front__IFront", "ppc::front::IFront *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__IFrontBuilder = {"_p_ppc__front__IFrontBuilder", "ppc::front::IFrontBuilder *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__IFrontClient = {"_p_ppc__front__IFrontClient", "ppc::front::IFrontClient *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__IMessageHandler = {"_p_ppc__front__IMessageHandler", "ppc::front::IMessageHandler *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__MessageDispatcherHandler = {"_p_ppc__front__MessageDispatcherHandler", "ppc::front::MessageDispatcherHandler *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__front__SendResponseHandler = {"_p_ppc__front__SendResponseHandler", "ppc::front::SendResponseHandler *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__gateway__IGateway__Ptr = {"_p_ppc__gateway__IGateway__Ptr", "ppc::gateway::IGateway::Ptr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__EndPoint = {"_p_ppc__protocol__EndPoint", "ppc::protocol::EndPoint *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__GrpcConfig = {"_p_ppc__protocol__GrpcConfig", "ppc::protocol::GrpcConfig *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__GrpcServerConfig = {"_p_ppc__protocol__GrpcServerConfig", "ppc::protocol::GrpcServerConfig *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__INodeInfo__Ptr = {"_p_ppc__protocol__INodeInfo__Ptr", "ppc::protocol::INodeInfo::Ptr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__Message = {"_p_ppc__protocol__Message", "ppc::protocol::Message *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__MessageBuilder = {"_p_ppc__protocol__MessageBuilder", "ppc::protocol::MessageBuilder *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__MessageHeader = {"_p_ppc__protocol__MessageHeader", "ppc::protocol::MessageHeader *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__MessageHeaderBuilder = {"_p_ppc__protocol__MessageHeaderBuilder", "ppc::protocol::MessageHeaderBuilder *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__MessageOptionalHeader = {"_p_ppc__protocol__MessageOptionalHeader", "ppc::protocol::MessageOptionalHeader *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__MessageOptionalHeaderBuilder = {"_p_ppc__protocol__MessageOptionalHeaderBuilder", "ppc::protocol::MessageOptionalHeaderBuilder *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__MessagePayload = {"_p_ppc__protocol__MessagePayload", "ppc::protocol::MessagePayload *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__MessagePayloadBuilder = {"_p_ppc__protocol__MessagePayloadBuilder", "ppc::protocol::MessagePayloadBuilder *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__protocol__RouteType = {"_p_ppc__protocol__RouteType", "ppc::protocol::RouteType *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__sdk__Transport = {"_p_ppc__sdk__Transport", "ppc::sdk::Transport *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ppc__sdk__TransportBuilder = {"_p_ppc__sdk__TransportBuilder", "ppc::sdk::TransportBuilder *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_short = {"_p_short", "int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "int8_t *|int_fast8_t *|int_least8_t *|signed char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_signed_char_t = {"_p_std__allocatorT_signed_char_t", "std::vector< signed char >::allocator_type *|std::allocator< signed char > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__allocatorT_unsigned_char_t = {"_p_std__allocatorT_unsigned_char_t", "std::vector< unsigned char >::allocator_type *|std::allocator< unsigned char > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__functionT_void_fF_t = {"_p_std__functionT_void_fF_t", "std::function< void () > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t = {"_p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t", "ppc::protocol::ReceiveMsgFunc *|std::function< void (std::shared_ptr< bcos::Error >) > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_t_std__shared_ptrT_ppc__protocol__Message_t_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_tF_t = {"_p_std__functionT_void_fstd__shared_ptrT_bcos__Error_t_std__shared_ptrT_ppc__protocol__Message_t_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_tF_t", "ppc::protocol::MessageCallback *|std::function< void (std::shared_ptr< bcos::Error >,std::shared_ptr< ppc::protocol::Message >,std::function< void (std::shared_ptr< bcos::bytes > &&) >) > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t = {"_p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t", "ppc::protocol::SendResponseFunction *|std::function< void (std::shared_ptr< bcos::bytes > &&) > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__functionT_void_fstd__shared_ptrT_ppc__protocol__Message_tF_t = {"_p_std__functionT_void_fstd__shared_ptrT_ppc__protocol__Message_tF_t", "ppc::protocol::MessageDispatcherCallback *|std::function< void (std::shared_ptr< ppc::protocol::Message >) > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_bcos__Error_t = {"_p_std__shared_ptrT_bcos__Error_t", "std::shared_ptr< bcos::Error > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_bcos__bytes_t = {"_p_std__shared_ptrT_bcos__bytes_t", "std::shared_ptr< bcos::bytes > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__ErrorCallback_t = {"_p_std__shared_ptrT_ppc__front__ErrorCallback_t", "std::shared_ptr< ppc::front::ErrorCallback > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t = {"_p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t", "ppc::front::FrontConfigBuilder::Ptr *|std::shared_ptr< ppc::front::FrontConfigBuilder > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__FrontConfig_t = {"_p_std__shared_ptrT_ppc__front__FrontConfig_t", "std::shared_ptr< ppc::front::FrontConfig > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t = {"_p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t", "std::shared_ptr< ppc::front::GetPeersInfoHandler > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__IFrontClient_t = {"_p_std__shared_ptrT_ppc__front__IFrontClient_t", "std::shared_ptr< ppc::front::IFrontClient > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__IFront_t = {"_p_std__shared_ptrT_ppc__front__IFront_t", "std::shared_ptr< ppc::front::IFront > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__IMessageHandler_t = {"_p_std__shared_ptrT_ppc__front__IMessageHandler_t", "std::shared_ptr< ppc::front::IMessageHandler > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t = {"_p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t", "std::shared_ptr< ppc::front::MessageDispatcherHandler > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__gateway__IGateway_t = {"_p_std__shared_ptrT_ppc__gateway__IGateway_t", "std::shared_ptr< ppc::gateway::IGateway > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__GrpcConfig_t = {"_p_std__shared_ptrT_ppc__protocol__GrpcConfig_t", "std::shared_ptr< ppc::protocol::GrpcConfig > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__MessageBuilder_t = {"_p_std__shared_ptrT_ppc__protocol__MessageBuilder_t", "std::shared_ptr< ppc::protocol::MessageBuilder > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t = {"_p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t", "std::shared_ptr< ppc::protocol::MessageHeaderBuilder > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__MessageHeader_t = {"_p_std__shared_ptrT_ppc__protocol__MessageHeader_t", "std::shared_ptr< ppc::protocol::MessageHeader > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t = {"_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t", "std::shared_ptr< ppc::protocol::MessageOptionalHeaderBuilder > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t = {"_p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t", "std::shared_ptr< ppc::protocol::MessageOptionalHeader > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t = {"_p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t", "std::shared_ptr< ppc::protocol::MessagePayloadBuilder > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__MessagePayload_t = {"_p_std__shared_ptrT_ppc__protocol__MessagePayload_t", "std::shared_ptr< ppc::protocol::MessagePayload > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__protocol__Message_t = {"_p_std__shared_ptrT_ppc__protocol__Message_t", "std::shared_ptr< ppc::protocol::Message > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__shared_ptrT_ppc__sdk__Transport_t = {"_p_std__shared_ptrT_ppc__sdk__Transport_t", "std::shared_ptr< ppc::sdk::Transport > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__string_view = {"_p_std__string_view", "std::string_view *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_int8_t_t = {"_p_std__vectorT_int8_t_t", "std::vector< int8_t > *|std::vector< signed char,std::allocator< signed char > > *|std::vector< signed char > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_uint8_t_t = {"_p_std__vectorT_uint8_t_t", "bcos::bytes *|std::vector< uint8_t > *|std::vector< unsigned char,std::allocator< unsigned char > > *|std::vector< unsigned char > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "bcos::byte *|uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_ConstPtr, + &_swigt__p_InputBuffer, + &_swigt__p_OutputBuffer, + &_swigt__p_PrevStdError, + &_swigt__p_Ptr, + &_swigt__p_UniqueConstPtr, + &_swigt__p_UniquePtr, + &_swigt__p_allocator_type, + &_swigt__p_bcos__Error, + &_swigt__p_bcos__boostssl__EncodedMsg, + &_swigt__p_bcos__boostssl__MessageFace__Ptr, + &_swigt__p_bcos__bytesConstRef, + &_swigt__p_char, + &_swigt__p_difference_type, + &_swigt__p_int, + &_swigt__p_long_long, + &_swigt__p_p_PyObject, + &_swigt__p_ppc__front__ErrorCallback, + &_swigt__p_ppc__front__FrontConfig, + &_swigt__p_ppc__front__FrontConfigBuilder, + &_swigt__p_ppc__front__GetPeersInfoHandler, + &_swigt__p_ppc__front__IFront, + &_swigt__p_ppc__front__IFrontBuilder, + &_swigt__p_ppc__front__IFrontClient, + &_swigt__p_ppc__front__IMessageHandler, + &_swigt__p_ppc__front__MessageDispatcherHandler, + &_swigt__p_ppc__front__SendResponseHandler, + &_swigt__p_ppc__gateway__IGateway__Ptr, + &_swigt__p_ppc__protocol__EndPoint, + &_swigt__p_ppc__protocol__GrpcConfig, + &_swigt__p_ppc__protocol__GrpcServerConfig, + &_swigt__p_ppc__protocol__INodeInfo__Ptr, + &_swigt__p_ppc__protocol__Message, + &_swigt__p_ppc__protocol__MessageBuilder, + &_swigt__p_ppc__protocol__MessageHeader, + &_swigt__p_ppc__protocol__MessageHeaderBuilder, + &_swigt__p_ppc__protocol__MessageOptionalHeader, + &_swigt__p_ppc__protocol__MessageOptionalHeaderBuilder, + &_swigt__p_ppc__protocol__MessagePayload, + &_swigt__p_ppc__protocol__MessagePayloadBuilder, + &_swigt__p_ppc__protocol__RouteType, + &_swigt__p_ppc__sdk__Transport, + &_swigt__p_ppc__sdk__TransportBuilder, + &_swigt__p_short, + &_swigt__p_signed_char, + &_swigt__p_size_type, + &_swigt__p_std__allocatorT_signed_char_t, + &_swigt__p_std__allocatorT_unsigned_char_t, + &_swigt__p_std__exception, + &_swigt__p_std__functionT_void_fF_t, + &_swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t, + &_swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_t_std__shared_ptrT_ppc__protocol__Message_t_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_tF_t, + &_swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t, + &_swigt__p_std__functionT_void_fstd__shared_ptrT_ppc__protocol__Message_tF_t, + &_swigt__p_std__invalid_argument, + &_swigt__p_std__shared_ptrT_bcos__Error_t, + &_swigt__p_std__shared_ptrT_bcos__bytes_t, + &_swigt__p_std__shared_ptrT_ppc__front__ErrorCallback_t, + &_swigt__p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t, + &_swigt__p_std__shared_ptrT_ppc__front__FrontConfig_t, + &_swigt__p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, + &_swigt__p_std__shared_ptrT_ppc__front__IFrontClient_t, + &_swigt__p_std__shared_ptrT_ppc__front__IFront_t, + &_swigt__p_std__shared_ptrT_ppc__front__IMessageHandler_t, + &_swigt__p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, + &_swigt__p_std__shared_ptrT_ppc__gateway__IGateway_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__MessageHeader_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__MessagePayload_t, + &_swigt__p_std__shared_ptrT_ppc__protocol__Message_t, + &_swigt__p_std__shared_ptrT_ppc__sdk__Transport_t, + &_swigt__p_std__string, + &_swigt__p_std__string_view, + &_swigt__p_std__vectorT_int8_t_t, + &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, + &_swigt__p_std__vectorT_uint8_t_t, + &_swigt__p_swig__SwigPyIterator, + &_swigt__p_unsigned_char, + &_swigt__p_unsigned_int, + &_swigt__p_unsigned_long_long, + &_swigt__p_unsigned_short, + &_swigt__p_value_type, +}; + +static swig_cast_info _swigc__p_ConstPtr[] = { {&_swigt__p_ConstPtr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_InputBuffer[] = { {&_swigt__p_InputBuffer, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_OutputBuffer[] = { {&_swigt__p_OutputBuffer, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PrevStdError[] = { {&_swigt__p_PrevStdError, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Ptr[] = { {&_swigt__p_Ptr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_UniqueConstPtr[] = { {&_swigt__p_UniqueConstPtr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_UniquePtr[] = { {&_swigt__p_UniquePtr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_bcos__Error[] = { {&_swigt__p_bcos__Error, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_bcos__boostssl__EncodedMsg[] = { {&_swigt__p_bcos__boostssl__EncodedMsg, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_bcos__boostssl__MessageFace__Ptr[] = { {&_swigt__p_bcos__boostssl__MessageFace__Ptr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_bcos__bytesConstRef[] = { {&_swigt__p_bcos__bytesConstRef, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__ErrorCallback[] = { {&_swigt__p_ppc__front__ErrorCallback, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__FrontConfig[] = { {&_swigt__p_ppc__front__FrontConfig, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__FrontConfigBuilder[] = { {&_swigt__p_ppc__front__FrontConfigBuilder, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__GetPeersInfoHandler[] = { {&_swigt__p_ppc__front__GetPeersInfoHandler, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__IFront[] = { {&_swigt__p_ppc__front__IFront, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__IFrontBuilder[] = { {&_swigt__p_ppc__front__IFrontBuilder, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__IFrontClient[] = { {&_swigt__p_ppc__front__IFrontClient, 0, 0, 0}, {&_swigt__p_ppc__front__IFront, _p_ppc__front__IFrontTo_p_ppc__front__IFrontClient, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__IMessageHandler[] = { {&_swigt__p_ppc__front__IMessageHandler, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__MessageDispatcherHandler[] = { {&_swigt__p_ppc__front__MessageDispatcherHandler, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__front__SendResponseHandler[] = { {&_swigt__p_ppc__front__SendResponseHandler, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__gateway__IGateway__Ptr[] = { {&_swigt__p_ppc__gateway__IGateway__Ptr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__EndPoint[] = { {&_swigt__p_ppc__protocol__EndPoint, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__GrpcConfig[] = { {&_swigt__p_ppc__protocol__GrpcConfig, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__GrpcServerConfig[] = { {&_swigt__p_ppc__protocol__GrpcServerConfig, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__INodeInfo__Ptr[] = { {&_swigt__p_ppc__protocol__INodeInfo__Ptr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__Message[] = { {&_swigt__p_ppc__protocol__Message, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__MessageBuilder[] = { {&_swigt__p_ppc__protocol__MessageBuilder, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__MessageHeader[] = { {&_swigt__p_ppc__protocol__MessageHeader, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__MessageHeaderBuilder[] = { {&_swigt__p_ppc__protocol__MessageHeaderBuilder, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__MessageOptionalHeader[] = { {&_swigt__p_ppc__protocol__MessageOptionalHeader, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__MessageOptionalHeaderBuilder[] = { {&_swigt__p_ppc__protocol__MessageOptionalHeaderBuilder, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__MessagePayload[] = { {&_swigt__p_ppc__protocol__MessagePayload, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__MessagePayloadBuilder[] = { {&_swigt__p_ppc__protocol__MessagePayloadBuilder, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__protocol__RouteType[] = { {&_swigt__p_ppc__protocol__RouteType, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__sdk__Transport[] = { {&_swigt__p_ppc__sdk__Transport, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ppc__sdk__TransportBuilder[] = { {&_swigt__p_ppc__sdk__TransportBuilder, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_signed_char_t[] = { {&_swigt__p_std__allocatorT_signed_char_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__allocatorT_unsigned_char_t[] = { {&_swigt__p_std__allocatorT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__exception[] = { {&_swigt__p_std__exception, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__functionT_void_fF_t[] = { {&_swigt__p_std__functionT_void_fF_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t[] = { {&_swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_t_std__shared_ptrT_ppc__protocol__Message_t_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_tF_t[] = { {&_swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_t_std__shared_ptrT_ppc__protocol__Message_t_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_tF_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t[] = { {&_swigt__p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__functionT_void_fstd__shared_ptrT_ppc__protocol__Message_tF_t[] = { {&_swigt__p_std__functionT_void_fstd__shared_ptrT_ppc__protocol__Message_tF_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_bcos__Error_t[] = { {&_swigt__p_std__shared_ptrT_bcos__Error_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_bcos__bytes_t[] = { {&_swigt__p_std__shared_ptrT_bcos__bytes_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__ErrorCallback_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__ErrorCallback_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__FrontConfig_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__FrontConfig_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__IFrontClient_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__IFrontClient_t, 0, 0, 0}, {&_swigt__p_std__shared_ptrT_ppc__front__IFront_t, _p_std__shared_ptrT_ppc__front__IFront_tTo_p_std__shared_ptrT_ppc__front__IFrontClient_t, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__IFront_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__IFront_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__IMessageHandler_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__IMessageHandler_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t[] = { {&_swigt__p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__gateway__IGateway_t[] = { {&_swigt__p_std__shared_ptrT_ppc__gateway__IGateway_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__GrpcConfig_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__MessageBuilder_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__MessageHeader_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__MessageHeader_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__MessagePayload_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__MessagePayload_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__protocol__Message_t[] = { {&_swigt__p_std__shared_ptrT_ppc__protocol__Message_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__shared_ptrT_ppc__sdk__Transport_t[] = { {&_swigt__p_std__shared_ptrT_ppc__sdk__Transport_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__string_view[] = { {&_swigt__p_std__string_view, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_int8_t_t[] = { {&_swigt__p_std__vectorT_int8_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = { {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_uint8_t_t[] = { {&_swigt__p_std__vectorT_uint8_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_ConstPtr, + _swigc__p_InputBuffer, + _swigc__p_OutputBuffer, + _swigc__p_PrevStdError, + _swigc__p_Ptr, + _swigc__p_UniqueConstPtr, + _swigc__p_UniquePtr, + _swigc__p_allocator_type, + _swigc__p_bcos__Error, + _swigc__p_bcos__boostssl__EncodedMsg, + _swigc__p_bcos__boostssl__MessageFace__Ptr, + _swigc__p_bcos__bytesConstRef, + _swigc__p_char, + _swigc__p_difference_type, + _swigc__p_int, + _swigc__p_long_long, + _swigc__p_p_PyObject, + _swigc__p_ppc__front__ErrorCallback, + _swigc__p_ppc__front__FrontConfig, + _swigc__p_ppc__front__FrontConfigBuilder, + _swigc__p_ppc__front__GetPeersInfoHandler, + _swigc__p_ppc__front__IFront, + _swigc__p_ppc__front__IFrontBuilder, + _swigc__p_ppc__front__IFrontClient, + _swigc__p_ppc__front__IMessageHandler, + _swigc__p_ppc__front__MessageDispatcherHandler, + _swigc__p_ppc__front__SendResponseHandler, + _swigc__p_ppc__gateway__IGateway__Ptr, + _swigc__p_ppc__protocol__EndPoint, + _swigc__p_ppc__protocol__GrpcConfig, + _swigc__p_ppc__protocol__GrpcServerConfig, + _swigc__p_ppc__protocol__INodeInfo__Ptr, + _swigc__p_ppc__protocol__Message, + _swigc__p_ppc__protocol__MessageBuilder, + _swigc__p_ppc__protocol__MessageHeader, + _swigc__p_ppc__protocol__MessageHeaderBuilder, + _swigc__p_ppc__protocol__MessageOptionalHeader, + _swigc__p_ppc__protocol__MessageOptionalHeaderBuilder, + _swigc__p_ppc__protocol__MessagePayload, + _swigc__p_ppc__protocol__MessagePayloadBuilder, + _swigc__p_ppc__protocol__RouteType, + _swigc__p_ppc__sdk__Transport, + _swigc__p_ppc__sdk__TransportBuilder, + _swigc__p_short, + _swigc__p_signed_char, + _swigc__p_size_type, + _swigc__p_std__allocatorT_signed_char_t, + _swigc__p_std__allocatorT_unsigned_char_t, + _swigc__p_std__exception, + _swigc__p_std__functionT_void_fF_t, + _swigc__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_tF_t, + _swigc__p_std__functionT_void_fstd__shared_ptrT_bcos__Error_t_std__shared_ptrT_ppc__protocol__Message_t_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_tF_t, + _swigc__p_std__functionT_void_fstd__shared_ptrT_bcos__bytes_t_RRF_t, + _swigc__p_std__functionT_void_fstd__shared_ptrT_ppc__protocol__Message_tF_t, + _swigc__p_std__invalid_argument, + _swigc__p_std__shared_ptrT_bcos__Error_t, + _swigc__p_std__shared_ptrT_bcos__bytes_t, + _swigc__p_std__shared_ptrT_ppc__front__ErrorCallback_t, + _swigc__p_std__shared_ptrT_ppc__front__FrontConfigBuilder_t, + _swigc__p_std__shared_ptrT_ppc__front__FrontConfig_t, + _swigc__p_std__shared_ptrT_ppc__front__GetPeersInfoHandler_t, + _swigc__p_std__shared_ptrT_ppc__front__IFrontClient_t, + _swigc__p_std__shared_ptrT_ppc__front__IFront_t, + _swigc__p_std__shared_ptrT_ppc__front__IMessageHandler_t, + _swigc__p_std__shared_ptrT_ppc__front__MessageDispatcherHandler_t, + _swigc__p_std__shared_ptrT_ppc__gateway__IGateway_t, + _swigc__p_std__shared_ptrT_ppc__protocol__GrpcConfig_t, + _swigc__p_std__shared_ptrT_ppc__protocol__MessageBuilder_t, + _swigc__p_std__shared_ptrT_ppc__protocol__MessageHeaderBuilder_t, + _swigc__p_std__shared_ptrT_ppc__protocol__MessageHeader_t, + _swigc__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeaderBuilder_t, + _swigc__p_std__shared_ptrT_ppc__protocol__MessageOptionalHeader_t, + _swigc__p_std__shared_ptrT_ppc__protocol__MessagePayloadBuilder_t, + _swigc__p_std__shared_ptrT_ppc__protocol__MessagePayload_t, + _swigc__p_std__shared_ptrT_ppc__protocol__Message_t, + _swigc__p_std__shared_ptrT_ppc__sdk__Transport_t, + _swigc__p_std__string, + _swigc__p_std__string_view, + _swigc__p_std__vectorT_int8_t_t, + _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, + _swigc__p_std__vectorT_uint8_t_t, + _swigc__p_swig__SwigPyIterator, + _swigc__p_unsigned_char, + _swigc__p_unsigned_int, + _swigc__p_unsigned_long_long, + _swigc__p_unsigned_short, + _swigc__p_value_type, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + +#ifndef SWIG_INIT_CLIENT_DATA_TYPE +#define SWIG_INIT_CLIENT_DATA_TYPE void * +#endif + +SWIGRUNTIME void +SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* ----------------------------------------------------------------------------- + * Patch %callback methods' docstrings to hold the callback ptrs + * -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (!c) continue; + c = strstr(c, "swig_ptr: "); + if (c) { + int j; + const swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + memcpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + memcpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + +#ifdef __cplusplus +} +#endif + + + + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md, *globals; + +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { + PyModuleDef_HEAD_INIT, + SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + SwigPyObject_own, + SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + PyTypeObject *swigpyobject; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + PyObject *self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); + assert(metatype); +#endif + + (void)globals; + + /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */ + SWIG_This(); + SWIG_Python_TypeCache(); + SwigPyPacked_type(); +#ifndef SWIGPYTHON_BUILTIN + SwigPyObject_type(); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule(SWIG_name, SwigMethods); +#endif + + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + swigpyobject = SwigPyObject_TypeOnce(); + + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = swigpyobject; + } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + SWIG_Python_SetConstant(d, "SHARED_PTR_DISOWN",SWIG_From_int(static_cast< int >(0))); + + // thread safe initialization + swig::container_owner_attribute(); + + SWIG_Python_SetConstant(d, "FrontMsgExtFlag_Response",SWIG_From_int(static_cast< int >(ppc::protocol::FrontMsgExtFlag::Response))); + SWIG_Python_SetConstant(d, "SDKMode_AIR",SWIG_From_int(static_cast< int >(ppc::sdk::SDKMode::AIR))); + SWIG_Python_SetConstant(d, "SDKMode_PRO",SWIG_From_int(static_cast< int >(ppc::sdk::SDKMode::PRO))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.h b/cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.h new file mode 100644 index 0000000..36d8b00 --- /dev/null +++ b/cpp/wedpr-transport/sdk-wrapper/python/src/wedpr_python_transportPYTHON_wrap.h @@ -0,0 +1,184 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.2.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_wedpr_python_transport_WRAP_H_ +#define SWIG_wedpr_python_transport_WRAP_H_ + +#include +#include + + +class SwigDirector_ErrorCallback : public ppc::front::ErrorCallback, public Swig::Director { + +public: + SwigDirector_ErrorCallback(PyObject *self); + virtual ~SwigDirector_ErrorCallback(); + virtual void onError(bcos::Error::Ptr error); + +/* Internal director utilities */ +public: + bool swig_get_inner(const char *swig_protected_method_name) const { + std::map::const_iterator iv = swig_inner.find(swig_protected_method_name); + return (iv != swig_inner.end() ? iv->second : false); + } + void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const { + swig_inner[swig_protected_method_name] = swig_val; + } +private: + mutable std::map swig_inner; + +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) +/* VTable implementation */ + PyObject *swig_get_method(size_t method_index, const char *method_name) const { + PyObject *method = vtable[method_index]; + if (!method) { + swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name); + method = PyObject_GetAttr(swig_get_self(), name); + if (!method) { + std::string msg = "Method in class ErrorCallback doesn't exist, undefined "; + msg += method_name; + Swig::DirectorMethodException::raise(msg.c_str()); + } + vtable[method_index] = method; + } + return method; + } +private: + mutable swig::SwigVar_PyObject vtable[1]; +#endif + +}; + + +class SwigDirector_MessageDispatcherHandler : public ppc::front::MessageDispatcherHandler, public Swig::Director { + +public: + SwigDirector_MessageDispatcherHandler(PyObject *self); + virtual ~SwigDirector_MessageDispatcherHandler(); + virtual void onMessage(ppc::protocol::Message::Ptr msg); + +/* Internal director utilities */ +public: + bool swig_get_inner(const char *swig_protected_method_name) const { + std::map::const_iterator iv = swig_inner.find(swig_protected_method_name); + return (iv != swig_inner.end() ? iv->second : false); + } + void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const { + swig_inner[swig_protected_method_name] = swig_val; + } +private: + mutable std::map swig_inner; + +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) +/* VTable implementation */ + PyObject *swig_get_method(size_t method_index, const char *method_name) const { + PyObject *method = vtable[method_index]; + if (!method) { + swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name); + method = PyObject_GetAttr(swig_get_self(), name); + if (!method) { + std::string msg = "Method in class MessageDispatcherHandler doesn't exist, undefined "; + msg += method_name; + Swig::DirectorMethodException::raise(msg.c_str()); + } + vtable[method_index] = method; + } + return method; + } +private: + mutable swig::SwigVar_PyObject vtable[1]; +#endif + +}; + + +class SwigDirector_IMessageHandler : public ppc::front::IMessageHandler, public Swig::Director { + +public: + SwigDirector_IMessageHandler(PyObject *self); + virtual ~SwigDirector_IMessageHandler(); + virtual void onMessage(bcos::Error::Ptr e,ppc::protocol::Message::Ptr msg,ppc::front::SendResponseHandler sendResponseHandler); + +/* Internal director utilities */ +public: + bool swig_get_inner(const char *swig_protected_method_name) const { + std::map::const_iterator iv = swig_inner.find(swig_protected_method_name); + return (iv != swig_inner.end() ? iv->second : false); + } + void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const { + swig_inner[swig_protected_method_name] = swig_val; + } +private: + mutable std::map swig_inner; + +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) +/* VTable implementation */ + PyObject *swig_get_method(size_t method_index, const char *method_name) const { + PyObject *method = vtable[method_index]; + if (!method) { + swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name); + method = PyObject_GetAttr(swig_get_self(), name); + if (!method) { + std::string msg = "Method in class IMessageHandler doesn't exist, undefined "; + msg += method_name; + Swig::DirectorMethodException::raise(msg.c_str()); + } + vtable[method_index] = method; + } + return method; + } +private: + mutable swig::SwigVar_PyObject vtable[1]; +#endif + +}; + + +class SwigDirector_GetPeersInfoHandler : public ppc::front::GetPeersInfoHandler, public Swig::Director { + +public: + SwigDirector_GetPeersInfoHandler(PyObject *self); + virtual ~SwigDirector_GetPeersInfoHandler(); + virtual void onPeersInfo(bcos::Error::Ptr e,std::string const &peersInfo); + +/* Internal director utilities */ +public: + bool swig_get_inner(const char *swig_protected_method_name) const { + std::map::const_iterator iv = swig_inner.find(swig_protected_method_name); + return (iv != swig_inner.end() ? iv->second : false); + } + void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const { + swig_inner[swig_protected_method_name] = swig_val; + } +private: + mutable std::map swig_inner; + +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) +/* VTable implementation */ + PyObject *swig_get_method(size_t method_index, const char *method_name) const { + PyObject *method = vtable[method_index]; + if (!method) { + swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name); + method = PyObject_GetAttr(swig_get_self(), name); + if (!method) { + std::string msg = "Method in class GetPeersInfoHandler doesn't exist, undefined "; + msg += method_name; + Swig::DirectorMethodException::raise(msg.c_str()); + } + vtable[method_index] = method; + } + return method; + } +private: + mutable swig::SwigVar_PyObject vtable[1]; +#endif + +}; + + +#endif