ccmsgque

The C++ Application-Server Project

SYNOPSIS

#include "ccmsgque.h"
using namespace ccmsgque;

INDEX

OBJECT CREATION AND DELETION
OBJECT CONFIGURATION
LINK CREATION AND DELETION
ADDING SERVICES
SEND DATA
READ DATA
SLAVE OBJECT
BUFFER OBJECT
EXCEPTION OBJECT

The msgque project is an infrastructure to link software together to act like a single software. To link mean distributing work from one software to an other software an wait or not wait for an answer. The linking is done using unix or inet domain sockets and is based on packages send from one software to an other software and back. The msgque project is used to handle all the different aspects for setup and maintain the link and is responsible for:

starting and stopping the server application
starting and stopping the communication interface
sending and receiving package data
reading and writing data from or into a package
setup and maintain the event-handling for an asynchronous transfer
propagate the error messages from the server to the client

OBJECT CREATION AND DELETION

MqC*

The object is the user visible part of a ccmsgque application link.

ctx = new MqC()

Create an object ready to be used with ctx.LinkCreate(struct MqBufferLS * args) to setup an application link. Use the isConnected to check if a link is already available.

class MyClass : public MqC ... { ... }
int main (int argc, MQ_CST argv[]) {
  MyClass ctx; ...
}

delete(ctx)

Delete the entire object including the application link using ctx.LinkDelete(). The object can not be reused.

OBJECT CONFIGURATION

The configuration of an object is done using the functions starting with MqConfig... or by using command-line arguments.

static: struct MqBufferLS * init = MqInitCreate()

Initialize the process startup argument prefix. The startup-prefix have to be the name of the executable found in the PATH and additional arguments like a script name or required startup options. The startup-prefix is used for two different purpose:

To start a new entity using the --spawn command-line option
To replace the SELF argument after the "@" command-line argument

The startup-prefix is initially set by ccmsgque during package loading.

struct MqBufferLS * init = MqInitCreate();
MqBufferLAppendC(init, "myExecutable");
MqBufferLAppendC(init, "myFirstArgument");

Attention:: the memory is owned by ccmsgque -> do not free the memory

command-line: --buffersize

type: MQ_INT, get: ConfigGetBuffersize , set: ConfigSetBuffersize

The send and receive buffersize in bytes (default: 4KB)

command-line: --debug

type: MQ_INT, get: ConfigGetDebug , set: ConfigSetDebug

Debug a message-queue application. Valid values are 0 <= NUM <= 9 using 0 for "no debugging" and 9 for "maximum debugging". (default: 0)

command-line: --timeout

type: MQ_TIME_T, get: ConfigGetTimeout , set: ConfigSetTimeout

User defined timeout used for connection setup and data sending (default: 90 seconds)

command-line: --name

type: MQ_CST, get: ConfigGetName , set: ConfigSetName

Use STRING as basename of the new message-queue object. The name shows up in the debugging output and is used as prefix for the new created command. (default: the name of the executable)

command-line: --srvname

type: MQ_CST, get: ConfigGetSrvName , set: ConfigSetSrvName

Use STRING as a client specific prefix in the server debugging output. This is used to link debugging and error messages on the server to a specific client connection. (default: empty)

command-line: --silent

type: bool, get: ConfigGetIsSilent , set: ConfigSetIsSilent

Write (MQ_NO) or don't write (MQ_YES) any output to stdout or stderr. (default: write to stdout or stderr)

command-line: --string

type: bool, get: ConfigGetIsString , set: ConfigSetIsString

Use (MQ_YES), as much as possible, strings in the data-package. Convert any native data-type, like integer or double, into a string (sending) and back to native (receiving). (default: use binary)

command-line: --thread --spawn --fork

type: enum MqStartE, get: ConfigGetStartAs , set: ConfigSetStartAs (startAs)

Start a new server as thread or spawn a new process or fork a new process. This arguments are used with:

a server-context to start a new instance after a client connection request
on a server to create a worker with: ctx.SlaveWorker(const int id, struct MqBufferLS * args = NULL)
on a client/server together with the "SELF" command-line argument: ctx.LinkCreate(struct MqBufferLS * args)

Parameters:

[in] startAs 0=default, 1=fork, 2=thread and 3=spawn

command-line: --daemon

type: MQ_CST, get: NO , set: ConfigSetDaemon (pidfile)

Close all default IO (e.g stdout, stdin, stderr) and fork the server into the background. (default: no daemon)

Attention:: this option require the fork system-call and is not compatible with threads.

Parameters:

[in] pidfile the name of the file to write the PID into

command-line: --tcp --host --port --myhost --myport

type: MQ_CST, get: ConfigGetIoTcpHost/Port/MyHost/MyPort , set: ConfigSetIoTcp (host, port, myhost, myport)

Configure a tcp socket link.

Parameters:

	host	client: name of the remote host (default: localhost) server: name of the local interface (default: listen on all interfaces)
	port	client: name of the remote port server: name of the local port
	myhost	client: name of the local interface
	myport	client: name of the local port

Attention:: named ports are supported as well

command-line: --uds --file

type: MQ_CST, get: ConfigGetIoUdsFile , set: ConfigSetIoUds (file)

Use a uds (http://en.wikipedia.org/wiki/Unix_domain_socket) socket link. The uds communication is usually 50% faster than a local tcp communication but only available on UNIX.

Parameters:

[in] file the name of the uds file

command-line: --pipe --socket

type: MQ_SOCK, get: ConfigGetIoPipeSocket , set: ConfigSetIoPipe (socket)

Start a pipe server to listen on socket. This is the default mode to start a server. The socket option is special because it is used for internal purpose to submit the socket from the client to the server started as pipe by the client.

Parameters:

[in] socket the file-descriptor number. The only public usage for this option is to serve as interface for an existing tool like (x)inetd. The (x)inetd tool is a UNIX service to listen on a tcp/ip port and start for every connection the proper entry from the file /etc/(x)inetd.conf with the file-descriptor 0 as send/recv socket handle.

master

type: MqC, get: ConfigGetMaster , set: SLAVE OBJECT

return the master if ctx is a slave-context or NULL if ctx is not a slave-context. !Only a SLAVE has a master!

ctxId

type: MQ_SIZE, get: ConfigGetCtxId , set: NO

return an identifier as integer and is unique per parent-context. The parent-context is always 0 and every new child-context get a new identifier by adding 1.

token

type: MQ_CST, get: ConfigGetToken , set: NO

return the current TOKEN IDENTIFIER and is only useful in a service callback. This command is needed on the server to implement a generic service (A ctx.ServiceCreate(MQ_CST const token, IService * const service) with different TOKEN IDENTIFIER but with the same service callback).

isConnected

type: bool, get: ConfigGetIsConnected , set: NO

Is the ccmsgque context connected ? A context is connected if the ctx.LinkCreate(struct MqBufferLS * args) command was successful and a context is NOT connected if a) the object has just been created or b) the link was deleted with ctx.LinkDelete()

isServer

type: bool, get: ConfigGetIsServer , set: IServerSetup or IServerCleanup

True if object is a server object (default: MQ_NO, be a client)

isParent

type: bool, get: ConfigGetIsParent , set: NO

True if object is a parent object (default: MQ_YES, be a parent)

isSlave

type: bool, get: ConfigGetIsSlave , set: NO

True if object is a slave object (default: MQ_NO, not be a slave)

IServerSetup

type: Interface, get: NO , set: ccmsgque::IServerSetup

Interface to define a server ccmsgque object. This Interface define the ServerSetup callback called at ctx.LinkCreate(struct MqBufferLS * args) to define the services or to initialize context specific variables. This interface set the isServer configuration value to MQ_YES.

IServerCleanup

type: Interface, get: NO , set: ccmsgque::IServerCleanup

Interface to define a server ccmsgque object. This Interface define the ServerCleanup callback called at ctx.LinkDelete() to free context specific variables. This interface set the isServer configuration value to MQ_YES.

IFilterFTR

type: Interface, get: NO , set: ccmsgque::IFilterFTR

Interface required to define a filter data stream object. This Interface define the IFilterFTR callback. The callback is used to act on filter data rows. Every filter input data is a list of filter data rows and every row is a list of filter data columns. Every row is send from one filter-command to the following filter-command as FTR service request. This interface set the isServer configuration value to MQ_YES. (read more at: FILTER MODE)

IFilterEOF

type: Interface, get: NO , set: ccmsgque::IFilterEOF

Interface required to define a filter data stream object. This Interface define the IFilterEOF callback. The callback is used to act on End-Of-Filter data and is called after all IFilterFTR data was send. Sometimes the filter data can not be served as IFilterFTR data (example: sorting of the input rows need to read all rows before the data can be send to the next filter command) and the IFilterEOF callback is used to continue send IFilterFTR data rows. This interface set the isServer configuration value to MQ_YES. (read more at: FILTER MODE)

IFactory

type: Interface, get: NO , set: ccmsgque::IFactory

The factory pattern is used to create a new application object (read more at: MqSetupS::Factory) Without the Factory pattern only the initial startup context is available to serve incoming requests. In general every server need to provide a Factory pattern.

class Server: public MqC, public IFactory, ... {
  private:
    MqC* Factory() const { return new Server(); }
  ...
}

IBgError

type: Interface, get: NO , set: ccmsgque::IBgError

Define an asyncrone error handler. This handler is used for handle errors send with ctx.SendERROR(). Use int ex.num() or ctx.ErrorGetNum() and string ex.what() or ctx.ErrorGetText() to access the error.

LINK CREATION AND DELETION

To create and to destroy a link is the main purpose of the ccmsgque library. A link is a client/server connection used to perform various tasks.

ctx.LinkCreate(struct MqBufferLS * args)

ctx.LinkCreateVA(va_list args)

ctx.LinkCreateV(MQ_CST ..., NULL)

ctx.LinkCreateVT(const std::vector<MQ_CST>& args)

ctx.LinkCreateVC(int const argc, MQ_CST *args)

Create a parent-context using the OBJECT CONFIGURATION. A parent-context is responsible to setup the client/server link:

the client-parent-context create the server-parent-context
the server-parent-context wait for a client-parent-context connection request

Parameters:

`[in]`	ctx	the object from OBJECT CREATION AND DELETION
`[in]`	args	command-line arguments including the "@" item for the --pipe setup

Attention:: if the first argument after the "@" item is the string "SELF" an independent server of the current server is started. This is not a SLAVE OBJECT. The "SELF" argument is replaced by an application default setting (if available) or by arguments set with static: struct MqBufferLS * init = MqInitCreate().

ctx.LinkCreateChild(const MqC& parent, struct MqBufferLS * args)

ctx.LinkCreateChildVA(const MqC& parent, va_list args)

ctx.LinkCreateChildV(const MqC& parent, MQ_CST ..., NULL)

ctx.LinkCreateChildVT(const MqC& parent, const std::vector<MQ_CST>& args)

ctx.LinkCreateChildVS(const MqC& parent, int const argc, MQ_CST *args)

Create a child-context from a ccmsgque parent-context and command-line arguments. A child is using the same process or thread as the parent but a different namespace. With a different namespace a child is able to act on different services on the shared server.

Parameters:

`[in]`	ctx	the object from OBJECT CREATION AND DELETION
`[in]`	parent	the parent object
`[in]`	args	all command-line arguments including the "@" token

ctx.LinkDelete()

Close the client/server link and delete the underlying communication object. All depending objects will be deleted as well like depending child-context and slave-context local and on the remote site of the link.

ctx.Exit()

Shutdown the entire communication and exit the current process or thread.

ADDING SERVICES

To provide a service is the main purpose of a server. The ctx.ServiceCreate(MQ_CST const token, IService * const service) method is usually added in the ServerSetup method of the IServerSetup.

public void ServerSetup() {
  ServiceCreate ("SRV1", CallbackF(&MyServer::SRV1));
}

TOKEN IDENTIFIER

The token is a 4 byte string and identifies the service. The token is used in:

SERVICE CALLBACK

A service is using a callback to act on an incoming service request. The callback is used on a server using ctx.ServiceCreate(MQ_CST const token, IService * const service) or on a client using ctx.SendEND_AND_CALLBACK(MQ_CST const token, IService * const callback).

The callback is implemented using Interface: IService method Service(MqS ctx) or using t type void CallbackF().

ctx.ServiceCreate(MQ_CST const token, IService * const service)

ctx.ServiceCreate(MQ_CST const token, CallbackF const service)

Create a new service listen on TOKEN IDENTIFIER and start for every incoming request a service. (on error return an EXCEPTION OBJECT)

ctx.ServiceDelete(MQ_CST const token)

Delete a new service listen on TOKEN IDENTIFIER . (on error return an EXCEPTION OBJECT)

ctx.ProcessEvent([int timeout], [MQ_WAIT_(NO|ONCE|FOREVER)])

Start the Event-Loop and check for the next event. In client mode this command is usually used together with ctx.SendEND_AND_CALLBACK(MQ_CST const token, IService * const callback) to process the results.

Parameters:

`[in]`	timeout	don't wait more than TIMEOUT seconds to get an answer from the server. If no answer is available an error is raised. (default: command-line: --timeout)
`[in]`	MqC.WAIT	use flag value to define the action (default: NO) NO, don't wait for an event do just the check ONCE, use timeout seconds to wait for exact one event FOREVER, wait forever and only come back on error or on exit

SEND DATA

The Send style methods are used to build and send data using the ccmsgque send data package. The data is typed using the TYPE IDENTIFIER and the methods can wait or not for an answer. During waiting the the application is still able to work on events like other ccmsgque client/server links.

ctx.SendSTART();
ctx.SendI(num);
ctx.SendL_START();
 ctx.SendD(balance);
 ctx.SendC("name of the owner");
 ctx.SendB(signature);
ctx.SendL_END();
ctx.SendEND_AND_WAIT("SRV1")

ctx.SendSTART()

Initialize a ccmsgque send data package. This method is required.

ctx.SendEND(MQ_CST const token)

Send the package using TOKEN IDENTIFIER without expecting an answer (FireAndForget). (on error return an EXCEPTION OBJECT)

Attention:: if an error is raised on the server during service-processing the error is send back as asynchronous event and can be raised sometime in the future. To be sure to get the error immediately use ctx.SendEND_AND_WAIT(MQ_CST const token, MQ_TIME_T timeout=MQ_TIMEOUT_USER)

ctx.SendEND_AND_WAIT(MQ_CST const token, MQ_TIME_T timeout=MQ_TIMEOUT_USER)

Send the package using TOKEN IDENTIFIER and wait timeout seconds for an answer. (on error return an EXCEPTION OBJECT)

ctx.SendEND_AND_CALLBACK(MQ_CST const token, IService * const callback)

ctx.SendEND_AND_CALLBACK(MQ_CST const token, CallbackF const callback)

Send the package using TOKEN IDENTIFIER and don't wait for an answer. The answer will be handled by the SERVICE CALLBACK. (on error return an EXCEPTION OBJECT)

ctx.SendRETURN()

Answer an incoming service-call started with ctx.SendEND_AND_WAIT(MQ_CST const token, MQ_TIME_T timeout=MQ_TIMEOUT_USER) or ctx.SendEND_AND_CALLBACK(MQ_CST const token, IService * const callback). The return package is build-up like the previous service call package but with a ctx.SendRETURN() as final command. (on error return an EXCEPTION OBJECT)

ctx.SendERROR()

Send an asyncrone error to the link target. (on error return an EXCEPTION OBJECT)

ctx.SendFTR(MQ_TIME_T timeout=MQ_TIMEOUT_USER)

Send a filter stream data package using FILTER MODE. (on error return an EXCEPTION OBJECT)

ctx.SendEOF(MQ_TIME_T timeout=MQ_TIMEOUT_USER)

Send a filter end-of-file data package using FILTER MODE. (on error return an EXCEPTION OBJECT)

ctx.Send[TYPE](TYPE value)

Add an item using TYPE IDENTIFIER to the ccmsgque send data package. (example: SendY)

ctx.SendL_START()

Start to send an embedded list item.

ctx.SendL_END()

Finish to send an embedded list item.

READ DATA

Read data from an incoming ccmsgque read data package:

on a server to serve an incoming service-call from the client
on a client to process the return-data from a previous service-call

Reading data is a passive task in opposite to sending data which is an active task. Passive mean that the read is triggered by an incoming data-package and not by the software-workflow.

num = ctx.ReadI();
ctx.ReadL_START();
 balance = ctx.ReadD();
 owner = ctx.ReadC();
 signature = ctx.ReadB();
ctx.ReadL_END();

TYPE ctx.Read[TYPE]()

return an item using the TYPE IDENTIFIER from the ccmsgque read data package. (on error return an EXCEPTION OBJECT)

MqBufferS ctx.ReadU()

return a temporary BUFFER OBJECT. (on error return an EXCEPTION OBJECT)

Attention:: The object is only valid until a new ccmsgque read data package has arrived.

ctx.ReadProxy(MqC otherCtx)

Link two ccmsgque objects to direct pass a data item from one object to the other. (on error return an EXCEPTION OBJECT)

int ctx.ReadGetNumItems()

return the number of items left in the ccmsgque read data package.

bool ctx.ReadItemExists()

Check if are still items in the ccmsgque read data package.

ctx.ReadUndo()

Undo the last read operation. This is useful if an error was raised or if a buffer object (returned from MqBufferS ctx.ReadU()) has not the expected type. (on error return an EXCEPTION OBJECT)

ctx.ReadL_START(MQ_BUF buffer=NULL)

ctx.ReadL_START(const MqBufferC& buffer)

ctx.ReadL_START(MqBufferC * const buffer)

Start to read an embedded list item. Use the current read package (buffer = NULL) or a buffer object. (on error return an EXCEPTION OBJECT)

ctx.ReadL_END()

Finish to read an embedded list item.

SLAVE OBJECT

The master/slave link is used to create a mesh of nodes by linking different PARENT context objects together. The master control the slave.
The link is used to perform the following tasks:

report error messages from the slave to the master
to create a slave-child-context if a master-child-context is created
to delete a slave-context if a master-context is deleted

In difference to the client/server link the master/slave link connect two independent msgque-context in the same process or thread (e.g. node). This leads to the restriction that only the master-msgque-context can be a server because only one server per node is possible.

ctx.SlaveWorker(const int id, struct MqBufferLS * args = NULL)

ctx.SlaveWorkerVA(const int id, va_list args)

ctx.SlaveWorkerV(const int id, MQ_CST ... , NULL)

ctx.SlaveWorkerVT(const int id, vector<MQ_CST>& args)

ctx.SlaveWorkerVC(const int id, int const argc, MQ_CST args[])

Create a worker as slave of the ctx object using the image of the ctx object self and started as an independent process or thread based on the command-line: --thread --spawn --fork argument.

Parameters:

`[in]`	ctx	the master ccmsgque object as SERVER-PARENT without a CHILD
`[in]`	id	an integer used as unique identifer for the master/slave link
`[in]`	args	command-line arguments passed to the worker-client or the worker-server. all arguments prior the first @ token are added to the worker-client and the other arguments to the worker-server.

example create a worker with id 7 as thread.

ctx.SlaveWorkerV (7, "--thread", "--silent", "@", "WORKER", "--name", "MyWorker", NULL);

ctx.SlaveCreate(const int id, MqC *const slave)

Create a master/slave link between the ctx object and the slave object. (on error return an EXCEPTION OBJECT)

Parameters:

`[in]`	ctx	the master ccmsgque object as PARENT without a CHILD
`[in]`	id	an integer used as unique identifer for the master/slave link
`[in]`	slave	the slave ccmsgque object as CLIENT-PARENT without a CHILD

ctx.SlaveDelete(const int id)

Delete a slave-context from a former ctx.SlaveCreate(const int id, MqC *const slave) command using the same identifier id. By default the slave-context object will be deleted if the master-context is deleted. In addition only the parent-slave-context can be deleted explicit. If id is invalid nothing will happen. (on error return an EXCEPTION OBJECT)

MqC ctx.SlaveGet(const int id)

return the slave-context from the ctx.SlaveCreate(const int id, MqC *const slave) using the same identifier id or NULL if the id is not valid or if ctx is not a master.

BUFFER OBJECT

The class MqBufferC object is created by MqBufferS ctx.ReadU() and id used to save a typeless temporary data item from the ccmsgque data package. The lifetime of the class MqBufferC is only the current callback up to the next read operation of the same context.

ccmsgque support 2 different buffer objects:

the libmsgque original buffer called MQ_BUF or MqBufferS
a ccmsgque wrapper called MqBufferC

Both objects are linked:

MqBufferC buf = ctx.ReadU();
MQ_BUF buf2 = buf.GetU();

1. Example:

MqBufferC buf = ctx.ReadU();
if (buf.GetType() == MQ_STRT)
  printf(buf.GetC());

2. Example:

MQ_BUF buf = ctx.ReadU();
if (buf->type == MQ_STRT)
  printf(buf->cur.C);

TYPE IDENTIFIER

A ccmsgque buffer data package is type safe, this mean that every item has a type prefix and every TYPE ctx.Read[TYPE]() or TYPE val=buffer.Get[TYPE]( have to match the previous ctx.Send[TYPE](TYPE value) with the same TYPE. One exception, the cast from and to string (TYPE=C) is allowed. The following type identifier's are available:

Y : 1 byte signed character
O : 1 byte boolean character using MQ_YES for yes or true or MQ_NO for no or wrong
S : 2 byte signed short
I : 4 byte signed integer
W : 8 byte signed long long integer
F : 4 byte float
D : 8 byte double
B : unsigned char array used for binary data
C : string data using a \0 at the end
L : list type able to hold a list of all items from above
U : typeless buffer able to hold a single item from above

TYPE val=buffer.Get[TYPE](

return the data form the buffer using the TYPE IDENTIFIER. (on error return an EXCEPTION OBJECT)

enum MqTypeE buffer.GetType()

return the type as single character of the item stored in the buffer object.

EXCEPTION OBJECT

The exception object is used to transport a ccmsgque error using the class MqCException ex.

try {
 i = ctx.ReadI();
} catch (const exception& ex) {
 ctx.ErrorSet(ex);
 cout << ctx.ErrorGetText() << endl;
 ctx.ErrorReset();
}

string ex.what() or ctx.ErrorGetText()

return the error message from the error object.

int ex.num() or ctx.ErrorGetNum()

return the error number from the error object. The number can be used as exit-code.

ctx.ErrorC(string prefix, int num, string what)

create a ccmsgque error object but do not raise the EXCEPTION OBJECT

ctx.ErrorSet(const exception& ex)

convert a class MqCException ex into a ccmsgque conform error using the ctx object. This method is used to enable additional error processing capabilities from ctx.LinkDelete() or ctx.Exit() after the exception was caught and before the application exit or the object is deleted.

    command1 | command2 | command3

A command pipeline with ccmsgque queues is using the special token @ to link the commands together:

    msgcmd1 @ msgcmd2 @ msgcmd3

To create a ccmsgque filter use:

IFilterFTR
IFilterEOF

and to send data to the next filter command use:

#include "ccmsgque.h"

using namespace ccmsgque;

class mulserver : public MqC, public IServerSetup, public IFactory {
  private:
    void MMUL () {
      SendSTART();
      SendD(ReadD() * ReadD());
      SendRETURN();
    }
    MqC* Factory() const {return new mulserver();}
    void ServerSetup () {
      ServiceCreate("MMUL", CallbackF(&mulserver::MMUL));
    }
};

int MQ_CDECL main (int argc, MQ_CST argv[])
{
  mulserver ctx;
  try {
    ctx.ConfigSetName ("MyMulServer");
    ctx.LinkCreateVC (argc, argv);
    ctx.ProcessEvent ();
  } catch (const exception& e) {
    ctx.ErrorSet(e);
  }
  ctx.Exit ();
}

Start mulserver.cc using TCP port 7777 and create a thread for every incoming connection

> mulserver --tcp --port 7777 --thread

2. in a client call the service from 1.

#include <iostream>
#include "ccmsgque.h"

using namespace std;
using namespace ccmsgque;

int MQ_CDECL main (int argc, MQ_CST argv[])
{
  MqC ctx;
  try {
    ctx.ConfigSetName ("MyMulClient");
    ctx.LinkCreateVC (argc, argv);
    ctx.SendSTART();
    ctx.SendD(3.67);
    ctx.SendD(22.3);
    ctx.SendEND_AND_WAIT("MMUL", 5);
    cout << ctx.ReadD() << endl;
  } catch (const exception& e) {
    ctx.ErrorSet(e);
  }
  ctx.Exit();
}

Use mulclient.cc to connect to mulserver.cc using TCP port 7777:

> mulclient --tcp --port 7777

3. create a filter to wrap every column in a '<>' pair

#include "ccmsgque.h"

using namespace std;
using namespace ccmsgque;

class manfilter : public MqC, public IFilterFTR {
  public:
    void fFTR () {
      MQ_BUF temp = GetTempBuffer();
      SendSTART();
      while (ReadItemExists()) {
        SendU(MqBufferSetV(temp, "<%s>", ReadC()));
      }
      SendFTR();
    }
};

int MQ_CDECL main (int argc, MQ_CST argv[])
{
  manfilter filter;
  try {
    filter.ConfigSetName ("manfilter");
    filter.LinkCreateVC(argc, argv);
    filter.ProcessEvent ();
  } catch (const exception& e) {
    filter.ErrorSet(e);
  }
  filter.Exit();
}

Use manfilter.cc in a LibMsgque command pipeline:

> echo -e "1:2:3\na:b:c" | atool split -d : @ manfilter @ atool join -d :

KEYWORDS

C++, unix, socket, message, msgque