#ifndef ARRAYUTILS_H
#define ARRAYUTILS_H



//  Add to the end
//  - Assumes that we have a separate integer (size) indicating how
//     many elements are in the array
//  - and that the "true" size of the array is at least one larger 
//      than the current value of that counter
template <typename T>
void addToEnd (T* array, int& size, T value)
{
   array[size] = value;
   ++size;
}



// Add value into array[index], shifting all elements already in positions
//    index..size-1 up one, to make room.
//  - Assumes that we have a separate integer (size) indicating how
//     many elements are in the array
//  - and that the "true" size of the array is at least one larger 
//      than the current value of that counter

template <typename T>
void addElement (T* array, int& size, int index, T value)
{
  // Make room for the insertion
  int toBeMoved = size - 1;
  while (toBeMoved >= index) {
    array[toBeMoved+1] = array[toBeMoved];
    --toBeMoved;
  }
  // Insert the new value
  array[index] = value;
  ++size;
}


// Assume the elements of the array are already in order
// Find the position where value could be added to keep
//    everything in order, and insert it there.
// Return the position where it was inserted
//  - Assumes that we have a separate integer (size) indicating how
//     many elements are in the array
//  - and that the "true" size of the array is at least one larger 
//      than the current value of that counter

template <typename T>
int addInOrder (T* array, int& size, T value)
{
  // Make room for the insertion
  int toBeMoved = size - 1;
  while (toBeMoved >= 0 && value < array[toBeMoved]) {
    array[toBeMoved+1] = array[toBeMoved];
    --toBeMoved;
  }
  // Insert the new value
  array[toBeMoved+1] = value;
  ++size;
  return toBeMoved+1;
}


// Search an array for a given value, returning the index where 
//    found or -1 if not found.
template <typename T>
int seqSearch(const T list[], int listLength, T searchItem)
{
    int loc;

    for (loc = 0; loc < listLength; loc++)
        if (list[loc] == searchItem)
            return loc;

    return -1;
}


// Search an ordered array for a given value, returning the index where 
//    found or -1 if not found.
template <typename T>
int seqOrderedSearch(const T list[], int listLength, T searchItem)
{
    int loc = 0;

    while (loc < listLength && list[loc] < searchItem)
      {
       ++loc;
      }
    if (loc < listLength && list[loc] == searchItem)
       return loc;
    else
       return -1;
}


// Removes an element from the indicated position in the array, moving
// all elements in higher positions down one to fill in the gap.
template <typename T>
void removeElement (T* array, int& size, int index)
{
  int toBeMoved = index + 1;
  while (toBeMoved < size) {
    array[toBeMoved] = array[toBeMoved+1];
    ++toBeMoved;
  }
  --size;
}



// Search an ordered array for a given value, returning the index where 
//    found or -1 if not found.
template <typename T>
int binarySearch(const T list[], int listLength, T searchItem)
{
    int first = 0;
    int last = listLength - 1;
    int mid;

    bool found = false;

    while (first <= last && !found)
    {
        mid = (first + last) / 2;

        if (list[mid] == searchItem)
            found = true;
        else 
            if (searchItem < list[mid])
                last = mid - 1;
            else
                first = mid + 1;
    }

    if (found) 
        return mid;
    else
        return -1;
}





#endif

#include <cassert>
#include <iostream>
#include <sstream>
#include <string>

#include "arrayUtils.h"

using namespace std;



// Unit test driver for array search functions





int main(int argc, char** argv)
{
  // Repeatedly reads tests from cin
  // Each test consists of a line containing one or more words. 
  // The first word is one that we want to search for. The
  // remaining words are placed into an array and represent the collection
  // we will search through.

  string line;
  getline (cin, line);
  while (cin)
    {
      istringstream in (line);
      cout << line << endl;
      string toSearchFor;
      in >> toSearchFor;
      int nWords = 0;
      string words[100];
      while (in >> words[nWords])
    ++nWords;
      
      cout << seqSearch (words, nWords, toSearchFor)
       << " "
       << seqOrderedSearch (words, nWords, toSearchFor)
       << " "
       << binarySearch (words, nWords, toSearchFor)
       << endl;

      getline (cin, line);
    }

  return 0;
}

<project name="codeAnnotation" basedir="." default="build"
     xmlns:ivy="antlib:org.apache.ivy.ant"
     xmlns:jacoco="antlib:org.jacoco.ant"
>

  <record name="ant.log" action="start" append="false" />
    
  <path id="testCompilationPath">
    <fileset dir="lib" includes="*.jar"/>
    <pathelement path="target/classes"/>
  </path>

  <path id="testExecutionPath">
    <fileset dir="lib" includes="*.jar"/>
    <pathelement path="target/classes"/>
    <pathelement path="target/test-classes"/>
  </path>


  <property name="ivy.install.version" value="2.3.0"/>
  <property name="jsch.install.version" value="0.1.49"/>
  <property name="ivy.jar.dir" value="${basedir}/ivy"/>
  <property name="ivy.jar.file" value="${ivy.jar.dir}/ivy.jar"/>
  <property name="jsch.jar.file" value="${ivy.jar.dir}/jsch.jar"/>
  <property name="build.dir" value="build"/>
  <property name="src.dir" value="src"/>

  <target name="download-ivy" unless="skip.download">
    <mkdir dir="${ivy.jar.dir}"/>
    <echo message="installing ivy..."/>
    <get src="http://repo1.maven.org/maven2/org/apache/ivy/ivy/${ivy.install.version}/ivy-${ivy.install.version}.jar" 
     dest="${ivy.jar.file}" usetimestamp="true"/>
  </target>

  <target name="download-jsch" unless="skip.download">
    <mkdir dir="${ivy.jar.dir}"/>
    <echo message="installing jsch..."/>
    <get src="http://repo1.maven.org/maven2/com/jcraft/jsch/${jsch.install.version}/jsch-${jsch.install.version}.jar" 
     dest="${jsch.jar.file}" usetimestamp="true"/>
  </target>
    
  <target name="install-jsch" depends="download-jsch">
  </target>
    
  <target name="install-ivy" depends="download-ivy" 
      description="--> install ivy">
    <path id="ivy.lib.path">
      <fileset dir="${ivy.jar.dir}" includes="*.jar"/>
    </path>
    <taskdef resource="org/apache/ivy/ant/antlib.xml" 
         uri="antlib:org.apache.ivy.ant" classpathref="ivy.lib.path"/>
  </target>

  <target name="resolve-ivy" depends="install-ivy,install-jsch" description="Resolve library dependencies">
    <ivy:retrieve/>
    <echo>ivy.default.ivy.user.dir is ${ivy.default.ivy.user.dir}</echo>
    <taskdef uri="antlib:org.jacoco.ant" resource="org/jacoco/ant/antlib.xml"> ➊
        <classpath refid="testExecutionPath"/>
    </taskdef>
    <taskdef classname="JFlex.anttask.JFlexTask" name="jflex">
        <classpath refid="testExecutionPath"/>
    </taskdef>
  </target>

  <target name="generateSource" depends="resolve-ivy">
    <mkdir dir="target/gen/java"/>
    <jflex file="src/main/jflex/code2html.flex"
       destdir="target/gen/java"/>
    <jflex file="src/main/jflex/code2tex.flex"
       destdir="target/gen/java"/>
    <jflex file="src/main/jflex/list2html.flex"
       destdir="target/gen/java"/>
    <jflex file="src/main/jflex/list2tex.flex"
       destdir="target/gen/java"/>
  </target>
  

  <target name="compile" depends="generateSource">   ➋
    <mkdir dir="target/classes"/>
    <javac srcdir="target/gen/java" destdir="target/classes" debug="true"
       source="1.6" includeantruntime="false"/>
    <javac srcdir="src/main/java" destdir="target/classes" debug="true"
       source="1.6" includeantruntime="false"/>
  </target>

  <target name="compile-tests" depends="compile">
    <mkdir dir="target/test-classes"/>
    <javac srcdir="src/test/java" destdir="target/test-classes" debug="true"
       source="1.6" includeantruntime="false">
      <classpath refid="testCompilationPath"/>
    </javac>
  </target>

  <target name="test" depends="compile-tests">
    <mkdir dir="target/test-results/details"/>
    <jacoco:coverage destfile="target/jacoco.exec">    ➌
      <junit printsummary="yes" 
         haltonfailure="yes" fork="yes"
         >
    <classpath refid="testExecutionPath"/>
    <formatter type="xml"/>
    <batchtest todir="target/test-results/details">
      <fileset dir="target/test-classes">
        <include name="**/*Test*.class"/>
      </fileset>
    </batchtest>
      </junit>
    </jacoco:coverage>
    <junitreport todir="target/test-results">
      <fileset dir="target/test-results/details">
        <include name="TEST-*.xml"/>
      </fileset>
      <report format="frames" todir="target/test-results/html"/>
    </junitreport>
  </target>

  <target name="coverageReport" depends="test">
    <jacoco:report>                ➍
        <executiondata>
            <file file="target/jacoco.exec"/>  ➎
        </executiondata>
                           
    <structure name="Code Annotation Project"> ➏
      <classfiles>
        <fileset dir="target/classes"/>
        <fileset dir="target/test-classes"/>
      </classfiles>
      <sourcefiles encoding="UTF-8">
        <fileset dir="src/main/java"/>
        <fileset dir="src/test/java"/>
        <fileset dir="target/gen/java"/>
      </sourcefiles>
        </structure>
                           
        <html destdir="target/coverageReport"/>   ➐
                           
    </jacoco:report>
  </target>

  <target name="build"  depends="coverageReport">
    <jar destfile="codeAnnotation.jar" basedir="target/classes">
        <manifest>
            <attribute name="Main-Class"
                       value="edu.odu.cs.code2html.Code2HTML"/>
        </manifest>
    </jar>
    <zip destfile="target/codeAnnotation-src.zip">
      <fileset dir=".">
        <include name="*.xml"/>
        <include name="test.cpp"/>
        <include name="*.css.cpp"/>
        <include name="src/**/*"/>
        <exclude name="**/*~"/>
        <exclude name="target/**/*"/>
      </fileset>
    </zip>
  </target>

  <target name="publish" depends="build">
    <ivy:retrieve/>
    <ivy:publish resolver="Forge350Publish"
         status="release"
         update="true"
         overwrite="true"
         publishivy="true">
      <artifacts pattern="[artifact].[ext]"/>
    </ivy:publish>
  </target>

  <target name="clean">
    <delete dir="target"/>
  </target>

  <target name="cleaner" depends="clean">
    <delete dir="lib"/>
  </target>

  <target name="cleanest" depends="cleaner">
    <delete dir="ivy"/>
  </target>
  
</project>