String.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_util_String_hpp
#define anna_core_util_String_hpp

#include <string>

#include <stdio.h>

#include <anna/core/util/defines.hpp>

namespace anna {

class DataBlock;

class String : public std::string {
public:
  struct Flag { enum _v { None, ShowNull }; };

  String(const Flag::_v flag = Flag::None) : a_flags(flag) {;}

  explicit String(const char* str, const Flag::_v flag = Flag::None) :
    std::string((str == NULL) ? ((flag & Flag::ShowNull) ? "<null>" : "") : str),
    a_flags(flag)
  {;}

  String(const String &other) : std::string(other), a_flags(other.a_flags) {;}


  explicit String(const std::string& other, const Flag::_v flag = Flag::None) : std::string(other), a_flags(flag) {;}

  void toUpper() ;

  void toLower() ;

  String& operator = (const char* vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const int vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const unsigned int vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const bool vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const S64 vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const U64 vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const float vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const double vv) { std::string::clear(); return operator<< (vv); }
  String& operator = (const std::string& vv) { std::string::operator= (vv); return *this; }
  String& operator = (const DataBlock& vv) { std::string::clear(); return operator<< (vv); }

  String& operator += (const char* vv) { return operator<< (vv); }
  String& operator += (const int vv) { return operator<< (vv); }
  String& operator += (const unsigned int vv) { return operator<< (vv); }
  String& operator += (const bool vv) { return operator<< (vv); }
  String& operator += (const S64 vv) { return operator<< (vv); }
  String& operator += (const U64 vv) { return operator<< (vv); }
  String& operator += (const float vv) { return operator<< (vv); }
  String& operator += (const double vv) { return operator<< (vv); }
  String& operator += (const std::string& vv) { return *this << vv; }
  String& operator += (const DataBlock& vv) { return *this << vv; }

  String& operator << (const char* vv) ;
  String& operator << (const int vv) ;
  String& operator << (const unsigned int vv) ;
  String& operator << (const bool vv) { std::string::operator+= ((vv == true) ? "true" : "false"); return *this; }
  String& operator << (const S64 vv) ;
  String& operator << (const U64 vv) ;
  String& operator << (const float vv) ;
  String& operator << (const double vv) ;
  String& operator << (const std::string& vv) { std::string::operator+= (vv); return *this; }
  String& operator << (const DataBlock& vv) ;

  static String format(const float vv, const char* format) { return __format(vv, format); }

  static String format(const double vv, const char* format) { return __format(vv, format); }

  static String format(const DataBlock& vv, const int characterByLine) ;

  static String hex(const int vv) { return __format(vv, "0x%x"); }

  static String hex(const unsigned int vv) { return __format(vv, "0x%x"); }

  static String hex(const S64 vv) {
    return __format(vv, "0x%llx");
    /*#ifdef __anna64__
       return __format (vv, "0x%lx");
    #else
       return __format (vv, "0x%llx");
    #endif
    */
  }

private:
  Flag::_v a_flags;

  template <typename T> static String __format(const T vv, const char* format) {
    char aux [64];
    sprintf(aux, format, vv);
    return String(aux);
  }
};

}

#endif