/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  a Base class for starting the JVM.
*
*/


#ifndef JVMSTARTERIMPL_H
#define JVMSTARTERIMPL_H

#include "jvmstarter.h"

#include <algorithm>
#include <string.h>
#include <string>
#include <list>

namespace java // codescanner::namespace
{

namespace runtime // codescanner::namespace
{

/**
 * This class implements partially the interface JvmStarter. The class mainly
 * contains argument storing and modifying features. The static instance
 * getters and virtual JVM starting methods are left to be implemented by
 * the JVM specific starter which will be inherited from this class.
 */


OS_NONSHARABLE_CLASS(JvmStarterImpl) : public JvmStarter
{
public:

    /**
     * Destructor of the JvmStarterImpl.
     */
    virtual ~JvmStarterImpl();

    /**
     * @see jvmstarter.h
     */
    virtual void appendClassPath(const std::wstring& file);

    /**
     * @see jvmstarter.h
     */
    virtual void appendBootClassPath(const std::wstring& file);

    /**
     * @see jvmstarter.h
     */
    virtual void prependBootClassPath(const std::wstring& file);

    /**
     * @see jvmstarter.h
     */
    virtual void appendExtensionPath(const std::wstring& extensionPath);

    /**
     * @see jvmstarter.h
     */
    virtual void setMainClass(const std::wstring& mainClass);

    /**
     * @see jvmstarter.h
     */
    virtual void appendApplicationArgument(const std::wstring& argument);

    /**
     * @see jvmstarter.h
     */
    virtual void appendSystemProperty(const std::wstring& systemproperty);

    /**
     * @see jvmstarter.h
     */
    virtual void appendRawJvmArgument(const std::wstring& argument);

    /**
     * @see jvmstarter.h
     */
    virtual void disableJit();

    /**
     * @see jvmstarter.h
     */
    virtual void enableThreadDumping();

protected: // Definitions

    /**
     * Clears all the std string & Lists.
     */
    virtual void clear();

    typedef std::list<std::wstring> JvmArgs_t;

    // A simple class for storing char* array that is deleted automatically
    // when going out of scope.
    class ScopedCharPointerArray
    {
    public:

        ScopedCharPointerArray(int size) : mBuffer(0), mSize(size)
        {
            mBuffer = new char* [size];
            memset(mBuffer, 0, mSize * sizeof(char*));
        }

        ~ScopedCharPointerArray()
        {
            for (int i = 0; i < mSize; i++)
            {
                delete[] mBuffer[i];
            }
            delete[] mBuffer;
        }

        char** get()
        {
            return mBuffer;
        }

    private:

        /*
         * No copy constructor allowed.
         */
        ScopedCharPointerArray(const ScopedCharPointerArray&);

        /*
         * No Assignment operator allowed.
         */
        ScopedCharPointerArray& operator= (const ScopedCharPointerArray&);

    private:
        char** mBuffer;
        int    mSize;
    };

    // A simple class for storing char* pointers that is deleted automatically
    // when going out of scope.
    class ScopedCharPointer
    {
    public:

        ScopedCharPointer()
        {
        }

        ScopedCharPointer(char* ptr) : mBuffer(ptr)
        {
        }

        ~ScopedCharPointer()
        {
            delete[] mBuffer;
        }

        void set(char* ptr)
        {
            mBuffer = ptr;
        }

        char* get()
        {
            return mBuffer;
        }

    private:

        /*
         * No copy constructor allowed.
         */
        ScopedCharPointer(const ScopedCharPointer&);

        /*
         * No Assignment operator allowed.
         */
        ScopedCharPointer& operator= (const ScopedCharPointer&);

    private:
        char* mBuffer;
    };


protected: //Methods
    JvmStarterImpl();   // Default constructor allowed for inherited classes

    /**
     * Appends the given source path to the given destination path. If there
     * already exists a path a platform specific classpath separator is added
     * before doing the appending Converts the path separtors to platform
     * specifc ones.
     * @param source The source path to be appended.
     * @param destination The destination path where to be appended.
     */
    void appendAndConvertClassPath(const std::wstring& source,
                                   std::wstring& destination);


protected: // Members

    std::wstring      mIdentifier;        // For identifying the runtime.
    std::wstring      mClassPath;         // The classpath of the application
    std::wstring      mBootClassPathAppend;  // The appended boot classpath
    std::wstring      mBootClassPathPrepend; // The prepended boot classpath
    std::wstring      mExtensionPath;     // The extension path to be used
    std::wstring      mMainClass;         // The main class of the application
    bool              mJitDisabled;       // Is the JIT disabled
    bool              mTheadDumpEnabled;  // Is the thread dump feature enabled
    Configuration     mConfiguration;     // CLDC or CDC
    JvmArgs_t         mJvmArgs;           // A list containing Jvm arguments.
    // This doesn't contain such
    // that has dedicated member variable
    // like the classpath
    JvmArgs_t         mAppAndArgs;        // A list containing application
    // class and arguments for the
    // application

private: // Methods
    /**
     * No copy constructor allowed
     */
    JvmStarterImpl(const JvmStarterImpl&);

    /**
     * No Assignment operator allowed
     */
    JvmStarterImpl& operator= (const JvmStarterImpl&);

};

} // end namespace runtime
} // end namespace java


#endif // JVMSTARTERIMPL_H