key-set.cc

可以在ns-2中进行仿真的SPIN路由协议的源码

#include <stdlib.h>
#include <object.h>
#include <mit/rca/meta/key-set.h>

static class KeySetClass : public TclClass {
public:
  KeySetClass() : TclClass("Set/KeySet") {}
  TclObject* create(int, const char*const*) {
    return (new KeySet());
  }
} class_KeySet;


KeySet::KeySet() : HashTab(19)
{
}

KeySet::~KeySet()
{
}

int KeySet::command(int argc, const char*const* argv)
{
  TclObject *obj;  
  Tcl& tcl = Tcl::instance();

  if (argc == 2) {
    if (strcmp(argv[1], "numelements") == 0) {
      int result = KeySet::Numelements();
      tcl.resultf("%d",result);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "emptyset?") == 0) {
      int result = KeySet::Emptyset();
      tcl.resultf("%d",result);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "pp") == 0) {
      KeySet::Pp();
      return TCL_OK;
    }
    else
      if (strcmp(argv[1], "settolist") == 0) {
	char *stringlist = KeySet::SetToList();
	tcl.resultf("%s",stringlist);
	delete stringlist;
	return TCL_OK;
      }
  }

  if (argc == 3) {
    if (strcmp(argv[1], "union") == 0) {
      if( (obj = TclObject::lookup(argv[2])) == 0) {
	fprintf(stderr, "KeySet: %s lookup of %s failed\n", argv[1],
		argv[2]);
	return TCL_ERROR;
      }
      KeySet::Union((KeySet *) obj);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "subset") == 0) {
      if( (obj = TclObject::lookup(argv[2])) == 0) {
	fprintf(stderr, "KeySet: %s lookup of %s failed\n", argv[1],
		argv[2]);
	return TCL_ERROR;
      }
      int result = KeySet::Subset((KeySet *) obj);
      tcl.resultf("%d",result);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "eq") == 0) {
      if( (obj = TclObject::lookup(argv[2])) == 0) {
	fprintf(stderr, "KeySet: %s lookup of %s failed\n", argv[1],
		argv[2]);
	return TCL_ERROR;
      }
      int result = KeySet::Eq((KeySet *) obj);
      tcl.resultf("%d",result);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "neq") == 0) {
      if( (obj = TclObject::lookup(argv[2])) == 0) {
	fprintf(stderr, "KeySet: %s lookup of %s failed\n", argv[1],
		argv[2]);
	return TCL_ERROR;
      }
      int result = KeySet::Neq((KeySet *) obj);
      tcl.resultf("%d",result);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "subtract") == 0) {
      if( (obj = TclObject::lookup(argv[2])) == 0) {
	fprintf(stderr, "KeySet: %s lookup of %s failed\n", argv[1],
		argv[2]);
	return TCL_ERROR;
      }
      KeySet::Subtract((KeySet *) obj);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "intersection") == 0) {
      if( (obj = TclObject::lookup(argv[2])) == 0) {
	fprintf(stderr, "KeySet: %s lookup of %s failed\n", argv[1],
		argv[2]);
	return TCL_ERROR;
      }
      KeySet::Intersection((KeySet *) obj);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "pp") == 0) {
      KeySet::Pp((char *)argv[2]);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "member") == 0) {
      int result = KeySet::Member((char *)argv[2]);
      tcl.resultf("%d",result);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "add") == 0) {
      KeySet::Add((char *)argv[2]);
      return TCL_OK;
    }
    else
    if (strcmp(argv[1], "findelement") == 0) {
      char *result = FindElement((char *)argv[2]);
      if (result == NULL)
	{
	  tcl.resultf("");
	  return TCL_OK;
	}
      tcl.resultf("%s",result);
      return TCL_OK;
    }

  }
  
  if (argc == 4) {
    if (strcmp(argv[1], "add") == 0) {
      KeySet::Add((char *)argv[2], (char *)argv[3]);
      return TCL_OK;
    }
  }

  return HashTab::command(argc, argv);
}

void KeySet::Union(KeySet *y)
{
  register i;
  
  for (i = 0; i < y->buckets_ ; i++)
    {
      BucketList *p;
      for( p = y->htab_[i] ; p != NULL ; p = p->next_)
	{
	  LookupInsertNotFound(p->key_, p->element_);
	}
    }

  return;
}

KeySet *KeySet::Copy()
{

  KeySet *cp = new KeySet;

  cp->Union(this);
  return cp;
}


void KeySet::Intersection(KeySet *y)
{
  register i;

  for (i = 0; i < buckets_ ; i++)
    {
      BucketList *p;
      p = htab_[i];
      while(p != NULL)
	{
	  BucketList *next = p->next_;
	  if (y->Lookup(p->key_) == NULL)
	    {
	      Delete(p->key_);
	    }
	  p = next;
	}
    }

  return;
}

void KeySet::Subtract(KeySet *y)
{
  register i;

  for (i = 0; i < y->buckets_ ; i++)
    {
      BucketList *p;
      for( p = y->htab_[i] ; p != NULL ; p = p->next_)
	{
	  Delete(p->key_);
	}
    }

  return;
}

int KeySet::Eq(KeySet *y)
{
  if (elements_ != y->elements_)
    {
      return 0;
    }

  if ((Subset(y) == 0) || (y->Subset(this) == 0))
    {
      return 0;
    }
  
  return 1;
}
    
int KeySet::Subset(KeySet *y)
{
  if (y->elements_ > elements_)
    {
      return 0;
    }

  for (int i = 0; i < y->buckets_ ; i++)
    {
      BucketList *p;
      for( p = y->htab_[i] ; p != NULL ; p = p->next_)
	{
	  if (Lookup(p->key_) == NULL)
	    {
	      return 0;
	    }
	}
    }

  return 1;
}

void KeySet::Add(char *key, char *element = NULL)
{
  LookupInsertNotFound(key, element);
}

int KeySet::Member(char *key)
{
  if (Lookup(key) == NULL)
    {
      return 0;
    }
  return 1;
}


void KeySet::Pp(char *desc = NULL)
{
  if (desc == NULL)
    {
      printf("This set ");
    }
  else
    {
      printf("%s ", desc);
    }
  
  printf("has %d elements. ( ",elements_);

  for (int i = 0; i < buckets_ ; i++)
    {
      BucketList *p;
      for( p = htab_[i] ; p != NULL ; p = p->next_)
	{
	  if (p->element_ != NULL)
	    {
	      printf("%s:%s ",p->key_,p->element_);
	    }
	  else
	    {
	      printf("%s ",p->key_);
	    }
	}
    }
  printf(")\n");
}

char *KeySet::SetToList()
{
  int size = 0;
  int i;

  if (elements_ == 0)
    {
      char *c = new char[1];
      *c = '\0';
      return c;
    }

  size += 1;			// for the empty-string

  for (i = 0; i < buckets_ ; i++)
    {
      BucketList *p;
      for (p = htab_[i] ; p != NULL ; p = p->next_)
	{
	  if (p->element_ != NULL)
	    {
	      size ++ ;		// for "{"
	      size += strlen(p->element_) + 2; // for "element} "
	    }
	  size += strlen(p->key_) + 1; // for "$key "
	}
    }
  size--;			// remove extra space

  char *string = new char[size];
  char *c = string;

  for (i = 0; i < buckets_ ; i++)
    {
      BucketList *p;
      for (p = htab_[i] ; p != NULL ; p = p->next_)
	{
	  if (p->element_ != NULL)
	    {
	      *c = '{';
	      c ++;
	    }
	  strcpy(c,p->key_);
	  size = strlen(p->key_);
	  c = c+size;
	  *c = ' ';
	  c++;

	  if (p->element_ != NULL)
	    {
	      strcpy(c,p->element_);
	      c += strlen(p->element_);
	      strcpy(c,"} ");
	      c += 2;
	    }
	}
    }
  c--;
  *c = '\0';
  return string;
}