rwTranslatableStringObject.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2022 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vrfutil/vrfutilDefines.h>
#include <readerWriter/readerWriter.h>

#include <vrfutil/iteratorBase.h>
#include <vrfutil/kinematicTools.h>
#include <vrfutil/rwTemplatedList.h>
#include <vrfutil/templatedDecoders.h>

#include <readerWriter/rwString.h>
#include <vlutil/vlStringUtil.h>

#include <boost/function.hpp>

class DtOutputStream;
class DtRwTranslatableStringObject;

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 );

   virtual ~DtRwTranslatableStringObject();

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

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

   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")
            {
               const unsigned MaxStrSize = 511;
               const unsigned MaxTruncated = 508;
               if (result.length() > MaxStrSize)
               {
                  result = DtString(result.c_str(), MaxTruncated) + "...";
               }
               else if (result.length() + iterator.current()->length() > MaxStrSize)
               {
                  unsigned maxSize = MaxTruncated - result.length();
                  DtString truncated(iterator.current()->c_str(), maxSize);
                  result = DtReplaceSubstring(result, "%1", truncated);
                  result += "...";
               }
               else
               {
                  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;
};