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);
}
//----------------------------------------------------------------------------
// 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 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);
}
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_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>();
}
}
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 Test_buffer_append_dictionary_string_string_extract_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.extract <Dictionary <string, string> >();
// Check)
Assert.IsTrue(bufferTemp.Count == 0);
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);
}
}
}
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 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 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_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> > >();
}
}
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 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_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_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_list_string_extract_general()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_string);
List <string> temp = bufferTemp.extract <List <string> >();
// Check)
Assert.IsTrue(bufferTemp.Count == 0);
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_append_array_string_extract_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(array_string);
string[] temp = bufferTemp.extract <string[]>();
// Check)
Assert.IsTrue(bufferTemp.Count == 0);
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_extract_int()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_int);
int[] temp = bufferTemp.extract <int[]>();
// Check)
Assert.IsTrue(bufferTemp.Count == 0);
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_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__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 Test_buffer_append_dictionary_string_string_extract_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.extract<Dictionary<string, string>>();
// Check)
Assert.IsTrue(bufferTemp.Count==0);
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);
}
}
}
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>>>();
}
}
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 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 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>();
}
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_list_string_extract_general()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_string);
List<string> temp = bufferTemp.extract<List<string>>();
// Check)
Assert.IsTrue(bufferTemp.Count==0);
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_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>>>();
}
}
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>();
}
//----------------------------------------------------------------------------
// 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_append_array_int_extract_int()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(list_int);
int[] temp = bufferTemp.extract<int[]>();
// Check)
Assert.IsTrue(bufferTemp.Count==0);
Assert.IsTrue(list_int.Count==temp.Length);
for(int j=0;j<list_int.Count;++j)
Assert.AreEqual(list_int[j], temp[j]);
}
}
//----------------------------------------------------------------------------
// 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);
}
public void Test_buffer_append_array_string_extract_string()
{
for (int i = 0; i < _TEST_COUNT; ++i)
{
// - Buffer 할당
CGD.buffer bufferTemp = new CGD.buffer(2048);
// - 값 써넣기
bufferTemp.append(array_string);
string[] temp = bufferTemp.extract<string[]>();
// Check)
Assert.IsTrue(bufferTemp.Count==0);
Assert.IsTrue(array_string.Length==temp.Length);
for(int j=0;j<array_string.Length;++j)
Assert.AreEqual(array_string[j], temp[j]);
}
}
