cmnStreamRawParser.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):    Peter Kazanzides

  (C) Copyright 2009-2014 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---

*/


#pragma once

#ifndef _cmnStreamRawParser_h
#define _cmnStreamRawParser_h

#include <iostream>
#include <string>
#include <set>
#include <functional>

#include <cisstCommon/cmnDataFunctions.h>
#include <cisstCommon/cmnLogger.h>

#include <cisstCommon/cmnExport.h>

class CISST_EXPORT cmnStreamRawParser
{
   class EntryBase {
   protected:
       std::string key;
       char delimiter;
       bool required;
       bool valid;
    public:
       EntryBase(const std::string &name, char delim = ' ', bool req = true) :
                 key(name), delimiter(delim), required(req), valid(false) {}
       virtual ~EntryBase() {}

       std::string GetKey() const { return key; }
       bool isRequired() const { return required; }
       bool isValid() const { return valid; }
       void SetValid(bool val) { valid = val; }

       // Following should be implemented in the derived classes
       virtual bool Parse(std::istream &CMN_UNUSED(inputStream)) { return false; }
       virtual void ToStream(std::ostream & outputStream) const { outputStream << key << " (default)"; }
   };

   template <class _elementType>
   class Entry : public EntryBase {
       _elementType *valuePtr;
   public:
       Entry(const std::string &name, _elementType &data, char delim = ' ', bool req = true) :
             EntryBase(name, delim, req), valuePtr(&data) {}
       ~Entry() {}

       bool Parse(std::istream &inputStream) {
           if (valid) CMN_LOG_INIT_WARNING << "cmnStreamRawParser: duplicate entry for " << key << std::endl;
           if (valuePtr) {
               try {
                   cmnData<_elementType>::DeSerializeText(*valuePtr, inputStream, delimiter);
                   valid = true;
               }
               catch (const std::runtime_error &) {
                   valid = false;
               }
           }
           return valid;
       }

       void ToStream(std::ostream & outputStream) const {
           outputStream << key << " ";
           if (valuePtr && valid) {
               try {
                   cmnData<_elementType>::SerializeText(*valuePtr, outputStream, delimiter);
               }
               catch (const std::runtime_error &e) {
                   outputStream << "(invalid: " << e.what() << ")";
               }
           }
           else
               outputStream << "(invalid)";
       }
   };

   template <class _elementType>
   class EntryStreamable : public EntryBase {
       _elementType *valuePtr;
   public:
       EntryStreamable(const std::string &name, _elementType &data, bool req = true) :
                       EntryBase(name, ' ', req), valuePtr(&data) {}
       ~EntryStreamable() {}

       bool Parse(std::istream &inputStream) {
           if (valid) CMN_LOG_INIT_WARNING << "cmnStreamRawParser: duplicate entry for " << key << std::endl;
           if (valuePtr)
               inputStream >> *valuePtr;
           valid = inputStream.good();
           return valid;
       }

       void ToStream(std::ostream & outputStream) const {
           outputStream << key << " ";
           if (valuePtr && valid)
               outputStream << *valuePtr;
           else
               outputStream << "(invalid)";
       }
   };

   // Comparison operator for std::set
   struct KeyListLess: public std::binary_function<const cmnStreamRawParser::EntryBase*, const cmnStreamRawParser::EntryBase*, bool>
   {
       result_type operator()(first_argument_type p1, second_argument_type p2) const
      {
          return p1->GetKey() < p2->GetKey();
      }
   };

   typedef std::set<cmnStreamRawParser::EntryBase *, KeyListLess> KeyListType;
   KeyListType KeyList;

public:
   cmnStreamRawParser() {}
   ~cmnStreamRawParser();

   template <class _elementType>
   bool AddEntry(const std::string &name, _elementType &data, char delim = ' ', bool req = true)
   {
       cmnStreamRawParser::EntryBase *newEntry = new Entry<_elementType>(name, data, delim, req);
       bool result = KeyList.insert(newEntry).second;
       if (!result) delete newEntry;  // if not inserted, delete entry
       return result;
   }

   template <class _elementType>
   bool AddEntryStreamable(const std::string &name, _elementType &data, bool req = true)
   {
       cmnStreamRawParser::EntryBase *newEntry = new EntryStreamable<_elementType>(name, data, req);
       bool result = KeyList.insert(newEntry).second;
       if (!result) delete newEntry;  // if not inserted, delete entry
       return result;
   }

   void SetAllValid(bool val = true);

   bool Parse(std::istream & inputStream);

   bool IsValid(const std::string &name) const;

   void ToStream(std::ostream & outputStream) const;
};

#endif // _cmnStreamRawParser_h