LCOV - code coverage report
Current view: top level - src - cbor.dart (source / functions) Hit Total Coverage
Test: coverage.lcov Lines: 41 46 89.1 %
Date: 2017-04-06 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  * Package : Cbor
       3             :  * Author : S. Hamblett <steve.hamblett@linux.com>
       4             :  * Date   : 12/12/2016
       5             :  * Copyright :  S.Hamblett
       6             :  */
       7             : 
       8             : part of cbor;
       9             : 
      10             : /// The CBOR package main API.
      11             : class Cbor {
      12             :   /// Construction
      13           1 :   Cbor() {
      14           1 :     init();
      15           2 :     _output = new OutputStandard();
      16           3 :     _encoder = new Encoder(output);
      17           2 :     _listener = new ListenerStack();
      18             :   }
      19             : 
      20             :   /// Decoder
      21             :   typed.Uint8Buffer _buffer;
      22             :   Input _input;
      23             :   Decoder _decoder;
      24             :   Listener _listener;
      25             : 
      26           0 :   Input get input => _input;
      27             : 
      28           1 :   set input(Input val) => _input = val;
      29             : 
      30           0 :   Decoder get decoder => _decoder;
      31             : 
      32           1 :   Output get output => _output;
      33             : 
      34           0 :   typed.Uint8Buffer get buffer => _buffer;
      35             : 
      36           0 :   Listener get listener => _listener;
      37             : 
      38             :   set listener(Listener value) {
      39           0 :     _listener = value;
      40             :   }
      41             : 
      42             :   /// Decode from a byte buffer payload
      43             :   void decodeFromBuffer(typed.Uint8Buffer buffer) {
      44           2 :     final ListenerStack listener = _listener as ListenerStack;
      45           2 :     listener.stack.clear();
      46           2 :     _output.clear();
      47           3 :     _input = new Input(buffer, buffer.length);
      48           4 :     _decoder = new Decoder.withListener(_input, _listener);
      49           2 :     _decoder.run();
      50             :   }
      51             : 
      52             :   /// Decode from a list of integer payload
      53             :   void decodeFromList(List<int> ints) {
      54           2 :     final ListenerStack listener = _listener as ListenerStack;
      55           2 :     listener.stack.clear();
      56           2 :     _output.clear();
      57           1 :     final typed.Uint8Buffer buffer = new typed.Uint8Buffer();
      58           1 :     buffer.addAll(ints);
      59           3 :     _input = new Input(buffer, buffer.length);
      60           4 :     _decoder = new Decoder.withListener(_input, _listener);
      61           2 :     _decoder.run();
      62             :   }
      63             : 
      64             :   /// Decode from the input attribute, i.e decode what we have
      65             :   /// just encoded.
      66             :   void decodeFromInput() {
      67           2 :     final ListenerStack listener = _listener as ListenerStack;
      68           2 :     listener.stack.clear();
      69           6 :     _input = new Input(_output.getData(), _output.size());
      70           4 :     _decoder = new Decoder.withListener(_input, _listener);
      71           2 :     _decoder.run();
      72             :   }
      73             : 
      74             :   /// Get the decoded data as a list
      75             :   List<dynamic> getDecodedData() {
      76           2 :     final ListenerStack listener = _listener as ListenerStack;
      77           2 :     return listener.stack.walk();
      78             :   }
      79             : 
      80             :   /// Get the decoded hints
      81             :   List<dataHints> getDecodedHints() {
      82           2 :     final ListenerStack listener = _listener as ListenerStack;
      83           2 :     return listener.stack.hints();
      84             :   }
      85             : 
      86             :   /// Pretty print the decoded data
      87             :   String decodedPrettyPrint([bool withHints = false]) {
      88             :     String ret = "";
      89           1 :     final List<dynamic> values = getDecodedData();
      90             :     List<dataHints> hints;
      91             :     if (withHints) {
      92           1 :       hints = getDecodedHints();
      93             :     }
      94           1 :     final int length = values.length;
      95           2 :     for (int i = 0; i < length; i++) {
      96           4 :       ret += "Entry $i   : Value is => ${values[i].toString()}\n";
      97             :       if (withHints) {
      98           4 :         ret += "          : Hint is => ${hints[i].toString()}\n";
      99             :       }
     100             :     }
     101             :     return ret;
     102             :   }
     103             : 
     104             :   /// To JSON, only supports strings as map keys.
     105             :   /// Returns null if the conversion fails.
     106             :   String decodedToJSON() {
     107             :     String ret;
     108             :     try {
     109           2 :       ret = json.serialize(getDecodedData());
     110             :     } catch (exception) {
     111             :       return null;
     112             :     }
     113             :     // Remove the [] from the JSON string
     114           3 :     return ret.substring(1, ret.length - 1);
     115             :   }
     116             : 
     117             :   /// Encoder
     118             :   Output _output;
     119             :   Encoder _encoder;
     120             : 
     121           1 :   Output get rawOutput => _output;
     122             : 
     123           1 :   Encoder get encoder => _encoder;
     124             : 
     125             :   /// Clear the encoded output
     126             :   void clearEncoded() {
     127           2 :     _output.clear();
     128             :   }
     129             : }

Generated by: LCOV version 1.10