---

AG.h

Go to the documentation of this file.

// AG.h: A AG is a set of annotations along with the index structure.
// Author: Xiaoyi Ma, Steven Bird
// Copyright (C) 2001 Linguistic Data Consortium, U Penn.
// Web: http://www.ldc.upenn.edu/; Email: ldc@ldc.upenn.edu
// For license information, see the file `LICENSE' included
// with the distribution.


#ifndef AG_h
#define AG_h

#include <list>

#include "AGTypes.h"
#include "Identifiers.h"
#include "Anchor.h"
#include "Annotation.h"
#include "AnnotationIndex.h"
#include "Timeline.h"

typedef set<FeatureName> FeatureNameSet;

using namespace std;

class AG : public AnnotationSeq {
 private:
  const Id id;

  string type;

  Timeline* timeline;

  Metadata metadata;

  AnnotationIndex I;

  Identifiers* anchorIds;
  
  Identifiers* annotationIds;

 public:

  AG(Id id, Timeline* timeline=NULL, string type="");

  ~AG();

  Id getId() const { return id; }

  void setType(string type) { this->type = type; }

  string getType() const { return type; }

  Timeline* getTimeline() const { return timeline; }

  void addAnchor(Anchor* a);
  
  void deleteAnchor(Anchor* a) throw (AGException);

  void setAnchorOffset(Anchor*, Offset);

  Anchor* splitAnchor(Anchor* original);

  void add(Annotation* anchor);

  Id createAnnotation(Id id, Anchor* anchor1, Anchor* anchor2,
                      AnnotationType annotationType) throw(AGException);

  void setFeature(Id id, FeatureName featureName, FeatureValue featureValue);


  bool existsFeature(Id id, FeatureName featureName);

  void deleteFeature(Id id, FeatureName featureName);

  string getFeature(Id id, FeatureName featureName);

  StringSet getFeatureNames(Id id);

  void getAnnotationFeatureNames(StringSet& S);

  void getAnnotationTypes(StringSet& S);

  void setFeatures(Id id, Features features);

  Features getFeatures(Id id);
  
  void unsetFeatures(Id id);
 
  AnchorId createAnchor(Id id, Offset offset, Unit unit, string signals);

  AnchorId createAnchor(Id id, Unit unit, string signals); 

  Offset getAnchorOffset(Anchor* anchor);

  Annotation* copyAnnotation(const Annotation* annotation);

  Annotation* splitAnnotation(Annotation* original);

  AnnotationSet nSplitAnnotation(Annotation* original, int n);

  void deleteAnnotation(Annotation* annotation);

  void setStartAnchor(Annotation* annotation, Anchor* anchor);

  void setEndAnchor(Annotation* annotation, Anchor* anchor);

  void unsetAnchorOffset(Anchor* a);

  void setFeature(Annotation*, const String&, const String&);

  AnchorSeq* getAnchorSet() { return &I.anchorSet; }

  Annotation* getById(const Id& id) throw (AGException);

  Anchor* getAnchorById(const Id& id) throw (AGException);

  AnchorSet getAnchorSetByOffset(Offset offset, double epsilon=0.0);

  AnnotationSet getAnnotationSetByType(const String& t) {return I.byType[t];}

  AnnotationSet getAnnotationSetByOffset(Offset o) {return I.getByOffset(o);}

  AnnotationSet getAnnotationSetByFeature(const String& f, const String& v) {return I.byFeature[make_pair(f,v)];}

  AnnotationSet getIncomingAnnotationSet(Anchor* a) {return I.incoming[a];}

  AnnotationSet getIncomingAnnotationSetByType(Anchor* a, AnnotationType t);

  AnnotationSet getOutgoingAnnotationSet(Anchor* a) {return I.outgoing[a];}

  AnnotationSet getOutgoingAnnotationSetByType(Anchor* a, AnnotationType t);

  Offset getNearestOffset(Offset o) {return I.getNearestOffset(o);}

  AnnotationSeq getAnnotationSeqByOffset(Offset begin=0.0, Offset end=0.0);

  Annotation* getAnnotationByOffset(Offset offset) { return I.getAnnotationByOffset(offset); }

  AnchorSet getAnchorSetNearestOffset(Offset offset);

  list<string> storeSQLs(AGSetId agSetId,FeatureNameSet features);

  string toString();

};


#endif

---