/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Implementation of LIW Iterable wrapper

*

*/

// INCLUDE FILES

#include <config.h>

#include <lookup.h>

#include <LiwServiceHandler.h>

#include "DeviceLiwIterable.h"

#include "DeviceLiwBinding.h"

const TInt KMaxKeySize = 128;

using namespace KJS;

const ClassInfo DeviceLiwIterable::info = { "DeviceLiwIterable", 0, 0, 0 };

const TInt INIT_JSOBJ_ARRAY_SIZE = 10;   // initial jsobject array

// ============================= LOCAL FUNCTIONS ===============================

/*

@begin DeviceLiwIterableTable 1

    getNext DeviceLiwIterable::getNext DontDelete|Function 0

    reset   DeviceLiwIterable::reset   DontDelete|Function 0

    close   DeviceLiwIterable::close   DontDelete|Function 0

@end

*/

/*

 * The DeviceLiwIterable is a plain wrapper around the underlying LIW iterable variant

 * object. It acts as a pass through for the iterable methods to JS. This

 * is needed for efficiently processing returned iterables (instead of copying the

 * contents into a JS array). Of course much of the benefit depends on how well iterables

 * are implemented in the underlying LIW framework.

 */

// ============================ MEMBER FUNCTIONS ===============================

// ----------------------------------------------------------------------------

// DeviceLiwIterable::DeviceLiwIterable

//

// ----------------------------------------------------------------------------

//

DeviceLiwIterable::DeviceLiwIterable(

    ExecState* exec,

    CDeviceLiwBinding* binding,

    CLiwIterable* variant)

    : JSObject(exec->lexicalInterpreter()->builtinObjectPrototype() )

    {

        m_privateData = new DeviceLiwIterablePrivate(variant, binding);

        if (!m_privateData || !m_privateData->m_jsobjArray )

            m_valid = false;

        else 

            {

            m_valid = true;

            KJS::Collector::protect(this);            

            }            

    }

// ----------------------------------------------------------------------------

// DeviceLiwIterable::~DeviceLiwIterable

//

// ----------------------------------------------------------------------------

//

DeviceLiwIterable::~DeviceLiwIterable()

    {

        // only can be called by garbage collection after the 

        // DeviceLiwIterable::Close() was called

    }

// ----------------------------------------------------------------------------

// DeviceLiwIterable::Close()

//

// ----------------------------------------------------------------------------

//

void DeviceLiwIterable::Close(ExecState* exec, bool unmark)

    {

    // avoid double close    

    if(!m_valid) 

        {   

        if(unmark) 

            {

            // unprotect this to allow the garbage collection to release this jsobject

            KJS::Collector::unprotect(this);

            }

        return;

        }

    // need exec to close other jsobject

    m_privateData->m_exec = exec;

    delete m_privateData;

    m_privateData = NULL;

    m_valid = false;

    if(unmark) 

        {

        // unprotect this to allow the garbage collection to release this jsobject

        KJS::Collector::unprotect(this);

        }

    }     

// ----------------------------------------------------------------------------

// DeviceLiwIterable::toString

// Returns string representation of the object

//

// ----------------------------------------------------------------------------

UString DeviceLiwIterable::toString(ExecState* /*exec*/) const

    {

    return "[object DeviceLiwIterable]";

    }

// ----------------------------------------------------------------------------

// Device::getOwnPropertySlot

//

// ----------------------------------------------------------------------------

bool DeviceLiwIterable::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

    {

    // When the DeviceLiwIterable is valid, the check order is

    //      DeviceLiwIterable table => own property => prototype property

    // When the DeviceLiwIterable is invalid (after close), the check order is

    //      close function in table => prototype property

    // 1. when it is valid

    if(m_valid) 

        {

        // 1.1 check DeviceLiwIterable table    

        const HashEntry* entry = Lookup::findEntry(&DeviceLiwIterableTable, propertyName);

        if (entry)

            {

            slot.setStaticEntry(this, entry, staticValueGetter<DeviceLiwIterable>);

            return true;

            }

        // 1.2 check own property

        if(JSObject::getOwnPropertySlot(exec, propertyName, slot))

            return true;

        // 1.3 check prototypes

        JSObject *proto = static_cast<JSObject *>(this->prototype());

        while (!proto->isNull() && proto->isObject())

            {

            if (proto->getOwnPropertySlot(exec, propertyName, slot))

                return true;

            proto = static_cast<JSObject *>(proto->prototype());

            }

        }

    // 2. when it is invalid

    else

        {

        // 2.1 check close() function

        if (propertyName == "close")

            {

            const HashEntry* entry = Lookup::findEntry(&DeviceLiwIterableTable, propertyName);

            if (entry)

                {

                slot.setStaticEntry(this, entry, staticValueGetter<DeviceLiwIterable>);

                return true;

                }      

            }

        // 2.2 check prototypes

        JSObject *proto = static_cast<JSObject *>(this->prototype());

        while (!proto->isNull() && proto->isObject())

            {

            if (proto->getOwnPropertySlot(exec, propertyName, slot))

                return true;

            proto = static_cast<JSObject *>(proto->prototype());

            }

        }

    return false;

    }

// ----------------------------------------------------------------------------

// JSVersion::getValueProperty

//

// ----------------------------------------------------------------------------

JSValue* DeviceLiwIterable::getValueProperty(ExecState *exec, int token) const

    {

    DeviceLiwIterableFunc *lf;

    switch (token)

            {

            // Unfortunately, the only operations that LIW Iterables support are next() and reset(). e.g. there

            // are no hasNext() or count() operations typical for iterators.

            case getNext:

            case reset:

            case close:

                {

                lf = new DeviceLiwIterableFunc(exec, token);

                break;

                }

            default:

                return throwError(exec, GeneralError);

            }

            return lf;

    }

// ---------------------------------------------------------------------------

// DeviceLiwIterablePrivate constructor

//

// ---------------------------------------------------------------------------

DeviceLiwIterablePrivate::DeviceLiwIterablePrivate(const CLiwIterable* liwIterable, CDeviceLiwBinding* liwBinding)

    {

    TRAP_IGNORE(

            m_liwBinding = liwBinding;

            m_jsobjArray = new RPointerArray<JSObject>( INIT_JSOBJ_ARRAY_SIZE );

            m_exec = NULL;    

            m_iterable = (CLiwIterable*) liwIterable;

            if ( m_iterable )

                m_iterable->IncRef();

            )

    }

// ---------------------------------------------------------------------------

// DeviceLiwMapPrivate::Close

//

// ---------------------------------------------------------------------------

void DeviceLiwIterablePrivate::Close()

    {

    // close the jsobject

    if ( m_jsobjArray && m_exec )

        {

        // close all the DeviceLiwMap objects and DeviceLiwIterable objects

        for (int i = 0; i < m_jsobjArray->Count(); i++)

            {

            JSObject * jsobj = (*m_jsobjArray)[i];

            if (jsobj->inherits( &DeviceLiwIterable::info ))

                {

                (static_cast<DeviceLiwIterable*>(jsobj))->Close(m_exec, true);

                }

            else if (jsobj->inherits( &DeviceLiwMap::info ))

                {

                (static_cast<DeviceLiwMap*>(jsobj))->Close(m_exec, true);

                }

            }

        m_jsobjArray->Close();

        delete m_jsobjArray;

        m_jsobjArray = NULL;

        m_exec = NULL;

        }

    // release the map    

    if ( m_iterable ) 

        {

        m_iterable->DecRef();

        m_iterable = NULL;

        }        

    }

// ----------------------------------------------------------------------------

// DeviceLiwIterablePrivate::DeviceLiwIterableFunc

//

// ----------------------------------------------------------------------------

//

DeviceLiwIterableFunc::DeviceLiwIterableFunc( ExecState* exec, int token )

    : JSObject( exec->lexicalInterpreter()->builtinObjectPrototype() ),

    m_func( token )

    {

    }

// ----------------------------------------------------------------------------

// DeviceLiwIterableFunc::~DeviceLiwIterableFunc

//

// ----------------------------------------------------------------------------

//

DeviceLiwIterableFunc::~DeviceLiwIterableFunc()

    {

    }

// ----------------------------------------------------------------------------

// DeviceLiwIterableFunc::implementsCall

//

// ----------------------------------------------------------------------------

//

bool DeviceLiwIterableFunc::implementsCall() const

    {

    return true;

    }

// ----------------------------------------------------------------------------

// DeviceLiwIterableFunc::callAsFunction

//

// ----------------------------------------------------------------------------

//

JSValue* DeviceLiwIterableFunc::callAsFunction(ExecState* exec, JSObject *thisObj, const List& aArgs )

    {

        JSValue* rval = jsUndefined();

        TBool found = EFalse;

        if (!thisObj->inherits(&DeviceLiwIterable::info)) {

                    return throwError(exec, GeneralError);

        }

        DeviceLiwIterable *it = static_cast<DeviceLiwIterable *>(thisObj);

        if ( !it->isValid() || !it->m_privateData->m_liwBinding || !it->m_privateData->m_iterable) {

            return rval;

        }

        if ( m_func == DeviceLiwIterable::getNext ) {

            TLiwVariant vv;

            TRAP_IGNORE( found = it->m_privateData->m_iterable->NextL( vv ) );

            if( found ) 

                {

                rval =  it->m_privateData->m_liwBinding->LiwVariant2JsVal( exec, vv );

                if(rval->isObject()) 

                    {

                    JSObject* obj =  static_cast<JSObject*> (rval);

                    if(obj->inherits( &KJS::DeviceLiwIterable::info ) || obj->inherits( &KJS::DeviceLiwMap::info ))

                        {

                        // insert into jsobject array

                        it->m_privateData->m_jsobjArray->Append(obj);

                        }

                    }                

                vv.Reset();

                }

        }

        else if ( m_func == DeviceLiwIterable::reset ){

            it->m_privateData->m_iterable->Reset();

        }

        else if ( m_func == DeviceLiwIterable::close ){

            it->Close(exec, false);

        }

        return rval;

    }

//END OF FILE