---

ag.idl

Go to the documentation of this file.

interface AGAPI {

  typedef string Id;              
  typedef string AGSetId;         
  typedef string AGId;
  typedef string AGIds;
  typedef string AnnotationId;
  typedef string AnnotationType;
  typedef string AnnotationIds;
  typedef string AnchorId;
  typedef string AnchorIds;
  typedef string TimelineId;
  typedef string SignalId;
  typedef string SignalIds;
  typedef string FeatureName;
  typedef string FeatureNames;
  typedef string FeatureValue;
  typedef string Features;
  typedef string URI;
  typedef string MimeClass;
  typedef string MimeType;
  typedef string Encoding;
  typedef string Unit;
  typedef double Offset;
  typedef string Track;

  AGSetId      CreateAGSet(      in AGSetId        agSetId);

  boolean      ExistsAGSet(      in AGSetId        agSetId);

  void         DeleteAGSet(         in AGSetId        agSetId);


  AGId         CreateAG(         in Id             id)

  AGId         CreateAG(         in Id             id,
                                 in TimelineId     timelineId );
  
  boolean      ExistsAG(         in AGId           agId );
  
  void         DeleteAG(         in AGId           agId );

  AGIds        GetAGIds(         in AGSetId        agSetId );
  
  TimelineId   CreateTimeline(   in Id     id );
  
  boolean      ExistsTimeline(   in TimelineId     timelineId );
  
  void         DeleteTimeline(   in TimelineId     timelineId );
  
  SignalId     CreateSignal(     in Id             id,
                                 in URI            uri,
                                 in MimeClass      mimeClass,
                                 in MimeType       mimeType,
                                 in Encoding       encoding,
                                 in Unit           unit,
                                 in Track          track );
  
  boolean      ExistsSignal(     in SignalId       signalId );
  
  void         DeleteSignal(     in SignalId       signalId );
  
  SignalIds    GetSignals(       in TimelineId     timelineId );

  void         SetOffsetUnit(    in AnchorId       anchorId,
                                 in Unit           unit);
  Unit         GetOffsetUnit(    in AnchorId       anchorId);

  void         SetAnchorSignalIds(in AnchorId      anchorId,
                                  in SignalIds     signalIds);

  SignalIds    GetAnchorSignalIds(in AnchorId      anchorId);

  MimeClass    GetSignalMimeClass(in SignalId      signalId );
  MimeType     GetSignalMimeType( in SignalId      signalId );
  Encoding     GetSignalEncoding( in SignalId      signalId );
  string       GetSignalXlinkType(in SignalId      signalId );
  string       GetSignalXlinkHref(in SignalId      signalId );
  string       GetSignalUnit(     in SignalId      signalId );
  Track        GetSignalTrack(    in SignalId      signalId );

  AnnotationId CreateAnnotation( in Id              id,
                                 in AnchorId        start,
                                 in AnchorId        end,
                                 in AnnotationType  annotationType );
  
  boolean      ExistsAnnotation( in AnnotationId    annotationId );
  void         DeleteAnnotation( in AnnotationId    annotationId );
  AnnotationId CopyAnnotation(   in AnnotationId    annotationId );

  AnnotationIds
               SplitAnnotation(  in AnnotationId     annotationId );

  AnnotationIds
               NSplitAnnotation( in AnnotationId     annotationId,
                                 in short            N );
  
  AnnotationType GetAnnotationType( in AnnoationId annotationId );
  AnchorId     GetStartAnchor(   in AnnotationId    annotationId );
  AnchorId     GetEndAnchor(     in AnnotationId    annotationId );

  string GetAnnotationInfo( in AnnoationId annotationId );

  void         SetStartAnchor(   in AnnotationId    annotationId,
                                 in AnchorId        anchorId );
  void         SetEndAnchor(     in AnnotationId    annotationId,
                                 in AnchorId        anchorId );
  
  Offset       GetStartOffset(   in AnnotationId    annotationId );
  Offset       GetEndOffset(     in AnnotationId    annotationId );
  void         SetStartOffset(   in AnnotationId    annotationId,
                                 in Offset          offset );
  void         SetEndOffset(     in AnnotationId    annotationId,
                                 in Offset          offset );

  sequence<AnnotationType> GetAnnotationTypes(in Id id);
  sequence<FeatureName> GetAnnotationFeatureNames(in Id id);
 
  // this might be necessary to package up an id into a durable reference
  //  AnnotationRef GetRef(          in Id              id );
  
  
  void         SetFeature(       in Id              id,
                                 in FeatureName     featureName,
                                 in FeatureValue    featureValue );
  
  boolean      ExistsFeature(    in Id              id,
                                 in FeatureName     featureName );
  
  void         DeleteFeature(    in Id             id,
                                 in FeatureName    featureName );
  
  string       GetFeature(       in Id             id,
                                 in FeatureName    featureName );
  void         UnsetFeature(     in Id             id,
                                 in FeatureName    featureName );
  FeatureNames
               GetFeatureNames(  in Id             id );

  void         SetFeatures(      in Id             id,
                                 in Features       features );
  
  Features     GetFeatures(      in Id             id );
  
  void         UnsetFeatures(    in Id             id );
  
  
  AnchorId     CreateAnchor(     in Id             id,
                                 in Offset         offset,
                                 in Unit           unit,
                                 in SignalIds      signalIds );
  
  AnchorId     CreateAnchor(     in Id             id,
                                 in SignalIds      signalIds );
  
  AnchorId     CreateAnchor(     in Id             id );

  boolean      ExistsAnchor(     in AnchorId       anchorId );
  void         DeleteAnchor(     in AnchorId       anchorId );
  void         SetAnchorOffset(  in AnchorId       anchorId,
                                 in Offset         offset );
  Offset       GetAnchorOffset(  in AnchorId       anchorId );

  boolean      GetAnchored(in AnchorId anchorId );

  void         UnsetAnchorOffset(in AnchorId       anchorId );
  
  AnchorId     SplitAnchor(      in AnchorId       anchorId );
  
  AnnotationIds
               GetIncomingAnnotationSet(
                                 in AnchorId       anchorId );

  AnnotationIds
  GetIncomigAnnotationSetByType(in AnchorId anchorId,
                                in AnnotationType type);

  AnnotationIds
               GetOutgoingAnnotationSet(
                                 in AnchorId       anchorId );

  AnnotationIds
  GetOutfoingAnnotationSet(in AnchorId anchorId,
                           in AnnotationType type);

  AnchorIds    GetAnchorSet(     in AGId           agId );
  AnchorIds    GetAnchorSetByOffset(
                                 in AGId           agId,
                                 in Offset         offset );

  AnchorIds    GetAnchorSetByOffset(
                                 in AGId           agId,
                                 in Offset         offset,
                                 in float          epsilon );


  AnchorIds    GetAnchorSetNearestOffset(
                                 in AGId           agId,
                                 in Offset         offset );

  AnnotationIds
               GetAnnotationSetByFeature(
                                 in AGId           agId,
                                 in FeatureName    featureName,
                                 in FeatureValue   featureValue);

  AnnotationIds
               GetAnnotationSetByOffset(
                                 in AGId           agId,
                                 in Offset         offset );
  AnnotationIds
               GetAnnotationSetByType(
                                 in AGId           agId,
                                 in AnnotationType annotationType );

  AnnotationIds GetAnnotationSeqByOffset(
                                        in AGId           agId);
  AnnotationIds GetAnnotationSeqByOffset(
                                        in AGId           agId,
                                        in Offset         begin);

  AnnotationIds GetAnnotationSeqByOffset(
                                        in AGId           agId,
                                        in Offset         begin,
                                        in Offset         end);
  
  
  AGSetId      GetAGSetId(       in Id             id );

  AGId         GetAGId(          in Id             id );

  TimelineId   GetTimelineId(    in Id             id );

  bool
  SPrecedes(in AnnotationId annotationId1,
            in AnnotationId annotationId2);

  string toXML(    in AGSetId            id);

  string toXML(    in AGId                   agId);

  bool LoadFromDB(   in string           connStr,
                     in AGSetId          agsetId);

  bool StoreToDB(   in string            connStr
                    in AGSetId           agsetId);


  AGIds
  Load(in string        format,
       in string        annotationFile,
       in string        id,
       in string[10][2] signalInfo,
       in string[10][2] options);


  void
  Store(in string        format,
        in string        filename,
        in string        agIds,
        in string[10][2] options);

boolean
CheckAnchorOffsetTotal(in Id agId,
                       in AnnotationType type);

boolean
CheckAnchorOffsetBounded(in Id agId,
                         in AnnotationType type);

boolean
CheckFeatureExists(in Id agId,
                   in AnnotationType type,
                   in FeatureName featureName);

boolean
CheckFeatureIsAnnotationId(in Id agId,
                           in AnnotationType type,
                           in FeatureName featureName);

boolean
CheckLinear(in Id agId,
            in AnnotationType type);

boolean
CheckConnected(in Id agId,
               in AnnotationType type);

boolean
CheckCoextensive(in Id agId,
                 in AnnotationType type1,
                 in AnnotationType type2);

boolean
CheckSpan(in Id agId,
          in AnnotationType spanType,
          in AnnotationType spannedType);

};

---