rwTranslatableStringObject.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2014 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once



#include "vrfutil/vrfutilDefines.h"
#include "vrfutil/readerWriter.h"
#include "vrfutil/rwTemplatedList.h"
#include "vrfutil/iteratorBase.h"
#include "vrfutil/rwString.h"
#include "vrfutil/kinematicTools.h"
#include <vrfutil/templatedDecoders.h>
#include <boost/function.hpp>
#include <vlutil/vlStringUtil.h>

class DtOutputStream;

class DT_DLL_vrfutil DtRwTranslatableStringObject : public DtReaderWriter
{
public:
   typedef boost::function<std::string (const char* module, const char* stringToTranslate)> TranslationFunction;

   DtRwTranslatableStringObject();

   DtRwTranslatableStringObject(const DtString& name, DtReaderWriterRegistry* 
      parentRegistry = 0);

   DtRwTranslatableStringObject(const DtString& name, const DtRwTranslatableStringObject& orig,
      DtReaderWriterRegistry* parentRegistry = 0);

   DtRwTranslatableStringObject(const DtRwTranslatableStringObject& orig,
      DtReaderWriterRegistry* parentRegistry = 0);

   const DtRwTranslatableStringObject& operator=(const DtRwTranslatableStringObject& orig);

   virtual bool operator==(const DtRwTranslatableStringObject& orig) const;
   virtual bool operator!=(const DtRwTranslatableStringObject& orig) const;

   virtual ~DtRwTranslatableStringObject();

   virtual const char* readerWriterType() const;

   static const char* theXmlType();

   virtual const char* xmlType() const
   {
      return theXmlType();
   }

   virtual void printTo(DtOutputStream&) const;

   virtual void addTranslatableString(const DtString&, const DtString& module = "DtRwTranslatableStringObject",
      const DtString& originalString = "");
   virtual void addArgument(const DtString&);

   virtual void clear();

   virtual std::string toFormattedString(bool finalCR = true) const;

   virtual std::vector<int> typesFrom(const std::string& fmt, std::string& reformatted) const;

   static DtRwTranslatableStringObject trUtf8(const DtString& string);

   DtString translate(bool finalCR = true) const
   {
      DtIteratorBase<DtRwString> iterator(myStringQueue);
      DtString result;
      unsigned int argsTranslated = 0;

      while (iterator.current())
      {
         std::vector<std::string> results;
         std::string source(iterator.current()->name().c_str());

         oldBoostSplit(results, source, boost::algorithm::is_any_of("="));

         if (results.size())
         {
            if (results[0] == "translate")
            {
               std::string module;
               std::string toTranslate = (*iterator.current()).c_str();
               if (results.size() >= 2)
               {
                  module = results[1];

                  if (results.size() == 3)
                  {
                     toTranslate = results[2];
                  }
               }

               std::string translated = (theTranslatorFunction)(module.c_str(), toTranslate.c_str()).c_str();

               if (translated == toTranslate.c_str())
               {
                  translated = (*iterator.current()).c_str();
               }

               result += translated;
            }
            else if (results[0] == "argument")
            {
               result = DtReplaceSubstring(result, "%1", iterator.current()->c_str());

               argsTranslated++;

               result = DtReplaceSubstring(result, "%" + DtString(argsTranslated + 1), "%1");
            }
         }
         else
         {
            result += *iterator.current();
         }

         ++iterator;
      }

      if (finalCR && (!result.length() || result[result.length() - 1] != '\n'))
      {
         result += "\n";
      }

      return result;
   }

   static void setTranslationFunction(TranslationFunction f) { theTranslatorFunction = f; };
   TranslationFunction translationFunction() const { return theTranslatorFunction; };

   static std::string defaultTranslationFunction(const char* module, const char* toTranslate) { return toTranslate; };

protected:
   DtRwTemplatedListPtr<DtRwString, true> myStringQueue;
   static TranslationFunction theTranslatorFunction;
};