Lisp Routine to Automatically Apply Project Updates (does it sound possible)

[Anonymous]

First, an explanation of how things work here.  We model files, called masters, that we always keep up to date. When a project has to be done a copy of the master files needed are copied to whatever project folder and it is those model files that get edited in the beginning for doing the design.  Any demo work will end in "-demo" and new work in "-neww".  When the project is finally constructed and redlines returned then the process is as follows: update the project folder to reflect what was actually done and then update masters. Since many changes occur to our masters before a design may be implemented you can't just copy the project file over and wipe out the masters; essentially you have to rebuild the project in the masters.  You look at what got demo'd (as evidenced by the -demo layer) and back to what point and have to remove those objects or break a line at places; a lot of what we have are building modifications.

What I would like to do could almost be done using overkill. If I did a copybase and pasted the demo work into the master file and would have many overlapping lines.  I would then want to use overkill to remove the lines that end in -exst layers (for existing) and keep the lines/objects ending in xxx-demo. I would then use filter and remove the "xxx-demo" layers and all that would be left is to copybase and paste the xxx-neww layers in and onto there "xxx" name.  So if I have layer pipe-neww and "light-neww" it would paste them in, filter all that's on pipe-neww and place those on pipe layer and so "light-neww" would be place be filtered and placed on "light" layer.

This would work if overkill could wipe out just a portion of a line.  We will, for instance demo pipe back to a point and then connect a new pipe so if there's a long line we would have broken the line in the master file and shown whatever portion as -demo.  Does anyone believe this can be done with a lisp routine.  I would invision the lisp routine would work as follows:

1. lisp asks for location and name of file to be edited

2. lisp asks for most recent update file (project file)

3. lisp turns on all layers in both files

4. lisp selects all demo layers (ending in -demo) from project file, by way of filter I imagine, performs a copybase at 0,0, and then pastes all the demo layers into the masters at 0,0

5. lisp performs the overkill command only allowing removal of things with similar names discluding the last 5 characters (i.e. ThisIsAMatch-exst and ThisIsAMatch-demo are the same); it would wipeout the existing layer and keep demo.

6. lisp would remove demo layer, I imagine by filter.

7. lisp selects all new work layers in project file via same method listed in #4 and pastes in master file

8. lisp places all new work onto the respective existing layer (i.e. ThisIsAMatch-neww get filtered and changed to ThisIsAMatch-exst)

9. lisp responds that it is finished.

If this is not possible, then is it possible to have a lisp apply the same breaks that one project has to another.  This would then allow me to do overkill manually.  In other words, in project file I broke the long line into two lines so the lisp would make those same breaks in the master when I execute it.

Thanks, sorry for the length.