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]); } }