Source code

/*
 * StringConverter.h 
 * Copyright (c) 2015 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */



#pragma once

#include <viz++\Object.h>
#include <viz++\StringT.h>

/**
 */
namespace VIZ {

class StringConverter :public Object {

public:
  StringConverter() {
  }

public:
  // char -> char
  bool convert(const char* mbstring, __out StringT<char>& string)
  {
    bool rc = false;
    if (mbstring) {
      //return a copy of mbstring
      string = mbstring;
      rc = true;
    }
    return rc;
  }

public:
  // char -> wchar_t
  bool convert(const char* mbstring, __out StringT<wchar_t>& string)
  {
    return toWideChar(mbstring, string);
  }

public:
  // wchar_t -> char
  bool convert(const wchar_t* wcstring, __out StringT<char>& string)
  {
    return toMultiByte(wcstring, string);
  }

public:
  // wchar_t -> wchar_t
  bool convert(const wchar_t* wcstring, __out StringT<wchar_t>& string)
  {
    bool rc = false;
    if (wcstring) {
      //return a copy of mbstring
      string = wcstring;
      rc = true;
    }
    return rc;
  }


public:
  /**
   * MultiByteString -> WideCharString(Unicode)
   */
  wchar_t* toWideChar(const char* mbstring) {
    wchar_t* wcstring = NULL;

    if (mbstring == NULL) {
      return wcstring;
    }
    
    int cb = MultiByteToWideChar(CP_ACP, 0, mbstring, -1, NULL, 0); 
    if (cb >0) {
      wcstring = new wchar_t[cb];
      wcstring[0] = ZERO;
      MultiByteToWideChar(CP_ACP, 0, mbstring, -1, wcstring, cb); 
    }
    return wcstring;
  }

public:
  /**
   * WideCharString -> WideCharString(Unicode)
   */
  wchar_t* toWideChar(const wchar_t* wstring) {
    wchar_t* wcstring = NULL;

    if (wstring == NULL) {
      return wcstring;
    }

    //Simply return a duplicate wchar_t string.
    wcstring = _strdup(wstring);

    return wcstring;
  }

public:
  /**
   * MultiByteString -> WideCharString(Unicode)
   */
  //2009/10/10
  bool toWideChar(__in const char* mbstring, __out StringT<wchar_t>& stringw) {
    bool rc = false;

    if (mbstring == NULL) {
      return rc;
    }
    
    int cb = MultiByteToWideChar(CP_ACP, 0, mbstring, -1, NULL, 0); 
    if (cb >0) {
      wchar_t* wcstring = NULL;

      wcstring = new wchar_t[cb];
      wcstring[0] = ZERO;
      MultiByteToWideChar(CP_ACP, 0, mbstring, -1, wcstring, cb);
      stringw.shallowCopy(wcstring);
      rc = true;
    }
    return rc;
  }

public:
  /**
   * WideCharString(Unicode) -> MultiByteString 
   */
  char* toMultiByte(const wchar_t* wcstring) {

    char* mbstring = NULL;

    if (wcstring == NULL) {
      return mbstring;
    }
    
    int cb = WideCharToMultiByte(CP_ACP, 0, wcstring, -1, NULL, 0, NULL, NULL);
    
    if (cb > 0) {
      mbstring = new char[cb];
      mbstring[0] = ZERO;
      WideCharToMultiByte(CP_ACP, 0, wcstring, -1, mbstring, cb, NULL, NULL);
    }
    return mbstring;
  }

public:
  /**
   * MultiByteString(Unicode) -> MultiByteString 
   */
  char* toMultiByte(const char* cstring) {

    char* mbstring = NULL;

    if (cstring == NULL) {
      return mbstring;
    }

    //Simply return a duplicate char string.
    mbstring = _strdup(cstring);

    return mbstring;
  }



public:
  /**
   * WideCharString(Unicode) -> MultiByteString 
   */
  //2009/10/10
  bool toMultiByte(__in const wchar_t* wcstring, __out StringT<char>& stringt) {

    bool rc = false;

    if (wcstring == NULL) {
      return rc;
    }
    
    int cb = WideCharToMultiByte(CP_ACP, 0, wcstring, -1, NULL, 0, NULL, NULL);
    
    if (cb > 0) {
      char* mbstring = new char[cb];
      mbstring[0] = ZERO;
      WideCharToMultiByte(CP_ACP, 0, wcstring, -1, mbstring, cb, NULL, NULL);
      
      stringt.shallowCopy(mbstring);

      rc = true;
    }
    return rc;
  }


public:
  /**
   * MultiByteString -> BSTR
   */
  BSTR toBSTR(const char* mbstring) {
  
     BSTR bstring = NULL;
  
    if (mbstring == NULL) {
      return bstring;
    }

    int  cb = MultiByteToWideChar(CP_ACP, 0, mbstring, -1, NULL, NULL) -1;
     bstring = SysAllocStringLen(NULL, cb);
    if (bstring != NULL) {
      MultiByteToWideChar(CP_ACP, 0, mbstring, -1, bstring, cb);
    }
    return bstring;
  }

public:
  //2009/06/18
  BSTR toBSTR(const wchar_t* wcstring)
  {
    BSTR bstring = NULL;
    if (wcstring == NULL) {
      return bstring;
    }
  
    bstring = SysAllocStringLen(wcstring, wcslen(wcstring));

    return bstring;
  }
};

}