99 lines
2.8 KiB
C++
99 lines
2.8 KiB
C++
/*
|
|
* Copyright 2007 Haiku, Inc. All rights reserved.
|
|
* Distributed under the terms of the MIT License.
|
|
*
|
|
* Authors:
|
|
* Ramshankar, v.ramshankar@gmail.com
|
|
*/
|
|
#ifndef _COMMAND_PIPE_H
|
|
#define _COMMAND_PIPE_H
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <List.h>
|
|
#include <OS.h>
|
|
|
|
|
|
class BMessage;
|
|
class BMessenger;
|
|
class BString;
|
|
|
|
namespace BPrivate {
|
|
|
|
class BCommandPipe {
|
|
public:
|
|
BCommandPipe();
|
|
virtual ~BCommandPipe();
|
|
|
|
status_t AddArg(const char* argv);
|
|
void PrintToStream() const;
|
|
|
|
// FlushArgs() deletes the commands while Close() explicity closes all
|
|
// pending pipe-ends
|
|
// Note: Internally FlushArgs() calls Close()
|
|
void FlushArgs();
|
|
void Close();
|
|
|
|
// You MUST NOT free/delete the strings in the array, but you MUST free
|
|
// just the array itself.
|
|
const char** Argv(int32& _argc) const;
|
|
|
|
// If you use these, you must explicitly call "close" for the parameters
|
|
// (stdOut/stdErr) when you are done with them!
|
|
thread_id Pipe(int* stdOut, int* stdErr) const;
|
|
thread_id Pipe(int* stdOut) const;
|
|
thread_id PipeAll(int* stdOutAndErr) const;
|
|
|
|
// If you use these, you need NOT call "fclose" for the parameters
|
|
// (out/err) when you are done with them, also you need not do any
|
|
// allocation for these FILE* pointers, just use FILE* out = NULL
|
|
// and pass &out and so on...
|
|
thread_id PipeInto(FILE** _out, FILE** _err);
|
|
thread_id PipeInto(FILE** _outAndErr);
|
|
|
|
// Run() is a synchronous call, and waits till the command has finished
|
|
// executing RunAsync() is an asynchronous call that returns immediately
|
|
// after launching the command Neither of these bother about redirecting
|
|
// pipes for you to use
|
|
void Run();
|
|
void RunAsync();
|
|
|
|
// Reading the Pipe output
|
|
|
|
class LineReader {
|
|
public:
|
|
virtual ~LineReader() {}
|
|
virtual bool IsCanceled() = 0;
|
|
virtual status_t ReadLine(const BString& line) = 0;
|
|
// TODO: Add a Timeout() method.
|
|
};
|
|
|
|
// This function reads line-by-line from "file". It calls IsCanceled()
|
|
// on the passed LineReader instance for each byte read from file
|
|
// (currently). And it calls ReadLine() for each complete line.
|
|
status_t ReadLines(FILE* file, LineReader* lineReader);
|
|
// This method can be used to read the entire file into a BString.
|
|
BString ReadLines(FILE* file);
|
|
|
|
// Stardard append operators, if you use pointers to a BCommandPipe,
|
|
// you must use *pipe << "command"; and not pipe << "command" (as it
|
|
// will not compile that way)
|
|
BCommandPipe& operator<<(const char* arg);
|
|
BCommandPipe& operator<<(const BString& arg);
|
|
BCommandPipe& operator<<(const BCommandPipe& arg);
|
|
|
|
protected:
|
|
BList fArgList;
|
|
int fStdOut[2];
|
|
int fStdErr[2];
|
|
bool fStdOutOpen;
|
|
bool fStdErrOpen;
|
|
};
|
|
|
|
} // namespace BPrivate
|
|
|
|
using BPrivate::BCommandPipe;
|
|
|
|
#endif // _COMMAND_PIPE_H
|