ContiguousDataStorageOutputRef - История изменений

Андрей Чусов: Содержимое страницы заменено на «{{class|ContiguousDataStorageOutputRef}} {{ContiguousDataStorageOutputRef example}} {{sa_list_begin}} {{sa_list_add|ContiguousDataS…»

2019-08-16T08:45:59Z

Содержимое страницы заменено на «{{class|ContiguousDataStorageOutputRef}} {{ContiguousDataStorageOutputRef example}} {{sa_list_begin}} {{sa_list_add|ContiguousDataS…»

@@ Строка 1: / Строка 1: @@
-{{ContiguousDataStorageOutputRef_brief}}
+{{class|ContiguousDataStorageOutputRef}}
+{{ContiguousDataStorageOutputRef example}}
-{{ContiguousDataStorageOutputRef methods|Собственные методы.}}
+{{sa_list_begin}}
+{{sa_list_add|ContiguousDataStorageOutputOwn}}
+{{sa_list_add|ContiguousDataStorageInputRef}}
-{{example_begin}}
+{{sa_list_add|ContiguousDataStorageRef}}
-<source lang="cpp">
+{{sa_list_end}}

Андрей Чусов в 13:36, 11 декабря 2017

2017-12-11T13:36:05Z

← Предыдущая		Версия 23:36, 11 декабря 2017
Строка 2:		Строка 2:

	{{ContiguousDataStorageOutputRef methods\|Собственные методы.}}		{{ContiguousDataStorageOutputRef methods\|Собственные методы.}}


			{{example_begin}}
			<source lang="cpp">
			#include <camaas/idatastorage.h>
			#include <chsvlib/chsvmath.h>
			#include <string>
			#include <iostream>
			#include <iomanip>

			using namespace CAMaaS;

			std::string operator""_s(const char* psz, std::size_t cch) {return std::string(psz, cch);}

			void TestContiguousDataSource(ContiguousDataStorageOutputRef output_side, ContiguousDataStorageInputRef input_side)
			{
			auto osWrite = represent_as<OutputByteStreamOwn>(output_side.write());
			osWrite.write(std::vector<std::uint8_t>({0x30, 0x31, 0x32, 0x33, 0x34}));
			osWrite.write(std::vector<std::uint8_t>({0x35, 0x36, 0x37, 0x38, 0x39}));
			auto osWrite2 = represent_as<OutputByteStreamOwn>(output_side.write(20));
			osWrite2.write(std::vector<std::uint8_t>({'a', 'b', 'c', 'd', 'e'}));
			osWrite2.write(std::vector<std::uint8_t>({'e', 'f', 'g', 'h', 'i'}));
			represent_as<ContiguousDataStorageOwn>(output_side).erase(10, 10);
			auto osRead1 = represent_as<InputByteStreamOwn>(input_side.read());
			auto v1 = osRead1.read_as<std::vector<std::uint8_t>>(10);
			auto vout10 = osRead1.read_as<std::vector<std::uint8_t>>(5);
			auto osRead2 = represent_as<InputByteStreamOwn>(input_side.read(15));
			auto vout11 = osRead2.read_as<std::vector<std::uint8_t>>(std::size_t(input_side.byte_size() - 15));
			std::move(vout10.begin(), vout10.end(), std::back_inserter(v1));
			std::move(vout11.begin(), vout11.end(), std::back_inserter(v1));
			auto v2 = represent_as<InputByteStreamOwn>(input_side.read()).read_all_as<std::vector<std::uint8_t>>();
			std::cout << "Vectors are equal: " << std::boolalpha << (v1 == v2) << "\n";
			std::cout << "Read contents: ";
			for (auto b:v2)
			std::cout << std::hex << b;
			std::cout << "\n";
			}

			constexpr std::uint8_t operator""_b(unsigned long long int val)
			{
			return std::uint8_t(val);
			}

			template <class _V>
			constexpr std::vector<_V> make_vector(std::initializer_list<_V> lst)
			{
			return std::vector<_V>(lst);
			}

			using namespace CAMaaS;

			bool copy(IInputByteStream* pFrom, IOutputByteStream* pTo)
			{
			const std::size_t WINDOW_SIZE = 0x1000;
			std::uint8_t buf[WINDOW_SIZE];
			std::uint64_t cbRead = 1;
			while(cbRead != 0)
			{
			cbRead = WINDOW_SIZE;
			std::int32_t nError = pFrom->ReadArray(buf, std::addressof(cbRead));
			if (nError < 0)
			return false; //error
			nError = pTo->WriteArray(buf, cbRead);
			if (nError < 0)
			return false; //error
			}
			return true;
			}

			int main(int, char**)
			{
			std::cout << "===File test===\n";
			auto strFile = u8"Test file.txt"_s;
			auto file = make_file_based_data_storage<FileReadWrite, FileCreateAlways>(strFile);
			TestContiguousDataSource(file, file);
			std::cout << "===Preallocated buffer test===\n";
			std::uint8_t pBuffer[100];
			auto buff = make_inmemory_preallocated_data_storage(pBuffer, sizeof(pBuffer));
			TestContiguousDataSource(buff, buff);
			std::cout << "===Preallocated buffer test with owning===\n";
			auto alloc = std::allocator<std::uint8_t>();
			auto p2 = std::allocator_traits<std::allocator<std::uint8_t>>::allocate(alloc, sizeof(pBuffer));
			auto buff2 = make_inmemory_preallocated_data_storage(own_buffer(p2, sizeof(pBuffer), alloc));
			TestContiguousDataSource(buff2, buff2);
			std::cout << "===Reading from existing buffer===\n";
			auto pRead = make_inmemory_input_data_source(pBuffer, std::size_t(buff.byte_size()));
			auto vRead = represent_as<InputByteStreamOwn>(pRead.read()).read_all_as<std::vector<std::uint8_t>>();
			std::cout << "Read contents from the input buffer: ";
			for (auto b:vRead)
			std::cout << std::hex << b;
			std::cout << "\n";
			try
			{
			represent_as<ConsequentDataStorageOwn>(pRead);
			std::cout << "Conversion did NOT cause an expected error\n";
			}catch (Chusov::Exceptions::ChsvCodeException& ex)
			{
			std::cout << "Conversion caused expected error: " << ex.what() << "\n";
			}
			std::cout << "===Cached buffer test===\n";
			auto buff_cached = make_inmemory_data_storage();
			TestContiguousDataSource(buff_cached, buff_cached);

			return 0;

			}

			</source>
			{{example_end}}

Ninok2801: Новая страница: «{{ContiguousDataStorageOutputRef_brief}} {{ContiguousDataStorageOutputRef methods|Собственные методы.}}»

2017-04-25T02:05:32Z

Новая страница: «{{ContiguousDataStorageOutputRef_brief}} {{ContiguousDataStorageOutputRef methods|Собственные методы.}}»

Новая страница