public int __cmp__([NotNull] PythonBuffer other)
{
if (Object.ReferenceEquals(this, other))
{
return(0);
}
return(PythonOps.Compare(ToString(), other.ToString()));
}
public override bool Equals(object obj)
{
PythonBuffer b = obj as PythonBuffer;
if (b == null)
{
return(false);
}
return(__cmp__(b) == 0);
}
private void WriteBuffer (PythonBuffer b) {
_bytes.Add ((byte)'s');
List<byte> newBytes = new List<byte> ();
for (int i = 0; i < b.Size; i++) {
if (b[i] is string) {
string str = b[i] as string;
byte[] utfBytes = Encoding.UTF8.GetBytes (str);
if (utfBytes.Length != str.Length) {
newBytes.AddRange (utfBytes);
} else {
byte[] strBytes = PythonAsciiEncoding.Instance.GetBytes (str);
newBytes.AddRange (strBytes);
}
} else {
newBytes.Add ((byte)b[i]);
}
}
WriteInt32 (newBytes.Count);
_bytes.AddRange (newBytes);
}
public MemoryView(PythonBuffer obj)
{
_buffer = new IListOfBytesBufferProtocol(obj);
}
public int send(PythonBuffer data, [DefaultParameterValue(0)] int flags) {
byte[] buffer = data.ToString().MakeByteArray();
try {
return _socket.Send(buffer, (SocketFlags)flags);
} catch (Exception e) {
throw MakeException(_context, e);
}
}
private bool InitBufferObject(object o, int offset, int size)
{
if (offset < 0)
{
throw PythonOps.ValueError("offset must be zero or positive");
}
else if (size < -1)
{
// -1 is the way to ask for the default size so we allow -1 as a size
throw PythonOps.ValueError("size must be zero or positive");
}
// we currently support only buffers, strings and arrays
// of primitives, strings, bytes, and bytearray objects.
int length;
if (o is PythonBuffer)
{
PythonBuffer py = (PythonBuffer)o;
o = py._object; // grab the internal object
length = py._size;
}
else if (o is string)
{
string strobj = (string)o;
length = strobj.Length;
}
else if (o is Bytes)
{
length = ((Bytes)o).Count;
}
else if (o is ByteArray)
{
length = ((ByteArray)o).Count;
}
else if (o is Array || o is IPythonArray)
{
Array arr = o as Array;
if (arr != null)
{
Type t = arr.GetType().GetElementType();
if (!t.IsPrimitive && t != typeof(string))
{
return(false);
}
length = arr.Length;
}
else
{
IPythonArray pa = (IPythonArray)o;
length = pa.Count;
}
}
else if (o is IPythonBufferable)
{
length = ((IPythonBufferable)o).Size;
_object = o;
}
else
{
return(false);
}
// reset the size based on the given buffer's original size
if (size >= (length - offset) || size == -1)
{
_size = length - offset;
}
else
{
_size = size;
}
_object = o;
_offset = offset;
return(true);
}
public void update(PythonBuffer newData) {
update(newData.ToString().MakeByteArray());
}
internal Sha256Object(PythonBuffer initialBuffer) {
_bytes = new byte[0];
update(initialBuffer);
}
public new void write(PythonBuffer data) {
ThrowIfClosed();
base.write(data);
}
private object fetchOneRow(CodeContext context)
{
int numcols = Sqlite3.sqlite3_data_count(this.statement.st);
object[] row = new object[numcols];
object converter = null;
for(int i = 0; i < numcols; ++i)
{
object converted = null;
if(this.connection.detect_types != 0)
{
converter = row_cast_map[i];
}
else
{
converter = null;
}
if(converter != null)
{
byte[] val = Sqlite3.sqlite3_column_blob(this.statement.st, i);
if(val == null)
{
converted = null;
}
else
{
string item = Latin1.GetString(val, 0, val.Length);
converted = PythonCalls.Call(context, converter, item);
}
}
else
{
int coltype = Sqlite3.sqlite3_column_type(this.statement.st, i);
switch(coltype)
{
case Sqlite3.SQLITE_NULL:
converted = null;
break;
case Sqlite3.SQLITE_INTEGER:
long l = Sqlite3.sqlite3_column_int64(this.statement.st, i);
if(l < int.MinValue || l > int.MaxValue)
converted = l;
else
converted = (int)l;
break;
case Sqlite3.SQLITE_FLOAT:
converted = Sqlite3.sqlite3_column_double(this.statement.st, i);
break;
case Sqlite3.SQLITE_TEXT:
converted = Sqlite3.sqlite3_column_text(this.statement.st, i);
break;
case Sqlite3.SQLITE_BLOB:
default:
byte[] blob = Sqlite3.sqlite3_column_blob(this.statement.st, i);
PythonBuffer buffer = new PythonBuffer(context, blob);
converted = buffer;
break;
}
}
row[i] = converted;
}
return new PythonTuple(row);
}
public void update(PythonBuffer buffer) {
update((IList<byte>)buffer);
}
private static object[] buildPyParams(CodeContext context, Sqlite3.sqlite3_context ctx, int argc, sqlite3_value[] argv)
{
object[] args = new object[argc];
for(int i = 0; i < argc; ++i)
{
sqlite3_value cur_value = argv[i];
object cur_py_value = null;
switch(Sqlite3.sqlite3_value_type(cur_value))
{
case Sqlite3.SQLITE_INTEGER:
cur_py_value = (int)Sqlite3.sqlite3_value_int64(cur_value);
break;
case Sqlite3.SQLITE_FLOAT:
cur_py_value = Sqlite3.sqlite3_value_double(cur_value);
break;
case Sqlite3.SQLITE_TEXT:
cur_py_value = Sqlite3.sqlite3_value_text(cur_value);
break;
case Sqlite3.SQLITE_BLOB:
byte[] result = Sqlite3.sqlite3_value_blob(cur_value);
PythonBuffer buffer = new PythonBuffer(context, result);
cur_py_value = buffer;
break;
case Sqlite3.SQLITE_NULL:
default:
cur_py_value = null;
break;
}
args[i] = cur_py_value;
}
return args;
}
internal sha(PythonBuffer initialBuffer) {
_bytes = new byte[0];
update(initialBuffer);
}
public void update(PythonBuffer newData) {
update((IList<byte>)newData);
}
public void update(PythonBuffer buffer) {
update(buffer.ToString().MakeByteArray());
}
public static Sha256Object sha256(PythonBuffer data) {
return new Sha256Object(data);
}
public static Sha512Object sha512(PythonBuffer data) {
return new Sha512Object(data);
}
internal MD5Type(PythonBuffer initialBuffer) {
_bytes = new byte[0];
update(initialBuffer);
}
public static Sha384Object sha384(PythonBuffer data) {
return new Sha384Object(data);
}
public static MD5Type @new(PythonBuffer data) {
return new MD5Type(data);
}
public void sendall(PythonBuffer data, [DefaultParameterValue(0)] int flags) {
sendallWorker(data.byteCache, flags);
}
public void update(PythonBuffer newBytes) {
update((IList<byte>)newBytes);
}
public static sha @new(PythonBuffer data) {
return new sha(data);
}
public PythonTuple recvfrom_into(PythonBuffer buffer, [DefaultParameterValue(0)]int nbytes, [DefaultParameterValue(0)]int flags) {
if (nbytes < 0) {
throw PythonOps.ValueError("negative buffersize in recvfrom_into");
}
throw PythonOps.TypeError("buffer is read-only");
}
public static Sha384Object sha384(PythonBuffer data) {
return new Sha384Object((IList<byte>)data);
}
public void sendall(PythonBuffer data, [DefaultParameterValue(0)] int flags) {
byte[] buffer = data.ToString().MakeByteArray();
try {
int bytesTotal = buffer.Length;
int bytesRemaining = bytesTotal;
while (bytesRemaining > 0) {
bytesRemaining -= _socket.Send(buffer, bytesTotal - bytesRemaining, bytesRemaining, (SocketFlags)flags);
}
} catch (Exception e) {
throw MakeException(_context, e);
}
}
private bool InitBufferObject(object o, int offset, int size)
{
// we currently support only buffers, strings and arrays
// of primitives and strings
if (o == null || (!(isbuffer = o is PythonBuffer) && !(isstring = o is string) && !(isarray = o is Array)))
{
return(false);
}
if (offset < 0)
{
throw Ops.ValueError("offset must be zero or positive");
}
// -1 is the way to ask for the default size so we allow -1 as a size
if (size < -1)
{
throw Ops.ValueError("size must be zero or positive");
}
if (isbuffer)
{
PythonBuffer py = (PythonBuffer)o;
o = py.@object; // grab the internal object
offset = py.offset + offset; // reset the offset based on the given buffer's original offset
// reset the size based on the given buffer's original size
if (size >= py.size - offset || size == -1)
{
this.size = py.size - offset;
}
else
{
this.size = size;
}
}
else if (isstring)
{
string strobj = ((string)o);
if (size >= strobj.Length || size == -1)
{
this.size = strobj.Length;
}
else
{
this.size = size;
}
}
else // has to be an array at this point
{
Array arr = (Array)o;
Type t = arr.GetType().GetElementType();
if (!t.IsPrimitive && t != typeof(string))
{
return(false);
}
if (size >= arr.Length || size == -1)
{
this.size = arr.Length;
}
else
{
this.size = size;
}
}
this.@object = o;
this.offset = offset;
return(true);
}
