Merge lp:~stolowski/unity-scopes-api/inline-playback-doc into lp:unity-scopes-api

[Paweł Stołowski]

Documentation for inline playback and concierge mode.

Documentation for inline playback and concierge mode.

[lp:~stolowski/unity-scopes-api/inline-playback-doc]

663. By Paweł Stołowski on 2016-03-04

Fix spelling

664. By Paweł Stołowski on 2016-03-08

Added CategoryRenderer doc

665. By Paweł Stołowski on 2016-03-08

Doc fixes

666. By Paweł Stołowski on 2016-03-08

-the

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-10-19 04:22:03 +0000
+++ CMakeLists.txt	2016-03-04 15:54:04 +0000
@@ -60,7 +60,7 @@
 endif()
 
 include(FindPkgConfig)
-find_package(Boost COMPONENTS system filesystem regex serialization thread log REQUIRED)
+find_package(Boost COMPONENTS system filesystem regex serialization thread REQUIRED)
 pkg_check_modules(UNITY_API libunity-api>=0.1.3 REQUIRED)
 pkg_check_modules(PROCESS_CPP process-cpp>=1.0.1 REQUIRED)
 pkg_check_modules(APPARMOR REQUIRED libapparmor REQUIRED)

=== modified file 'CONFIGFILES'
--- CONFIGFILES	2015-12-09 05:43:13 +0000
+++ CONFIGFILES	2016-03-04 15:54:04 +0000
@@ -114,38 +114,6 @@
   The environment variable UNITY_SCOPES_CONFIG_DIR overrides this key (useful when running
   automated tests that should not overwrite any of the real configuration files).
 
-- LogDir
-
-  The parent directory under which the run time writes the scope log files.
-  Setting this value explicitly to the empty string disables file logging and forces
-  all log entries to go to stderr.
-
-  The default value is the empty string.
-
-  If you set this value, you must set it to a directory that is writable to
-  confined scopes. We suggest $HOME/.cache/unity-scopes.
-
-  Note that the actual logs are written into subdirectories of this
-  directory. Assuming LogDir is set to $HOME/.cache/unity-scopes,
-  the subdirectories are
-  $HOME/.cache/unity-scopes/leaf-net/<scope_id>/logs (for confined scopes) and
-  $HOME/.cache/unity-scopes/unconfined/<scope_id>/logs (for unconfined scopes).
-
-  The environment variable UNITY_SCOPES_LOGDIR overrides this key.
-  Setting this variable explicitly to the empty string disables file logging and forces
-  all log entries to go to stderr.
-
-- Log.MaxFileSize
-
-  The maximum size in bytes of an individual log file before it is rolled over.
-  The value must be at least 1024. The default value is 512 kB.
-
-- Log.MaxDirSize
-
-  The maximum size in bytes of the sum of sizes of all log files in the log directory
-  before they are deleted. The value must be greater than Log.MaxFileSize.
-  The default value is 2 MB.
-
 - Log.TraceChannels
 
   The names of channels for which to emit trace. This must be a semicolon-separated

=== modified file 'HACKING'
--- HACKING	2015-09-15 21:55:44 +0000
+++ HACKING	2016-03-04 15:54:04 +0000
@@ -293,13 +293,13 @@
 ABI compliance test
 -------------------
 
-The tests include an ABI compliance test (for Wily and later). To run it:
+The tests include an ABI compliance test (for xenial and later). To run it:
 
     $ cd test/abi-compliance
     $ make test
 
 The test is also automatically run as part of the test suite.
-It takes several minutes to run . If you don't want to wait during local builds,
+It takes a while to run. If you don't want to wait during local builds,
 set the cmake "slowtests" option to OFF to skip the check.
 
 The baseline ABI files for the test are in test/abi-compliance/abi_dumps.
@@ -313,11 +313,8 @@
 Once all the packages are built, you can extract the ABI dump
 files and add them to the corresponding directory in the source tree.
 
-The abi-compliance-checker tool produces a report in
-
-    test/abi-compliance/compat_reports/libunity-scopes.so/[version]_to_[version]/compat_report.html
-
-The report provides a nicely layed-out page with all the details.
+The abi compliance test produces a report in
+libunity-scopes_<current-version>_abi-report.txt if anything unusual is detected.
 
 Autopkg test suite
 ------------------

=== modified file 'STRUCTS'
--- STRUCTS	2015-07-14 15:11:48 +0000
+++ STRUCTS	2016-03-04 15:54:04 +0000
@@ -105,6 +105,11 @@
 =====================================
   filter_id   : Variant (arbitrary, depends on filter type)
 
+FilterGroup
+===========
+  'id'    : string
+  'label' : string
+
 FilterOption
 ============
  'id'     : string
@@ -115,6 +120,7 @@
  'id'           : string
  'filter_type'  : string
  'display_hints': int, optional
+ 'filter_group' : string, optional
 
 OptionSelectorFilter (FilterBase)
 =================================
@@ -126,10 +132,15 @@
 
 RangeInputFilter
 ================
- 'id'           : string
- 'start_label'  : string
- 'end_label'    : string
- 'unit_label'   : string
+ 'id'                  : string
+ 'default_start_value' : variant (int, double, null)
+ 'default_end_value'   : variant (int, double, null)
+ 'start_prefix_label'  : string
+ 'start_postfix_label' : string
+ 'end_prefix_label'    : string
+ 'end_postfix_label'   : string
+ 'central_label'       : string
+ 'filter_group' : string, optional
 
 Filters + FilterState
 =====================

=== modified file 'debian/VERSION'
--- debian/VERSION	2016-02-09 10:26:20 +0000
+++ debian/VERSION	2016-03-04 15:54:04 +0000
@@ -1,1 +1,1 @@
-1.0.3
+1.0.4

=== modified file 'debian/changelog'
--- debian/changelog	2016-02-09 15:15:15 +0000
+++ debian/changelog	2016-03-04 15:54:04 +0000
@@ -1,3 +1,13 @@
+unity-scopes-api (1.0.4-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Pawel Stolowski ]
+  * New RangeInputFilter.
+
+  [ Michi Henning ]
+  * Changed ABI compliance testing to use abigail.
+
+ -- Pawel Stolowski <[e-mail]>  Mon, 11 Jan 2016 12:06:29 +0100
+
 unity-scopes-api (1.0.3+16.04.20160209-0ubuntu1) xenial; urgency=medium
 
   [ Michi Henning ]

=== modified file 'debian/control'
--- debian/control	2015-12-18 09:21:53 +0000
+++ debian/control	2016-03-04 15:54:04 +0000
@@ -1,124 +1,14 @@
 # This file is autogenerated. DO NOT EDIT!
-#
-# Modifications should be made to control.in instead.
+# 
+# Modifications should be made to debian/control.in instead.
 # This file is regenerated automatically in the clean target.
 #
 Source: unity-scopes-api
-Priority: optional
-Maintainer: Ubuntu Developers <[e-mail]>
-Build-Depends: abi-compliance-checker,
-               capnproto,
-               click-dev (>= 0.2.2),
-               cmake,
-               dbus-test-runner,
+Maintainer: This not the real control file because it is generated during the build from control.in.
+Build-Depends: click-dev (>= 0.2.2),
                debhelper (>= 9),
-               devscripts,
-               doxygen,
-               exuberant-ctags,
-               google-mock,
-               graphviz,
-               libaccounts-glib-dev,
-               libapparmor-dev,
-               libboost-filesystem-dev,
-               libboost-log-dev,
-               libboost-regex-dev,
-               libboost-serialization-dev,
-               libcapnp-dev (>= 0.4.0),
-               libdbustest1-dev,
-               libjsoncpp-dev,
-               liblttng-ust-dev,
-               libnet-cpp-dev (>= 1.2.0),
-               libprocess-cpp-dev (>= 1.0.1),
-               libsignon-glib-dev,
-               libunity-api-dev (>= 7.80.7~),
-               libzmq3-dev,
-               libzmqpp-dev,
                lsb-release,
-               lttng-tools,
-               pkg-config,
-               python3:any,
-               python-tornado,
-               valgrind,
-Standards-Version: 3.9.6
-XS-Testsuite: autopkgtest
-Section: libs
-Homepage: https://launchpad.net/unity-scopes-api
-# if you don't have have commit access to this branch but would like to upload
-# directly to Ubuntu, don't worry: your changes will be merged back into the
-# upstream branch
-Vcs-Bzr: lp:unity-scopes-api
-Vcs-Browser: https://code.launchpad.net/unity-scopes-api
 
 Package: libunity-scopes1.0
 Architecture: any
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends},
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-Replaces: libunity-scopes0,
-          libunity-scopes3,
-          libunity-scopes1,
-          libunity-scopes2,
-Conflicts: libunity-scopes0,
-           libunity-scopes3,
-           libunity-scopes1,
-           libunity-scopes2,
-Description: API for Unity scopes integration
- Library to integrate scopes with the Unity shell
-
-Package: libunity-scopes-dev
-Section: libdevel
-Architecture: any
-Multi-Arch: same
-Depends: libproperties-cpp-dev,
-         libunity-api-dev,
-         libunity-scopes1.0 (= ${binary:Version}),
-         ${misc:Depends},
-Description: Header files for Unity scopes API
- Library to integrate scopes with the Unity shell (dev files)
-
-Package: libunity-scopes-cli
-Section: devel
-Architecture: any
-Multi-Arch: foreign
-Depends: libunity-scopes1.0 (= ${binary:Version}),
-         ${misc:Depends},
-         ${shlibs:Depends},
-Description: Client utility for Unity scopes API
- Commandline client utility for querying Unity scopes, useful for testing.
-
-Package: libunity-scopes-doc
-Section: doc
-Architecture: all
-Multi-Arch: foreign
-Depends: ${misc:Depends},
-Description: Documentation for Unity scopes API
- Library to integrate scopes with the Unity shell (documentation)
-
-Package: libunity-scopes-qt0.2
-Architecture: any
-Multi-Arch: same
-Pre-Depends: ${misc:Pre-Depends},
-Depends: ${misc:Depends},
-         ${shlibs:Depends},
-Description: Qt library for Unity scopes API
- Library that integrates classes based on Qt for convenience
-
-Package: libunity-scopes-qt-dev
-Section: libdevel
-Architecture: any
-Multi-Arch: same
-Depends: libunity-scopes-dev (= ${binary:Version}),
-         libunity-scopes-qt0.2 (= ${binary:Version}),
-         libnet-cpp-dev (>=1.2.0),
-         ${misc:Depends},
-Description: Header files for Qt library for Unity scopes API
- Library that integrates classes based on Qt for convenience (dev files)
-
-Package: libunity-scopes-qt-doc
-Section: doc
-Architecture: all
-Multi-Arch: foreign
-Depends: ${misc:Depends},
-Description: Documentation for Unity Qt library
- Library that integrates classes based on Qt for convenience (documentation)
+Description: This not the real control file because it is generated during the build from control.in.

=== modified file 'debian/control.in'
--- debian/control.in	2015-11-13 04:05:00 +0000
+++ debian/control.in	2016-03-04 15:54:04 +0000
@@ -1,7 +1,8 @@
 Source: unity-scopes-api
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
-Build-Depends: abi-compliance-checker,
+Build-Depends: abigail-tools | libabigail-tools,
+               binutils,
                capnproto,
                click-dev (>= 0.2.2),
                cmake,
@@ -15,9 +16,9 @@
                libaccounts-glib-dev,
                libapparmor-dev,
                libboost-filesystem-dev,
-               libboost-log-dev,
                libboost-regex-dev,
                libboost-serialization-dev,
+               libboost-thread-dev,
                libcapnp-dev (>= 0.4.0),
                libdbustest1-dev,
                libjsoncpp-dev,

=== modified file 'demo/client.cpp'
--- demo/client.cpp	2015-02-09 02:23:22 +0000
+++ demo/client.cpp	2016-03-04 15:54:04 +0000
@@ -478,7 +478,6 @@
         shared_ptr<Receiver> reply(new Receiver(result_index));
 
         SearchMetadata metadata("C", "desktop");
-        metadata.set_cardinality(10);
         auto ctrl = meta.proxy()->search(search_string, department_id, filter_state, metadata, reply); // May raise TimeoutException
         cout << "client: created query" << endl;
         reply->wait_until_finished();

=== modified file 'doc/tutorial.dox'
--- doc/tutorial.dox	2015-10-29 02:35:50 +0000
+++ doc/tutorial.dox	2016-03-04 15:54:04 +0000
@@ -410,6 +410,75 @@
 (because `cancelled()` and `run()` are called by different threads and, therefore, can be dispatched out of order).
 
 
+\paragraph filters Filters
+
+Scopes API offers support for filter widgets, which provide means for filtering search results based on user input other than search query string
+alone. Filter widgets need to be defined by creating appropriate filters inside the overriden SearchQueryBase::run() method, and then pushed
+to the UI. It is recommended to push filters early before search results are pushed for best user experience.
+
+Here is an example of how filters can be created:
+
+\code{.cpp}
+void run(SearchReplyProxy const& reply)
+{
+    OptionSelectorFilter::UPtr filter1 = OptionSelectorFilter::create("brand", "Brand");
+    filter1->add_option("audi", "Audi");
+    filter1->add_option("bmw", "BMW");
+
+    RangeInputFilter::SPtr filter2 = RangeInputFilter::create("price", Variant(0.0f), Variant::null(), "Min", "", "", "Max", "");
+    ValueSliderFilter::SPtr filter3 = ValueSliderFilter::create("horsepower", 1, 135, 50, ValueSliderLabels("Min", "Max"));
+
+    Filters filters;
+    filters.push_back(filter1);
+    filters.push_back(filter2);
+    filters.push_back(filter3);
+
+    reply->push(filters, query().filter_state());
+
+    // push search results here
+\endcode
+
+Scopes are free to change filters at any time - with every execution of search the scope can omit any of the previously visible filters or add new ones, if that
+makes sense for particular use cases.
+
+Filters act only as UI widgets - it is the responsibility of the scope to check their state and actually apply them to search results. The current value of a filter
+becomes just another parameter of the search query that needs to be taken into account in the implementation of search handling inside run().
+
+To examine current state of the filters, pass the instance of unity::scopes::FilterState received with search query to respective methods of
+the filters. For example:
+
+\code{.cpp}
+void run(SearchReplyProxy const& reply)
+{
+    // filter creation code omitted here
+    auto state = query().filter_state();
+    int search_start = 0;
+    int search_end = 1000;
+    if (rangefilter->has_start_value(state)) {
+        search_start = rangefilter->start_value(state);
+    }
+    if (rangefilter->has_end_value(state)) {
+        search_end = rangefilter->end_value(state);
+    }
+
+    // apply search_start and search_end to search logic
+\endcode
+
+The scope may nominate a single filter to act as "primary navigation". This is only possible if departments are not used at the same time (in which case departments
+become a primary navigation tool). An attempt to nominate a filter to be a "primary navigation" while departments are present is ignored by the UI and the
+filter acts as a regular filter. Also, only a single-selection OptionSelectorFilter can currently be promoted to be primary navigation. To do this, set the display
+hints to FilterBase::DisplayHints::Primary:
+
+\code{.cpp}
+OptionSelectorFilter::UPtr filter1 = OptionSelectorFilter::create("brand", "Brand");
+filter1->set_display_hints(FilterBase::DisplayHints::Primary);
+filter1->add_option("audi", "Audi");
+\endcode
+
+When a filter becomes a primary navigation filter, it gets displayed in the search box drop-down, below recent searches, so it's readily available for quick access.
+Also, currently selected option is displayed as a "brick" in the search box, hinting the user about the context of current search. All the other filters can be
+revealed via the filters panel icon.
+
 \paragraph handlingpreview Handling previews
 
 Your scope is responsible for handling preview requests for results it has returned; you implement this by overriding
@@ -785,6 +854,70 @@
 (See \link unity::scopes::utility::BufferedResultForwarder BufferedResultForwarder\endlink
 for more details.)
 
+\paragraph inlineplayback Inline music playback
+
+Results which represent music (songs, albums etc.) can contain an extra data about audio content and can then be played directly from the Dash.
+Such results have a "play" button overlayed on them. To create results that support this functionality two conditions must be met:
+<ul>
+<li>Category renderer definition must contain the "quick-preview-type" key with the value of "audio" in the "template" section;
+<li>Results in the respective category must contain a "quick-preview-data" attribute, each of them is a dictionary with the extra playback data described
+below.
+</ul>
+
+The data assigned to "quick-preview-data" attribute of a Result needs to contain the following keys:
+<ul>
+<li>uri - a playable uri of a media file (path of a local file, or http uri).
+<li>duration - the duration of the media file, in seconds.
+<li>playlist - an array of uris of additional songs, e.g. songs from same album; they will be played in the background when the main
+song finishes. This list can contain the main song again.
+</ul>
+
+Here is an example of a category renderer for inline playback, which uses component mapping to map quick-preview-data to audio-data attribute of a result:
+\code{.cpp}
+static const char CATEGORY_RENDERER[] = R"(
+{
+  "schema-version": 1,
+  "template": {
+    "category-layout": "grid",
+    "card-size": "large",
+    "card-layout" : "horizontal",
+    "quick-preview-type" : "audio"
+  },
+  "components": {
+    "title": "title",
+    "art": {
+      "field": "art"
+    },
+    "subtitle": "artist",
+    "quick-preview-data": {
+        "field": "audio-data"
+    }
+  }
+}
+)";
+\endcode
+
+A sample code that creates a result card representing a song and all songs from same album in a background playlist may look this way:
+\code{.cpp}
+
+CategorisedResult res(category);
+res.set_uri(uri);
+res.set_title(media.getTitle());
+...
+
+VariantMap inline_playback_data;
+inline_playback_data["uri"] = uri;
+inline_playback_data["duration"] = song_duration_in_seconds;
+VariantArray playlist;
+for (const std::string& song: album_songs)
+{
+    playlist.push_back(Variant(song.getUri()));
+}
+inline_playback_data["playlist"] = playlist;
+res["audio-data"] = inline_playback_data;
+
+\endcode
+
 \paragraph aggactiv Activation and preview
 
 If an aggregator scope simply forwards the results it receives from other scopes (possibly changing their category),

=== modified file 'include/unity/scopes/FilterBase.h'
--- include/unity/scopes/FilterBase.h	2015-11-12 14:20:36 +0000
+++ include/unity/scopes/FilterBase.h	2016-03-04 15:54:04 +0000
@@ -21,6 +21,7 @@
 #include <unity/util/NonCopyable.h>
 #include <unity/scopes/Variant.h>
 #include <unity/util/DefinesPtrs.h>
+#include <unity/scopes/FilterGroup.h>
 #include <memory>
 #include <list>
 
@@ -94,10 +95,33 @@
 
     /// @cond
     virtual ~FilterBase();
+    /// @endcond
+
+    /**
+    \brief Set an optional title of this filter.
+    \param title The title.
+    */
+    void set_title(std::string const& title);
+
+    /**
+    \brief Get the optional title of this filter.
+    \return Filter title (can be empty).
+    */
+    std::string title() const;
+
+    /**
+     \brief Get the filter group this filter belongs to.
+
+     \return The filter group (or null)
+    */
+    FilterGroup::SCPtr filter_group() const;
 
 protected:
+    /// @cond
     FilterBase(internal::FilterBaseImpl *pimpl);
     std::unique_ptr<internal::FilterBaseImpl> p;
+
+    friend class internal::FilterBaseImpl;
     /// @endcond
 };
 

=== added file 'include/unity/scopes/FilterGroup.h'
--- include/unity/scopes/FilterGroup.h	1970-01-01 00:00:00 +0000
+++ include/unity/scopes/FilterGroup.h	2016-03-04 15:54:04 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/util/NonCopyable.h>
+#include <unity/util/DefinesPtrs.h>
+#include <string>
+#include <memory>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+    class FilterGroupImpl;
+}
+
+/**
+\brief Groups several filters into an expandable widget in the UI.
+*/
+class FilterGroup
+{
+public:
+    /// @cond
+    NONCOPYABLE(FilterGroup);
+    UNITY_DEFINES_PTRS(FilterGroup);
+
+    virtual ~FilterGroup();
+    /// @endcond
+
+    /**
+     \brief Create a WidgetGroup.
+
+     \return An instance of WidgetGroup.
+     */
+    static FilterGroup::SCPtr create(std::string const& id, std::string const& label);
+
+    /**
+     \brief Get the id of the widget group.
+
+     \return The identifier.
+    */
+    std::string id() const;
+
+    /**
+     \brief Get the label of the widget group.
+
+     \return The label.
+    */
+    std::string label() const;
+
+private:
+    /// @cond
+    FilterGroup();
+    FilterGroup(internal::FilterGroupImpl *pimpl);
+    std::unique_ptr<internal::FilterGroupImpl> p;
+
+    friend class internal::FilterGroupImpl;
+    /// @endcond
+};
+
+} // namespace scopes
+
+} // namespace unity

=== modified file 'include/unity/scopes/FilterOption.h'
--- include/unity/scopes/FilterOption.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/FilterOption.h	2016-03-04 15:54:04 +0000
@@ -62,6 +62,12 @@
     ~FilterOption();
     /// @endcond
 
+    /**
+     \brief Return the default value of this filter option.
+     \return default value
+    */
+    bool default_value() const;
+
 private:
     FilterOption(std::string const& id, std::string const& label);
     std::unique_ptr<internal::FilterOptionImpl> p;

=== modified file 'include/unity/scopes/OptionSelectorFilter.h'
--- include/unity/scopes/OptionSelectorFilter.h	2015-11-12 14:20:36 +0000
+++ include/unity/scopes/OptionSelectorFilter.h	2016-03-04 15:54:04 +0000
@@ -21,6 +21,7 @@
 #include <unity/scopes/FilterBase.h>
 #include <unity/scopes/FilterOption.h>
 #include <unity/scopes/Variant.h>
+#include <unity/scopes/FilterGroup.h>
 #include <string>
 #include <list>
 #include <set>
@@ -74,7 +75,9 @@
     bool multi_select() const;
 
     /**
-    \brief Add a new option to this filter.
+    \brief Add a new option to this filter. The option is 'off' by default.
+
+    \throws unity::InvalidArgumentException on invalid id or label
     \return The new option instance.
     */
     FilterOption::SCPtr add_option(std::string const& id, std::string const& label);
@@ -114,6 +117,29 @@
     */
     static void update_state(FilterState& filter_state, std::string const& filter_id, std::string const& option_id, bool value);
 
+    /**
+    \brief Add a new option to this filter and provide its default value.
+
+    \throws unity::LogicException if multiple options with value of 'true' are provided for a single-selection OptionSelectorFilter.
+    \throws unity::InvalidArgumentException on invalid id or label
+    \return The new option instance.
+    */
+    FilterOption::SCPtr add_option(std::string const& id, std::string const& label, bool value);
+
+    /**
+    \brief Creates an OpionSelectorFilter inside a FilterGroup.
+    \param id A unique identifier for the filter that can be used to identify it later among several filters.
+    \param label A display label for the filter.
+    \param group A filter group this filter should be added to.
+    \param multi_select If true, the filter permits more than option to be selected; otherwise, only a single
+    option can be selected.
+    \throws unity::InvalidArgumentException on invalid null group.
+
+    \note The multi-selection cannot be combined with unity::scopes::FilterBase::DisplayHints::Primary flag set via
+    unity::scopes::FilterBase::set_display_hints().
+    */
+    static OptionSelectorFilter::UPtr create(std::string const& id, std::string const& label, FilterGroup::SCPtr const& group, bool multi_select = false);
+
 private:
     OptionSelectorFilter(internal::OptionSelectorFilterImpl*);
     internal::OptionSelectorFilterImpl* fwd() const;

=== modified file 'include/unity/scopes/RangeInputFilter.h'
--- include/unity/scopes/RangeInputFilter.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/RangeInputFilter.h	2016-03-04 15:54:04 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical Ltd
+ * Copyright (C) 2015 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License version 3 as
@@ -20,6 +20,7 @@
 
 #include <unity/scopes/FilterBase.h>
 #include <unity/scopes/Variant.h>
+#include <unity/scopes/FilterGroup.h>
 
 namespace unity
 {
@@ -34,11 +35,13 @@
 class RangeInputFilterImpl;
 }
 
-namespace experimental
-{
-
 /**
 \brief A range filter which allows a start and end value to be entered by user, and any of them is optional.
+
+RangeInputFilter is composed of two input boxes which accept numeric values. Any of them is optional. It can have
+up to five labels: two labels for start value (prefix or postfix label, displayed left or right to the input box, respectively),
+two labels for end value and a single label displayed in between both input boxes.
+The filter may provide defaults for start and end values. Default values are used by the UI if user didn't enter values.
 */
 class UNITY_API RangeInputFilter : public FilterBase
 {
@@ -50,30 +53,119 @@
     /**
     \brief Creates a RangeInputFilter.
     \param id A unique identifier for the filter that can be used to identify it later among several filters.
-    \param start_label A display label for the input box of start value (can be empty).
-    \param end_label A display label for the input box of end value (can be empty).
-    \param unit_label A display label for the unit of this range filter (e.g. currency name).
-    \return Instance of RangeInputFilter.
-    */
-    static RangeInputFilter::SPtr create(std::string const& id, std::string const& start_label, std::string const& end_label, std::string const& unit_label = "");
-
-    /**
-    \brief Get the label of start value.
-    \return The label of start value.
-    */
-    std::string start_label() const;
-
-    /**
-    \brief Get the label of end value.
-    \return The label of end value.
-    */
-    std::string end_label() const;
-
-    /**
-    \brief Get the label of unit for this filter..
-    \return The label of unit.
-    */
-    std::string unit_label() const;
+    \param start_prefix_label A display label for the input box of start value, displayed to the left (can be empty).
+    \param start_postfix_label A display label for the input box of start value, displayed to the right (can be empty).
+    \param central_label A display label displayed between the two input boxes (can be empty).
+    \param end_prefix_label A display label for the input box of end value, displayed to the left (can be empty).
+    \param end_postfix_label A display label for the input box of end value, displayed to the right (can be empty).
+    \return Instance of RangeInputFilter.
+    */
+    static RangeInputFilter::SPtr create(std::string const& id,
+            std::string const& start_prefix_label, std::string const& start_postfix_label,
+            std::string const& central_label,
+            std::string const& end_prefix_label, std::string const& end_postfix_label);
+
+    /**
+    \brief Creates a RangeInputFilter with specific default values for start and end.
+    \param id A unique identifier for the filter that can be used to identify it later among several filters.
+    \param default_start_value A default start value (double, int or null).
+    \param default_end_value A default end value (double, int or null).
+    \param start_prefix_label A display label for the input box of start value, displayed to the left (can be empty).
+    \param start_postfix_label A display label for the input box of start value, displayed to the right (can be empty).
+    \param central_label A display label displayed between the two input boxes (can be empty).
+    \param end_prefix_label A display label for the input box of end value, displayed to the left (can be empty).
+    \param end_postfix_label A display label for the input box of end value, displayed to the right (can be empty).
+    \return Instance of RangeInputFilter.
+    */
+    static RangeInputFilter::SPtr create(std::string const& id,
+            Variant const& default_start_value,
+            Variant const& default_end_value,
+            std::string const& start_prefix_label, std::string const& start_postfix_label,
+            std::string const& central_label,
+            std::string const& end_prefix_label, std::string const& end_postfix_label);
+
+    /**
+    \brief Creates a RangeInputFilter inside a FilterGroup.
+    \param id A unique identifier for the filter that can be used to identify it later among several filters.
+    \param start_prefix_label A display label for the input box of start value, displayed to the left (can be empty).
+    \param start_postfix_label A display label for the input box of start value, displayed to the right (can be empty).
+    \param central_label A display label displayed between the two input boxes (can be empty).
+    \param end_prefix_label A display label for the input box of end value, displayed to the left (can be empty).
+    \param end_postfix_label A display label for the input box of end value, displayed to the right (can be empty).
+    \param group A filter group this filter should be added to.
+    \return Instance of RangeInputFilter.
+    */
+    static RangeInputFilter::SPtr create(std::string const& id,
+            std::string const& start_prefix_label, std::string const& start_postfix_label,
+            std::string const& central_label,
+            std::string const& end_prefix_label, std::string const& end_postfix_label, FilterGroup::SCPtr const& group);
+
+    /**
+    \brief Creates a RangeInputFilter with specific default values for start and end, inside a FilterGroup.
+    \param id A unique identifier for the filter that can be used to identify it later among several filters.
+    \param start_prefix_label A display label for the input box of start value, displayed to the left (can be empty).
+    \param start_postfix_label A display label for the input box of start value, displayed to the right (can be empty).
+    \param central_label A display label displayed between the two input boxes (can be empty).
+    \param end_prefix_label A display label for the input box of end value, displayed to the left (can be empty).
+    \param end_postfix_label A display label for the input box of end value, displayed to the right (can be empty).
+    \param group A filter group this filter should be added to.
+    \return Instance of RangeInputFilter.
+    */
+    static RangeInputFilter::SPtr create(std::string const& id,
+            Variant const& default_start_value,
+            Variant const& default_end_value,
+            std::string const& start_prefix_label, std::string const& start_postfix_label,
+            std::string const& central_label,
+            std::string const& end_prefix_label, std::string const& end_postfix_label,
+            FilterGroup::SCPtr const& group);
+
+    /**
+    \brief Get the prefix label of start value.
+    \return The prefix label of start value.
+    */
+    std::string start_prefix_label() const;
+
+    /**
+    \brief Get the postfix label of start value.
+    \return The postfix label of start value.
+    */
+    std::string start_postfix_label() const;
+
+    /**
+    \brief Get the prefix label of end value.
+    \return The label of end value.
+    */
+    std::string end_prefix_label() const;
+
+    /**
+    \brief Get the postfix label of end value.
+    \return The label of end value.
+    */
+    std::string end_postfix_label() const;
+
+    /**
+    \brief Get the central label for this filter.
+    \return The central label.
+    */
+    std::string central_label() const;
+
+    /**
+    \brief Get default start value if set (int, double or null).
+
+    The default value should be used unless a value is present in the FilterState -
+    use unity::scopes::RangeInputFilter::has_start_value() and unity::scopes::RangeInputFilter::start_value()
+    before resorting to the default value.
+    */
+    Variant default_start_value() const;
+
+    /**
+    \brief Get default end value if set (int, double or null).
+
+    The default value should be used unless a value is present in the FilterState -
+    use unity::scopes::RangeInputFilter::has_end_value() and unity::scopes::RangeInputFilter::end_value()
+    before resorting to the default value.
+    */
+    Variant default_end_value() const;
 
     /**
     \brief Check if filter state holds a start value for this filter instance.
@@ -144,8 +236,6 @@
     friend class internal::RangeInputFilterImpl;
 };
 
-} // namespace experimental
-
 } // namespace scopes
 
 } // namespace unity

=== modified file 'include/unity/scopes/ValueSliderFilter.h'
--- include/unity/scopes/ValueSliderFilter.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/ValueSliderFilter.h	2016-03-04 15:54:04 +0000
@@ -19,6 +19,7 @@
 #pragma once
 
 #include <unity/scopes/FilterBase.h>
+#include <unity/scopes/FilterGroup.h>
 
 namespace unity
 {
@@ -33,16 +34,14 @@
 class ValueSliderFilterImpl;
 }
 
-namespace experimental
-{
+class ValueSliderLabels;
 
 /**
 \brief A value slider filter that allows for selecting a value within given range.
 
-The ValueSliderFilter displays a static label, such as "Maximum size" and a slider that
-allows for selecting a value within range defined by minimum and maximum values. The currently
-selected value gets displayed using a label template provided by scope, e.g. "Less than %1 MB",
-resulting in labels such as "Less than 40.5 MB".
+The ValueSliderFilter allows for selecting a value within range defined by minimum and maximum values.
+Both minimum and maximum values can have labels and in addition, the scope may provide extra labels
+to mark other values from that range - these label will serve as a guidance to the user.
 */
 class UNITY_API ValueSliderFilter : public FilterBase
 {
@@ -52,62 +51,52 @@
     /// @endcond
 
     /**
-     \brief The type of value slider.
-
-     The type should be set according to the behaviour of the filter:
-     ValueSliderFilter::SliderType::LessThan should be used if values lesser than selected value are to be returned, otherwise
-     ValueSliderFilter::SliderType::MoreThan should be used.
-     Note: the selected type is a display hint for the Shell only. It's up to the scope to set it properly and actually follow
-     it on search.
-     */
-    enum SliderType
-    {
-        LessThan, /**< Scope will search for values lesser than selected value */
-        MoreThan  /**< Scope will search for values greater than selected value */
-    };
-
-    /**
      \brief Create ValueSliderFilter.
 
      Creates ValueSliderFilter of ValueSliderFilter::SliderType::LessThan type.
 
      \param id A unique identifier for the filter that can be used to identify it later among several filters.
-     \param label The label for the filter
-     \param label_template The template for value label, e.g. "Less than %1"
      \param min The minimum allowed value
      \param max The maximum allowed value
+     \param default_value The default value of this filter, from the min..max range.
+     \param value_labels The labels for min and max values as well as optional extra labels.
      \return Instance of ValueSliderFilter.
-     \throws unity::LogicException on invalid (min, max) range.
+     \throws unity::LogicException on invalid (min, max) range or erroneous value_labels.
     */
-    static ValueSliderFilter::UPtr create(std::string const& id, std::string const& label, std::string const& label_template, double min, double max);
+    static ValueSliderFilter::UPtr create(std::string const& id, double min, double max, double default_value, ValueSliderLabels const& value_labels);
 
     /**
-     \brief Change the type of this filter.
-
-     \param tp The type of slider filter.
-     */
-    void set_slider_type(SliderType tp);
+     \brief Create ValueSliderFilter inside a FilterGroup.
+
+     Creates ValueSliderFilter of ValueSliderFilter::SliderType::LessThan type.
+
+     \param id A unique identifier for the filter that can be used to identify it later among several filters.
+     \param min The minimum allowed value
+     \param max The maximum allowed value
+     \param default_value The default value of this filter, from the min..max range.
+     \param value_labels The labels for min and max values as well as optional extra labels.
+     \param group A filter group this filter should be added to.
+     \return Instance of ValueSliderFilter.
+     \throws unity::LogicException on invalid (min, max) range or erroneous value_labels.
+    */
+    static ValueSliderFilter::UPtr create(std::string const& id, double min, double max, double default_value, ValueSliderLabels const& value_labels, FilterGroup::SCPtr const& group);
 
     /**
      \brief Change the default value of this filter.
 
-     The default value of this filter is by default the maximum value allowed. This value is used when calling unity::scopes::ValueSliderFilter::value_label()
-     and there is no state for this filter in unity::scopes::FilterState.
+     The default value will be used by the shell if no value is present for this filter in the
+     unity::scopes::FilterState (no value has been set by the user).
 
      \param val The new default value.
     */
     void set_default_value(double val);
 
     /**
-     \brief Get the type of this filter.
-
-     \return The type of slider filter.
-     */
-    SliderType slider_type() const;
-
-    /**
      \brief Get the default value of this filter.
 
+     The default value will be used by the shell if no value is present for this filter in the
+     unity::scopes::FilterState (no value has been set by the user).
+
      \return The default value
     */
     double default_value() const;
@@ -127,20 +116,6 @@
     double max() const;
 
     /**
-    \brief Get the label of this filter.
-
-    \return The label
-    */
-    std::string label() const;
-
-    /**
-     \brief Get the value label template of this filter.
-
-     \return The value label template.
-     */
-    std::string value_label_template() const;
-
-    /**
     \brief Check if filter state object holds a value of this filter.
 
     \return true if filter_state has a value of this filter.
@@ -156,6 +131,13 @@
     double value(FilterState const& filter_state) const;
 
     /**
+     \brief Get value labeles for this slider filter.
+
+     \return the value labels.
+     */
+    ValueSliderLabels const& labels() const;
+
+    /**
     \brief Sets value of this filter instance in filter state object.
 
     This is meant to be used to modify a FilterState received with a search request before sending it back to the client (UI shell).
@@ -178,8 +160,6 @@
     friend class internal::ValueSliderFilterImpl;
 };
 
-} // namespace experimental
-
 } // namespace scopes
 
 } // namespace unity

=== added file 'include/unity/scopes/ValueSliderLabels.h'
--- include/unity/scopes/ValueSliderLabels.h	1970-01-01 00:00:00 +0000
+++ include/unity/scopes/ValueSliderLabels.h	2016-03-04 15:54:04 +0000
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+ */
+
+#pragma once
+
+#include <string>
+#include <list>
+#include <memory>
+#include <unity/SymbolExport.h>
+#include <unity/scopes/Variant.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+class ValueSliderFilterImpl;
+class ValueSliderLabelsImpl;
+}
+
+/// @cond
+typedef std::pair<double, std::string> ValueLabelPair;
+typedef std::vector<ValueLabelPair> ValueLabelPairList;
+/// @endcond
+
+/**
+\brief Labels used by a ValueSliderFilter.
+
+The ValueSliderLabels objects holds labels for a ValueSliderFilter. At the very least labels for minimum and maximum
+values need to be provided. In addition, an arbitrary number of extra labels can be defined to mark values between minimum and maximum values.
+*/
+class UNITY_API ValueSliderLabels final
+{
+public:
+    /**@name Copy and assignment
+    Copy and assignment (move and non-move versions) have the usual value semantics.
+    */
+    //{@
+    ValueSliderLabels(ValueSliderLabels const& other);
+    ValueSliderLabels(ValueSliderLabels&&);
+    ValueSliderLabels& operator=(ValueSliderLabels const& other);
+    ValueSliderLabels& operator=(ValueSliderLabels&&);
+    ~ValueSliderLabels();
+    //@}
+
+    /**
+      \brief Create ValueSliderLabels object with labels for minimum and maximum values only.
+
+      \throws unity::InvalidArgumentException on invalid (empty or duplicated) labels.
+     */
+    ValueSliderLabels(std::string const& min_label, std::string const& max_label);
+
+    /**
+      \brief Create ValueSliderLabels object with labels for minimum and maximum, as well as extra labels.
+
+      Create ValueSliderLabels object with labels for minimum, maximum and values between minimum and maximum.
+      Note that these extra labels act only as a guidance for the user (i.e. they do not limit the available choices)
+      and also Unity shell is free to omit some or all of them depending on the available screen space.
+
+      \param min_label The label for minimum value of the associated ValueSliderFilter filter.
+      \param max_label The label for maximum value of the associated ValueSliderFilter filter.
+      \param extra_labels Additional labels for values between minimum and maximum values.
+
+      \throws unity::InvalidArgumentException on invalid labels (empty or duplicate labels, non-increasing values).
+     */
+    ValueSliderLabels(std::string const& min_label, std::string const& max_label, ValueLabelPairList const& extra_labels);
+
+    /**
+     \brief Get the label for the minimum value of the filter.
+     \return The label for minimum value
+     */
+    std::string min_label() const;
+
+    /**
+     \brief Get the label for the maximum value of the filter.
+     \return The label for maximum value
+     */
+    std::string max_label() const;
+
+    /**
+     \brief Get the labels for intermediate values of the filter.
+     */
+    ValueLabelPairList extra_labels() const;
+
+    /// @cond
+    VariantMap serialize() const;
+    /// @endcond
+
+private:
+    ValueSliderLabels(internal::ValueSliderLabelsImpl* pimpl);
+    ValueSliderLabels(VariantMap const& var);
+    std::unique_ptr<internal::ValueSliderLabelsImpl> p;
+    friend class internal::ValueSliderLabelsImpl;
+    friend class internal::ValueSliderFilterImpl;
+};
+
+} // namespace scopes
+
+} // namespace unity

=== modified file 'include/unity/scopes/internal/ChildScopesRepository.h'
--- include/unity/scopes/internal/ChildScopesRepository.h	2015-04-01 10:15:25 +0000
+++ include/unity/scopes/internal/ChildScopesRepository.h	2016-03-04 15:54:04 +0000
@@ -43,7 +43,7 @@
     NONCOPYABLE(ChildScopesRepository);
 
     ChildScopesRepository(std::string const& repo_file_path,
-                          boost::log::sources::severity_channel_logger_mt<>& logger);
+                          unity::scopes::internal::Logger& logger);
 
     ChildScopeList child_scopes(ChildScopeList const& child_scopes_defaulted);
     bool set_child_scopes(ChildScopeList const& child_scopes);
@@ -56,7 +56,7 @@
     ChildScopeEnabledMap json_to_list(std::string const& child_scopes_json);
 
     std::string const repo_file_path_;
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
+    unity::scopes::internal::Logger& logger_;
 
     std::mutex mutex_;
     ChildScopeEnabledMap cached_repo_;

=== modified file 'include/unity/scopes/internal/DfltConfig.h.in'
--- include/unity/scopes/internal/DfltConfig.h.in	2015-12-09 05:43:13 +0000
+++ include/unity/scopes/internal/DfltConfig.h.in	2016-03-04 15:54:04 +0000
@@ -57,10 +57,6 @@
 static constexpr char const* DFLT_HOME_CACHE_SUBDIR = ".local/share/unity-scopes";
 static constexpr char const* DFLT_HOME_APP_SUBDIR = ".local/share";
 static constexpr char const* DFLT_HOME_CONFIG_SUBDIR = ".config/unity-scopes";
-static constexpr char const* DFLT_HOME_LOG_SUBDIR = "";
-
-static constexpr int DFLT_MAX_LOG_FILE_SIZE = 512 * 1024;       // bytes, individual file size
-static constexpr int DFLT_MAX_LOG_DIR_SIZE = 2 * 1024 * 1024;   // bytes, sum of file sizes
 
 static constexpr bool DFLT_LOCATION_PERMITTED = true;    // Whether a scope that wants location data, but does not
                                                          // have a settings.ini file yet, actually gets the data.

=== modified file 'include/unity/scopes/internal/FilterBaseImpl.h'
--- include/unity/scopes/internal/FilterBaseImpl.h	2015-11-12 14:20:36 +0000
+++ include/unity/scopes/internal/FilterBaseImpl.h	2016-03-04 15:54:04 +0000
@@ -20,7 +20,9 @@
 
 #include <unity/scopes/Variant.h>
 #include <unity/scopes/FilterBase.h>
+#include <unity/scopes/FilterGroup.h>
 #include <string>
+#include <map>
 
 namespace unity
 {
@@ -40,12 +42,16 @@
     virtual ~FilterBaseImpl();
     void set_display_hints(int hints);
     std::string id() const;
+    void set_title(std::string const& title);
+    std::string title() const;
     int display_hints() const;
+    void add_to_filter_group(FilterGroup::SCPtr const& group);
+    FilterGroup::SCPtr filter_group() const;
     VariantMap serialize() const;
     virtual std::string filter_type() const = 0;
     static FilterBase::SCPtr deserialize(VariantMap const& var);
     static VariantArray serialize_filters(Filters const& filters);
-    static Filters deserialize_filters(VariantArray const& var);
+    static Filters deserialize_filters(VariantArray const& var, std::map<std::string, FilterGroup::SCPtr> const& groups);
     static void validate_filters(Filters const& filters);
     virtual void validate_display_hints() const = 0;
 
@@ -56,7 +62,9 @@
 
 private:
     std::string id_;
+    std::string title_;
     int display_hints_;
+    FilterGroup::SCPtr filter_group_;
 };
 
 } // namespace internal

=== added file 'include/unity/scopes/internal/FilterGroupImpl.h'
--- include/unity/scopes/internal/FilterGroupImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/scopes/internal/FilterGroupImpl.h	2016-03-04 15:54:04 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+ */
+
+#pragma once
+
+#include <string>
+#include <map>
+#include <unity/scopes/Variant.h>
+#include <unity/scopes/FilterBase.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+class FilterState;
+
+namespace internal
+{
+
+class FilterGroupImpl
+{
+public:
+    FilterGroupImpl(std::string const& id, std::string const& label);
+    std::string id() const;
+    std::string label() const;
+    static VariantArray serialize_filter_groups(Filters const& filters);
+    static std::map<std::string, FilterGroup::SCPtr> deserialize_filter_groups(VariantArray const& var);
+
+private:
+    std::string id_;
+    std::string label_;
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace unity

=== modified file 'include/unity/scopes/internal/FilterOptionImpl.h'
--- include/unity/scopes/internal/FilterOptionImpl.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/FilterOptionImpl.h	2016-03-04 15:54:04 +0000
@@ -35,10 +35,13 @@
     FilterOptionImpl(std::string const& id, std::string const& label);
     std::string id() const;
     std::string label() const;
+    void set_default_value(bool default_value);
+    bool default_value() const;
 
 private:
     std::string id_;
     std::string label_;
+    bool default_value_;
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/Logger.h'
--- include/unity/scopes/internal/Logger.h	2014-12-10 04:00:08 +0000
+++ include/unity/scopes/internal/Logger.h	2016-03-04 15:54:04 +0000
@@ -20,18 +20,11 @@
 
 #include <unity/util/DefinesPtrs.h>
 #include <unity/util/NonCopyable.h>
-#include <unity/util/ResourcePtr.h>
-
-#define BOOST_LOG_DYN_LINK
-
-#include <boost/log/sinks.hpp>
-#include <boost/log/sources/global_logger_storage.hpp>
-#include <boost/log/sources/record_ostream.hpp>
-#include <boost/log/sources/severity_channel_logger.hpp>
-#include <boost/log/utility/value_ref.hpp>
-
+
+#include <array>
 #include <atomic>
-#include <unordered_map>
+#include <iostream>
+#include <sstream>
 
 namespace unity
 {
@@ -42,18 +35,58 @@
 namespace internal
 {
 
-namespace
+enum class LoggerSeverity { Info, Warning, Error, Fatal, Trace };
+
+enum class LoggerChannel { DefaultChannel, IPC, LastChannelEnum_ };
+
+class Logger;
+
+class LogStream : public std::ostringstream
 {
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-
-BOOST_LOG_ATTRIBUTE_KEYWORD(severity, "Severity", int)
-BOOST_LOG_ATTRIBUTE_KEYWORD(channel, "Channel", std::string)
-
-#pragma GCC diagnostic pop
-
-}
+public:
+    NONCOPYABLE(LogStream);
+    UNITY_DEFINES_PTRS(LogStream);
+
+#if __GNUC__ == 4
+    // gcc 4.9 doesn't have a move constructor for ostringstream:
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54316
+    // We simulate the move with a copy and clear.
+    LogStream(LogStream&& other)
+        : id_(std::move(other.id_))
+        , outstream_(other.outstream_)
+        , severity_(other.severity_)
+        , channel_(other.channel_)
+    {
+        *this << other.str();
+        other.str("");
+        other.clear();
+    }
+#else
+    // We need an explicit move constructor because basic_ios does not have a move
+    // constructor. Instead, it has a protected move() method that ostringstream calls
+    // as part if its move constructor.
+    LogStream(LogStream&& other)
+        : std::ostringstream(std::move(other))
+        , id_(std::move(other.id_))
+        , outstream_(other.outstream_)
+        , severity_(other.severity_)
+        , channel_(other.channel_)
+    {
+    }
+#endif
+
+    LogStream& operator=(LogStream&&) = delete;  // Move assignment is impossible due to reference member.
+
+    LogStream();
+    LogStream(std::ostream& outstream, std::string const& id, LoggerSeverity s, LoggerChannel c);
+    ~LogStream();
+
+private:
+    std::string const id_;
+    std::ostream& outstream_;
+    LoggerSeverity severity_;
+    LoggerChannel channel_;
+};
 
 class Logger
 {
@@ -61,57 +94,42 @@
     NONCOPYABLE(Logger);
     UNITY_DEFINES_PTRS(Logger);
 
-    // Instantiate a logger that logs to std::clog.
-    Logger(std::string const& id);
-    ~Logger();
-
-    enum Channel
+    // We need an explicit move constructor because atomics are not movable.
+    Logger(Logger&& other)
+        : id_(move(other.id_))
+        , outstream_(other.outstream_)
     {
-        IPC,
-        LastChannelEnum_
-    };
-
-    // Returns default logger (no channel)
-    operator boost::log::sources::severity_channel_logger_mt<>&();
-
-    // Returns logger for specified channel.
-    boost::log::sources::severity_channel_logger_mt<>& operator()(Channel c);
-
-    void set_log_file(std::string const& path, int rotation_size, int dir_size);
-
-    enum Severity { Info, Warning, Error, Fatal, Trace };
-    Severity set_severity_threshold(Severity s);
-
-    bool set_channel(Channel c, bool enable);
+        severity_threshold_.exchange(other.severity_threshold_);
+        for (unsigned i = 0; i < other.enabled_.size(); ++i)
+        {
+            enabled_[i].exchange(other.enabled_[i]);
+        }
+    }
+
+    Logger& operator=(Logger&&) = delete;  // Move assignment is impossible due to reference member.
+
+    // Instantiate a logger that logs to the given stream.
+    Logger(std::string const& id, std::ostream& outstream = std::clog);
+
+    // Returns default writer for severity Error on the default channel.
+    LogStream operator()();
+
+    // Returns writer for specified severity.
+    LogStream operator()(LoggerSeverity s);
+
+    // Returns writer for specified channel.
+    LogStream operator()(LoggerChannel c);
+
+    LoggerSeverity set_severity_threshold(LoggerSeverity s);
+
+    bool set_channel(LoggerChannel c, bool enable);
     bool set_channel(std::string channel_name, bool enable);
-    void enable_channels(std::vector<std::string> const& names);
 
 private:
-    bool filter(boost::log::value_ref<int, tag::severity> const& level,
-                boost::log::value_ref<std::string, tag::channel> const& channel);
-
-    void formatter(boost::log::record_view const& rec,
-                   boost::log::formatting_ostream& strm);
-
-    std::string scope_id_;  // immutable
-
-    boost::log::sources::severity_channel_logger_mt<> logger_;  // Default logger, no channel, immutable
-
-    std::atomic<Severity> severity_;
-
-    typedef boost::log::sinks::asynchronous_sink<boost::log::sinks::text_ostream_backend> ClogSinkT;
-    typedef boost::shared_ptr<ClogSinkT> ClogSinkPtr;
-    ClogSinkPtr clog_sink_;
-
-    typedef boost::log::sinks::asynchronous_sink<boost::log::sinks::text_file_backend> FileSinkT;
-    typedef boost::shared_ptr<FileSinkT> FileSinkPtr;
-    FileSinkPtr file_sink_;
-
-    typedef std::pair<boost::log::sources::severity_channel_logger_mt<>, std::atomic_bool> ChannelData;
-    typedef std::unordered_map<std::string, ChannelData> ChannelMap;
-    ChannelMap channel_loggers_;  // immutable
-
-    std::mutex mutex_;  // Protects clog_sink_ and file_sink_
+    std::string const id_;
+    std::ostream& outstream_;
+    std::atomic<LoggerSeverity> severity_threshold_;
+    std::array<std::atomic_bool, int(LoggerChannel::LastChannelEnum_)> enabled_;
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/OptionSelectorFilterImpl.h'
--- include/unity/scopes/internal/OptionSelectorFilterImpl.h	2015-11-12 14:20:36 +0000
+++ include/unity/scopes/internal/OptionSelectorFilterImpl.h	2016-03-04 15:54:04 +0000
@@ -42,7 +42,7 @@
     OptionSelectorFilterImpl(VariantMap const& var);
     std::string label() const;
     bool multi_select() const;
-    virtual FilterOption::SCPtr add_option(std::string const& id, std::string const& label);
+    virtual FilterOption::SCPtr add_option(std::string const& id, std::string const& label, bool default_value = false);
     std::list<FilterOption::SCPtr> options() const;
     int num_of_options() const;
     std::set<FilterOption::SCPtr> active_options(FilterState const& filter_state) const;

=== modified file 'include/unity/scopes/internal/RangeInputFilterImpl.h'
--- include/unity/scopes/internal/RangeInputFilterImpl.h	2015-11-12 14:20:36 +0000
+++ include/unity/scopes/internal/RangeInputFilterImpl.h	2016-03-04 15:54:04 +0000
@@ -30,18 +30,25 @@
 namespace internal
 {
 
-using namespace experimental;
-
 class RangeInputFilterImpl : public FilterBaseImpl
 {
 public:
-    RangeInputFilterImpl(std::string const& id, std::string const& start_label, std::string const& end_label, std::string const& unit_label);
+    RangeInputFilterImpl(std::string const& id,
+            Variant const& default_start_value, Variant const& default_end_value,
+            std::string const& start_prefix_label, std::string const& start_postfix_label,
+            std::string const& central_label,
+            std::string const& end_prefix_label, std::string const& end_postfix_label);
+
     RangeInputFilterImpl(VariantMap const& var);
 
-    std::string start_label() const;
-    std::string end_label() const;
-    std::string unit_label() const;
+    std::string start_prefix_label() const;
+    std::string start_postfix_label() const;
+    std::string end_prefix_label() const;
+    std::string end_postfix_label() const;
+    std::string central_label() const;
 
+    Variant default_start_value() const;
+    Variant default_end_value() const;
     bool has_start_value(FilterState const& filter_state) const;
     bool has_end_value(FilterState const& filter_state) const;
     double start_value(FilterState const& filter_state) const;
@@ -64,9 +71,13 @@
     double get_value(FilterState const& filter_state, unsigned int index) const;
     static void check_type(Variant const& val, std::string const& filter_id, std::string const& varname);
 
-    std::string start_label_;
-    std::string end_label_;
-    std::string unit_label_;
+    Variant default_start_value_;
+    Variant default_end_value_;
+    std::string start_prefix_label_;
+    std::string start_postfix_label_;
+    std::string end_prefix_label_;
+    std::string end_postfix_label_;
+    std::string central_label_;
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/RatingFilterImpl.h'
--- include/unity/scopes/internal/RatingFilterImpl.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/RatingFilterImpl.h	2016-03-04 15:54:04 +0000
@@ -31,6 +31,8 @@
 {
 
 using namespace experimental;
+// FIXME: reconsider using FilterOption and RadioButtonsFilterImpl as a base when moving this filter out from experimental namespace,
+// the default values of individual FilterOption don't make much sense with RatingFilter.
 
 class RatingFilterImpl : public RadioButtonsFilterImpl
 {
@@ -38,7 +40,8 @@
     RatingFilterImpl(std::string const& id, std::string const& label);
     RatingFilterImpl(std::string const& id, std::string const& label, int top_rating);
     RatingFilterImpl(VariantMap const& var);
-    FilterOption::SCPtr add_option(std::string const& id, std::string const& label) override;
+
+    FilterOption::SCPtr add_option(std::string const& id, std::string const& label, bool default_value = false) override;
     void set_on_icon(std::string const& on_icon);
     void set_off_icon(std::string const& off_icon);
     std::string on_icon() const;

=== modified file 'include/unity/scopes/internal/RegistryObject.h'
--- include/unity/scopes/internal/RegistryObject.h	2015-12-08 01:02:15 +0000
+++ include/unity/scopes/internal/RegistryObject.h	2016-03-04 15:54:04 +0000
@@ -100,7 +100,7 @@
 
         ScopeProcess(ScopeExecData exec_data,
                      std::weak_ptr<MWPublisher> const& publisher,
-                     boost::log::sources::severity_channel_logger_mt<>& logger);
+                     unity::scopes::internal::Logger& logger);
         ~ScopeProcess();
 
         ProcessState state() const;
@@ -131,12 +131,12 @@
         core::posix::ChildProcess process_ = core::posix::ChildProcess::invalid();
         std::weak_ptr<MWPublisher> reg_publisher_; // weak_ptr, so processes don't hold publisher alive
         bool manually_started_;
-        boost::log::sources::severity_channel_logger_mt<>& logger_;
+        unity::scopes::internal::Logger& logger_;
     };
 
 private:
     std::unique_ptr<unity::scopes::internal::Logger> test_logger_;
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
+    unity::scopes::internal::Logger& logger_;
 
     core::posix::ChildProcess::DeathObserver& death_observer_;
     core::ScopedConnection death_observer_connection_;

=== modified file 'include/unity/scopes/internal/RuntimeConfig.h'
--- include/unity/scopes/internal/RuntimeConfig.h	2014-12-10 03:18:53 +0000
+++ include/unity/scopes/internal/RuntimeConfig.h	2016-03-04 15:54:04 +0000
@@ -47,15 +47,11 @@
     std::string cache_directory() const;
     std::string app_directory() const;
     std::string config_directory() const;
-    std::string log_directory() const;
-    int max_log_file_size() const;
-    int max_log_dir_size() const;
     std::vector<std::string> trace_channels() const;
 
     static std::string default_cache_directory();
     static std::string default_app_directory();
     static std::string default_config_directory();
-    static std::string default_log_directory();
 
 private:
     std::string registry_identity_;
@@ -69,9 +65,6 @@
     std::string cache_directory_;
     std::string app_directory_;
     std::string config_directory_;
-    std::string log_directory_;
-    int max_log_file_size_;
-    int max_log_dir_size_;
     std::vector<std::string> trace_channels_;
 };
 

=== modified file 'include/unity/scopes/internal/RuntimeImpl.h'
--- include/unity/scopes/internal/RuntimeImpl.h	2015-03-02 03:59:01 +0000
+++ include/unity/scopes/internal/RuntimeImpl.h	2016-03-04 15:54:04 +0000
@@ -53,8 +53,7 @@
     Reaper::SPtr reply_reaper() const;
     ThreadPool::SPtr async_pool() const;
     ThreadSafeQueue<std::future<void>>::SPtr future_queue() const;
-    boost::log::sources::severity_channel_logger_mt<>& logger() const;
-    boost::log::sources::severity_channel_logger_mt<>& logger(Logger::Channel channel) const;
+    unity::scopes::internal::Logger& logger() const;
     void run_scope(ScopeBase* scope_base,
                    std::string const& scope_ini_file,
                    std::promise<void> ready_promise = std::promise<void>());

=== modified file 'include/unity/scopes/internal/ValueSliderFilterImpl.h'
--- include/unity/scopes/internal/ValueSliderFilterImpl.h	2015-11-12 14:20:36 +0000
+++ include/unity/scopes/internal/ValueSliderFilterImpl.h	2016-03-04 15:54:04 +0000
@@ -20,6 +20,8 @@
 
 #include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/ValueSliderFilter.h>
+#include <unity/scopes/ValueSliderLabels.h>
+#include <unity/scopes/internal/ValueSliderLabelsImpl.h>
 
 namespace unity
 {
@@ -32,24 +34,19 @@
 namespace internal
 {
 
-using namespace experimental;
-
 class ValueSliderFilterImpl : public FilterBaseImpl
 {
 public:
-    ValueSliderFilterImpl(std::string const& id, std::string const& label, std::string const& label_template, double min, double max);
+    ValueSliderFilterImpl(std::string const& id, double min, double max, double default_value, ValueSliderLabels const& labels);
     ValueSliderFilterImpl(VariantMap const& var);
-    void set_slider_type(ValueSliderFilter::SliderType tp);
-    ValueSliderFilter::SliderType slider_type() const;
     void set_default_value(double val);
-    std::string label() const;
     double min() const;
     double max() const;
     double default_value() const;
-    std::string value_label_template() const;
     bool has_value(FilterState const& filter_state) const;
     double value(FilterState const& filter_state) const;
     void update_state(FilterState& filter_state, double value) const;
+    ValueSliderLabels const& labels() const;
     static ValueSliderFilter::SPtr create(VariantMap const& var);
     static void update_state(FilterState& filter_state, std::string const& filter_id, double value);
     void validate_display_hints() const override;
@@ -61,12 +58,10 @@
     void check_range(double val) const;
 
 private:
-    std::string label_;
-    std::string label_template_;
-    ValueSliderFilter::SliderType slider_type_;
-    double default_val_;
     double min_;
     double max_;
+    double default_val_;
+    std::unique_ptr<ValueSliderLabels> labels_;
 };
 
 } // namespace internal

=== added file 'include/unity/scopes/internal/ValueSliderLabelsImpl.h'
--- include/unity/scopes/internal/ValueSliderLabelsImpl.h	1970-01-01 00:00:00 +0000
+++ include/unity/scopes/internal/ValueSliderLabelsImpl.h	2016-03-04 15:54:04 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/scopes/ValueSliderLabels.h>
+#include <unity/scopes/Variant.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class ValueSliderLabelsImpl
+{
+public:
+    ValueSliderLabelsImpl(std::string const& min_label, std::string const& max_label);
+    ValueSliderLabelsImpl(std::string const& min_label, std::string const& max_label, std::vector<std::pair<double, std::string>> const& extra_labels);
+    ValueSliderLabelsImpl(VariantMap const& var);
+    ValueSliderLabelsImpl(ValueSliderLabelsImpl const&) = default;
+
+    std::string min_label() const;
+    std::string max_label() const;
+    std::vector<std::pair<double, std::string>> extra_labels() const;
+    VariantMap serialize() const;
+    void deserialize(VariantMap const& var);
+
+    void validate(double min, double max) const;
+
+private:
+    std::string min_label_;
+    std::string max_label_;
+    std::vector<std::pair<double, std::string>> extra_labels_;
+};
+
+}
+
+}
+
+}

=== modified file 'include/unity/scopes/internal/smartscopes/SmartScopesClient.h'
--- include/unity/scopes/internal/smartscopes/SmartScopesClient.h	2015-12-08 01:02:15 +0000
+++ include/unity/scopes/internal/smartscopes/SmartScopesClient.h	2016-03-04 15:54:04 +0000
@@ -20,6 +20,7 @@
 
 #include <unity/scopes/FilterBase.h>
 #include <unity/scopes/FilterState.h>
+#include <unity/scopes/FilterGroup.h>
 #include <unity/scopes/internal/JsonNodeInterface.h>
 #include <unity/scopes/internal/Logger.h>
 #include <unity/scopes/internal/smartscopes/HttpClientInterface.h>
@@ -27,12 +28,13 @@
 
 #include <unity/util/NonCopyable.h>
 
-#include <string>
-#include <vector>
 #include <map>
 #include <memory>
 #include <mutex>
+#include <set>
+#include <string>
 #include <tuple>
+#include <vector>
 
 namespace unity
 {
@@ -152,6 +154,8 @@
     std::function<void(std::shared_ptr<DepartmentInfo> const&)> departments_handler;
     std::function<void(Filters const&)> filters_handler;
     std::function<void(FilterState const&)> filter_state_handler;
+
+    std::map<std::string, FilterGroup::SCPtr> filter_groups;
 };
 
 struct PreviewReplyHandler
@@ -179,7 +183,7 @@
 
     bool get_remote_scopes(std::vector<RemoteScope>& scopes, std::string const& locale = "", bool caching_enabled = true);
 
-    SearchHandle::UPtr search(SearchReplyHandler const& handler,
+    SearchHandle::UPtr search(SearchReplyHandler& handler,
                               std::string const& base_url,
                               std::string const& query,
                               std::string const& department_id,
@@ -204,7 +208,7 @@
                                 std::string const& country = "",
                                 std::string const& user_agent_hdr = "");
 
-    boost::log::sources::severity_channel_logger_mt<>& logger() const;
+    unity::scopes::internal::Logger& logger() const;
 
 private:
     friend class SearchHandle;
@@ -213,11 +217,12 @@
     void wait_for_search(unsigned int search_id);
     void wait_for_preview(unsigned int preview_id);
     std::shared_ptr<DepartmentInfo> parse_departments(JsonNodeInterface::SPtr node);
-    Filters parse_filters(JsonNodeInterface::SPtr node);
+    std::map<std::string, FilterGroup::SCPtr> parse_filter_groups(JsonNodeInterface::SPtr node);
+    Filters parse_filters(JsonNodeInterface::SPtr node, std::map<std::string, FilterGroup::SCPtr> const& filter_groups);
     FilterState parse_filter_state(JsonNodeInterface::SPtr node);
 
     std::string handle_chunk(const std::string& chunk, std::function<void(const std::string&)> line_handler);
-    void handle_line(std::string const& json, SearchReplyHandler const& handler);
+    void handle_line(std::string const& json, SearchReplyHandler& handler);
     void handle_line(std::string const& json, PreviewReplyHandler const& handler);
 
     std::vector<std::string> extract_json_stream(std::string const& json_stream);
@@ -232,7 +237,7 @@
     HttpClientInterface::SPtr http_client_;
     JsonNodeInterface::SPtr json_node_;
     std::unique_ptr<unity::scopes::internal::Logger> test_logger_;
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
+    unity::scopes::internal::Logger& logger_;
     std::string url_;
 
     std::map<unsigned int, HttpResponseHandle::SPtr> query_results_;

=== modified file 'include/unity/scopes/internal/zmq_middleware/ObjectAdapter.h'
--- include/unity/scopes/internal/zmq_middleware/ObjectAdapter.h	2015-12-08 01:02:15 +0000
+++ include/unity/scopes/internal/zmq_middleware/ObjectAdapter.h	2016-03-04 15:54:04 +0000
@@ -109,8 +109,7 @@
 
     void store_exception(scopes::MiddlewareException& ex);
 
-    boost::log::sources::severity_channel_logger_mt<>& logger() const;
-    boost::log::sources::severity_channel_logger_mt<>& ipc_logger() const;
+    unity::scopes::internal::Logger& logger() const;
 
     void trace_dispatch(Current const& c);
     void trace_response();

=== modified file 'include/unity/scopes/internal/zmq_middleware/ZmqMiddleware.h'
--- include/unity/scopes/internal/zmq_middleware/ZmqMiddleware.h	2015-12-08 01:02:15 +0000
+++ include/unity/scopes/internal/zmq_middleware/ZmqMiddleware.h	2016-03-04 15:54:04 +0000
@@ -135,7 +135,7 @@
     mutable std::mutex state_mutex_;            // Protects state_
     std::atomic_bool shutdown_flag_;
     std::unique_ptr<unity::scopes::internal::Logger> test_logger_;
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
+    unity::scopes::internal::Logger& logger_;
 
     int64_t twoway_timeout_;                    // Default timeout for twoway invocations
     int64_t locate_timeout_;                    // Timeout for registry locate()

=== modified file 'scoperegistry/DirWatcher.cpp'
--- scoperegistry/DirWatcher.cpp	2015-01-07 02:24:43 +0000
+++ scoperegistry/DirWatcher.cpp	2016-03-04 15:54:04 +0000
@@ -32,7 +32,7 @@
 namespace scoperegistry
 {
 
-DirWatcher::DirWatcher(boost::log::sources::severity_channel_logger_mt<>& logger)
+DirWatcher::DirWatcher(Logger& logger)
     : fd_(inotify_init())
     , thread_state_(Running)
     , thread_exception_(nullptr)
@@ -137,11 +137,11 @@
             }
             catch (std::exception const& e)
             {
-                BOOST_LOG(logger_) << "~DirWatcher(): " << e.what();
+                logger_() << "~DirWatcher(): " << e.what();
             }
             catch (...)
             {
-                BOOST_LOG(logger_) << "~DirWatcher(): watch_thread was aborted due to an unknown exception";
+                logger_() << "~DirWatcher(): watch_thread was aborted due to an unknown exception";
             }
         }
         else
@@ -283,14 +283,14 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(logger_) << "DirWatcher::watch_thread(): " << e.what();
+        logger_() << "DirWatcher::watch_thread(): " << e.what();
         std::lock_guard<std::mutex> lock(mutex_);
         thread_state_ = Failed;
         thread_exception_ = std::current_exception();
     }
     catch (...)
     {
-        BOOST_LOG(logger_) << "DirWatcher::watch_thread(): Thread aborted: unknown exception";
+        logger_() << "DirWatcher::watch_thread(): Thread aborted: unknown exception";
         std::lock_guard<std::mutex> lock(mutex_);
         thread_state_ = Failed;
         thread_exception_ = std::current_exception();

=== modified file 'scoperegistry/DirWatcher.h'
--- scoperegistry/DirWatcher.h	2014-11-24 05:06:00 +0000
+++ scoperegistry/DirWatcher.h	2016-03-04 15:54:04 +0000
@@ -48,7 +48,7 @@
         Directory
     };
 
-    DirWatcher(boost::log::sources::severity_channel_logger_mt<>& logger);
+    DirWatcher(unity::scopes::internal::Logger& logger);
     virtual ~DirWatcher();
 
     void add_watch(std::string const& path);
@@ -73,7 +73,7 @@
     std::mutex mutex_;
     ThreadState thread_state_;
     std::exception_ptr thread_exception_;
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
+    unity::scopes::internal::Logger& logger_;
 
     void watch_thread();
     virtual void watch_event(EventType, FileType, std::string const&) = 0;

=== modified file 'scoperegistry/ScopesWatcher.cpp'
--- scoperegistry/ScopesWatcher.cpp	2015-01-20 06:18:36 +0000
+++ scoperegistry/ScopesWatcher.cpp	2016-03-04 15:54:04 +0000
@@ -35,7 +35,7 @@
 
 ScopesWatcher::ScopesWatcher(RegistryObject::SPtr registry,
                              std::function<void(std::pair<std::string, std::string> const&)> ini_added_callback,
-                             boost::log::sources::severity_channel_logger_mt<>& logger)
+                             Logger& logger)
     : DirWatcher(logger)
     , registry_(registry)
     , ini_added_callback_(ini_added_callback)
@@ -60,7 +60,7 @@
         catch (unity::LogicException const&) {} // Ignore already exists exception
         catch (unity::SyscallException const& e)
         {
-            BOOST_LOG(logger_) << "ScopesWatcher::add_install_dir(): parent dir watch: " << e.what();
+            logger_() << "ScopesWatcher::add_install_dir(): parent dir watch: " << e.what();
         }
 
         // Create a new entry for this install dir into idir_to_sdirs_map_
@@ -101,11 +101,11 @@
     }
     catch (unity::ResourceException const& e)
     {
-        BOOST_LOG(logger_) << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
+        logger_() << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
     }
     catch (unity::SyscallException const& e)
     {
-        BOOST_LOG(logger_) << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
+        logger_() << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
     }
 }
 
@@ -196,13 +196,13 @@
 
             // New config found, execute callback
             ini_added_callback_(config);
-            BOOST_LOG_SEV(logger_, Logger::Info)
-                << "ScopesWatcher: scope: \"" << config.first << "\" installed to: \"" << dir << "\"";
+            logger_(LoggerSeverity::Info) << "ScopesWatcher: scope: \"" << config.first
+                                          << "\" installed to: \"" << dir << "\"";
         }
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(logger_) << "scoperegistry: add_scope_dir(): " << e.what();
+        logger_() << "scoperegistry: add_scope_dir(): " << e.what();
     }
 }
 
@@ -227,8 +227,8 @@
         filesystem::path p(ini_path);
         std::string scope_id = p.stem().native();
         registry_->remove_local_scope(scope_id);
-        BOOST_LOG_SEV(logger_, Logger::Info)
-            << "ScopesWatcher: scope: \"" << scope_id << "\" uninstalled from: \"" << dir << "\"";
+        logger_(LoggerSeverity::Info) << "ScopesWatcher: scope: \"" << scope_id
+                                      << "\" uninstalled from: \"" << dir << "\"";
     }
 
     // Remove the watch for this directory
@@ -273,8 +273,8 @@
             {
                 sdir_to_ini_map_[parent_path] = path;
                 ini_added_callback_(std::make_pair(scope_id, path));
-                BOOST_LOG_SEV(logger_, Logger::Info)
-                    << "scopeswatcher: scope: \"" << scope_id << "\" .ini installed: \"" << path << "\"";
+                logger_(LoggerSeverity::Info) << "scopeswatcher: scope: \"" << scope_id
+                                              << "\" .ini installed: \"" << path << "\"";
             }
         }
         // a .ini has been removed
@@ -282,9 +282,8 @@
         {
             sdir_to_ini_map_.erase(parent_path);
             registry_->remove_local_scope(scope_id);
-            BOOST_LOG_SEV(logger_, Logger::Info)
-                << "scopeswatcher: scope: \"" << scope_id << "\" .ini uninstalled: \""
-                << path << "\"";
+            logger_(LoggerSeverity::Info) << "scopeswatcher: scope: \"" << scope_id
+                                          << "\" .ini uninstalled: \"" << path << "\"";
         }
     }
     else
@@ -317,7 +316,7 @@
         {
             bool is_inside_install_dir;
             {
-                std::lock_guard<std::mutex> lock(mutex);
+                std::lock_guard<std::mutex> lock(mutex_);
                 is_inside_install_dir = idir_to_sdirs_map_.find(parent_dir(path)) != idir_to_sdirs_map_.end();
             }
 

=== modified file 'scoperegistry/ScopesWatcher.h'
--- scoperegistry/ScopesWatcher.h	2014-11-28 06:41:23 +0000
+++ scoperegistry/ScopesWatcher.h	2016-03-04 15:54:04 +0000
@@ -34,7 +34,7 @@
 public:
     ScopesWatcher(unity::scopes::internal::RegistryObject::SPtr registry,
                   std::function<void(std::pair<std::string, std::string> const&)> ini_added_callback,
-                  boost::log::sources::severity_channel_logger_mt<>& logger);
+                  unity::scopes::internal::Logger& logger);
 
     ~ScopesWatcher();
 
@@ -43,7 +43,7 @@
 private:
     unity::scopes::internal::RegistryObject::SPtr const registry_;
     std::function<void(std::pair<std::string, std::string> const&)> const ini_added_callback_;
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
+    unity::scopes::internal::Logger& logger_;
     std::map<std::string, std::string> sdir_to_ini_map_;
     std::map<std::string, std::set<std::string>> idir_to_sdirs_map_;
     std::mutex mutex_;

=== modified file 'src/scopes/CMakeLists.txt'
--- src/scopes/CMakeLists.txt	2015-04-09 15:59:17 +0000
+++ src/scopes/CMakeLists.txt	2016-03-04 15:54:04 +0000
@@ -22,6 +22,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/Department.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/DateTimePickerFilter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/FilterBase.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/FilterGroup.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/FilterOption.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/FilterState.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Link.cpp
@@ -55,6 +56,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/SearchReply.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/SwitchFilter.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ValueSliderFilter.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ValueSliderLabels.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/VariantBuilder.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Variant.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Version.cpp

=== modified file 'src/scopes/CategoryRenderer.cpp'
--- src/scopes/CategoryRenderer.cpp	2015-01-07 22:36:31 +0000
+++ src/scopes/CategoryRenderer.cpp	2016-03-04 15:54:04 +0000
@@ -49,8 +49,12 @@
 
 As specified by the \c "category-layout" key of the \c "template" dictionary, Unity will render results associated with this category in a grid layout. The \c "components" dictionary specifies which result fields are used by Unity. In case of this definition, each tile of the grid will map the "title" field from the result (set also by the call to unity::scopes::Result::set_title()) as title for the grid tile, and "art" field from the result (see unity::scopes::Result::set_art()) as the icon for the grid tile.
 
-To sum up, the \c "template" dictionary contains information to determine the correct renderer and its parameters, and the \c "components" dictionary contains mapping specifying which fields of the results are used by the renderer, where keys of the dictionary are understood by Unity and values specify either field name of the results directly (<tt>{"title": "album_name"}</tt> would mean that Unity will use <tt>result["album_name"]</tt> as a title for the grid tile), or the value can specify extra hints for the renderer as well as the result field name and a fallback image
-(<tt>{"art": {"field": "icon", "aspect-ratio": 1.3, "fallback": "file:///path_to_fallback_image}}</tt>).
+To sum up, the \c "template" dictionary contains information to determine the correct renderer and its parameters, and the \c "components" dictionary contains a mapping that specifies which fields of the results are used by the renderer.
+The keys of the dictionary are understood by Unity and the values specify a field name of the results. For example, <tt>{"title": "album_name"}</tt> means that Unity will use <tt>result["album_name"]</tt> as a title for the grid tile.r
+
+A value also can specify extra hints for the renderer, such as the result field name and a fallback image. For example,
+<tt>{"art": {"field": "icon", "aspect-ratio": 1.3, "fallback": "file:///path_to_fallback_image}}</tt>.
+The fallback image is shown by Unity if no image URL is provided by the result, but the card requires an image. The fallback image is also shown if the result provides an empty URL for an image, the image does not load due to an error, or if loading results in an empty image. If a result does not specify a fallback image and the actual image is empty or cannot be loaded, Unity substitutes a generic fallback image.
 
 \section jsonschema1 JSON structure (v1)
 

=== modified file 'src/scopes/FilterBase.cpp'
--- src/scopes/FilterBase.cpp	2015-11-12 14:20:36 +0000
+++ src/scopes/FilterBase.cpp	2016-03-04 15:54:04 +0000
@@ -54,6 +54,16 @@
     return p->id();
 }
 
+void FilterBase::set_title(std::string const& title)
+{
+    p->set_title(title);
+}
+
+std::string FilterBase::title() const
+{
+    return p->title();
+}
+
 int FilterBase::display_hints() const
 {
     return p->display_hints();
@@ -64,6 +74,11 @@
     return p->filter_type();
 }
 
+FilterGroup::SCPtr FilterBase::filter_group() const
+{
+    return p->filter_group();
+}
+
 } // namespace scopes
 
 } // namespace unity

=== added file 'src/scopes/FilterGroup.cpp'
--- src/scopes/FilterGroup.cpp	1970-01-01 00:00:00 +0000
+++ src/scopes/FilterGroup.cpp	2016-03-04 15:54:04 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+ */
+
+#include <unity/scopes/FilterGroup.h>
+#include <unity/scopes/internal/FilterGroupImpl.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+/// @cond
+FilterGroup::FilterGroup(internal::FilterGroupImpl *pimpl)
+    : p(pimpl)
+{
+}
+
+FilterGroup::FilterGroup() = default;
+FilterGroup::~FilterGroup() = default;
+
+/// @endcond
+
+FilterGroup::SCPtr FilterGroup::create(std::string const& id, std::string const& label)
+{
+    return std::shared_ptr<FilterGroup>(new FilterGroup(new internal::FilterGroupImpl(id, label)));
+}
+
+std::string FilterGroup::label() const
+{
+    return p->label();
+}
+
+std::string FilterGroup::id() const
+{
+    return p->id();
+}
+
+} // namespace scopes
+
+} // namespace unity

=== modified file 'src/scopes/FilterOption.cpp'
--- src/scopes/FilterOption.cpp	2014-02-25 14:59:28 +0000
+++ src/scopes/FilterOption.cpp	2016-03-04 15:54:04 +0000
@@ -44,6 +44,11 @@
     return p->label();
 }
 
+bool FilterOption::default_value() const
+{
+    return p->default_value();
+}
+
 } // namespace scopes
 
 } // namespace unity

=== modified file 'src/scopes/OptionSelectorFilter.cpp'
--- src/scopes/OptionSelectorFilter.cpp	2014-05-19 09:54:37 +0000
+++ src/scopes/OptionSelectorFilter.cpp	2016-03-04 15:54:04 +0000
@@ -35,6 +35,13 @@
     return std::unique_ptr<OptionSelectorFilter>(new OptionSelectorFilter(new internal::OptionSelectorFilterImpl(id, label, multi_select)));
 }
 
+OptionSelectorFilter::UPtr OptionSelectorFilter::create(std::string const& id, std::string const& label, FilterGroup::SCPtr const& group, bool multi_select)
+{
+    auto filter = std::unique_ptr<OptionSelectorFilter>(new OptionSelectorFilter(new internal::OptionSelectorFilterImpl(id, label, multi_select)));
+    filter->p->add_to_filter_group(group);
+    return filter;
+}
+
 std::string OptionSelectorFilter::label() const
 {
     return fwd()->label();
@@ -47,7 +54,12 @@
 
 FilterOption::SCPtr OptionSelectorFilter::add_option(std::string const& id, std::string const& label)
 {
-    return fwd()->add_option(id, label);
+    return fwd()->add_option(id, label, false);
+}
+
+FilterOption::SCPtr OptionSelectorFilter::add_option(std::string const& id, std::string const& label, bool value)
+{
+    return fwd()->add_option(id, label, value);
 }
 
 std::list<FilterOption::SCPtr> OptionSelectorFilter::options() const

=== modified file 'src/scopes/PreviewWidget.cpp'
--- src/scopes/PreviewWidget.cpp	2015-12-10 16:26:30 +0000
+++ src/scopes/PreviewWidget.cpp	2016-03-04 15:54:04 +0000
@@ -158,7 +158,7 @@
 
 \arg \c source A URI pointing to the image
 \arg \c zoomable A boolean specifying whether the image is zoomable (default: \c false)
-\arg \c fallback A fallback image to be used if the image URI cannot be retrieved (default: none)
+\arg \c fallback A fallback image to be used if the image URI is empty or cannot be retrieved (default: none)
 \arg \c share-data An optional dictionary for making this image shareable with Content Hub. See \link contentsharing content sharing\endlink below.
 
 \code{.cpp}
@@ -178,7 +178,7 @@
 List of attributes:
 
 \arg \c sources An array of image URIs
-\arg \c fallback A fallback image to be used if an image URI cannot be resolved (default: none)
+\arg \c fallback A fallback image to be used if an image URI is empty or cannot be retrieved (default: none)
 
 \code{.cpp}
 {
@@ -203,7 +203,7 @@
 \arg \c title A string specifying the title
 \arg \c subtitle A string specifying the subtitle
 \arg \c mascot A URI specifying the mascot
-\arg \c fallback A fallback image to be used if the mascot URI cannot be retrieved (default: none)
+\arg \c fallback A fallback image to be used if the mascot URI is empty or cannot be retrieved (default: none)
 \arg \c emblem A URI specifying the emblem
 
 \code{.cpp}

=== modified file 'src/scopes/RangeInputFilter.cpp'
--- src/scopes/RangeInputFilter.cpp	2014-06-17 10:30:03 +0000
+++ src/scopes/RangeInputFilter.cpp	2016-03-04 15:54:04 +0000
@@ -26,32 +26,105 @@
 namespace scopes
 {
 
-namespace experimental
-{
-
-RangeInputFilter::SPtr RangeInputFilter::create(std::string const& id, std::string const& start_label, std::string const& end_label, std::string const& unit_label)
-{
-    return std::shared_ptr<RangeInputFilter>(new RangeInputFilter(new internal::RangeInputFilterImpl(id, start_label, end_label, unit_label)));
-}
+RangeInputFilter::SPtr RangeInputFilter::create(std::string const& id,
+        std::string const& start_prefix_label, std::string const& start_postfix_label,
+        std::string const& central_label,
+        std::string const& end_prefix_label, std::string const& end_postfix_label)
+{
+    return std::shared_ptr<RangeInputFilter>(new RangeInputFilter(new internal::RangeInputFilterImpl(id,
+                    Variant::null(), Variant::null(),
+                    start_prefix_label, start_postfix_label,
+                    central_label,
+                    end_prefix_label, end_postfix_label)));
+}
+
+RangeInputFilter::SPtr RangeInputFilter::create(std::string const& id,
+        Variant const& default_start_value,
+        Variant const& default_end_value,
+        std::string const& start_prefix_label, std::string const& start_postfix_label,
+        std::string const& central_label,
+        std::string const& end_prefix_label, std::string const& end_postfix_label)
+{
+    return std::shared_ptr<RangeInputFilter>(new RangeInputFilter(new internal::RangeInputFilterImpl(id,
+                    default_start_value, default_end_value,
+                    start_prefix_label, start_postfix_label,
+                    central_label,
+                    end_prefix_label, end_postfix_label)));
+}
+
+RangeInputFilter::SPtr RangeInputFilter::create(std::string const& id,
+        std::string const& start_prefix_label, std::string const& start_postfix_label,
+        std::string const& central_label,
+        std::string const& end_prefix_label, std::string const& end_postfix_label,
+        FilterGroup::SCPtr const& group
+        )
+{
+    auto filter = std::shared_ptr<RangeInputFilter>(new RangeInputFilter(new internal::RangeInputFilterImpl(id,
+                    Variant::null(), Variant::null(),
+                    start_prefix_label, start_postfix_label,
+                    central_label,
+                    end_prefix_label, end_postfix_label)));
+    filter->p->add_to_filter_group(group);
+    return filter;
+}
+
+RangeInputFilter::SPtr RangeInputFilter::create(std::string const& id,
+        Variant const& default_start_value,
+        Variant const& default_end_value,
+        std::string const& start_prefix_label, std::string const& start_postfix_label,
+        std::string const& central_label,
+        std::string const& end_prefix_label, std::string const& end_postfix_label,
+        FilterGroup::SCPtr const& group
+        )
+{
+    auto filter = std::shared_ptr<RangeInputFilter>(new RangeInputFilter(new internal::RangeInputFilterImpl(id,
+                    default_start_value, default_end_value,
+                    start_prefix_label, start_postfix_label,
+                    central_label,
+                    end_prefix_label, end_postfix_label)));
+    filter->p->add_to_filter_group(group);
+    return filter;
+}
+
 
 RangeInputFilter::RangeInputFilter(internal::RangeInputFilterImpl* impl)
     : FilterBase(impl)
 {
 }
 
-std::string RangeInputFilter::start_label() const
-{
-    return fwd()->start_label();
-}
-
-std::string RangeInputFilter::end_label() const
-{
-    return fwd()->end_label();
-}
-
-std::string RangeInputFilter::unit_label() const
-{
-    return fwd()->unit_label();
+std::string RangeInputFilter::start_prefix_label() const
+{
+    return fwd()->start_prefix_label();
+}
+
+std::string RangeInputFilter::start_postfix_label() const
+{
+    return fwd()->start_postfix_label();
+}
+
+std::string RangeInputFilter::end_prefix_label() const
+{
+    return fwd()->end_prefix_label();
+}
+
+std::string RangeInputFilter::end_postfix_label() const
+{
+    return fwd()->end_postfix_label();
+}
+
+std::string RangeInputFilter::central_label() const
+{
+    return fwd()->central_label();
+}
+
+Variant RangeInputFilter::default_start_value() const
+{
+    return fwd()->default_start_value();
+}
+
+Variant RangeInputFilter::default_end_value() const
+{
+    return fwd()->default_end_value();
 }
 
 bool RangeInputFilter::has_start_value(FilterState const& filter_state) const
@@ -89,8 +162,6 @@
     return dynamic_cast<internal::RangeInputFilterImpl*>(p.get());
 }
 
-} // namespace experimental
-
 } // namespace scopes
 
 } // namespace unity

=== modified file 'src/scopes/ValueSliderFilter.cpp'
--- src/scopes/ValueSliderFilter.cpp	2014-06-17 10:30:03 +0000
+++ src/scopes/ValueSliderFilter.cpp	2016-03-04 15:54:04 +0000
@@ -25,22 +25,21 @@
 namespace scopes
 {
 
-namespace experimental
-{
-
 ValueSliderFilter::ValueSliderFilter(internal::ValueSliderFilterImpl *impl)
     : FilterBase(impl)
 {
 }
 
-ValueSliderFilter::UPtr ValueSliderFilter::create(std::string const& id, std::string const& label, std::string const& label_template, double min, double max)
+ValueSliderFilter::UPtr ValueSliderFilter::create(std::string const& id, double min, double max, double default_value, ValueSliderLabels const& labels)
 {
-    return std::unique_ptr<ValueSliderFilter>(new ValueSliderFilter(new internal::ValueSliderFilterImpl(id, label, label_template, min, max)));
+    return std::unique_ptr<ValueSliderFilter>(new ValueSliderFilter(new internal::ValueSliderFilterImpl(id, min, max, default_value, labels)));
 }
 
-void ValueSliderFilter::set_slider_type(SliderType tp)
+ValueSliderFilter::UPtr ValueSliderFilter::create(std::string const& id, double min, double max, double default_value, ValueSliderLabels const& labels, FilterGroup::SCPtr const& group)
 {
-    fwd()->set_slider_type(tp);
+    auto filter = std::unique_ptr<ValueSliderFilter>(new ValueSliderFilter(new internal::ValueSliderFilterImpl(id, min, max, default_value, labels)));
+    filter->p->add_to_filter_group(group);
+    return filter;
 }
 
 void ValueSliderFilter::set_default_value(double val)
@@ -48,11 +47,6 @@
     fwd()->set_default_value(val);
 }
 
-ValueSliderFilter::SliderType ValueSliderFilter::slider_type() const
-{
-    return fwd()->slider_type();
-}
-
 double ValueSliderFilter::default_value() const
 {
     return fwd()->default_value();
@@ -68,14 +62,9 @@
     return fwd()->max();
 }
 
-std::string ValueSliderFilter::label() const
-{
-    return fwd()->label();
-}
-
-std::string ValueSliderFilter::value_label_template() const
-{
-    return fwd()->value_label_template();
+ValueSliderLabels const& ValueSliderFilter::labels() const
+{
+    return fwd()->labels();
 }
 
 bool ValueSliderFilter::has_value(FilterState const& filter_state) const
@@ -103,8 +92,6 @@
     return dynamic_cast<internal::ValueSliderFilterImpl*>(p.get());
 }
 
-} // namespace experimental
-
 } // namespace scopes
 
 } // namespace unity

=== added file 'src/scopes/ValueSliderLabels.cpp'
--- src/scopes/ValueSliderLabels.cpp	1970-01-01 00:00:00 +0000
+++ src/scopes/ValueSliderLabels.cpp	2016-03-04 15:54:04 +0000
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+*/
+
+#include <unity/scopes/ValueSliderLabels.h>
+#include <unity/scopes/internal/ValueSliderLabelsImpl.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+ValueSliderLabels::ValueSliderLabels(internal::ValueSliderLabelsImpl* pimpl)
+    : p(pimpl)
+{
+}
+
+ValueSliderLabels::ValueSliderLabels(std::string const& min_label, std::string const& max_label)
+    : p(new internal::ValueSliderLabelsImpl(min_label, max_label))
+{
+}
+
+ValueSliderLabels::ValueSliderLabels(std::string const& min_label, std::string const& max_label, ValueLabelPairList const& extra_labels)
+    : p(new internal::ValueSliderLabelsImpl(min_label, max_label, extra_labels))
+{
+}
+
+ValueSliderLabels::ValueSliderLabels(VariantMap const& var)
+    : p(new internal::ValueSliderLabelsImpl(var))
+{
+}
+
+ValueSliderLabels::ValueSliderLabels(ValueSliderLabels const& other)
+    : p(new internal::ValueSliderLabelsImpl(*(other.p)))
+{
+}
+
+ValueSliderLabels& ValueSliderLabels::operator=(ValueSliderLabels const& other)
+{
+    if (this != &other)
+    {
+        p.reset(new internal::ValueSliderLabelsImpl(*(other.p)));
+    }
+    return *this;
+}
+
+ValueSliderLabels::ValueSliderLabels(ValueSliderLabels&&) = default;
+ValueSliderLabels& ValueSliderLabels::operator=(ValueSliderLabels&&) = default;
+
+ValueSliderLabels::~ValueSliderLabels() = default;
+
+std::string ValueSliderLabels::min_label() const
+{
+    return p->min_label();
+}
+
+std::string ValueSliderLabels::max_label() const
+{
+    return p->max_label();
+}
+
+ValueLabelPairList ValueSliderLabels::extra_labels() const
+{
+    return p->extra_labels();
+}
+
+VariantMap ValueSliderLabels::serialize() const
+{
+    return p->serialize();
+}
+
+}
+
+}

=== modified file 'src/scopes/internal/ActivationQueryObject.cpp'
--- src/scopes/internal/ActivationQueryObject.cpp	2015-01-21 23:35:22 +0000
+++ src/scopes/internal/ActivationQueryObject.cpp	2016-03-04 15:54:04 +0000
@@ -71,13 +71,13 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(info.mw->runtime()->logger()) << "ActivationQueryBase::activate(): " << e.what();
+        info.mw->runtime()->logger()() << "ActivationQueryBase::activate(): " << e.what();
         reply_->finished(CompletionDetails(CompletionDetails::Error,
                                            string("ActivationQueryBase::activate(): ") + e.what()));
     }
     catch (...)
     {
-        BOOST_LOG(info.mw->runtime()->logger()) << "ActivationQueryBase::activate(): unknown exception";
+        info.mw->runtime()->logger()() << "ActivationQueryBase::activate(): unknown exception";
         reply_->finished(CompletionDetails(CompletionDetails::Error,
                                            "ActivationQueryBase::activate(): unknown exception"));
     }

=== modified file 'src/scopes/internal/CMakeLists.txt'
--- src/scopes/internal/CMakeLists.txt	2015-03-27 17:18:09 +0000
+++ src/scopes/internal/CMakeLists.txt	2016-03-04 15:54:04 +0000
@@ -25,6 +25,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/DynamicLoader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Executor.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/FilterBaseImpl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/FilterGroupImpl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/FilterOptionImpl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/FilterStateImpl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/IniSettingsSchema.cpp
@@ -89,6 +90,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/UniqueID.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Utils.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ValueSliderFilterImpl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ValueSliderLabelsImpl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/VariantBuilderImpl.cpp
 )
 set(UNITY_SCOPES_LIB_SRC ${UNITY_SCOPES_LIB_SRC} ${SRC} PARENT_SCOPE)

=== modified file 'src/scopes/internal/ChildScopesRepository.cpp'
--- src/scopes/internal/ChildScopesRepository.cpp	2015-04-01 11:28:32 +0000
+++ src/scopes/internal/ChildScopesRepository.cpp	2016-03-04 15:54:04 +0000
@@ -19,6 +19,7 @@
 #include <unity/scopes/internal/ChildScopesRepository.h>
 #include <unity/scopes/internal/JsonCppNode.h>
 
+#include <cassert>
 #include <fstream>
 #include <set>
 #include <sstream>
@@ -26,8 +27,7 @@
 using namespace unity::scopes;
 using namespace unity::scopes::internal;
 
-ChildScopesRepository::ChildScopesRepository(std::string const& repo_file_path,
-                                             boost::log::sources::severity_channel_logger_mt<>& logger)
+ChildScopesRepository::ChildScopesRepository(std::string const& repo_file_path, Logger& logger)
     : repo_file_path_(repo_file_path)
     , logger_(logger)
     , have_latest_cache_(false)
@@ -79,9 +79,7 @@
     std::ofstream repo_file(repo_file_path_);
     if (repo_file.fail())
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ChildScopesRepository::write_repo(): "
-                                              << "Failed to open file: \"" << repo_file_path_
-                                              << "\"";
+        logger_() << "ChildScopesRepository::write_repo(): Failed to open file: \"" << repo_file_path_ << "\"";
         return false;
     }
 
@@ -104,9 +102,8 @@
     std::ifstream repo_file(repo_file_path_);
     if (repo_file.fail())
     {
-        BOOST_LOG_SEV(logger_, Logger::Info) << "ChildScopesRepository::read_repo(): "
-                                             << "Failed to open file: \"" << repo_file_path_
-                                             << "\"";
+        logger_(LoggerSeverity::Info) << "ChildScopesRepository::read_repo(): "
+                                      << "Failed to open file: \"" << repo_file_path_ << "\"";
         return ChildScopeEnabledMap();
     }
 
@@ -143,16 +140,13 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ChildScopesRepository::json_to_list(): "
-                                              << "Exception thrown while reading json string: "
-                                              << e.what();
+        logger_() << "ChildScopesRepository::json_to_list(): Exception thrown while reading json string: " << e.what();
         return ChildScopeEnabledMap();
     }
     if (json_node.type() != JsonCppNode::Array)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ChildScopesRepository::json_to_list(): "
-                                              << "Root node of json string is not an array:"
-                                              << std::endl << child_scopes_json;
+        logger_() << "ChildScopesRepository::json_to_list(): Root node of json string is not an array:"
+                  << std::endl << child_scopes_json;
         return ChildScopeEnabledMap();
     }
 
@@ -164,10 +158,8 @@
         if (!child_node->has_node("id") ||
             !child_node->has_node("enabled"))
         {
-            BOOST_LOG_SEV(logger_, Logger::Error) << "ChildScopesRepository::json_to_list(): "
-                                                  << "Child node is missing a required field. "
-                                                  << "Skipping child node:" << std::endl
-                                                  << child_node->to_json_string();
+            logger_() << "ChildScopesRepository::json_to_list(): Child node is missing a required field. "
+                     << "Skipping child node:" << std::endl << child_node->to_json_string();
             continue;
         }
         auto id_node = child_node->get_node("id");
@@ -176,10 +168,9 @@
         if (id_node->type() != JsonCppNode::String ||
             enabled_node->type() != JsonCppNode::Bool)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error) << "ChildScopesRepository::json_to_list(): "
-                                                  << "Child node contains an invalid value type. "
-                                                  << "Skipping child node:" << std::endl
-                                                  << child_node->to_json_string();
+            logger_() << "ChildScopesRepository::json_to_list(): "
+                      << "Child node contains an invalid value type. Skipping child node:"
+                      << std::endl << child_node->to_json_string();
             continue;
         }
 

=== modified file 'src/scopes/internal/FilterBaseImpl.cpp'
--- src/scopes/internal/FilterBaseImpl.cpp	2015-03-30 15:59:08 +0000
+++ src/scopes/internal/FilterBaseImpl.cpp	2016-03-04 15:54:04 +0000
@@ -54,6 +54,12 @@
 {
     auto it = find_or_throw("FilterBase()", var, "id");
     id_ = it->second.get_string();
+    it = var.find("title");
+    if (it != var.end())
+    {
+        title_ = it->second.get_string();
+    }
+
     it = var.find("display_hints");
     if (it != var.end())
     {
@@ -75,6 +81,23 @@
 
 FilterBaseImpl::~FilterBaseImpl() = default;
 
+void FilterBaseImpl::add_to_filter_group(FilterGroup::SCPtr const& group)
+{
+    // Filter can only belong to one group. The API guarantees this by only allowing group to be passed at Filter's construction time,
+    // so this assert should never be reached.
+    assert(filter_group_ == nullptr);
+    if (!group)
+    {
+        throw unity::InvalidArgumentException("FilterBaseImpl::add_to_filter_group(): invalid null group");
+    }
+    filter_group_ = group;
+}
+
+FilterGroup::SCPtr FilterBaseImpl::filter_group() const
+{
+    return filter_group_;
+}
+
 void FilterBaseImpl::set_display_hints(int hints)
 {
     // note: make sure all_flags is updated whenever new values are added to the DisplayHints enum
@@ -98,15 +121,33 @@
     return display_hints_;
 }
 
+void FilterBaseImpl::set_title(std::string const& title)
+{
+    title_ = title;
+}
+
+std::string FilterBaseImpl::title() const
+{
+    return title_;
+}
+
 VariantMap FilterBaseImpl::serialize() const
 {
     VariantMap vm;
     vm["id"] = id_;
+    if (title_.size() > 0)
+    {
+        vm["title"] = title_;
+    }
     if (display_hints_ != FilterBase::DisplayHints::Default)
     {
         vm["display_hints"] = static_cast<int>(display_hints_);
     }
     vm["filter_type"] = filter_type();
+    if (filter_group_)
+    {
+        vm["filter_group"] = filter_group_->id();
+    }
     serialize(vm);
     return vm;
 }
@@ -170,12 +211,28 @@
     return var;
 }
 
-Filters FilterBaseImpl::deserialize_filters(VariantArray const& var)
+Filters FilterBaseImpl::deserialize_filters(VariantArray const& var, std::map<std::string, FilterGroup::SCPtr> const& groups)
 {
     Filters filters;
     for (auto const& f: var)
     {
-        filters.push_back(FilterBaseImpl::deserialize(f.get_dict()));
+        auto const data = f.get_dict();
+        auto filter = FilterBaseImpl::deserialize(data);
+        auto grit = data.find("filter_group");
+        if (grit != data.end())
+        {
+            auto const group_id = grit->second.get_string();
+            auto it = groups.find(group_id);
+            if (it != groups.end())
+            {
+                filter->p->add_to_filter_group(it->second);
+            }
+            else
+            {
+                throw unity::LogicException("FilterBaseImpl::deserialize_filters(): Invalid group '" + group_id + "' for filter '" + filter->id() + "'");
+            }
+        }
+        filters.push_back(filter);
     }
     return filters;
 }

=== added file 'src/scopes/internal/FilterGroupImpl.cpp'
--- src/scopes/internal/FilterGroupImpl.cpp	1970-01-01 00:00:00 +0000
+++ src/scopes/internal/FilterGroupImpl.cpp	2016-03-04 15:54:04 +0000
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2016 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+*/
+
+#include <unity/scopes/internal/FilterGroupImpl.h>
+#include <unity/UnityExceptions.h>
+#include <unity/scopes/FilterState.h>
+#include <unity/scopes/internal/Utils.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+FilterGroupImpl::FilterGroupImpl(std::string const& id, std::string const& label)
+    : id_(id),
+      label_(label)
+{
+}
+
+std::string FilterGroupImpl::id() const
+{
+    return id_;
+}
+
+std::string FilterGroupImpl::label() const
+{
+    return label_;
+}
+
+VariantArray FilterGroupImpl::serialize_filter_groups(Filters const& filters)
+{
+    std::map<std::string, FilterGroup::SCPtr> group_lookup;
+    VariantArray va;
+    for (auto const& filter: filters)
+    {
+        auto grp = filter->filter_group();
+        if (grp)
+        {
+            auto it = group_lookup.find(grp->id());
+            if (it == group_lookup.end())
+            {
+                group_lookup[grp->id()] = grp;
+                VariantMap grpvar;
+                grpvar["id"] = grp->id();
+                grpvar["label"] = grp->label();
+                va.push_back(Variant(grpvar));
+            }
+            else
+            {
+                if (it->second != grp)
+                {
+                    throw unity::LogicException("FilterGroupImpl::serialize_filter_groups(): duplicate FilterGroup definitions for group id '" + grp->id() + "'");
+                }
+            }
+        }
+    }
+    return va;
+}
+
+std::map<std::string, FilterGroup::SCPtr> FilterGroupImpl::deserialize_filter_groups(VariantArray const& var)
+{
+    std::map<std::string, FilterGroup::SCPtr> groups;
+    for (auto it = var.begin(); it != var.end(); it++)
+    {
+        auto const grvar = it->get_dict();
+        auto const id = find_or_throw("FilterGroup::deserialize_filter_groups", grvar, "id")->second.get_string();
+        auto const label = find_or_throw("FilterGroup::deserialize_filter_groups", grvar, "label")->second.get_string();
+        auto group = FilterGroup::create(id, label);
+        groups[id] = group;
+    }
+    return groups;
+}
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace unity

=== modified file 'src/scopes/internal/FilterOptionImpl.cpp'
--- src/scopes/internal/FilterOptionImpl.cpp	2014-05-15 03:23:43 +0000
+++ src/scopes/internal/FilterOptionImpl.cpp	2016-03-04 15:54:04 +0000
@@ -31,7 +31,8 @@
 
 FilterOptionImpl::FilterOptionImpl(std::string const& id, std::string const& label)
     : id_(id),
-      label_(label)
+      label_(label),
+      default_value_(false)
 {
     if (id_.empty())
     {
@@ -53,6 +54,16 @@
     return label_;
 }
 
+void FilterOptionImpl::set_default_value(bool default_value)
+{
+    default_value_ = default_value;
+}
+
+bool FilterOptionImpl::default_value() const
+{
+    return default_value_;
+}
+
 } // namespace internal
 
 } // namespace scopes

=== modified file 'src/scopes/internal/Logger.cpp'
--- src/scopes/internal/Logger.cpp	2015-03-02 13:18:28 +0000
+++ src/scopes/internal/Logger.cpp	2016-03-04 15:54:04 +0000
@@ -18,33 +18,14 @@
 
 #include <unity/scopes/internal/Logger.h>
 
-#include <boost/log/attributes.hpp>
-#include <boost/log/core.hpp>
-#include <boost/log/expressions.hpp>
-#include <boost/log/sources/record_ostream.hpp>
-#include <boost/log/support/date_time.hpp>
-#include <boost/log/trivial.hpp>
-#include <boost/phoenix/bind.hpp>
-
-#if (BOOST_VERSION / 100000 == 1) && (((BOOST_VERSION / 100) % 1000) < 56)
-#include <boost/utility/empty_deleter.hpp>
-typedef boost::empty_deleter NullDeleter;
-#else
-#include <boost/core/null_deleter.hpp>
-typedef boost::null_deleter NullDeleter;
-#endif
-
 #include <unity/UnityExceptions.h>
 
+#include <cassert>
+#include <chrono>
+#include <iomanip>
+
 using namespace std;
 
-namespace logging = boost::log;
-namespace sinks = boost::log::sinks;
-namespace src = boost::log::sources;
-namespace attrs = boost::log::attributes;
-namespace expr = boost::log::expressions;
-namespace keywords = boost::log::keywords;
-
 namespace unity
 {
 
@@ -57,214 +38,158 @@
 namespace
 {
 
-static array<string, Logger::LastChannelEnum_> const channel_names = {{"IPC"}};
+static array<string, 5> const severities = {{"INFO", "WARNING", "ERROR", "FATAL", "TRACE"}};
 
-string const& to_severity(int s)
+static array<pair<string, LoggerChannel>, int(LoggerChannel::LastChannelEnum_)> const channel_names =
 {
-    static array<string, 5> const severities = {{"INFO", "WARNING", "ERROR", "FATAL", "TRACE"}};
-    static string const unknown = "UNKNOWN";
+    pair<string, LoggerChannel>{"", LoggerChannel::DefaultChannel},
+    pair<string, LoggerChannel>{"IPC", LoggerChannel::IPC}
+};
 
-    if (s < 0 || s >= static_cast<int>(severities.size()))
-    {
-        return unknown;
-    }
-    return severities[s];
-}
-}
+}  // namespace
 
 // Instantiate a logger for the scope/client with the given ID.
 
-Logger::Logger(string const& scope_id)
-    : scope_id_(scope_id)
-    , logger_(keywords::severity = Logger::Error)
-    , severity_(Logger::Info)
-{
-    namespace ph = std::placeholders;
-
-    assert(!scope_id_.empty());
-
-    logger_.add_attribute("TimeStamp", attrs::local_clock());
-
-    // Create a channel logger for each channel.
-    for (auto&& name : channel_names)
-    {
-        auto clogger = boost::log::sources::severity_channel_logger_mt<>(keywords::severity = Logger::Trace,
-                                                                         keywords::channel = name);
-        clogger.add_attribute("TimeStamp", attrs::local_clock());
-        channel_loggers_[name] = make_pair(clogger, false);
-    }
-
-    // Set up sink that logs to std::clog.
-    clog_sink_ = boost::make_shared<ClogSinkT>();
-    clog_sink_->set_formatter(bind(&Logger::formatter, this, ph::_1, ph::_2));
-    boost::shared_ptr<std::ostream> console_stream(&std::clog, NullDeleter());
-    clog_sink_->locked_backend()->add_stream(console_stream);
-    clog_sink_->locked_backend()->auto_flush(true);
-    logging::core::get()->add_sink(clog_sink_);
-
-    set_severity_threshold(severity_);
-}
-
-Logger::~Logger()
-{
-    lock_guard<mutex> lock(mutex_);
-
-    if (clog_sink_)
-    {
-        logging::core::get()->remove_sink(clog_sink_);
-        clog_sink_->stop();
-        clog_sink_->flush();
-    }
-    else
-    {
-        logging::core::get()->remove_sink(file_sink_);
-        file_sink_->stop();
-        file_sink_->flush();
-    }
-}
-
-Logger::operator boost::log::sources::severity_channel_logger_mt<>&()
-{
-    return logger_;  // No lock needed, immutable
-}
-
-src::severity_channel_logger_mt<>& Logger::operator()(Channel c)
-{
-    // No lock needed: channel_loggers_ is immutable, and the boolean is atomic.
-    return channel_loggers_[channel_names[c]].first;
-}
-
-bool Logger::set_channel(Channel c, bool enable)
-{
-    auto it = channel_loggers_.find(channel_names[c]);
-    assert(it != channel_loggers_.end());
-    bool was_enabled = it->second.second.exchange(enable);
-    return was_enabled;
+Logger::Logger(string const& id, ostream& outstream)
+    : id_(id)
+    , outstream_(outstream)
+    , severity_threshold_(LoggerSeverity::Info)  // By default, log all severities
+{
+    // Channels are disabled by default.
+    for (auto& e : enabled_)
+    {
+        e = false;
+    }
+    // Except for the default channel.
+    enabled_[0] = true;
+}
+
+// Default writes to the default channel at severity Error.
+
+LogStream Logger::operator()()
+{
+    if (LoggerSeverity::Error >= severity_threshold_)
+    {
+        return LogStream(outstream_, id_, LoggerSeverity::Error, LoggerChannel::DefaultChannel);
+    }
+    return LogStream();  // Null writer
+}
+
+LogStream Logger::operator()(LoggerSeverity s)
+{
+    if (s >= severity_threshold_)
+    {
+        return LogStream(outstream_, id_, s, LoggerChannel::DefaultChannel);
+    }
+    return LogStream();  // Null writer
+}
+
+LogStream Logger::operator()(LoggerChannel c)
+{
+    if (enabled_[int(c)])
+    {
+        return LogStream(outstream_, id_, LoggerSeverity::Trace, c);
+    }
+    return LogStream();  // Null writer
+}
+
+bool Logger::set_channel(LoggerChannel c, bool enable)
+{
+    return enabled_[int(c)].exchange(enable);
 }
 
 bool Logger::set_channel(string channel_name, bool enable)
 {
-    auto it = channel_loggers_.find(channel_name);
-    if (it == channel_loggers_.end())
-    {
-        throw InvalidArgumentException("Logger::set_channel(): invalid channel name: " + channel_name);
-    }
-    bool was_enabled = it->second.second.exchange(enable);
-    return was_enabled;
-}
-
-void Logger::enable_channels(vector<string> const& names)
-{
-    exception_ptr ep;
-    for (auto&& name : names)
-    {
-        try
-        {
-            set_channel(name, true);
-        }
-        catch (InvalidArgumentException& e)
-        {
-            ep = ep ? make_exception_ptr(current_exception()) : e.remember(ep);
-        }
-    }
-    if (ep)
-    {
-        rethrow_exception(ep);
-    }
-}
-
-void Logger::set_log_file(string const& path, int rotation_size, int dir_size)
-{
-    namespace ph = std::placeholders;
-
-    FileSinkPtr s =
-        boost::make_shared<FileSinkT>(keywords::file_name = path + "-%N.log", keywords::rotation_size = rotation_size);
-
-    string parent = boost::filesystem::path(path).parent_path().native();
-    s->locked_backend()->set_file_collector(sinks::file::make_collector(
-        keywords::target = parent, keywords::max_size = dir_size, keywords::min_free_space = 1024 * 1024 * 5));
-    try
-    {
-        s->locked_backend()->scan_for_files();
-    }
-    catch (std::exception const& e)
-    {
-        BOOST_LOG_SEV(logger_, Warning) << "RuntimeImpl::Logger(): log rotation failed (path = " << parent
-                                        << "): " << e.what();
-        return;
-    }
-    catch (...)
-    {
-        BOOST_LOG_SEV(logger_, Warning) << "RuntimeImpl::Logger(): log rotation failed (path = " << parent
-                                        << "): unknown exception";
-        return;
-    }
-
-    {
-        lock_guard<mutex> lock(mutex_);
-
-        if (clog_sink_)
-        {
-            logging::core::get()->remove_sink(clog_sink_);
-            clog_sink_ = nullptr;
-        }
-        else
-        {
-            logging::core::get()->remove_sink(file_sink_);
-        }
-
-        file_sink_ = s;
-        file_sink_->locked_backend()->auto_flush(true);
-        file_sink_->set_formatter(bind(&Logger::formatter, this, ph::_1, ph::_2));
-        logging::core::get()->add_sink(file_sink_);
-    }
-    set_severity_threshold(severity_);
-}
-
-Logger::Severity Logger::set_severity_threshold(Logger::Severity s)
-{
-    auto old_s = severity_.exchange(s);
-
-    lock_guard<mutex> lock(mutex_);
-
-    auto filter = boost::phoenix::bind(&Logger::filter, this, severity.or_none(), channel.or_none());
-    if (clog_sink_)
-    {
-        clog_sink_->set_filter(filter);
-    }
-    else
-    {
-        file_sink_->set_filter(filter);
-    }
-
-    return old_s;
-}
-
-bool Logger::filter(logging::value_ref<int, tag::severity> const& level,
-                    logging::value_ref<string, tag::channel> const& channel)
-{
-    if (level.get() < static_cast<int>(severity_))  // atomic
-    {
-        return false;
-    }
-    if (channel.get().empty())
-    {
-        return true;
-    }
-    // No lock needed: channel_loggers_ is immutable, and the boolean is atomic.
-    auto it = channel_loggers_.find(channel.get());
-    assert(it != channel_loggers_.end());
-    return it->second.second;
-}
-
-void Logger::formatter(logging::record_view const& rec, logging::formatting_ostream& strm)
-{
-    string channel = expr::attr<string>("Channel")(rec).get();
-
-    string prefix = channel.empty() ? to_severity(expr::attr<int>("Severity")(rec).get()) : channel;
-
-    strm << "[" << expr::format_date_time<boost::posix_time::ptime>("TimeStamp", "%Y-%m-%d %H:%M:%S.%f")(rec) << "] "
-         << prefix << ": " << scope_id_ << ": " << rec[expr::smessage];
+    for (auto const& p : channel_names)
+    {
+        if (!p.first.empty() && channel_name == p.first)
+        {
+            return set_channel(p.second, enable);
+        }
+    }
+    throw InvalidArgumentException("Logger::set_channel(): invalid channel name: \"" + channel_name + "\"");
+}
+
+LoggerSeverity Logger::set_severity_threshold(LoggerSeverity s)
+{
+    return severity_threshold_.exchange(s);
+}
+
+namespace
+{
+
+// Null streambuf implementation that always reports success.
+// This allows the operator<<() functions to inject into a stream without
+// having to check in each function whether we actually want to log something.
+
+template <class cT, class traits = std::char_traits<cT>>
+class NullBuf : public std::basic_streambuf<cT, traits>
+{
+    typename traits::int_type overflow(typename traits::int_type c)
+    {
+        return traits::not_eof(c);  // Indicate success
+    }
+};
+
+static string const null_id;
+static NullBuf<char> null_buf;
+static ostream null_stream(&null_buf);
+
+}  // namespace
+
+LogStream::LogStream()  // Doesn't log anything
+    : id_(null_id)
+    , outstream_(null_stream)
+    , severity_(static_cast<LoggerSeverity>(0))
+    , channel_(static_cast<LoggerChannel>(0))
+{
+}
+
+LogStream::LogStream(ostream& outstream, string const& id, LoggerSeverity s, LoggerChannel c)
+    : id_(id)
+    , outstream_(outstream)
+    , severity_(s)
+    , channel_(c)
+{
+}
+
+namespace
+{
+
+string get_time()
+{
+    auto now = chrono::system_clock::now();
+    auto curr_t = chrono::system_clock::to_time_t(now);
+    auto millisecs = chrono::duration_cast<chrono::milliseconds>(now.time_since_epoch()).count() % 1000;
+
+    struct tm result;
+    localtime_r(&curr_t, &result);
+
+    // Should use std::put_time(&result, "%F %T') here, but gcc 4.9 doesn't provide it.
+    char buf[]{"yyyy-mm-dd hh:mm:ss"};
+    strftime(buf, sizeof(buf), "%F %T", &result);
+    stringstream s;
+    s << buf << "." << setw(3) << setfill('0') << millisecs;
+    return s.str();
+}
+
+}  // namespace
+
+LogStream::~LogStream()
+{
+    string msg = str();
+    if (msg.empty())
+    {
+        return;
+    }
+    // Something was logged. Accumulate all the details in an output string.
+    string prefix = channel_ != LoggerChannel::DefaultChannel
+                        ? channel_names[int(channel_)].first
+                        : severities[int(severity_)];
+    string output = "[" + get_time() + "] " + prefix + ": " + id_ + ": " + msg + "\n";
+
+    // Write contents with a single insertion to avoid interleaving of messages from different threads.
+    outstream_ << output;
 }
 
 }  // namespace internal

=== modified file 'src/scopes/internal/OptionSelectorFilterImpl.cpp'
--- src/scopes/internal/OptionSelectorFilterImpl.cpp	2015-11-12 14:20:36 +0000
+++ src/scopes/internal/OptionSelectorFilterImpl.cpp	2016-03-04 15:54:04 +0000
@@ -17,6 +17,7 @@
 */
 
 #include <unity/scopes/internal/OptionSelectorFilterImpl.h>
+#include <unity/scopes/internal/FilterOptionImpl.h>
 #include <unity/scopes/FilterState.h>
 #include <unity/scopes/ScopeExceptions.h>
 #include <unity/UnityExceptions.h>
@@ -75,6 +76,10 @@
         VariantMap vm;
         vm["id"] = opt->id();
         vm["label"] = opt->label();
+        if (opt->default_value())
+        {
+            vm["default"] = Variant(true);
+        }
         ops.push_back(Variant(vm));
     }
     var["label"] = label_;
@@ -111,7 +116,14 @@
         auto opt_id = it->second.get_string();
         it = optvar.find("label");
         throw_on_missing(it, optvar.end(), "option label");
-        add_option(opt_id, it->second.get_string());
+        auto const label = it->second.get_string();
+        bool default_val = false;
+        it = optvar.find("default");
+        if (it != optvar.end() && it->second.get_bool())
+        {
+            default_val = true;
+        }
+        add_option(opt_id, label, default_val);
     }
 }
 
@@ -120,18 +132,23 @@
     return "option_selector";
 }
 
-FilterOption::SCPtr OptionSelectorFilterImpl::add_option(std::string const& id, std::string const& label)
+FilterOption::SCPtr OptionSelectorFilterImpl::add_option(std::string const& id, std::string const& label, bool default_value)
 {
-    try
-    {
-        auto opt = std::shared_ptr<FilterOption>(new FilterOption(id, label));
-        options_.push_back(opt);
-        return opt;
-    }
-    catch (...)
-    {
-        throw ResourceException("OptionSelectorFilter(): cannot create FilterOption");
-    }
+    auto opt = std::shared_ptr<FilterOption>(new FilterOption(id, label));
+    // if it's not a multi-selection filter, then there can only be a single option selected by default
+    if (default_value && !multi_select_)
+    {
+        for (auto const& o: options_)
+        {
+            if (o->default_value())
+            {
+                throw unity::LogicException("OptionSelectorFilter::add_option(): only one option with default value 'true' allowed for a single-selection OptionSelectorFilter");
+            }
+        }
+    }
+    opt->p->set_default_value(default_value);
+    options_.push_back(opt);
+    return opt;
 }
 
 int OptionSelectorFilterImpl::num_of_options() const

=== modified file 'src/scopes/internal/PreviewQueryObject.cpp'
--- src/scopes/internal/PreviewQueryObject.cpp	2015-01-20 02:14:29 +0000
+++ src/scopes/internal/PreviewQueryObject.cpp	2016-03-04 15:54:04 +0000
@@ -94,7 +94,7 @@
             lock_guard<mutex> lock(mutex_);
             pushable_ = false;
         }
-        BOOST_LOG(info.mw->runtime()->logger()) << "PreviewQueryBase::run(): " << e.what();
+        info.mw->runtime()->logger()() << "PreviewQueryBase::run(): " << e.what();
         reply_->finished(CompletionDetails(CompletionDetails::Error, string("PreviewQueryBase::run(): ") + e.what()));
     }
     catch (...)
@@ -103,7 +103,7 @@
             lock_guard<mutex> lock(mutex_);
             pushable_ = false;
         }
-        BOOST_LOG(info.mw->runtime()->logger()) << "PreviewQueryBase::run(): unknown exception";
+        info.mw->runtime()->logger()() << "PreviewQueryBase::run(): unknown exception";
         reply_->finished(CompletionDetails(CompletionDetails::Error, "PreviewQueryBase::run(): unknown exception"));
     }
 }

=== modified file 'src/scopes/internal/QueryCtrlImpl.cpp'
--- src/scopes/internal/QueryCtrlImpl.cpp	2015-01-26 08:20:45 +0000
+++ src/scopes/internal/QueryCtrlImpl.cpp	2016-03-04 15:54:04 +0000
@@ -78,7 +78,7 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(reply_proxy_->mw_base()->runtime()->logger()) << e.what();
+        reply_proxy_->mw_base()->runtime()->logger()() << e.what();
     }
 }
 

=== modified file 'src/scopes/internal/QueryObject.cpp'
--- src/scopes/internal/QueryObject.cpp	2015-04-10 10:00:19 +0000
+++ src/scopes/internal/QueryObject.cpp	2016-03-04 15:54:04 +0000
@@ -128,7 +128,7 @@
             lock_guard<mutex> lock(mutex_);
             pushable_ = false;
         }
-        BOOST_LOG(info.mw->runtime()->logger()) << "QueryBase::run(): " << e.what();
+        info.mw->runtime()->logger()() << "QueryBase::run(): " << e.what();
         reply_->finished(CompletionDetails(CompletionDetails::Error, string("QueryBase::run(): ") + e.what()));
     }
     catch (...)
@@ -137,7 +137,7 @@
             lock_guard<mutex> lock(mutex_);
             pushable_ = false;
         }
-        BOOST_LOG(info.mw->runtime()->logger()) << "QueryBase::run(): unknown exception";
+        info.mw->runtime()->logger()() << "QueryBase::run(): unknown exception";
         reply_->finished(CompletionDetails(CompletionDetails::Error, "QueryBase::run(): unknown exception"));
     }
 }
@@ -171,7 +171,7 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(info.mw->runtime()->logger()) << "QueryBase::cancelled(): " << e.what();
+        info.mw->runtime()->logger()() << "QueryBase::cancelled(): " << e.what();
         // Deliberately no error completion here. On the client side, we short-cut the cancelled()
         // callback locally, which unregisters the servant for the cancel message and assumes that
         // cancellation will work, passing a Cancelled status, even if cancellation throws in the scope.
@@ -182,7 +182,7 @@
     }
     catch (...)
     {
-        BOOST_LOG(info.mw->runtime()->logger()) << "QueryBase::cancelled(): unknown exception";
+        info.mw->runtime()->logger()() << "QueryBase::cancelled(): unknown exception";
         // Same caveat as for std::exception here.
         reply_->finished(CompletionDetails(CompletionDetails::Cancelled, ""));
     }

=== modified file 'src/scopes/internal/RangeInputFilterImpl.cpp'
--- src/scopes/internal/RangeInputFilterImpl.cpp	2015-11-12 14:20:36 +0000
+++ src/scopes/internal/RangeInputFilterImpl.cpp	2016-03-04 15:54:04 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical Ltd
+ * Copyright (C) 2015 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License version 3 as
@@ -31,11 +31,19 @@
 namespace internal
 {
 
-RangeInputFilterImpl::RangeInputFilterImpl(std::string const& id, std::string const& start_label, std::string const& end_label, std::string const& unit_label)
+RangeInputFilterImpl::RangeInputFilterImpl(std::string const& id,
+        Variant const& default_start_value, Variant const& default_end_value,
+        std::string const& start_prefix_label, std::string const& start_postfix_label,
+        std::string const& central_label,
+        std::string const& end_prefix_label, std::string const& end_postfix_label)
     : FilterBaseImpl(id),
-      start_label_(start_label),
-      end_label_(end_label),
-      unit_label_(unit_label)
+      default_start_value_(default_start_value),
+      default_end_value_(default_end_value),
+      start_prefix_label_(start_prefix_label),
+      start_postfix_label_(start_postfix_label),
+      end_prefix_label_(end_prefix_label),
+      end_postfix_label_(end_postfix_label),
+      central_label_(central_label)
 {
 }
 
@@ -52,19 +60,39 @@
     return filter;
 }
 
-std::string RangeInputFilterImpl::start_label() const
-{
-    return start_label_;
-}
-
-std::string RangeInputFilterImpl::end_label() const
-{
-    return end_label_;
-}
-
-std::string RangeInputFilterImpl::unit_label() const
-{
-    return unit_label_;
+std::string RangeInputFilterImpl::start_prefix_label() const
+{
+    return start_prefix_label_;
+}
+
+std::string RangeInputFilterImpl::start_postfix_label() const
+{
+    return start_postfix_label_;
+}
+
+std::string RangeInputFilterImpl::end_prefix_label() const
+{
+    return end_prefix_label_;
+}
+
+std::string RangeInputFilterImpl::end_postfix_label() const
+{
+    return end_postfix_label_;
+}
+
+std::string RangeInputFilterImpl::central_label() const
+{
+    return central_label_;
+}
+
+Variant RangeInputFilterImpl::default_start_value() const
+{
+    return default_start_value_;
+}
+
+Variant RangeInputFilterImpl::default_end_value() const
+{
+    return default_end_value_;
 }
 
 bool RangeInputFilterImpl::has_value(FilterState const& filter_state, unsigned int index) const
@@ -131,7 +159,9 @@
 void RangeInputFilterImpl::check_type(Variant const& val, std::string const& filter_id, std::string const& varname)
 {
     if (val.which() == Variant::Type::Int || val.which() == Variant::Type::Double || val.is_null())
+    {
         return;
+    }
     std::stringstream err;
     err << "RangeInputFilterImpl::check_type(): Invalid variant type for " << varname << ", filter '" << filter_id << "'";
     throw unity::InvalidArgumentException(err.str());
@@ -178,19 +208,31 @@
 
 void RangeInputFilterImpl::serialize(VariantMap& var) const
 {
-    var["start_label"] = start_label_;
-    var["end_label"] = end_label_;
-    var["unit_label"] = unit_label_;
+    var["default_start_value"] = default_start_value_;
+    var["default_end_value"] = default_end_value_;
+    var["start_prefix_label"] = start_prefix_label_;
+    var["start_postfix_label"] = start_postfix_label_;
+    var["end_prefix_label"] = end_prefix_label_;
+    var["end_postfix_label"] = end_postfix_label_;
+    var["central_label"] = central_label_;
 }
 
 void RangeInputFilterImpl::deserialize(VariantMap const& var)
 {
-    auto it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "start_label");
-    start_label_ = it->second.get_string();
-    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "end_label");
-    end_label_ = it->second.get_string();
-    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "unit_label");
-    unit_label_ = it->second.get_string();
+    auto it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "start_prefix_label");
+    start_prefix_label_ = it->second.get_string();
+    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "start_postfix_label");
+    start_postfix_label_ = it->second.get_string();
+    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "end_prefix_label");
+    end_prefix_label_ = it->second.get_string();
+    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "end_postfix_label");
+    end_postfix_label_ = it->second.get_string();
+    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "central_label");
+    central_label_ = it->second.get_string();
+    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "default_start_value");
+    default_start_value_ = it->second;
+    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "default_end_value");
+    default_end_value_ = it->second;
 }
 
 void RangeInputFilterImpl::validate_display_hints() const

=== modified file 'src/scopes/internal/RatingFilterImpl.cpp'
--- src/scopes/internal/RatingFilterImpl.cpp	2014-05-15 14:51:39 +0000
+++ src/scopes/internal/RatingFilterImpl.cpp	2016-03-04 15:54:04 +0000
@@ -58,7 +58,7 @@
 {
 }
 
-FilterOption::SCPtr RatingFilterImpl::add_option(std::string const& id, std::string const& label)
+FilterOption::SCPtr RatingFilterImpl::add_option(std::string const& id, std::string const& label, bool /* default_value */)
 {
     if (num_of_options() < max_rating)
     {

=== modified file 'src/scopes/internal/RegistryObject.cpp'
--- src/scopes/internal/RegistryObject.cpp	2015-12-08 01:02:15 +0000
+++ src/scopes/internal/RegistryObject.cpp	2016-03-04 15:54:04 +0000
@@ -91,7 +91,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(logger_) << "RegistryObject(): failed to create registry publisher: " << e.what();
+            logger_() << "RegistryObject(): failed to create registry publisher: " << e.what();
         }
     }
 }
@@ -120,7 +120,7 @@
         }
         catch(std::exception const& e)
         {
-            BOOST_LOG(logger_) << "RegistryObject::~RegistryObject(): " << e.what();
+            logger_() << "RegistryObject::~RegistryObject(): " << e.what();
         }
     }
 }
@@ -154,7 +154,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(logger_) << "cannot get metadata from remote registry: " << e.what();
+            logger_() << "cannot get metadata from remote registry: " << e.what();
         }
     }
 
@@ -182,7 +182,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(logger_) << "cannot get scopes list from remote registry: " << e.what();
+            logger_() << "cannot get scopes list from remote registry: " << e.what();
         }
     }
 
@@ -377,8 +377,7 @@
                 it->second->update_state(ScopeProcess::ProcessState::Stopping);
                 break;
             default:
-                BOOST_LOG(logger_)
-                    << "RegistryObject::on_state_received(): unknown state received from scope: " << scope_id;
+                logger_() << "RegistryObject::on_state_received(): unknown state received from scope: " << scope_id;
         }
     }
     // simply ignore states from scopes the registry does not know about
@@ -463,7 +462,7 @@
 
 RegistryObject::ScopeProcess::ScopeProcess(ScopeExecData exec_data,
                                            std::weak_ptr<MWPublisher> const& publisher,
-                                           boost::log::sources::severity_channel_logger_mt<>& logger)
+                                           unity::scopes::internal::Logger& logger)
     : exec_data_(exec_data)
     , reg_publisher_(publisher)
     , manually_started_(false)
@@ -479,7 +478,7 @@
     }
     catch(std::exception const& e)
     {
-        BOOST_LOG(logger_) << "RegistryObject::ScopeProcess::~ScopeProcess(): " << e.what();
+        logger_() << "RegistryObject::ScopeProcess::~ScopeProcess(): " << e.what();
     }
 }
 
@@ -518,16 +517,15 @@
     {
         if (!wait_for_state(lock, ScopeProcess::Stopped))
         {
-            BOOST_LOG(logger_)
-                << "RegistryObject::ScopeProcess::exec(): Force killing process. Scope: \""
-                << exec_data_.scope_id << "\" did not stop after " << exec_data_.timeout_ms << " ms.";
+            logger_() << "RegistryObject::ScopeProcess::exec(): Force killing process. Scope: \""
+                      << exec_data_.scope_id << "\" did not stop after " << exec_data_.timeout_ms << " ms.";
             try
             {
                 kill(lock);
             }
             catch(std::exception const& e)
             {
-                BOOST_LOG(logger_) << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
+                logger_() << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
             }
         }
     }
@@ -599,15 +597,15 @@
         }
         catch(std::exception const& e)
         {
-            BOOST_LOG(logger_) << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
+            logger_() << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
         }
         throw unity::ResourceException("RegistryObject::ScopeProcess::exec(): exec aborted. Scope: \""
                                        + exec_data_.scope_id + "\" took longer than "
                                        + std::to_string(exec_data_.timeout_ms) + " ms to start.");
     }
 
-    BOOST_LOG_SEV(logger_, Logger::Info)
-        << "RegistryObject::ScopeProcess::exec(): Process for scope: \"" << exec_data_.scope_id << "\" started";
+    logger_(LoggerSeverity::Info) << "RegistryObject::ScopeProcess::exec(): Process for scope: \""
+                                  << exec_data_.scope_id << "\" started";
 
     // 4. add the scope process to the death observer
     death_observer.add(process_);
@@ -626,9 +624,8 @@
     // check if this is the process reported to have died
     if (pid == process_.pid())
     {
-        BOOST_LOG_SEV(logger_, Logger::Info)
-            << "RegistryObject::ScopeProcess::on_process_death(): Process for scope: \"" << exec_data_.scope_id
-            << "\" exited";
+        logger_(LoggerSeverity::Info) << "RegistryObject::ScopeProcess::on_process_death(): Process for scope: \""
+                                      << exec_data_.scope_id << "\" exited";
         clear_handle_unlocked();
         return true;
     }
@@ -659,9 +656,8 @@
 
         if (state_ != Starting)
         {
-            BOOST_LOG_SEV(logger_, Logger::Info)
-                << "RegistryObject::ScopeProcess: Process for scope: \"" << exec_data_.scope_id
-                << "\" started manually";
+            logger_(LoggerSeverity::Info) << "RegistryObject::ScopeProcess: Process for scope: \""
+                                          << exec_data_.scope_id << "\" started manually";
 
             manually_started_ = true;
         }
@@ -676,9 +672,8 @@
 
         if (state_ != Stopping)
         {
-            BOOST_LOG(logger_)
-                << "RegistryObject::ScopeProcess: Scope: \"" << exec_data_.scope_id
-                << "\" closed unexpectedly. Either the process crashed or was killed forcefully.";
+            logger_() << "RegistryObject::ScopeProcess: Scope: \"" << exec_data_.scope_id
+                      << "\" closed unexpectedly. Either the process crashed or was killed forcefully.";
         }
     }
     else if (new_state == Stopping && manually_started_)
@@ -689,9 +684,8 @@
             reg_publisher->send_message("stopped", exec_data_.scope_id);
         }
 
-        BOOST_LOG(logger_)
-            << "RegistryObject::ScopeProcess: Manually started process for scope: \""
-            << exec_data_.scope_id << "\" exited";
+        logger_() << "RegistryObject::ScopeProcess: Manually started process for scope: \""
+                  << exec_data_.scope_id << "\" exited";
 
         new_state = Stopped;
         manually_started_ = false;
@@ -731,10 +725,9 @@
         {
             std::error_code ec;
 
-            BOOST_LOG(logger_)
-                << "RegistryObject::ScopeProcess::kill(): Scope: \"" << exec_data_.scope_id
-                << "\" took longer than " << exec_data_.timeout_ms << " ms to exit gracefully. "
-                << "Killing the process instead.";
+            logger_() << "RegistryObject::ScopeProcess::kill(): Scope: \"" << exec_data_.scope_id
+                      << "\" took longer than " << exec_data_.timeout_ms << " ms to exit gracefully. "
+                    << "Killing the process instead.";
 
             // scope is taking too long to close, send kill signal
             process_.send_signal(core::posix::Signal::sig_kill, ec);
@@ -745,8 +738,7 @@
     }
     catch (std::exception const&)
     {
-        BOOST_LOG(logger_)
-            << "RegistryObject::ScopeProcess::kill(): Failed to kill scope: \"" << exec_data_.scope_id << "\"";
+        logger_() << "RegistryObject::ScopeProcess::kill(): Failed to kill scope: \"" << exec_data_.scope_id << "\"";
 
         // clear the process handle
         // even on error, the previous handle will be unrecoverable at this point
@@ -821,10 +813,9 @@
             started_message += " string:" + exec_data_.scope_id + " uint64:" + std::to_string(process_.pid());
             if (safe_system_call(started_message) != 0)
             {
-                BOOST_LOG(logger_)
-                    << "RegistryObject::ScopeProcess::publish_state_change(): "
-                       "Failed to execute SDK DBus ScopeLoaded callback "
-                       "(Scope ID: " << exec_data_.scope_id << ")";
+                logger_() << "RegistryObject::ScopeProcess::publish_state_change(): "
+                             "Failed to execute SDK DBus ScopeLoaded callback "
+                             "(Scope ID: " << exec_data_.scope_id << ")";
             }
         }
     }
@@ -842,10 +833,9 @@
             stopped_message += " string:" + exec_data_.scope_id;
             if (safe_system_call(stopped_message) != 0)
             {
-                BOOST_LOG(logger_)
-                    << "RegistryObject::ScopeProcess::publish_state_change(): "
-                       "Failed to execute SDK DBus ScopeStopped callback "
-                       "(Scope ID: " << exec_data_.scope_id << ")";
+                logger_() << "RegistryObject::ScopeProcess::publish_state_change(): "
+                             "Failed to execute SDK DBus ScopeStopped callback "
+                             "(Scope ID: " << exec_data_.scope_id << ")";
             }
         }
     }

=== modified file 'src/scopes/internal/ReplyImpl.cpp'
--- src/scopes/internal/ReplyImpl.cpp	2015-11-25 08:55:19 +0000
+++ src/scopes/internal/ReplyImpl.cpp	2016-03-04 15:54:04 +0000
@@ -121,7 +121,7 @@
     {
         error_message = "unknown exception";
     }
-    BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger()) << "ReplyImpl::error(): " << error_message;
+    mw_proxy_->mw_base()->runtime()->logger()() << "ReplyImpl::error(): " << error_message;
 
     try
     {
@@ -129,8 +129,7 @@
     }
     catch (std::exception const&)
     {
-        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
-            << "ReplyImpl::error(): exception from finished(): " << error_message;
+        mw_proxy_->mw_base()->runtime()->logger()() << "ReplyImpl::error(): exception from finished(): " << error_message;
     }
 }
 
@@ -147,8 +146,7 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
-            << "ReplyImpl::error(): exception from info(): " << e.what();
+        mw_proxy_->mw_base()->runtime()->logger()() << "ReplyImpl::error(): exception from info(): " << e.what();
     }
 }
 

=== modified file 'src/scopes/internal/ReplyObject.cpp'
--- src/scopes/internal/ReplyObject.cpp	2015-06-09 07:27:24 +0000
+++ src/scopes/internal/ReplyObject.cpp	2016-03-04 15:54:04 +0000
@@ -135,7 +135,7 @@
     // Safe to call finished now if something went wrong or cardinality was exceeded.
     if (!error.empty())
     {
-        BOOST_LOG(runtime_->logger()) << "ReplyObject::push(): " << error;
+        runtime_->logger()() << "ReplyObject::push(): " << error;
         finished(CompletionDetails(CompletionDetails::Error, error));
     }
     else if (stop)
@@ -183,11 +183,11 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(runtime_->logger()) << "ReplyObject::finished(): " << e.what();
+        runtime_->logger()() << "ReplyObject::finished(): " << e.what();
     }
     catch (...)
     {
-        BOOST_LOG(runtime_->logger()) << "ReplyObject::finished(): unknown exception";
+        runtime_->logger()() << "ReplyObject::finished(): unknown exception";
     }
 
     // Disconnect self from middleware, if this hasn't happened yet.
@@ -219,11 +219,11 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(runtime_->logger()) << "ReplyObject::info(): " << e.what();
+        runtime_->logger()() << "ReplyObject::info(): " << e.what();
     }
     catch (...)
     {
-        BOOST_LOG(runtime_->logger()) << "ReplyObject::info(): unknown exception";
+        runtime_->logger()() << "ReplyObject::info(): unknown exception";
     }
 }
 

=== modified file 'src/scopes/internal/ResultReplyObject.cpp'
--- src/scopes/internal/ResultReplyObject.cpp	2015-06-09 07:27:24 +0000
+++ src/scopes/internal/ResultReplyObject.cpp	2016-03-04 15:54:04 +0000
@@ -24,6 +24,7 @@
 #include <unity/scopes/internal/CategorisedResultImpl.h>
 #include <unity/scopes/internal/DepartmentImpl.h>
 #include <unity/scopes/FilterBase.h>
+#include <unity/scopes/internal/FilterGroupImpl.h>
 #include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/internal/FilterStateImpl.h>
 #include <unity/UnityExceptions.h>
@@ -65,7 +66,14 @@
     auto it = data.find("filters");
     if (it != data.end())
     {
-        Filters const filters = FilterBaseImpl::deserialize_filters(it->second.get_array());
+        auto itgr = data.find("filter_groups");
+        std::map<std::string, FilterGroup::SCPtr> groups;
+        if (itgr != data.end())
+        {
+            groups = FilterGroupImpl::deserialize_filter_groups(itgr->second.get_array());
+        }
+
+        Filters const filters = FilterBaseImpl::deserialize_filters(it->second.get_array(), groups);
         it = data.find("filter_state");
         if (it != data.end())
         {

=== modified file 'src/scopes/internal/RuntimeConfig.cpp'
--- src/scopes/internal/RuntimeConfig.cpp	2015-12-16 06:55:08 +0000
+++ src/scopes/internal/RuntimeConfig.cpp	2016-03-04 15:54:04 +0000
@@ -53,9 +53,6 @@
 const string cache_dir_key = "CacheDir";
 const string app_dir_key = "AppDir";
 const string config_dir_key = "ConfigDir";
-const string log_dir_key = "LogDir";
-const string max_log_file_size_key = "Log.MaxFileSize";
-const string max_log_dir_size_key = "Log.MaxDirSize";
 const string trace_channels_key = "Log.TraceChannels";
 
 }  // namespace
@@ -73,8 +70,6 @@
         default_middleware_configfile_ = DFLT_ZMQ_MIDDLEWARE_INI;
         reap_expiry_ = DFLT_REAP_EXPIRY;
         reap_interval_ = DFLT_REAP_INTERVAL;
-        max_log_file_size_ = DFLT_MAX_LOG_FILE_SIZE;
-        max_log_dir_size_ = DFLT_MAX_LOG_DIR_SIZE;
         cache_directory_ = default_cache_directory();
         app_directory_ = default_app_directory();
         config_directory_ = default_config_directory();
@@ -142,29 +137,6 @@
             }
         }
 
-        log_directory_ = get_optional_string(runtime_config_group, log_dir_key);
-
-        // Check if we have an override for the log directory.
-        char const* logdir = getenv("UNITY_SCOPES_LOGDIR");
-        if (logdir)
-        {
-            log_directory_ = logdir;
-        }
-
-        max_log_file_size_ = get_optional_int(runtime_config_group, max_log_file_size_key, DFLT_MAX_LOG_FILE_SIZE);
-        if (max_log_file_size_ < 1024)
-        {
-            throw_ex("Illegal value (" + to_string(max_log_file_size_) + ") for " + max_log_file_size_key
-                     + ": value must be > 1024");
-        }
-
-        max_log_dir_size_ = get_optional_int(runtime_config_group, max_log_dir_size_key, DFLT_MAX_LOG_DIR_SIZE);
-        if (max_log_dir_size_ <= max_log_file_size_)
-        {
-            throw_ex("Illegal value (" + to_string(max_log_dir_size_) + ") for " + max_log_dir_size_key
-                     + ": value must be > " + max_log_file_size_key + " (" + to_string(max_log_file_size_) + ")");
-        }
-
         try
         {
             trace_channels_ = parser()->get_string_array(runtime_config_group, trace_channels_key);
@@ -198,9 +170,6 @@
                                                 cache_dir_key,
                                                 app_dir_key,
                                                 config_dir_key,
-                                                log_dir_key,
-                                                max_log_file_size_key,
-                                                max_log_dir_size_key,
                                                 trace_channels_key
                                              }
                                           }
@@ -267,21 +236,6 @@
     return config_directory_;
 }
 
-string RuntimeConfig::log_directory() const
-{
-    return log_directory_;
-}
-
-int RuntimeConfig::max_log_file_size() const
-{
-    return max_log_file_size_;
-}
-
-int RuntimeConfig::max_log_dir_size() const
-{
-    return max_log_dir_size_;
-}
-
 vector<string> RuntimeConfig::trace_channels() const
 {
     return trace_channels_;
@@ -317,19 +271,6 @@
     return string(home) + "/" + DFLT_HOME_CONFIG_SUBDIR;
 }
 
-string RuntimeConfig::default_log_directory()
-{
-    char const* home = getenv("HOME");
-    if (!home || *home == '\0')
-    {
-        throw ResourceException("RuntimeConfig::default_log_directory(): $HOME not set");
-    }
-    string dir = string(home) + "/" + DFLT_HOME_LOG_SUBDIR;
-    make_directories(dir, 0700);
-
-    return dir;
-}
-
 } // namespace internal
 
 } // namespace scopes

=== modified file 'src/scopes/internal/RuntimeImpl.cpp'
--- src/scopes/internal/RuntimeImpl.cpp	2015-12-18 09:21:53 +0000
+++ src/scopes/internal/RuntimeImpl.cpp	2016-03-04 15:54:04 +0000
@@ -81,23 +81,16 @@
         RuntimeConfig config(configfile);
 
         // Configure trace channels.
-        try
-        {
-            logger_->enable_channels(config.trace_channels());
-        }
-        catch (...)
-        {
-            throw InvalidArgumentException("Runtime(): invalid trace channel name(s)");
-        }
-
-        // Now that we have the config, change the logger to log to a file.
-        // If log_dir is set to the empty string, continue logging to std::clog.
-        log_dir_ = config.log_directory();
-        if (!log_dir_.empty())
-        {
-            logger_->set_log_file(find_log_dir(log_file_basename) + "/" + log_file_basename,
-                                  config.max_log_file_size(),
-                                  config.max_log_dir_size());
+        for (auto const& c : config.trace_channels())
+        {
+            try
+            {
+                logger_->set_channel(c, true);
+            }
+            catch (...)
+            {
+                throw InvalidArgumentException("Runtime(): invalid trace channel name");
+            }
         }
 
         string default_middleware = config.default_middleware();
@@ -119,7 +112,7 @@
 
         if (registry_configfile_.empty() || registry_identity_.empty())
         {
-            BOOST_LOG_SEV(logger(), Logger::Warning) << "no registry configured";
+            logger()(LoggerSeverity::Warning) << "no registry configured";
             registry_identity_ = "";
         }
         else
@@ -140,7 +133,7 @@
         string msg = "Cannot instantiate run time for " + (scope_id.empty() ? "client" : scope_id) +
                      ", config file: " + configfile;
         ConfigException ex(msg);
-        BOOST_LOG(logger()) << ex.what();
+        logger()() << ex.what();
         throw ex;
     }
 }
@@ -153,11 +146,11 @@
     }
     catch (std::exception const& e) // LCOV_EXCL_LINE
     {
-        BOOST_LOG(logger()) << "~RuntimeImpl(): " << e.what();
+        logger()() << "~RuntimeImpl(): " << e.what();
     }
     catch (...) // LCOV_EXCL_LINE
     {
-        BOOST_LOG(logger()) << "~RuntimeImpl(): unknown exception";
+        logger()() << "~RuntimeImpl(): unknown exception";
     }
 }
 
@@ -311,16 +304,11 @@
     return future_queue_;  // Immutable
 }
 
-boost::log::sources::severity_channel_logger_mt<>& RuntimeImpl::logger() const
+internal::Logger& RuntimeImpl::logger() const
 {
     return *logger_;
 }
 
-boost::log::sources::severity_channel_logger_mt<>& RuntimeImpl::logger(Logger::Channel channel) const
-{
-    return (*logger_)(channel);
-}
-
 namespace
 {
 

=== modified file 'src/scopes/internal/ScopeObject.cpp'
--- src/scopes/internal/ScopeObject.cpp	2015-06-01 13:33:27 +0000
+++ src/scopes/internal/ScopeObject.cpp	2016-03-04 15:54:04 +0000
@@ -84,7 +84,7 @@
         if (!query_base)
         {
             string msg = "Scope \"" + mw_base->runtime()->scope_id() + "\" returned nullptr from " + method + "()";
-            BOOST_LOG(mw_base->runtime()->logger()) << msg;
+            mw_base->runtime()->logger()() << msg;
             throw ResourceException(msg);
         }
         query_base->p->set_settings_db(scope_base_->p->settings_db());
@@ -92,7 +92,7 @@
     catch (...)
     {
         string msg = "Scope \"" + mw_base->runtime()->scope_id() + "\" threw an exception from " + method + "()";
-        BOOST_LOG(mw_base->runtime()->logger()) << msg;
+        mw_base->runtime()->logger()() << msg;
         throw ResourceException(msg);
     }
 
@@ -130,7 +130,7 @@
         catch (...)
         {
         }
-        BOOST_LOG(mw_base->runtime()->logger()) << "ScopeObject::query(): " << e.what();
+        mw_base->runtime()->logger()() << "ScopeObject::query(): " << e.what();
         throw;
     }
     catch (...)
@@ -142,7 +142,7 @@
         catch (...)
         {
         }
-        BOOST_LOG(mw_base->runtime()->logger()) << "ScopeObject::query(): unknown exception";
+        mw_base->runtime()->logger()() << "ScopeObject::query(): unknown exception";
         throw;
     }
     return ctrl_proxy;

=== modified file 'src/scopes/internal/SearchQueryBaseImpl.cpp'
--- src/scopes/internal/SearchQueryBaseImpl.cpp	2015-05-29 15:06:06 +0000
+++ src/scopes/internal/SearchQueryBaseImpl.cpp	2016-03-04 15:54:04 +0000
@@ -210,8 +210,7 @@
         // scope_impl can be nullptr if we use a mock scope: TypedScopeFixture<testing::Scope>
         if (scope_impl)
         {
-            auto logger = scope_impl->runtime()->logger();
-            BOOST_LOG_SEV(logger, Logger::Warning)
+            scope_impl->runtime()->logger()(LoggerSeverity::Warning)
                 << "query loop for query \"" << canned_query_.query_string()
                 << "\", client: " << get<0>(tuple)
                 << ", aggregator: " << get<1>(tuple)

=== modified file 'src/scopes/internal/SearchReplyImpl.cpp'
--- src/scopes/internal/SearchReplyImpl.cpp	2015-11-25 08:55:19 +0000
+++ src/scopes/internal/SearchReplyImpl.cpp	2016-03-04 15:54:04 +0000
@@ -24,14 +24,19 @@
 #include <unity/scopes/internal/DepartmentImpl.h>
 #include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/internal/FilterStateImpl.h>
+#include <unity/scopes/internal/FilterGroupImpl.h>
 #include <unity/scopes/internal/MWReply.h>
 #include <unity/scopes/internal/QueryObjectBase.h>
 #include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/ScopeExceptions.h>
 #include <unity/UnityExceptions.h>
 #include <unity/util/FileIO.h>
+#include <unity/util/ResourcePtr.h>
+
+#include <cassert>
 
 #include <stdlib.h>
+#include <unistd.h>
 
 using namespace std;
 
@@ -185,6 +190,11 @@
     }
 
     VariantMap var;
+    auto filter_groups = internal::FilterGroupImpl::serialize_filter_groups(filters);
+    if (filter_groups.size())
+    {
+        var["filter_groups"] = filter_groups;
+    }
     var["filters"] = internal::FilterBaseImpl::serialize_filters(filters);
     var["filter_state"] = filter_state.serialize();
     return ReplyImpl::push(var);
@@ -260,8 +270,17 @@
         VariantMap vm;
         vm["departments"] = move(departments);
         vm["categories"] = move(categories);
+
+        // serialize filter groups if present
+        auto filter_groups = internal::FilterGroupImpl::serialize_filter_groups(cached_filters_);
+        if (filter_groups.size())
+        {
+            vm["filter_groups"] = move(filter_groups);
+        }
+
         vm["filters"] = move(filters);
         vm["filter_state"] = move(filter_state);
+
         vm["results"] = move(results);
         string const json = Variant(move(vm)).serialize_json();
 
@@ -285,15 +304,13 @@
     catch (std::exception const& e)
     {
         ::unlink(tmp_path.c_str());
-        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
-            << "SearchReply::write_cached_results(): " << e.what();
+        mw_proxy_->mw_base()->runtime()->logger()() << "SearchReply::write_cached_results(): " << e.what();
     }
     // LCOV_EXCL_START
     catch (...)
     {
         ::unlink(tmp_path.c_str());
-        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
-            << "SearchReply::write_cached_results(): unknown exception";
+        mw_proxy_->mw_base()->runtime()->logger()() << "SearchReply::write_cached_results(): unknown exception";
     }
     // LCOV_EXCL_STOP
 }
@@ -383,7 +400,14 @@
             register_category(cp);
         }
 
-        auto filters = FilterBaseImpl::deserialize_filters(move(filter_array));
+        std::map<std::string, FilterGroup::SCPtr> groups;
+        it = vm.find("filter_groups");
+        if (it != vm.end())
+        {
+            groups = FilterGroupImpl::deserialize_filter_groups(it->second.get_array());
+        }
+
+        auto filters = FilterBaseImpl::deserialize_filters(move(filter_array), groups);
         auto filter_state = FilterStateImpl::deserialize(move(filter_state_dict));
         push(filters, filter_state);
 
@@ -396,13 +420,13 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+        mw_proxy_->mw_base()->runtime()->logger()()
             << "SearchReply::push_surfacing_results_from_cache() (file = " + cache_path + "): " << e.what();
     }
     // LCOV_EXCL_START
     catch (...)
     {
-        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+        mw_proxy_->mw_base()->runtime()->logger()()
             << "SearchReply::push_surfacing_results_from_cache() (file = " + cache_path + "): unknown exception";
     }
     // LCOV_EXCL_STOP

=== modified file 'src/scopes/internal/ValueSliderFilterImpl.cpp'
--- src/scopes/internal/ValueSliderFilterImpl.cpp	2015-11-12 14:20:36 +0000
+++ src/scopes/internal/ValueSliderFilterImpl.cpp	2016-03-04 15:54:04 +0000
@@ -32,26 +32,21 @@
 namespace internal
 {
 
-ValueSliderFilterImpl::ValueSliderFilterImpl(std::string const& id, std::string const& label, std::string const& label_template, double min, double max)
+ValueSliderFilterImpl::ValueSliderFilterImpl(std::string const& id, double min, double max, double default_value, ValueSliderLabels const& labels)
     : FilterBaseImpl(id),
-      label_(label),
-      label_template_(label_template),
-      slider_type_(ValueSliderFilter::SliderType::LessThan),
       min_(min),
-      max_(max)
+      max_(max),
+      default_val_(default_value),
+      labels_(new ValueSliderLabels(labels))
 {
-    if (label.empty())
-    {
-        throw InvalidArgumentException("ValueSliderFilterImpl(): Invalid empty label string");
-    }
-
-    if (min < 0 || min >= max)
+    if (default_value < min || default_value > max)
     {
         std::stringstream err;
-        err << "ValueSliderFilterImpl::ValueSliderFilterImpl(): invalid min or max value for filter '" << id << "', min is " << min << ", max is " << max;
-        throw LogicException(err.str());
+        err << "ValueSliderFilterImpl::ValueSliderFilterImpl(): invalid default value for filter '" << id << "', " << default_value << " not in " << min << "-"
+            << max << " range";
+        throw InvalidArgumentException(err.str());
     }
-    default_val_ = max;
+    labels_->p->validate(min_, max_);
 }
 
 ValueSliderFilterImpl::ValueSliderFilterImpl(VariantMap const& var)
@@ -73,16 +68,6 @@
     default_val_ = val;
 }
 
-void ValueSliderFilterImpl::set_slider_type(ValueSliderFilter::SliderType tp)
-{
-    slider_type_ = tp;
-}
-
-ValueSliderFilter::SliderType ValueSliderFilterImpl::slider_type() const
-{
-    return slider_type_;
-}
-
 double ValueSliderFilterImpl::default_value() const
 {
     return default_val_;
@@ -98,14 +83,11 @@
     return max_;
 }
 
-std::string ValueSliderFilterImpl::label() const
-{
-    return label_;
-}
-
-std::string ValueSliderFilterImpl::value_label_template() const
-{
-    return label_template_;
+ValueSliderLabels const& ValueSliderFilterImpl::labels() const
+{
+    // labels_ pointer is guaranteed to be initialized either by the regular ctor or when deserialized from a variant
+    assert(labels_);
+    return *labels_;
 }
 
 bool ValueSliderFilterImpl::has_value(FilterState const& filter_state) const
@@ -119,7 +101,7 @@
     {
         try
         {
-            double val = FilterBaseImpl::get(filter_state, id()).get_double(); // this can throw if of different type
+            auto val = FilterBaseImpl::get(filter_state, id()).get_double(); // this can throw if of different type
             check_range(val);
             return val;
         }
@@ -154,28 +136,23 @@
 
 void ValueSliderFilterImpl::serialize(VariantMap& var) const
 {
-    var["label"] = label_;
-    var["label_template"] = label_template_;
     var["min"] = Variant(min_);
     var["max"] = Variant(max_);
     var["default"] = Variant(default_val_);
-    var["slider_type"] = static_cast<int>(slider_type_);
+    var["labels"] = Variant(labels_->serialize());
 }
 
 void ValueSliderFilterImpl::deserialize(VariantMap const& var)
 {
-    auto it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "label");
-    label_ = it->second.get_string();
-    it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "label_template");
-    label_template_ = it->second.get_string();
-    it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "min");
+    auto it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "min");
     min_ = it->second.get_double();
     it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "max");
     max_ = it->second.get_double();
     it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "default");
     default_val_ = it->second.get_double();
-    it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "slider_type");
-    slider_type_ = static_cast<ValueSliderFilter::SliderType>(it->second.get_int());
+    it = find_or_throw("ValueSliderFilterImpl::deserialize()", var, "labels");
+    labels_.reset(new ValueSliderLabels(it->second.get_dict()));
+    labels_->p->validate(min_, max_);
 }
 
 std::string ValueSliderFilterImpl::filter_type() const
@@ -189,7 +166,7 @@
     {
         std::stringstream err;
         err << "ValueSliderFilterImpl::check_range(): value " << val << " outside of allowed range (" << min_ << ", " << max_ << ")";
-        throw LogicException(err.str());
+        throw InvalidArgumentException(err.str());
     }
 }
 

=== added file 'src/scopes/internal/ValueSliderLabelsImpl.cpp'
--- src/scopes/internal/ValueSliderLabelsImpl.cpp	1970-01-01 00:00:00 +0000
+++ src/scopes/internal/ValueSliderLabelsImpl.cpp	2016-03-04 15:54:04 +0000
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Pawel Stolowski <[e-mail]>
+ */
+
+#include <unity/scopes/internal/ValueSliderLabelsImpl.h>
+#include <unity/scopes/internal/Utils.h>
+#include <unity/UnityExceptions.h>
+#include <unordered_set>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+ValueSliderLabelsImpl::ValueSliderLabelsImpl(std::string const& min_label, std::string const& max_label)
+    : min_label_(min_label),
+      max_label_(max_label)
+{
+}
+
+ValueSliderLabelsImpl::ValueSliderLabelsImpl(std::string const& min_label, std::string const& max_label, std::vector<std::pair<double, std::string>> const& extra_labels)
+    : min_label_(min_label),
+      max_label_(max_label),
+      extra_labels_(extra_labels)
+{
+}
+
+ValueSliderLabelsImpl::ValueSliderLabelsImpl(VariantMap const& var)
+{
+    deserialize(var);
+}
+
+std::string ValueSliderLabelsImpl::min_label() const
+{
+    return min_label_;
+}
+
+std::string ValueSliderLabelsImpl::max_label() const
+{
+    return max_label_;
+}
+
+std::vector<std::pair<double, std::string>> ValueSliderLabelsImpl::extra_labels() const
+{
+    return extra_labels_;
+}
+
+void ValueSliderLabelsImpl::validate(double min, double max) const
+{
+    if (min >= max)
+    {
+        std::stringstream err;
+        err << "ValueSliderLabelsImpl::validate(): invalid range " << min << ", " << max;
+        throw InvalidArgumentException(err.str());
+    }
+
+    double last_value = min;
+    std::unordered_set<std::string> label_lut;
+
+    // check that values of extra labels grow, i.e. v1 < v2 < v3 ... and lables are unique and not empty
+    for (auto const &p: extra_labels_)
+    {
+        if (p.first <= last_value)
+        {
+            std::stringstream err;
+            err << "ValueSliderLabelsImpl::validate(): value " << p.first << " for extra label '" << p.second << "' must be greater than previous value";
+            throw InvalidArgumentException(err.str());
+        }
+        if (p.second == "")
+        {
+            std::stringstream err;
+            err << "ValueSliderLabelsImpl::validate(): extra label for value " << p.first << " cannot be empty";
+            throw InvalidArgumentException(err.str());
+        }
+        if (p.second == min_label_ || p.second == max_label_)
+        {
+            std::stringstream err;
+            err << "ValueSliderLabelsImpl::validate(): extra label for value " << p.first << " must not be equal to min or max labels";
+            throw InvalidArgumentException(err.str());
+        }
+        if (label_lut.find(p.second) != label_lut.end())
+        {
+            std::stringstream err;
+            err << "ValueSliderLabelsImpl::validate(): multiple definitions of label '" << p.second << "'";
+            throw InvalidArgumentException(err.str());
+        }
+        label_lut.insert(p.second);
+        last_value = p.first;
+    }
+
+    if (max <= last_value)
+    {
+        std::stringstream err;
+        err << "ValueSliderLabelsImpl::validate(): the value of last extra label must not be greater than the maximum value " << max;
+        throw InvalidArgumentException(err.str());
+    }
+}
+
+VariantMap ValueSliderLabelsImpl::serialize() const
+{
+    VariantMap vm;
+    VariantArray va;
+    for (auto const& p: extra_labels_)
+    {
+        va.push_back(Variant(p.first));
+        va.push_back(Variant(p.second));
+    }
+    vm["extra_labels"] = Variant(va);
+    vm["min_label"] = Variant(min_label_);
+    vm["max_label"] = Variant(max_label_);
+    return vm;
+}
+
+void ValueSliderLabelsImpl::deserialize(VariantMap const& var)
+{
+    auto it = find_or_throw("ValueSliderLabels::deserialize()", var, "min_label");
+    min_label_ = it->second.get_string();
+    it = find_or_throw("ValueSliderLabels::deserialize()", var, "max_label");
+    max_label_ = it->second.get_string();
+    it = var.find("extra_labels");
+    if (it != var.end())
+    {
+        auto const va = it->second.get_array();
+        for (auto it = va.begin(); it != va.end();)
+        {
+            auto const value = (it++)->get_double();
+            if (it == va.end())
+            {
+                throw unity::InvalidArgumentException("ValueSliderLabels::deserialize(): invalid value-label array");
+            }
+            std::string const label = (it++)->get_string();
+            extra_labels_.push_back(std::make_pair<>(value, label));
+        }
+    }
+}
+}
+
+}
+
+}

=== modified file 'src/scopes/internal/smartscopes/SSQueryObject.cpp'
--- src/scopes/internal/smartscopes/SSQueryObject.cpp	2015-01-09 07:10:07 +0000
+++ src/scopes/internal/smartscopes/SSQueryObject.cpp	2016-03-04 15:54:04 +0000
@@ -95,7 +95,7 @@
         std::lock_guard<std::mutex> lock(queries_mutex_);
 
         query_it->second->q_pushable = false;
-        BOOST_LOG(info.mw->runtime()->logger()) << "SSQueryObject::run(): " << e.what();
+        info.mw->runtime()->logger()() << "SSQueryObject::run(): " << e.what();
         reply->finished(CompletionDetails(CompletionDetails::Error, e.what()));  // Oneway, can't block
     }
     catch (...)
@@ -103,7 +103,7 @@
         std::lock_guard<std::mutex> lock(queries_mutex_);
 
         query_it->second->q_pushable = false;
-        BOOST_LOG(info.mw->runtime()->logger()) << "SSQueryObject::run(): unknown exception";
+        info.mw->runtime()->logger()() << "SSQueryObject::run(): unknown exception";
         reply->finished(CompletionDetails(CompletionDetails::Error, "unknown exception"));  // Oneway, can't block
     }
 

=== modified file 'src/scopes/internal/smartscopes/SSRegistryObject.cpp'
--- src/scopes/internal/smartscopes/SSRegistryObject.cpp	2015-11-26 05:48:01 +0000
+++ src/scopes/internal/smartscopes/SSRegistryObject.cpp	2016-03-04 15:54:04 +0000
@@ -82,7 +82,7 @@
     catch (std::exception const& e)
     {
 
-        BOOST_LOG(middleware_->runtime()->logger()) << "SSRegistryObject: get_remote_scopes() failed: " << e.what();
+        middleware_->runtime()->logger()() << "SSRegistryObject: get_remote_scopes() failed: " << e.what();
     }
 
     refresh_thread_ = std::thread(&SSRegistryObject::refresh_thread, this);
@@ -95,8 +95,8 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(middleware_->runtime()->logger())
-                << "SSRegistryObject(): failed to create registry publisher: " << e.what();
+            middleware_->runtime()->logger()() << "SSRegistryObject(): failed to create registry publisher: "
+                                               << e.what();
         }
     }
 }
@@ -209,8 +209,7 @@
             }
             catch (std::exception const& e)
             {
-                BOOST_LOG(middleware_->runtime()->logger())
-                    << "SSRegistryObject: get_remote_scopes() failed: " << e.what();
+                middleware_->runtime()->logger()() << "SSRegistryObject: get_remote_scopes() failed: " << e.what();
             }
         }
     }
@@ -283,9 +282,9 @@
                 }
                 catch (ResourceException const& e)
                 {
-                    BOOST_LOG(middleware_->runtime()->logger())
-                        << "SSRegistryObject: ignoring invalid settings JSON for scope \"" << scope.id << "\": "
-                        << e.what();
+                    middleware_->runtime()->logger()()
+                        << "SSRegistryObject: ignoring invalid settings JSON for scope \""
+                        << scope.id << "\": " << e.what();
                 }
             }
             else if (needs_location_data)
@@ -330,9 +329,8 @@
                 }
                 catch (ResourceException const& e)
                 {
-                    BOOST_LOG(middleware_->runtime()->logger())
-                        << "SSRegistryObject: ignoring invalid settings JSON for scope \"" << scope.id << "\": "
-                        << e.what();
+                    middleware_->runtime()->logger()() << "SSRegistryObject: ignoring invalid settings JSON for scope \""
+                                                       << scope.id << "\": " << e.what();
                 }
             }
 
@@ -356,8 +354,8 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(middleware_->runtime()->logger())
-                << "SSRegistryObject: skipping scope \"" << scope.id << "\": " << e.what();
+            middleware_->runtime()->logger()() << "SSRegistryObject: skipping scope \""
+                                               << scope.id << "\": " << e.what();
         }
     }
 

=== modified file 'src/scopes/internal/smartscopes/SSScopeObject.cpp'
--- src/scopes/internal/smartscopes/SSScopeObject.cpp	2015-05-29 12:02:54 +0000
+++ src/scopes/internal/smartscopes/SSScopeObject.cpp	2016-03-04 15:54:04 +0000
@@ -187,7 +187,7 @@
         catch (...)
         {
         }
-        BOOST_LOG(info.mw->runtime()->logger()) << "SSScopeObject::query(): " << e.what();
+        info.mw->runtime()->logger()() << "SSScopeObject::query(): " << e.what();
         throw;
     }
     catch (...)
@@ -199,7 +199,7 @@
         catch (...)
         {
         }
-        BOOST_LOG(info.mw->runtime()->logger()) << "SSScopeObject::query(): unknown exception";
+        info.mw->runtime()->logger()() << "SSScopeObject::query(): unknown exception";
         throw;
     }
 

=== modified file 'src/scopes/internal/smartscopes/SmartScope.cpp'
--- src/scopes/internal/smartscopes/SmartScope.cpp	2015-11-25 08:55:19 +0000
+++ src/scopes/internal/smartscopes/SmartScope.cpp	2016-03-04 15:54:04 +0000
@@ -94,7 +94,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(ss_client_->logger())
+            ss_client_->logger()()
                 << "SmartScope::run(): Failed to register filters for scope '" << filters_data.scope_id
                 << "': " << e.what();
         }
@@ -106,7 +106,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(ss_client_->logger())
+            ss_client_->logger()()
                 << "SmartScope::run(): Failed to set filter state for scope '" << filters_data.scope_id
                 << "': " << e.what();
         }
@@ -119,7 +119,7 @@
         }
         catch (std::exception const&)
         {
-            BOOST_LOG(this->ss_client_->logger())
+            this->ss_client_->logger()()
                 << "SmartScope: failed to register category: \"" << category->id
                 << "\" for scope \"" << scope_id_ << "\" and query: \"" << query_.query_string() << "\"";
         }
@@ -142,7 +142,7 @@
         }
         else
         {
-            BOOST_LOG(this->ss_client_->logger())
+            this->ss_client_->logger()()
                 << "SmartScope: result for query: \"" << scope_id_ << "\": \"" << query_.query_string()
                 << "\" returned an invalid cat_id. Skipping result.";
         }
@@ -155,7 +155,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(this->ss_client_->logger())
+            this->ss_client_->logger()()
                 << "SmartScope::run(): Failed to register departments for scope '" << scope_id_ << "': " << e.what();
         }
     };
@@ -173,7 +173,7 @@
     else
     {
         session_id = "session_id_missing";
-        BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Info)
+        this->ss_client_->logger()(LoggerSeverity::Info)
             << "SmartScope: missing or invalid session id for \"" << scope_id_ << "\": \""
             << query_.query_string() << "\"";
     }
@@ -183,7 +183,7 @@
     }
     else
     {
-        BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Info)
+        this->ss_client_->logger()(LoggerSeverity::Info)
             << "SmartScope: missing or invalid query id for \"" << scope_id_ << "\": \""
             << query_.query_string() << "\"";
     }
@@ -209,7 +209,7 @@
             settings(), query_.filter_state().serialize(), hints_.locale(), loc, agent, hints_.cardinality());
     search_handle_->wait();
 
-    BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Info)
+    this->ss_client_->logger()(LoggerSeverity::Info)
         << "SmartScope: query for \"" << scope_id_ << "\": \"" << query_.query_string() << "\" complete";
 }
 
@@ -286,7 +286,7 @@
     else
     {
         session_id = "session_id_missing";
-        BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Info)
+        this->ss_client_->logger()(LoggerSeverity::Info)
             << "SmartScope: missing or invalid session id for \"" << scope_id_ << "\" preview: \""
             << result().uri() << "\"";
     }
@@ -301,7 +301,7 @@
 
     preview_handle_->wait();
 
-    BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Info)
+    this->ss_client_->logger()(LoggerSeverity::Info)
         << "SmartScope: preview for \"" << scope_id_ << "\": \"" << result().uri() << "\" complete";
 }
 
@@ -335,7 +335,7 @@
 SearchQueryBase::UPtr SmartScope::search(std::string const& scope_id, CannedQuery const& q, SearchMetadata const& hints)
 {
     SearchQueryBase::UPtr query(new SmartQuery(scope_id, reg_, q, hints));
-    BOOST_LOG_SEV(ss_client_->logger(), Logger::Info)
+    ss_client_->logger()(LoggerSeverity::Info)
         << "SmartScope: created query for \"" << scope_id << "\": \"" << q.query_string() << "\"";
     return query;
 }
@@ -343,7 +343,7 @@
 QueryBase::UPtr SmartScope::preview(std::string const& scope_id, Result const& result, ActionMetadata const& hints)
 {
     QueryBase::UPtr preview(new SmartPreview(scope_id, reg_, result, hints));
-    BOOST_LOG_SEV(ss_client_->logger(), Logger::Info)
+    ss_client_->logger()(LoggerSeverity::Info)
         << "SmartScope: created preview for \"" << scope_id << "\": \"" << result.uri() << "\"";
     return preview;
 }
@@ -357,7 +357,7 @@
 ActivationQueryBase::UPtr SmartScope::perform_action(std::string const& scope_id, Result const& result, ActionMetadata const& metadata, std::string const& widget_id, std::string const& action_id)
 {
     ActivationQueryBase::UPtr activation(new SmartActivation(result, metadata, widget_id, action_id));
-    BOOST_LOG_SEV(ss_client_->logger(), Logger::Info)
+    ss_client_->logger()(LoggerSeverity::Info)
         << "SmartScope: created activation for \"" << scope_id << "\": \"" << result.uri() << "\"";
     return activation;
 }
@@ -366,7 +366,7 @@
 {
     // NOTE: there is no endpoint for it really, SmartActivation is a no-op (not-handled)
     ActivationQueryBase::UPtr activation(new SmartActivation(result, metadata, "", action_id));
-    BOOST_LOG_SEV(ss_client_->logger(), Logger::Info)
+    ss_client_->logger()(LoggerSeverity::Info)
         << "SmartScope: created result action activation for \"" << scope_id << "\": \"" << result.uri() << "\", action_id=" << action_id;
     return activation;
 }

=== modified file 'src/scopes/internal/smartscopes/SmartScopesClient.cpp'
--- src/scopes/internal/smartscopes/SmartScopesClient.cpp	2015-12-08 01:02:15 +0000
+++ src/scopes/internal/smartscopes/SmartScopesClient.cpp	2016-03-04 15:54:04 +0000
@@ -19,6 +19,7 @@
 
 #include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/internal/FilterStateImpl.h>
+#include <unity/scopes/internal/FilterGroupImpl.h>
 #include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/internal/smartscopes/SmartScopesClient.h>
 #include <unity/scopes/internal/Utils.h>
@@ -179,7 +180,7 @@
             remote_scopes_uri << "locale=" << locale;
         }
 
-        BOOST_LOG_SEV(logger_, Logger::Info)
+        logger_(LoggerSeverity::Info)
             << "SmartScopesClient.get_remote_scopes(): GET " << remote_scopes_uri.str();
 
         HttpHeaders headers;
@@ -190,12 +191,13 @@
             {
                 std::string const user_agent_hdr = "partner=" + http_client_->to_percent_encoding(partner_id);
                 headers.push_back(std::make_pair("User-Agent", user_agent_hdr));
-                BOOST_LOG_SEV(logger_, Logger::Info) << "User agent: " << user_agent_hdr;
+                logger_(LoggerSeverity::Info) << "User agent: " << user_agent_hdr;
             }
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error) << "SmartScopesClient.get_remote_scopes(): failed to read " << partner_file_ << ": " << e.what();
+            logger_() << "SmartScopesClient.get_remote_scopes(): failed to read "
+                      << partner_file_ << ": " << e.what();
         }
 
         std::mutex reponse_mutex;
@@ -207,18 +209,16 @@
 
         response->get();
 
-        BOOST_LOG_SEV(logger_, Logger::Info)
-            << "SmartScopesClient.get_remote_scopes(): Remote scopes:\n" << response_str;
+        logger_(LoggerSeverity::Info) << "SmartScopesClient.get_remote_scopes(): Remote scopes:\n" << response_str;
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(logger_)
-            << "SmartScopesClient.get_remote_scopes(): Failed to retrieve remote scopes from uri: "
-            << url_ << c_remote_scopes_resource << ": " << e.what();
+        logger_() << "SmartScopesClient.get_remote_scopes(): Failed to retrieve remote scopes from uri: "
+                  << url_ << c_remote_scopes_resource << ": " << e.what();
 
         if (caching_enabled)
         {
-            BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes(): Using remote scopes from cache";
+            logger_() << "SmartScopesClient.get_remote_scopes(): Using remote scopes from cache";
 
             response_str = read_cache();
             if (response_str.empty())
@@ -245,8 +245,8 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes() Failed to parse json response from uri: "
-                           << url_ << c_remote_scopes_resource << ": " << e.what();
+        logger_() << "SmartScopesClient.get_remote_scopes() Failed to parse json response from uri: "
+                  << url_ << c_remote_scopes_resource << ": " << e.what();
         throw;
     }
 
@@ -261,7 +261,7 @@
 
             if (!child_node->has_node("id"))
             {
-                BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes(): Skipping scope with no id";
+                logger_() << "SmartScopesClient.get_remote_scopes(): Skipping scope with no id";
                 continue;
             }
 
@@ -273,15 +273,14 @@
             {
                 if (!child_node->has_node(field))
                 {
-                    BOOST_LOG(logger_)
-                        << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
-                        << "\" has no \"" << field << "\" field";
+                    logger_() << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
+                              << "\" has no \"" << field << "\" field";
                     err = true;
                 }
             }
             if (err)
             {
-                BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes(): Skipping scope: \"" << scope.id << "\"";
+                logger_() << "SmartScopesClient.get_remote_scopes(): Skipping scope: \"" << scope.id << "\"";
                 continue;
             }
 
@@ -320,9 +319,8 @@
             scope.version = child_node->has_node("version") ? child_node->get_node("version")->as_int() : 0;
             if (scope.version < 0)
             {
-                BOOST_LOG(logger_)
-                    << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
-                    << "\" returned a negative \"version\" value, skipping scope";
+                logger_() << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
+                          << "\" returned a negative \"version\" value, skipping scope";
                 continue;
             }
 
@@ -340,17 +338,15 @@
                         }
                         catch (unity::LogicException const&)
                         {
-                            BOOST_LOG(logger_)
-                                << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
-                                << "\" returned a non-string keyword";
+                            logger_() << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
+                                      << "\" returned a non-string keyword";
                         }
                     }
                 }
                 else
                 {
-                    BOOST_LOG(logger_)
-                        << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
-                        << "\" returned an invalid value type for \"keywords\"";
+                    logger_() << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
+                              << "\" returned an invalid value type for \"keywords\"";
                 }
             }
 
@@ -358,17 +354,15 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG(logger_)
-                << "SmartScopesClient.get_remote_scopes(): Skipping scope: \""
-                << scope.id << "\" due to a json parsing failure: " << e.what();
+            logger_() << "SmartScopesClient.get_remote_scopes(): Skipping scope: \""
+                      << scope.id << "\" due to a json parsing failure: " << e.what();
         }
     }