ooxml_crypt 0.1.0

data/vendor/cybozulib/include/cybozu/csv.hpp

@@ -0,0 +1,294 @@
+#pragma once
+/**
+	@file
+	@brief csv reader and write class
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+
+#include <string>
+#include <list>
+#include <fstream>
+#include <cybozu/stream.hpp>
+
+namespace cybozu {
+
+namespace csv_local {
+
+inline bool isValidSeparator(char c)
+{
+	return c == ',' || c == '\t' || c == ';' || c == ' ';
+}
+
+} // csv_local
+/**
+	CSV reader class
+	InputStream must have ssize_t read(char *str, size_t size);
+*/
+template<class InputStream, size_t MAX_LINE_SIZE = 10 * 1024 * 1024>
+class CsvReaderT {
+	CsvReaderT(const CsvReaderT&);
+	void operator=(const CsvReaderT&);
+	typedef cybozu::InputStreamTag<InputStream> In;
+public:
+	/**
+		@param is [in] input stream
+		@param sep [in] separator character(comma, tab, semicolon, space)
+	*/
+	CsvReaderT(InputStream& is, char sep = ',')
+		: sep_(sep)
+		, is_(is)
+		, line_(0)
+		, lineSize_(0)
+		, pos_(0)
+		, bufSize_(0)
+		, eof_(false)
+	{
+		if (!csv_local::isValidSeparator(sep)) {
+			throw cybozu::Exception("csv:CsvReaderT:invalid separator") << sep;
+		}
+	}
+	/**
+		get one line from InputStream and push_back() into out
+		@return false if no data(eof)
+		@note out must have push_back(std::string)
+		@note string must be UTF-8
+		ignore all \x0d
+	*/
+	template<class Container>
+	bool read(Container& out)
+	{
+		if (eof_) return false;
+		line_++;
+		out.clear();
+		enum {
+			Top,
+			InQuote,
+			SearchSep,
+			NeedSepOrQuote
+		} state = Top;
+
+		const char CR = '\x0d';
+		const char LF = '\x0a';
+		const char quote = '"';
+
+		std::string str;
+		for (;;) {
+			int c = my_getchar();
+			if (c == EOF && str.empty()) return false;
+			if (c == CR) continue;
+			switch (state) {
+			case Top:
+				if (c == EOF || c == LF) {
+					if (!str.empty()) {
+						appendAndClear(out, str);
+					}
+					return true;
+				}
+				if (c == quote) {
+					state = InQuote;
+				} else if (c == sep_) {
+					appendAndClear(out, str);
+				} else {
+					addChar(str, c);
+					state = SearchSep;
+				}
+				break;
+			case InQuote:
+				if (c == EOF) {
+					throw cybozu::Exception("csv:read:quote is necessary") << line_ << str;
+				}
+				if (c == quote) {
+					state = NeedSepOrQuote;
+				} else {
+					addChar(str, c);
+				}
+				break;
+			case NeedSepOrQuote:
+				if (c == EOF || c == LF) {
+					appendAndClear(out, str);
+					return true;
+				}
+				if (c == quote) {
+					addChar(str, quote);
+					state = InQuote;
+				} else if (c == sep_) {
+					appendAndClear(out, str);
+					state = Top;
+				} else {
+					throw cybozu::Exception("csv:read:bad character after quote") << line_ << str << c;
+				}
+				break;
+			case SearchSep:
+			default:
+				if (c == EOF || c == LF) {
+					appendAndClear(out, str);
+					return true;
+				}
+				if (c == sep_) {
+					appendAndClear(out, str);
+					state = Top;
+				} else {
+					addChar(str, c);
+				}
+				break;
+			}
+		}
+	}
+private:
+	void addChar(std::string& str, int c)
+	{
+		str += static_cast<char>(c);
+		lineSize_++;
+		if (lineSize_ == MAX_LINE_SIZE) {
+			throw cybozu::Exception("csv:addChar:too large size") << line_ << str << MAX_LINE_SIZE;
+		}
+	}
+	template<class Container>
+	void appendAndClear(Container& out, std::string& str)
+	{
+		out.push_back(str);
+		str.clear();
+	}
+	int my_getchar()
+	{
+		if (pos_ < bufSize_) {
+			return buf_[pos_++];
+		}
+		bufSize_ = cybozu::readSome(buf_, sizeof(buf_), is_);
+		if (bufSize_ > 0) {
+			pos_ = 1;
+			return buf_[0];
+		} else {
+			pos_ = 0;
+			eof_ = true;
+			return EOF;
+		}
+	}
+	char sep_;
+	InputStream& is_;
+	size_t line_;
+	size_t lineSize_;
+	char buf_[2048];
+	size_t pos_;
+	size_t bufSize_;
+	bool eof_;
+};
+
+/**
+	CSV writer class
+	OutputStream must have ssize_t write(const char *str, size_t size);
+*/
+template<class OutputStream>
+class CsvWriterT {
+	CsvWriterT(const CsvWriterT&);
+	void operator=(const CsvWriterT&);
+	typedef cybozu::OutputStreamTag<OutputStream> Out;
+public:
+	/**
+		@param os [in] output stream
+		@param sep [in] separator character(comma, tab, semicolon, space)
+	*/
+	CsvWriterT(OutputStream& os, char sep = ',')
+		: os_(os)
+		, sep_(sep)
+	{
+		if (!csv_local::isValidSeparator(sep)) {
+			throw cybozu::Exception("csv:CsvWriteT:inavlid separator") << sep;
+		}
+	}
+	/**
+		make one line from [begin, end) and write it
+		@note type of *begin must be std::string
+		@note string must be UTF-8
+	*/
+	template<class Iterator>
+	void write(Iterator begin, Iterator end)
+	{
+		bool isFirst = true;
+		while (begin != end) {
+			if (isFirst) {
+				isFirst = false;
+			} else {
+				appendSeparator();
+			}
+			append(*begin);
+			++begin;
+		}
+		appendEndLine();
+	}
+private:
+	void append(const std::string& str)
+	{
+		std::string out = "\"";
+		for (size_t i = 0, n = str.size(); i < n; i++) {
+			char c = str[i];
+			if (c == '"') {
+				out += '"';
+			}
+			out += c;
+		}
+		out += "\"";
+		writeToStream(&out[0], out.size());
+	}
+	void appendSeparator()
+	{
+		writeToStream(&sep_, 1);
+	}
+	void appendEndLine()
+	{
+		writeToStream("\x0d\x0a", 2);
+	}
+	void writeToStream(const char *str, size_t size)
+	{
+		Out::write(os_, str, size);
+	}
+	OutputStream& os_;
+	char sep_;
+};
+
+class CsvReader {
+	std::ifstream ifs_;
+	cybozu::CsvReaderT<std::ifstream> csv_;
+public:
+	CsvReader(const std::string& name, char sep = ',')
+		: ifs_(name.c_str(), std::ios::binary)
+		, csv_(ifs_, sep)
+	{
+	}
+	/**
+		get one line from InputStream and push_back() into out
+		@return false if no data(eof)
+		@note out must have push_back(std::string)
+		@note string must be UTF-8
+		ignore all \x0d
+	*/
+	template<class Container>
+	bool read(Container& out)
+	{
+		return csv_.read(out);
+	}
+};
+
+class CsvWriter {
+	std::ofstream ofs_;
+	cybozu::CsvWriterT<std::ofstream> csv_;
+public:
+	CsvWriter(const std::string& name, char sep = ',')
+		: ofs_(name.c_str(), std::ios::binary)
+		, csv_(ofs_, sep)
+	{
+	}
+	/**
+		make one line from [begin, end) and write it
+		@note type of *begin must be std::string
+		@note string must be UTF-8
+	*/
+	template<class Iterator>
+	void write(Iterator begin, Iterator end)
+	{
+		csv_.write(begin, end);
+	}
+};
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/data_type.hpp

@@ -0,0 +1,27 @@
+#pragma once
+/**
+	@file
+	@brief typedef of some STL data type
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <cybozu/inttype.hpp>
+
+namespace cybozu {
+
+typedef std::vector<int> IntVec;
+typedef std::vector<uint32_t> Uint32Vec;
+typedef std::vector<std::string> StrVec;
+typedef std::map<int, int> Int2Int;
+typedef std::map<int, std::string> Int2Str;
+typedef std::map<std::string, int> Str2Int;
+typedef std::map<std::string, std::string> Str2Str;
+typedef std::set<int> IntSet;
+typedef std::set<uint32_t> Uint32Set;
+typedef std::set<std::string> StrSet;
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/endian.hpp

@@ -0,0 +1,224 @@
+#pragma once
+
+/**
+	@file
+	@brief deal with big and little endian
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#include <cybozu/inttype.hpp>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+namespace cybozu {
+
+#ifdef _MSC_VER
+inline uint16_t byteSwap(uint16_t x) { return _byteswap_ushort(x); }
+inline uint32_t byteSwap(uint32_t x) { return _byteswap_ulong(x); }
+inline uint64_t byteSwap(uint64_t x) { return _byteswap_uint64(x); }
+#else
+#if (((__GNUC__) << 16) + (__GNUC_MINOR__)) >= ((4 << 16) + 8)
+inline uint16_t byteSwap(uint16_t x) { return __builtin_bswap16(x); }
+#else
+inline uint16_t byteSwap(uint16_t x) { return (x >> 8) | (x << 8); }
+#endif
+inline uint32_t byteSwap(uint32_t x) { return __builtin_bswap32(x); }
+inline uint64_t byteSwap(uint64_t x) { return __builtin_bswap64(x); }
+#endif
+
+/**
+	get 16bit integer as little endian
+	@param src [in] pointer
+*/
+inline uint16_t Get16bitAsLE(const void *src)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	uint16_t x;
+	memcpy(&x, src, sizeof(x));
+	return x;
+#else
+	const uint8_t *p = static_cast<const uint8_t *>(src);
+	return p[0] | (p[1] << 8);
+#endif
+}
+
+/**
+	get 32bit integer as little endian
+	@param src [in] pointer
+*/
+inline uint32_t Get32bitAsLE(const void *src)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	uint32_t x;
+	memcpy(&x, src, sizeof(x));
+	return x;
+#else
+	const uint8_t *p = static_cast<const uint8_t *>(src);
+	return Get16bitAsLE(p) | (static_cast<uint32_t>(Get16bitAsLE(p + 2)) << 16);
+#endif
+}
+
+/**
+	get 64bit integer as little endian
+	@param src [in] pointer
+*/
+inline uint64_t Get64bitAsLE(const void *src)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	uint64_t x;
+	memcpy(&x, src, sizeof(x));
+	return x;
+#else
+	const uint8_t *p = static_cast<const uint8_t *>(src);
+	return Get32bitAsLE(p) | (static_cast<uint64_t>(Get32bitAsLE(p + 4)) << 32);
+#endif
+}
+
+/**
+	get 16bit integer as bit endian
+	@param src [in] pointer
+*/
+inline uint16_t Get16bitAsBE(const void *src)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	uint16_t x;
+	memcpy(&x, src, sizeof(x));
+	return byteSwap(x);
+#else
+	const uint8_t *p = static_cast<const uint8_t *>(src);
+	return p[1] | (p[0] << 8);
+#endif
+}
+
+/**
+	get 32bit integer as bit endian
+	@param src [in] pointer
+*/
+inline uint32_t Get32bitAsBE(const void *src)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	uint32_t x;
+	memcpy(&x, src, sizeof(x));
+	return byteSwap(x);
+#else
+	const uint8_t *p = static_cast<const uint8_t *>(src);
+	return Get16bitAsBE(p + 2) | (static_cast<uint32_t>(Get16bitAsBE(p)) << 16);
+#endif
+}
+
+/**
+	get 64bit integer as big endian
+	@param src [in] pointer
+*/
+inline uint64_t Get64bitAsBE(const void *src)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	uint64_t x;
+	memcpy(&x, src, sizeof(x));
+	return byteSwap(x);
+#else
+	const uint8_t *p = static_cast<const uint8_t *>(src);
+	return Get32bitAsBE(p + 4) | (static_cast<uint64_t>(Get32bitAsBE(p)) << 32);
+#endif
+}
+
+/**
+	set 16bit integer as little endian
+	@param src [out] pointer
+	@param x [in] integer
+*/
+inline void Set16bitAsLE(void *src, uint16_t x)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	memcpy(src, &x, sizeof(x));
+#else
+	uint8_t *p = static_cast<uint8_t *>(src);
+	p[0] = static_cast<uint8_t>(x);
+	p[1] = static_cast<uint8_t>(x >> 8);
+#endif
+}
+/**
+	set 32bit integer as little endian
+	@param src [out] pointer
+	@param x [in] integer
+*/
+inline void Set32bitAsLE(void *src, uint32_t x)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	memcpy(src, &x, sizeof(x));
+#else
+	uint8_t *p = static_cast<uint8_t *>(src);
+	p[0] = static_cast<uint8_t>(x);
+	p[1] = static_cast<uint8_t>(x >> 8);
+	p[2] = static_cast<uint8_t>(x >> 16);
+	p[3] = static_cast<uint8_t>(x >> 24);
+#endif
+}
+/**
+	set 64bit integer as little endian
+	@param src [out] pointer
+	@param x [in] integer
+*/
+inline void Set64bitAsLE(void *src, uint64_t x)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	memcpy(src, &x, sizeof(x));
+#else
+	uint8_t *p = static_cast<uint8_t *>(src);
+	Set32bitAsLE(p, static_cast<uint32_t>(x));
+	Set32bitAsLE(p + 4, static_cast<uint32_t>(x >> 32));
+#endif
+}
+/**
+	set 16bit integer as big endian
+	@param src [out] pointer
+	@param x [in] integer
+*/
+inline void Set16bitAsBE(void *src, uint16_t x)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	x = byteSwap(x);
+	memcpy(src, &x, sizeof(x));
+#else
+	uint8_t *p = static_cast<uint8_t *>(src);
+	p[0] = static_cast<uint8_t>(x >> 8);
+	p[1] = static_cast<uint8_t>(x);
+#endif
+}
+/**
+	set 32bit integer as big endian
+	@param src [out] pointer
+	@param x [in] integer
+*/
+inline void Set32bitAsBE(void *src, uint32_t x)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	x = byteSwap(x);
+	memcpy(src, &x, sizeof(x));
+#else
+	uint8_t *p = static_cast<uint8_t *>(src);
+	p[0] = static_cast<uint8_t>(x >> 24);
+	p[1] = static_cast<uint8_t>(x >> 16);
+	p[2] = static_cast<uint8_t>(x >> 8);
+	p[3] = static_cast<uint8_t>(x);
+#endif
+}
+/**
+	set 64bit integer as big endian
+	@param src [out] pointer
+	@param x [in] integer
+*/
+inline void Set64bitAsBE(void *src, uint64_t x)
+{
+#if CYBOZU_ENDIAN == CYBOZU_ENDIAN_LITTLE
+	x = byteSwap(x);
+	memcpy(src, &x, sizeof(x));
+#else
+	uint8_t *p = static_cast<uint8_t *>(src);
+	Set32bitAsBE(p, static_cast<uint32_t>(x >> 32));
+	Set32bitAsBE(p + 4, static_cast<uint32_t>(x));
+#endif
+}
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/env.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+/**
+	@file
+	@brief get env function
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#include <cybozu/exception.hpp>
+#include <stdlib.h>
+
+namespace cybozu {
+
+inline bool QueryEnv(std::string& value, const std::string& key)
+{
+#ifdef _WIN32
+	char buf[4096];
+	size_t size;
+	if (getenv_s(&size, buf, key.c_str()) == 0) {
+		if (size > 0) {
+			value.assign(buf, size - 1);
+			return true;
+		}
+	}
+	return false;
+#else
+	const char *p = getenv(key.c_str());
+	if (p) {
+		value.assign(p);
+		return true;
+	}
+	return false;
+#endif
+}
+
+/**
+	get env
+	@param key [in] key name
+	@return value
+	@note throw exception if none
+*/
+inline std::string GetEnv(const std::string& key)
+{
+	std::string value;
+	if (!QueryEnv(value, key)) throw cybozu::Exception("env:GetEnv") << key;
+	return value;
+}
+
+/**
+	get env
+	@param key [in] key name
+	@param defaultValue [in] default value
+	@return value
+	@note return defaultValue if none
+*/
+inline std::string GetEnv(const std::string& key, const std::string& defaultValue)
+{
+	std::string value;
+	if (!QueryEnv(value, key)) return defaultValue;
+	return value;
+}
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/event.hpp

@@ -0,0 +1,122 @@
+#pragma once
+/**
+	@file
+	@brief event class
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+
+#ifdef _WIN32
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+#else
+	#include <unistd.h>
+#endif
+#include <cybozu/exception.hpp>
+#if CYBOZU_CPP_VERSION >= CYBOZU_CPP_VERSION_CPP11
+#include <mutex>
+#include <condition_variable>
+#endif
+
+namespace cybozu {
+
+struct EventException : cybozu::Exception {
+	EventException() : cybozu::Exception("event") { }
+};
+
+#ifdef _WIN32
+class Event {
+	HANDLE event_;
+	Event(const Event&);
+	void operator=(const Event&);
+public:
+	Event()
+	{
+		event_ = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+		if (event_ == 0) {
+			cybozu::EventException e;
+			e << "CreateEvent";
+			throw e;
+		}
+	}
+	~Event()
+	{
+		::CloseHandle(event_);
+	}
+	void wakeup()
+	{
+		::SetEvent(event_);
+	}
+	void wait()
+	{
+		DWORD msec = INFINITE;
+		if (WaitForSingleObject(event_, msec) != WAIT_OBJECT_0) {
+			cybozu::EventException e;
+			e << "wait";
+			throw e;
+		}
+	}
+};
+#else
+#if CYBOZU_CPP_VERSION >= CYBOZU_CPP_VERSION_CPP11
+
+class Event {
+	bool isSignaled_;
+	std::mutex m_;
+	std::condition_variable cv_;
+	Event(const Event&) = delete;
+	void operator=(const Event&) = delete;
+public:
+	Event() : isSignaled_(false) {}
+	void wakeup()
+	{
+        std::unique_lock<std::mutex> lk(m_);
+		isSignaled_ = true;
+		cv_.notify_one();
+	}
+	void wait()
+	{
+        std::unique_lock<std::mutex> lk(m_);
+		cv_.wait(lk, [this] { return isSignaled_; });
+		isSignaled_ = false;
+	}
+};
+
+#else
+class Event {
+	int pipefd_[2];
+	Event(const Event&);
+	void operator=(const Event&);
+public:
+	Event()
+	{
+		if (::pipe(pipefd_) < 0) {
+			cybozu::EventException e;
+			e << "pipe";
+			throw e;
+		}
+	}
+	~Event()
+	{
+		::close(pipefd_[0]);
+		::close(pipefd_[1]);
+	}
+	void wakeup()
+	{
+		char c = 'a';
+		ssize_t size = ::write(pipefd_[1], &c, 1);
+		cybozu::disable_warning_unused_variable(size);
+	}
+	void wait()
+	{
+		char c;
+		ssize_t size = ::read(pipefd_[0], &c, 1);
+		cybozu::disable_warning_unused_variable(size);
+	}
+};
+#endif
+#endif
+
+} // cybozu