/*
 * SchemaComplexType.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2011/02/06
#pragma once

#include <sol/xml/SchemaType.h>
#include <sol/xml/SchemaItemCollection.h>
#include <sol/xml/SchemaAny.h>
#include <sol/xml/SchemaModelGroup.h>
#include <sol/xml/SchemaConstant.h>
#include <sol/xml/SOMItemType.h>
#include <sol/xml/SchemaConstant.h>

namespace SOL {

class SchemaComplexType : public SchemaType
{
public:
    SchemaComplexType(MSXML2::ISchemaComplexTypePtr pType)
    :SchemaType((MSXML2::ISchemaTypePtr)pType)
    {
    }

public:
    MSXML2::ISchemaComplexTypePtr getTypePtr()
    {
        return(MSXML2::ISchemaComplexTypePtr)SchemaType::getTypePtr();
    }

    VARIANT_BOOL getIsAbstract()
    {
        return getTypePtr()->GetisAbstract();
    }

    MSXML2::ISchemaAnyPtr getAnyAttribute()
    {
        return getTypePtr()->GetanyAttribute();
    }

    MSXML2::ISchemaItemCollectionPtr getAttributes()
    {
        return getTypePtr()->Getattributes();
    }

    SCHEMACONTENTTYPE getContentType()
    {
        return getTypePtr()->GetcontentType();
    }

    MSXML2::ISchemaModelGroupPtr getContentModel()
    {
        return getTypePtr()->GetcontentModel();
    }

    SCHEMADERIVATIONMETHOD getProhibitedSubstitutions()
    {
        return getTypePtr()->GetprohibitedSubstitutions();
    }
public:
    void display(const TCHAR* name)
    {
        if (name == NULL) {
            name = _T("SchemaComplexType");
        }
        _tprintf(_T("<%s>\n"), name);
        try {
            SchemaItemCollection pCollection = getAttributes();
            pCollection.display(_T("Attributes"));
        } catch (...) {
        }

        try {
            SchemaAny any = getAnyAttribute();
            any.display();
        } catch (...) {
        }

        try {
            SchemaModelGroup group = getContentModel();
            group.display(_T("ContentModel"));
        } catch (...) {
        }

        SOMItemType type;
        try {
            _tprintf(_T("<CotentType>%s</CotentType>\n"),
                type.getType(getContentType()));
        } catch (...) {
        }

        SchemaConstant constant;
        try {
            _tprintf(_T("<ProhibitedSubstitutions>%s</ProhibitedSubstitutions>\n"),
                constant.getDerivationMethod(getProhibitedSubstitutions()));
        } catch (...) {
        }

        _tprintf(_T("</%s>\n"), name);
    }

};


}