z3950v3.asn

ASN.1工具源代码,包括编译源码生成工具和各种基本类型构造类型的编解码实现代码

-- begin auxiliary definitions for Search and Present APDUs

-- begin definition of records
  Records ::= CHOICE{
  responseRecords      [28]  IMPLICIT SEQUENCE OF NamePlusRecord,
  nonSurrogateDiagnostic     [130]  IMPLICIT DefaultDiagFormat,
  multipleNonSurDiagnostics   [205]  IMPLICIT SEQUENCE OF DiagRec} 
--
  NamePlusRecord  ::=  SEQUENCE{
  name    [0] IMPLICIT DatabaseName OPTIONAL,
  record  [1] CHOICE{
        retrievalRecord        [1] EXTERNAL,
        surrogateDiagnostic    [2] DiagRec, 
          -- Must select one of the above two, retrievalRecord or
          -- surrogateDiagnostic, unless 'level 2 segmentation' is in effect.
        startingFragment    [3] FragmentSyntax,
        intermediateFragment  [4] FragmentSyntax,
        finalFragment    [5] FragmentSyntax}}
  FragmentSyntax ::= CHOICE{
    externallyTagged    EXTERNAL,
    notExternallyTagged  OCTET STRING}

  DiagRec ::= CHOICE{
      defaultFormat    DefaultDiagFormat,
                -- Must choose defaultFormat if version 2 is in effect.
      externallyDefined    EXTERNAL}

  DefaultDiagFormat::= SEQUENCE{ 
  diagnosticSetId  OBJECT IDENTIFIER,
  condition    INTEGER,
  addinfo      CHOICE{
           v2Addinfo  VisibleString,  -- version 2
           v3Addinfo  InternationalString  -- version 3
            }}
  -- end definition of records
  Range  ::= SEQUENCE{
    startingPosition    [1] IMPLICIT INTEGER,
    numberOfRecords    [2] IMPLICIT INTEGER} 
--
  ElementSetNames ::= CHOICE {
    genericElementSetName  [0] IMPLICIT InternationalString,
    databaseSpecific    [1] IMPLICIT SEQUENCE OF SEQUENCE{
              dbName  DatabaseName,
              esn    ElementSetName}}

  PresentStatus   ::=    [27]  IMPLICIT INTEGER{
                            success  (0),
                             partial-1   (1),
                              partial-2   (2),
              partial-3   (3),
                                      partial-4   (4),
                               failure    (5)}

-- begin definition of composition specification
  CompSpec ::= SEQUENCE{
  selectAlternativeSyntax  [1] IMPLICIT BOOLEAN,
            -- See comment for recordSyntax, below.
  generic             [2] IMPLICIT Specification OPTIONAL,
  dbSpecific      [3] IMPLICIT SEQUENCE OF SEQUENCE{
                db  [1] DatabaseName,
                spec  [2] IMPLICIT Specification} OPTIONAL,
    -- At least one of generic and dbSpecific must occur, and both may occur. If both, then for
     -- any record not in the list of databases within dbSpecific, generic applies.
   recordSyntax               [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL
               -- For each record, the target selects the first record syntax
               -- in this list that it can support.  If the list is exhausted, the
               -- target may select an alternative syntax if
               -- selectAlternativeSyntax is 'true'.
        }
  Specification ::= SEQUENCE{
  schema    [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
  elementSpec    [2] CHOICE{
              elementSetName   [1] IMPLICIT InternationalString,
          externalEspec  [2] IMPLICIT EXTERNAL} OPTIONAL}
-- end definition of composition specification
-- end auxiliary definitions for search and response APDUs

-- Delete APDUs
  DeleteResultSetRequest ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
      deleteFunction      [32]  IMPLICIT INTEGER{
                    list   (0),
                    all   (1)},
   resultSetList          SEQUENCE OF ResultSetId OPTIONAL,
  otherInfo          OtherInformation OPTIONAL} 
--
  DeleteResultSetResponse ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
    deleteOperationStatus    [0]  IMPLICIT DeleteSetStatus,
  deleteListStatuses      [1]  IMPLICIT ListStatuses OPTIONAL,
  numberNotDeleted       [34]  IMPLICIT INTEGER OPTIONAL,
     bulkStatuses        [35]   IMPLICIT ListStatuses OPTIONAL,
   deleteMessage      [36]  IMPLICIT InternationalString OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
  ListStatuses ::= SEQUENCE OF SEQUENCE{ 
        id  ResultSetId, 
        status  DeleteSetStatus}

  DeleteSetStatus ::= [33] IMPLICIT INTEGER{
                  success          (0),
                   resultSetDidNotExist      (1),
                    previouslyDeletedByTarget      (2),
                     systemProblemAtTarget      (3),
                   accessNotAllowed        (4),
      resourceControlAtOrigin      (5),
                   resourceControlAtTarget      (6),
                    bulkDeleteNotSupported      (7),
                   notAllRsltSetsDeletedOnBulkDlte    (8),
      notAllRequestedResultSetsDeleted    (9),
      resultSetInUse        (10)}
--

--Access- and Resource-control APDUs
--
  AccessControlRequest ::= SEQUENCE{
  referenceId        ReferenceId OPTIONAL,
  securityChallenge      CHOICE{
              simpleForm      [37] IMPLICIT OCTET STRING,
               externallyDefined    [0]  EXTERNAL},
  otherInfo        OtherInformation OPTIONAL}

  AccessControlResponse ::= SEQUENCE{
  referenceId        ReferenceId OPTIONAL,
  securityChallengeResponse  CHOICE{
              simpleForm      [38]   IMPLICIT OCTET STRING,
               externallyDefined    [0]  EXTERNAL} OPTIONAL,
              -- Optional only in version 3; mandatory in version 2. If
              -- omitted (in version 3) then diagnostic must occur.
  diagnostic    [223]    DiagRec OPTIONAL, -- Version 3 only.
  otherInfo        OtherInformation OPTIONAL}



  ResourceControlRequest ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
  suspendedFlag      [39]  IMPLICIT BOOLEAN OPTIONAL,
  resourceReport      [40]  ResourceReport OPTIONAL,
  partialResultsAvailable    [41]  IMPLICIT INTEGER{
                subset    (1),
                interim  (2),
                none    (3)} OPTIONAL,
  responseRequired      [42]   IMPLICIT BOOLEAN, 
  triggeredRequestFlag    [43]   IMPLICIT BOOLEAN OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}


  ResourceControlResponse ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
    continueFlag       [44]   IMPLICIT BOOLEAN, 
  resultSetWanted      [45]  IMPLICIT BOOLEAN OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}



  TriggerResourceControlRequest ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
  requestedAction      [46]  IMPLICIT INTEGER{
                resourceReport  (1),
                resourceControl  (2),
                cancel      (3)}, 
  prefResourceReportFormat    [47]   IMPLICIT ResourceReportId OPTIONAL,
  resultSetWanted      [48]   IMPLICIT BOOLEAN OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}



  ResourceReportRequest ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
  opId          [210]  IMPLICIT ReferenceId OPTIONAL,
  prefResourceReportFormat    [49]   IMPLICIT ResourceReportId OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
--
  ResourceReportResponse ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
  resourceReportStatus    [50]   IMPLICIT INTEGER{
                success    (0),
                partial    (1),
                failure-1    (2),
                failure-2    (3),
                failure-3    (4),
                failure-4    (5),
                failure-5    (6),
                failure-6    (7)},
  resourceReport               [51]   ResourceReport OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
--
   ResourceReport     ::=   EXTERNAL
  ResourceReportId    ::=    OBJECT IDENTIFIER

--Scan APDUs
  ScanRequest ::= SEQUENCE{
  referenceId              ReferenceId OPTIONAL,
    databaseNames        [3]  IMPLICIT SEQUENCE OF DatabaseName,
    attributeSet            AttributeSetId OPTIONAL,
    termListAndStartPoint        AttributesPlusTerm,
    stepSize           [5]   IMPLICIT INTEGER OPTIONAL,
    numberOfTermsRequested         [6]   IMPLICIT INTEGER,
    preferredPositionInResponse      [7]   IMPLICIT INTEGER OPTIONAL,
    otherInfo            OtherInformation OPTIONAL}

  ScanResponse ::= SEQUENCE{
   referenceId              ReferenceId OPTIONAL,
   stepSize           [3]  IMPLICIT INTEGER OPTIONAL,
   scanStatus           [4]  IMPLICIT INTEGER {
                                success   (0),
                                partial-1   (1),
                                partial-2   (2),
                                partial-3   (3),
                                partial-4   (4),
                                partial-5   (5),
                                failure  (6) },
   numberOfEntriesReturned       [5]  IMPLICIT INTEGER,
   positionOfTerm         [6]  IMPLICIT INTEGER OPTIONAL,
   entries           [7]  IMPLICIT ListEntries  OPTIONAL,  
   attributeSet          [8]  IMPLICIT AttributeSetId OPTIONAL,
   otherInfo            OtherInformation OPTIONAL}

-- begin auxiliary definitions for Scan
  ListEntries ::= SEQUENCE{
  entries        [1]   IMPLICIT SEQUENCE OF Entry OPTIONAL,
    nonsurrogateDiagnostics    [2]  IMPLICIT SEQUENCE OF DiagRec OPTIONAL
    -- At least one of entries and nonsurrogateDiagnostics must occur
          }

  Entry  ::= CHOICE {
     termInfo               [1]   IMPLICIT TermInfo,
     surrogateDiagnostic    [2]   DiagRec}
--
  TermInfo ::= SEQUENCE {
   term                    Term,
     displayTerm      [0]   IMPLICIT InternationalString OPTIONAL,
                                     -- Presence of displayTerm means that term is not considered by
              -- the target to be suitable for display, and displayTerm should
              -- instead be displayed. 'term' is the actual term in the term list;
               -- 'displayTerm' is for display purposes only, and is not an actual
              -- term in the term list.
  suggestedAttributes            AttributeList OPTIONAL,
     alternativeTerm    [4]  IMPLICIT SEQUENCE OF AttributesPlusTerm OPTIONAL, 
     globalOccurrences    [2]  IMPLICIT INTEGER OPTIONAL,
     byAttributes      [3]  IMPLICIT OccurrenceByAttributes OPTIONAL,
     otherTermInfo      OtherInformation OPTIONAL} 

  OccurrenceByAttributes ::= SEQUENCE OF SEQUENCE{
     attributes    [1]  AttributeList, 
     occurrences       CHOICE{
               global    [2] INTEGER,
            byDatabase  [3] IMPLICIT SEQUENCE OF SEQUENCE{ 
              db      DatabaseName,
              num     [1]  IMPLICIT INTEGER OPTIONAL,
              otherDbInfo    OtherInformation OPTIONAL}} OPTIONAL,
     otherOccurInfo    OtherInformation OPTIONAL} 
-- end auxiliary definitions for Scan

-- Sort APDUs
SortRequest  ::= SEQUENCE{
  referenceId              ReferenceId OPTIONAL,
  inputResultSetNames  [3]  IMPLICIT SEQUENCE OF InternationalString,
  sortedResultSetName  [4]    IMPLICIT InternationalString,
  sortSequence     [5]  IMPLICIT SEQUENCE OF SortKeySpec,
              -- order of occurrence is from major to minor
  otherInfo        OtherInformation OPTIONAL}

SortResponse  ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
  sortStatus         [3]  IMPLICIT INTEGER{
                            success  (0), 
              partial-1  (1),
              failure  (2)},
  resultSetStatus    [4]  IMPLICIT INTEGER{
              empty    (1), 
                  interim  (2), 
                  unchanged  (3),
              none    (4)} OPTIONAL,
  diagnostics        [5]             IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
  otherInfo        OtherInformation OPTIONAL}

-- begin auxiliary definitions for Sort
  SortKeySpec ::= SEQUENCE{