Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
A
Actor Framework
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Operations
Operations
Metrics
Environments
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
cpp-libs
Actor Framework
Commits
96e1e051
Commit
96e1e051
authored
Nov 12, 2011
by
neverlord
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
announce example 5
parent
e5fa9a1a
Changes
2
Show whitespace changes
Inline
Side-by-side
Showing
2 changed files
with
215 additions
and
210 deletions
+215
-210
examples/announce_example_5
examples/announce_example_5
+0
-210
examples/announce_example_5.cpp
examples/announce_example_5.cpp
+215
-0
No files found.
examples/announce_example_5
deleted
100755 → 0
View file @
e5fa9a1a
#! /bin/sh
# announce_example_5 - temporary wrapper script for .libs/announce_example_5
# Generated by libtool (GNU libtool) 2.4.2
#
# The announce_example_5 program cannot be directly executed until all the libtool
# libraries that it depends on are installed.
#
# This wrapper script should never be moved out of the build directory.
# If it is, it will not operate correctly.
# Sed substitution that helps us do robust quoting. It backslashifies
# metacharacters that are still active within double-quoted strings.
sed_quote_subst
=
's/\([`"$\\]\)/\\\1/g'
# Be Bourne compatible
if
test
-n
"
${
ZSH_VERSION
+set
}
"
&&
(
emulate sh
)
>
/dev/null 2>&1
;
then
emulate sh
NULLCMD
=
:
# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias
-g
'${1+"$@"}'
=
'"$@"'
setopt NO_GLOB_SUBST
else
case
`
(
set
-o
)
2>/dev/null
`
in
*
posix
*
)
set
-o
posix
;;
esac
fi
BIN_SH
=
xpg4
;
export
BIN_SH
# for Tru64
DUALCASE
=
1
;
export
DUALCASE
# for MKS sh
# The HP-UX ksh and POSIX shell print the target directory to stdout
# if CDPATH is set.
(
unset
CDPATH
)
>
/dev/null 2>&1
&&
unset
CDPATH
relink_command
=
""
# This environment variable determines our operation mode.
if
test
"
$libtool_install_magic
"
=
"%%%MAGIC variable%%%"
;
then
# install mode needs the following variables:
generated_by_libtool_version
=
'2.4.2'
notinst_deplibs
=
' /Users/neverlord/libcppa/.libs/libcppa.la'
else
# When we are sourced in execute mode, $file and $ECHO are already set.
if
test
"
$libtool_execute_magic
"
!=
"%%%MAGIC variable%%%"
;
then
file
=
"
$0
"
# A function that is used when there is no print builtin or printf.
func_fallback_echo
()
{
eval
'cat <<_LTECHO_EOF
$1
_LTECHO_EOF'
}
ECHO
=
"printf %s
\\
n"
fi
# Very basic option parsing. These options are (a) specific to
# the libtool wrapper, (b) are identical between the wrapper
# /script/ and the wrapper /executable/ which is used only on
# windows platforms, and (c) all begin with the string --lt-
# (application programs are unlikely to have options which match
# this pattern).
#
# There are only two supported options: --lt-debug and
# --lt-dump-script. There is, deliberately, no --lt-help.
#
# The first argument to this parsing function should be the
# script's ../libtool value, followed by no.
lt_option_debug
=
func_parse_lt_options
()
{
lt_script_arg0
=
$0
shift
for
lt_opt
do
case
"
$lt_opt
"
in
--lt-debug
)
lt_option_debug
=
1
;;
--lt-dump-script
)
lt_dump_D
=
`
$ECHO
"X
$lt_script_arg0
"
| /usr/bin/sed
-e
's/^X//'
-e
's%/[^/]*$%%'
`
test
"X
$lt_dump_D
"
=
"X
$lt_script_arg0
"
&&
lt_dump_D
=
.
lt_dump_F
=
`
$ECHO
"X
$lt_script_arg0
"
| /usr/bin/sed
-e
's/^X//'
-e
's%^.*/%%'
`
cat
"
$lt_dump_D
/
$lt_dump_F
"
exit
0
;;
--lt-
*
)
$ECHO
"Unrecognized --lt- option: '
$lt_opt
'"
1>&2
exit
1
;;
esac
done
# Print the debug banner immediately:
if
test
-n
"
$lt_option_debug
"
;
then
echo
"announce_example_5:announce_example_5:
${
LINENO
}
: libtool wrapper (GNU libtool) 2.4.2"
1>&2
fi
}
# Used when --lt-debug. Prints its arguments to stdout
# (redirection is the responsibility of the caller)
func_lt_dump_args
()
{
lt_dump_args_N
=
1
;
for
lt_arg
do
$ECHO
"announce_example_5:announce_example_5:
${
LINENO
}
: newargv[
$lt_dump_args_N
]:
$lt_arg
"
lt_dump_args_N
=
`
expr
$lt_dump_args_N
+ 1
`
done
}
# Core function for launching the target application
func_exec_program_core
()
{
if
test
-n
"
$lt_option_debug
"
;
then
$ECHO
"announce_example_5:announce_example_5:
${
LINENO
}
: newargv[0]:
$progdir
/
$program
"
1>&2
func_lt_dump_args
${
1
+
"
$@
"
}
1>&2
fi
exec
"
$progdir
/
$program
"
${
1
+
"
$@
"
}
$ECHO
"
$0
: cannot exec
$program
$*
"
1>&2
exit
1
}
# A function to encapsulate launching the target application
# Strips options in the --lt-* namespace from $@ and
# launches target application with the remaining arguments.
func_exec_program
()
{
case
"
$*
"
in
*
\
--lt-
*
)
for
lt_wr_arg
do
case
$lt_wr_arg
in
--lt-
*
)
;;
*
)
set
x
"
$@
"
"
$lt_wr_arg
"
;
shift
;;
esac
shift
done
;;
esac
func_exec_program_core
${
1
+
"
$@
"
}
}
# Parse options
func_parse_lt_options
"
$0
"
${
1
+
"
$@
"
}
# Find the directory that this script lives in.
thisdir
=
`
$ECHO
"
$file
"
| /usr/bin/sed
's%/[^/]*$%%'
`
test
"x
$thisdir
"
=
"x
$file
"
&&
thisdir
=
.
# Follow symbolic links until we get to the real thisdir.
file
=
`
ls
-ld
"
$file
"
| /usr/bin/sed
-n
's/.*-> //p'
`
while
test
-n
"
$file
"
;
do
destdir
=
`
$ECHO
"
$file
"
| /usr/bin/sed
's%/[^/]*$%%'
`
# If there was a directory component, then change thisdir.
if
test
"x
$destdir
"
!=
"x
$file
"
;
then
case
"
$destdir
"
in
[
\\
/]
*
|
[
A-Za-z]:[
\\
/]
*
)
thisdir
=
"
$destdir
"
;;
*
)
thisdir
=
"
$thisdir
/
$destdir
"
;;
esac
fi
file
=
`
$ECHO
"
$file
"
| /usr/bin/sed
's%^.*/%%'
`
file
=
`
ls
-ld
"
$thisdir
/
$file
"
| /usr/bin/sed
-n
's/.*-> //p'
`
done
# Usually 'no', except on cygwin/mingw when embedded into
# the cwrapper.
WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
=
no
if
test
"
$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
"
=
"yes"
;
then
# special case for '.'
if
test
"
$thisdir
"
=
"."
;
then
thisdir
=
`
pwd
`
fi
# remove .libs from thisdir
case
"
$thisdir
"
in
*
[
\\
/].libs
)
thisdir
=
`
$ECHO
"
$thisdir
"
| /usr/bin/sed
's%[\\/][^\\/]*$%%'
`
;;
.libs
)
thisdir
=
.
;;
esac
fi
# Try to get the absolute directory name.
absdir
=
`
cd
"
$thisdir
"
&&
pwd
`
test
-n
"
$absdir
"
&&
thisdir
=
"
$absdir
"
program
=
'announce_example_5'
progdir
=
"
$thisdir
/.libs"
if
test
-f
"
$progdir
/
$program
"
;
then
# Add our own library path to DYLD_LIBRARY_PATH
DYLD_LIBRARY_PATH
=
"/Users/neverlord/libcppa/.libs:
$DYLD_LIBRARY_PATH
"
# Some systems cannot cope with colon-terminated DYLD_LIBRARY_PATH
# The second colon is a workaround for a bug in BeOS R4 sed
DYLD_LIBRARY_PATH
=
`
$ECHO
"
$DYLD_LIBRARY_PATH
"
| /usr/bin/sed
's/::*$//'
`
export
DYLD_LIBRARY_PATH
if
test
"
$libtool_execute_magic
"
!=
"%%%MAGIC variable%%%"
;
then
# Run the actual program with our arguments.
func_exec_program
${
1
+
"
$@
"
}
fi
else
# The program doesn't exist.
$ECHO
"
$0
: error:
\`
$progdir
/
$program
' does not exist"
1>&2
$ECHO
"This script is just a wrapper for
$program
."
1>&2
$ECHO
"See the libtool documentation for more information."
1>&2
exit
1
fi
fi
examples/announce_example_5.cpp
0 → 100644
View file @
96e1e051
/******************************************************************************
* This example shows how to implement serialize/deserialize to announce *
* non-trivial data structures to the libcppa type system. *
* *
* However, announce() auto-detects STL compliant containers and provides *
* an easy way to tell libcppa how to serialize user defined types. *
* See announce_example 1-4 for usage examples. *
* *
* You should use "hand written" serialize/deserialize implementations *
* if and only if there is no other way. *
******************************************************************************/
#include <cstdint>
#include <iostream>
#include "cppa/cppa.hpp"
#include "cppa/to_string.hpp"
using
std
::
cout
;
using
std
::
endl
;
using
namespace
cppa
;
// a node containing an integer and a vector of children
struct
tree_node
{
std
::
uint32_t
value
;
std
::
vector
<
tree_node
>
children
;
tree_node
(
std
::
uint32_t
v
=
0
)
:
value
(
v
)
{
}
tree_node
&
add_child
(
int
v
=
0
)
{
children
.
push_back
({
v
});
return
*
this
;
}
tree_node
(
const
tree_node
&
)
=
default
;
// recursively print this node and all of its children to stdout
void
print
()
const
{
// format is: value { children0, children1, ..., childrenN }
// e.g., 10 { 20 { 21, 22 }, 30 }
cout
<<
value
;
if
(
children
.
empty
()
==
false
)
{
cout
<<
" { "
;
auto
begin
=
children
.
begin
();
auto
end
=
children
.
end
();
for
(
auto
i
=
begin
;
i
!=
end
;
++
i
)
{
if
(
i
!=
begin
)
{
cout
<<
", "
;
}
i
->
print
();
}
cout
<<
" } "
;
}
}
};
// a very primitive tree implementation
struct
tree
{
tree_node
root
;
// print tree to stdout
void
print
()
const
{
cout
<<
"tree::print: "
;
root
.
print
();
cout
<<
endl
;
}
};
// tree node are equals if values and all values of all children are equal
bool
operator
==
(
const
tree_node
&
lhs
,
const
tree_node
&
rhs
)
{
if
(
lhs
.
value
==
rhs
.
value
&&
lhs
.
children
.
size
()
==
rhs
.
children
.
size
())
{
for
(
std
::
uint32_t
i
=
0
;
i
<
lhs
.
children
.
size
();
++
i
)
{
if
(
!
(
lhs
.
children
[
i
]
==
rhs
.
children
[
i
]))
return
false
;
}
return
true
;
}
return
false
;
}
bool
operator
==
(
const
tree
&
lhs
,
const
tree
&
rhs
)
{
return
lhs
.
root
==
rhs
.
root
;
}
// abstract_uniform_type_info implements all functions of uniform_type_info
// except for serialize() and deserialize() if the template parameter T:
// - does have a default constructor
// - does have a copy constructor
// - does provide operator==
class
tree_type_info
:
public
util
::
abstract_uniform_type_info
<
tree
>
{
protected:
void
serialize
(
const
void
*
ptr
,
serializer
*
sink
)
const
{
// ptr is guaranteed to be a pointer of type tree
auto
tree_ptr
=
reinterpret_cast
<
const
tree
*>
(
ptr
);
// serialization always begins with begin_object(name())
// and ends with end_object();
// name() returns the uniform type name of tree
sink
->
begin_object
(
name
());
// recursively serialize nodes, beginning with root
serialize_node
(
tree_ptr
->
root
,
sink
);
sink
->
end_object
();
}
void
deserialize
(
void
*
ptr
,
deserializer
*
source
)
const
{
// seek_object() gets the uniform name of the next object in the
// stream without modifying the deserializer
std
::
string
cname
=
source
->
seek_object
();
// this name has to be our type name
if
(
cname
!=
name
())
{
throw
std
::
logic_error
(
"wrong type name found"
);
}
// ptr is guaranteed to be a pointer of type tree
auto
tree_ptr
=
reinterpret_cast
<
tree
*>
(
ptr
);
tree_ptr
->
root
.
children
.
clear
();
// workflow is analogous to serialize: begin_object() ... end_object()
source
->
begin_object
(
cname
);
// recursively deserialize nodes, beginning with root
deserialize_node
(
tree_ptr
->
root
,
source
);
source
->
end_object
();
}
private:
void
serialize_node
(
const
tree_node
&
node
,
serializer
*
sink
)
const
{
// serialize { value, number of children } ... children ...
std
::
uint32_t
num_children
=
node
.
children
.
size
();
sink
->
write_value
(
node
.
value
);
sink
->
write_value
(
num_children
);
for
(
const
tree_node
&
subnode
:
node
.
children
)
{
serialize_node
(
subnode
,
sink
);
}
}
void
deserialize_node
(
tree_node
&
node
,
deserializer
*
source
)
const
{
// deserialize { value, number of children } ... children ...
auto
value
=
get
<
std
::
uint32_t
>
(
source
->
read_value
(
pt_uint32
));
auto
num_children
=
get
<
std
::
uint32_t
>
(
source
->
read_value
(
pt_uint32
));
node
.
value
=
value
;
for
(
std
::
uint32_t
i
=
0
;
i
<
num_children
;
++
i
)
{
node
.
add_child
();
deserialize_node
(
node
.
children
.
back
(),
source
);
}
}
};
int
main
()
{
// the tree_type_info is owned by libcppa after this function call
announce
(
typeid
(
tree
),
new
tree_type_info
);
tree
t
;
// create a tree and fill it with some data
t
.
root
.
add_child
(
10
);
t
.
root
.
children
.
back
().
add_child
(
11
).
add_child
(
12
).
add_child
(
13
);
t
.
root
.
add_child
(
20
);
t
.
root
.
children
.
back
().
add_child
(
21
).
add_child
(
22
);
/*
tree t is now:
0
/ \
/ \
/ \
10 20
/ |\ / \
/ | \ / \
11 12 13 21 22
*/
// send a tree to ourselves ...
send
(
self
(),
t
);
receive
(
// ... and receive it
on
<
tree
>
()
>>
[](
const
tree
&
tmsg
)
{
// prints the tree in its serialized format:
// @<> ( { tree ( 0, 2, 10, 3, 11, 0, 12, 0, 13, 0, 20, 2, 21, 0, 22, 0 ) } )
cout
<<
"to_string(last_received()): "
<<
to_string
(
last_received
())
<<
endl
;
// prints: 0 { 10 { 11, 12, 13 } , 20 { 21, 22 } }
tmsg
.
print
();
}
);
return
0
;
}
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment