C++ splice函数代码示例

static void splice_test(void)
{
	int pipes[2];
	int ret;

	fd_in = SAFE_OPEN(cleanup, TESTFILE1, O_RDONLY);
	SAFE_PIPE(cleanup, pipes);
	fd_out = SAFE_OPEN(cleanup, TESTFILE2, O_WRONLY | O_CREAT | O_TRUNC, 0666);

	ret = splice(fd_in, NULL, pipes[1], NULL, TEST_BLOCK_SIZE, 0);
	if (ret < 0)
		tst_brkm(TBROK | TERRNO, cleanup, "splice(fd_in, pipe) failed");

	ret = splice(pipes[0], NULL, fd_out, NULL, TEST_BLOCK_SIZE, 0);
	if (ret < 0)
		tst_brkm(TBROK | TERRNO, cleanup, "splice(pipe, fd_out) failed");

	close(fd_in);
	close(fd_out);
	close(pipes[0]);
	close(pipes[1]);

	fd_out = 0;
	fd_in = 0;

	check_file();
}

void Subdivision::deleteEdge(Edge *e)
{
    splice(e, e->Oprev());
    splice(e->Sym(), e->Sym()->Oprev());

    delete e;
}

/* 
 * Requires:
 *   "bp" is the address of a free block that is at least "asize" bytes.
 *
 * Effects:
 *   Place a block of "asize" bytes at the start of the free block "bp" and
 *   split that block if the remainder would be at least the minimum block
 *   size. 
 */
static void
place(void *bp, size_t asize)
{
	size_t csize = GET_SIZE(HDRP(bp));
	struct node *nodep = (struct node *) bp;
	struct node *new_nodep;

	/* increased size to account for next and previous pointer overhead */
	if ((csize - asize) >= (ASIZE + QSIZE)) { 
		PUT(HDRP(bp), PACK(asize, 1));
		PUT(FTRP(bp), PACK(asize, 1));
		
		bp = NEXT_BLKP(bp);
		PUT(HDRP(bp), PACK(csize - asize, 0));
		PUT(FTRP(bp), PACK(csize - asize, 0));
		
		/* Set new node for the leftover free block */
		new_nodep = (struct node *)bp;
		
		new_nodep->previous = nodep->previous;
		new_nodep->next = nodep->next;
				
		/* Remove node from allocated block */
		splice(nodep);
		
	} else {
		PUT(HDRP(bp), PACK(csize, 1));
		PUT(FTRP(bp), PACK(csize, 1));
		
		/* Remove node from allocated block */
		splice(nodep);
	}
	checkheap(1);
}

// There is no scenario requiring a public key, we support it for completeness.
bool create_key_pair(encrypted_private& out_private,
    encrypted_public& out_public, ec_compressed& out_point,
    const encrypted_token& token, const ek_seed& seed, uint8_t version,
    bool compressed)
{
    const parse_encrypted_token parse(token);
    if (!parse.valid())
        return false;

    const auto point = splice(parse.sign(), parse.data());
    auto point_copy = point;
    const auto factor = bitcoin_hash(seed);
    if (!ec_multiply(point_copy, factor))
        return false;

    ek_salt salt;
    if (!address_salt(salt, point_copy, version, compressed))
        return false;

    const auto salt_entropy = splice(salt, parse.entropy());
    const auto derived = split(scrypt_pair(point, salt_entropy));
    const auto flags = set_flags(compressed, parse.lot_sequence(), true);

    if (!create_public_key(out_public, flags, salt, parse.entropy(),
        derived.left, derived.right, factor, version))
        return false;

    create_private_key(out_private, flags, salt, parse.entropy(), derived.left,
        derived.right, seed, version);

    out_point = point_copy;
    return true;
}

// 查找模块的名称
void find_module(char* scan_mode,char* find_modules)
{
	DIR *dirp;

	int find_status = 0;

	char* this_path;
	// 路径尾部组合
	char* path_last = splice("plugins/",splice(scan_mode,"/"));
	// 全路径
	char* path_obj = splice(defpath(),path_last);

	dirp = opendir(path_obj);

	if(dirp != NULL)
	{
		while(1)
		{
			direntp = readdir(dirp);

			if(direntp == NULL){
				break;
			}else if(direntp->d_name[0] != '.'){
				if (strcmp(direntp->d_name,find_modules) == 0){
					printf("[*] Find modules Path: %s ,Plugin: %s \n",path[path_index],direntp->d_name);
					find_status = find_status + 1;
				}
			}
		}
		if (find_status < 1){
			printf("[*] Can't not found this module.\n");
		}
		closedir(dirp);
	}
}

int main(int argc, char *argv[])
{
    if(argc != 2) {
        printf("Usage: %s <file>\n", basename(argv[0]));
        exit(EXIT_FAILURE);
    }
    int filefd = open(argv[1], O_CREAT | O_WRONLY | O_TRUNC, 0666);
    if(filefd == -1)
        ERR_EXIT("open");
    int pipefd_stdout[2];
    int ret = pipe(pipefd_stdout);
    if(ret == -1)
        ERR_EXIT("pipe");
    int pipefd_file[2];
    ret = pipe(pipefd_file);
    if(ret == -1)
        ERR_EXIT("pipe");

    if(splice(STDIN_FILENO, NULL, pipefd_stdout[1], NULL, 32768, SPLICE_F_MORE | SPLICE_F_MOVE) == -1)
        ERR_EXIT("splice");
    if(tee(pipefd_stdout[0], pipefd_file[1], 32768, SPLICE_F_NONBLOCK) == -1)
        ERR_EXIT("tee");
    if(splice(pipefd_file[0], NULL, filefd, NULL, 32768, SPLICE_F_MORE | SPLICE_F_MOVE) == -1)
        ERR_EXIT("splice");
    if(splice(pipefd_stdout[0], NULL, STDOUT_FILENO, NULL, 32768, SPLICE_F_MORE | SPLICE_F_MOVE) == -1)
        ERR_EXIT("splice");
    close(filefd);
    close(pipefd_stdout[0]);
    close(pipefd_stdout[1]);
    close(pipefd_file[0]);
    close(pipefd_file[1]);
    exit(EXIT_SUCCESS);
}

void List<Type>::merge(List &list, Predicate predicate)
{
    Iterator iter1 = begin();
    Iterator iter2 = list.begin();

    Iterator last1 = end();
    Iterator last2 = list.end();

    while (iter1 != last1 && iter2 != last2)
    {
        // check whether [predicate] is true
        if (predicate(*iter1, *iter2))
        {
            ++iter1;
        }
        else
        {
            // move element at location [iter2] to this list before [iter1]
            Iterator position = iter2++;
            splice(iter1, list, position, iter2);
        }
    }

    splice(last1, list, iter2, last2);
}

void terminalImpl::createSplicedTerminals() {
	unsigned int lI = 0;
	unsigned int hI = 0;
	bool joinable;
	for (unsigned int index = 0; index < highestIndex - lowestIndex; ++index) {
		bitTerminal& t0 = bitTerminals.at(lowestIndex + index);
		bitTerminal& t1 = bitTerminals.at(lowestIndex + index + 1);
		if (t0.isConst && t1.isConst)
			joinable = true;
		else if (t0.isConst || t1.isConst)
			joinable = false;
		else {
			joinable = true;
			std::unordered_set<bitTerminal*> lowerBitTerminal;
			for (auto&& cBT : t1.connectedBitNet->connectedBitTerminals) {
				int lesserIndex = cBT->index;
				lesserIndex--;
				if (lesserIndex < 0) {
					joinable = false;
					break;
				} else
					lowerBitTerminal.insert(&cBT->baseTerminal->bitTerminals.at(lesserIndex));
			}
			joinable &= (t0.connectedBitNet->connectedBitTerminals == lowerBitTerminal);
		}

		if (joinable)
			hI++;
		else {
			splice(lowestIndex + hI, lowestIndex + lI);
			lI = ++hI;
		}
	}
	splice(lowestIndex + hI, lowestIndex + lI);
}

// 输出所有插件列表
void str_list(void)
{
	DIR *dirp;

	printf("[*] Loading Plugin List ...\n");

	for (path_index = 0; path_index < 4; path_index++)
	{
		char* this_path;
		// 路径尾部组合
		char* path_last = splice("plugins/",splice(path[path_index],"/"));
		// 全路径
		char* path_obj = splice(defpath(),path_last);

		dirp = opendir(path_obj);

		if(dirp != NULL)
		{
			while(1)
			{
				direntp = readdir(dirp);

				if(direntp == NULL){
					break;
				}else if(direntp->d_name[0] != '.'){
					printf("[*] Path: %s ,Plugin: %s \n",path[path_index],direntp->d_name);
				}
			}
			closedir(dirp);
		}	
    }
}

EdgePointer CDelaunay::connectRight(EdgePointer a, EdgePointer b)
{
  EdgePointer ans;
  ans = makeEdge(dest(a), orig(b));
  splice(ans, (EdgePointer) sym(a));
  splice((EdgePointer) sym(ans), (EdgePointer) oprev(b));
  return(ans);
}

// connects the a.dst to b.org through a new edge
edge connect(edge a, edge b) {
    Edge_Record er = make_edge();
    er.get_qr().v = a.dst();
    er.sym().get_qr().v = b.org();
    splice(er, a.lnext());
    splice(er.sym(), b);
    return er;
}

/*
 *  stress_splice
 *	stress copying of /dev/zero to /dev/null
 */
int stress_splice(
	uint64_t *const counter,
	const uint32_t instance,
	const uint64_t max_ops,
	const char *name)
{
	int fd_in, fd_out, fds[2];

	if (!set_splice_bytes) {
		if (opt_flags & OPT_FLAGS_MAXIMIZE)
			opt_splice_bytes = MAX_SPLICE_BYTES;
		if (opt_flags & OPT_FLAGS_MINIMIZE)
			opt_splice_bytes = MIN_SPLICE_BYTES;
	}

	(void)instance;

	if (pipe(fds) < 0) {
		pr_failed_err(name, "pipe");
		return EXIT_FAILURE;
	}

	if ((fd_in = open("/dev/zero", O_RDONLY)) < 0) {
		(void)close(fds[0]);
		(void)close(fds[1]);
		pr_failed_err(name, "open");
		return EXIT_FAILURE;
	}
	if ((fd_out = open("/dev/null", O_WRONLY)) < 0) {
		(void)close(fd_in);
		(void)close(fds[0]);
		(void)close(fds[1]);
		pr_failed_err(name, "open");
		return EXIT_FAILURE;
	}

	do {
		int ret;

		ssize_t bytes;

		bytes = splice(fd_in, NULL, fds[1], NULL, opt_splice_bytes, SPLICE_F_MOVE);
		if (bytes < 0)
			break;

		ret = splice(fds[0], NULL, fd_out, NULL, opt_splice_bytes, SPLICE_F_MOVE);
		if (ret < 0)
			break;

		(*counter)++;
	} while (opt_do_run && (!max_ops || *counter < max_ops));
	(void)close(fd_out);
	(void)close(fd_in);
	(void)close(fds[0]);
	(void)close(fds[1]);

	return EXIT_SUCCESS;
}

QuadEdge *connect( QuadEdge *a, QuadEdge *b ) {
  QuadEdge *e = makeEdge();
  e->setOrg( a->Dest() );
  e->setDest( b->Org() );
  splice( e, a->Lnext() );
  splice( e->Sym(), b );

  return e;
}

void List<Type>::swap(List &list)
{
    List copy;

    // exchang the elements of this list with [list]
    splice(copy.begin(), list);
    splice(list.begin(), *this);
    splice(begin(), copy);
}

void deleteEdge( QuadEdge *e ) {
  splice( e, e->Oprev() );
  splice( e->Sym(), e->Sym()->Oprev() );

  delete e->Rotinv();
  delete e->Sym();
  delete e->Rot();
  delete e;
}