File: example01.h

package info (click to toggle)
pypy3 7.0.0%2Bdfsg-3
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 111,848 kB
  • sloc: python: 1,291,746; ansic: 74,281; asm: 5,187; cpp: 3,017; sh: 2,533; makefile: 544; xml: 243; lisp: 45; csh: 21; awk: 4
file content (115 lines) | stat: -rw-r--r-- 2,841 bytes parent folder | download | duplicates (9)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <string>

class payload {
public:
    payload(double d = 0.);
    payload(const payload& p);
    payload& operator=(const payload& e);
    ~payload();

    double getData();
    void setData(double d);

public:        // class-level data
    static int count;

private:
    double m_data;
};


class example01 {
public:
    example01();
    example01(int a);
    example01(const example01& e);
    example01& operator=(const example01& e);
    virtual ~example01();

public:        // class-level methods
    static int staticAddOneToInt(int a);
    static int staticAddOneToInt(int a, int b);
    static double staticAddToDouble(double a);
    static int staticAtoi(const char* str);
    static char* staticStrcpy(const char* strin);
    static void staticSetPayload(payload* p, double d);
    static payload* staticCyclePayload(payload* p, double d);
    static payload staticCopyCyclePayload(payload* p, double d);
    static int getCount();
    static void setCount(int);

public:        // instance methods
    int addDataToInt(int a);
    int addDataToIntConstRef(const int& a);
    int overloadedAddDataToInt(int a, int b);
    int overloadedAddDataToInt(int a);
    int overloadedAddDataToInt(int a, int b, int c);
    double addDataToDouble(double a);
    int addDataToAtoi(const char* str);
    char* addToStringValue(const char* str);

    void setPayload(payload* p);
    payload* cyclePayload(payload* p);
    payload copyCyclePayload(payload* p);

public:        // class-level data
    static int count;

public:        // instance data
    int m_somedata;
};


// global functions and data
int globalAddOneToInt(int a);
namespace ns_example01 {
    int globalAddOneToInt(int a);
    extern int gMyGlobalInt;
}

int installableAddOneToInt(example01&, int a);

#define itypeValue(itype, tname) \
   itype tname##Value(itype arg0, int argn=0, itype arg1=1, itype arg2=2)

#define ftypeValue(ftype) \
   ftype ftype##Value(ftype arg0, int argn=0, ftype arg1=1., ftype arg2=2.)


// argument passing
class ArgPasser {        // use a class for now as methptrgetter not
public:                  // implemented for global functions
   itypeValue(short, short);
   itypeValue(unsigned short, ushort);
   itypeValue(int, int);
   itypeValue(unsigned int, uint);
   itypeValue(long, long);
   itypeValue(unsigned long, ulong);

   ftypeValue(float);
   ftypeValue(double);

   std::string stringValue(
      std::string arg0, int argn=0, std::string arg1 = "default");

   std::string stringRef(
      const std::string& arg0, int argn=0, const std::string& arg1="default");
};


// typedefs
typedef example01 example01_t;


// special case naming
class z_ {
public:
   z_& gime_z_(z_& z);
   int myint;
};

// for pythonization checking
class example01a : public example01 {
public:
   example01a(int a) : example01(a) {}
};