LCOV - code coverage report
Current view: top level - builds/mtusseau/poc-diff-coverage/src - binary.cxx (source / functions) Hit Total Coverage
Test: lcov-run.info Lines: 16 40 40.0 %
Date: 2019-02-15 00:00:25 Functions: 4 13 30.8 %
Branches: 10 24 41.7 %

           Branch data     Line data    Source code
       1                 :            : // Copyright (c) 2005-2014 Code Synthesis Tools CC
       2                 :            : //
       3                 :            : // This program was generated by CodeSynthesis XSD, an XML Schema to
       4                 :            : // C++ data binding compiler.
       5                 :            : //
       6                 :            : // This program is free software; you can redistribute it and/or modify
       7                 :            : // it under the terms of the GNU General Public License version 2 as
       8                 :            : // published by the Free Software Foundation.
       9                 :            : //
      10                 :            : // This program is distributed in the hope that it will be useful,
      11                 :            : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      12                 :            : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13                 :            : // GNU General Public License for more details.
      14                 :            : //
      15                 :            : // You should have received a copy of the GNU General Public License
      16                 :            : // along with this program; if not, write to the Free Software
      17                 :            : // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
      18                 :            : //
      19                 :            : // In addition, as a special exception, Code Synthesis Tools CC gives
      20                 :            : // permission to link this program with the Xerces-C++ library (or with
      21                 :            : // modified versions of Xerces-C++ that use the same license as Xerces-C++),
      22                 :            : // and distribute linked combinations including the two. You must obey
      23                 :            : // the GNU General Public License version 2 in all respects for all of
      24                 :            : // the code used other than Xerces-C++. If you modify this copy of the
      25                 :            : // program, you may extend this exception to your version of the program,
      26                 :            : // but you are not obligated to do so. If you do not wish to do so, delete
      27                 :            : // this exception statement from your version.
      28                 :            : //
      29                 :            : // Furthermore, Code Synthesis Tools CC makes a special exception for
      30                 :            : // the Free/Libre and Open Source Software (FLOSS) which is described
      31                 :            : // in the accompanying FLOSSE file.
      32                 :            : //
      33                 :            : 
      34                 :            : // Begin prologue.
      35                 :            : //
      36                 :            : //
      37                 :            : // End prologue.
      38                 :            : 
      39                 :            : #include <xsd/cxx/pre.hxx>
      40                 :            : 
      41                 :            : #include "binary.hxx"
      42                 :            : 
      43                 :            : #include "axe1.hxx"
      44                 :            : 
      45                 :            : // Binary
      46                 :            : // 
      47                 :            : 
      48                 :          0 : const Binary::AxeSequence& Binary::
      49                 :            : getAxe () const
      50                 :            : {
      51                 :          0 :   return this->axe_;
      52                 :            : }
      53                 :            : 
      54                 :          0 : Binary::AxeSequence& Binary::
      55                 :            : getAxe ()
      56                 :            : {
      57                 :          0 :   return this->axe_;
      58                 :            : }
      59                 :            : 
      60                 :          0 : void Binary::
      61                 :            : setAxe (const AxeSequence& s)
      62                 :            : {
      63                 :            :   this->axe_ = s;
      64                 :          0 : }
      65                 :            : 
      66                 :            : 
      67                 :            : #include <xsd/cxx/xml/dom/parsing-source.hxx>
      68                 :            : 
      69                 :            : // Binary
      70                 :            : //
      71                 :            : 
      72                 :          0 : Binary::
      73                 :            : Binary ()
      74                 :            : : ::xml_schema::Type (),
      75                 :          0 :   axe_ (this)
      76                 :            : {
      77                 :          0 : }
      78                 :            : 
      79                 :          0 : Binary::
      80                 :            : Binary (const Binary& x,
      81                 :            :         ::xml_schema::Flags f,
      82                 :            :         ::xml_schema::Container* c)
      83                 :            : : ::xml_schema::Type (x, f, c),
      84                 :          0 :   axe_ (x.axe_, f, this)
      85                 :            : {
      86                 :          0 : }
      87                 :            : 
      88                 :          1 : Binary::
      89                 :            : Binary (const ::xercesc::DOMElement& e,
      90                 :            :         ::xml_schema::Flags f,
      91                 :            :         ::xml_schema::Container* c)
      92                 :            : : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
      93                 :          1 :   axe_ (this)
      94                 :            : {
      95         [ +  - ]:          1 :   if ((f & ::xml_schema::Flags::base) == 0)
      96                 :            :   {
      97         [ +  - ]:          1 :     ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
      98         [ +  - ]:          1 :     this->parse (p, f);
      99                 :            :   }
     100                 :          1 : }
     101                 :            : 
     102                 :          2 : void Binary::
     103                 :            : parse (::xsd::cxx::xml::dom::parser< char >& p,
     104                 :            :        ::xml_schema::Flags f)
     105                 :            : {
     106         [ +  + ]:          2 :   for (; p.more_content (); p.next_content (false))
     107                 :            :   {
     108                 :            :     const ::xercesc::DOMElement& i (p.cur_element ());
     109                 :            :     const ::xsd::cxx::xml::qualified_name< char > n (
     110                 :          1 :       ::xsd::cxx::xml::dom::name< char > (i));
     111                 :            : 
     112                 :            :     // axe
     113                 :            :     //
     114 [ +  - ][ -  + ]:          1 :     if (n.name () == "axe" && n.namespace_ ().empty ())
                 [ +  - ]
     115                 :            :     {
     116                 :            :       ::std::unique_ptr< AxeType > r (
     117         [ +  - ]:          1 :         AxeTraits::create (i, f, this));
     118                 :            : 
     119         [ +  - ]:          1 :       this->axe_.push_back (::std::move (r));
     120                 :            :       continue;
     121                 :            :     }
     122                 :            : 
     123                 :          0 :     break;
     124                 :            :   }
     125                 :          1 : }
     126                 :            : 
     127                 :          0 : Binary* Binary::
     128                 :            : _clone (::xml_schema::Flags f,
     129                 :            :         ::xml_schema::Container* c) const
     130                 :            : {
     131         [ #  # ]:          0 :   return new class Binary (*this, f, c);
     132                 :            : }
     133                 :            : 
     134                 :          0 : Binary& Binary::
     135                 :            : operator= (const Binary& x)
     136                 :            : {
     137         [ #  # ]:          0 :   if (this != &x)
     138                 :            :   {
     139                 :          0 :     static_cast< ::xml_schema::Type& > (*this) = x;
     140                 :            :     this->axe_ = x.axe_;
     141                 :            :   }
     142                 :            : 
     143                 :          0 :   return *this;
     144                 :            : }
     145                 :            : 
     146                 :          2 : Binary::
     147                 :          1 : ~Binary ()
     148                 :            : {
     149                 :          1 : }
     150                 :            : 
     151                 :            : bool
     152                 :          0 : operator== (const Binary& x, const Binary& y)
     153                 :            : {
     154         [ #  # ]:          0 :   if (!(x.getAxe () == y.getAxe ()))
     155                 :            :     return false;
     156                 :            : 
     157                 :          0 :   return true;
     158                 :            : }
     159                 :            : 
     160                 :            : bool
     161                 :          0 : operator!= (const Binary& x, const Binary& y)
     162                 :            : {
     163                 :          0 :   return !(x == y);
     164                 :            : }
     165                 :            : 
     166                 :            : #include <istream>
     167                 :            : #include <xsd/cxx/xml/sax/std-input-source.hxx>
     168                 :            : #include <xsd/cxx/tree/error-handler.hxx>
     169                 :            : 
     170                 :            : #include <xsd/cxx/post.hxx>
     171                 :            : 
     172                 :            : // Begin epilogue.
     173                 :            : //
     174                 :            : //
     175                 :            : // End epilogue.
     176                 :            : 

Generated by: LCOV version 1.12