LCOV - code coverage report
Current view: top level - src/plugins/tcl - tcl.cpp (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 28 39 71.8 %
Date: 2019-09-12 12:28:41 Functions: 4 5 80.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include "tcl.hpp"
      10             : 
      11             : #include <key.hpp>
      12             : #include <keyset.hpp>
      13             : 
      14             : #include <fstream>
      15             : 
      16             : #include "errno.h"
      17             : 
      18             : #include <boost/spirit/include/qi_expect.hpp>
      19             : #include <boost/spirit/include/support_istream_iterator.hpp>
      20             : 
      21             : using namespace ckdb;
      22             : #include <kdberrors.h>
      23             : 
      24             : extern "C" {
      25             : 
      26         115 : int elektraTclGet (Plugin *, KeySet * returned, Key * parentKey)
      27             : {
      28         230 :         kdb::Key parent (parentKey);
      29         345 :         if (parent.getName () == "system/elektra/modules/tcl")
      30             :         {
      31             :                 /* get config */
      32             :                 KeySet * n;
      33             :                 ksAppend (returned,
      34          97 :                           n = ksNew (30, keyNew ("system/elektra/modules/tcl", KEY_VALUE, "tcl plugin waits for your orders", KEY_END),
      35             :                                      keyNew ("system/elektra/modules/tcl/exports", KEY_END),
      36             :                                      keyNew ("system/elektra/modules/tcl/exports/get", KEY_FUNC, elektraTclGet, KEY_END),
      37             :                                      keyNew ("system/elektra/modules/tcl/exports/set", KEY_FUNC, elektraTclSet, KEY_END),
      38             :                                      keyNew ("system/elektra/modules/tcl/exports/cpp_serialise", KEY_SIZE, sizeof (&elektra::serialise),
      39             :                                              KEY_BINARY, KEY_VALUE, &elektra::serialise, KEY_END),
      40             :                                      keyNew ("system/elektra/modules/tcl/exports/cpp_unserialise", KEY_SIZE, sizeof (&elektra::unserialise),
      41             :                                              KEY_BINARY, KEY_VALUE, &elektra::unserialise, KEY_END),
      42             : #include "readme_tcl.c"
      43          97 :                                      keyNew ("system/elektra/modules/tcl/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END));
      44          97 :                 ksDel (n);
      45             :                 return ELEKTRA_PLUGIN_STATUS_SUCCESS;
      46             :         }
      47             :         /* get all keys */
      48             : 
      49          18 :         int errnosave = errno;
      50          54 :         std::ifstream in (parent.getString (), std::ios::binary); // we get our input from this file
      51          18 :         if (!in.is_open ())
      52             :         {
      53           0 :                 ELEKTRA_SET_ERROR_GET (*parent);
      54           0 :                 errno = errnosave;
      55             :                 parent.release ();
      56             :                 return -1;
      57             :         }
      58             : 
      59          18 :         kdb::KeySet input (returned);
      60             : 
      61          18 :         int ret = 0;
      62             :         try
      63             :         {
      64          18 :                 elektra::unserialise (in, input, parent);
      65             :         }
      66           0 :         catch (boost::spirit::qi::expectation_failure<boost::spirit::istream_iterator> const & e)
      67             :         {
      68           0 :                 ELEKTRA_SET_VALIDATION_SYNTACTIC_ERROR (*parent,
      69             :                                                         std::string (std::string ("File '") + parent.getString () +
      70             :                                                                      "' could not be parsed. Reason: " + std::string (e.first, e.last))
      71             :                                                                 .c_str ());
      72           0 :                 ret = -1;
      73             :         }
      74           0 :         catch (std::exception const & e)
      75             :         {
      76           0 :                 ELEKTRA_SET_VALIDATION_SYNTACTIC_ERROR (
      77             :                         *parent, std::string (std::string ("File '") + parent.getString () + "' could not be parsed. Reason: " + e.what ())
      78             :                                          .c_str ());
      79           0 :                 ret = -1;
      80             :         }
      81          18 :         input.release ();
      82          18 :         parent.release ();
      83             : 
      84          18 :         return ret;
      85             : }
      86             : 
      87           8 : int elektraTclSet (Plugin *, KeySet * returned, Key * parentKey)
      88             : {
      89             :         /* set all keys */
      90             : 
      91           8 :         int errnosave = errno;
      92          16 :         kdb::Key parent (parentKey);
      93          24 :         std::ofstream ofs (parent.getString (), std::ios::binary);
      94           8 :         if (!ofs.is_open ())
      95             :         {
      96           0 :                 ELEKTRA_SET_ERROR_SET (*parent);
      97           0 :                 errno = errnosave;
      98           0 :                 return -1;
      99             :         }
     100             : 
     101           8 :         kdb::KeySet output (returned);
     102             : 
     103           8 :         elektra::serialise (ofs, output, parent);
     104           8 :         parent.release ();
     105           8 :         output.release ();
     106             : 
     107           8 :         return 1; /* success */
     108             : }
     109             : 
     110         201 : Plugin * ELEKTRA_PLUGIN_EXPORT
     111             : {
     112             :         // clang-format off
     113             :         return elektraPluginExport("tcl",
     114             :                 ELEKTRA_PLUGIN_GET,     &elektraTclGet,
     115             :                 ELEKTRA_PLUGIN_SET,     &elektraTclSet,
     116         201 :                 ELEKTRA_PLUGIN_END);
     117             : }
     118             : 
     119          92 : } // end extern "C"

Generated by: LCOV version 1.13