source: trunk/gsinstaller/gsManifest.cpp@ 1397

#include "gsManifest.h"
#include "fileCopier.h"

#include <string.h>
#include <stdio.h>

#include <windows.h>

gsManifest::gsManifest(FilePath &root)
{   this->getManifest(root);
    this->expandGroups();
}

bool gsManifest::getManifest(FilePath &root)
{ FilePath *manifestPath = new FilePath((char *) root.cString(), "manifest.cfg");
    FILE *    file;
  DWORD         fileSize;
  string        currentgroup;
  char *        buffer;
  char *        line;
  char *        eol;

    // open file handle for read access
  file = fopen(manifestPath->cString(), "rb");
    if (file == NULL)
  { return false;
  }

  // get size of file
  File f(manifestPath->cString());
  fileSize  = f.getFileSize();

  // allocate buffer for whole file and read it in
    buffer  = new char[fileSize];
  if (fread(buffer, 1, fileSize, file) < fileSize)
  { // TODO: error handling
  }
  fclose(file);

  //parse file into lines and send to the line fn
  line  = buffer;
  while ((eol = strchr(line, '\x0a')) != NULL)  // use 0a for the eol to remove
                                                // dependency on dos 0d,0a eol
  { *eol = '\0';

    this->getManifestLine(line, currentgroup);

    line = eol + 1;
  }
  this->getManifestLine(line, currentgroup);

    delete buffer;
  return true;
}

bool gsManifest::getManifestLine(char *line, string &group)
{ char *eol;    // we (potentially) need to clean up the end of
              // line, and we won't use the eol from the main
              // getManifest fn. as for the last line it'd be
              // null.

    // clean up the start of the line
    while (*line <= ' ' && *line != '\0')
    { line ++;
  }

  // it's a blank line - don't bother!
  if (line == '\0')
  { return true;
  }

  // clean up the end of line
  eol   = line + strlen(line) - 1;
  while (*eol <= ' ' && eol >= line)
  { *eol = '\0';
    eol --;
  }

  // does the line end with a colon?; if so take it as a group definition
  if (*eol == ':')
  { if (eol == line) // if it's literally just a colon do nothing
    {   return true;
    }

    // note the new group name
    string newgroup(line, 0, eol - line);
    group = newgroup;
  }
  else
  { stringArray array;
    array   =   stringArray::words(line);

    if (group.length() == 0)
    {   this->manifests["all"].add(array);
    }
    else
    {   this->manifests[group].add(array);
    }
  }
  return true;
}

/**
 * Expand all groups
 */
void gsManifest::expandGroups()
{   strArrayMap::iterator here = this->manifests.begin();
  strArrayMap::iterator end = this->manifests.end();

  while (here != end)
  { this->expandGroup((*here).first);
    here ++;
  }
}

/**
 * expand a particular group
 */
void gsManifest::expandGroup(string &group)
{   stringArray &array = this->manifests[group];

    unsigned int i = 0;
  while (i < array.size())
  { if (this->isGroup(array[i]))
    {   this->expandGroupInstance(group, array[i]);
    }
    else
    {   i ++;
    }
  }
}

/**
 * expand a group instance inside a given group
 */
void gsManifest::expandGroupInstance(string parentgroup, string groupName)
{ // remove the group instance from the parent
    this->manifests[parentgroup].remove(groupName);

    // create a "clean" name without the { } brackets
    string group(groupName, 1, groupName.length() - 2);

  // circular reference - we're kind and ignore it!!
  if (parentgroup.compare(group) == 0)
  { return;
  }

  // lookup chidl group and add it to the parent
    this->manifests[parentgroup].add(this->manifests[group]);
}

/**
 * Check if a member of a group is itself a group - look for { } brackets
 * around the name
 */
bool gsManifest::isGroup(string &name)
{ if (name[0] == '{' && name[name.length()-1] == '}')
    {   return true;
  }
    return false;
}

void gsManifest::expandMacro(string macro, string value)
{   string macroRef = "\$(" + macro + ")";

  strArrayMap::iterator here = this->manifests.begin();
  strArrayMap::iterator end = this->manifests.end();

  while (here != end)
  { stringArray &array = this->manifests[(*here).first];

    unsigned int i = 0;
    while (i < array.size())
    { unsigned int pos;
        while ((pos = array[i].find(macroRef)) < array[i].length() && pos != -1)
            {   array[i].replace(pos, macroRef.length(), value);
      }
      i ++;
    }
    here ++;
  }
}

void gsManifest::clearSelection()
{   this->selected.empty();
}

void gsManifest::selectGroup(string &groupName, FilePath &destination)
{ stringArray &groupArray = this->manifests[groupName];

    groupArray  = this->manifests[groupName];
  this->selected[destination].add(groupArray);
}

bool gsManifest::copy(FilePath *source)
{ fileCopier    copy;

    pathStringArrayMap::iterator here = this->selected.begin();
  pathStringArrayMap::iterator end  = this->selected.end();

  while (here != end)
  { FileVector *fileList;
    stringArray &array = (*here).second;
    FilePath path((*here).first);

    // TODO: eliminate inefficiency; we're doing FilePath->string->FilePath in
    // effect between constructing the copy lists, and then the sets as far
    // as the destinations go
    fileList = this->selection(array);
    fileCopySet copySet(*fileList, *source, path);
    copy.addSet(copySet);
        delete fileList;
    here ++;
  }

  if (!copy.checkSpace())
  { return false;
  }
  copy.copy();
  return true;
}

FileVector *gsManifest::selection(stringArray &array)
{   FileVector *reply = new FileVector();

  for (unsigned int i = 0; i < array.size(); i++)
  { File file(array[i]);
    reply->push_back(file);
  }
  return reply;
}

FileVector *gsManifest::selection(FilePath &destination)
{   return this->selection(this->selected[destination]);
}