blocktype.cpp

ncbi源码

    } else if (isSimple) {
        openTag   = "<xs:element name=\"" + tag + "\">\n"
                    "  <xs:complexType>\n";
        if (!simpleType.empty()) {
            openTag  +="    <xs:simpleContent>\n"
                       "      <xs:extension base=\"" + simpleType + "\">\n";
        }
        closeTag1.erase();
        closeTag2.erase();
        if (!simpleType.empty()) {
            closeTag2+= "      </xs:extension>\n"
                        "    </xs:simpleContent>\n";
        }
        closeTag2+= "  </xs:complexType>\n"
                    "</xs:element>\n";
    } else {
        openTag.erase();
        if (!hasNotag) {
            openTag += "<xs:element name=\"" + tag + "\">\n" +
                       "  <xs:complexType>\n";
        }
        openTag     += "    <xs:"  + xsdk;
        if (isOptional) {
            openTag += " minOccurs=\"0\"";
        }
        if (isSeq) {
            openTag += " maxOccurs=\"unbounded\"";
        }
        openTag     += ">\n";
        closeTag1    = "    </xs:" + xsdk + ">\n";
        closeTag2.erase();
        if (!hasNotag) {
            closeTag2+= "  </xs:complexType>\n"
                        "</xs:element>\n";
        }
    }

    out << openTag;
    if (isAttlist) {
        ITERATE ( TMembers, i, m_Members ) {
            i->get()->GetType()->PrintXMLSchemaElement(out);
        }
    } else if (!isSimple) {
        ITERATE ( TMembers, i, m_Members ) {
            const CDataMember& member = **i;
            string member_name( member.GetType()->XmlTagName());
            bool uniseq = false;
            if (GetEnforcedStdXml()) {
                if (member.Attlist()) {
                    continue;
                }
                const CUniSequenceDataType* type =
                    dynamic_cast<const CUniSequenceDataType*>(member.GetType());
                uniseq = (type != 0);
                if (uniseq) {
                    if (isSimpleSeq) {
                        type->PrintXMLSchemaElement(out);
                        continue;
                    }
                    const CReferenceDataType* typeRef =
                        dynamic_cast<const CReferenceDataType*>(type->GetElementType());
                    if (typeRef) {
                        if (type->XmlTagName() != typeRef->UserTypeXmlTagName()) {
                            uniseq = false;
                        }
                    }
                }
                if (member.Notag()) {
                    member.GetType()->PrintXMLSchemaElement(out);
                    continue;
                }
            }
            out << "      <xs:element ref=\"" << member_name << "\"";
            if ( member.Optional()) {
                out << " minOccurs=\"0\"";
            }
            if (uniseq) {
                out << " maxOccurs=\"unbounded\"";
            }
            out << "/>\n";
        }
    }
    out << closeTag1;
    if (hasAttlist) {
        ITERATE ( TMembers, i, m_Members ) {
            const CDataMember& member = **i;
            if (member.Attlist()) {
                member.GetType()->PrintXMLSchemaElement(out);
            }
        }
    }
    out << closeTag2;
}

void CDataMemberContainerType::PrintXMLSchemaExtra(CNcbiOstream& out) const
{
    if ( GetParentType() == 0 ) {
        out << 
            "\n";
    }
    ITERATE ( TMembers, i, m_Members ) {
        const CDataMember& member = **i;
        if (member.Notag()) {
            member.GetType()->PrintXMLSchemaExtra(out);
        } else {
            member.PrintXMLSchema(out);
        }
    }                                                                                         
    m_LastComments.PrintDTD(out, CComments::eMultiline);
}


void CDataMemberContainerType::FixTypeTree(void) const
{
    CParent::FixTypeTree();
    ITERATE ( TMembers, i, m_Members ) {
        (*i)->GetType()->SetParent(this, (*i)->GetName());
    }
}

bool CDataMemberContainerType::CheckType(void) const
{
    bool ok = true;
    ITERATE ( TMembers, i, m_Members ) {
        if ( !(*i)->Check() )
            ok = false;
    }
    return ok;
}

TObjectPtr CDataMemberContainerType::CreateDefault(const CDataValue& ) const
{
    NCBI_THROW(CDatatoolException,eNotImplemented,
                 GetASNKeyword() + string(" default not implemented"));
}

const char* CDataContainerType::XmlMemberSeparator(void) const
{
    return ",";
}

CTypeInfo* CDataContainerType::CreateTypeInfo(void)
{
    return CreateClassInfo();
}

CClassTypeInfo* CDataContainerType::CreateClassInfo(void)
{
    size_t itemCount = 0;
    // add place for 'isSet' flags
    ITERATE ( TMembers, i, GetMembers() ) {
        ++itemCount;
        CDataMember* mem = i->get();
        if ( mem->Optional() )
            ++itemCount;
    }
    auto_ptr<CAnyTypeClassInfo> typeInfo(new CAnyTypeClassInfo(GlobalName(),
                                                               itemCount));
    size_t index = 0;
    for ( TMembers::const_iterator i = GetMembers().begin();
          i != GetMembers().end(); ++i ) {
        CDataMember* mem = i->get();
        CDataType* memType = mem->GetType();
        TConstObjectPtr memberPtr = typeInfo->GetAnyTypePtr(index++);
        CMemberInfo* memInfo =
            typeInfo->AddMember(mem->GetName(), memberPtr,
                                memType->GetTypeInfo());
        if ( mem->Optional() ) {
            if ( mem->GetDefault() ) {
                TObjectPtr defPtr = memType->CreateDefault(*mem->GetDefault());
                memInfo->SetDefault(defPtr);
            }
            else {
                memInfo->SetOptional();
            }
            memInfo->SetSetFlag(typeInfo->GetSetFlagPtr(index++));
        }
        if (mem->NoPrefix()) {
            memInfo->SetNoPrefix();
        }
        if (mem->Attlist()) {
            memInfo->SetAttlist();
        }
        if (mem->Notag()) {
            memInfo->SetNotag();
        }
    }
    if ( HaveModuleName() )
        typeInfo->SetModuleName(GetModule()->GetName());
    return typeInfo.release();
}

AutoPtr<CTypeStrings> CDataContainerType::GenerateCode(void) const
{
    return GetFullCType();
}

AutoPtr<CTypeStrings> CDataContainerType::GetFullCType(void) const
{
    bool isRootClass = GetParentType() == 0;
    AutoPtr<CClassTypeStrings> code(new CClassTypeStrings(GlobalName(),
                                                          ClassName()));
    bool haveUserClass = isRootClass;
/*
    bool isObject;
    if ( haveUserClass ) {
        isObject = true;
    }
    else {
        isObject = !GetVar("_object").empty();
    }
*/
    code->SetHaveUserClass(haveUserClass);
    code->SetObject(true /*isObject*/ );
    ITERATE ( TMembers, i, GetMembers() ) {
        string defaultCode;
        bool optional = (*i)->Optional();
        const CDataValue* defaultValue = (*i)->GetDefault();
        if ( defaultValue ) {
            defaultCode = (*i)->GetType()->GetDefaultString(*defaultValue);
            _ASSERT(!defaultCode.empty());
        }

        bool delayed = !GetVar((*i)->GetName()+"._delay").empty();
        AutoPtr<CTypeStrings> memberType = (*i)->GetType()->GetFullCType();
        code->AddMember((*i)->GetName(), memberType,
                        (*i)->GetType()->GetVar("_pointer"),
                        optional, defaultCode, delayed,
                        (*i)->GetType()->GetTag(),
                        (*i)->NoPrefix(), (*i)->Attlist(), (*i)->Notag(),
                        (*i)->SimpleType(),(*i)->GetType(),false);
        (*i)->GetType()->SetTypeStr(&(*code));
    }
    SetTypeStr(&(*code));
    SetParentClassTo(*code);
    return AutoPtr<CTypeStrings>(code.release());
}

AutoPtr<CTypeStrings> CDataContainerType::GetRefCType(void) const
{
    return AutoPtr<CTypeStrings>(new CClassRefTypeStrings(ClassName(),
                                                          Namespace(),
                                                          FileName()));
}

const char* CDataSetType::GetASNKeyword(void) const
{
    return "SET";
}

bool CDataSetType::CheckValue(const CDataValue& value) const
{
    const CBlockDataValue* block =
        dynamic_cast<const CBlockDataValue*>(&value);
    if ( !block ) {
        value.Warning("block of values expected");
        return false;
    }

    typedef map<string, const CDataMember*> TReadValues;
    TReadValues mms;
    for ( TMembers::const_iterator m = GetMembers().begin();
          m != GetMembers().end(); ++m ) {
        mms[m->get()->GetName()] = m->get();
    }

    ITERATE ( CBlockDataValue::TValues, v, block->GetValues() ) {
        const CNamedDataValue* currvalue =
            dynamic_cast<const CNamedDataValue*>(v->get());
        if ( !currvalue ) {
            v->get()->Warning("named value expected");
            return false;
        }
        TReadValues::iterator member = mms.find(currvalue->GetName());
        if ( member == mms.end() ) {
            currvalue->Warning("unexpected member");
            return false;
        }
        if ( !member->second->GetType()->CheckValue(currvalue->GetValue()) ) {
            return false;
        }
        mms.erase(member);
    }
    
    for ( TReadValues::const_iterator member = mms.begin();
          member != mms.end(); ++member ) {
        if ( !member->second->Optional() ) {
            value.Warning(member->first + " member expected");
            return false;
        }
    }
    return true;
}

CClassTypeInfo* CDataSetType::CreateClassInfo(void)
{
    return CParent::CreateClassInfo()->SetRandomOrder();
}

const char* CDataSequenceType::GetASNKeyword(void) const
{
    return "SEQUENCE";
}

bool CDataSequenceType::CheckValue(const CDataValue& value) const
{
    const CBlockDataValue* block =
        dynamic_cast<const CBlockDataValue*>(&value);
    if ( !block ) {
        value.Warning("block of values expected");
        return false;
    }
    TMembers::const_iterator member = GetMembers().begin();
    CBlockDataValue::TValues::const_iterator cvalue =
        block->GetValues().begin();
    while ( cvalue != block->GetValues().end() ) {
        const CNamedDataValue* currvalue =
            dynamic_cast<const CNamedDataValue*>(cvalue->get());
        if ( !currvalue ) {
            cvalue->get()->Warning("named value expected");
            return false;
        }
        for (;;) {
            if ( member == GetMembers().end() ) {
                currvalue->Warning("unexpected value");
                return false;
            }
            if ( (*member)->GetName() == currvalue->GetName() )
                break;
            if ( !(*member)->Optional() ) {
                currvalue->GetValue().Warning((*member)->GetName() +
                                              " member expected");
                return false;
            }
            ++member;
        }
        if ( !(*member)->GetType()->CheckValue(currvalue->GetValue()) ) {
            return false;
        }
        ++member;
        ++cvalue;
    }
    while ( member != GetMembers().end() ) {
        if ( !(*member)->Optional() ) {
            value.Warning((*member)->GetName() + " member expected");
            return false;
        }
    }
    return true;
}


CDataMember::CDataMember(const string& name, const AutoPtr<CDataType>& type)
    : m_Name(name), m_Type(type), m_Optional(false),
    m_NoPrefix(false), m_Attlist(false), m_Notag(false), m_SimpleType(false)

{
    if ( m_Name.empty() ) {
        NCBI_THROW(CDatatoolException,eInvalidData,
                     string("Unnamed member in ASN.1 specification"));
    }
    m_Type->SetDataMember(this);
}

CDataMember::~CDataMember(void)
{
}

void CDataMember::PrintASN(CNcbiOstream& out, int indent, bool last) const
{
    GetType()->PrintASNTypeComments(out, indent);
    bool oneLineComment = m_Comments.OneLine();
    if ( !oneLineComment )
        m_Comments.PrintASN(out, indent);
    out << GetName() << ' ';
    GetType()->PrintASN(out, indent);
    if ( GetDefault() ) {
        GetDefault()->PrintASN(out << " DEFAULT ", indent + 1);
    }
    else if ( Optional() ) {
        out << " OPTIONAL";
    }
    if ( !last )
        out << ',';
    if ( oneLineComment ) {
        out << ' ';
        m_Comments.PrintASN(out, indent, CComments::eOneLine);
    }
}

void CDataMember::PrintDTD(CNcbiOstream& out) const
{
    GetType()->PrintDTD(out, m_Comments);
}

void CDataMember::PrintXMLSchema(CNcbiOstream& out) const
{
    GetType()->PrintXMLSchema(out,m_Comments);
}

bool CDataMember::Check(void) const
{
    if ( !m_Type->Check() )
        return false;
    if ( !m_Default )
        return true;
    return GetType()->CheckValue(*m_Default);
}

void CDataMember::SetDefault(const AutoPtr<CDataValue>& value)
{
    m_Default = value;
}

void CDataMember::SetOptional(void)
{
    m_Optional = true;
}

void CDataMember::SetNoPrefix(void)
{
    m_NoPrefix = true;
}

void CDataMember::SetAttlist(void)
{
    m_Attlist = true;
}
void CDataMember::SetNotag(void)
{
    m_Notag = true;
}
void CDataMember::SetSimpleType(void)
{
    m_SimpleType = true;
}


END_NCBI_SCOPE