/*

* 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: 

*

*/

// INCLUDE FILES

#include <config.h>

#include <lookup.h>

#include <PropertyNameArray.h>

#include "DeviceLiwMap.h"

#include "DeviceLiwBinding.h"

#include "array_instance.h"

#include <liwvariant.h>

const TInt KMaxKeySize = 255;

using namespace KJS;

const ClassInfo DeviceLiwMap::info = { "DeviceLiwMap", 0/*&ArrayInstance::info*/, 0, 0 };

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

/*

@begin DeviceLiwMapTable 1

    close DeviceLiwMap::close DontDelete|Function 0

@end

*/

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

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

// DeviceLiwMap::DeviceLiwMap

//

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

//

DeviceLiwMap::DeviceLiwMap( JSValue* proto, const CLiwMap* liwMap, CDeviceLiwBinding* liwBinding)

    : JSObject(proto)

    {

        m_privateData = new DeviceLiwMapPrivate(liwMap, liwBinding);

        if (!m_privateData )

            m_valid = false;

        else

            {

            m_valid = true;

            // protect this object

            KJS::Collector::protect(this);   

            }            

    }

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

// DeviceLiwMap::~DeviceLiwMap

//

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

//

DeviceLiwMap::~DeviceLiwMap()

    {

        // only can be called by garbage collection after the 

        // DeviceLiwMap::Close() was called

    }

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

// DeviceLiwMap::Close()

//

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

//

void DeviceLiwMap::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;

        }        

    if (exec) 

        {

        PropertyNameArray propertyNames;

        this->getPropertyNames( exec, propertyNames );

        unsigned size = static_cast<unsigned>(propertyNames.size());

        for (unsigned i = 0; i < size; i++)

            {

            JSValue * jsvalue = this->get( exec, propertyNames[i] );

            if(jsvalue->isObject()) 

                {

                JSObject * prop = jsvalue->toObject( exec );            

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

                    {

                    (static_cast<DeviceLiwIterable*>(prop))->Close(exec, true);

                    }

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

                    {

                    (static_cast<DeviceLiwMap*>(prop))->Close(exec, true);

                    }

                }        

            }                

        }    

    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);

        }

    }

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

// Device::toString

//

//

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

//

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

    {

    return "[object DeviceLiwMap]";

    }

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

// DeviceLiwMap::getOwnPropertySlot

//

//

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

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

{

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

    //      DeviceLiwMap table => own property => prototype property

    // When the DeviceLiwMap 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 DeviceLiwMap table

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

        if (entry)

            {

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

            return true;

            }

        // 1.2 check own property

        m_privateData->m_propName = propertyName;

        if (!getDirect(propertyName))

            {

            // 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());

            }

            if (!m_privateData->m_liwMap)

                return false;

            if ( propertyName.size() >= KMaxKeySize )

                throwError( exec, GeneralError, "key name too long" );

            // Store the property in the object so we get the same one each time.

            TLiwVariant detail;

            char prop_name8[KMaxKeySize];

            UChar * u_propname = (UChar *)propertyName.data();

            for (int i = 0; i < propertyName.size(); i++)

            {

                prop_name8[i] = u_propname[i].low();

            }

            prop_name8[propertyName.size()] = NULL;

            TBuf8<KMaxKeySize> prop_name((const unsigned char *)prop_name8);

            if (!m_privateData->m_liwMap->FindL(prop_name, detail))

                return false;

            JSValue* result = m_privateData->m_liwBinding->LiwVariant2JsVal(exec, detail);

            if ( result->type() == UndefinedType || exec->hadException() )

                return false;

            else

                this->putDirect( propertyName, result, DontDelete|ReadOnly );

            }

        return JSObject::getOwnPropertySlot(exec, propertyName, slot);

        }

    // when it is invalid

    else

        {

        // 2.1 check close() function

        if (propertyName == "close")

            {

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

            if (entry)

                {

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

                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;

}

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

// DeviceLiwMap::getValueProperty

//

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

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

    {

    switch (token)

            {

            case close:

                {

                return new DeviceLiwMapFunc(exec, token);;

                }

            default:

                if(m_valid)

                    return getDirect(m_privateData->m_propName);

                else

                    return jsUndefined();                

            }

    }

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

// DeviceLiwMapPrivate constructor

//

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

DeviceLiwMapPrivate::DeviceLiwMapPrivate(const CLiwMap* liwMap, CDeviceLiwBinding* liwBinding)

    {

    TRAP_IGNORE(

            m_liwBinding = liwBinding;    

            m_liwMap = (CLiwMap*) liwMap;

            if ( m_liwMap )

                m_liwMap->IncRef();

            )

    }

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

// DeviceLiwMapPrivate::Close

//

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

void DeviceLiwMapPrivate::Close()

    {

       m_liwBinding = NULL;

    // release the map    

    if ( m_liwMap ) 

        {

        m_liwMap->DecRef();

        m_liwMap = NULL;

        }        

    }

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

// DeviceLiwMapFunc::DeviceLiwMapFunc

//

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

//

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

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

    m_func( token )

    {

    }

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

// DeviceLiwMapFunc::call

//

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

//

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

    {

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

            return throwError(exec, GeneralError);

        }

        DeviceLiwMap *map = static_cast<DeviceLiwMap *>(thisObj);

        if ( m_func == DeviceLiwMap::close ) 

            {

            map->Close(exec, false);

            }

        return jsUndefined();

    }

//END OF FILE