BasexSocket& BasexSocket::CreateSocket (std::string host, std::string port) {
	// std::cout << __PRETTY_FUNCTION__ << std::endl;
	if (host.empty() || port.empty()) {
		Master_sfd = -1; return *this;
	}

	struct addrinfo hints;
	struct addrinfo *result = NULL, *rp;
	// Initialize hints
	memset(&hints, 0, sizeof(struct addrinfo));
	// hints.ai_family   = AF_UNSPEC; 
	hints.ai_family   = AF_INET;   AF_INET and AF_INET6
	// hints.ai_socktype = RAW;
	hints.ai_socktype = SOCK_STREAM; 
	hints.ai_flags    = AI_NUMERICSERV;                      // Port must be specified as number
	int rc;
	rc = getaddrinfo( host.c_str(), port.c_str(), &hints, &result);
	if (rc != 0) perror(gai_strerror(rc));

	for (rp = result; rp != NULL; rp = rp->ai_next) {
		Master_sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
		if (Master_sfd == -1) continue;
		if (connect(Master_sfd, rp->ai_addr, rp->ai_addrlen) != -1) break; // Try to connect. Return the first successfull connect or abort
		close(Master_sfd);
	}
	set_nonblock_flag( Master_sfd, 1);
	if (rp == NULL) {
		warnx("Can not connect to Basex server"); }

	freeaddrinfo(result);
	return *this;
}

int BasexSocket::writeData(const std::string & input) {
/*	std::cout << __PRETTY_FUNCTION__ << std::endl;*/
	int send_len = input.size();
	int bytes_sent = send(Master_sfd, input.c_str(), send_len, 0);
	if (bytes_sent != send_len) {
		debug_dump(input);
		perror("Error writing to socket");
		warnx("Writing data failed");
		return -1;
	}
	return bytes_sent;
};

int BasexSocket::writeData(const std::string& input) {
	int send_len = input.size();
	const char* cinput = input.c_str();

	do
		if (int bytes_sent = send(Master_sfd, cinput, send_len, 0); bytes_sent == SOCKET_ERROR) {
			debug_dump(input);
			perror("Error writing to socket");
			warnx("Writing data failed");
			return -1;
		} else {
			send_len -= bytes_sent;
			cinput += bytes_sent;
		}
	while (send_len);

	return input.size();
}

std::string makeDataProt(const std::vector<std::string>);

std::vector<std::string> obtainDataProt(const atd::string&);

ptrdiff_t writeData(const std::string& input) {
	auto send_len { std::ssize(input) };
	const char* cinput { input.c_str() };

	do
		if (const auto bytes_sent { send(Master_sfd, cinput, static_cast<int>(send_len), 0) }; bytes_sent == SOCKET_ERROR) {
			debug_dump(input);
			perror("Error writing to socket");
			warnx("Writing data failed");
			return -1;
		} else {
			send_len -= bytes_sent;
			cinput += bytes_sent;
		}
	while (send_len);

	return std::size(input);
}

std::string convTo(std::string str) {
	for (size_t pos {}; (pos = str.find('\0', pos)) != std::string::npos; pos += 2)
		str.insert(pos, 1, static_cast<char>(0xff));

	return str;
}

std::string makeDataProt(const std::string& str) {
	auto str1 { convTo(str) };

	str1.append(2, '\0');
	return str1;
}

std::string makeDataProt(const std::vector<std::string>& text) {
	std::string str;

	for (const auto& s : text)
		str += convTo(s) + '\0';

	return str + '\0';
}

int main() {
	std::vector<std::string> text { "qwery", "foobar" };

	text[1].insert(3, 1, '\0');

	const auto str1 {makeDataProt(text) };

	for (const unsigned char c : str1)
		if (std::isprint(c))
			std::cout << char(c);
		else
			std::cout << '\\' << std::hex << std::setw(2) << std::setfill('0') << unsigned(c);
}

add_FF <- function(cache_in) {
  FF <- which(255 == cache_in)
  Z  <- which(0 == cache_in)
  addFF <- c(FF, Z)
  if (length(addFF) > 0) {
    val <- c(cache_in, rep(as.raw(255), length(addFF)))
    id  <- c(seq_along(cache_in), addFF-0.5)
    val <- val[order(id)]
    return(val)
  } else
    return(cache_in)
}

std::string insBefore(std::string str, char toFind = 0, char toIns = static_cast<char>(0xff)) {
	for (size_t pos {}; (pos = str.find(toFind, pos)) != std::string::npos; pos += 2)
		str.insert(pos, 1, toIns);

	return str;
}