FXCodeToPythonCode.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                    Converts a code location into a number                     *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003 by Niall Douglas.   All Rights Reserved.            *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* 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.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef FXCODETOPYTHONCODE_H
#define FXCODETOPYTHONCODE_H
#include "FXPython.h"
#include "../include/qmemarray.h"
#include "../include/FXException.h"

namespace FX {

#ifdef _MSC_VER
// Disable warning about initialising bases off this
#pragma warning(disable: 4355)
#endif

template<template<typename, int> class vector, int length> class FXCodeToPythonCode
{
    struct vectorBase
    {
        static FXCodeToPythonCode *&getParent()
        {
            static FXCodeToPythonCode *parent;
            return parent;
        }
    };
    typedef typename Generic::FnFromList<typename vector<vectorBase, 0>::functionSpec>::value vectorSpec;
    typedef typename Generic::TL::numberRange<length>::value noRange;
    struct CodeItem
    {
        vectorSpec ptr;
        boost::python::api::object *code;
        CodeItem(vectorSpec _ptr=0) : ptr(_ptr), code(0) { }
    };
    QMemArray<CodeItem> list;
public:
    boost::python::object &lookupVector(int idx)
    {
        boost::python::object *code=list[idx].code;
        assert(code);
        return *code;
    }
private:
    template<typename type> struct CodeAddr;
    template<int no> struct CodeAddr<Generic::IntToType<no> > : public vector<vectorBase, no>
    {
        CodeAddr();
        CodeAddr(FXCodeToPythonCode *_parent) { vector<vectorBase, no>::getParent()=_parent; _parent->list[no]=&vector<vectorBase, no>::function; }
    };
    Generic::TL::instantiateH<noRange, CodeAddr> codevectors;
public:
    FXCodeToPythonCode() : list(length), codevectors(this) { }
    vectorSpec allocate(boost::python::api::object *code)
    {
        int n, empty=-1;
        for(n=0; n<length; n++)
        {
            CodeItem &ci=list[n];
            if(empty<0 && !ci.code) empty=n;
            if(code==ci.code) return ci.ptr;
        }
        FXERRH(empty>=0, "No more space in list", 0, FXERRH_ISDEBUG);
        list[empty].code=code;
        return list[empty].ptr;
    }
    bool deallocate(boost::python::api::object *code)
    {
        for(int n=0; n<length; n++)
        {
            CodeItem &ci=list[n];
            if(code==ci.code)
            {
                ci.code=0;
                return true;
            }
        }
        return false;
    }
    bool deallocate(vectorSpec spec)
    {
        for(int n=0; n<length; n++)
        {
            CodeItem &ci=list[n];
            if(spec==ci.ptr)
            {
                ci.code=0;
                return true;
            }
        }
        return false;
    }
};

/*template<typename base, int no> struct sortFuncVector : public base
{
    typedef Generic::TL::create<FXint, const FXListItem *, const FXListItem *>::value functionSpec;
    static FXint function(const FXListItem *a, const FXListItem *b)
    {
        return extract<FXint>(getParent()->lookupVector(no)(a, b));
    }
};
*/

#ifdef _MSC_VER
#pragma warning(default: 4355)
#endif

}

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.