Figure 3.3. Modified ldfilt_config.xml

<?xml version="1.0"?>

<!DOCTYPE keyval PUBLIC
   "-//VAISALA//DTD KeyValue XML V1.0.0//EN"
   "http://www.mekwin.com/vaisala/xml/dtd/keyval/keyval_1_0_0.dtd">

<!-- $Id: ldfilt_config.xml,v 1.1 2004/03/13 00:05:17 pkb Exp $

  Definition of configurable options for ldfilt

  Edit this file, it will be used to produce:
      ldfilt_config.hh
      ldfilt_config.cc
      ldfilt_config.m4i
      src/package/ldfilt.cfg

-->

<keyval class="ldfilt" namespace="lp">

  &verbosity;

  <boolean default="false" varname="Invert">
    <key>lp.ldfilt.invert</key>
    <summary>Reverses the results of the filter rules.</summary>

    <description>If this option is set to <literal>true</literal>,
    then the rules will have the opposite affect. Data that would have
    been allowed through would be filtered out and data that would
    have been filtered out would now be allowed
    through.</description>
  </boolean>

  <real default="-1500.0" min="-15000.0" max="0.0" varname="SignalMin">
    <key>lp.ldfilt.signal.min</key>
    <summary>Minimum signal strength (LLP units) to allow through.</summary>

    <description>All Ld objects which have a signal strength less than
    this value are filtered.</description>
  </real>

  <real default="1500.0" min="0.0" max="15000.0" varname="SignalMax">
    <key>lp.ldfilt.signal.max</key>
    <summary>Maximum signal strength (LLP units) to allow through.</summary>

    <description>All Ld objects which have a signal strength greater than
    this value are filtered.</description>
  </real>

</keyval>

Figure 3.4. nlib::Filter for ldfilter.cc

//----------------------------------------------------------------  
// nlib::Filter implementation for Ld objects
//----------------------------------------------------------------

#ifndef __nobj_Filter_hh
#include <nobj/Filter.hh>
#endif

#ifndef __nobj_Source_hh
#include <nobj/Source.hh>
#endif

#ifndef __vdata_Ld_hh
#include <vdata/Ld.hh>
#endif

namespace {
  class LdFilter : public nlib::Filter {
  public:
    LdFilter(const ldfiltConfig& cfg) {
      _Acceptable = !cfg.isInvert();
      _SigMin = cfg.getSignalMin();
      _SigMax = cfg.getSignalMax();
    }

    bool isObjectAcceptable(const nlib::Handle& h) {
      const Ld* ld = Ld::toLd(h);
      if (ld == 0) return false; // only allow Ld objects through

      double sig;		// we require signal strength values
      if (!ld->getSignal(sig)) return false;

      bool ok = _Acceptable;
				// see if out of range
      if ((sig < _SigMin) || (sig > _SigMax)) ok = !_Acceptable;

      return ok;
    }

  private:
    bool _Acceptable;
    double _SigMin, _SigMax;
  };
}

Figure 3.5. Updated main() in ldfilt.cc

//----------------------------------------------------------------  
// ldfilt::main() implementation
//----------------------------------------------------------------

int ldfilt::main() {

				// let base class make basic checks
  if (Application::main() != 0) {
    return 1;			// leave now if it something is wrong
  }

  doInitialization();		// initialize class (loads config)

				// construct instance of our Ld Filter
  Handle filter(new LdFilter(_Cfg));

				// install it as filter to object output
  Handle out(Source::toArchive(&std::cout,filter));

				// now, read all Objects from cin, and
				// and send them through filter (and
				// possibly out)
  Source* in = Source::fromArchive(&std::cin);
  in->getNotifier().addListener(out);
  in->run();
  delete in;

  if (verbosityLevel(1)) {
    vout() << "\nnormal termination of ldfilt::main()\n";
  }

  return 0;			// return success
      
}