WSDL Service Index

The following operations are supported. For a formal definition, please review the Service Description.

Web Service Links

Namespace Children of ::wsdb::elements::datetime::ShowDateTimeComponentsResponse

Namespace Code for ::wsdb::elements::datetime::ShowDateTimeComponentsResponse

namespace eval ::wsdb::elements::datetime::ShowDateTimeComponentsResponse {
    variable Children {TestString IsDateTime All YMD Year Positivity Month Day HMS Hour Minute Second SecondWhole SecondFract Timezone TZSign TZValue TZ14Hour TZ14Min TZHour TZMin}

    variable MaxOccurs
         set MaxOccurs(HMS) 1
         set MaxOccurs(TZ14Hour) 1
         set MaxOccurs(Year) 1
         set MaxOccurs(YMD) 1
         set MaxOccurs(Timezone) 1
         set MaxOccurs(TZHour) 1
         set MaxOccurs(SecondFract) 1
         set MaxOccurs(Day) 1
         set MaxOccurs(Hour) 1
         set MaxOccurs(TestString) 1
         set MaxOccurs(IsDateTime) 1
         set MaxOccurs(All) 1
         set MaxOccurs(TZMin) 1
         set MaxOccurs(Minute) 1
         set MaxOccurs(TZValue) 1
         set MaxOccurs(SecondWhole) 1
         set MaxOccurs(Positivity) 1
         set MaxOccurs(Second) 1
         set MaxOccurs(Month) 1
         set MaxOccurs(TZ14Min) 1
         set MaxOccurs(TZSign) 1

    variable MinOccurs
         set MinOccurs(HMS) 0
         set MinOccurs(TZ14Hour) 0
         set MinOccurs(Year) 0
         set MinOccurs(YMD) 0
         set MinOccurs(Timezone) 0
         set MinOccurs(TZHour) 0
         set MinOccurs(SecondFract) 0
         set MinOccurs(Day) 0
         set MinOccurs(Hour) 0
         set MinOccurs(TestString) 1
         set MinOccurs(IsDateTime) 1
         set MinOccurs(All) 0
         set MinOccurs(TZMin) 0
         set MinOccurs(Minute) 0
         set MinOccurs(TZValue) 0
         set MinOccurs(SecondWhole) 0
         set MinOccurs(Positivity) 0
         set MinOccurs(Second) 0
         set MinOccurs(Month) 0
         set MinOccurs(TZ14Min) 0
         set MinOccurs(TZSign) 0
    variable facetList {form Value name ShowDateTimeComponentsResponse}
    variable new ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::new
    variable validate ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::ValidateShowDateTimeComponentsResponse
    variable validate_All ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::All::Validate
    variable validate_Day ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Day::Validate
    variable validate_HMS ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::HMS::Validate
    variable validate_Hour ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Hour::Validate
    variable validate_IsDateTime ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::IsDateTime::Validate
    variable validate_Minute ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Minute::Validate
    variable validate_Month ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Month::Validate
    variable validate_Positivity ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Positivity::Validate
    variable validate_Second ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Second::Validate
    variable validate_SecondFract ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::SecondFract::Validate
    variable validate_SecondWhole ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::SecondWhole::Validate
    variable validate_TZ14Hour ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZ14Hour::Validate
    variable validate_TZ14Min ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZ14Min::Validate
    variable validate_TZHour ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZHour::Validate
    variable validate_TZMin ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZMin::Validate
    variable validate_TZSign ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZSign::Validate
    variable validate_TZValue ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZValue::Validate
    variable validate_TestString ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TestString::Validate
    variable validate_Timezone ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Timezone::Validate
    variable validate_YMD ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::YMD::Validate
    variable validate_Year ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Year::Validate

}

Procedures in ::wsdb::elements::datetime::ShowDateTimeComponentsResponse


proc ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::ValidateShowDateTimeComponentsResponse {
    namespace
} {

    variable Children
    variable MinOccurs
    variable MaxOccurs
    variable validate_TestString
    variable validate_IsDateTime
    variable validate_All
    variable validate_YMD
    variable validate_Year
    variable validate_Positivity
    variable validate_Month
    variable validate_Day
    variable validate_HMS
    variable validate_Hour
    variable validate_Minute
    variable validate_Second
    variable validate_SecondWhole
    variable validate_SecondFract
    variable validate_Timezone
    variable validate_TZSign
    variable validate_TZValue
    variable validate_TZ14Hour
    variable validate_TZ14Min
    variable validate_TZHour
    variable validate_TZMin
    array set COUNT [array get ${namespace}::.COUNT]
    set COUNT(.INVALID) 0

    set ElementNames $Children

    foreach ElementName $ElementNames {
        if {$MinOccurs($ElementName) > 0} {
            if {![info exists COUNT($ElementName)]} {
                ::wsdl::elements::noteFault $namespace [list 4 $ElementName 0 $MinOccurs($ElementName)]
                incr COUNT(.INVALID)
                return 0
            } elseif {$COUNT($ElementName) < $MinOccurs($ElementName)} {
                ::wsdl::elements::noteFaunt $namespace [list 4 $ElementName $COUNT($ElementName) $MinOccurs($ElementName)]
                incr COUNT(.INVALID)
                return 0
            }
        }
        if {[info exists COUNT($ElementName)] && $COUNT($ElementName) > $MaxOccurs($ElementName)} {
            ::wsdl::elements::noteFault $namespace [list 5 $ElementName $COUNT($ElementName) $MaxOccurs($ElementName)]
            incr COUNT(.INVALID)
            return 0
        }
    }

    set PARTS [set ${namespace}::.PARTS]
    set COUNT(.ELEMENTS) 0

    foreach PART $PARTS {
        incr COUNT(.ELEMENTS)
        foreach {childName prefix childPart} $PART {}
        set childPart [::xml::normalizeNamespace $namespace $childPart]

        switch -exact -- $childName {
            TestString {
                if {![eval [linsert $validate_TestString end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 TestString $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            IsDateTime {
                if {![eval [linsert $validate_IsDateTime end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 IsDateTime $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            All {
                if {![eval [linsert $validate_All end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 All $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            YMD {
                if {![eval [linsert $validate_YMD end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 YMD $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Year {
                if {![eval [linsert $validate_Year end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Year $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Positivity {
                if {![eval [linsert $validate_Positivity end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Positivity $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Month {
                if {![eval [linsert $validate_Month end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Month $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Day {
                if {![eval [linsert $validate_Day end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Day $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            HMS {
                if {![eval [linsert $validate_HMS end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 HMS $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Hour {
                if {![eval [linsert $validate_Hour end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Hour $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Minute {
                if {![eval [linsert $validate_Minute end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Minute $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Second {
                if {![eval [linsert $validate_Second end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Second $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            SecondWhole {
                if {![eval [linsert $validate_SecondWhole end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 SecondWhole $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            SecondFract {
                if {![eval [linsert $validate_SecondFract end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 SecondFract $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            Timezone {
                if {![eval [linsert $validate_Timezone end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 Timezone $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            TZSign {
                if {![eval [linsert $validate_TZSign end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 TZSign $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            TZValue {
                if {![eval [linsert $validate_TZValue end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 TZValue $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            TZ14Hour {
                if {![eval [linsert $validate_TZ14Hour end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 TZ14Hour $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            TZ14Min {
                if {![eval [linsert $validate_TZ14Min end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 TZ14Min $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            TZHour {
                if {![eval [linsert $validate_TZHour end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 TZHour $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            TZMin {
                if {![eval [linsert $validate_TZMin end $childPart]]} {
                    ::wsdl::elements::noteFault $namespace [list 2 TZMin $childPart]
                    incr COUNT(.INVALID)
                    break
                }
            }
            default {
                ::wsdl::elements::noteFault $namespace [list 3 $childName $childPart]
                incr COUNT(.INVALID)
            }
        }
    }

    if {$COUNT(.INVALID)} {
        return 0
    } else {
        return 1
    }
}


proc ::wsdb::elements::datetime::ShowDateTimeComponentsResponse::new {
    instanceNamespace
    childValuesList
} {

    set typeNS [::xml::element::append $instanceNamespace ShowDateTimeComponentsResponse]
    if {[lindex $childValuesList 0] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TestString::new $typeNS [lindex $childValuesList 0]
    } else {
        return -code error "Missing value for required Element TestString with no default value calling $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TestString::new"
    }
    if {[lindex $childValuesList 1] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::IsDateTime::new $typeNS [lindex $childValuesList 1]
    } else {
        return -code error "Missing value for required Element IsDateTime with no default value calling $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::IsDateTime::new"
    }
    if {[lindex $childValuesList 2] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::All::new $typeNS [lindex $childValuesList 2]
    } else {
        # skip element All
    }
    if {[lindex $childValuesList 3] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::YMD::new $typeNS [lindex $childValuesList 3]
    } else {
        # skip element YMD
    }
    if {[lindex $childValuesList 4] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Year::new $typeNS [lindex $childValuesList 4]
    } else {
        # skip element Year
    }
    if {[lindex $childValuesList 5] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Positivity::new $typeNS [lindex $childValuesList 5]
    } else {
        # skip element Positivity
    }
    if {[lindex $childValuesList 6] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Month::new $typeNS [lindex $childValuesList 6]
    } else {
        # skip element Month
    }
    if {[lindex $childValuesList 7] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Day::new $typeNS [lindex $childValuesList 7]
    } else {
        # skip element Day
    }
    if {[lindex $childValuesList 8] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::HMS::new $typeNS [lindex $childValuesList 8]
    } else {
        # skip element HMS
    }
    if {[lindex $childValuesList 9] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Hour::new $typeNS [lindex $childValuesList 9]
    } else {
        # skip element Hour
    }
    if {[lindex $childValuesList 10] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Minute::new $typeNS [lindex $childValuesList 10]
    } else {
        # skip element Minute
    }
    if {[lindex $childValuesList 11] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Second::new $typeNS [lindex $childValuesList 11]
    } else {
        # skip element Second
    }
    if {[lindex $childValuesList 12] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::SecondWhole::new $typeNS [lindex $childValuesList 12]
    } else {
        # skip element SecondWhole
    }
    if {[lindex $childValuesList 13] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::SecondFract::new $typeNS [lindex $childValuesList 13]
    } else {
        # skip element SecondFract
    }
    if {[lindex $childValuesList 14] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::Timezone::new $typeNS [lindex $childValuesList 14]
    } else {
        # skip element Timezone
    }
    if {[lindex $childValuesList 15] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZSign::new $typeNS [lindex $childValuesList 15]
    } else {
        # skip element TZSign
    }
    if {[lindex $childValuesList 16] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZValue::new $typeNS [lindex $childValuesList 16]
    } else {
        # skip element TZValue
    }
    if {[lindex $childValuesList 17] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZ14Hour::new $typeNS [lindex $childValuesList 17]
    } else {
        # skip element TZ14Hour
    }
    if {[lindex $childValuesList 18] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZ14Min::new $typeNS [lindex $childValuesList 18]
    } else {
        # skip element TZ14Min
    }
    if {[lindex $childValuesList 19] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZHour::new $typeNS [lindex $childValuesList 19]
    } else {
        # skip element TZHour
    }
    if {[lindex $childValuesList 20] ne ""} {
        $::wsdb::elements::datetime::ShowDateTimeComponentsResponse::TZMin::new $typeNS [lindex $childValuesList 20]
    } else {
        # skip element TZMin
    }
    return $typeNS
}