privdayz.com speacial mini anti bypass shell

Linux centos-s-1vcpu-2gb-sgp1-01 3.10.0-1160.108.1.el7.x86_64 #1 SMP Thu Jan 25 16:17:31 UTC 2024 x86_64
nginx/1.26.1
167.99.78.96

attribute.swg

/* -----------------------------------------------------------------------------
 * attribute.swg
 *
 * Attribute implementation
 * ----------------------------------------------------------------------------- */

/*
  The following macros convert a pair of set/get methods
  into a "native" attribute.

Use %attribute when you have a pair of get/set methods to a primitive type
  like in:

%attribute(A, int, a, get_a, set_a);

struct A
      {
        int get_a() const;
        void set_a(int aa);
      };

If you don't provide a 'set' method, a 'read-only' attribute
  is generated, ie, like in:

%attribute(A, int, c, get_c);

Use %attributeref when you have const/non-const reference access methods
  for primitive types or class/structs, like in:

%attributeref(A, int, b);

struct A
      {
        const int& b() const;
        int& b();
      };

%attributeref(B, int, c);

struct B
      {
        int& c();
      };

You can also use

%attributeref(Class, AttributeType, AttributeName, AccessorMethod)

if the internal C++ reference methods have a different name from the
  attribute you want, so

%attributeref(B, int, d, c);

is the same as the last example, but instead of the attribute 'c' being
  called 'c', it is called 'd'.

Now you can use the attributes like so:

x = A()
      x.a = 3        # calls A::set_a
      print x.a      # calls A::get_a

x.b = 3        # calls A::b()
      print x.b      # calls A::b() const

Use %attribute2 instead of %attribute to indicate that reference-pointer
  translation is required. You use %attribute2 instead of %attribute in
  cases like this:
 
  %attribute2(MyClass, MyFoo, Foo, GetFoo, SetFoo);
  %inline %{
    struct MyFoo { 
      int x;
    };
    class MyClass {
      MyFoo foo;
    public:
      MyFoo& GetFoo() { return foo; }
      void SetFoo(const MyFoo& other) { foo = other; }
    };
  %}

Here, the data type of the property is a wrapped type (MyFoo) and on the
  C++ side it is passed by reference. The problem is that the SWIG wrapper will
  pass around a pointer (MyFoo *) which is not compatible with the reference
  type of the accessors (MyFoo &). Therefore, if you use %attribute, you'll get
  an error from your C/C++ compiler. %attribute2 translates between a pointer
  and a reference to eliminate the error. In case you're confused, let's make it
  simple: just use %attribute at first, but if the C/C++ compiler gives an error
  while compiling the wrapper, try %attribute2 instead.

NOTE: remember that if the type contains commas, such as 'std::pair<int,int>',
  you need to use the macro like:

%attributeref(A, %arg(std::pair<int,int>), pval);

where %arg() 'normalizes' the type to be understood as a single
  argument, otherwise the macro will get confused by the comma.

The %attributeval is the same as %attribute, but should be used when the type
  is a class/struct (ie a non-primitive type) and when the get and set methods 
  return/pass by value. The following is very similar to the above example, but 
  note that the access is by value rather than reference.

%attributeval(MyClassVal, MyFoo, ReadWriteFoo, GetFoo, SetFoo);
    %attributeval(MyClassVal, MyFoo, ReadOnlyFoo, GetFoo);
    %inline %{
      class MyClassVal {
	MyFoo foo;
      public:
	MyFoo GetFoo() { return foo; }
	void SetFoo(MyFoo other) { foo = other; }
      };
    %}

The %attributestring is the same as %attributeval, but should be used for string
  class types, which are unusual as they are a class on the C++ side, but normally an
  immutable/primitive type in the target language. Example usage for std::string:

%include <std_string.i>
    %attributestring(MyStringyClass, std::string, ReadWriteString, GetString, SetString);
    %attributestring(MyStringyClass, std::string, ReadOnlyString, GetString);
    %inline %{
      class MyStringyClass {
	std::string str;
      public:
	MyStringyClass(const std::string &val) : str(val) {}
	std::string GetString() { return str; }
	void SetString(std::string other) { str = other; }
      };
    %}

//
// Define SWIG_ATTRIBUTE_TEMPLATE if you want to use templates instead of macros for the C++ get and set wrapper methods
// Does not always generate compileable code, use at your peril!
//
//#define SWIG_ATTRIBUTE_TEMPLATE

%define %attribute_custom(Class, AttributeType, AttributeName, GetMethod, SetMethod, GetMethodCall, SetMethodCall)
  %ignore Class::GetMethod();
  %ignore Class::GetMethod() const;
  #if #SetMethod != #AttributeName
    %ignore Class::SetMethod;
  #endif
  %extend Class {
    AttributeType AttributeName;
  }
#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
  %{
    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
      return GetMethodCall;
    }
    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
      return GetMethodCall;
    }
    template < class C > inline void %mangle(Class) ##_## AttributeName ## _set(C* self_, AttributeType val_) {
      SetMethodCall;
    }
  %}
#else
  %{
    #define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
    #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) SetMethodCall
  %}
#endif
%enddef

%define %attribute_readonly(Class, AttributeType, AttributeName, GetMethod, GetMethodCall)
  %ignore Class::GetMethod();
  %ignore Class::GetMethod() const;
  %immutable Class::AttributeName;
  %extend Class {
    AttributeType AttributeName;
  }
#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
  %{
    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
      return GetMethodCall;
    }
    template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
      return GetMethodCall;
    }
  %}
#else
  %{
    #define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
  %}
#endif
%enddef

// User macros

%define %attribute(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
  #if #SetMethod != ""
    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, SetMethod, self_->GetMethod(), self_->SetMethod(val_))
  #else
    %attribute_readonly(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, self_->GetMethod())
  #endif
%enddef

%define %attribute2(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
  #if #SetMethod != ""
    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, SetMethod, &self_->GetMethod(), self_->SetMethod(*val_))
  #else
    %attribute_readonly(%arg(Class), %arg(AttributeType), AttributeName, GetMethod, &self_->GetMethod())
  #endif
%enddef

%define %attributeref(Class, AttributeType, AttributeName, AccessorMethod...)
  #if #AccessorMethod != ""
    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
  #else
    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AttributeName, AttributeName, self_->AttributeName(), self_->AttributeName() = val_)
  #endif
%enddef

%define %attribute2ref(Class, AttributeType, AttributeName, AccessorMethod...)
  #if #AccessorMethod != ""
    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, &self_->AccessorMethod(), self_->AccessorMethod() = *val_)
  #else
    %attribute_custom(%arg(Class), %arg(AttributeType), AccessorName, AccessorName, AccessorName, &self_->AccessorName(), self_->AccessorName() = *val_)
  #endif
%enddef

// deprecated (same as %attributeref, but there is an argument order inconsistency)
%define %attribute_ref(Class, AttributeType, AccessorMethod, AttributeName...)
  #if #AttributeName != ""
    %attribute_custom(%arg(Class), %arg(AttributeType), AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
  #else
    %attribute_custom(%arg(Class), %arg(AttributeType), AccessorMethod, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
  #endif
%enddef

%define %attributeval(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
  %{
    #define %mangle(Class) ##_## AttributeName ## _get(self_) new AttributeType(self_->GetMethod())
  %}
  #if #SetMethod != ""
    %{
      #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) self_->SetMethod(*val_)
    %}
    #if #SetMethod != #AttributeName
      %ignore Class::SetMethod;
    #endif
  #else
    %immutable Class::AttributeName;
  #endif
  %ignore Class::GetMethod();
  %ignore Class::GetMethod() const;
  %newobject Class::AttributeName;
  %extend Class {
    AttributeType AttributeName;
  }
%enddef

%define %attributestring(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
  %{
    #define %mangle(Class) ##_## AttributeName ## _get(self_) *new AttributeType(self_->GetMethod())
  %}
  #if #SetMethod != ""
    %{
      #define %mangle(Class) ##_## AttributeName ## _set(self_, val_) self_->SetMethod(val_)
    %}
    #if #SetMethod != #AttributeName
      %ignore Class::SetMethod;
    #endif
  #else
    %immutable Class::AttributeName;
  #endif
  %ignore Class::GetMethod();
  %ignore Class::GetMethod() const;
  %newobject Class::AttributeName;
  %typemap(newfree) const AttributeType &AttributeName "delete $1;// my newfree override"
  %extend Class {
    AttributeType AttributeName;
  }
%enddef

System Information
*ReClick For Close
File : privdayz.com /index.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2023-02-17 06:21:26
..	dir	-	root/root	0755	2023-02-17 06:21:26
attribute.swg	text/x-c++	9.37 KB	root/root	0644	2016-11-05 04:22:49
carrays.swg	text/x-c	2.62 KB	root/root	0644	2016-11-05 04:22:49
cdata.swg	text/x-c	1.83 KB	root/root	0644	2016-11-05 04:22:49
cmalloc.swg	text/x-c	2.38 KB	root/root	0644	2016-11-05 04:22:49
cpointer.swg	text/plain	3.18 KB	root/root	0644	2016-11-05 04:22:49
cstring.swg	text/plain	167 B	root/root	0644	2016-11-05 04:22:49
cstrings.swg	text/plain	8.03 KB	root/root	0644	2016-11-05 04:22:49
cwstring.swg	text/plain	207 B	root/root	0644	2016-11-05 04:22:49
enumint.swg	text/plain	906 B	root/root	0644	2016-11-05 04:22:49
exception.swg	text/x-c	2.65 KB	root/root	0644	2016-11-05 04:22:49
factory.swg	text/x-c++	2.38 KB	root/root	0644	2016-11-05 04:22:49
fragments.swg	text/x-c	6.65 KB	root/root	0644	2016-11-05 04:22:49
implicit.swg	text/x-c++	4.71 KB	root/root	0644	2016-11-05 04:22:49
inoutlist.swg	text/x-Algol68	9.26 KB	root/root	0644	2016-11-05 04:22:49
misctypes.swg	text/x-c	467 B	root/root	0644	2016-11-05 04:22:49
primtypes.swg	text/x-c	8.38 KB	root/root	0644	2016-11-05 04:22:49
ptrtypes.swg	text/plain	6.44 KB	root/root	0644	2016-11-05 04:22:49
std_except.swg	text/x-c++	1.16 KB	root/root	0644	2016-11-05 04:22:49
std_string.swg	text/x-c++	350 B	root/root	0644	2016-11-05 04:22:49
std_strings.swg	text/plain	1.93 KB	root/root	0644	2016-11-05 04:22:49
std_wstring.swg	text/x-c++	395 B	root/root	0644	2016-11-05 04:22:49
string.swg	text/plain	547 B	root/root	0644	2016-11-05 04:22:49
strings.swg	text/plain	18.11 KB	root/root	0644	2016-11-05 04:22:49
swigmacros.swg	text/x-c	7.94 KB	root/root	0644	2016-11-05 04:22:49
swigobject.swg	text/plain	894 B	root/root	0644	2016-11-05 04:22:49
swigtype.swg	text/plain	18.78 KB	root/root	0644	2016-11-05 04:22:49
swigtypemaps.swg	text/x-c	4.87 KB	root/root	0644	2016-11-05 04:22:49
traits.swg	text/x-c++	7.37 KB	root/root	0644	2016-11-05 04:22:49
typemaps.swg	text/plain	4.46 KB	root/root	0644	2016-11-05 04:22:49
valtypes.swg	text/plain	6.97 KB	root/root	0644	2016-11-05 04:22:49
void.swg	text/plain	2.02 KB	root/root	0644	2016-11-05 04:22:49
wstring.swg	text/plain	567 B	root/root	0644	2016-11-05 04:22:49