LCOV - code coverage report
Current view: top level - lang/cpp/src - importresult.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 92 0.0 %
Date: 2016-12-01 18:45:36 Functions: 0 29 0.0 %

          Line data    Source code
       1             : /*
       2             :   importresult.cpp - wraps a gpgme import result
       3             :   Copyright (C) 2004 Klarälvdalens Datakonsult AB
       4             : 
       5             :   This file is part of GPGME++.
       6             : 
       7             :   GPGME++ is free software; you can redistribute it and/or
       8             :   modify it under the terms of the GNU Library General Public
       9             :   License as published by the Free Software Foundation; either
      10             :   version 2 of the License, or (at your option) any later version.
      11             : 
      12             :   GPGME++ is distributed in the hope that it will be useful,
      13             :   but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :   GNU Library General Public License for more details.
      16             : 
      17             :   You should have received a copy of the GNU Library General Public License
      18             :   along with GPGME++; see the file COPYING.LIB.  If not, write to the
      19             :   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      20             :   Boston, MA 02110-1301, USA.
      21             : */
      22             : 
      23             : 
      24             : #ifdef HAVE_CONFIG_H
      25             :  #include "config.h"
      26             : #endif
      27             : 
      28             : #include <importresult.h>
      29             : #include "result_p.h"
      30             : 
      31             : #include <gpgme.h>
      32             : #include <cstdlib>
      33             : #include <cstring>
      34             : 
      35             : #include <string.h>
      36             : 
      37             : class GpgME::ImportResult::Private
      38             : {
      39             : public:
      40           0 :     Private(const _gpgme_op_import_result &r) : res(r)
      41             :     {
      42             :         // copy recursively, using compiler-generated copy ctor.
      43             :         // We just need to handle the pointers in the structs:
      44           0 :         for (gpgme_import_status_t is = r.imports ; is ; is = is->next) {
      45           0 :             gpgme_import_status_t copy = new _gpgme_import_status(*is);
      46           0 :             copy->fpr = strdup(is->fpr);
      47           0 :             copy->next = 0;
      48           0 :             imports.push_back(copy);
      49             :         }
      50           0 :         res.imports = 0;
      51           0 :     }
      52           0 :     ~Private()
      53           0 :     {
      54           0 :         for (std::vector<gpgme_import_status_t>::iterator it = imports.begin() ; it != imports.end() ; ++it) {
      55           0 :             std::free((*it)->fpr);
      56           0 :             delete *it; *it = 0;
      57             :         }
      58           0 :     }
      59             : 
      60             :     _gpgme_op_import_result res;
      61             :     std::vector<gpgme_import_status_t> imports;
      62             : };
      63             : 
      64           0 : GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, int error)
      65           0 :     : GpgME::Result(error), d()
      66             : {
      67           0 :     init(ctx);
      68           0 : }
      69             : 
      70           0 : GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, const Error &error)
      71           0 :     : GpgME::Result(error), d()
      72             : {
      73           0 :     init(ctx);
      74           0 : }
      75             : 
      76           0 : void GpgME::ImportResult::init(gpgme_ctx_t ctx)
      77             : {
      78           0 :     if (!ctx) {
      79           0 :         return;
      80             :     }
      81           0 :     gpgme_import_result_t res = gpgme_op_import_result(ctx);
      82           0 :     if (!res) {
      83           0 :         return;
      84             :     }
      85           0 :     d.reset(new Private(*res));
      86             : }
      87             : 
      88           0 : make_standard_stuff(ImportResult)
      89             : 
      90           0 : int GpgME::ImportResult::numConsidered() const
      91             : {
      92           0 :     return d ? d->res.considered : 0 ;
      93             : }
      94             : 
      95           0 : int GpgME::ImportResult::numKeysWithoutUserID() const
      96             : {
      97           0 :     return d ? d->res.no_user_id : 0 ;
      98             : }
      99             : 
     100           0 : int GpgME::ImportResult::numImported() const
     101             : {
     102           0 :     return d ? d->res.imported : 0 ;
     103             : }
     104             : 
     105           0 : int GpgME::ImportResult::numRSAImported() const
     106             : {
     107           0 :     return d ? d->res.imported_rsa : 0 ;
     108             : }
     109             : 
     110           0 : int GpgME::ImportResult::numUnchanged() const
     111             : {
     112           0 :     return d ? d->res.unchanged : 0 ;
     113             : }
     114             : 
     115           0 : int GpgME::ImportResult::newUserIDs() const
     116             : {
     117           0 :     return d ? d->res.new_user_ids : 0 ;
     118             : }
     119             : 
     120           0 : int GpgME::ImportResult::newSubkeys() const
     121             : {
     122           0 :     return d ? d->res.new_sub_keys : 0 ;
     123             : }
     124             : 
     125           0 : int GpgME::ImportResult::newSignatures() const
     126             : {
     127           0 :     return d ? d->res.new_signatures : 0 ;
     128             : }
     129             : 
     130           0 : int GpgME::ImportResult::newRevocations() const
     131             : {
     132           0 :     return d ? d->res.new_revocations : 0 ;
     133             : }
     134             : 
     135           0 : int GpgME::ImportResult::numSecretKeysConsidered() const
     136             : {
     137           0 :     return d ? d->res.secret_read : 0 ;
     138             : }
     139             : 
     140           0 : int GpgME::ImportResult::numSecretKeysImported() const
     141             : {
     142           0 :     return d ? d->res.secret_imported : 0 ;
     143             : }
     144             : 
     145           0 : int GpgME::ImportResult::numSecretKeysUnchanged() const
     146             : {
     147           0 :     return d ? d->res.secret_unchanged : 0 ;
     148             : }
     149             : 
     150           0 : int GpgME::ImportResult::notImported() const
     151             : {
     152           0 :     return d ? d->res.not_imported : 0 ;
     153             : }
     154             : 
     155           0 : GpgME::Import GpgME::ImportResult::import(unsigned int idx) const
     156             : {
     157           0 :     return Import(d, idx);
     158             : }
     159             : 
     160           0 : std::vector<GpgME::Import> GpgME::ImportResult::imports() const
     161             : {
     162           0 :     if (!d) {
     163           0 :         return std::vector<Import>();
     164             :     }
     165           0 :     std::vector<Import> result;
     166           0 :     result.reserve(d->imports.size());
     167           0 :     for (unsigned int i = 0 ; i < d->imports.size() ; ++i) {
     168           0 :         result.push_back(Import(d, i));
     169             :     }
     170           0 :     return result;
     171             : }
     172             : 
     173           0 : GpgME::Import::Import(const std::shared_ptr<ImportResult::Private> &parent, unsigned int i)
     174           0 :     : d(parent), idx(i)
     175             : {
     176             : 
     177           0 : }
     178             : 
     179           0 : GpgME::Import::Import() : d(), idx(0) {}
     180             : 
     181           0 : bool GpgME::Import::isNull() const
     182             : {
     183           0 :     return !d || idx >= d->imports.size() ;
     184             : }
     185             : 
     186           0 : const char *GpgME::Import::fingerprint() const
     187             : {
     188           0 :     return isNull() ? 0 : d->imports[idx]->fpr ;
     189             : }
     190             : 
     191           0 : GpgME::Error GpgME::Import::error() const
     192             : {
     193           0 :     return Error(isNull() ? 0 : d->imports[idx]->result);
     194             : }
     195             : 
     196           0 : GpgME::Import::Status GpgME::Import::status() const
     197             : {
     198           0 :     if (isNull()) {
     199           0 :         return Unknown;
     200             :     }
     201           0 :     const unsigned int s = d->imports[idx]->status;
     202           0 :     unsigned int result = Unknown;
     203           0 :     if (s & GPGME_IMPORT_NEW) {
     204           0 :         result |= NewKey;
     205             :     }
     206           0 :     if (s & GPGME_IMPORT_UID) {
     207           0 :         result |= NewUserIDs;
     208             :     }
     209           0 :     if (s & GPGME_IMPORT_SIG) {
     210           0 :         result |= NewSignatures;
     211             :     }
     212           0 :     if (s & GPGME_IMPORT_SUBKEY) {
     213           0 :         result |= NewSubkeys;
     214             :     }
     215           0 :     if (s & GPGME_IMPORT_SECRET) {
     216           0 :         result |= ContainedSecretKey;
     217             :     }
     218           0 :     return static_cast<Status>(result);
     219             : }

Generated by: LCOV version 1.11