//----------------------------------------------------------------------------
// Example 2) 가장 기본적인 형의 쓰기와 읽기
//
// append<T> 함수를 사용하여 버퍼의 끝에 T형 값을 써넣을 수 있다.
// extract<T> 함수를 사용하여 버퍼에 제일 앞에서부터 T형 값을 읽어올 수 있다.
//
//----------------------------------------------------------------------------
static void Sample_simple_append_extract()
{
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND) 기본적인 값들을 써넣는다.
bufTemp.append<byte>(10);
bufTemp.append<sbyte>(20);
bufTemp.append<int>(-100);
bufTemp.append<uint>(1000);
// * 여기까지 append를 수행했으면 총 14Byte가 쓰여져
// Count 값은 14가 된다. Offset은 여전히 0이지만
// * append할때 붙여진 <T>보다는 쓰여진 값에 따라 쓰여진다.
// EXTRACT) 값을 일어낸다.
// - 값을 읽어내게 되면 Offset값부터 값을 읽어내게 되고 Offset값을 읽어낸 크기 증가시킨다.
var temp1 = bufTemp.extract<byte>(); // 10
var temp2 = bufTemp.extract<SByte>(); // 20
var temp3 = bufTemp.extract<int>(); // -100
var temp4 = bufTemp.extract<uint>(); // 1000
// 확인)
Console.WriteLine("temp1:"+temp1 +" temp2:"+ temp2 + " temp3"+temp3 + " temp4"+temp4);
}
public void TestMethod2()
{
CGD.buffer tempBufer = new CGD.buffer();
tempBufer.alloc(200);
TEST_B temp = new TEST_B();
temp.X = 10;
temp.Y = "Tesfdsafdsafdsafdst";
temp.Z = 100;
temp.W = new List <int> {
10, 20, 30
};
string tempString;
tempString = "Txxfasgfsgfdfx";
tempBufer.append <int>(10);
tempBufer.append <TEST_B>(temp);
tempBufer.append <string>(tempString);
int a1 = tempBufer.extract <int>();
TEST_B a2 = tempBufer.extract <TEST_B>();
string a3 = tempBufer.extract <string>();
}
//----------------------------------------------------------------------------
// Example 4) Collection 쓰기/읽기
//
// Collection 역시 그냥 append함수로 똑같이 읽고 쓸수 있다.
//
//----------------------------------------------------------------------------
static void Sample_simple_append_extract_collection()
{
// Decalre) 임시로 사용할 List를 선언한다.
List<int> list_int = new List<int> { 10, 20, 30, 40};
List<string> list_string = new List<string> { "first","second","second"};
Dictionary<string, int> dictionary_int_string = new Dictionary<string, int> { {"first", 10}, {"second", 20}, {"third", 30}};
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND) List<int>를 추가한다.
bufTemp.append(list_int);
bufTemp.append(list_string);
bufTemp.append(dictionary_int_string);
// EXTRACT) 추가했던 문자열을 읽어낸다.
var data1 = bufTemp.extract<List<int>>();
var data2 = bufTemp.extract<List<string>>();
var data3 = bufTemp.extract<Dictionary<string, int>>();
// 2) 출력한다.
foreach(var iter in data1) {Console.WriteLine(iter.ToString());}
foreach(var iter in data2) {Console.WriteLine(iter.ToString());}
foreach(var iter in data3) {Console.WriteLine(iter.ToString());}
}
public void Test_buffer__multi_level()
{
CGD.buffer tempBufer = new CGD.buffer();
tempBufer.alloc(200);
TEST_C temp = new TEST_C();
temp.x = 10;
temp.y = new List <int> {
1, 2, 3
};
temp.t = new DateTime(1990, 12, 11, 10, 21, 11);
temp.z.X = 10;
temp.z.Y = "Tesfdsafdsafdsafdst";
temp.z.Z = 100;
temp.z.W = new List <int> {
10, 20, 30
};
string tempString;
tempString = "Txxfasgfsgfdfx";
tempBufer.append <int>(10);
tempBufer.append <TEST_C>(temp);
tempBufer.append <string>(tempString);
var a1 = tempBufer.extract <int>();
var a2 = tempBufer.extract <TEST_C>();
var a3 = tempBufer.extract <string>();
}
//----------------------------------------------------------------------------
// Example 3) 문자열 쓰기/읽기
//
// 역시 append<string> 함수를 사용하여 버퍼의 끝에 string형 값을 쓸수 있다.
// 굳이 <string>을 쓸 필요가 없지만 코드의 가독성을 위해 붙여 주는 경우가 많다.
//
// 읽을 때는 extract<string> 함수를 사용하여 읽을 수 있다.
// 여기서는 반드시 템플릿 인자인 <string>를 써주어야 한다.
//
//----------------------------------------------------------------------------
static void Sample_simple_append_extract_string()
{
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND1) 문자열을 추가한다. (1)
bufTemp.append <string>("First test String");
// APPEND2) 문자열을 추가한다. 구지 <string>을 쓸 필요는 없다.(2)
bufTemp.append("Second");
// Declare) 임시로 문자열 변수를 만든다.
string tempString = "Third";
// APPEND3) 문자열을 추가한다. 구지 <string>을 쓸 필요는 없다.(2)
bufTemp.append(tempString);
// EXTRACT) 추가된 문자열을 뽑아낸다.
var str1 = bufTemp.extract <string>(); // "First test String"
var str2 = bufTemp.extract <string>(); // "Second"
var str3 = bufTemp.extract <string>(); // "Third"
// 확인)
Console.WriteLine(str1);
Console.WriteLine(str2);
Console.WriteLine(str3);
}
static void Main(string[] args)
{
tcpSession = new AsyncTcpSession();
tcpSession.Connected += tcpSession_Connected;
tcpSession.Closed += tcpSession_Closed;
tcpSession.DataReceived += tcpSession_DataReceived;
tcpSession.Error += tcpSession_Error;
tcpSession.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3000));
var tmpData = "";
while (tmpData != "q")
{
tmpData = Console.ReadLine();
var buffer = new CGD.buffer(50);
buffer.append <int>(123);
buffer.append <short>(0);
buffer.append <string>(tmpData);
buffer.set_front <short>(buffer.Count, 4);
tcpSession.Send(buffer);
}
}
//----------------------------------------------------------------------------
// Example 1) 다양한 형태의 생성 방법
//
//----------------------------------------------------------------------------
static void Sample_simple_creation_copy()
{
// Case 1) 256 Byte의 메모리를 할당한다.
CGD.buffer bufTemp1 = new CGD.buffer(256);
// Case 2) 선언 후 할당하기
CGD.buffer bufTemp2 = new CGD.buffer();
bufTemp2.alloc(256);
// Case 3) CGPool이 있을 경우
//CGD.buffer buffer 3 = MEM_POOL.Alloc(256);
// Case 4) 바이트 배열을 직접 할당해 넣기.
CGD.buffer bufTemp3 = new CGD.buffer(new byte[256]);
// Case 5) byte[]과 함께 Offset과 Length도 설정하기
// (offset:10, Count:100)
CGD.buffer bufTemp4 = new CGD.buffer(new byte[256], 10, 100);
// Case 6) 생성된 CGD.buffer에서 가져온다.(얕은 복사)
CGD.buffer bufTemp5 = bufTemp1;
// Case 7) 생성된 기본 버퍼에서 Offset을 10만큼 더한 후 가져오기
CGD.buffer bufTemp6 = bufTemp2 + 10;
// Case 8) 복사본을 만든다. (깊은 복사)
CGD.buffer bufTemp7 = bufTemp1.clone();
// 할당 해제
bufTemp1.clear();
}
static void Sample_simple_append_extract_struct2()
{
// Declare) 임시로 사용할 List를 선언한다.
TEST2 temp = new TEST2();
temp.a = 10;
//temp.b; // 생성하지 않았다! (이 변수는 null일 것이다.)
temp.c = new TEST();
temp.c.x = 10;
temp.c.y = 1.0f;
//temp.c.z = "temp string";
temp.c.w = new List <int> {
10, 20, 30
};
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND 1) List<int>를 추가한다.
bufTemp.append(temp);
// EXTRACT 1) 추가했던 문자열을 읽어낸다.
var tempRead = bufTemp.extract <TEST2>();
// 4) 출력한다.
Console.WriteLine(tempRead.a);
Console.WriteLine(tempRead.b);
Console.WriteLine(tempRead.c.x);
Console.WriteLine(tempRead.c.y);
Console.WriteLine(tempRead.c.z);
foreach (var iter in tempRead.c.w)
{
Console.WriteLine(iter.ToString());
}
}
public void TestMethod_General_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 1) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 2) 값 써넣기
bufferTemp.append <sbyte>((sbyte)3);
bufferTemp.append <byte>((byte)4);
bufferTemp.append <short>((short)4100);
bufferTemp.append <ushort>((ushort)32210);
bufferTemp.append <int>(123310);
bufferTemp.append <uint>(121234);
bufferTemp.append <long>(-1000443L);
bufferTemp.append <ulong>(12233094310UL);
bufferTemp.append <float>(1.0f);
bufferTemp.append <double>(2.0);
// 3) 값 읽기
var value0 = bufferTemp.extract <sbyte>();
var value1 = bufferTemp.extract <byte>();
var value2 = bufferTemp.extract <short>();
var value3 = bufferTemp.extract <ushort>();
var value4 = bufferTemp.extract <int>();
var value5 = bufferTemp.extract <uint>();
var value6 = bufferTemp.extract <long>();
var value7 = bufferTemp.extract <ulong>();
var value8 = bufferTemp.extract <float>();
var value9 = bufferTemp.extract <double>();
}
}
//----------------------------------------------------------------------------
// Example 2) 가장 기본적인 형의 쓰기와 읽기
//
// append<T> 함수를 사용하여 버퍼의 끝에 T형 값을 써넣을 수 있다.
// extract<T> 함수를 사용하여 버퍼에 제일 앞에서부터 T형 값을 읽어올 수 있다.
//
//----------------------------------------------------------------------------
static void Sample_simple_append_extract()
{
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND) 기본적인 값들을 써넣는다.
bufTemp.append <byte>(10);
bufTemp.append <sbyte>(20);
bufTemp.append <int>(-100);
bufTemp.append <uint>(1000);
// * 여기까지 append를 수행했으면 총 14Byte가 쓰여져
// Count 값은 14가 된다. Offset은 여전히 0이지만
// * append할때 붙여진 <T>보다는 쓰여진 값에 따라 쓰여진다.
// EXTRACT) 값을 일어낸다.
// - 값을 읽어내게 되면 Offset값부터 값을 읽어내게 되고 Offset값을 읽어낸 크기 증가시킨다.
var temp1 = bufTemp.extract <byte>(); // 10
var temp2 = bufTemp.extract <SByte>(); // 20
var temp3 = bufTemp.extract <int>(); // -100
var temp4 = bufTemp.extract <uint>(); // 1000
// 확인)
Console.WriteLine("temp1:" + temp1 + " temp2:" + temp2 + " temp3" + temp3 + " temp4" + temp4);
}
public void TestMethod_String_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
string[] stringExtract = new string[8];
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 2) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 3) 값 써넣기
bufferTemp.append <string>(array_string[0]);
bufferTemp.append <string>(array_string[1]);
bufferTemp.append <string>(array_string[2]);
bufferTemp.append <string>(array_string[3]);
bufferTemp.append <string>(array_string[4]);
bufferTemp.append <string>(array_string[5]);
bufferTemp.append <string>(array_string[6]);
bufferTemp.append <string>(array_string[7]);
// 4) 값 읽기
stringExtract[0] = bufferTemp.extract <string>();
stringExtract[1] = bufferTemp.extract <string>();
stringExtract[2] = bufferTemp.extract <string>();
stringExtract[3] = bufferTemp.extract <string>();
stringExtract[4] = bufferTemp.extract <string>();
stringExtract[5] = bufferTemp.extract <string>();
stringExtract[6] = bufferTemp.extract <string>();
stringExtract[7] = bufferTemp.extract <string>();
}
}
public void TestMethod_General_append_extract_struct()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
TEST tempData = new TEST();
tempData.v0 = (sbyte)3;
tempData.v1 = (byte)4;
tempData.v2 = (short)4100;
tempData.v3 = (ushort)32210;
tempData.v4 = 123310;
tempData.v5 = 121234;
tempData.v6 = -1000443L;
tempData.v7 = 12233094310UL;
tempData.v8 = 1.0f;
tempData.v9 = 2.0;
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 1) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 2) 값 써넣기
bufferTemp.append <TEST>(tempData);
// 3) 값 읽기
var value2 = bufferTemp.extract <TEST>();
}
}
static void Sample_simple_append_extract_struct()
{
// Decalre) 임시로 사용할 List를 선언한다.
TEST temp = new TEST();
temp.x = 10;
temp.y = 1.0f;
temp.z = "temp string";
temp.w = new List <int> {
10, 20, 30
};
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND) List<int>를 추가한다.
bufTemp.append(temp);
// EXTRACT) 추가했던 문자열을 읽어낸다.
var tempRead = bufTemp.extract <TEST>();
// 2) 출력한다.
Console.WriteLine(tempRead.x);
Console.WriteLine(tempRead.y);
Console.WriteLine(tempRead.z);
foreach (var iter in tempRead.w)
{
Console.WriteLine(iter.ToString());
}
}
public void Test_buffer_appendextract_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(1024);
string[] strResult;
// - 값 써넣기
function_append_STRING(ref bufferTemp);
strResult = function_extract_STRING(ref bufferTemp);
// Check)
Assert.IsTrue(bufferTemp.Count == 0);
Assert.IsTrue(array_string[0] == strResult[0]);
Assert.IsTrue(array_string[1] == strResult[1]);
Assert.IsTrue(array_string[2] == strResult[2]);
Assert.IsTrue(array_string[3] == strResult[3]);
Assert.IsTrue(array_string[4] == strResult[4]);
Assert.IsTrue(array_string[5] == strResult[5]);
Assert.IsTrue(array_string[6] == strResult[6]);
Assert.IsTrue(array_string[7] == strResult[7]);
}
}
public void Test_buffer_append_dictionary_int_int_extract_int_int()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(dictionary_int_int);
Dictionary <int, int> temp = bufferTemp.extract <Dictionary <int, int> >();
// Check)
Assert.IsTrue(bufferTemp.Count == 0);
Assert.IsTrue(dictionary_int_int.Count == temp.Count);
IEnumerator <int> ka = dictionary_int_int.Keys.GetEnumerator();
IEnumerator <int> va = dictionary_int_int.Values.GetEnumerator();
IEnumerator <int> kb = temp.Keys.GetEnumerator();
IEnumerator <int> vb = temp.Values.GetEnumerator();
while (ka.MoveNext() && kb.MoveNext() && va.MoveNext() && vb.MoveNext())
{
Assert.IsTrue(ka.Current == kb.Current);
Assert.IsTrue(va.Current == vb.Current);
}
}
}
public void Test_buffer_append_dictionary_string_string_get_front_string_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(dictionary_string_string);
// - 값 읽기
Dictionary <string, string> temp = bufferTemp.get_front <Dictionary <string, string> >();
// Check)
Assert.IsTrue(dictionary_string_string.Count == temp.Count);
IEnumerator <string> ka = dictionary_string_string.Keys.GetEnumerator();
IEnumerator <string> va = dictionary_string_string.Values.GetEnumerator();
IEnumerator <string> kb = temp.Keys.GetEnumerator();
IEnumerator <string> vb = temp.Values.GetEnumerator();
while (ka.MoveNext() && kb.MoveNext() && va.MoveNext() && vb.MoveNext())
{
Assert.IsTrue(ka.Current == kb.Current);
Assert.IsTrue(va.Current == vb.Current);
}
}
}
void function_append_STRING(ref CGD.buffer _Buffer)
{
_Buffer.append <string>(array_string[0]);
_Buffer.append <string>(array_string[1]);
_Buffer.append <string>(array_string[2]);
_Buffer.append <string>(array_string[3]);
_Buffer.append <string>(array_string[4]);
_Buffer.append <string>(array_string[5]);
_Buffer.append <string>(array_string[6]);
_Buffer.append <string>(array_string[7]);
}
public void Test_buffer_append_general()
{
// - Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(1024);
for (int i = 0; i < _TEST_COUNT; ++i)
{
CGD.buffer bufferTemp = bufferCreate;
// - 값 써넣기
function_append_GENERAL(ref bufferTemp);
}
}
public void Test_buffer_append_list_list_int_string_get_front()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_list_int);
List <List <int> > temp = bufferTemp.extract <List <List <int> > >();
}
}
public void Test_buffer_append_dictionary_string_list_string_get_front()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(dictionary_string_List_string);
Dictionary <string, List <string> > temp = bufferTemp.extract <Dictionary <string, List <string> > >();
}
}
void function_append_GENERAL(ref CGD.buffer _Buffer)
{
_Buffer.append <char>((char)12);
_Buffer.append <sbyte>((byte)3);
_Buffer.append <byte>((sbyte)4);
_Buffer.append <short>((short)4100);
_Buffer.append <ushort>((ushort)32210);
_Buffer.append <int>(123310);
_Buffer.append <uint>(12);
_Buffer.append <long>(-1000443L);
_Buffer.append <ulong>(12233094310UL);
_Buffer.append <float>(1.0f);
_Buffer.append <double>(2.0);
}
void function_extract_GENERAL(ref CGD.buffer _Buffer)
{
var value1 = _Buffer.extract <char>();
var value2 = _Buffer.extract <sbyte>();
var value3 = _Buffer.extract <byte>();
var value4 = _Buffer.extract <short>();
var value5 = _Buffer.extract <ushort>();
var value6 = _Buffer.extract <int>();
var value7 = _Buffer.extract <uint>();
var value8 = _Buffer.extract <long>();
var value9 = _Buffer.extract <ulong>();
var value10 = _Buffer.extract <float>();
var value11 = _Buffer.extract <double>();
}
private static void tcpSession_Connected(object sender, EventArgs e)
{
AsyncTcpSession session = sender as AsyncTcpSession;
Console.WriteLine("tcpSession_Connected");
var buffer = new CGD.buffer(50);
buffer.append <int>(123);
buffer.append <short>(0);
buffer.append <string>("전송한 데이터");
buffer.set_front <short>(buffer.Count, 4);
session.Send(buffer);
}
string[] function_extract_STRING(ref CGD.buffer _Buffer)
{
string[] temp = new string[8];
temp[0] = _Buffer.extract <string>();
temp[1] = _Buffer.extract <string>();
temp[2] = _Buffer.extract <string>();
temp[3] = _Buffer.extract <string>();
temp[4] = _Buffer.extract <string>();
temp[5] = _Buffer.extract <string>();
temp[6] = _Buffer.extract <string>();
temp[7] = _Buffer.extract <string>();
return(temp);
}
public void TestMethod_List_string_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 2) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 3) 값 써넣기
bufferTemp.append(list_int);
// 4) 값 읽기
var temp = bufferTemp.extract <List <int> >();
}
}
public void TestMethod_Associated_string_list_int_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 2) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 3) 값 써넣기
bufferTemp.append(dictionary_string_List_int);
// 4) 값 읽기
var temp = bufferTemp.extract <Dictionary <string, List <int> > >();
}
}
public void Test_buffer_append_getfront_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(1024);
// - 값 써넣기
bufferTemp.append <string>("Test_String");
string strResult;
strResult = bufferTemp.get_front <string>();
// Check)
Assert.IsTrue(strResult == "Test_String");
}
}
private static void tcpSession_DataReceived(object sender, DataEventArgs e)
{
AsyncTcpSession session = sender as AsyncTcpSession;
byte[] tmpBuffer = e.Data;
var buffer = new CGD.buffer(e.Data, 0, e.Length);
int bufferType = (int)buffer.extract_uint();
ushort bufferLength = (ushort)buffer.extract_short();
string bufferData = buffer.extract_string();
Console.WriteLine("tcpSession_DataReceived");
Console.WriteLine("---------------------------------");
Console.WriteLine("Type : " + bufferType);
Console.WriteLine("Length : " + bufferLength);
Console.WriteLine("Data : " + bufferData);
Console.WriteLine("---------------------------------");
}
public void Test_buffer_date()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
DateTime tempTime = new DateTime(2016, 12, 11, 03, 12, 22);
// - 값 써넣기
bufferTemp.append(tempTime);
var temp = bufferTemp.extract <DateTime>();
// Check)
Assert.IsTrue(tempTime == temp);
Assert.IsTrue(bufferTemp.len == 0);
}
}
public void Test_buffer_append_array_string_get_front_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(array_string);
string[] temp = bufferTemp.get_front <string[]>();
// Check)
Assert.IsTrue(array_string.Length == temp.Length);
for (int j = 0; j < array_string.Length; ++j)
{
Assert.AreEqual(array_string[j], temp[j]);
}
}
}
public void Test_buffer_append_array_int_get_front_array_int()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_int);
int[] temp = bufferTemp.get_front <int[]>();
// Check)
Assert.IsTrue(list_int.Count == temp.Length);
for (int j = 0; j < list_int.Count; ++j)
{
Assert.AreEqual(list_int[j], temp[j]);
}
}
}
public void Test_buffer_append_list_string_get_front_list_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_string);
List <string> temp = bufferTemp.get_front <List <string> >();
// Check)
Assert.IsTrue(list_string.Count == temp.Count);
for (int j = 0; j < list_string.Count; ++j)
{
Assert.AreEqual(list_string[j], temp[j]);
}
}
}
public void Test_buffer_appendextract_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(1024);
string[] strResult;
// - 값 써넣기
function_append_STRING(ref bufferTemp);
strResult = function_extract_STRING(ref bufferTemp);
// Check)
Assert.IsTrue(bufferTemp.Count==0);
Assert.IsTrue(array_string[0]==strResult[0]);
Assert.IsTrue(array_string[1]==strResult[1]);
Assert.IsTrue(array_string[2]==strResult[2]);
Assert.IsTrue(array_string[3]==strResult[3]);
Assert.IsTrue(array_string[4]==strResult[4]);
Assert.IsTrue(array_string[5]==strResult[5]);
Assert.IsTrue(array_string[6]==strResult[6]);
Assert.IsTrue(array_string[7]==strResult[7]);
}
}
public void Test_buffer_append_array_string_get_front_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(array_string);
string[] temp = bufferTemp.get_front<string[]>();
// Check)
Assert.IsTrue(array_string.Length==temp.Length);
for(int j=0;j<array_string.Length;++j)
Assert.AreEqual(array_string[j], temp[j]);
}
}
static void Sample_simple_append_extract_struct()
{
// Decalre) 임시로 사용할 List를 선언한다.
TEST temp = new TEST();
temp.x = 10;
temp.y = 1.0f;
temp.z = "temp string";
temp.w = new List<int> { 10, 20, 30};
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND) List<int>를 추가한다.
bufTemp.append(temp);
// EXTRACT) 추가했던 문자열을 읽어낸다.
var tempRead = bufTemp.extract<TEST>();
// 2) 출력한다.
Console.WriteLine(tempRead.x);
Console.WriteLine(tempRead.y);
Console.WriteLine(tempRead.z);
foreach (var iter in tempRead.w) { Console.WriteLine(iter.ToString()); }
}
public void Test_buffer_append_dictionary_int_int_extract_int_int()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(dictionary_int_int);
Dictionary<int, int> temp = bufferTemp.extract<Dictionary<int, int>>();
// Check)
Assert.IsTrue(bufferTemp.Count==0);
Assert.IsTrue(dictionary_int_int.Count==temp.Count);
IEnumerator<int> ka = dictionary_int_int.Keys.GetEnumerator();
IEnumerator<int> va = dictionary_int_int.Values.GetEnumerator();
IEnumerator<int> kb = temp.Keys.GetEnumerator();
IEnumerator<int> vb = temp.Values.GetEnumerator();
while(ka.MoveNext() && kb.MoveNext() && va.MoveNext() && vb.MoveNext())
{
Assert.IsTrue(ka.Current==kb.Current);
Assert.IsTrue(va.Current==vb.Current);
}
}
}
public void Test_buffer_date()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
DateTime tempTime = new DateTime(2016, 12, 11, 03,12,22);
// - 값 써넣기
bufferTemp.append(tempTime);
var temp = bufferTemp.extract<DateTime>();
// Check)
Assert.IsTrue(tempTime==temp);
Assert.IsTrue(bufferTemp.len==0);
}
}
public void Test_buffer_front_general()
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(1024);
bufferTemp.append<char>(12);
bufferTemp.set_front<char>(12);
var a0 = bufferTemp.get_front<char>();
Assert.IsTrue(a0==12);
bufferTemp.append<sbyte>(3);
bufferTemp.set_front<sbyte>(3);
var a1 = bufferTemp.get_front<sbyte>();
Assert.IsTrue(a1==3);
bufferTemp.append<byte>(4);
bufferTemp.set_front<byte>(4);
var a2 = bufferTemp.get_front<byte>();
Assert.IsTrue(a2==4);
bufferTemp.append<short>(4100);
bufferTemp.set_front<short>(4100);
var a3 = bufferTemp.get_front<short>();
Assert.IsTrue(a3==4100);
bufferTemp.append<ushort>(32210);
bufferTemp.set_front<ushort>(32210);
var a4 = bufferTemp.get_front<ushort>();
Assert.IsTrue(a4==32210);
bufferTemp.append<int>(123310);
bufferTemp.set_front<int>(123310);
var a5 = bufferTemp.get_front<int>();
Assert.IsTrue(a5==123310);
bufferTemp.append<uint>(12);
bufferTemp.set_front<uint>(12);
var a6 = bufferTemp.get_front<uint>();
Assert.IsTrue(a6==12);
bufferTemp.append<long>(-1000443L);
bufferTemp.set_front<long>(-1000443L);
var a7 = bufferTemp.get_front<long>();
Assert.IsTrue(a7==-1000443L);
bufferTemp.append<ulong>(12233094310UL);
bufferTemp.set_front<ulong>(12233094310UL);
var a8 = bufferTemp.get_front<ulong>();
Assert.IsTrue(a8==12233094310UL);
bufferTemp.append<float>(1.0f);
bufferTemp.set_front<float>(1.0f);
var a9 = bufferTemp.get_front<float>();
Assert.IsTrue(a9==1.0f);
bufferTemp.append<double>(2.0);
bufferTemp.set_front<double>(2.0);
var a10 = bufferTemp.get_front<double>();
Assert.IsTrue(a10==2.0);
}
static void Sample_simple_append_extract_struct2()
{
// Declare) 임시로 사용할 List를 선언한다.
TEST2 temp = new TEST2();
temp.a = 10;
//temp.b; // 생성하지 않았다! (이 변수는 null일 것이다.)
temp.c = new TEST();
temp.c.x = 10;
temp.c.y = 1.0f;
//temp.c.z = "temp string";
temp.c.w = new List<int> { 10, 20, 30 };
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND 1) List<int>를 추가한다.
bufTemp.append(temp);
// EXTRACT 1) 추가했던 문자열을 읽어낸다.
var tempRead = bufTemp.extract<TEST2>();
// 4) 출력한다.
Console.WriteLine(tempRead.a);
Console.WriteLine(tempRead.b);
Console.WriteLine(tempRead.c.x);
Console.WriteLine(tempRead.c.y);
Console.WriteLine(tempRead.c.z);
foreach (var iter in tempRead.c.w) { Console.WriteLine(iter.ToString()); }
}
public void TestMethod_List_string_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 2) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 3) 값 써넣기
bufferTemp.append(list_int);
// 4) 값 읽기
var temp = bufferTemp.extract<List<int>>();
}
}
public void Test_buffer_append_getfront_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(1024);
// - 값 써넣기
bufferTemp.append<string>("Test_String");
string strResult;
strResult = bufferTemp.get_front<string>();
// Check)
Assert.IsTrue(strResult=="Test_String");
}
}
public void Test_buffer_append_list_list_int_string_get_front()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_list_int);
List<List<int>> temp = bufferTemp.extract<List<List<int>>>();
}
}
public void Test_buffer_append_list_string_get_front_list_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_string);
List<string> temp = bufferTemp.get_front<List<string>>();
// Check)
Assert.IsTrue(list_string.Count==temp.Count);
for(int j=0;j<list_string.Count;++j)
Assert.AreEqual(list_string[j], temp[j]);
}
}
public void TestMethod_String_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
string[] stringExtract = new string[8];
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 2) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 3) 값 써넣기
bufferTemp.append<string>(array_string[0]);
bufferTemp.append<string>(array_string[1]);
bufferTemp.append<string>(array_string[2]);
bufferTemp.append<string>(array_string[3]);
bufferTemp.append<string>(array_string[4]);
bufferTemp.append<string>(array_string[5]);
bufferTemp.append<string>(array_string[6]);
bufferTemp.append<string>(array_string[7]);
// 4) 값 읽기
stringExtract[0] = bufferTemp.extract<string>();
stringExtract[1] = bufferTemp.extract<string>();
stringExtract[2] = bufferTemp.extract<string>();
stringExtract[3] = bufferTemp.extract<string>();
stringExtract[4] = bufferTemp.extract<string>();
stringExtract[5] = bufferTemp.extract<string>();
stringExtract[6] = bufferTemp.extract<string>();
stringExtract[7] = bufferTemp.extract<string>();
}
}
public void TestMethod1()
{
CGD.buffer tempBufer = new CGD.buffer();
tempBufer.alloc(100);
TEST temp = new TEST();
temp.X = 10;
temp.Y = 1.0f;
temp.Z = 100;
string tempString = "Txxx";
tempBufer.append<int>(10);
tempBufer.append<TEST>(temp);
tempBufer.append<string>(tempString);
int a1 = tempBufer.extract<int>();
TEST a2 = tempBufer.extract<TEST>();
string a3 = tempBufer.extract<string>();
}
public void TestMethod_Associated_string_list_int_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 2) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 3) 값 써넣기
bufferTemp.append(dictionary_string_List_int);
// 4) 값 읽기
var temp = bufferTemp.extract<Dictionary<string, List<int>> >();
}
}
public void Test_buffer_append_array_int_get_front_array_int()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_int);
int[] temp = bufferTemp.get_front<int[]>();
// Check)
Assert.IsTrue(list_int.Count==temp.Length);
for(int j=0;j<list_int.Count;++j)
Assert.AreEqual(list_int[j], temp[j]);
}
}
public void Test_buffer_append_general()
{
// - Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(1024);
for (int i = 0; i < _TEST_COUNT; ++i)
{
CGD.buffer bufferTemp = bufferCreate;
// - 값 써넣기
function_append_GENERAL(ref bufferTemp);
}
}
public void TestMethod2()
{
CGD.buffer tempBufer = new CGD.buffer();
tempBufer.alloc(200);
TEST_B temp = new TEST_B();
temp.X = 10;
temp.Y = "Tesfdsafdsafdsafdst";
temp.Z = 100;
temp.W = new List<int> { 10, 20, 30};
string tempString;
tempString = "Txxfasgfsgfdfx";
tempBufer.append<int>(10);
tempBufer.append<TEST_B>(temp);
tempBufer.append<string>(tempString);
int a1 = tempBufer.extract<int>();
TEST_B a2 = tempBufer.extract<TEST_B>();
string a3 = tempBufer.extract<string>();
}
public void Test_buffer_append_dictionary_string_string_get_front_string_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(dictionary_string_string);
// - 값 읽기
Dictionary<string, string> temp = bufferTemp.get_front<Dictionary<string, string>>();
// Check)
Assert.IsTrue(dictionary_string_string.Count==temp.Count);
IEnumerator<string> ka = dictionary_string_string.Keys.GetEnumerator();
IEnumerator<string> va = dictionary_string_string.Values.GetEnumerator();
IEnumerator<string> kb = temp.Keys.GetEnumerator();
IEnumerator<string> vb = temp.Values.GetEnumerator();
while(ka.MoveNext() && kb.MoveNext() && va.MoveNext() && vb.MoveNext())
{
Assert.IsTrue(ka.Current==kb.Current);
Assert.IsTrue(va.Current==vb.Current);
}
}
}
//----------------------------------------------------------------------------
// Example 1) 다양한 형태의 생성 방법
//
//----------------------------------------------------------------------------
static void Sample_simple_creation_copy()
{
// Case 1) 256 Byte의 메모리를 할당한다.
CGD.buffer bufTemp1 = new CGD.buffer(256);
// Case 2) 선언 후 할당하기
CGD.buffer bufTemp2 = new CGD.buffer();
bufTemp2.alloc(256);
// Case 3) CGPool이 있을 경우
//CGD.buffer buffer 3 = MEM_POOL.Alloc(256);
// Case 4) 바이트 배열을 직접 할당해 넣기.
CGD.buffer bufTemp3 = new CGD.buffer(new byte[256]);
// Case 5) byte[]과 함께 Offset과 Length도 설정하기
// (offset:10, Count:100)
CGD.buffer bufTemp4 = new CGD.buffer(new byte[256], 10, 100);
// Case 6) 생성된 CGD.buffer에서 가져온다.(얕은 복사)
CGD.buffer bufTemp5 = bufTemp1;
// Case 7) 생성된 기본 버퍼에서 Offset을 10만큼 더한 후 가져오기
CGD.buffer bufTemp6 = bufTemp2 + 10;
// Case 8) 복사본을 만든다. (깊은 복사)
CGD.buffer bufTemp7 = bufTemp1.clone();
// 할당 해제
bufTemp1.clear();
}
public void Test_buffer_append_dictionary_string_list_string_get_front()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(dictionary_string_List_string);
Dictionary<string, List<string>> temp=bufferTemp.extract<Dictionary<string, List<string>>>();
}
}
public void TestMethod_General_append_extract()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 1) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 2) 값 써넣기
bufferTemp.append<sbyte>((sbyte)3);
bufferTemp.append<byte>((byte)4);
bufferTemp.append<short>((short)4100);
bufferTemp.append<ushort>((ushort)32210);
bufferTemp.append<int>(123310);
bufferTemp.append<uint>(121234);
bufferTemp.append<long>(-1000443L);
bufferTemp.append<ulong>(12233094310UL);
bufferTemp.append<float>(1.0f);
bufferTemp.append<double>(2.0);
// 3) 값 읽기
var value0 = bufferTemp.extract<sbyte>();
var value1 = bufferTemp.extract<byte>();
var value2 = bufferTemp.extract<short>();
var value3 = bufferTemp.extract<ushort>();
var value4 = bufferTemp.extract<int>();
var value5 = bufferTemp.extract<uint>();
var value6 = bufferTemp.extract<long>();
var value7 = bufferTemp.extract<ulong>();
var value8 = bufferTemp.extract<float>();
var value9 = bufferTemp.extract<double>();
}
}
public void Test_buffer__multi_level()
{
CGD.buffer tempBufer = new CGD.buffer();
tempBufer.alloc(200);
TEST_C temp = new TEST_C();
temp.x = 10;
temp.y = new List<int> { 1, 2, 3};
temp.t = new DateTime(1990, 12, 11, 10, 21, 11);
temp.z.X = 10;
temp.z.Y = "Tesfdsafdsafdsafdst";
temp.z.Z = 100;
temp.z.W = new List<int> { 10, 20, 30};
string tempString;
tempString = "Txxfasgfsgfdfx";
tempBufer.append<int>(10);
tempBufer.append<TEST_C>(temp);
tempBufer.append<string>(tempString);
var a1 = tempBufer.extract<int>();
var a2 = tempBufer.extract<TEST_C>();
var a3 = tempBufer.extract<string>();
}
public void TestMethod_General_append_extract_struct()
{
// 1) Buffer 할당
CGD.buffer bufferCreate = new CGD.buffer(2048);
TEST tempData = new TEST();
tempData.v0 = (sbyte)3;
tempData.v1 = (byte)4;
tempData.v2 = (short)4100;
tempData.v3 = (ushort)32210;
tempData.v4 = 123310;
tempData.v5 = 121234;
tempData.v6 = -1000443L;
tempData.v7 = 12233094310UL;
tempData.v8 = 1.0f;
tempData.v9 = 2.0;
for (int i = 0; i < _TEST_COUNT; ++i)
{
// 1) Buffer 준비
CGD.buffer bufferTemp = bufferCreate;
// 2) 값 써넣기
bufferTemp.append<TEST>(tempData);
// 3) 값 읽기
var value2 = bufferTemp.extract<TEST>();
}
}
//----------------------------------------------------------------------------
// Example 3) 문자열 쓰기/읽기
//
// 역시 append<string> 함수를 사용하여 버퍼의 끝에 string형 값을 쓸수 있다.
// 굳이 <string>을 쓸 필요가 없지만 코드의 가독성을 위해 붙여 주는 경우가 많다.
//
// 읽을 때는 extract<string> 함수를 사용하여 읽을 수 있다.
// 여기서는 반드시 템플릿 인자인 <string>를 써주어야 한다.
//
//----------------------------------------------------------------------------
static void Sample_simple_append_extract_string()
{
// 1) byte[256]를 생성해서 설정한다.
CGD.buffer bufTemp = new CGD.buffer(new byte[256]);
// APPEND1) 문자열을 추가한다. (1)
bufTemp.append<string>("First test String");
// APPEND2) 문자열을 추가한다. 구지 <string>을 쓸 필요는 없다.(2)
bufTemp.append("Second");
// Declare) 임시로 문자열 변수를 만든다.
string tempString = "Third";
// APPEND3) 문자열을 추가한다. 구지 <string>을 쓸 필요는 없다.(2)
bufTemp.append(tempString);
// EXTRACT) 추가된 문자열을 뽑아낸다.
var str1 = bufTemp.extract<string>(); // "First test String"
var str2 = bufTemp.extract<string>(); // "Second"
var str3 = bufTemp.extract<string>(); // "Third"
// 확인)
Console.WriteLine(str1);
Console.WriteLine(str2);
Console.WriteLine(str3);
}
