factory.h

audio-video-codecs.rar语音编解码器

//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 2005-2006 Intel Corporation. All Rights Reserved.
//

#ifndef __FACTORY_H
#define __FACTORY_H

#include "object.h"
#include "vm_strings.h"
#include "vm_shared_object.h"

class Factory
{
protected:
    ObjectsList    m_objects_list;
public:
    Factory();
    ~Factory();

    bool Load(vm_char* p_filename,vm_char* p_funcname = NULL);
    bool InitStatic(void);

protected:
    bool          RegObjectsList(ObjectsList* p_list);
public:
    ObjectsList*  GetObjectsList(void);

    template <class T = Object>
    class Iterator
    {
    protected:
        ObjectsList* m_plist;
        ObjectsList* m_pcurrent_list;
        Object*      m_pobject;
    public:

        Iterator();
        Iterator(Factory& factory);

        void        operator=(Factory& factory);

        bool        operator ==(void*p);
        bool        operator !=(void*p);
        T*          operator ->();
        Iterator<T> operator ++(int);

        bool        Find(vm_char*);
    protected:
        bool        GetNext(void);

    };
};

template <class T>
Factory::Iterator<T>::Iterator()
{
    m_pcurrent_list = m_plist = &g_static_objects_list;
    m_pobject = m_pcurrent_list->p_begin;
}

template <class T>
Factory::Iterator<T>::Iterator(Factory& factory)
{
    m_pcurrent_list = m_plist = factory.GetObjectsList();
    m_pobject = m_pcurrent_list->p_begin;

    GetNext();
}

template <class T>
void
Factory::Iterator<T>::operator=(Factory& factory)
{
    m_pcurrent_list = m_plist = factory.GetObjectsList();
    m_pobject = m_pcurrent_list->p_begin;

    if (m_pobject == NULL) GetNext();
}

template <class T>
bool
Factory::Iterator<T>::operator==(void* p)
{
    return (m_pobject == p);
}

template <class T>
bool
Factory::Iterator<T>::operator!=(void* p)
{
    return (m_pobject != p);
}

template <class T>
T*
Factory::Iterator<T>::operator ->()
{
    return (T*)m_pobject;
}
template <class T>
Factory::Iterator<T>
Factory::Iterator<T>::operator ++(int)
{
    GetNext();
    return *this;
}

template <class T>
bool
Factory::Iterator<T>::Find(vm_char* p_name)
{
    ObjectsList* p_list_iterator;
    T*           p_obj_iterator;

    if (p_name == NULL) return false;

    p_list_iterator = m_plist;

    while (p_list_iterator != NULL)
    {
        p_obj_iterator = (T*)p_list_iterator->p_begin;
        while (p_obj_iterator != NULL)
        {
            if (ObjectTypeCheck<T>(p_obj_iterator))
            {
                if (!vm_string_strcmp(p_obj_iterator->GetName(),p_name))
                {
                    m_pobject = p_obj_iterator;
                    m_pcurrent_list = p_list_iterator;
                    return true;
                }
            }
            p_obj_iterator = (T*)p_obj_iterator->m_pnext;
        }
        p_list_iterator = p_list_iterator->p_next;
    }
    return false;
}

template <class T>
bool
Factory::Iterator<T>::GetNext(void)
{
    ObjectsList*   p_list_iterator;
    T*             p_obj_iterator;

    if (m_pcurrent_list == NULL)
    {
        return false;
    }

    p_list_iterator = m_pcurrent_list;
    p_obj_iterator =(T*) m_pobject;
    if (p_obj_iterator ) p_obj_iterator = (T*)p_obj_iterator->m_pnext;

    for(;;)
    {
        while (p_obj_iterator != NULL)
        {
            if (ObjectTypeCheck(p_obj_iterator))
            {
                m_pobject = p_obj_iterator;
                m_pcurrent_list = p_list_iterator;
                return true;
            }
            p_obj_iterator = (T*)p_obj_iterator->m_pnext;
        }
        p_list_iterator = p_list_iterator->p_next;
        if (p_list_iterator == NULL) break;
        p_obj_iterator = (T*)p_list_iterator->p_begin;
    }

    m_pobject = NULL;
    m_pcurrent_list = NULL;
    return false;
}

#endif /* __FACTORY_H */