celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rlenfer...@apache.org
Subject celix git commit: Fixed incorrect markdown format
Date Fri, 31 Mar 2017 10:22:45 GMT
Repository: celix
Updated Branches:
  refs/heads/develop a030567d0 -> 061669071


Fixed incorrect markdown format


Project: http://git-wip-us.apache.org/repos/asf/celix/repo
Commit: http://git-wip-us.apache.org/repos/asf/celix/commit/06166907
Tree: http://git-wip-us.apache.org/repos/asf/celix/tree/06166907
Diff: http://git-wip-us.apache.org/repos/asf/celix/diff/06166907

Branch: refs/heads/develop
Commit: 0616690711f35eacc11cc8f1b986cabecbeefbcd
Parents: a030567
Author: Roy Lenferink <lenferinkroy@gmail.com>
Authored: Fri Mar 31 12:20:10 2017 +0200
Committer: Roy Lenferink <lenferinkroy@gmail.com>
Committed: Fri Mar 31 12:20:10 2017 +0200

----------------------------------------------------------------------
 README.md                                       |  8 ++---
 documents/building/readme.md                    | 18 +++++------
 documents/cmake_commands/readme.md              | 32 ++++++++++----------
 .../getting_started/creating_a_simple_bundle.md | 20 ++++++------
 documents/getting_started/readme.md             |  4 +--
 .../getting_started/using_services_with_c.md    |  2 +-
 .../getting_started/using_services_with_cxx.md  |  2 +-
 documents/intro/readme.md                       | 26 ++++++++--------
 documents/roadmap/improvement_ideas.md          |  6 ++--
 etcdlib/README.md                               | 22 +++++++-------
 pubsub/pubsub_admin_udp_mc/README.md            |  8 ++---
 utils/docs/thpool/FAQ.md                        |  6 ++--
 12 files changed, 77 insertions(+), 77 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/README.md
----------------------------------------------------------------------
diff --git a/README.md b/README.md
index 18a7b6b..3834801 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
-#Apache Celix [![Build Status](https://travis-ci.org/apache/celix.svg?branch=develop)](https://travis-ci.org/apache/celix)
[![Coverage Status](https://coveralls.io/repos/apache/celix/badge.svg?branch=develop&service=github)](https://coveralls.io/github/apache/celix?branch=develop)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/6685/badge.svg)](https://scan.coverity.com/projects/6685)
+# Apache Celix [![Build Status](https://travis-ci.org/apache/celix.svg?branch=develop)](https://travis-ci.org/apache/celix)
[![Coverage Status](https://coveralls.io/repos/apache/celix/badge.svg?branch=develop&service=github)](https://coveralls.io/github/apache/celix?branch=develop)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/6685/badge.svg)](https://scan.coverity.com/projects/6685)
 Apache Celix is an implementation of the OSGi specification adapted to C and C++ (C++11).
It is a provides a framework to develop (dynamic) modular software applications using component
and/or service-oriented programming.
 
-##Building
+## Building
 For information how to build Apache Celix see [Building Apache Celix](documents/building/readme.md)
 
-##Introduction to Apache Celix
+## Introduction to Apache Celix
 For an introduction into Apache Celix see [Apache Celix Intro](documents/intro/readme.md)
 
-##Getting Started with Apache Celix
+## Getting Started with Apache Celix
 For a guide how to start writing your own bundles and services see [Getting Started Guide](documents/getting_started/readme.md)
 

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/building/readme.md
----------------------------------------------------------------------
diff --git a/documents/building/readme.md b/documents/building/readme.md
index 2b08f6d..d47a364 100644
--- a/documents/building/readme.md
+++ b/documents/building/readme.md
@@ -1,4 +1,4 @@
-#Apache Celix - Building and Installing
+# Apache Celix - Building and Installing
 Apache Celix aims to be support a broad range of UNIX platforms.
  
 Currently the [continuous integration build server](https://travis-ci.org/apache/celix) builds
and tests Apache Celix for:
@@ -12,7 +12,7 @@ Currently the [continuous integration build server](https://travis-ci.org/apache
 *   Android (cross-compiled on Ubuntu Trusty Tahr) 
     * GCC 
 
-#Preparing 
+# Preparing
 The following packages (libraries + headers) should be installed on your system:
 
 *	Development Environment
@@ -65,7 +65,7 @@ For OSX systems with brew installed, the following command should work:
     brew link --force libffi
 ```
 
-##Download the Apache Celix sources
+## Download the Apache Celix sources
 To get started you first have to download the Apache Celix sources. This can be done by cloning
the Apache Celix git repository:
 
 ```bash
@@ -78,11 +78,11 @@ cd ${WS}
 git clone --single-branch --branch master https://github.com/apache/celix.git
 ```
 
-##Building Apache Celix
+## Building Apache Celix
 Apache Celix uses [CMake](https://cmake.org) as build system. CMake can generate (among others)
makefiles or ninja build files. 
 using ninja build files will result in a faster build.
 
-###Building using CMake and makefiles:
+### Building using CMake and makefiles:
 ```bash
 cd ${WS}/celix
 mkdir build
@@ -91,7 +91,7 @@ cmake ..
 make 
 ```
 
-###Building using CMake and Ninja
+### Building using CMake and Ninja
 ```bash
 cd ${WS}/celix
 mkdir build
@@ -100,7 +100,7 @@ cmake -G Ninja ..
 ninja
 ```
 
-##Editing Build options
+## Editing Build options
 With use of CMake, Apache Celix makes it possible to edit build options. This enabled users,
among other options, to configure a install location and select additional bundles.
 To edit the options use ccmake or cmake-gui. For cmake-gui an additional package install
can be necessary (Fedora: `dnf install cmake-gui`). 
 
@@ -113,7 +113,7 @@ ccmake .
 
 For this guide we assume the CMAKE_INSTALL_PREFIX is `/usr/local`.
 
-##Installing Apache Celix
+## Installing Apache Celix
 
 ```bash
 cd ${WS}/celix/build
@@ -121,7 +121,7 @@ make
 sudo make install
 ```
 
-##Running Apache Celix
+## Running Apache Celix
 
 If Apache Celix is succesfully installed running
 ```bash

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/cmake_commands/readme.md
----------------------------------------------------------------------
diff --git a/documents/cmake_commands/readme.md b/documents/cmake_commands/readme.md
index 9045cf2..f68eb37 100644
--- a/documents/cmake_commands/readme.md
+++ b/documents/cmake_commands/readme.md
@@ -1,10 +1,10 @@
-#Apache Celix - CMake Commands
+# Apache Celix - CMake Commands
 
 For Apache Celix several cmake command are added to be able to work with Apache Celix bundles
and deployments.
 
-#Bundles
+# Bundles
 
-##add_bundle
+## add_bundle
 Add a bundle to the project.  There are three variants:
 - With SOURCES the bundle will be created using a list of sources files as input for the
bundle activator library.
 - With ACTIVATOR the bundle will be created using the library target or absolute path to
existing library as activator library.
@@ -61,7 +61,7 @@ For SOVERSION only the major part is used. Expected scheme is "<major>.<minor>.<
 - If IMPORT_LIBRARIES is provided all provided lib are added to the "Import-Library" manifest
statement and added in the root of the bundle. libraries can be cmake library targets or absolute
paths to existing libraries.  This is not yet supported by the celix framework
 - If HEADERS is provided the headers values are appended to the bundle manifest.
 
-##bundle_private_libs
+## bundle_private_libs
 Add libraries to a bundle target. The libraries should be cmake library targets or an absolute
path to a existing library.
 
 ```CMake
@@ -70,7 +70,7 @@ bundle_private_libs(<bundle_target>
 )
 ```
 
-##bundle_files
+## bundle_files
 Add files to the target bundle. DESTINATION is relative to the bundle archive root. 
 The rest of the command is conform file(COPY ...) cmake command.
 See cmake file(COPY ...) command for more info.
@@ -88,7 +88,7 @@ bundle_files(<bundle_target>
 ```
 
 
-##bundle_headers
+## bundle_headers
 Append the provided headers to the target bundle manifest.
 
 ```CMake
@@ -99,35 +99,35 @@ bundle_headers(<bundle_target>
 )
 ```
 
-##bundle_symbolic_name
+## bundle_symbolic_name
 Set bundle symbolic name
 
 ```CMake
 bundle_symbolic_name(<bundle_target> symbolic_name)
 ```
 
-##bundle_name
+## bundle_name
 Set bundle name
 
 ```CMake
 bundle_name(<bundle_target> name)
 ```
 
-##bundle_version
+## bundle_version
 Set bundle version
 
 ```CMake
 bundle_version(<bundle_target> version)
 ```
 
-##bundle_description
+## bundle_description
 Set bundle description
 
 ```CMake
 bundle_description(<bundle_target> description)
 ```
 
-##install_bundle
+## install_bundle
 Install bundle when 'make install' is executed. 
 Bundles are installed at `<install-prefix>/share/<project_name>/bundles`.
 Headers are installed at `<install-prefix>/include/<project_name>/<bundle_name>`
@@ -147,9 +147,9 @@ install_bundle(<bundle_target>
 - If HEADERS is provided the list of provided headers will be installed.
 - If RESOURCES is provided the list of provided resources will be installed.
 
-#Deployments
+# Deployments
 
-#add_deploy
+# add_deploy
 Add a deployment, consisting out of a selection of bundles, for the project. 
 Deployments can be used to run/test a selection of bundles in the celix framework.
 A deployment can be found in `<cmake_build_dir>/deploy[/<group_name>]/<deploy_name>`.

@@ -182,7 +182,7 @@ If the bundle target is never added CMake will give an error:
 - If BUNDLES is provided the list of bundles will be added the the generated config.properties
for startup. Combined with COPY the bundles will also be copied to a bundles dir.
 - If PROPERTIES is provided the list of properties will be appended to the generated config.properties
 
-#deploy_bundles_dir
+# deploy_bundles_dir
 Deploy a selection of bundles to the provided bundle dir. This can be used to create an endpoints
/ proxies bundles dir for the remote service admin or drivers bundles dir for the device access.

 
 ```CMake
@@ -195,7 +195,7 @@ deploy_bundles_dir(<deploy_target_name>
 )
 ```
 
-#deploy_bundles
+# deploy_bundles
 Deploy the selected bundles. The bundles are configured for auto starting. 
 
 ```CMake
@@ -206,7 +206,7 @@ deploy_bundles(<deploy_target_name>
 )
 ```
 
-#deploy_properties
+# deploy_properties
 
 ```CMake
 Add the provided properties to the target deploy config.properties.

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/getting_started/creating_a_simple_bundle.md
----------------------------------------------------------------------
diff --git a/documents/getting_started/creating_a_simple_bundle.md b/documents/getting_started/creating_a_simple_bundle.md
index c86dcec..4eefcba 100644
--- a/documents/getting_started/creating_a_simple_bundle.md
+++ b/documents/getting_started/creating_a_simple_bundle.md
@@ -1,20 +1,20 @@
-#Apache Celix - Getting Started Guide: Creating a Simple Bundle
+# Apache Celix - Getting Started Guide: Creating a Simple Bundle
 
-##Intro
+## Intro
 This page is intended for first time users of Apache Celix. It should guide you through building
& installing Apache Celix, setting up a new project, creating your first bundle, setting
up the project for use with Eclipse project and finally running and debugging your bundle
directly from eclipse workspace. 
 
 If there are any uncertainties or question, don't hesitate to ask your questions in the [Apache
Celix mailing](https://celix.apache.org/support/mailinglist.html).
 
-##Prerequisite
+## Prerequisite
 Some experience with a command line interface (xterm) is expected to be able to follow this
guide. 
 
-##Building and Installing
+## Building and Installing
 For Apache Celix see [Building And Installing](../building/readme.md)
 
-##Installing Eclipse CDT
+## Installing Eclipse CDT
 Download the latest eclipse CDT at [http://www.eclipse.org](http://www.eclipse.org) and install
it on your system. For more information on how the install eclipse on your system consult
the eclipse documentation. For this getting started guide the luna version of eclipse was
used ([linux](http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/luna/R/eclipse-cpp-luna-R-linux-gtk-x86_64.tar.gz)
[mac](http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/luna/R/eclipse-cpp-luna-R-macosx-cocoa-x86_64.tar.gz)).
 
-##Apache Celix Bundle project
+## Apache Celix Bundle project
 Now that Apache Celix and Eclipse is installed, we are ready to create a new Apache Celix
Bundle project.
 CMake is used as build tool for Apache Celix projects.
 
@@ -209,7 +209,7 @@ void HelloWorldActivator::deinit() {
 }
 ```
 	
-###Building 
+### Building
 One of the highly recommended features of CMake is the ability to do out of source builds,
the benefit is that all of the build results will go in a separate directory without cluttering
the (source) project.
 CMake also needs to able to find the cmake files Celix provides. This can be achieved by
providing a CMAKE_MODULE_PATH variable (or setting the CMAKE_MODULE_PATH in the top level
CMakeLists.txt). 
 For this example it is assumed that Celix in installed in `/usr/local`.
@@ -230,7 +230,7 @@ make all
 Hopefully you will some some build results scrolling over the screen and actual build results
in the build directory. There should be a hello_world.zip in the bundles/hello_world directory,
this the actual bundle.  
 A bundle on its own has no real value, so lets setup a deployment and run the Apache Celix
framwork with these bundles.
 
-###Running 
+### Running
 
 To create a deployment for the hello world bundles two things are needed: 
 	
@@ -275,7 +275,7 @@ help inspect
 stop 0
 ```
 	
-##Apache Celix Bundle Project in Eclipse
+## Apache Celix Bundle Project in Eclipse
 
 A nice feature of CMake is the ability to generate Eclipse project files, with this feature
bundles can also be developed with use of Eclipse. This should help speed up the development
process. 
 To get started change directory to the build directory and generate a eclipse project file.
@@ -295,7 +295,7 @@ To build the project, use Project->Build All. To run or debug from
Eclipse navig
 
 ![run project](getting_started_img3.png) 
  
-##Next
+## Next
 
 The idea behind service oriented programming is that functionality is provided and used by
abstract service, which hide implementation details.
 For a guide how to provide and use services see

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/getting_started/readme.md
----------------------------------------------------------------------
diff --git a/documents/getting_started/readme.md b/documents/getting_started/readme.md
index 60da6d3..871f6e8 100644
--- a/documents/getting_started/readme.md
+++ b/documents/getting_started/readme.md
@@ -1,6 +1,6 @@
-#Apache Celix - Getting Started Guide
+# Apache Celix - Getting Started Guide
 
-##Guides
+## Guides
 There are several guide to help you get started. The first guide is [Getting Started: Creating
a simple bundle](creating_a_simple_bundle.md) 
 and this should get you started for your first C and/or C++ bundle.
 

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/getting_started/using_services_with_c.md
----------------------------------------------------------------------
diff --git a/documents/getting_started/using_services_with_c.md b/documents/getting_started/using_services_with_c.md
index 9934fa5..de69d55 100644
--- a/documents/getting_started/using_services_with_c.md
+++ b/documents/getting_started/using_services_with_c.md
@@ -1,4 +1,4 @@
-#Apache Celix - Using Services with C
+# Apache Celix - Using Services with C
 
 ## Intro 
 

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/getting_started/using_services_with_cxx.md
----------------------------------------------------------------------
diff --git a/documents/getting_started/using_services_with_cxx.md b/documents/getting_started/using_services_with_cxx.md
index 488aacd..e215e37 100644
--- a/documents/getting_started/using_services_with_cxx.md
+++ b/documents/getting_started/using_services_with_cxx.md
@@ -1,4 +1,4 @@
-#Apache Celix - Using Services with C++
+# Apache Celix - Using Services with C++
 
 ## Intro 
 

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/intro/readme.md
----------------------------------------------------------------------
diff --git a/documents/intro/readme.md b/documents/intro/readme.md
index a8c84de..4d4b73b 100644
--- a/documents/intro/readme.md
+++ b/documents/intro/readme.md
@@ -1,18 +1,18 @@
-#Apache Celix Introduction
+# Apache Celix Introduction
 
-##What is Apache Celix
+## What is Apache Celix
 Apache Celix is an implementation of the [OSGi specification](https://www.osgi.org/developer/specifications)
adapted to C and C++. It is a provides a framework to develop (dynamic) modular software applications
using component and/or service-oriented programming.
 
 Apache Celix is primarily developed in C and adds an additional abstraction, in the form
of a library, to support for C++. 
 
-##Bundles
+## Bundles
 OSGi uses bundles as medium to (run-time) add and remove modules (additional functionality)
to OSGi applications. For Java, OSGi bundles are jars with a OSGi specific manifest. For Apache
Celix bundles are zip files containing an OSGi manifest (with some differences) and possible
modules in the form of shared libraries. One of these modules can be the bundle activator
in which case the Apache Celix framework will lookup the bundle create, start, stop and destroy
symbols to manage the lifecycle of the bundle; This can be used bootstrap the bundles functionality.

 
-##C and Objects
+## C and Objects
 C is a procedural programming language and as result has no direct support for the notion
of a object. 
 To be able to follow the OSGi specification, a standard mapping from C to Java is used. This
mapping takes care of how instances, parameters, return values and exceptions (error codes)
work in Apache Celix.
 
-###Example
+### Example
 Before going into detail, here is an example of the mapping from a method in Java to a function
in C:
 
 ```Java
@@ -29,7 +29,7 @@ public interface BundleContext {
 celix_status_t bundleContext_getServiceReferences(bundle_context_pt context, const char*
serviceName, const char* filter, array_list_pt* service_references);
 ```
 
-###Object methods 
+### Object methods
 Using the provided example, the following templates can be extracted for mapping a object
method to a C function:
 
 ```C
@@ -67,7 +67,7 @@ Note that although the first template is preferred, Apache Celix still uses
the
 Unless stated otherwise, the caller is owner of the output and should destroy/deallocate
the result.
 An exception is a const output parameters, this indicates the callee is still owner.
 
-###Creating and destroying Objects
+### Creating and destroying Objects
 Objects in Apache Celix can generally be created and destroyed using a create and destroy
functions.
 For example:
 
@@ -90,25 +90,25 @@ void hashMapIterator_init(hash_map_pt map, hash_map_iterator_pt iterator);
 void hashMapIterator_deinit(hash_map_iterator_pt iterator);
 ```
 
-###OSGi documentation and Apache Celix
+### OSGi documentation and Apache Celix
 Apache Celix follows the OSGi API as close as possible, but since the OSGi specification
is written primarily for Java, there will be differences (Java is OO, C is procedural).
 Taking into account those differences and mapping explained before the OSGi javadoc can be
used for a more in depth description of what the Apache Celix API offers. 
 
 * [OSGi core specification 4.3](https://osgi.org/javadoc/r4v43/core/index.html)
 * [OSGi compendium specification 4.3](https://osgi.org/javadoc/r4v43/cmpn/index.html)
 
-##What is a OSGi service?
+## What is a OSGi service?
 A OSGi service is a Java object register to the OSGi framework under a certain set of properties.
 OSGi services are generally registered as a well known interface (using the `objectClass`
property).
  
 Consumers can dynamically lookup the services providing a filter to specify what kind of
services their are interested in.   
 
-##C services in Apache Celix
+## C services in Apache Celix
 As mentioned OSGi uses Java Interfaces to define a service. Since C does not have Interfaces
as compilable unit, this is not possible for Celix.  To be able to define a service which
hides implementation details, Celix uses structs with function pointers.
  
 See [Apache Celix - Getting Started Guide](https://github.com/apache/celix/blob/master/documents/getting_started/readme.md)
for a more in depth look at services and service usage.
  
-##Impact of dynamic services
+## Impact of dynamic services
 Services in Apache Celix are dynamic, meaning that they can come and go at any moment. 
 How to cope with this dynamic behaviour is very critical for creating a stable solution.
  
@@ -124,13 +124,13 @@ Apache Celix offers different solutions how to cope with this dynamic
behaviour:
 
 Even though the dependency manager is not part of the OSGi specification, this is the preferred
way because it uses a higher abstraction and removes a lot boilerplate code. 
 
-##C++ Support
+## C++ Support
 
 One of the reasons why C was chosen as implementation language is that C can act as a common
denominator for (service oriented) interoperability between a range of languages.
 C++ support is added with the use of a [C++ Dependency Manager](../../dependency_manager_cxx/readme.md).
 The Dependency Manager is arguably the most convenient way to interact with services, confers
most uses cases and eliminates the necessity to port the rest of the (large) API to C++.
 
-##Documentation
+## Documentation
 
 For more information see:
 

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/documents/roadmap/improvement_ideas.md
----------------------------------------------------------------------
diff --git a/documents/roadmap/improvement_ideas.md b/documents/roadmap/improvement_ideas.md
index 54bad87..ff71d11 100644
--- a/documents/roadmap/improvement_ideas.md
+++ b/documents/roadmap/improvement_ideas.md
@@ -87,6 +87,6 @@ could be used if preferable.
 Now an admin is responsible for serialization and communication.
 
 # Add pub sub admins. 
-The current implementation uses JSON over multicast UDP or over ZMQ.
-One or more could be added. i.e. serialization based on Apache-Avro, communication over TCP
/ Kafka / Shared Memory
-Add interfaces for other languages (Python / Rust / Go / ...)
\ No newline at end of file
+The current implementation uses JSON over multicast UDP or over ZMQ.  
+One or more could be added. i.e. serialization based on Apache-Avro, communication over TCP
/ Kafka / Shared Memory  
+Add interfaces for other languages (Python / Rust / Go / ...)  
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/etcdlib/README.md
----------------------------------------------------------------------
diff --git a/etcdlib/README.md b/etcdlib/README.md
index 1bbf14e..49f18d6 100644
--- a/etcdlib/README.md
+++ b/etcdlib/README.md
@@ -1,11 +1,11 @@
-#Etcdlib
+# Etcdlib
 etcd is a distributed, consistent key-value store for shared configuration and service discovery,
part of the CoreOS project.
 
 This repository provides a library for etcd for C applications.
 
 Etcdlib can be used as part of Celix but is also useable stand-alone.
 
-##Preparing
+## Preparing
 The following packages (libraries + headers) should be installed on your system:
 
 *	Development Environment
@@ -16,23 +16,23 @@ The following packages (libraries + headers) should be installed on your
system:
 	*	curl
 	*	jansson
 
-##Download the Apache Celix sources
+## Download the Apache Celix sources
 To get started you first have to download the Apache Celix sources. This can be done by cloning
the Apache Celix git repository:
 
 ```bash
-#Create a new workspace to work in, e.g:
+# Create a new workspace to work in, e.g:
 mkdir -p ${HOME}/workspace
 export WS=${HOME}/workspace
 cd ${WS}
 
-#clone the repro
+# clone the repro
 git clone --single-branch --branch develop https://github.com/apache/celix.git
 ```
 
-##Building
+## Building
 Etcdlib uses [CMake](https://cmake.org) as build system. CMake can generate (among others)
makefiles or ninja build files. Using ninja build files will result in a faster build.
 
-###Building using CMake and makefiles:
+### Building using CMake and makefiles:
 ```bash
 cd ${WS}/celix/etcdlib
 mkdir build
@@ -41,7 +41,7 @@ cmake ..
 make 
 ```
 
-###Building using CMake and Ninja
+### Building using CMake and Ninja
 ```bash
 cd ${WS}/celix/etcdlib
 mkdir build
@@ -50,19 +50,19 @@ cmake -G Ninja ..
 ninja
 ```
 
-##Editing Build options
+## Editing Build options
 With use of CMake, Etcdlib makes it possible to edit build options. This enabled users, among
other options, to configure a install location.
 To edit the options use ccmake or cmake-gui. For cmake-gui an additional package install
can be necessary (Fedora: `dnf install cmake-gui`). 
 
 ```bash
 cd ${WS}/celix/etcdlib/build
 ccmake .
-#Edit the CMAKE_INSTALL_PREFIX config to set the install location
+# Edit the CMAKE_INSTALL_PREFIX config to set the install location
 ```
 
 For this guide we assume the CMAKE_INSTALL_PREFIX is `/usr/local`.
 
-##Installing Etcdlib
+## Installing Etcdlib
 
 ```bash
 cd ${WS}/celix/etcdlib/build

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/pubsub/pubsub_admin_udp_mc/README.md
----------------------------------------------------------------------
diff --git a/pubsub/pubsub_admin_udp_mc/README.md b/pubsub/pubsub_admin_udp_mc/README.md
index 19c7b86..0f3f637 100644
--- a/pubsub/pubsub_admin_udp_mc/README.md
+++ b/pubsub/pubsub_admin_udp_mc/README.md
@@ -1,8 +1,8 @@
-#PUBSUB-Admin UDP Multicast
+# PUBSUB-Admin UDP Multicast
 
 ---
 
-##Description
+## Description
 
 This description is particular for the UDP-Multicast PUB-SUB. 
 
@@ -39,7 +39,7 @@ Now a data-connection is created and data send by the publisher will be
received
 
 ---
 
-##Properties
+## Properties
 
 <table border="1">
     <tr><th>Property</th><th>Description</th></tr>
@@ -50,7 +50,7 @@ Now a data-connection is created and data send by the publisher will be
received
 
 ---
 
-##Shortcomings
+## Shortcomings
 
 1. Per topic a random portnr is used for creating an endpoint. It is theoretical possible
that for 2 topic the same endpoint is created.
 2. For every message a 32 bit random message ID is generated to discriminate segments of
different messages which could be sent at the same time. It is theoretically possible that
there are 2 equal message ID's at the same time. But since the mesage ID is valid only during
the transmission of a message (maximum some milliseconds with large messages) this is not
very plausible.

http://git-wip-us.apache.org/repos/asf/celix/blob/06166907/utils/docs/thpool/FAQ.md
----------------------------------------------------------------------
diff --git a/utils/docs/thpool/FAQ.md b/utils/docs/thpool/FAQ.md
index 584a699..0eea250 100644
--- a/utils/docs/thpool/FAQ.md
+++ b/utils/docs/thpool/FAQ.md
@@ -1,5 +1,5 @@
 
-###Why isn't pthread_exit() used to exit a thread?
+### Why isn't pthread_exit() used to exit a thread?
 `thread_do` used to use pthread_exit(). However that resulted in
 hard times of testing for memory leaks. The reason is that on pthread_exit()
 not all memory is freed bt pthread (probably for future threads or false
@@ -9,7 +9,7 @@ is used.
 Interestingly using `pthread_exit()` results in much more memory being allocated.
 
 
-###Why do you use sleep() after calling thpool_destroy()?
+### Why do you use sleep() after calling thpool_destroy()?
 This is needed only in the tests. The reason is that if you call thpool_destroy
 and then exit immedietely, maybe the program will exit before all the threads
 had the time to deallocate. In that way it is impossible to check for memory
@@ -23,7 +23,7 @@ and thus threads will have more than enough time to terminate.
 
 
 
-###Why does wait() use all my CPU?
+### Why does wait() use all my CPU?
 Normally `wait()` will spike CPU usage to full when called. This is normal as long as it
doesn't last for more than 1 second. The reason this happens is that `wait()` goes through
various phases of polling (what is called smart polling).
 
  * Initially there is no interval between polling and hence the 100% use of your CPU.


Mime
View raw message