FilesExpand file tree

 improve-tests

/

pysequence.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

163 lines (145 loc) · 4.21 KB

 improve-tests

/

pysequence.cs

Copy path

Top

File metadata and controls

• Code
• Blame

163 lines (145 loc) · 4.21 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

using System;

using System.Collections;

namespace Python.Runtime

{

/// <summary>

/// Represents a generic Python sequence. The methods of this class are

/// equivalent to the Python "abstract sequence API". See

/// http://www.python.org/doc/current/api/sequence.html for details.

/// </summary>

public class PySequence : PyObject, IEnumerable

{

protected PySequence(IntPtr ptr) : base(ptr)

{

}

protected PySequence() : base()

{

}

/// <summary>

/// IsSequenceType Method

/// </summary>

///

/// <remarks>

/// Returns true if the given object implements the sequence protocol.

/// </remarks>

public static bool IsSequenceType(PyObject value)

{

return Runtime.PySequence_Check(value.obj);

}

/// <summary>

/// GetSlice Method

/// </summary>

///

/// <remarks>

/// Return the slice of the sequence with the given indices.

/// </remarks>

public PyObject GetSlice(int i1, int i2)

{

IntPtr op = Runtime.PySequence_GetSlice(obj, i1, i2);

if (op == IntPtr.Zero)

{

throw new PythonException();

}

return new PyObject(op);

}

/// <summary>

/// SetSlice Method

/// </summary>

///

/// <remarks>

/// Sets the slice of the sequence with the given indices.

/// </remarks>

public void SetSlice(int i1, int i2, PyObject v)

{

int r = Runtime.PySequence_SetSlice(obj, i1, i2, v.obj);

if (r < 0)

{

throw new PythonException();

}

}

/// <summary>

/// DelSlice Method

/// </summary>

///

/// <remarks>

/// Deletes the slice of the sequence with the given indices.

/// </remarks>

public void DelSlice(int i1, int i2)

{

int r = Runtime.PySequence_DelSlice(obj, i1, i2);

if (r < 0)

{

throw new PythonException();

}

}

/// <summary>

/// Index Method

/// </summary>

///

/// <remarks>

/// Return the index of the given item in the sequence, or -1 if

/// the item does not appear in the sequence.

/// </remarks>

public int Index(PyObject item)

{

int r = Runtime.PySequence_Index(obj, item.obj);

if (r < 0)

{

Runtime.PyErr_Clear();

return -1;

}

return r;

}

/// <summary>

/// Contains Method

/// </summary>

///

/// <remarks>

/// Return true if the sequence contains the given item. This method

/// throws a PythonException if an error occurs during the check.

/// </remarks>

public bool Contains(PyObject item)

{

int r = Runtime.PySequence_Contains(obj, item.obj);

if (r < 0)

{

throw new PythonException();

}

return (r != 0);

}

/// <summary>

/// Concat Method

/// </summary>

///

/// <remarks>

/// Return the concatenation of the sequence object with the passed in

/// sequence object.

/// </remarks>

public PyObject Concat(PyObject other)

{

IntPtr op = Runtime.PySequence_Concat(obj, other.obj);

if (op == IntPtr.Zero)

{

throw new PythonException();

}

return new PyObject(op);

}

/// <summary>

/// Repeat Method

/// </summary>

///

/// <remarks>

/// Return the sequence object repeated N times. This is equivalent

/// to the Python expression "object * count".

/// </remarks>

public PyObject Repeat(int count)

{

IntPtr op = Runtime.PySequence_Repeat(obj, count);

if (op == IntPtr.Zero)

{

throw new PythonException();

}

return new PyObject(op);

}

}

}