 ------
 Overview of SCM's
 ------
 Wim Deblauwe
 ------
 2005-12-01
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Overview of SCM's

  Maven SCM supports many SCM's. This is a list of all currently known SCM's:

* Fully implemented SCM's

  * {{{./bazaar.html}Bazaar}}

  * {{{./cvs.html}CVS}}

  * {{{./git.html}Git}}

  * {{{./jazz.html}Jazz}}

  * {{{./mercurial.html}Mercurial}}

  * {{{./perforce.html}Perforce}}

  * {{{./starteam.html}StarTeam}}

  * {{{./subversion.html}Subversion}}

  * {{{./synergy.html}CM Synergy}}

* Partially implemented SCM's

  * {{{./accurev.html}Accurev}}

  * {{{./clearcase.html}ClearCase}}

  * {{{./local.html}File system}}

  * {{{./vss.html}Visual Source Safe}}

  * {{{./tfs.html}Team Foundation Server}}

* Not implemented SCM's

    This is a list of all the known SCM's that are not implemented currently.

  * Aegis

  * Arch

  * BitKeeper

  * ClearCase Multisite

  * Code Co-op

  * Darcs

  * Monotone

  * OpenCM

  * PureCM

  * Serena PVCS / Dimension

  * Starteam Enterprise

  * Svk

  * Vesta
