//
//	clipptr_net.cs
//
//	配列ポインタ
//
//	CLiP - Common Library for P/ECE
//	Copyright (C) 2017 Naoyuki Sawa
//
//	* Fri Mar 03 22:34:24 JST 2017 Naoyuki Sawa
//	- 1st リリース。
//	  当モジュールはC言語版には有りません。
//	- 配列のベースアドレスとオフセットをまとめて扱い、C言語のポインタに相当する構造体です。
//	  C言語ならばポインタ一つで済むのですが、C#はunsafe無しでポインタを扱うのが難しいので、このような構造体を用意する事にしました。
//	  .NET FrameworkのArraySegment<T>に似ていますが、自分の使い方には合っていなかったので…
//	  既存の関数の移植のために、極力、C言語のポインタと同じ感覚で使えるようにしてみました。
//	- 各構造体の実装は似ているので、Int32Ptr構造体の実装をコピーして、他の構造体の実装も作成しました。
//	  今後もし、変更や修正を行う場合は、まずInt32Ptrを修正して、その後、他の構造体にも反映して下さい。
//	  いずれ、テンプレートから各構造体の実装を自動生成するような、sedスクリプトを作りたいと思います。(※TODO:)
//	- BytePtrとSBytePtr構造体だけは、BitConverter.ToByte()が無いので、インデクサの実装が少し違います。
//	  上記の方法で反映した後、BytePtrとSBytePtr構造体のインデクサだけは、手作業で少し変更して下さい。
//	- VoidPtr構造体は、適用出来ない処理が有るので、他とはかなり違います。
//	  上記の方法で反映した後、VoidPtr構造体は手作業で少し変更して下さい。
//	* Mon Mar 13 21:21:21 JST 2017 Naoyuki Sawa
//	- StringPtrを追加しました。
//	  VoidPtr〜DoublePtrはbyte[]をカプセル化する構造体だったのに対して、StringPtrはchar[]をカプセル化する構造体です。
//	  VoidPtr〜DoublePtrとStringPtrを、相互に変換する事は出来ません。
//
using System;
namespace org.piece_me {
	public static partial class libclip {
		//*****************************************************************************
		//	VoidPtr
		//*****************************************************************************
		public struct VoidPtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(VoidPtr x, VoidPtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(VoidPtr x, VoidPtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public VoidPtr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator VoidPtr(byte[] Array) {
				return new VoidPtr(Array, 0);
			}
			public static implicit operator bool(VoidPtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(VoidPtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(VoidPtr x) {
		//不要		return x.Array == null;
		//不要	}
		//不可	public static implicit operator VoidPtr(   VoidPtr x) { return new VoidPtr(   x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static implicit operator BytePtr(   VoidPtr x) { return new BytePtr(   x.Array, x.Offset); }
			public static implicit operator SBytePtr(  VoidPtr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static implicit operator Int16Ptr(  VoidPtr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static implicit operator UInt16Ptr( VoidPtr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static implicit operator Int32Ptr(  VoidPtr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static implicit operator UInt32Ptr( VoidPtr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static implicit operator Int64Ptr(  VoidPtr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static implicit operator UInt64Ptr( VoidPtr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static implicit operator BooleanPtr(VoidPtr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static implicit operator CharPtr(   VoidPtr x) { return new CharPtr(   x.Array, x.Offset); }
			public static implicit operator SinglePtr( VoidPtr x) { return new SinglePtr( x.Array, x.Offset); }
			public static implicit operator DoublePtr( VoidPtr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(VoidPtr x, VoidPtr y) {
		//不可		return (x - y) < 0;
				if(x.Array != y.Array) { throw new ApplicationException(); }
				return x.Offset < y.Offset;
			}
			public static bool operator >(VoidPtr x, VoidPtr y) {
		//不可		return (x - y) > 0;
				if(x.Array != y.Array) { throw new ApplicationException(); }
				return x.Offset > y.Offset;
			}
			public static bool operator <=(VoidPtr x, VoidPtr y) {
		//不可		return (x - y) <= 0;
				if(x.Array != y.Array) { throw new ApplicationException(); }
				return x.Offset <= y.Offset;
			}
			public static bool operator >=(VoidPtr x, VoidPtr y) {
		//不可		return (x - y) >= 0;
				if(x.Array != y.Array) { throw new ApplicationException(); }
				return x.Offset >= y.Offset;
			}
		//不可	public static int operator -(VoidPtr x, VoidPtr y) {
		//不可		if(x.Array != y.Array) { throw new ApplicationException(); }
		//不可		int n = x.Offset - y.Offset;
		//不可		if((n % sizeof(Void)) != 0) { throw new ApplicationException(); }
		//不可		return n / sizeof(Void);
		//不可	}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
		//不可	public Void this[int i] {
		//不可		get {
		//不可			return BitConverter.ToVoid(Array, Offset + (i * sizeof(Void)));
		//不可		}
		//不可		set {
		//不可			BitConverter.GetVoids(value).CopyTo(Array, Offset + (i * sizeof(Void)));
		//不可		}
		//不可	}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
		//不可	public Void Read() {
		//不可		return (this++)[0];
		//不可	}
		//不可	public void Write(Void value) {
		//不可	//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
		//不可		this[0] = value;
		//不可		this++;
		//不可	}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
		//不可	public static VoidPtr operator +(VoidPtr x, int i) {
		//不可		return new VoidPtr(x.Array, x.Offset + (i * sizeof(Void)));
		//不可	}
		//不可	public static VoidPtr operator -(VoidPtr x, int i) {
		//不可		return new VoidPtr(x.Array, x.Offset - (i * sizeof(Void)));
		//不可	}
		//不可	public static VoidPtr operator ++(VoidPtr x) {
		//不可		return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
		//不可	}
		//不可	public static VoidPtr operator --(VoidPtr x) {
		//不可		return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
		//不可	}
		}
		//*****************************************************************************
		//	BytePtr
		//*****************************************************************************
		public struct BytePtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(BytePtr x, BytePtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(BytePtr x, BytePtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public BytePtr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator BytePtr(byte[] Array) {
				return new BytePtr(Array, 0);
			}
			public static implicit operator bool(BytePtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(BytePtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(BytePtr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   BytePtr x) { return new VoidPtr(   x.Array, x.Offset); }
		//不可	public static explicit operator BytePtr(   BytePtr x) { return new BytePtr(   x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator SBytePtr(  BytePtr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  BytePtr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( BytePtr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  BytePtr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( BytePtr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  BytePtr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( BytePtr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(BytePtr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   BytePtr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( BytePtr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( BytePtr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(BytePtr x, BytePtr y) {
				return (x - y) < 0;
			}
			public static bool operator >(BytePtr x, BytePtr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(BytePtr x, BytePtr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(BytePtr x, BytePtr y) {
				return (x - y) >= 0;
			}
			public static int operator -(BytePtr x, BytePtr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Byte)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Byte);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Byte this[int i] {
				get {
				//不可	return BitConverter.ToByte(Array, Offset + (i * sizeof(Byte)));
					return Array[Offset + (i * sizeof(Byte))];
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Byte)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Byte Read() {
				return (this++)[0];
			}
			public void Write(Byte value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static BytePtr operator +(BytePtr x, int i) {
				return new BytePtr(x.Array, x.Offset + (i * sizeof(Byte)));
			}
			public static BytePtr operator -(BytePtr x, int i) {
				return new BytePtr(x.Array, x.Offset - (i * sizeof(Byte)));
			}
			public static BytePtr operator ++(BytePtr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static BytePtr operator --(BytePtr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	SBytePtr
		//*****************************************************************************
		public struct SBytePtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(SBytePtr x, SBytePtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(SBytePtr x, SBytePtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public SBytePtr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator SBytePtr(byte[] Array) {
				return new SBytePtr(Array, 0);
			}
			public static implicit operator bool(SBytePtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(SBytePtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(SBytePtr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   SBytePtr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   SBytePtr x) { return new BytePtr(   x.Array, x.Offset); }
		//不可	public static explicit operator SBytePtr(  SBytePtr x) { return new SBytePtr(  x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator Int16Ptr(  SBytePtr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( SBytePtr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  SBytePtr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( SBytePtr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  SBytePtr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( SBytePtr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(SBytePtr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   SBytePtr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( SBytePtr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( SBytePtr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(SBytePtr x, SBytePtr y) {
				return (x - y) < 0;
			}
			public static bool operator >(SBytePtr x, SBytePtr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(SBytePtr x, SBytePtr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(SBytePtr x, SBytePtr y) {
				return (x - y) >= 0;
			}
			public static int operator -(SBytePtr x, SBytePtr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(SByte)) != 0) { throw new ApplicationException(); }
				return n / sizeof(SByte);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public SByte this[int i] {
				get {
				//不可	return BitConverter.ToSByte(Array, Offset + (i * sizeof(SByte)));
					return (SByte)Array[Offset + (i * sizeof(SByte))];
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(SByte)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public SByte Read() {
				return (this++)[0];
			}
			public void Write(SByte value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static SBytePtr operator +(SBytePtr x, int i) {
				return new SBytePtr(x.Array, x.Offset + (i * sizeof(SByte)));
			}
			public static SBytePtr operator -(SBytePtr x, int i) {
				return new SBytePtr(x.Array, x.Offset - (i * sizeof(SByte)));
			}
			public static SBytePtr operator ++(SBytePtr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static SBytePtr operator --(SBytePtr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	Int16Ptr
		//*****************************************************************************
		public struct Int16Ptr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(Int16Ptr x, Int16Ptr y) {
				return x.Equals(y);
			}
			public static bool operator !=(Int16Ptr x, Int16Ptr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public Int16Ptr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator Int16Ptr(byte[] Array) {
				return new Int16Ptr(Array, 0);
			}
			public static implicit operator bool(Int16Ptr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(Int16Ptr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(Int16Ptr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   Int16Ptr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   Int16Ptr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  Int16Ptr x) { return new SBytePtr(  x.Array, x.Offset); }
		//不可	public static explicit operator Int16Ptr(  Int16Ptr x) { return new Int16Ptr(  x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator UInt16Ptr( Int16Ptr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  Int16Ptr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( Int16Ptr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  Int16Ptr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( Int16Ptr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(Int16Ptr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   Int16Ptr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( Int16Ptr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( Int16Ptr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(Int16Ptr x, Int16Ptr y) {
				return (x - y) < 0;
			}
			public static bool operator >(Int16Ptr x, Int16Ptr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(Int16Ptr x, Int16Ptr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(Int16Ptr x, Int16Ptr y) {
				return (x - y) >= 0;
			}
			public static int operator -(Int16Ptr x, Int16Ptr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Int16)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Int16);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Int16 this[int i] {
				get {
					return BitConverter.ToInt16(Array, Offset + (i * sizeof(Int16)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Int16)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Int16 Read() {
				return (this++)[0];
			}
			public void Write(Int16 value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static Int16Ptr operator +(Int16Ptr x, int i) {
				return new Int16Ptr(x.Array, x.Offset + (i * sizeof(Int16)));
			}
			public static Int16Ptr operator -(Int16Ptr x, int i) {
				return new Int16Ptr(x.Array, x.Offset - (i * sizeof(Int16)));
			}
			public static Int16Ptr operator ++(Int16Ptr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static Int16Ptr operator --(Int16Ptr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	UInt16Ptr
		//*****************************************************************************
		public struct UInt16Ptr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(UInt16Ptr x, UInt16Ptr y) {
				return x.Equals(y);
			}
			public static bool operator !=(UInt16Ptr x, UInt16Ptr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public UInt16Ptr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator UInt16Ptr(byte[] Array) {
				return new UInt16Ptr(Array, 0);
			}
			public static implicit operator bool(UInt16Ptr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(UInt16Ptr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(UInt16Ptr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   UInt16Ptr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   UInt16Ptr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  UInt16Ptr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  UInt16Ptr x) { return new Int16Ptr(  x.Array, x.Offset); }
		//不可	public static explicit operator UInt16Ptr( UInt16Ptr x) { return new UInt16Ptr( x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator Int32Ptr(  UInt16Ptr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( UInt16Ptr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  UInt16Ptr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( UInt16Ptr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(UInt16Ptr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   UInt16Ptr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( UInt16Ptr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( UInt16Ptr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(UInt16Ptr x, UInt16Ptr y) {
				return (x - y) < 0;
			}
			public static bool operator >(UInt16Ptr x, UInt16Ptr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(UInt16Ptr x, UInt16Ptr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(UInt16Ptr x, UInt16Ptr y) {
				return (x - y) >= 0;
			}
			public static int operator -(UInt16Ptr x, UInt16Ptr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(UInt16)) != 0) { throw new ApplicationException(); }
				return n / sizeof(UInt16);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public UInt16 this[int i] {
				get {
					return BitConverter.ToUInt16(Array, Offset + (i * sizeof(UInt16)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(UInt16)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public UInt16 Read() {
				return (this++)[0];
			}
			public void Write(UInt16 value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static UInt16Ptr operator +(UInt16Ptr x, int i) {
				return new UInt16Ptr(x.Array, x.Offset + (i * sizeof(UInt16)));
			}
			public static UInt16Ptr operator -(UInt16Ptr x, int i) {
				return new UInt16Ptr(x.Array, x.Offset - (i * sizeof(UInt16)));
			}
			public static UInt16Ptr operator ++(UInt16Ptr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static UInt16Ptr operator --(UInt16Ptr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	Int32Ptr
		//*****************************************************************************
		public struct Int32Ptr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(Int32Ptr x, Int32Ptr y) {
				return x.Equals(y);
			}
			public static bool operator !=(Int32Ptr x, Int32Ptr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public Int32Ptr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator Int32Ptr(byte[] Array) {
				return new Int32Ptr(Array, 0);
			}
			public static implicit operator bool(Int32Ptr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(Int32Ptr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(Int32Ptr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   Int32Ptr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   Int32Ptr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  Int32Ptr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  Int32Ptr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( Int32Ptr x) { return new UInt16Ptr( x.Array, x.Offset); }
		//不可	public static explicit operator Int32Ptr(  Int32Ptr x) { return new Int32Ptr(  x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator UInt32Ptr( Int32Ptr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  Int32Ptr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( Int32Ptr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(Int32Ptr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   Int32Ptr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( Int32Ptr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( Int32Ptr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(Int32Ptr x, Int32Ptr y) {
				return (x - y) < 0;
			}
			public static bool operator >(Int32Ptr x, Int32Ptr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(Int32Ptr x, Int32Ptr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(Int32Ptr x, Int32Ptr y) {
				return (x - y) >= 0;
			}
			public static int operator -(Int32Ptr x, Int32Ptr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Int32)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Int32);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Int32 this[int i] {
				get {
					return BitConverter.ToInt32(Array, Offset + (i * sizeof(Int32)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Int32)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Int32 Read() {
				return (this++)[0];
			}
			public void Write(Int32 value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static Int32Ptr operator +(Int32Ptr x, int i) {
				return new Int32Ptr(x.Array, x.Offset + (i * sizeof(Int32)));
			}
			public static Int32Ptr operator -(Int32Ptr x, int i) {
				return new Int32Ptr(x.Array, x.Offset - (i * sizeof(Int32)));
			}
			public static Int32Ptr operator ++(Int32Ptr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static Int32Ptr operator --(Int32Ptr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	UInt32Ptr
		//*****************************************************************************
		public struct UInt32Ptr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(UInt32Ptr x, UInt32Ptr y) {
				return x.Equals(y);
			}
			public static bool operator !=(UInt32Ptr x, UInt32Ptr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public UInt32Ptr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator UInt32Ptr(byte[] Array) {
				return new UInt32Ptr(Array, 0);
			}
			public static implicit operator bool(UInt32Ptr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(UInt32Ptr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(UInt32Ptr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   UInt32Ptr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   UInt32Ptr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  UInt32Ptr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  UInt32Ptr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( UInt32Ptr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  UInt32Ptr x) { return new Int32Ptr(  x.Array, x.Offset); }
		//不可	public static explicit operator UInt32Ptr( UInt32Ptr x) { return new UInt32Ptr( x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator Int64Ptr(  UInt32Ptr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( UInt32Ptr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(UInt32Ptr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   UInt32Ptr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( UInt32Ptr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( UInt32Ptr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(UInt32Ptr x, UInt32Ptr y) {
				return (x - y) < 0;
			}
			public static bool operator >(UInt32Ptr x, UInt32Ptr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(UInt32Ptr x, UInt32Ptr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(UInt32Ptr x, UInt32Ptr y) {
				return (x - y) >= 0;
			}
			public static int operator -(UInt32Ptr x, UInt32Ptr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(UInt32)) != 0) { throw new ApplicationException(); }
				return n / sizeof(UInt32);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public UInt32 this[int i] {
				get {
					return BitConverter.ToUInt32(Array, Offset + (i * sizeof(UInt32)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(UInt32)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public UInt32 Read() {
				return (this++)[0];
			}
			public void Write(UInt32 value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static UInt32Ptr operator +(UInt32Ptr x, int i) {
				return new UInt32Ptr(x.Array, x.Offset + (i * sizeof(UInt32)));
			}
			public static UInt32Ptr operator -(UInt32Ptr x, int i) {
				return new UInt32Ptr(x.Array, x.Offset - (i * sizeof(UInt32)));
			}
			public static UInt32Ptr operator ++(UInt32Ptr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static UInt32Ptr operator --(UInt32Ptr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	Int64Ptr
		//*****************************************************************************
		public struct Int64Ptr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(Int64Ptr x, Int64Ptr y) {
				return x.Equals(y);
			}
			public static bool operator !=(Int64Ptr x, Int64Ptr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public Int64Ptr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator Int64Ptr(byte[] Array) {
				return new Int64Ptr(Array, 0);
			}
			public static implicit operator bool(Int64Ptr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(Int64Ptr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(Int64Ptr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   Int64Ptr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   Int64Ptr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  Int64Ptr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  Int64Ptr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( Int64Ptr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  Int64Ptr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( Int64Ptr x) { return new UInt32Ptr( x.Array, x.Offset); }
		//不可	public static explicit operator Int64Ptr(  Int64Ptr x) { return new Int64Ptr(  x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator UInt64Ptr( Int64Ptr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(Int64Ptr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   Int64Ptr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( Int64Ptr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( Int64Ptr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(Int64Ptr x, Int64Ptr y) {
				return (x - y) < 0;
			}
			public static bool operator >(Int64Ptr x, Int64Ptr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(Int64Ptr x, Int64Ptr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(Int64Ptr x, Int64Ptr y) {
				return (x - y) >= 0;
			}
			public static int operator -(Int64Ptr x, Int64Ptr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Int64)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Int64);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Int64 this[int i] {
				get {
					return BitConverter.ToInt64(Array, Offset + (i * sizeof(Int64)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Int64)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Int64 Read() {
				return (this++)[0];
			}
			public void Write(Int64 value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static Int64Ptr operator +(Int64Ptr x, int i) {
				return new Int64Ptr(x.Array, x.Offset + (i * sizeof(Int64)));
			}
			public static Int64Ptr operator -(Int64Ptr x, int i) {
				return new Int64Ptr(x.Array, x.Offset - (i * sizeof(Int64)));
			}
			public static Int64Ptr operator ++(Int64Ptr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static Int64Ptr operator --(Int64Ptr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	UInt64Ptr
		//*****************************************************************************
		public struct UInt64Ptr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(UInt64Ptr x, UInt64Ptr y) {
				return x.Equals(y);
			}
			public static bool operator !=(UInt64Ptr x, UInt64Ptr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public UInt64Ptr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator UInt64Ptr(byte[] Array) {
				return new UInt64Ptr(Array, 0);
			}
			public static implicit operator bool(UInt64Ptr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(UInt64Ptr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(UInt64Ptr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   UInt64Ptr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   UInt64Ptr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  UInt64Ptr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  UInt64Ptr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( UInt64Ptr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  UInt64Ptr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( UInt64Ptr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  UInt64Ptr x) { return new Int64Ptr(  x.Array, x.Offset); }
		//不可	public static explicit operator UInt64Ptr( UInt64Ptr x) { return new UInt64Ptr( x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator BooleanPtr(UInt64Ptr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   UInt64Ptr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( UInt64Ptr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( UInt64Ptr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(UInt64Ptr x, UInt64Ptr y) {
				return (x - y) < 0;
			}
			public static bool operator >(UInt64Ptr x, UInt64Ptr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(UInt64Ptr x, UInt64Ptr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(UInt64Ptr x, UInt64Ptr y) {
				return (x - y) >= 0;
			}
			public static int operator -(UInt64Ptr x, UInt64Ptr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(UInt64)) != 0) { throw new ApplicationException(); }
				return n / sizeof(UInt64);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public UInt64 this[int i] {
				get {
					return BitConverter.ToUInt64(Array, Offset + (i * sizeof(UInt64)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(UInt64)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public UInt64 Read() {
				return (this++)[0];
			}
			public void Write(UInt64 value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static UInt64Ptr operator +(UInt64Ptr x, int i) {
				return new UInt64Ptr(x.Array, x.Offset + (i * sizeof(UInt64)));
			}
			public static UInt64Ptr operator -(UInt64Ptr x, int i) {
				return new UInt64Ptr(x.Array, x.Offset - (i * sizeof(UInt64)));
			}
			public static UInt64Ptr operator ++(UInt64Ptr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static UInt64Ptr operator --(UInt64Ptr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	BooleanPtr
		//*****************************************************************************
		public struct BooleanPtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(BooleanPtr x, BooleanPtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(BooleanPtr x, BooleanPtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public BooleanPtr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator BooleanPtr(byte[] Array) {
				return new BooleanPtr(Array, 0);
			}
			public static implicit operator bool(BooleanPtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(BooleanPtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(BooleanPtr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   BooleanPtr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   BooleanPtr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  BooleanPtr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  BooleanPtr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( BooleanPtr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  BooleanPtr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( BooleanPtr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  BooleanPtr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( BooleanPtr x) { return new UInt64Ptr( x.Array, x.Offset); }
		//不可	public static explicit operator BooleanPtr(BooleanPtr x) { return new BooleanPtr(x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator CharPtr(   BooleanPtr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( BooleanPtr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( BooleanPtr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(BooleanPtr x, BooleanPtr y) {
				return (x - y) < 0;
			}
			public static bool operator >(BooleanPtr x, BooleanPtr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(BooleanPtr x, BooleanPtr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(BooleanPtr x, BooleanPtr y) {
				return (x - y) >= 0;
			}
			public static int operator -(BooleanPtr x, BooleanPtr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Boolean)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Boolean);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Boolean this[int i] {
				get {
					return BitConverter.ToBoolean(Array, Offset + (i * sizeof(Boolean)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Boolean)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Boolean Read() {
				return (this++)[0];
			}
			public void Write(Boolean value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static BooleanPtr operator +(BooleanPtr x, int i) {
				return new BooleanPtr(x.Array, x.Offset + (i * sizeof(Boolean)));
			}
			public static BooleanPtr operator -(BooleanPtr x, int i) {
				return new BooleanPtr(x.Array, x.Offset - (i * sizeof(Boolean)));
			}
			public static BooleanPtr operator ++(BooleanPtr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static BooleanPtr operator --(BooleanPtr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	CharPtr
		//*****************************************************************************
		public struct CharPtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(CharPtr x, CharPtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(CharPtr x, CharPtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public CharPtr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator CharPtr(byte[] Array) {
				return new CharPtr(Array, 0);
			}
			public static implicit operator bool(CharPtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(CharPtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(CharPtr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   CharPtr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   CharPtr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  CharPtr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  CharPtr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( CharPtr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  CharPtr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( CharPtr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  CharPtr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( CharPtr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(CharPtr x) { return new BooleanPtr(x.Array, x.Offset); }
		//不可	public static explicit operator CharPtr(   CharPtr x) { return new CharPtr(   x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator SinglePtr( CharPtr x) { return new SinglePtr( x.Array, x.Offset); }
			public static explicit operator DoublePtr( CharPtr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(CharPtr x, CharPtr y) {
				return (x - y) < 0;
			}
			public static bool operator >(CharPtr x, CharPtr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(CharPtr x, CharPtr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(CharPtr x, CharPtr y) {
				return (x - y) >= 0;
			}
			public static int operator -(CharPtr x, CharPtr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Char)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Char);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Char this[int i] {
				get {
					return BitConverter.ToChar(Array, Offset + (i * sizeof(Char)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Char)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Char Read() {
				return (this++)[0];
			}
			public void Write(Char value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static CharPtr operator +(CharPtr x, int i) {
				return new CharPtr(x.Array, x.Offset + (i * sizeof(Char)));
			}
			public static CharPtr operator -(CharPtr x, int i) {
				return new CharPtr(x.Array, x.Offset - (i * sizeof(Char)));
			}
			public static CharPtr operator ++(CharPtr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static CharPtr operator --(CharPtr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	SinglePtr
		//*****************************************************************************
		public struct SinglePtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(SinglePtr x, SinglePtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(SinglePtr x, SinglePtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public SinglePtr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator SinglePtr(byte[] Array) {
				return new SinglePtr(Array, 0);
			}
			public static implicit operator bool(SinglePtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(SinglePtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(SinglePtr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   SinglePtr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   SinglePtr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  SinglePtr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  SinglePtr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( SinglePtr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  SinglePtr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( SinglePtr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  SinglePtr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( SinglePtr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(SinglePtr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   SinglePtr x) { return new CharPtr(   x.Array, x.Offset); }
		//不可	public static explicit operator SinglePtr( SinglePtr x) { return new SinglePtr( x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			public static explicit operator DoublePtr( SinglePtr x) { return new DoublePtr( x.Array, x.Offset); }
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(SinglePtr x, SinglePtr y) {
				return (x - y) < 0;
			}
			public static bool operator >(SinglePtr x, SinglePtr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(SinglePtr x, SinglePtr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(SinglePtr x, SinglePtr y) {
				return (x - y) >= 0;
			}
			public static int operator -(SinglePtr x, SinglePtr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Single)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Single);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Single this[int i] {
				get {
					return BitConverter.ToSingle(Array, Offset + (i * sizeof(Single)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Single)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Single Read() {
				return (this++)[0];
			}
			public void Write(Single value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static SinglePtr operator +(SinglePtr x, int i) {
				return new SinglePtr(x.Array, x.Offset + (i * sizeof(Single)));
			}
			public static SinglePtr operator -(SinglePtr x, int i) {
				return new SinglePtr(x.Array, x.Offset - (i * sizeof(Single)));
			}
			public static SinglePtr operator ++(SinglePtr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static SinglePtr operator --(SinglePtr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	DoublePtr
		//*****************************************************************************
		public struct DoublePtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(DoublePtr x, DoublePtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(DoublePtr x, DoublePtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public byte[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public DoublePtr(byte[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator DoublePtr(byte[] Array) {
				return new DoublePtr(Array, 0);
			}
			public static implicit operator bool(DoublePtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(DoublePtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(DoublePtr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator VoidPtr(   DoublePtr x) { return new VoidPtr(   x.Array, x.Offset); }
			public static explicit operator BytePtr(   DoublePtr x) { return new BytePtr(   x.Array, x.Offset); }
			public static explicit operator SBytePtr(  DoublePtr x) { return new SBytePtr(  x.Array, x.Offset); }
			public static explicit operator Int16Ptr(  DoublePtr x) { return new Int16Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt16Ptr( DoublePtr x) { return new UInt16Ptr( x.Array, x.Offset); }
			public static explicit operator Int32Ptr(  DoublePtr x) { return new Int32Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt32Ptr( DoublePtr x) { return new UInt32Ptr( x.Array, x.Offset); }
			public static explicit operator Int64Ptr(  DoublePtr x) { return new Int64Ptr(  x.Array, x.Offset); }
			public static explicit operator UInt64Ptr( DoublePtr x) { return new UInt64Ptr( x.Array, x.Offset); }
			public static explicit operator BooleanPtr(DoublePtr x) { return new BooleanPtr(x.Array, x.Offset); }
			public static explicit operator CharPtr(   DoublePtr x) { return new CharPtr(   x.Array, x.Offset); }
			public static explicit operator SinglePtr( DoublePtr x) { return new SinglePtr( x.Array, x.Offset); }
		//不可	public static explicit operator DoublePtr( DoublePtr x) { return new DoublePtr( x.Array, x.Offset); }	//error CS0555: ユーザー定義の演算子は、それを囲む型のオブジェクトの取得、およびそれを囲む型のオブジェクトへの変換を行えません。
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(DoublePtr x, DoublePtr y) {
				return (x - y) < 0;
			}
			public static bool operator >(DoublePtr x, DoublePtr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(DoublePtr x, DoublePtr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(DoublePtr x, DoublePtr y) {
				return (x - y) >= 0;
			}
			public static int operator -(DoublePtr x, DoublePtr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				int n = x.Offset - y.Offset;
				if((n % sizeof(Double)) != 0) { throw new ApplicationException(); }
				return n / sizeof(Double);
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public Double this[int i] {
				get {
					return BitConverter.ToDouble(Array, Offset + (i * sizeof(Double)));
				}
				set {
					BitConverter.GetBytes(value).CopyTo(Array, Offset + (i * sizeof(Double)));
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public Double Read() {
				return (this++)[0];
			}
			public void Write(Double value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static DoublePtr operator +(DoublePtr x, int i) {
				return new DoublePtr(x.Array, x.Offset + (i * sizeof(Double)));
			}
			public static DoublePtr operator -(DoublePtr x, int i) {
				return new DoublePtr(x.Array, x.Offset - (i * sizeof(Double)));
			}
			public static DoublePtr operator ++(DoublePtr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static DoublePtr operator --(DoublePtr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
		//*****************************************************************************
		//	StringPtr
		//*****************************************************************************
		public struct StringPtr {
			//-----------------------------------------------------------------------------
			//定型処理
			public override int GetHashCode() {
				return base.GetHashCode();
			}
			public override bool Equals(object obj) {
				return base.Equals(obj);
			}
			public static bool operator ==(StringPtr x, StringPtr y) {
				return x.Equals(y);
			}
			public static bool operator !=(StringPtr x, StringPtr y) {
				return !x.Equals(y);
			}
			//-----------------------------------------------------------------------------
			//プロパティ
			public char[] Array {
				get;
				private set;
			}
			public int Offset {
				get;
				private set;
			}
			//-----------------------------------------------------------------------------
			//コンストラクタ
			public StringPtr(char[] Array, int Offset) {
				this.Array = Array;
				this.Offset = Offset;
			}
			//-----------------------------------------------------------------------------
			//変換演算子
			public static implicit operator StringPtr(char[] Array) {
				return new StringPtr(Array, 0);
			}
			public static implicit operator bool(StringPtr x) {
				return x.Array != null;
			}
		//不要	public static bool operator true(StringPtr x) {
		//不要		return x.Array != null;
		//不要	}
		//不要	public static bool operator false(StringPtr x) {
		//不要		return x.Array == null;
		//不要	}
			public static implicit operator StringPtr(string x) { return new StringPtr(x.ToCharArray(), 0); }
			public static implicit operator string(StringPtr x) {	//現在の位置から'\0'まで,又は,配列の終端までを、文字列に変換して返します。ただし、配列が設定されていないStringPtrが指定された場合は、nullポインタを返します。
				if(x.Array == null) { return null; }
				int i = System.Array.IndexOf(x.Array, '\0', x.Offset);	//「Array.IndexOf()」と書くとArrayクラスでなくArrayフィールドと見なされてコンパイルエラーになるので、「System.Array.IndexOf()」と書く必要が有ります。
				if(i == -1) { i = x.Array.Length; }
				return new string(x.Array, x.Offset, i - x.Offset);
			}
			//-----------------------------------------------------------------------------
			//比較演算子
			public static bool operator <(StringPtr x, StringPtr y) {
				return (x - y) < 0;
			}
			public static bool operator >(StringPtr x, StringPtr y) {
				return (x - y) > 0;
			}
			public static bool operator <=(StringPtr x, StringPtr y) {
				return (x - y) <= 0;
			}
			public static bool operator >=(StringPtr x, StringPtr y) {
				return (x - y) >= 0;
			}
			public static int operator -(StringPtr x, StringPtr y) {
				if(x.Array != y.Array) { throw new ApplicationException(); }
				return x.Offset - y.Offset;
			}
			//-----------------------------------------------------------------------------
			//インデクスを指定して、配列要素を読み書きする。
			public char this[int i] {
				get {
					i += Offset;
					if(i == Array.Length) { return '\0'; }	//文字配列の終端には仮想的な'\0'が有るものと見なす事にしました。「String.ToCharArray()」では終端の'\0'が付かないので新たな配列を作成して'\0'を追加しないで良いようにするためです。
					return Array[i];
				}
				set {
					i += Offset;
					if((i == Array.Length) && (value == '\0')) { return; }	//文字配列の終端への'\0'書き込みは許容して無視する事にしました。上記のgetアクセサの仕様との対称性のためです。
					Array[i] = value;
				}
			}
			//-----------------------------------------------------------------------------
			//現在の位置から一要素読み書きし、次の位置へ進める。
			public char Read() {
				return (this++)[0];
			}
			public void Write(char value) {
			//不可	(this++)[0] = value;	//error CS0131: 代入式の左辺には変数、プロパティ、またはインデクサーを指定してください。
				this[0] = value;
				this++;
			}
			//-----------------------------------------------------------------------------
			//配列ポインタとインデクスを加算,又は,減算して、配列ポインタを作成する。
			public static StringPtr operator +(StringPtr x, int i) {
				return new StringPtr(x.Array, x.Offset + i);
			}
			public static StringPtr operator -(StringPtr x, int i) {
				return new StringPtr(x.Array, x.Offset - i);
			}
			public static StringPtr operator ++(StringPtr x) {
				return x + 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
			public static StringPtr operator --(StringPtr x) {
				return x - 1;	//C++と違いC#では言語が代入するので値を返すだけで良い。
			}
		}
	}
}
