<!--
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.
-->
<img src="images/tinkerpop-conference.png" class="img-responsive" />
<div class="container">
   <div class="hero-unit" style="padding:10px">
      <b><font size="5" face="american typewriter">Apache TinkerPop&trade;</font></b>
      <p><font size="5">Provider Listing and Graphic Usage Policies</font></p>
   </div>
</div>
<div class="container-fluid">
   <div class="container">
      <a name="provider-listing-policy"></a>
      <h3>Provider Listing Policy</h3>
      <p>Graph system and language providers can have the project listed in two locations on the Apache TinkerPop homepage.
         The first location is on the homepage <a href="index.html">index.html</a>. The second is on the homepage <a href="providers.html">providers.html</a>. The policies
         for each are provided below. Note that the Apache Software Foundation's <a href="http://www.apache.org/foundation/marks/linking">linking policy</a> supercede those
         stipulated by Apache TinkerPop. All things considered, if your project meets the requirements, please email Apache TinkerPop's
         <a href="http://mail-archives.apache.org/mod_mbox/incubator-tinkerpop-dev/">developer mailing list</a> requesting that your project be added to a listing.
      </p>
      <h4>Index Listing Requirements</h4>
      <ul>
         <li>The project must be either a TinkerPop-enabled graph system, a Gremlin language variant/compiler, a Gremlin language driver, or a TinkerPop-enabled middleware tool.</li>
         <li>The project must have a public URL that can be referenced by Apache TinkerPop.</li>
         <li>The project must have at least one release.</li>
         <li>The project must be actively developed/maintained to a current or previous "y" version of Apache TinkerPop (3.y.z).</li>
         <li>The project must have <em>some</em> documentation and that documentation must make explicit its usage of Apache TinkerPop and its version compatibility requirements.</li>
      </ul>
      <h4>Provider Listing Requirements</h4>
      <ul>
         <li>The project must be either a TinkerPop-enabled graph system, a Gremlin language variant/compiler, or a TinkerPop-enabled tool.</li>
         <li>The project must have a public URL that can be referenced by Apache TinkerPop.</li>
         <li>The project must have a homepage that is not simply a software repository page.</li>
         <li>The project must have a high-resolution logo that can be used by Apache TinkerPop.</li>
         <li>The project must have at least one release.</li>
         <li>The project must be actively developed/maintained to a current or previous "y" version of Apache TinkerPop (3.y.z).</li>
         <li>The project must have <em>significant</em> documentation and that documentation must make explicit its usage of Apache TinkerPop and its version compatibility requirements.</li>
      </ul>
   </div>
   <div class="container">
      <a name="graphic-usage-policy"></a>
      <h3>Graphic Usage Policy</h3>
      <p>Apache TinkerPop has a plethora of graphics that the community can use. There are four categories of graphics. These categories and their respective policies are presented
         below. If you are unsure of the category of a particular graphic, please ask on our <a href="http://mail-archives.apache.org/mod_mbox/incubator-tinkerpop-dev/">developer mailing</a>
         list before using it. Finally, note that the Apache Software Foundation's <a href="http://www.apache.org/foundation/marks/">trademark policies</a> supercede those stipulated
         by Apache TinkerPop.
      </p>
      <ul>
         <li><strong>Character Graphics</strong>: A character graphic can be used <em>without permission</em> as long as its being used in an Apache TinkerPop related context and it is acknowledged that the graphic is a trademark of the Apache Software Foundation/Apache TinkerPop.</li>
         <img src="images/policy/pipes-character.png" style="padding:10px;width:9%;"/> <img src="images/policy/rexster-character.png" style="padding:10px;width:9%;"/> <img src="images/policy/gremlin-character.png" style="padding:10px;width:9%;"/> <img src="images/policy/blueprints-character.png" style="padding:10px;width:9%;"/> <img src="images/policy/furnace-character.png" style="padding:10px;width:9%;"/> <img src="images/policy/frames-character.png" style="padding:10px;width:9%;"/>
         <li><strong>Character Dress-Up Graphics</strong>: A character graphic can be manipulated ("dressed up") and used <em>without permission</em> as long as it's being used in an Apache TinkerPop related context and it is acknowledged that the graphic is a trademark of the Apache Software Foundation/Apache TinkerPop.</li>
         <img src="images/policy/gremlin-gremopoly.png" style="padding:10px;width:10%;"/> <img src="images/policy/gremlin-gremreaper.png" style="padding:10px;width:14%;"/> <img src="images/policy/gremlin-chickenwing.png" style="padding:10px;width:10%;"/> <img src="images/policy/gremlin-no-more-mr-nice-guy.png" style="padding:10px;width:10%;"/> <img src="images/policy/gremlin-new-sheriff-in-town.png" style="padding:10px;width:12%;"/> <img src="images/policy/gremlin-gremstefani.png" style="padding:10px;width:10%;"/>
         <li><strong>Explanatory Diagrams</strong>: Explanatory diagrams can be used <em>without permission</em> as long as they are being used in an Apache TinkerPop related context, it is acknowledged that they are trademarks of the Apache Software Foundation/Apache TinkerPop, and are being used for technical explanatory purposes.</li>
         <img src="images/policy/olap-traversal.png" style="padding:10px;width:22%;"/> <img src="images/policy/cyclicpath-step.png" style="padding:10px;width:22%;"/> <img src="images/policy/flat-map-lambda.png" style="padding:10px;width:15%;"/> <img src="images/policy/adjacency-list.png" style="padding:10px;width:22%;"/>
         <li><strong>Character Scene Graphics</strong>: Character scene graphics <u><em>require permission</em></u> before being used. Please ask for permission on the Apache TinkerPop <a href="http://mail-archives.apache.org/mod_mbox/incubator-tinkerpop-dev/">developer mailing list</a>.</li>
         <img src="images/policy/tinkerpop-reading.png" style="padding:10px;width:20%;"/> <img src="images/policy/gremlintron.png" style="padding:10px;width:20%;"/> <img src="images/policy/business-gremlin.png" style="padding:10px;width:20%;"/> <img src="images/policy/tinkerpop3-splash.png" style="padding:10px;width:20%;"/>
      </ul>
   </div>
</div>
