name.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2012 Josh Bialkowski (jbialk@mit.edu)
 *
 *  This file is part of cppfontconfig.
 *
 *  cppfontconfig is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  cppfontconfig 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 for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with cppfontconfig.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef CPPFONTCONFIG_NAME_H_
#define CPPFONTCONFIG_NAME_H_


#include <cpp_fontconfig/common.h>
#include <cpp_fontconfig/ObjectType.h>
#include <cpp_fontconfig/Constant.h>

namespace fontconfig {




class ObjectTypeList
{
    public:
        class Item;
        class BuildToken;

    private:
        FcObjectType*   m_ptr;      
        int             m_nItems;   

        static BuildToken sm_seed;

        ObjectTypeList();

    public:
        ObjectTypeList( BuildToken& token );

        ObjectTypeList(const ObjectTypeList& other );

        FcObjectType* get_ptr();

        const FcObjectType* get_ptr() const;

        int get_nItems() const;

        void destroy();

        static Item create();
};

class ObjectTypeList::BuildToken
{
    private:
        FcObjectType*   m_ptr;      
        int             m_iItem;    
        int             m_nItems;   

        explicit BuildToken(){}

        BuildToken( const BuildToken& other ){}

        BuildToken& operator=( const BuildToken& other ){ return *this; }

        void init();


        void incrementCount();


        void allocate();


        void write( const char* object, Type_t type );

    public:
        friend class ObjectTypeList;
        friend class ObjectTypeList::Item;



};

class ObjectTypeList::Item
{
    private:
        ObjectTypeList::BuildToken&     m_token;
        const char*                     m_object;
        Type_t                          m_type;
        bool                            m_isLast;

    public:
        Item( ObjectTypeList::BuildToken& token );

        ~Item();

        Item operator()( const char* object, Type_t type );

        ObjectTypeList::BuildToken& operator()();
};





class ConstantList
{
    public:
        class Item;
        class BuildToken;

    private:
        FcConstant*   m_ptr;
        int           m_nItems;

        static BuildToken sm_seed;

        ConstantList();

    public:
        ConstantList(ConstantList::BuildToken& token );

        ConstantList(const ConstantList& other );

        FcConstant* get_ptr();

        const FcConstant* get_ptr() const;

        int get_nItems() const;

        void destroy();

        static Item create();

};

class ConstantList::BuildToken
{
    private:
        FcConstant* m_ptr;      
        int         m_iItem;    
        int         m_nItems;   

        explicit BuildToken(){}

        BuildToken( const BuildToken& other ){}

        BuildToken& operator=( const BuildToken& other ){ return *this; }

        void init();


        void incrementCount();


        void allocate();


        void write( const Char8_t* name, const char* object, int value );

    public:
        friend class ConstantList;
        friend class ConstantList::Item;
};

class ConstantList::Item
{
    private:
        ConstantList::BuildToken&   m_token;
        const Char8_t*              m_name;
        const char*                 m_object;
        int                         m_value;
        bool                        m_isLast;

    public:
        Item( ConstantList::BuildToken& token );

        ~Item();

        Item operator()( const Char8_t* name, const char* object, int value );

        ConstantList::BuildToken& operator()();
};



namespace       name {


bool registerObjectTypes( const ObjectTypeList& list );


bool unregisterObjectTypes( const ObjectTypeList& list );


RefPtr<ObjectType> getObjectType( const char* object );


bool registerConstants( const ConstantList& list );


bool unregisterConstants( const ConstantList& list );


RefPtr<Constant> getConstant(Char8_t* string);


bool constant( Char8_t* string, int* result );



}
}














#endif // NAME_H_