LCOV - code coverage report
Current view: top level - src/plugins/directoryvalue - directoryvalue.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 29 37 78.4 %
Date: 2019-09-12 12:28:41 Functions: 6 7 85.7 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Source for directoryvalue plugin
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : #include "directoryvalue.hpp"
      11             : 
      12             : #include <kdbhelper.h>
      13             : 
      14             : using std::exception;
      15             : using std::range_error;
      16             : 
      17             : using elektra::DirectoryValueDelegate;
      18             : 
      19             : using CppKey = kdb::Key;
      20             : using CppKeySet = kdb::KeySet;
      21             : 
      22             : namespace
      23             : {
      24             : 
      25             : /**
      26             :  * @brief This function returns a key set containing the plugin contract.
      27             :  *
      28             :  * @return A key set specifying the capabilities of the plugin
      29             :  */
      30         373 : CppKeySet getContract ()
      31             : {
      32             :         return CppKeySet{ 30,
      33             :                           keyNew ("system/elektra/modules/directoryvalue", KEY_VALUE, "directoryvalue plugin waits for your orders",
      34             :                                   KEY_END),
      35             :                           keyNew ("system/elektra/modules/directoryvalue/exports", KEY_END),
      36             :                           keyNew ("system/elektra/modules/directoryvalue/exports/open", KEY_FUNC, elektraDirectoryValueOpen, KEY_END),
      37             :                           keyNew ("system/elektra/modules/directoryvalue/exports/close", KEY_FUNC, elektraDirectoryValueClose, KEY_END),
      38             :                           keyNew ("system/elektra/modules/directoryvalue/exports/get", KEY_FUNC, elektraDirectoryValueGet, KEY_END),
      39             :                           keyNew ("system/elektra/modules/directoryvalue/exports/set", KEY_FUNC, elektraDirectoryValueSet, KEY_END),
      40             : #include ELEKTRA_README
      41             :                           keyNew ("system/elektra/modules/directoryvalue/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END),
      42         373 :                           KS_END };
      43             : }
      44             : 
      45             : } // end namespace
      46             : 
      47             : extern "C" {
      48             : 
      49             : typedef Delegator<DirectoryValueDelegate> delegator;
      50             : 
      51             : /** @see elektraDocOpen */
      52        1977 : int elektraDirectoryValueOpen (Plugin * handle, Key * key)
      53             : {
      54        1977 :         return delegator::open (handle, key);
      55             : }
      56             : 
      57             : /** @see elektraDocClose */
      58        1977 : int elektraDirectoryValueClose (Plugin * handle, Key * key)
      59             : {
      60        3954 :         return delegator::close (handle, key);
      61             : }
      62             : 
      63             : /** @see elektraDocGet */
      64         649 : int elektraDirectoryValueGet (Plugin * handle, KeySet * returned, Key * parentKey)
      65             : {
      66        1298 :         CppKeySet keys{ returned };
      67        1298 :         CppKey parent{ parentKey };
      68             : 
      69        1947 :         if (parent.getName () == "system/elektra/modules/directoryvalue")
      70             :         {
      71        1119 :                 keys.append (getContract ());
      72         373 :                 parent.release ();
      73         373 :                 keys.release ();
      74         373 :                 return ELEKTRA_PLUGIN_STATUS_SUCCESS;
      75             :         }
      76             : 
      77         276 :         int status = ELEKTRA_PLUGIN_STATUS_ERROR;
      78             :         try
      79             :         {
      80         276 :                 status = delegator::get (handle)->convertToDirectories (keys);
      81             :         }
      82           0 :         catch (range_error const & error)
      83             :         {
      84           0 :                 ELEKTRA_SET_VALIDATION_SYNTACTIC_ERRORF (*parent, "Unable to insert array value %s", error.what ());
      85             :         }
      86           0 :         catch (exception const & error)
      87             :         {
      88           0 :                 ELEKTRA_SET_PLUGIN_MISBEHAVIOR_ERRORF (*parent, "Uncaught Exception: %s", error.what ());
      89             :         }
      90             : 
      91             : #ifdef HAVE_LOGGER
      92             :         for (auto key : keys)
      93             :         {
      94             :                 ELEKTRA_LOG_DEBUG ("\t“%s”: “%s”", key.getName ().c_str (),
      95             :                                    key.getBinarySize () == 0 ? "NULL" : key.isBinary () ? "binary value!" : key.getString ().c_str ());
      96             :         }
      97             : #endif
      98             : 
      99         276 :         parent.release ();
     100         276 :         keys.release ();
     101         276 :         return status;
     102             : }
     103             : 
     104             : /** @see elektraDocSet */
     105         101 : int elektraDirectoryValueSet (Plugin * handle, KeySet * returned, Key * parentKey)
     106             : {
     107         202 :         CppKeySet keys{ returned };
     108         202 :         CppKey parent{ parentKey };
     109             : 
     110         101 :         int status = ELEKTRA_PLUGIN_STATUS_ERROR;
     111             :         try
     112             :         {
     113         101 :                 status = delegator::get (handle)->convertToLeaves (keys);
     114             :         }
     115           0 :         catch (range_error const & error)
     116             :         {
     117           0 :                 ELEKTRA_SET_VALIDATION_SYNTACTIC_ERRORF (*parent, "Unable to insert array value %s", error.what ());
     118             :         }
     119           0 :         catch (exception const & error)
     120             :         {
     121           0 :                 ELEKTRA_SET_PLUGIN_MISBEHAVIOR_ERRORF (*parent, "Uncaught exception: %s", error.what ());
     122             :         }
     123             : 
     124         101 :         parent.release ();
     125         101 :         keys.release ();
     126         202 :         return status;
     127             : }
     128             : 
     129        1977 : Plugin * ELEKTRA_PLUGIN_EXPORT
     130             : {
     131             :         // clang-format off
     132             :         return elektraPluginExport ("directoryvalue",
     133             :                 ELEKTRA_PLUGIN_OPEN,    &elektraDirectoryValueOpen,
     134             :                 ELEKTRA_PLUGIN_CLOSE,   &elektraDirectoryValueClose,
     135             :                 ELEKTRA_PLUGIN_GET,     &elektraDirectoryValueGet,
     136             :                 ELEKTRA_PLUGIN_SET,     &elektraDirectoryValueSet,
     137        1977 :                 ELEKTRA_PLUGIN_END);
     138             : }
     139             : 
     140             : } // end extern "C"

Generated by: LCOV version 1.13