z3950v3.asn

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

    sortElement      SortElement, 
       sortRelation    [1]  IMPLICIT INTEGER{
                                ascending      (0),
              descending      (1),
              ascendingByFrequency    (3),
              descendingByfrequency  (4)},
      caseSensitivity    [2]   IMPLICIT INTEGER{
                                 caseSensitive      (0), 
              caseInsensitive    (1)},
      missingValueAction    [3]   CHOICE{
                                     abort    [1] IMPLICIT NULL,
                                     nullval      [2] IMPLICIT NULL,
                    --supply a null value for missing value
          missingValueData  [3] IMPLICIT OCTET STRING} OPTIONAL}

  SortElement ::=   CHOICE{
    generic        [1] SortKey,
       datbaseSpecific    [2] IMPLICIT SEQUENCE OF SEQUENCE{
                       databaseName  DatabaseName,
                       dbSort    SortKey}} 

  SortKey ::= CHOICE{
    sortfield       [0]  IMPLICIT InternationalString,
                  -- An element, element-group-tag, or alias supported by the target
               -- and denoting a set of elements associated with each record.
     elementSpec    [1]  IMPLICIT Specification,
        sortAttributes    [2]  IMPLICIT SEQUENCE{
              id  AttributeSetId,
              list  AttributeList}}
-- end auxiliary definitions for sort



-- Extended Service APDUs
  ExtendedServicesRequest  ::= SEQUENCE{
  referenceId              ReferenceId OPTIONAL,
  function      [3]  IMPLICIT INTEGER {
              create    (1),
              delete    (2),
              modify  (3)},
  packageType      [4]  IMPLICIT OBJECT IDENTIFIER,
  packageName    [5]  IMPLICIT InternationalString OPTIONAL,
              -- PackageName mandatory for 'modify' or 'delete'; optional for
              -- 'create'. Following four parameters mandatory for 'create'; should
              -- be included on 'modify' if being modified; not needed on 'delete'.
  userId        [6]   IMPLICIT InternationalString OPTIONAL,
  retentionTime    [7]   IMPLICIT IntUnit OPTIONAL,
  permissions      [8]   IMPLICIT Permissions OPTIONAL,
  description      [9]   IMPLICIT InternationalString OPTIONAL,

-- (ExtendedServiceRequest APDU continued)
  taskSpecificParameters  [10]  IMPLICIT EXTERNAL OPTIONAL, 
              -- Mandatory for 'create'; included on 'modify' if specific
              -- parameters being modified; not necessary on 'delete'. For the
              -- 'EXTERNAL,' use OID of specific ES definition and select
              --  CHOICE [1]: 'esRequest'.
  waitAction      [11]  IMPLICIT INTEGER{
              wait      (1),
              waitIfPossible  (2),
              dontWait    (3),
              dontReturnPackage  (4)},
  elements          ElementSetName OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
--

ExtendedServicesResponse ::= SEQUENCE{
  referenceId                ReferenceId OPTIONAL,
  operationStatus    [3]    IMPLICIT INTEGER{
                done      (1),
                accepted    (2),  
                failure    (3)},
  diagnostics      [4]    IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
  taskPackage      [5]    IMPLICIT EXTERNAL OPTIONAL,
                -- Use OID: {Z39-50-recordSyntax (106)} and corresponding
                -- syntax. For the EXTERNAL, 'taskSpecific,' within that
                -- definition, use OID of the specific es, and choose [2],
                -- 'taskPackage'.
  otherInfo          OtherInformation OPTIONAL}

 Permissions ::= SEQUENCE OF SEQUENCE{
  userId      [1] IMPLICIT InternationalString,
  allowableFunctions  [2] IMPLICIT SEQUENCE OF INTEGER{
              delete      (1),
              modifyContents  (2),
              modifyPermissions  (3),
              present    (4),
                 invoke    (5)}} 

Close ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,  -- See 3.2.11.1.5.
  closeReason          CloseReason,
  diagnosticInformation    [3]  IMPLICIT InternationalString OPTIONAL,
  resourceReportFormat    [4]  IMPLICIT ResourceReportId OPTIONAL, 
                -- For use by origin only, and only on Close request;
                -- origin requests target to include report in response.
   resourceReport      [5]  ResourceReport OPTIONAL,
                -- For use by target only, unilaterally on Close request;
                -- on Close response may be unilateral or in response
                -- to origin request.
  otherInfo          OtherInformation OPTIONAL}

  CloseReason ::=  [211]  IMPLICIT INTEGER{
            finished      (0),
            shutdown      (1),
            systemProblem    (2),
            costLimit      (3),
            resources      (4),
            securityViolation    (5),
            protocolError    (6),
            lackOfActivity    (7),
            peerAbort      (8),
            unspecified      (9)}


-- Global auxiliary definitions
  ReferenceId       ::=      [2]  IMPLICIT OCTET STRING
  ResultSetId        ::=      [31]    IMPLICIT InternationalString
  ElementSetName     ::=     [103]   IMPLICIT InternationalString
  DatabaseName     ::=    [105]   IMPLICIT InternationalString
  AttributeSetId     ::=       OBJECT IDENTIFIER


-- OtherInformation
  OtherInformation   ::= [201] IMPLICIT SEQUENCE OF SEQUENCE{
    category            [1]   IMPLICIT InfoCategory OPTIONAL, 
    information        CHOICE{
      characterInfo        [2]  IMPLICIT InternationalString,
      binaryInfo        [3]  IMPLICIT OCTET STRING,
      externallyDefinedInfo    [4]  IMPLICIT EXTERNAL,
      oid          [5]  IMPLICIT OBJECT IDENTIFIER}}
--
  InfoCategory ::= SEQUENCE{
      categoryTypeId  [1]   IMPLICIT OBJECT IDENTIFIER OPTIONAL,
      categoryValue  [2]   IMPLICIT INTEGER}


-- Units
  -- IntUnit is used when value and unit are supplied together. Unit, alone, is used when just
  -- specifying a unit (without a value).  For example, IntUnit is used in Term, in an RPNQuery, or
  -- it can be the datatype of an element within a retrieval record. Unit (alone) would be used in an
  -- element request, when requesting data be returned according to a particular unit.

  IntUnit ::= SEQUENCE{
    value    [1] IMPLICIT INTEGER,
    unitUsed  [2] IMPLICIT Unit}
--
  Unit ::= SEQUENCE{
    unitSystem    [1] InternationalString OPTIONAL,    -- e.g. 'SI'
    unitType    [2] StringOrNumeric OPTIONAL,    -- e.g. 'mass'
    unit      [3] StringOrNumeric OPTIONAL,    -- e.g. 'kilograms'
    scaleFactor    [4] IMPLICIT INTEGER OPTIONAL    -- e.g. 9 means 10**9
        }

--CharacterString
  InternationalString ::= GeneralString
    -- When version 2 is in force, this collapses to VisibleString. That is, only characters in the
    -- visibleString repertoire may be used. (Datatype compatibility with version 2 is not affected,
     -- because references are IMPLICIT.)  When version 3 is in force, the semantics of the
    -- GeneralString content may be altered by negotiation during initialization. If no such
    -- negotiation is in effect, then GeneralString semantics are in force.

StringOrNumeric ::= CHOICE{
  string    [1] IMPLICIT InternationalString,
  numeric  [2] IMPLICIT INTEGER}

END -- IR DEFINITIONS



DiagnosticFormatDiag1 
{z39-50-diagnosticFormat diag-1 (2)} DEFINITIONS ::=
BEGIN
IMPORTS Term, Specification, AttributeList, SortElement, DatabaseName, 
DefaultDiagFormat, InternationalString FROM Z39-50-APDU-1995;


DiagnosticFormat ::=  SEQUENCE OF SEQUENCE{ 
  diagnostic  [1] CHOICE{
              defaultDiagRec    [1]  IMPLICIT DefaultDiagFormat,
              explicitDiagnostic    [2]  DiagFormat} OPTIONAL, 
  message  [2] IMPLICIT InternationalString OPTIONAL} 


DiagFormat ::= CHOICE{

tooMany  [1000]   IMPLICIT SEQUENCE{
                tooManyWhat   [1]  IMPLICIT INTEGER{
                                  argumentWords        (1), 
                                  truncatedWords        (2), 
                                  booleanOperators      (3),
                                  incompleteSubfields    (4), 
                                  characters          (5),
                                  recordsRetrieved      (6), 
                                  dataBasesSpecified      (7),
                                  resultSetsCreated      (8), 
                                  indexTermsProcessed    (9)},
                max        [2]  IMPLICIT INTEGER OPTIONAL},







badSpec    [1001]  IMPLICIT SEQUENCE{  -- element set name or specification
                spec        [1] IMPLICIT Specification, -- esn or element spec not supported
                db        [2] IMPLICIT DatabaseName OPTIONAL,
                            -- if db specified, above spec not supported for db; otherwise,
                            -- spec not supported period.
                goodOnes    [3] IMPLICIT SEQUENCE OF Specification OPTIONAL  
                            -- target supplies ones that are supported
                            },


dbUnavail  [1002]  IMPLICIT SEQUENCE{ -- database unavailable
                db  [1] IMPLICIT DatabaseName,
                why  [2] IMPLICIT SEQUENCE{
                        reasonCode  [1] IMPLICIT INTEGER{
                                      doesNotExist    (0),
                                      existsButUnavail  (1),
                                      locked      (2),
                                      accessDenied    (3)} OPTIONAL,
                        message    [2] IMPLICIT InternationalString OPTIONAL}},


unSupOp  [1003]  IMPLICIT INTEGER{  -- unsupported operator
                and     (0),
                or      (1),
                and-not  (2),
                prox    (3)},


attribute    [1004]  IMPLICIT SEQUENCE{
                    -- Applies for unsupported attribute set, attribute type, 
                    -- attribute value, or term (for a given attribute type or value).

                id      [1]  IMPLICIT OBJECT IDENTIFIER,
                   -- if only "id" occurs, then attribute set is not supported
                type    [2]  IMPLICIT INTEGER OPTIONAL,
                   -- must occur if value occurs.
                value    [3]   IMPLICIT INTEGER OPTIONAL,
                    -- if omitted, and Type occurs, then Type is what is unsupported
                term    [4]  Term OPTIONAL
                    -- If occurs, term is illegal or not supported, for attribute value,
                    -- if value occurs; otherwise, for type.
                                },


attCombo  [1005]  IMPLICIT SEQUENCE{ -- attribute combination not supported
              unsupportedCombination  [1] IMPLICIT AttributeList, 
              recommendedAlternatives  [2] IMPLICIT SEQUENCE OF AttributeList OPTIONAL}, 




term      [1006]  IMPLICIT SEQUENCE{
                problem    [1] IMPLICIT INTEGER{
                            codedValue  (1),
                            unparsable  (2),
                            tooShort    (3),
                            type      (4)} OPTIONAL,
                term      [2] Term},


proximity  [1007] CHOICE{        -- proximity diagnostics:
               resultSets  [1]    IMPLICIT NULL,         -- proximity between sets not supported
              badSet    [2]    IMPLICIT InternationalString,  -- bad result set specified
                 relation    [3]   IMPLICIT INTEGER,      -- 1 to 6 ; relation not supported
              unit      [4]  IMPLICIT INTEGER,      -- unsupported unit code
              distance    [5]  IMPLICIT INTEGER,      -- unsupported distance
              attributes  [6]  AttributeList,             --  proximity not supported with specified
                                                   -- attribute combination
              ordered    [7]  IMPLICIT NULL,        -- ordered flag not supported
              exclusion  [8]  IMPLICIT NULL          -- exclusion flag not supported
                    },