/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#ifndef PLATFORMSTRING_H

#define PLATFORMSTRING_H

#include <string>

#include <list>

#include <stdio.h>

#include <stdlib.h>

#include "jni.h"

#include "Platform.h"

struct WideString {

    size_t length;

    wchar_t* data;

    WideString() { length = 0; data = NULL; }

};

struct MultibyteString {

    size_t length;

    char* data;

    MultibyteString() { length = 0; data = NULL; }

};

template <typename T>

class DynamicBuffer {

private:

    T* FData;

    size_t FSize;

public:

    DynamicBuffer(size_t Size) {

        FSize = 0;

        FData = NULL;

        Resize(Size);

    }

    ~DynamicBuffer() {

        delete[] FData;

    }

    T* GetData() { return FData; }

    size_t GetSize() { return FSize; }

    bool Resize(size_t Size) {

        FSize = Size;

        if (FData != NULL) {

            delete[] FData;

            FData = NULL;

        }

        if (FSize != 0) {

            FData = new T[FSize];

            if (FData != NULL) {

                Zero();

            } else {

                return false;

            }

        }

        return true;

    }

    void Zero() {

        memset(FData, 0, FSize * sizeof(T));

    }

    T& operator[](size_t index) {

        return FData[index];

    }

};

#ifdef MAC

// StringToFileSystemString is a stack object. It's usage is

// simply inline to convert a

// TString to a file system string. Example:

//

// return dlopen(StringToFileSystemString(FileName), RTLD_LAZY);

//

class StringToFileSystemString {

    // Prohibit Heap-Based StringToFileSystemString

private:

    static void *operator new(size_t size);

    static void operator delete(void *ptr);

private:

    TCHAR* FData;

    bool FRelease;

public:

    StringToFileSystemString(const TString &value);

    ~StringToFileSystemString();

    operator TCHAR* ();

};

// FileSystemStringToString is a stack object. It's usage is

// simply inline to convert a

// file system string to a TString. Example:

//

// DynamicBuffer<TCHAR> buffer(MAX_PATH);

// if (readlink("/proc/self/exe", buffer.GetData(), MAX_PATH) != -1)

//    result = FileSystemStringToString(buffer.GetData());

//

class FileSystemStringToString {

    // Prohibit Heap-Based FileSystemStringToString

private:

    static void *operator new(size_t size);

    static void operator delete(void *ptr);

private:

    TString FData;

public:

    FileSystemStringToString(const TCHAR* value);

    operator TString ();

};

#endif //MAC

#ifdef LINUX

#define StringToFileSystemString PlatformString

#define FileSystemStringToString PlatformString

#endif //LINUX

class PlatformString {

private:

    char* FData; // Stored as UTF-8

    size_t FLength;

    wchar_t* FWideTStringToFree;

    void initialize();

    // Caller must free result using delete[].

    static void CopyString(char *Destination,

            size_t NumberOfElements, const char *Source);

    // Caller must free result using delete[].

    static void CopyString(wchar_t *Destination,

            size_t NumberOfElements, const wchar_t *Source);

    static WideString MultibyteStringToWideString(const char* value);

    static MultibyteString WideStringToMultibyteString(const wchar_t* value);

// Prohibit Heap-Based PlatformStrings

private:

    static void *operator new(size_t size);

    static void operator delete(void *ptr);

public:

    PlatformString(void);

    PlatformString(const PlatformString &value);

    PlatformString(const char* value);

    PlatformString(const wchar_t* value);

    PlatformString(const std::string &value);

    PlatformString(const std::wstring &value);

    PlatformString(JNIEnv *env, jstring value);

    PlatformString(size_t Value);

    static TString Format(const TString value, ...);

    ~PlatformString(void);

    size_t length();

    char* c_str();

    char* toMultibyte();

    wchar_t* toWideString();

    std::wstring toUnicodeString();

    std::string toStdString();

    jstring toJString(JNIEnv *env);

    TCHAR* toPlatformString();

    TString toString();

    operator char* ();

    operator wchar_t* ();

    operator std::wstring ();

    // Caller must free result using delete[].

    static char* duplicate(const char* Value);

    // Caller must free result using delete[].

    static wchar_t* duplicate(const wchar_t* Value);

};

#endif // PLATFORMSTRING_H