XXMLManager.h

Go to the documentation of this file.

#ifndef _det_XXMLManager_h_
#define _det_XXMLManager_h_

#include <det/VManager.h>
#include <det/ValidityStamp.h>

#include <utl/ErrorLogger.h>
#include <utl/Branch.h>

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/tokenizer.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/empty_base.hpp>

#include <map>
#include <string>
#include <set>
#include <vector>
#include <cstddef>


namespace det {

  namespace detail {

    class MultiConfigBase {
    public:
      MultiConfigBase() : fCurrentConfiguration(1) { }

      void NextConfiguration() { ++fCurrentConfiguration; }

      unsigned int GetCurrentConfiguration() const { return fCurrentConfiguration; }

      void SetCurrentConfiguration(unsigned int n) { fCurrentConfiguration = n; }

    private:
      unsigned int fCurrentConfiguration;
    };

    typedef boost::mpl::empty_base MonoConfigBase;

  }


  template<class Info>
  class XXMLManager : public det::VManager,
                      // Here we're choosing the base class according to the boolean flag.
                      public boost::mpl::if_c<
                               Info::kAllowMultiConfig,
                               detail::MultiConfigBase,
                               detail::MonoConfigBase
                             >::type {
  public:
    XXMLManager() { Initialize(); }
    virtual ~XXMLManager() { }
    // Call.
    VMANAGER_GETDATA_CALL(GetDataInternal, double);
    VMANAGER_GETDATA_CALL(GetDataInternal, int);
    VMANAGER_GETDATA_CALL(GetDataInternal, std::string);
    VMANAGER_GETDATA_CALL(GetDataInternal, std::list<int>);
    VMANAGER_GETDATA_CALL(GetDataInternal, std::vector<double>);
    VMANAGER_GETDATA_CALL(GetDataInternal, std::vector<int>);
    VMANAGER_GETDATA_CALL(GetDataInternal, utl::TabulatedFunction);
    // Deny.
    //VMANAGER_GETDATA_DENIED(std::vector<int>);
    //VMANAGER_GETDATA_DENIED(unsigned long long int)
    VMANAGER_GETDATA_DENIED(std::vector<std::string>);
    VMANAGER_GETDATA_DENIED(std::list<double>);
    VMANAGER_GETDATA_DENIED(std::list<std::string>);
    VMANAGER_GETDATA_DENIED(std::list<std::pair<int, int> >);
    VMANAGER_GETDATA_DENIED(std::map<int, utl::TabulatedFunction>);
    VMANAGER_GETDATA_DENIED(std::map<std::string, double>);
    VMANAGER_GETDATA_DENIED(std::vector<std::vector<int> >);
    VMANAGER_GETDATA_DENIED(utl::TabulatedFunctionComplexLgAmpPhase)
    VMANAGER_GETDATA_DENIED(std::vector<bool>);

  private:
    VMANAGER_GETDATA_HANDLE_DENIED

    template<typename T, std::size_t N>
    static
    std::size_t
    Size(const T (&)[N])
    {
      // A const seems proper, anyway no parameter name!!!
      return N;
    }

    template<typename T, std::size_t N>
    static
    bool
    LookUpCoda(utl::Branch& dest, const utl::Branch& src, const T (&path)[N])
    {
      utl::Branch b = src;
      // Now, do the transversing the remainding until finding it.
      unsigned int i = 1;// From the second of the path.
      // No need to call Size, we already have N.
      for ( ; i < N && b; ++i)
        b = b.GetChild(path[i]);
      /*
       * For sucessful result we have to have a branch
       * and also transversed all the desired path.
       */
      if (b && i == N) {
        dest = b;
        return true;
      }
      return false;
    }

    template<bool AllowMultiConfig, int dummy = 0>
    struct ConfigHandler {
      // Perform look up with MultiConfig criteria.
      template<typename T, std::size_t N>
      static
      bool
      Handle(const XXMLManager& m, utl::Branch& dest, const T (&path)[N])
      {
        /*
         * If no child, just make a quick return without bothering too much (without a
         * time consuming logic) and being quiet without prompting messages.
         * Here we will have a quick return when the manager is configured with
         * an empty branch.
         */
        if (!m.fBranch.GetFirstChild())
          return false;
        // If there's something, proceed with the logic as normal.
        // Call the method that is defined in the variable base-class that keeps the count of the current number.
        const int currConfig = m.GetCurrentConfiguration();
        const int minConfig = 1;
        /*
         * Start looking from the current 'til the first.
         * Note that since path[0] is likely to be the same in model or data cases we may
         * find it, tough without further levels in one of the cases (ie it will be there
         * because of the other case).
         */
        for (int n = currConfig; n >= minConfig; --n) {
          // Look up a child with the configured name, and the current number as attribute.
          const utl::AttributeMap attr{{Info::kIdAtt, boost::lexical_cast<std::string>(n)}};
          // Note the unconditional access to element #0; it's a requirement to have at least 1.
          if (const utl::Branch br = m.fBranch.GetChild(path[0], attr)) {
            // Now that we've found the root, now complete the lookup stage.
            // If found == true, then dest was already modified and so we simply return.
            if (LookUpCoda(dest, br, path))
              return true;
          }
        }
        std::ostringstream msg;
        msg << "In configuration change, no branch "
             << path[0]
             << " was found for configuration number from "
             << currConfig
             << " down to "
             << minConfig
             << " used as attribute "
             << Info::kIdAtt
             << ".";
        WARNING(msg);
        return false;
      }
    };

    template<int dummy>
    struct ConfigHandler<false, dummy> {
      // If no configuration change is allowed then the top branch is used directly.
      template<typename T, std::size_t N>
      static bool Handle(const XXMLManager& m, utl::Branch& dest, const T (&path)[N])
      { return LookUpCoda(dest, m.fBranch, path); }
    };

    //
    class IdMatcher {
    public:
      IdMatcher(const std::string& i,const std::string& compName, bool report) :
        fId(i),
        fCompName(compName),
        fIsReportingErrors(report)
      { }

      utl::Branch
      operator()(const utl::Branch& b)
      {
        // XXX Some hardcoding for this tag/wildcard.
        const std::string kAllTag("all");
        // If there was no match with ranges a last
        // chance is to allow a wildcard match.
        utl::AttributeMap all;
        all[Info::kIdAtt] = kAllTag;
        //DEBUGLOG("Child looked-up by wilcard on");
        //DEBUGLOG(b.GetName());
        // The outcome doesn't need to be checked if it's null.
        return b.GetChild(fCompName, all);
      }

      bool
      operator()(const int lowerBound, const int upperBound)
      {
        std::istringstream is(fId);
        int i = 0;
        if (is >> i) {
          const bool b = lowerBound <= i && i <= upperBound;
          //DEBUGLOG(b ? "Child found by range." : "");
          return b;
        } else if (fIsReportingErrors) {
          std::ostringstream warn;
          warn << "The id "
               << fId
               << " specified for the component "
               << fCompName
               << " was ignored as it couldn't be interpreted as integer in range matching.";
          WARNING(warn);
        }
        return false;
      }

      bool
      operator()(const int id)
      {
        std::istringstream is(fId);
        int i = 0;
        if (is >> i) {
          const bool b = i == id;
          //DEBUGLOG(b ? "Child found by specific id." : "");
          return b;
        } else if (fIsReportingErrors) {
          std::ostringstream warn;
          warn << "The id "
               << fId
               << " specified for the component "
               << fCompName
               << " was ignored as it couldn't be interpreted as integer in specific id matching";
          WARNING(warn);
        }
        return false;
      }

    private:
      const std::string& fId;
      const std::string& fCompName;
      const bool fIsReportingErrors;
    };

    template<class Container>
    class AccumulatorMatcher {
    public:
      AccumulatorMatcher(Container& ids, const bool report) :
        fIds(ids),
        fIsReportingErrors(report),
        fModified(false)
      { }

      utl::Branch operator()(const utl::Branch& /*b*/)
      { return utl::Branch(); }

      bool
      operator()(const int lowerBound, const int upperBound)
      {
        for (int i = lowerBound; i<= upperBound; ++i) {
          fIds.push_back(i);
          fModified = true;
        }
        return false;
      }

      bool
      operator()(const int id)
      {
        fIds.push_back(id);
        fModified = true;
        return false;
      }

      bool IsModified() const { return fModified; }

    private:
      Container& fIds;
      const bool fIsReportingErrors;
      bool fModified;
    };

    template<class Matcher>
    static utl::Branch FindMatchingBranch(const utl::Branch& parent,
                                          const std::string& compName,
                                          Matcher& matcher,
                                          bool isReportingErrors);

    template <typename T, std::size_t N>
    utl::Branch FindRoot(const T (&path)[N]) const;

    utl::Branch FindModelBranch(const utl::Branch& componentModels,
                                const utl::Branch& compBranch,
                                const std::string& name) const;

    template<typename T>
    det::VManager::Status
    GetDataInternal(T& t,
                    const std::string& prop,
                    const std::string& name,
                    const det::VManager::IndexMap& m) const;

    void Initialize();

    template<typename T>
    det::VManager::Status
    GetDataInternal(const utl::Branch& topB,
                    T& t,
                    const std::string& prop,
                    const std::string& name) const;

    template<typename T>
    det::VManager::Status
    GetDataInternal(const utl::Branch& topB,
                    std::list<T>& t,
                    const std::string& componentName,
                    const std::string& name) const;
  };


  template<class Info>
  void
  XXMLManager<Info>::Initialize()
  {
    /*
     * At last, seems not to be needed.
     * SStationListXMLManager assumes that is
     * propery set, so we assume the same.
     * Init(Info::kManagerName);
     *
     * TODO A list for managed properties may be used here.
     * // for fast decission if the manager can provided data
     * // for a specific property
     * std::set<std::string> fPropertiesList;
     */
    //DEBUGLOG("Initializing.");
  }


  template<class Info>
  template <typename T, std::size_t N>
  utl::Branch
  XXMLManager<Info>::FindRoot(const T (&path)[N])
    const
  {
    using namespace utl;
    using namespace std;
    /*
     * XXX All this look-up could be done just once, or least not
     * everytime (beware of fBranch changes, of course).
     * Also, now, it will be necesary to take into account the configuration
     * number.
     */
    Branch result; // empty by now
    // Be it mono or multiple, this has to be the case: the root
    // element has it's name equal to the first element in the path;
    // then in the multiple case we will allow some stutter and the
    // first path element will be searched for once again.
    if (fBranch.GetName() != path[0]) {
      /*
       * It's a requirement to have at least one value on the path.
       * We could ignore it or do this check. In the supposedly
       * case of zero-size array argument, the complier would
       * complain about the calls to Size: it's not legal (in
       * the standard sense) to have zero sized arrays.
       */
      std::ostringstream warn;
      warn << "No root branch found, wrong path: started with "
           << fBranch.GetName()
           << " but "
          << path[0]
          << " was configured as first element of the path.";
      WARNING(warn);
      return result; // none: empty return value.
    }
    // Handle according to multi or mono configuration.
    // b is an output parameter.
    Branch b;
    const bool found = ConfigHandler<Info::kAllowMultiConfig>::Handle(*this, b, path);
    if (found)
      result = b;
    // May return empty. Loggin' has been done within Handle.
    return result;
  }


  template<class Info>
  template<class Matcher>
  utl::Branch
  XXMLManager<Info>::FindMatchingBranch(const utl::Branch& b,
                                        const std::string& compName,
                                        Matcher& matcher,
                                        bool isReportingErrors)
  {
    using namespace std;
    using namespace utl;
    const char kInterRange = ',';
    const char kIntraRange = '-';
    // Typedefs related to tokenization.
    typedef boost::char_separator<char> Sep;
    typedef boost::tokenizer<Sep> Tokenizer;
    typedef Tokenizer::const_iterator It;
    // Separators used inside the following loops.
    const Sep interSep(string(1, kInterRange).c_str());
    const Sep intraSep(string(1, kIntraRange).c_str());
    // Now peform a look up based on ranges.
    //DEBUGLOG("Loop over childs of");
    //DEBUGLOG(b.GetName());
    //DEBUGLOG("looking for");
    //DEBUGLOG(compName);
    for (Branch cB = b.GetFirstChild(); cB; cB = cB.GetNextSibling()) {
      //DEBUGLOG("On the loop...");
      //DEBUGLOG(cB.GetName());
      // First /match by element name
      if (cB.GetName() == compName) {
        //DEBUGLOG("Branch match for:");
        //DEBUGLOG(compName);
        const AttributeMap branchAtt = cB.GetAttributes();
        const AttributeMap::const_iterator i = branchAtt.find(Info::kIdAtt);
        // Check to have the id; and then something used to define ranges,
        // if nothing range.
        if (branchAtt.end() != i) {
          //DEBUGLOG("Att found");
          //DEBUGLOG(i->second);
          if (i->second.find(kIntraRange) != string::npos ||
              i->second.find(kInterRange) != string::npos) {
            //DEBUGLOG("Range matching:");
            // First split among different ranges and...
            Tokenizer ranges(i->second, interSep);
            // ...loop over them.
            for (It rangesIt = ranges.begin(); rangesIt != ranges.end(); ++rangesIt) {
              const string& rangeStr = *rangesIt;
              Tokenizer range(rangeStr, intraSep);
              //DEBUGLOG("Iteration over ranges:");
              //DEBUGLOG(rangeStr);
              // Start empty.
              string lower;
              string upper;
              // Over the range.
              for (It rangeIt = range.begin(); rangeIt != range.end(); ++rangeIt) {
                const string& rangeVal = *rangeIt;
                //DEBUGLOG("Iteration inside range.");
                //DEBUGLOG(rangeVal);
                // Fill in order...
                if (lower.empty())
                  lower = rangeVal;
                else if (upper.empty())
                  upper = rangeVal;
                else if (isReportingErrors) {
                  ostringstream warn;
                  warn << "The additional elements in the range "
                       << rangeVal
                       << " specified for the component "
                       << compName
                       << " were ignored.";
                  WARNING(warn);
                }
              } // intra range
              if (upper.empty())
                upper = lower; // Allow single value ranges.
              // check if the bounds were actually found for the current range.
              // The check for upper isn't neccesary (see previous if).
              if (lower.size() /*&& upper.size()*/) {
                int lb = 0;
                int ub = 0;
                istringstream ls(lower);
                istringstream us(upper);
                if (ls >> lb && us >> ub) {
                  if (matcher(lb, ub)) {
                    //DEBUGLOG("Range match.");
                    return cB;
                  }
                } else if (isReportingErrors) {
                  ostringstream warn;
                  warn << "The elements in the range "
                       << rangeStr
                       << " specified for the component "
                       << compName
                       << " were ignored as they couldn't be interpreted as integers.";
                  WARNING(warn);
                }
              } else if (isReportingErrors) {
                ostringstream warn;
                warn << "The range "
                     << rangeStr
                     << " specified for the component "
                     << compName
                     << " wasn't completely specified.";
                WARNING(warn);
              }
            } // inter range loop.
          } else {
            //DEBUGLOG("Specific matching.");
            // plain ol'id: no range.
            int id = 0;
            istringstream is(i->second);
            if (is >> id) {
              if (matcher(id)) {
                //DEBUGLOG("Specific id match");
                return cB;
              }
            } else if (isReportingErrors) {
              ostringstream warn;
              warn << "The id specified ("
                   << i->second
                   << ") specified for the component "
                   << compName
                   << " was ignored as it couldn't be interpreted as integer.";
              WARNING(warn);
            }
          }
        } else { // end had attribute.
          // No attribute was found.
          //DEBUGLOG("Implicit matching.");
          /*
           * This is an special case.
           *
           * Mainly meant for those cases where
           * the contained element is unique (at the cpp level) whithin its
           * container: ie there's a one-to-one relationship.
           *
           * What we do here is that if no attribute is found, then the
           * identifying attribute is supposed to be 1.
           * In this way, for those aforementioned cases there's no need
           * to code in the XML the, let's say it, fictious attribute.
           * I say fictious because given the one-to-one relationship there's
           * no need of an identifying value. The need of an identifying attributes
           * comes from that within the attribute map, the name of the
           * component has to be included (and so the attribute has to have some
           * definitive value). Also note that in those cases, at the cpp level,
           * the value of the identifying attribute is hardcoded (as a parameter
           * passed by the containing class upon construction of the contained
           * objects).
           */
          if (matcher(1)) {
            //DEBUGLOG("Implicit identifying attribute equal to 1 match (no attribute was found in the branch).");
            return cB;
          }
        }
      } // end had element.
    }
    //DEBUGLOG("End of loop over the childs.");
    return matcher(b);
  }


  template<class Info>
  utl::Branch
  XXMLManager<Info>::FindModelBranch(const utl::Branch& componentModels,
                                     const utl::Branch& compBranch,
                                     const std::string& name)
    const
  {
    using namespace utl;
    using namespace std;
    string modelName;
    // First look for an specific model at the component branch level.
    // XXX Use the same tag, or create another one.
    const Branch specificModel = compBranch.GetChild(Info::kModelsTag);
    if (specificModel) {
      // The model is the content of the branch, load it.
      specificModel.GetData(modelName);
    } else {
      // If not, then look for the general models specified at the root level,
      // with the models branch and an element for each component (with
      // the component name as an attribute).
      // XXX It may be better to specify the model name in the same way.
      // It the previous case, putting an element in between seems ugly.
      // And in this case I don't want to change the former way; in this
      // case, nevertheless, the model could be perfectly put as the branch
      // content.
      // Search for the particular model, if we have them.
      if (componentModels) {
        //DEBUGLOG(componentModels.GetName());
        /*
         * Retrieve the model for the component, specified under an
         * element with name equal to the one of the component.
         */
        Branch model;
        // Need to match w/o attributes, only by name:
        // the id is looked for.
        for (Branch cB = componentModels.GetFirstChild(); cB; cB = cB.GetNextSibling()) {
          if (cB.GetName() == name) {
            model = cB;
            break;
          }
        }
        if (model) {
          //DEBUGLOG(model.GetName());
          // Look up the name of the model used for the component.
          // Note that we're also using the template parameter.
          /*
           * Caveat emptor: GetAttributes return _BY COPY_
           * so you better make your own copy, instead of chaining
           * like
           * i = model.GetAttributes().find...
           * if (i != model.GetAttributes().end())
           */
          const AttributeMap att = model.GetAttributes();
          // Again the attribute name comes from the template arg.
          const AttributeMap::const_iterator i = att.find(Info::kIdAtt);
          if (i != att.end()) {
            //DEBUGLOG("Found attribute:");
            //DEBUGLOG(i->first);
            //DEBUGLOG(i->second);
            // We have the name of the model on the iterator.
            modelName = i->second;

          } else if (IsReportingErrors()) {
            ostringstream warn;
            warn << "The actual models found for the component "
                 << name
                 << " don't have an identification attribute.";
            WARNING(warn);
          }
        } else if (IsReportingErrors()) {
          ostringstream warn;
          warn << "No actual models were found for the component " << name << ".";
          WARNING(warn);
        }
      } else if (IsReportingErrors()) {
        ostringstream warn;
        warn << "No actual models were found " << name << ".";
        WARNING(warn);
      }
    } // End of model name look-up.
    // Retrieve the branch where the data for models is specified.
    const Branch modelsData = FindRoot(Info::kModelsRootPath);
    //DEBUGLOG(modelName);
    // FindRoot takes care of reporting.
    if (modelsData && modelName.size()) {
        //DEBUGLOG(modelsData.GetName());
        /*
         * Build attributes map (I prefer this
         * over the string with = in between, seems cleaner
         * for my taste).
         */
        AttributeMap a;
        // Look up for the model specified by the name.
        a.insert(AttributeMap::value_type(Info::kIdAtt, modelName));
        /*
         * LookUp for the branch with the data for the model:
         * the name is again the one taht comes from the component
         * and we have set up attributes with the name of the
         * particular model.
         *
         * Simply return the value, the caller has to
         * take care if it's empty or not.
         */
        return modelsData.GetChild(name, a);
    }
    // No match, empty branch.
    return Branch();
  }


  template<class Info>
  template<typename T>
  det::VManager::Status
  XXMLManager<Info>::GetDataInternal(const utl::Branch& /*topB*/,
                                     T& /*t*/,
                                     const std::string& /*prop*/,
                                     const std::string& /*name*/)
    const
  {
    std::ostringstream err;
    err << "Information without attributes was required with an scalar type.";
    ERROR(err);
    return VManager::eNotFound;
  }


  template<class Info>
  template<typename T>
  det::VManager::Status
  XXMLManager<Info>::GetDataInternal(const utl::Branch& topB,
                  std::list<T>& t,
                  const std::string& componentName,
                  const std::string& /*name*/)
    const
  {
    const utl::AttributeMap atts = topB.GetAttributes();
    AccumulatorMatcher<std::list<T> > matcher(t, IsReportingErrors());
    // Ignore the result.
    // In this particular case the property name is a component name, so the
    // name parameter is ignored.
    FindMatchingBranch(topB, componentName, matcher, IsReportingErrors());
    /*
     * The original function taken as reference
     *
     * VManager::Status
     * SStationListXMLManager::GetFullStationListXML(
     * list<int>& returnList,
     * const string& componentProperty,
     * const string& componentName,
     * const IndexMap& componentIndex)
     *
     * upon each insertion performed a lower_bound look to do an ordered
     * insertion and to check for reps.
     *
     * It seems better to check that thing upon finalization instead of
     * in each insertion.
     */
    /* First do a simple check, it's likely to have
     * the list already ordered.
     * Of course, if it's empty we don't have to bother at all.
     */
    if (t.size() &&
        std::adjacent_find(t.begin(), t.end(), boost::lambda::_1 >= boost::lambda::_2) != t.end()) {
      // Bad luck, it needs to be sorted.
      /*
       * No, no: this needs random access iterators:
       * std::sort(t.begin(), t.end());
       */
      t.sort(); // This is O(N log(N)) anyway.
      // Check against repetitions.
      typename std::list<T>::const_iterator i =
        std::adjacent_find(t.begin(), t.end(), boost::lambda::_1 == boost::lambda::_2);
      if (i != t.end()) {
        // The function from SStationListXMLManager did this unconditionally.
        if (IsReportingErrors()) {
          std::ostringstream warn;
          warn << "The id = " << *i << " "
                  "appears more than once in the XML file list. "
                  "This and other repetitions will be ignored.";
          WARNING(warn);
        }
        // Modify the list to have no reps.
        std::unique(t.begin(), t.end());
      }
    }
    return matcher.IsModified() ? VManager::eFound : VManager::eNotFound;
  }


  template<class Info>
  template<typename T>
  det::VManager::Status
  XXMLManager<Info>:: // split line
  GetDataInternal(T& t, const std::string& prop, const std::string& name, const det::VManager::IndexMap& m)
    const
  {
    using namespace utl;
    using namespace det;
    using namespace std;
    //DEBUGLOG(Info::kManagerName);
    //DEBUGLOG(name);
    //DEBUGLOG(prop);
    const bool handleModels = ! string(Info::kModelsTag).empty();
    /*
     * This call discards cv-qualifiers over 'this'
     * if (!fIsInitialized)
     *   Init(Info::kManagerName);
     *
     * Can't remember nor find from where I took this
     * previous code that was done here (I believe I
     * took it from some other manager):
     * Anyway put it in the initialize, and that's it.
     */
    /*
     * By this time, fBranch is already initialized (during configuration of
     * the register).
     */
    // Retrieve the branch were the actual data resides.
    Branch dataRoot = FindRoot(Info::kDataRootPath);
    // Check if the root was actually found.
    if (dataRoot) {
      // Retrieve once and for all the total number of attributes.
      const unsigned int nAttTotal = m.size();
      /*
       * Transverse among siblings, for non model-like configuration
       * a single sibling will exist; for model-like multiple ones
       * will exist, and the particular element name will correspond
       * to the configuration (this element name is ignored for the
       * matters of this class, it's simply a label within the XML).
       */
      if (handleModels) {
        //DEBUGLOG("Handling models");
        /*
         * If there are models, then there's an element
         * in between groups the child branches belonging
         * to a particular model configuration.
         */
        dataRoot = dataRoot.GetFirstChild();
      }
      for (Branch cB = dataRoot; cB; cB = cB.GetNextSibling()) {
        unsigned int nAttFound = 0;
        Branch curr = cB;
        //DEBUGLOG(cB.GetName());
        /*
         * Whenever the path transversed brakes, then abort
         * the loop: that path is kept in curr.
         *
         * See comments inside to tell why i is compared with <=.
         */
        for (unsigned int i = 0; curr && i <= Size(Info::kComponentsIds); ++i) {
          /*
           * Here we check if the last component was in the match: if
           * that's the case then given that the components exhausted, then
           * the look-up for the (non existing) component id is equivalent
           * to a not found id in the map m.
           * If i is over the Size then the iterators gets initialized directly
           * with the end, and so we go over the else.
           * if the total number of attributes isn't reached then we'll try
           * another loop, but then the condition over i will break the loop:
           * that's correct. If we haven't reached the total number of ids
           * but the path in the branches ends first, we have to abort the search,
           * there's no match in/under this branch.
           */
          const IndexMap::const_iterator attIt = i < Size(Info::kComponentsIds) ?
                                                 m.find(Info::kComponentsIds[i]) :
                                                 m.end();
          //DEBUGLOG(i < Size(Info::kComponentsIds) ? Info::kComponentsIds[i] : "Past last component.");
          if (attIt != m.end()) {
            // If we enter here then i is a valid index.
            const string compName(Info::kComponentsNames[i]);
            // The match for specific id could be done directly with look up,
            // but I preferred to call FindMatchingBranch and have a common code.
            IdMatcher matcher(attIt->second, compName, IsReportingErrors());
            // Proceed to further levels.
            curr = FindMatchingBranch(curr, compName, matcher, IsReportingErrors());
            //DEBUGLOG(curr ? "Match found" : "No match found");
            nAttFound++;
          } else {
            if (nAttFound == nAttTotal) {
              //DEBUGLOG("Exhausted attributes.");
              // Do a linear search starting from i 'til the end (or 'til find).
              bool isComponent = false;
              /*
               * Note that when i is past the number of components, then this loop never
               * enters and, so, isComponent is false. That's correct, if the match
               * is the last in the component array, then it's a leaf in the hierarchy,
               * and so no further component will be under it. Remember also, that
               * if the list of these last component is desired then no id should
               * be specified in the map, and so we wouldn't reach this line of code
               * for i past the total number of components.
               * See then comment inside the isComponent condition.
               * At last, note that, precisely, the index i is never used again anymore.
               */
              for (unsigned int j = i; !isComponent && j < Size(Info::kComponentsIds); ++j)
                isComponent = Info::kComponentsNames[j] == prop;
              if (isComponent) {
                // Found a leaf of the hierarchy where we're looking for.
                /*
                 * If the property is the same as a component name, we
                 * should not have an id for that level on the attribute
                 * map (this is not actually checked, but it's implied
                 * since we have reached nAttTotal and here we're in the
                 * case where attIt == m.end).
                 * What is meant is  to retrieve the list of all
                 * the component's ids on that level.
                 */
                // The attributes maps is needed, in fact we have already
                // consumed all its data.
                // Call the overloaded method.
                //DEBUGLOG("Searching for a component.");
                return GetDataInternal(curr, t, prop, name);
              } else {
                /*
                 * It's indeed a property, get the specific prop;
                 * but not so quick dude, maybe there shall be
                 * a "model" indirection, that's, with all this
                 * loops we have just determined the models that
                 * correspond to the desired component.
                 */
                if (handleModels) {
                  //DEBUGLOG("Searching via models.");
                  //DEBUGLOG(Info::kModelsTag);
                  /*
                   * Yes, we have models cause the specified tag
                   * is not empty: so, retrive'em.
                   */
                  const Branch componentModels = cB.GetChild(Info::kModelsTag);
                  /*
                   * Look-up the branch with the data according to the models
                   * we found.
                   *
                   * XXX Put even this in a policy? No, at least for now.
                   */
                  curr = FindModelBranch(componentModels, curr, name);
                  if (!curr) {
                    //DEBUGLOG("No model found.");
                    // Normally the models should be found.
                    // The called function takes care of the reporting.
                    return VManager::eNotFound;
                  }
                }
                // In any case, prop should (if existing) hang form curr.
                curr = curr.GetChild(prop);
                if (curr) {
                  curr.GetData(t);
                  return VManager::eFound;
                }
                //XXX Here we are allowing to go on the logic and match other branches.
              }
            }
            /* else {
             * Go on with the loop haven't examined all the attributes
             * in the map.
             * If we don't find a particular idName in m that means
             * that we are looking for something that's not
             * in the particular branch of the detector that
             * contains that idName.
             * i < j => idNames[j] doesn't come before idNames[i]
             * in the hierarchy of the detector.
             * So in this case, we can skip the particular one.
             * }
             */
          }
        }
      }
      // Not found in any of the siblings.
      if (IsReportingErrors()) {
        string msg = QueryInfoMessage(prop, name, m);
        msg += " not Found.";
        WARNING(msg);
      }
    } else if (IsReportingErrors()) {
      ostringstream warn;
      warn << "No data branch found:";
      for (unsigned int i = 0; i < Size(Info::kDataRootPath); ++i)
        warn << " " << Info::kDataRootPath[i];
      warn << ".";
      WARNING(warn);
    }
    // Not found exit, in any of the cases.
    return VManager::eNotFound;
  }

}


#endif