src/IO/Serialization.h

Go to the documentation of this file.

/*
* This file is part of MultiBoost, a multi-class 
* AdaBoost learner/classifier
*
* Copyright (C) 2005 Norman Casagrande
* For informations write to nova77@gmail.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*
*/

#ifndef __SERIALIZATION_H
#define __SERIALIZATION_H

#include "WeakLearners/BaseLearner.h"
#include "IO/ClassMappings.h"
#include "Utils/StreamTokenizer.h"

#include "Utils/Utils.h"

#include <sstream>
#include <algorithm> // for fill

using namespace std;


namespace MultiBoost {

class Serialization
{
public:

   Serialization(const string& shypFileName, const string& weakLearnerName);

   ~Serialization();

   void  saveHypotheses(vector<BaseLearner*>& weakHypotheses);

   void  appendHypothesis(const int iteration, BaseLearner* pWeakHypothesis);

   // helper functions for creating xml tags

   template <typename T>
   static string standardTag(const string& tagName, const T& value, const int numTab = 0)
   {
      ostringstream ss;
      ss << getTabs(numTab);
      ss << "<" << tagName << ">" << value << "</" << tagName << ">";
      return ss.str();
   }

   
   template <typename T>
   static string vectorTag(const string& tagName, const vector<T>& values, 
                           const int numTab = 0)
   {
      ostringstream ss;
      ss << getTabs(numTab);
      
      // The header of the vector
      ss << "<" << tagName << " size=\"" << values.size() << "\">\n";
      
      // The vector values
      for (int i = 0; i < (int)values.size(); ++i)
      {
         ss << getTabs(numTab+1);
         ss << "<class id=\"" << ClassMappings::getClassNameFromIdx(i) << "\">" << values[i] << "</class>\n";
      }

      // closing tag
      ss << getTabs(numTab);
      ss << "</" << tagName << ">"; // close tag

      return ss.str();
   }

private:

   string _shypFileName; 

   inline static string getTabs(const int numTabs)
   {
      string tabs;
      tabs.resize(numTabs);
      fill(tabs.begin(), tabs.end(), '\t');
      return tabs;
   }

};

// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------

class UnSerialization
{
public:
   void loadHypotheses(const string& shypFileName, 
                       vector<BaseLearner*>& weakHypotheses);

   static bool seekSimpleTag(nor_utils::StreamTokenizer& st, const string& tag);

   static bool seekParamTag(nor_utils::StreamTokenizer& st, const string& tag);

   static bool seekAndParseParamTag(nor_utils::StreamTokenizer& st, 
                                    const string& tag, string& tagParam, string& paramValue);

   static void parseParamTag(const string& str, 
                             string& tag, string& tagParam, string& paramValue);

   template <typename T>
   static T seekAndParseEnclosedValue(nor_utils::StreamTokenizer& st, const string& tag)
   {
      do {
         // keeps getting the next token until it finds the tag
         if ( nor_utils::cmp_nocase( st.next_token(), tag ) )
         {
            T val;
            istringstream ss(st.next_token()); 
            ss >> val;
            return val;
         }
      } while( st.has_token() );

      return T();
   }

   template <typename T>
   static void seekAndParseVectorTag(nor_utils::StreamTokenizer& st, 
                                     const string& arrayName, 
                                     vector<T>& vecToFill)
   {

      string tagParam, paramVal;

      // move until the tag arrayName, then get the value of the param "size"
      seekAndParseParamTag(st, arrayName, tagParam, paramVal);

      // resize the vector to vector size
      // (FIXME: not very safe!)
      vecToFill.resize( atoi(paramVal.c_str() ) );

      T tmpVal;
      string className;
      string tag, param;

      // parses the xml vector definition
      const string closeTag = "/" + arrayName;
      while ( !nor_utils::cmp_nocase(tag, closeTag) && st.has_token() )
      {
         // seek the parameter "class"
         parseParamTag(st.next_token(), tag, param, paramVal );
         if ( !nor_utils::cmp_nocase(tag, "class") )
            continue;

         // convert the string into a value
         istringstream ss( st.next_token() );
         ss >> tmpVal;

         // stores the value, using the mapping from the class name
         // to the class index.
         vecToFill[ ClassMappings::getIdxFromClassName(paramVal) ] = tmpVal;
      }

   }

};

} // end of namespace MultiBoost

#endif // __SERIALIZATION_H

---