jueves, 3 de septiembre de 2015

Windows Runtime DateTime to SYSTEMTIME conversion

This post is about how to make date/time conversion between Windows::Foundation::DateTime and SYSTEMTIME structure types. Let's go to see by example:


// First we obtain the current DateTime from Calendar class

Windows::Globalization::Calendar^ cal = ref new Windows::Globalization::Calendar();
Windows::Foundation::DateTime date= cal->GetDateTime();


// Here, we are converting DateTime to a 64bit value (UniversalTime format)
ULARGE_INTEGER time;
time.QuadPart = date.UniversalTime;


// Now convert the ULARGE_INTEGER to a FILETIME structure
FILETIME fileTime;
fileTime.dwHighDateTime = time.HighPart;
fileTime.dwLowDateTime = time.LowPart;


// And finally we get a SYSTEMTIME value by calling the FileTimeToSystemTime Windows Api.
SYSTEMTIME systemTime;
FileTimeToSystemTime(&fileTime, &systemTime);

With C++ and once again, we are doing many things to something simple but sometimes necessary.

C++ Platform::String^ object to const wchar_t* conversion

In Windows Store applications, for example when you want to make a shared library, it is necessary to make use of common types like Platform::String. All the public types must be types from Windows Runtime to make it possible a cross language usage of your libraries (C++, JavaScript, C#, VB).

But when you want to use the C++ standard types like wchar_t or std::wstring, you're going to need a temporary conversion from Windows Runtime types to C++ Standard types.

You can access the string value of a Platform::String^ object by using the Data() method like this:

Platform::String^ ps3DModel(L"Gear");
std::wstring _3DModel = ps3DModel->Data();


Now, you can use the _3DModel std::wstring like another C++ standard string by using his own methods. Also, you could have converted to a "const wchar_t type":


const wchar_t * _3DModel = ps3DModel->Data();

The problem is when you want to make any changes into the ps3DModel Platform::String object since this is inmutable. What you mus to do is make a copy of the string into a std::wstring object and them modify it according to your needs. Later, when you must save the changes into the Platform::String object, you must create as a new "ref new Platform::String^". But better, let's see this with a small example:


// We create the Platform::String object
Platform::String^ ps3DModel(L"Gear");

// Now, we copy the string into a new wstring object
std::wstring _3DModel = ps3DModel->Data();

// Here we make some changes
_3DModel = L"_GEAR_";

// An finally, we put the changes into the original 'ps3DModel' object
ps3DModel = ref new Platform::String(_3DModel.c_str());

WinRT with C++ Standard vs C++/CX

OFFTOPIC:
Nota: Hoy he decidido escribir esta publicación del blog en inglés.
Note: Today I decided to write this blog post in English.


In a new application than I am developing for a company, I had to decide if to make use of C++/CX (C++ with Component Extension) or make all the main stuff in C++ standard and ABI/COM.

All of you than have had to work with COM (Component Object Model) and fighting with the interfaces, reference count, etc. known the tricky and heavy that it can become.

As an example of the easy approach using C++/CX, I am creating a new Uri object, like this:

auto uriEasyWay = ref new Windows::Foundation::Uri(http://www.manuelvillasur.com);
assert(wcscmp(uriEasyWay->AbsoluteUri->Data(), L"http://www.manuelvillasur.com/") == 0);


Now, I going to show you the more difficult approach using C++ Standard and  ABI/COM interfaces:

HSTRING_HEADER header = {};
HSTRING string = nullptr;

HRESULT hr = WindowsCreateStringReference(L"Windows.Foundation.Uri", 22, &header, &string);

if (SUCCEEDED(hr)) {
    ABI::Windows::Foundation::IUriRuntimeClassFactory * factory = nullptr;
    hr = RoGetActivationFactory(string, __uuidof(factory), reinterpret_cast<void **>(&factory));

    if (SUCCEEDED(hr)) {
        HSTRING stringUri = nullptr;
        hr = WindowsCreateStringReference(L"http://www.manuelvillasur.com", 24, &header, &stringUri);

        if (SUCCEEDED(hr)) {
            ABI::Windows::Foundation::IUriRuntimeClass * uri = nullptr;
            hr = factory->CreateUri(stringUri, &uri);

            if (SUCCEEDED(hr)) {
                HSTRING absUriString = nullptr;
                hr = uri->get_AbsoluteUri(&absUriString);
                if (SUCCEEDED(hr)) {
                    const WCHAR * uriString = WindowsGetStringRawBuffer(absUriString, nullptr);
                    assert(wcscmp(uriString, L"http://www.manuelvillasur.com/") == 0);
                    WindowsDeleteString(absUriString);
                }
                uri->Release();
            }
        }
        factory->Release();
    }
}

martes, 1 de septiembre de 2015

C++ Moderno

Si eres programador de C++, no te quedes atrás y ponte las pilas con C++ Moderno, porque ya viene pisando fuerte desde hace unos añitos y cada vez se está haciendo notar más.


Con las nuevas especificaciones del lenguaje de programación C++ (C++11, C++14, 17 ...) vienen, como es lógico, nuevas características interesantes y poderosas que no podemos dejar de utilizar por desconocimiento. Así, aunque podemos seguir programando en C++ "antiguo", hacer caso omiso de las nuevas características del lenguaje impedirá, entre otras cosas, que seas más productivo.


Como ejemplo, puedes echar un vistazo a esta función que localicé hace tiempo por Github (https://gist.github.com/goldshtn/7433212) en la cual puedes ver algunas de estas nuevas características del lenguaje:


#include <iostream>

#include <future>


using namespace std;


template <typename Fn, typename... Args>

auto do_async_with_log(ostream& os, Fn&& fn, Args&&... args) ->

         future

{

    os << "[TID=" << this_thread::get_id()

       << "] Starting to invoke function..." << endl;

    auto bound = bind(fn, forward(args...));

    return async([b=move(bound),&os]() mutable {

            auto result = b();

            os << "[TID=" << this_thread::get_id()

               << "] ...invocation done, returning " << result << endl;

             return result;

     });

}


Cualquier programador de C++ de "la vieja escuela", posiblemente al observar este código se pregunte ¿Esto es C++? Pues sí, pero esto es C++ Moderno.


Algunas de las nuevas características que debieras ir mirando son:


  • Plantillas Variádicas,
  • Bucles For basados en rango,
  • Inicializadores de listas,
  • Expresiones Lambdas,
  • Concurrencia,
  • Especificadores como Override, Final, noexcept, decltype, ...
  • Punteros inteligentes,
  • Referencias Rvalue y semántica move,
  • etc.

viernes, 28 de agosto de 2015

¿Dónde se instalan las aplicaciones en Windows 10?

Si necesitas saber donde se instalan las aplicaciones en Windows 10, tan solo debes dirigirte al siguiente directorio/carpeta y ahí las encontrarás:


C:\Program Files\windowsapps ó


C:\Archivos de Programa\windowsapps


Recuerda que al igual que en Windows 8 (como ya comenté aquí), esta carpeta está protegida y necesitarás los permisos adecuados para poder acceder a ella.



RAII (Resource Adquisition is Initialization)

Todo programador de C/C++ sabe que un handicap extra a la hora de diseñar software e implementarlo correctamente, es la gestión de recursos/memoria. En este lenguajete de programación es bien conocido el trabajo de punteros y reservas/liberación de memoria y los riesgos que ello conlleva si no se realiza correctamente. Encontrarse con problemas de "fugas de memoria", "saturación de recursos", "buffer overflows", UaF, además de propiciar el mal funcionamiento del software o su comportamiento no controlado, pueden dar pie a graves problemas de seguridad.

Con esta idea en mente, un buen día Bjarse Stroustrup, inventor del lenguaje de programación C++, ideó una técnica de programación conocida como RAII (Resource Adquisition Is Initialization). Traducido al español, significaría algo así como que la adquisición de recursos es inicialización. La idea general consiste en dejar que sea el propio destructor del objeto el que se encargue de liberar los recursos que se habrán reservado previamente en la inicialización del mismo.

Vamos a plantear un caso práctico donde tiene mucho sentido implementar un patrón de estas características tipo RAII. Supongamos que tenemos un clase cuyo objetivo es guardar determinados eventos en un archivo de registro (LOG) clásico. RAII nos estaría diciendo que debemos inicializar y posiblemente abrir el archivo de registro en la inicialización del objeto o en su constructor y, que dicho archivo debería cerrarse y por ende, liberar sus recursos en el destructor de dicho objeto.

Esto cobra un gran sentido, si planteamos un escenario donde el archivo de registro se ha abierto con total normalidad, pero al escribir algún determinado evento en el mismo, se produce alguna excepción., o incluso excepciones que no tengan una relación directa con la clase encargada de gestionar el registro de eventos. Algo que debemos saber, es que ante tales excepciones, el código que con seguridad se va a ejecutar es el correspondiente al destructor de los objetos, lo cual garantizaría la liberación de los recursos. Sin embargo, si no utilizamos esta técnica, podríamos estar fugando la memoria correspondiente a los recursos consumidos por el objeto, dado que tras producirse la excepción, estos no serían liberados.

A continuación podemos ver una clase donde se hace uso de la técnica de programación RAII.


class CEventLog
{
public:
 // Constructor
 CEventLog(const char* nombrearchivo)
 : _pvFile(std::fopen(nombrearchivo, "w+")) {
  if (!_pvfile) {
   throw std::runtime_error("Error al abrir el archivo de registro (LOG).");
  }
 }
 // Destructor
 ~CEventLog() {
  if (std::fclose(_pvfile)) {
   throw std::runtime_error("Error al cerrar el archivo de registro (LOG).");
  }
 }
private:
 std::FILE* _pvFile;
 // ...
};


Pues bien, esta clase la podríamos utilizar con total tranquilidad, en cuanto a la liberación de los recursos consumidos por FILE se refiere, ya que estos, serán liberados "sí o sí", en el destructor de la clase, aunque se produjeran excepciones.


Como conclusión final, recordad que la liberación de los recursos consumidos por nuestros programas, es tan importante o más que su reserva.

sábado, 22 de agosto de 2015

Base64 encoding & decoding with OpenSSL

Just a Little reminder about using base64 with OpenSSL in Windows Operating Systems.

Encoding:

C:\> OpenSSL enc -base64 < file_name_plain_text.txt

Decoding:

C:\> OpenSSL enc -base64 -d < file_name_base64_encoded.txt