SASC-NG
DVBSoftCAM
Public Member Functions

SI::ExtendedEventDescriptors Class Reference

#include <descriptor.h>

Inheritance diagram for SI::ExtendedEventDescriptors:

List of all members.

Public Member Functions

int getMaximumTextLength (const char *separation1="\t", const char *separation2="\n")
char * getText (const char *separation1="\t", const char *separation2="\n")
char * getText (char *buffer, int size, const char *separation1="\t", const char *separation2="\n")
int getMaximumTextPlainLength ()
char * getTextPlain ()
char * getTextPlain (char *buffer, int size)
int getMaximumTextItemizedLength (const char *separation1="\t", const char *separation2="\n")
char * getTextItemized (const char *separation1="\t", const char *separation2="\n")
char * getTextItemized (char *buffer, int size, const char *separation1="\t", const char *separation2="\n")
bool getTextItemized (Loop::Iterator &it, bool &valid, char *itemDescription, char *itemText, int sizeItemDescription, int sizeItemText)

Detailed Description

Definition at line 52 of file descriptor.h.

Member Function Documentation

int SI::ExtendedEventDescriptors::getMaximumTextItemizedLength ( const char *  separation1 = "\t",
const char *  separation2 = "\n" 
)

Definition at line 179 of file descriptor.c.

References SI::VariableLengthPart::getLength(), i, and SI::ExtendedEventDescriptor::itemLoop.

                                                                                                           {
   int ret=0;
   int sepLength=strlen(separation1)+strlen(separation2);
   for (int i=0;i<length;i++) {
      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
      if (!d)
         continue;
      //The length includes two 8-bit length fields which have already been subtracted from sepLength //XXX kls 2004-06-06: what does this mean???
      ret+=d->itemLoop.getLength()+sepLength;
   }
   return ret;
}
int SI::ExtendedEventDescriptors::getMaximumTextLength ( const char *  separation1 = "\t",
const char *  separation2 = "\n" 
)

Definition at line 81 of file descriptor.c.

                                                                                                   {
   //add length of plain text, of itemized text with separators, and for one separator between the two fields.
   return getMaximumTextPlainLength()+getMaximumTextItemizedLength(separation1, separation2)+strlen(separation2);
}
int SI::ExtendedEventDescriptors::getMaximumTextPlainLength ( )

Definition at line 147 of file descriptor.c.

References SI::VariableLengthPart::getLength(), i, and SI::ExtendedEventDescriptor::text.

                                                        {
   int ret=0;
   for (int i=0;i<length;i++) {
      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
      if (!d)
         continue;
      ret+=d->text.getLength();
   }
   return ret;
}
char * SI::ExtendedEventDescriptors::getText ( const char *  separation1 = "\t",
const char *  separation2 = "\n" 
)

Definition at line 86 of file descriptor.c.

References SI::ExtendedEventDescriptor::text.

                                                                                        {
   int size = getMaximumTextLength(separation1, separation2);
   char *text=new char[size];
   return getText(text, size, separation1, separation2);
}
char * SI::ExtendedEventDescriptors::getText ( char *  buffer,
int  size,
const char *  separation1 = "\t",
const char *  separation2 = "\n" 
)

Definition at line 92 of file descriptor.c.

References SI::StructureLoop< T >::getNext(), SI::String::getText(), i, SI::ExtendedEventDescriptor::Item::item, SI::ExtendedEventDescriptor::Item::itemDescription, SI::ExtendedEventDescriptor::itemLoop, and SI::ExtendedEventDescriptor::text.

                                                                                                                {
   int index=0, len;
   for (int i=0;i<length;i++) {
      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
      if (!d)
         continue;
      d->text.getText(buffer+index, size);
      len = strlen(buffer+index);
      index += len;
      size -= len;
   }

   int sepLen1 = strlen(separation1);
   int sepLen2 = strlen(separation2);
   bool separated = false;
   for (int i=0;i<length;i++) {
      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
      if (!d)
         continue;

      ExtendedEventDescriptor::Item item;
      for (Loop::Iterator it; d->itemLoop.getNext(item, it);   ) {
         if (!separated && size > sepLen2) {
            strcpy(buffer+index, separation2); // let's have a separator between the long text and the items
            index += sepLen2;
            size -= sepLen2;
            separated = true;
         }

         item.itemDescription.getText(buffer+index, size);
         len = strlen(buffer+index);
         index += len;
         size -= len;
         if (size > sepLen1) {
            strcpy(buffer+index, separation1);
            index += sepLen1;
            size -= sepLen1;
         }

         item.item.getText(buffer+index, size);
         len = strlen(buffer+index);
         index += len;
         size -= len;
         if (size > sepLen2) {
            strcpy(buffer+index, separation2);
            index += sepLen2;
            size -= sepLen2;
         }
      }
   }

   buffer[index]='\0';
   return buffer;
}
char * SI::ExtendedEventDescriptors::getTextItemized ( const char *  separation1 = "\t",
const char *  separation2 = "\n" 
)

Definition at line 192 of file descriptor.c.

References SI::ExtendedEventDescriptor::text.

                                                                                                {
   int size = getMaximumTextItemizedLength(separation1, separation2);
   char *text=new char[size];
   return getTextItemized(text, size, separation1, separation2);
}
bool SI::ExtendedEventDescriptors::getTextItemized ( Loop::Iterator &  it,
bool &  valid,
char *  itemDescription,
char *  itemText,
int  sizeItemDescription,
int  sizeItemText 
)

Definition at line 236 of file descriptor.c.

References SI::StructureLoop< T >::getNext(), SI::String::getText(), SI::ExtendedEventDescriptor::Item::item, SI::ExtendedEventDescriptor::Item::itemDescription, SI::ExtendedEventDescriptor::itemLoop, and SI::Loop::Iterator::reset().

                                                                                                                                                              {
   //The iterator has to store two values: The descriptor index (4bit)
   //and the item loop index (max overall length 256, min item length 16 => max number 128 => 7bit)
   valid=false;

   int index=(it.i & 0x780) >> 7; // 0x780 == 1111 000 0000
   it.i &= 0x7F; //0x7F == 111 1111

   for (;index<length;index++) {
      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[index];
      if (!d)
         continue;

      ExtendedEventDescriptor::Item item;
      if (d->itemLoop.getNext(item, it)) {
         item.item.getText(itemDescription, sizeItemDescription);
         item.itemDescription.getText(itemText, sizeItemText);
         valid=true;
         break;
      } else {
         it.reset();
         continue;
      }
   }

   it.i &= 0x7F;
   it.i |= (index & 0xF) << 7; //0xF == 1111

   return index<length;
}
char * SI::ExtendedEventDescriptors::getTextItemized ( char *  buffer,
int  size,
const char *  separation1 = "\t",
const char *  separation2 = "\n" 
)

Definition at line 198 of file descriptor.c.

References SI::StructureLoop< T >::getNext(), SI::String::getText(), i, SI::ExtendedEventDescriptor::Item::item, SI::ExtendedEventDescriptor::Item::itemDescription, and SI::ExtendedEventDescriptor::itemLoop.

                                                                                                                        {
   int index=0, len;
   int sepLen1 = strlen(separation1);
   int sepLen2 = strlen(separation2);
   for (int i=0;i<length;i++) {
      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
      if (!d)
         continue;

      ExtendedEventDescriptor::Item item;
      for (Loop::Iterator it; d->itemLoop.getNext(item, it);   ) {
         item.itemDescription.getText(buffer+index, size);
         len = strlen(buffer+index);
         index += len;
         size -= len;
         if (size > sepLen1) {
            strcpy(buffer+index, separation1);
            index += sepLen1;
            size -= sepLen1;
         }

         item.item.getText(buffer+index, size);
         len = strlen(buffer+index);
         index += len;
         size -= len;
         if (size > sepLen2) {
            strcpy(buffer+index, separation2);
            index += sepLen2;
            size -= sepLen2;
         }
      }
   }
   buffer[index]='\0';
   return buffer;
}
char * SI::ExtendedEventDescriptors::getTextPlain ( )

Definition at line 158 of file descriptor.c.

References SI::ExtendedEventDescriptor::text.

                                             {
   int size = getMaximumTextPlainLength();
   char *text=new char[size];
   return getTextPlain(text, size);
}
char * SI::ExtendedEventDescriptors::getTextPlain ( char *  buffer,
int  size 
)

Definition at line 164 of file descriptor.c.

References SI::String::getText(), i, and SI::ExtendedEventDescriptor::text.

                                                                   {
   int index=0, len;
   for (int i=0;i<length;i++) {
      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
      if (!d)
         continue;
      d->text.getText(buffer+index, size);
      len = strlen(buffer+index);
      index += len;
      size -= len;
   }
   buffer[index]='\0';
   return buffer;
}
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines