Add in the basic CMake Infrastructure required for vtkm.

CMake/CheckCXX11Features.cmake

@@ -0,0 +1,142 @@
+# - Check which parts of the C++11 standard the compiler supports
+#
+# When found it will set the following variables
+#
+#  CXX11_COMPILER_FLAGS         - the compiler flags needed to get C++11 features
+#
+#  HAS_CXX11_AUTO               - auto keyword
+#  HAS_CXX11_AUTO_RET_TYPE      - function declaration with deduced return types
+#  HAS_CXX11_CLASS_OVERRIDE     - override and final keywords for classes and methods
+#  HAS_CXX11_CONSTEXPR          - constexpr keyword
+#  HAS_CXX11_CSTDINT_H          - cstdint header
+#  HAS_CXX11_DECLTYPE           - decltype keyword
+#  HAS_CXX11_FUNC               - __func__ preprocessor constant
+#  HAS_CXX11_INITIALIZER_LIST   - initializer list
+#  HAS_CXX11_LAMBDA             - lambdas
+#  HAS_CXX11_LIB_REGEX          - regex library
+#  HAS_CXX11_LONG_LONG          - long long signed & unsigned types
+#  HAS_CXX11_NULLPTR            - nullptr
+#  HAS_CXX11_RVALUE_REFERENCES  - rvalue references
+#  HAS_CXX11_SIZEOF_MEMBER      - sizeof() non-static members
+#  HAS_CXX11_STATIC_ASSERT      - static_assert()
+#  HAS_CXX11_VARIADIC_TEMPLATES - variadic templates
+
+#=============================================================================
+# Copyright 2011,2012 Rolf Eike Beer <eike@sf-mail.de>
+# Copyright 2012 Andreas Weis
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+#
+# Each feature may have up to 3 checks, every one of them in it's own file
+# FEATURE.cpp              - example that must build and return 0 when run
+# FEATURE_fail.cpp         - example that must build, but may not return 0 when run
+# FEATURE_fail_compile.cpp - example that must fail compilation
+#
+# The first one is mandatory, the latter 2 are optional and do not depend on
+# each other (i.e. only one may be present).
+#
+
+if (NOT CMAKE_CXX_COMPILER_LOADED)
+    message(FATAL_ERROR "CheckCXX11Features modules only works if language CXX is enabled")
+endif ()
+
+cmake_minimum_required(VERSION 2.8.3)
+
+#
+### Check for needed compiler flags
+#
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag("-std=c++11" _HAS_CXX11_FLAG)
+if (NOT _HAS_CXX11_FLAG)
+    check_cxx_compiler_flag("-std=c++0x" _HAS_CXX0X_FLAG)
+endif ()
+
+if (_HAS_CXX11_FLAG)
+    set(CXX11_COMPILER_FLAGS "-std=c++11")
+elseif (_HAS_CXX0X_FLAG)
+    set(CXX11_COMPILER_FLAGS "-std=c++0x")
+endif ()
+
+function(cxx11_check_feature FEATURE_NAME RESULT_VAR)
+    if (NOT DEFINED ${RESULT_VAR})
+        set(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11_${FEATURE_NAME}")
+
+        set(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/CheckCXX11Features/cxx11-test-${FEATURE_NAME})
+        set(_LOG_NAME "\"${FEATURE_NAME}\"")
+        message(STATUS "Checking C++11 support for ${_LOG_NAME}")
+
+        set(_SRCFILE "${_SRCFILE_BASE}.cpp")
+        set(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp")
+        set(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp")
+
+        if (CROSS_COMPILING)
+            try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}"
+                        COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+                try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}"
+                            COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+        else (CROSS_COMPILING)
+            try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+                    "${_bindir}" "${_SRCFILE}"
+                    COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+                set(${RESULT_VAR} TRUE)
+            else (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+                set(${RESULT_VAR} FALSE)
+            endif (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR)
+            if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+                try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR
+                        "${_bindir}_fail" "${_SRCFILE_FAIL}"
+                         COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+                if (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+                    set(${RESULT_VAR} TRUE)
+                else (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+                    set(${RESULT_VAR} FALSE)
+                endif (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR)
+            endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL})
+        endif (CROSS_COMPILING)
+        if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+            try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}"
+                        COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}")
+            if (_TMP_RESULT)
+                set(${RESULT_VAR} FALSE)
+            else (_TMP_RESULT)
+                set(${RESULT_VAR} TRUE)
+            endif (_TMP_RESULT)
+        endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE})
+
+        if (${RESULT_VAR})
+            message(STATUS "Checking C++11 support for ${_LOG_NAME}: works")
+        else (${RESULT_VAR})
+            message(STATUS "Checking C++11 support for ${_LOG_NAME}: not supported")
+        endif (${RESULT_VAR})
+        set(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}")
+    endif (NOT DEFINED ${RESULT_VAR})
+endfunction(cxx11_check_feature)
+
+cxx11_check_feature("__func__" HAS_CXX11_FUNC)
+cxx11_check_feature("auto" HAS_CXX11_AUTO)
+cxx11_check_feature("auto_ret_type" HAS_CXX11_AUTO_RET_TYPE)
+cxx11_check_feature("class_override_final" HAS_CXX11_CLASS_OVERRIDE)
+cxx11_check_feature("constexpr" HAS_CXX11_CONSTEXPR)
+cxx11_check_feature("cstdint" HAS_CXX11_CSTDINT_H)
+cxx11_check_feature("decltype" HAS_CXX11_DECLTYPE)
+cxx11_check_feature("initializer_list" HAS_CXX11_INITIALIZER_LIST)
+cxx11_check_feature("lambda" HAS_CXX11_LAMBDA)
+cxx11_check_feature("long_long" HAS_CXX11_LONG_LONG)
+cxx11_check_feature("nullptr" HAS_CXX11_NULLPTR)
+cxx11_check_feature("regex" HAS_CXX11_LIB_REGEX)
+cxx11_check_feature("rvalue-references" HAS_CXX11_RVALUE_REFERENCES)
+cxx11_check_feature("sizeof_member" HAS_CXX11_SIZEOF_MEMBER)
+cxx11_check_feature("static_assert" HAS_CXX11_STATIC_ASSERT)
+cxx11_check_feature("variadic_templates" HAS_CXX11_VARIADIC_TEMPLATES)

CMake/CheckCXX11Features/cxx11-test-__func__.cpp

@@ -0,0 +1,8 @@
+int main(void)
+{
+	if (!__func__)
+		return 1;
+	if (!(*__func__))
+		return 1;
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-auto.cpp

@@ -0,0 +1,12 @@
+
+int main()
+{
+	auto i = 5;
+	auto f = 3.14159f;
+	auto d = 3.14159;
+	bool ret = (
+		(sizeof(f) < sizeof(d)) &&
+		(sizeof(i) == sizeof(int))
+	);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp

@@ -0,0 +1,7 @@
+int main(void)
+{
+	// must fail because there is no initializer
+	auto i;
+
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-auto_ret_type.cpp

@@ -0,0 +1,8 @@
+auto foo(int i) -> int {
+	return i - 1;
+}
+
+int main()
+{
+	return foo(1);
+}

CMake/CheckCXX11Features/cxx11-test-class_override_final.cpp

@@ -0,0 +1,21 @@
+class base {
+public:
+    virtual int foo(int a)
+     { return 4 + a; }
+    int bar(int a) final
+     { return a - 2; }
+};
+
+class sub final : public base {
+public:
+    virtual int foo(int a) override
+     { return 8 + 2 * a; };
+};
+
+int main(void)
+{
+    base b;
+    sub s;
+
+    return (b.foo(2) * 2 == s.foo(2)) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp

@@ -0,0 +1,25 @@
+class base {
+public:
+    virtual int foo(int a)
+     { return 4 + a; }
+    virtual int bar(int a) final
+     { return a - 2; }
+};
+
+class sub final : public base {
+public:
+    virtual int foo(int a) override
+     { return 8 + 2 * a; };
+    virtual int bar(int a)
+     { return a; }
+};
+
+class impossible : public sub { };
+
+int main(void)
+{
+    base b;
+    sub s;
+
+    return 1;
+}

CMake/CheckCXX11Features/cxx11-test-constexpr.cpp

@@ -0,0 +1,19 @@
+constexpr int square(int x)
+{
+	return x*x;
+}
+
+constexpr int the_answer()
+{
+	return 42;
+}
+
+int main()
+{
+	int test_arr[square(3)];
+	bool ret = (
+		(square(the_answer()) == 1764) &&
+		(sizeof(test_arr)/sizeof(test_arr[0]) == 9)
+	);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-cstdint.cpp

@@ -0,0 +1,11 @@
+#include <cstdint>
+
+int main()
+{
+	bool test =
+		(sizeof(int8_t) == 1) &&
+		(sizeof(int16_t) == 2) &&
+		(sizeof(int32_t) == 4) &&
+		(sizeof(int64_t) == 8);
+	return test ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-decltype.cpp

@@ -0,0 +1,10 @@
+bool check_size(int i)
+{
+	return sizeof(int) == sizeof(decltype(i));
+}
+
+int main()
+{
+	bool ret = check_size(42);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-initializer_list.cpp

@@ -0,0 +1,27 @@
+#include <vector>
+
+class seq {
+public:
+    seq(std::initializer_list<int> list);
+
+    int length() const;
+private:
+    std::vector<int> m_v;
+};
+
+seq::seq(std::initializer_list<int> list)
+    : m_v(list)
+{
+}
+
+int seq::length() const
+{
+    return m_v.size();
+}
+
+int main(void)
+{
+    seq a = {18, 20, 2, 0, 4, 7};
+
+    return (a.length() == 6) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-lambda.cpp

@@ -0,0 +1,5 @@
+int main()
+{
+	int ret = 0;
+	return ([&ret]() -> int { return ret; })();
+}

CMake/CheckCXX11Features/cxx11-test-long_long.cpp

@@ -0,0 +1,7 @@
+int main(void)
+{
+	long long l;
+	unsigned long long ul;
+
+	return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-nullptr.cpp

@@ -0,0 +1,6 @@
+int main(void)
+{
+	void *v = nullptr;
+
+	return v ? 1 : 0;
+}

CMake/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp

@@ -0,0 +1,6 @@
+int main(void)
+{
+	int i = nullptr;
+
+	return 1;
+}

CMake/CheckCXX11Features/cxx11-test-regex.cpp

@@ -0,0 +1,26 @@
+#include <algorithm>
+#include <regex>
+
+int parse_line(std::string const& line)
+{
+	std::string tmp;
+	if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+//(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+//(-)?(\\d)+"), std::string("V"));
+	} else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+"), std::string("V"));
+	} else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+"), std::string("V"));
+	} else {
+		tmp = std::regex_replace(line, std::regex("(-)?(\\d)+"), std::string("V"));
+	}
+	return static_cast<int>(std::count(tmp.begin(), tmp.end(), 'V'));
+}
+
+int main()
+{
+	bool test = (parse_line("f 7/7/7 -3/3/-3 2/-2/2") == 3) &&
+				(parse_line("f 7//7 3//-3 -2//2") == 3) &&
+				(parse_line("f 7/7 3/-3 -2/2") == 3) &&
+				(parse_line("f 7 3 -2") == 3);
+	return test ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-rvalue-references.cpp

@@ -0,0 +1,57 @@
+#include <cassert>
+
+class rvmove {
+public:
+   void *ptr;
+   char *array;
+
+   rvmove()
+    : ptr(0),
+    array(new char[10])
+   {
+     ptr = this;
+   }
+
+   rvmove(rvmove &&other)
+    : ptr(other.ptr),
+    array(other.array)
+   {
+    other.array = 0;
+    other.ptr = 0;
+   }
+
+   ~rvmove()
+   {
+    assert(((ptr != 0) && (array != 0)) || ((ptr == 0) && (array == 0)));
+    delete[] array;
+   }
+
+   rvmove &operator=(rvmove &&other)
+   {
+     delete[] array;
+     ptr = other.ptr;
+     array = other.array;
+     other.array = 0;
+     other.ptr = 0;
+     return *this;
+   }
+
+   static rvmove create()
+   {
+     return rvmove();
+   }
+private:
+  rvmove(const rvmove &);
+  rvmove &operator=(const rvmove &);
+};
+
+int main()
+{
+  rvmove mine;
+  if (mine.ptr != &mine)
+    return 1;
+  mine = rvmove::create();
+  if (mine.ptr == &mine)
+    return 1;
+  return 0;
+}

CMake/CheckCXX11Features/cxx11-test-sizeof_member.cpp

@@ -0,0 +1,14 @@
+struct foo {
+	char bar;
+	int baz;
+};
+
+int main(void)
+{
+	bool ret = (
+		(sizeof(foo::bar) == 1) &&
+		(sizeof(foo::baz) >= sizeof(foo::bar)) &&
+		(sizeof(foo) >= sizeof(foo::bar) + sizeof(foo::baz))
+	);
+	return ret ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp

@@ -0,0 +1,9 @@
+struct foo {
+	int baz;
+	double bar;
+};
+
+int main(void)
+{
+	return (sizeof(foo::bar) == 4) ? 0 : 1;
+}

CMake/CheckCXX11Features/cxx11-test-static_assert.cpp

@@ -0,0 +1,5 @@
+int main(void)
+{
+	static_assert(0 < 1, "your ordering of integers is screwed");
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp

@@ -0,0 +1,5 @@
+int main(void)
+{
+	static_assert(1 < 0, "your ordering of integers is screwed");
+	return 0;
+}

CMake/CheckCXX11Features/cxx11-test-variadic_templates.cpp

@@ -0,0 +1,23 @@
+int Accumulate()
+{
+	return 0;
+}
+
+template<typename T, typename... Ts>
+int Accumulate(T v, Ts... vs)
+{
+	return v + Accumulate(vs...);
+}
+
+template<int... Is>
+int CountElements()
+{
+	return sizeof...(Is);
+}
+
+int main()
+{
+	int acc = Accumulate(1, 2, 3, 4, -5);
+	int count = CountElements<1,2,3,4,5>();
+	return ((acc == 5) && (count == 5)) ? 0 : 1;
+}

CMake/FindBoostHeaders.cmake

@@ -0,0 +1,438 @@
+#
+# - Finds the Boost headers only
+# Use this module by invoking find_package with the form:
+#  find_package(Boost
+#    [version] [EXACT]      # Minimum or EXACT version e.g. 1.36.0
+#    [REQUIRED]             # Fail with error if Boost is not found
+#    )
+#
+# This module finds boost headers the search for the boost headers results
+# reported in variables:
+#
+#  Boost_FOUND            - True if headers and requested libraries were found
+#  Boost_INCLUDE_DIRS     - Boost include directories
+#  Boost_VERSION          - BOOST_VERSION value from boost/version.hpp
+#  Boost_MAJOR_VERSION    - Boost major version number (X in X.y.z)
+#  Boost_MINOR_VERSION    - Boost minor version number (Y in x.Y.z)
+#  Boost_SUBMINOR_VERSION - Boost subminor version number (Z in x.y.Z)
+#
+# This module reads hints about search locations from variables:
+#  BOOST_INCLUDEDIR       - Preferred include directory e.g. <prefix>/include
+#  Boost_NO_SYSTEM_PATHS  - Set to ON to disable searching in locations not
+#                           specified by these hint variables. Default is OFF.
+#  Boost_ADDITIONAL_VERSIONS
+#                         - List of Boost versions not known to this module
+#                           (Boost install locations may contain the version)
+# and saves search results persistently in CMake cache entries:
+#  Boost_INCLUDE_DIR         - Directory containing Boost headers
+#
+# Users may set these hints or results as cache entries.  Projects should
+# not read these entries directly but instead use the above result variables.
+# Note that some hint names start in upper-case "BOOST".  One may specify
+# these as environment variables if they are not specified as CMake variables
+# or cache entries.
+#
+# This module first searches for the Boost header files using the above hint
+# variables  and saves the result in
+# Boost_INCLUDE_DIR.
+#
+#
+#=============================================================================
+# Copyright 2006-2012 Kitware, Inc.
+# Copyright 2006-2008 Andreas Schneider <mail@cynapses.org>
+# Copyright 2007      Wengo
+# Copyright 2007      Mike Jackson
+# Copyright 2008      Andreas Pakulat <apaku@gmx.de>
+# Copyright 2008-2012 Philip Lowman <philip@yhbt.com>
+#
+# CMake - Cross Platform Makefile Generator
+# Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in the
+#   documentation and/or other materials provided with the distribution.
+#
+# * Neither the names of Kitware, Inc., the Insight Software Consortium,
+#   nor the names of their contributors may be used to endorse or promote
+#   products derived from this software without specific prior written
+#   permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# ------------------------------------------------------------------------------
+#
+# The above copyright and license notice applies to distributions of
+# CMake in source and binary form.  Some source files contain additional
+# notices of original copyright by their contributors; see each source
+# for details.  Third-party software packages supplied with CMake under
+# compatible licenses provide their own copyright notices documented in
+# corresponding subdirectories.
+#
+# ------------------------------------------------------------------------------
+#
+# CMake was initially developed by Kitware with the following sponsorship:
+#
+#  * National Library of Medicine at the National Institutes of Health
+#    as part of the Insight Segmentation and Registration Toolkit (ITK).
+#
+#  * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel
+#    Visualization Initiative.
+#
+#  * National Alliance for Medical Image Computing (NAMIC) is funded by the
+#    National Institutes of Health through the NIH Roadmap for Medical Research,
+#    Grant U54 EB005149.
+#
+#  * Kitware, Inc.
+#
+#
+#
+
+#-------------------------------------------------------------------------------
+#  FindBoost functions & macros
+#
+macro(_Boost_CHANGE_DETECT changed_var)
+  set(${changed_var} 0)
+  foreach(v ${ARGN})
+    if(DEFINED _Boost_COMPONENTS_SEARCHED)
+      if(${v})
+        if(_${v}_LAST)
+          string(COMPARE NOTEQUAL "${${v}}" "${_${v}_LAST}" _${v}_CHANGED)
+        else()
+          set(_${v}_CHANGED 1)
+        endif()
+      elseif(_${v}_LAST)
+        set(_${v}_CHANGED 1)
+      endif()
+      if(_${v}_CHANGED)
+        set(${changed_var} 1)
+      endif()
+    else()
+      set(_${v}_CHANGED 0)
+    endif()
+  endforeach()
+endmacro()
+
+#
+# Make sure the spelling of boost options is correct
+#
+function(_Boost_CHECK_SPELLING _var)
+  if(${_var})
+    string(TOUPPER ${_var} _var_UC)
+    message(FATAL_ERROR "ERROR: ${_var} is not the correct spelling.  The proper spelling is ${_var_UC}.")
+  endif()
+endfunction()
+
+#
+# End functions/macros
+#
+#-------------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------------
+# main.
+#-------------------------------------------------------------------------------
+
+# Check the version of Boost against the requested version.
+if(Boost_FIND_VERSION AND NOT Boost_FIND_VERSION_MINOR)
+  message(SEND_ERROR "When requesting a specific version of Boost, you must provide at least the major and minor version numbers, e.g., 1.34")
+endif()
+
+if(Boost_FIND_VERSION_EXACT)
+  # The version may appear in a directory with or without the patch
+  # level, even when the patch level is non-zero.
+  set(_boost_TEST_VERSIONS
+    "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.${Boost_FIND_VERSION_PATCH}"
+    "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
+else()
+  # The user has not requested an exact version.  Among known
+  # versions, find those that are acceptable to the user request.
+  set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS}
+    "1.56.0" "1.56" "1.55.0" "1.55" "1.54.0" "1.54"
+    "1.53.0" "1.53" "1.52.0" "1.52" "1.51.0" "1.51"
+    "1.50.0" "1.50" "1.49.0" "1.49" "1.48.0" "1.48" "1.47.0" "1.47" "1.46.1"
+    "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42"
+    "1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37"
+    "1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0"
+    "1.34" "1.33.1" "1.33.0" "1.33")
+  set(_boost_TEST_VERSIONS)
+  if(Boost_FIND_VERSION)
+    set(_Boost_FIND_VERSION_SHORT "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
+    # Select acceptable versions.
+    foreach(version ${_Boost_KNOWN_VERSIONS})
+      if(NOT "${version}" VERSION_LESS "${Boost_FIND_VERSION}")
+        # This version is high enough.
+        list(APPEND _boost_TEST_VERSIONS "${version}")
+      elseif("${version}.99" VERSION_EQUAL "${_Boost_FIND_VERSION_SHORT}.99")
+        # This version is a short-form for the requested version with
+        # the patch level dropped.
+        list(APPEND _boost_TEST_VERSIONS "${version}")
+      endif()
+    endforeach()
+  else()
+    # Any version is acceptable.
+    set(_boost_TEST_VERSIONS "${_Boost_KNOWN_VERSIONS}")
+  endif()
+endif()
+
+# The reason that we failed to find Boost. This will be set to a
+# user-friendly message when we fail to find some necessary piece of
+# Boost.
+set(Boost_ERROR_REASON)
+
+if(Boost_DEBUG)
+  # Output some of their choices
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "_boost_TEST_VERSIONS = ${_boost_TEST_VERSIONS}")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "Boost_ADDITIONAL_VERSIONS = ${Boost_ADDITIONAL_VERSIONS}")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "Boost_NO_SYSTEM_PATHS = ${Boost_NO_SYSTEM_PATHS}")
+endif()
+
+_Boost_CHECK_SPELLING(Boost_INCLUDEDIR)
+
+# Collect environment variable inputs as hints.  Do not consider changes.
+foreach(v BOOST_INCLUDEDIR)
+  set(_env $ENV{${v}})
+  if(_env)
+    file(TO_CMAKE_PATH "${_env}" _ENV_${v})
+  else()
+    set(_ENV_${v} "")
+  endif()
+endforeach()
+
+# Collect inputs and cached results.  Detect changes since the last run.
+set(_Boost_VARS_DIR
+  Boost_NO_SYSTEM_PATHS
+  )
+
+if(Boost_DEBUG)
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "Declared as CMake or Environmental Variables:")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "  BOOST_INCLUDEDIR = ${BOOST_INCLUDEDIR}")
+  message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                 "_boost_TEST_VERSIONS = ${_boost_TEST_VERSIONS}")
+endif()
+
+# ------------------------------------------------------------------------
+#  Search for Boost include DIR
+# ------------------------------------------------------------------------
+
+set(_Boost_VARS_INC BOOST_INCLUDEDIR Boost_INCLUDE_DIR Boost_ADDITIONAL_VERSIONS)
+_Boost_CHANGE_DETECT(_Boost_CHANGE_INCDIR ${_Boost_VARS_DIR} ${_Boost_VARS_INC})
+# Clear Boost_INCLUDE_DIR if it did not change but other input affecting the
+# location did.  We will find a new one based on the new inputs.
+if(_Boost_CHANGE_INCDIR AND NOT _Boost_INCLUDE_DIR_CHANGED)
+  unset(Boost_INCLUDE_DIR CACHE)
+endif()
+
+if(NOT Boost_INCLUDE_DIR)
+  set(_boost_INCLUDE_SEARCH_DIRS "")
+  if(BOOST_INCLUDEDIR)
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS ${BOOST_INCLUDEDIR})
+  elseif(_ENV_BOOST_INCLUDEDIR)
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS ${_ENV_BOOST_INCLUDEDIR})
+  endif()
+
+  if( Boost_NO_SYSTEM_PATHS)
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS NO_CMAKE_SYSTEM_PATH)
+  else()
+    list(APPEND _boost_INCLUDE_SEARCH_DIRS PATHS
+      C:/boost/include
+      C:/boost
+      /sw/local/include
+      )
+  endif()
+
+  # Try to find Boost by stepping backwards through the Boost versions
+  # we know about.
+  # Build a list of path suffixes for each version.
+  set(_boost_PATH_SUFFIXES)
+  foreach(_boost_VER ${_boost_TEST_VERSIONS})
+    # Add in a path suffix, based on the required version, ideally
+    # we could read this from version.hpp, but for that to work we'd
+    # need to know the include dir already
+    set(_boost_BOOSTIFIED_VERSION)
+
+    # Transform 1.35 => 1_35 and 1.36.0 => 1_36_0
+    if(_boost_VER MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+")
+        string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1_\\2_\\3"
+          _boost_BOOSTIFIED_VERSION ${_boost_VER})
+    elseif(_boost_VER MATCHES "[0-9]+\\.[0-9]+")
+        string(REGEX REPLACE "([0-9]+)\\.([0-9]+)" "\\1_\\2"
+          _boost_BOOSTIFIED_VERSION ${_boost_VER})
+    endif()
+
+    list(APPEND _boost_PATH_SUFFIXES
+      "boost-${_boost_BOOSTIFIED_VERSION}"
+      "boost_${_boost_BOOSTIFIED_VERSION}"
+      "boost/boost-${_boost_BOOSTIFIED_VERSION}"
+      "boost/boost_${_boost_BOOSTIFIED_VERSION}"
+      )
+
+  endforeach()
+
+  if(Boost_DEBUG)
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "Include debugging info:")
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "  _boost_INCLUDE_SEARCH_DIRS = ${_boost_INCLUDE_SEARCH_DIRS}")
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "  _boost_PATH_SUFFIXES = ${_boost_PATH_SUFFIXES}")
+  endif()
+
+  # Look for a standard boost header file.
+  find_path(Boost_INCLUDE_DIR
+    NAMES         boost/config.hpp
+    HINTS         ${_boost_INCLUDE_SEARCH_DIRS}
+    PATH_SUFFIXES ${_boost_PATH_SUFFIXES}
+    )
+endif()
+
+# ------------------------------------------------------------------------
+#  Extract version information from version.hpp
+# ------------------------------------------------------------------------
+
+# Set Boost_FOUND based only on header location and version.
+# It will be updated below for component libraries.
+if(Boost_INCLUDE_DIR)
+  if(Boost_DEBUG)
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "location of version.hpp: ${Boost_INCLUDE_DIR}/boost/version.hpp")
+  endif()
+
+  # Extract Boost_VERSION and Boost_LIB_VERSION from version.hpp
+  set(Boost_VERSION 0)
+  set(Boost_LIB_VERSION "")
+  file(STRINGS "${Boost_INCLUDE_DIR}/boost/version.hpp" _boost_VERSION_HPP_CONTENTS REGEX "#define BOOST_(LIB_)?VERSION ")
+  set(_Boost_VERSION_REGEX "([0-9]+)")
+  set(_Boost_LIB_VERSION_REGEX "\"([0-9_]+)\"")
+  foreach(v VERSION LIB_VERSION)
+    if("${_boost_VERSION_HPP_CONTENTS}" MATCHES ".*#define BOOST_${v} ${_Boost_${v}_REGEX}.*")
+      set(Boost_${v} "${CMAKE_MATCH_1}")
+    endif()
+  endforeach()
+  unset(_boost_VERSION_HPP_CONTENTS)
+
+  math(EXPR Boost_MAJOR_VERSION "${Boost_VERSION} / 100000")
+  math(EXPR Boost_MINOR_VERSION "${Boost_VERSION} / 100 % 1000")
+  math(EXPR Boost_SUBMINOR_VERSION "${Boost_VERSION} % 100")
+
+  set(Boost_ERROR_REASON
+    "${Boost_ERROR_REASON}Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}\nBoost include path: ${Boost_INCLUDE_DIR}")
+  if(Boost_DEBUG)
+    message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
+                   "version.hpp reveals boost "
+                   "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+  endif()
+
+  if(Boost_FIND_VERSION)
+    # Set Boost_FOUND based on requested version.
+    set(_Boost_VERSION "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+    if("${_Boost_VERSION}" VERSION_LESS "${Boost_FIND_VERSION}")
+      set(Boost_FOUND 0)
+      set(_Boost_VERSION_AGE "old")
+    elseif(Boost_FIND_VERSION_EXACT AND
+        NOT "${_Boost_VERSION}" VERSION_EQUAL "${Boost_FIND_VERSION}")
+      set(Boost_FOUND 0)
+      set(_Boost_VERSION_AGE "new")
+    else()
+      set(Boost_FOUND 1)
+    endif()
+    if(NOT Boost_FOUND)
+      # State that we found a version of Boost that is too new or too old.
+      set(Boost_ERROR_REASON
+        "${Boost_ERROR_REASON}\nDetected version of Boost is too ${_Boost_VERSION_AGE}. Requested version was ${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
+      if (Boost_FIND_VERSION_PATCH)
+        set(Boost_ERROR_REASON
+          "${Boost_ERROR_REASON}.${Boost_FIND_VERSION_PATCH}")
+      endif ()
+      if (NOT Boost_FIND_VERSION_EXACT)
+        set(Boost_ERROR_REASON "${Boost_ERROR_REASON} (or newer)")
+      endif ()
+      set(Boost_ERROR_REASON "${Boost_ERROR_REASON}.")
+    endif ()
+  else()
+    # Caller will accept any Boost version.
+    set(Boost_FOUND 1)
+  endif()
+else()
+  set(Boost_FOUND 0)
+  set(Boost_ERROR_REASON
+    "${Boost_ERROR_REASON}Unable to find the Boost header files. Please set BOOST_INCLUDEDIR to the directory containing Boost's headers.")
+endif()
+
+set(Boost_INCLUDE_DIRS ${Boost_INCLUDE_DIR})
+set(Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIR})
+
+# ------------------------------------------------------------------------
+#  Notification to end user about what was found
+# ------------------------------------------------------------------------
+
+if(Boost_FOUND)
+  if(NOT Boost_FIND_QUIETLY)
+    message(STATUS "Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+  endif()
+else()
+  if(Boost_FIND_REQUIRED)
+    message(SEND_ERROR "Unable to find the requested Boost libraries.\n${Boost_ERROR_REASON}")
+  else()
+    if(NOT Boost_FIND_QUIETLY)
+      # we opt not to automatically output Boost_ERROR_REASON here as
+      # it could be quite lengthy and somewhat imposing in its requests
+      # Since Boost is not always a required dependency we'll leave this
+      # up to the end-user.
+      if(Boost_DEBUG OR Boost_DETAILED_FAILURE_MSG)
+        message(STATUS "Could NOT find Boost\n${Boost_ERROR_REASON}")
+      else()
+        message(STATUS "Could NOT find Boost")
+      endif()
+    endif()
+  endif()
+endif()
+
+# Configure display of cache entries in GUI.
+foreach(v ${_Boost_VARS_INC} ${_Boost_VARS_LIB})
+  get_property(_type CACHE ${v} PROPERTY TYPE)
+  if(_type)
+    set_property(CACHE ${v} PROPERTY ADVANCED 1)
+    if("x${_type}" STREQUAL "xUNINITIALIZED")
+      if("x${v}" STREQUAL "xBoost_ADDITIONAL_VERSIONS")
+        set_property(CACHE ${v} PROPERTY TYPE STRING)
+      else()
+        set_property(CACHE ${v} PROPERTY TYPE PATH)
+      endif()
+    endif()
+  endif()
+endforeach()
+
+# Record last used values of input variables so we can
+# detect on the next run if the user changed them.
+foreach(v
+    ${_Boost_VARS_INC} ${_Boost_VARS_LIB}
+    ${_Boost_VARS_DIR} ${_Boost_VARS_NAME}
+    )
+  if(DEFINED ${v})
+    set(_${v}_LAST "${${v}}" CACHE INTERNAL "Last used ${v} value.")
+  else()
+    unset(_${v}_LAST CACHE)
+  endif()
+endforeach()

CMake/TestBuild.cxx.in

@@ -0,0 +1,13 @@
+//mark that we are including headers as test for completeness.
+//This is used by headers that include thrust to properly define a proper
+//device backend / system
+#define VTKM_TEST_HEADER_BUILD
+
+#define BOOST_SP_DISABLE_THREADS
+
+#include <@dir_prefix@/@header@>
+
+int Test_Build_For_@headername@()
+{
+  return 0;
+}

CMake/VtkmCheckCopyright.cmake

@@ -0,0 +1,245 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+## This CMake script checks source files for the appropriate VTKM copyright
+## statement, which is stored in VTKm_SOURCE_DIR/CMake/VTKmCopyrightStatement.txt.
+## To run this script, execute CMake as follows:
+##
+## cmake -DVTKm_SOURCE_DIR=<VTKm_SOURCE_DIR> -P <VTKm_SOURCE_DIR>/CMake/VTKMCheckCopyright.cmake
+##
+
+cmake_minimum_required(VERSION 2.8)
+
+set(FILES_TO_CHECK
+  *.txt
+  *.cmake
+  *.h
+  *.h.in
+  *.cxx
+  *.cu
+  )
+
+set(EXCEPTIONS
+  LICENSE.txt
+  README.txt
+  )
+
+if (NOT VTKm_SOURCE_DIR)
+  message(SEND_ERROR "VTKm_SOURCE_DIR not defined.")
+endif (NOT VTKm_SOURCE_DIR)
+
+set(copyright_file ${VTKm_SOURCE_DIR}/CMake/VTKMCopyrightStatement.txt)
+
+if (NOT EXISTS ${copyright_file})
+  message(SEND_ERROR "Cannot find VTKMCopyrightStatement.txt.")
+endif (NOT EXISTS ${copyright_file})
+
+set(license_file ${VTKm_SOURCE_DIR}/LICENSE.txt)
+
+if (NOT EXISTS ${license_file})
+  message(SEND_ERROR "Cannot find LICENSE.txt.")
+endif (NOT EXISTS ${license_file})
+
+# Get a list of third party files (with different copyrights) from the
+# license file.
+file(STRINGS ${license_file} license_lines)
+list(FIND
+  license_lines
+  "- - - - - - - - - - - - - - - - - - - - - - - - do not remove this line"
+  separator_index
+  )
+math(EXPR begin_index "${separator_index} + 1")
+list(LENGTH license_lines license_file_length)
+math(EXPR end_index "${license_file_length} - 1")
+foreach (index RANGE ${begin_index} ${end_index})
+  list(GET license_lines ${index} tpl_file)
+  set(EXCEPTIONS ${EXCEPTIONS} ${tpl_file})
+endforeach(index)
+message("${EXCEPTIONS}")
+
+# Gets the current year (if possible).
+function (get_year var)
+  if (UNIX)
+    execute_process(COMMAND "date" "+%Y" OUTPUT_VARIABLE result)
+    string(REGEX REPLACE "(....).*" "\\1" result "${result}")
+  elseif (WIN32)
+    execute_process(COMMAND "date" "/T" OUTPUT_VARIABLE result)
+    string(REGEX REPLACE ".*../../(....).*" "\\1" result "${result}")
+  else (UNIX)
+    message("Don't know how to get date.")
+    set(result "20XX")
+  endif (UNIX)
+  set(${var} "${result}" PARENT_SCOPE)
+endfunction (get_year)
+
+set(copyright_file_year 2011)
+get_year(current_year)
+
+# Escapes ';' characters (list delimiters) and splits the given string into
+# a list of its lines without newlines.
+function (list_of_lines var string)
+  string(REGEX REPLACE ";" "\\\\;" conditioned_string "${string}")
+  string(REGEX REPLACE "\n" ";" conditioned_string "${conditioned_string}")
+  set(${var} "${conditioned_string}" PARENT_SCOPE)
+endfunction (list_of_lines)
+
+# Read in copyright statement file.
+file(READ ${copyright_file} COPYRIGHT_STATEMENT)
+
+# Remove trailing whitespace and ending lines.  They are sometimes hard to
+# see or remove in editors.
+string(REGEX REPLACE "[ \t]*\n" "\n" COPYRIGHT_STATEMENT "${COPYRIGHT_STATEMENT}")
+string(REGEX REPLACE "\n+$" "" COPYRIGHT_STATEMENT "${COPYRIGHT_STATEMENT}")
+
+# Get a list of lines in the copyright statement.
+list_of_lines(COPYRIGHT_LINE_LIST "${COPYRIGHT_STATEMENT}")
+
+# Comment regular expression characters that we want to match literally.
+string(REPLACE "." "\\." COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}")
+string(REPLACE "(" "\\(" COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}")
+string(REPLACE ")" "\\)" COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}")
+
+# Introduce regular expression for years we want to be generic.
+string(REPLACE
+  "${copyright_file_year}"
+  "20[0-9][0-9]"
+  COPYRIGHT_LINE_LIST
+  "${COPYRIGHT_LINE_LIST}"
+  )
+
+# Replace year in COPYRIGHT_STATEMENT with current year.
+string(REPLACE
+  "${copyright_file_year}"
+  "${current_year}"
+  COPYRIGHT_STATEMENT
+  "${COPYRIGHT_STATEMENT}"
+  )
+
+# Print an error concerning the missing copyright in the given file.
+function(missing_copyright filename comment_prefix)
+  message("${filename} does not have the appropriate copyright statement:\n")
+
+  # Condition the copyright statement
+  string(REPLACE
+    "\n"
+    "\n${comment_prefix}  "
+    comment_copyright
+    "${COPYRIGHT_STATEMENT}"
+    )
+  set(comment_copyright "${comment_prefix}  ${comment_copyright}")
+  string(REPLACE
+    "\n${comment_prefix}  \n"
+    "\n${comment_prefix}\n"
+    comment_copyright
+    "${comment_copyright}"
+    )
+
+  message("${comment_prefix}=============================================================================")
+  message("${comment_prefix}")
+  message("${comment_copyright}")
+  message("${comment_prefix}")
+  message("${comment_prefix}=============================================================================\n")
+  message(SEND_ERROR
+    "Please add the previous statement to the beginning of ${filename}"
+    )
+endfunction(missing_copyright)
+
+# Get an appropriate beginning line comment for the given filename.
+function(get_comment_prefix var filename)
+  get_filename_component(base "${filename}" NAME_WE)
+  get_filename_component(extension "${filename}" EXT)
+  if (extension STREQUAL ".cmake")
+    set(${var} "##" PARENT_SCOPE)
+  elseif (base STREQUAL "CMakeLists" AND extension STREQUAL ".txt")
+    set(${var} "##" PARENT_SCOPE)
+  elseif (extension STREQUAL ".txt")
+    set(${var} "" PARENT_SCOPE)
+  elseif (extension STREQUAL ".h" OR extension STREQUAL ".h.in" OR extension STREQUAL ".cxx" OR extension STREQUAL ".cu")
+    set(${var} "//" PARENT_SCOPE)
+  elseif (extension STREQUAL ".worklet")
+    set(${var} "//" PARENT_SCOPE)
+  else (extension STREQUAL ".cmake")
+    message(SEND_ERROR "Could not identify file type of ${filename}.")
+  endif (extension STREQUAL ".cmake")
+endfunction(get_comment_prefix)
+
+# Check the given file for the appropriate copyright statement.
+function(check_copyright filename)
+
+  get_comment_prefix(comment_prefix "${filename}")
+
+  # Read in the first 2000 characters of the file and split into lines.
+  # This is roughly equivalent to the file STRINGS command except that we
+  # also escape semicolons (list separators) in the input, which the file
+  # STRINGS command does not currently do.
+  file(READ "${filename}" header_contents LIMIT 2000)
+  list_of_lines(header_lines "${header_contents}")
+
+  # Check each copyright line.
+  foreach (copyright_line IN LISTS COPYRIGHT_LINE_LIST)
+    set(match)
+    # My original algorithm tried to check the order by removing items from
+    # header_lines as they were encountered.  Unfortunately, CMake 2.8's
+    # list REMOVE_AT command removed the escaping on the ; in one of the
+    # header_line's items and cause the compare to fail.
+    foreach (header_line IN LISTS header_lines)
+      if (copyright_line)
+        string(REGEX MATCH
+          "^${comment_prefix}[ \t]*${copyright_line}[ \t]*$"
+          match
+          "${header_line}"
+          )
+      else (copyright_line)
+        if (NOT header_line)
+          set(match TRUE)
+        endif (NOT header_line)
+      endif (copyright_line)
+      if (match)
+        break()
+      endif (match)
+    endforeach (header_line)
+    if (NOT match)
+      message(STATUS "Could not find match for `${copyright_line}'")
+      missing_copyright("${filename}" "${comment_prefix}")
+    endif (NOT match)
+  endforeach (copyright_line)
+endfunction(check_copyright)
+
+foreach (glob_expression ${FILES_TO_CHECK})
+  file(GLOB_RECURSE file_list
+    RELATIVE "${VTKm_SOURCE_DIR}"
+    "${VTKm_SOURCE_DIR}/${glob_expression}"
+    )
+
+  foreach (file ${file_list})
+    set(skip)
+    foreach(exception ${EXCEPTIONS})
+      if(file MATCHES "^${exception}(/.*)?$")
+        # This file is an exception
+        set(skip TRUE)
+      endif(file MATCHES "^${exception}(/.*)?$")
+    endforeach(exception)
+
+    if (NOT skip)
+      message("Checking ${file}")
+      check_copyright("${VTKm_SOURCE_DIR}/${file}")
+    endif (NOT skip)
+  endforeach (file)
+endforeach (glob_expression)

CMake/VtkmCompilerExtras.cmake

@@ -0,0 +1,56 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  set(CMAKE_COMPILER_IS_CLANGXX 1)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANGXX)
+
+  include(CheckCXXCompilerFlag)
+
+  # Standard warning flags we should always have
+  set(CMAKE_CXX_FLAGS_WARN " -Wall")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
+    "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${CMAKE_CXX_FLAGS_WARN}")
+  set(CMAKE_CXX_FLAGS_DEBUG
+    "${CMAKE_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_WARN}")
+
+  # Addtional warnings for GCC
+  set(CMAKE_CXX_FLAGS_WARN_EXTRA "-Wno-long-long -Wcast-align -Wchar-subscripts -Wextra -Wpointer-arith -Wformat -Wformat-security -Wshadow -Wunused-parameter -fno-common")
+  if (VTKM_FORCE_ANSI)
+    set(CMAKE_CXX_FLAGS_WARN_EXTRA "-ansi ${CMAKE_CXX_FLAGS_WARN_EXTRA}")
+  endif()
+
+  # Set up the debug CXX_FLAGS for extra warnings
+  option(VTKM_EXTRA_COMPILER_WARNINGS "Add compiler flags to do stricter checking when building debug." ON)
+  # We used to add the compiler flags globally, but this caused problems with
+  # the CUDA compiler (and its lack of support for GCC pragmas).  Instead,
+  # the vtkm_declare_headers and vtkm_unit_tests CMake functions add these flags
+  # to their compiles.  As long as the unit tests have good coverage, this
+  # should catch all problems.
+  if(VTKM_EXTRA_COMPILER_WARNINGS)
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
+      "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${CMAKE_CXX_FLAGS_WARN_EXTRA}")
+    set(CMAKE_CXX_FLAGS_DEBUG
+      "${CMAKE_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_WARN_EXTRA}")
+  endif()
+endif()
+

CMake/VtkmConfig.cmake.in

@@ -0,0 +1,40 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+# This file should be installed in the include directory.
+# Find the root directory.
+get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_install_dir "${_dir}/.." ABSOLUTE)
+
+# The VTKm include file directories.
+set(VTKm_INCLUDE_DIRS "@VTKm_INCLUDE_DIRS_CONFIG@")
+
+# The VTKm version number
+set(VTKm_MAJOR_VERSION "@VTKm_MAJOR_VERSION@")
+set(VTKm_MINOR_VERSION "@VTKm_MINOR_VERSION@")
+set(VTKm_PATCH_VERSION "@VTKm_PATCH_VERSION@")
+
+set(VTKm_REQUIRED_BOOST_VERSION "@VTKm_REQUIRED_BOOST_VERSION@")
+
+set(VTKm_CMAKE_MODULE_PATH "@VTKm_CMAKE_MODULE_PATH_CONFIG@")
+
+# VTKm requires some CMake Find modules not included with CMake, so
+# include the CMake modules distributed with VTKm.
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${VTKm_CMAKE_MODULE_PATH})

CMake/VtkmConfigVersion.cmake.in

@@ -0,0 +1,10 @@
+set(PACKAGE_VERSION "@VTKm_VERSION@")
+
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if ("${PACKAGE_VERSION}" STREQUAL "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

CMake/VtkmCopyrightStatement.txt

@@ -0,0 +1,17 @@
+Copyright (c) Kitware, Inc.
+All rights reserved.
+See LICENSE.txt for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.  See the above copyright notice for more information.
+
+Copyright 2014 Sandia Corporation.
+Copyright 2014 UT-Battelle, LLC.
+Copyright 2014. Los Alamos National Security
+
+Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+the U.S. Government retains certain rights in this software.
+Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+Laboratory (LANL), the U.S. Government retains certain rights in
+this software.

CMake/VtkmMacros.cmake

@@ -0,0 +1,343 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+include(CMakeParseArguments)
+
+# Utility to build a kit name from the current directory.
+function(vtkm_get_kit_name kitvar)
+  # Will this always work?  It should if ${CMAKE_CURRENT_SOURCE_DIR} is
+  # built from ${VTKm_SOURCE_DIR}.
+  string(REPLACE "${VTKm_SOURCE_DIR}/" "" dir_prefix ${CMAKE_CURRENT_SOURCE_DIR})
+  string(REPLACE "/" "_" kit "${dir_prefix}")
+  set(${kitvar} "${kit}" PARENT_SCOPE)
+  # Optional second argument to get dir_prefix.
+  if (${ARGC} GREATER 1)
+    set(${ARGV1} "${dir_prefix}" PARENT_SCOPE)
+  endif (${ARGC} GREATER 1)
+endfunction(vtkm_get_kit_name)
+
+# Builds a source file and an executable that does nothing other than
+# compile the given header files.
+function(vtkm_add_header_build_test name dir_prefix use_cuda)
+  set(hfiles ${ARGN})
+  if (use_cuda)
+    set(suffix ".cu")
+  else (use_cuda)
+    set(suffix ".cxx")
+  endif (use_cuda)
+  set(cxxfiles)
+  foreach (header ${ARGN})
+    get_source_file_property(cant_be_tested ${header} VTKm_CANT_BE_HEADER_TESTED)
+
+    if( NOT cant_be_tested )
+      string(REPLACE "${CMAKE_CURRENT_BINARY_DIR}" "" header "${header}")
+      get_filename_component(headername ${header} NAME_WE)
+      set(src ${CMAKE_CURRENT_BINARY_DIR}/testing/TestBuild_${name}_${headername}${suffix})
+      configure_file(${VTKm_SOURCE_DIR}/CMake/TestBuild.cxx.in ${src} @ONLY)
+      list(APPEND cxxfiles ${src})
+    endif()
+
+  endforeach (header)
+
+  #only attempt to add a test build executable if we have any headers to
+  #test. this might not happen when everything depends on thrust.
+  list(LENGTH cxxfiles cxxfiles_len)
+  if (use_cuda AND ${cxxfiles_len} GREATER 0)
+    cuda_add_library(TestBuild_${name} ${cxxfiles} ${hfiles})
+  elseif (${cxxfiles_len} GREATER 0)
+    add_library(TestBuild_${name} ${cxxfiles} ${hfiles})
+    if(VTKm_EXTRA_COMPILER_WARNINGS)
+      set_target_properties(TestBuild_${name}
+        PROPERTIES COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA})
+    endif(VTKm_EXTRA_COMPILER_WARNINGS)
+  endif ()
+  set_source_files_properties(${hfiles}
+    PROPERTIES HEADER_FILE_ONLY TRUE
+    )
+endfunction(vtkm_add_header_build_test)
+
+function(vtkm_install_headers dir_prefix)
+  set(hfiles ${ARGN})
+  install(FILES ${hfiles}
+    DESTINATION ${VTKm_INSTALL_INCLUDE_DIR}/${dir_prefix}
+    )
+endfunction(vtkm_install_headers)
+
+# Declare a list of headers that require thrust to be enabled
+# for them to header tested. In cases of thrust version 1.5 or less
+# we have to make sure openMP is enabled, otherwise we are okay
+function(vtkm_requires_thrust_to_test)
+  #determine the state of thrust and testing
+  set(cant_be_tested FALSE)
+    if(NOT VTKm_ENABLE_THRUST)
+      #mark as not valid
+      set(cant_be_tested TRUE)
+    elseif(NOT VTKm_ENABLE_OPENMP)
+      #mark also as not valid
+      set(cant_be_tested TRUE)
+    endif()
+
+  foreach(header ${ARGN})
+    #set a property on the file that marks if we can header test it
+    set_source_files_properties( ${header}
+        PROPERTIES VTKm_CANT_BE_HEADER_TESTED ${cant_be_tested} )
+
+  endforeach(header)
+
+endfunction(vtkm_requires_thrust_to_test)
+
+# Declare a list of header files.  Will make sure the header files get
+# compiled and show up in an IDE.
+function(vtkm_declare_headers)
+  set(options CUDA)
+  set(oneValueArgs)
+  set(multiValueArgs)
+  cmake_parse_arguments(VTKm_DH "${options}"
+    "${oneValueArgs}" "${multiValueArgs}"
+    ${ARGN}
+    )
+  set(hfiles ${VTKm_DH_UNPARSED_ARGUMENTS})
+  vtkm_get_kit_name(name dir_prefix)
+
+  #only do header testing if enable testing is turned on
+  if (VTKm_ENABLE_TESTING)
+    vtkm_add_header_build_test(
+      "${name}" "${dir_prefix}" "${VTKm_DH_CUDA}" ${hfiles})
+  endif()
+  #always install headers
+  vtkm_install_headers("${dir_prefix}" ${hfiles})
+endfunction(vtkm_declare_headers)
+
+# Declare a list of worklet files.
+function(vtkm_declare_worklets)
+  # Currently worklets are just really header files.
+  vtkm_declare_headers(${ARGN})
+endfunction(vtkm_declare_worklets)
+
+# Declare unit tests, which should be in the same directory as a kit
+# (package, module, whatever you call it).  Usage:
+#
+# vtkm_unit_tests(
+#   SOURCES <source_list>
+#   LIBRARIES <dependent_library_list>
+#   )
+function(vtkm_unit_tests)
+  set(options CUDA)
+  set(oneValueArgs)
+  set(multiValueArgs SOURCES LIBRARIES)
+  cmake_parse_arguments(VTKm_UT
+    "${options}" "${oneValueArgs}" "${multiValueArgs}"
+    ${ARGN}
+    )
+
+  #set up what we possibly need to link too.
+  list(APPEND VTKm_UT_LIBRARIES ${TBB_LIBRARIES})
+  #set up storage for the include dirs
+  set(VTKm_UT_INCLUDE_DIRS )
+
+  if(VTKm_ENABLE_OPENGL_INTEROP)
+    list(APPEND VTKm_UT_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR} ${GLEW_INCLUDE_DIR} )
+    list(APPEND VTKm_UT_LIBRARIES ${OPENGL_LIBRARIES} ${GLEW_LIBRARIES} )
+  endif()
+
+  if(VTKm_ENABLE_OPENGL_TESTS)
+    list(APPEND VTKm_UT_INCLUDE_DIRS ${GLUT_INCLUDE_DIR} )
+    list(APPEND VTKm_UT_LIBRARIES ${GLUT_LIBRARIES}  )
+  endif()
+
+  if (VTKm_ENABLE_TESTING)
+    vtkm_get_kit_name(kit)
+    #we use UnitTests_kit_ so that it is an unique key to exclude from coverage
+    set(test_prog UnitTests_kit_${kit})
+    create_test_sourcelist(TestSources ${test_prog}.cxx ${VTKm_UT_SOURCES})
+    if (VTKm_UT_CUDA)
+      cuda_add_executable(${test_prog} ${TestSources})
+    else (VTKm_UT_CUDA)
+      add_executable(${test_prog} ${TestSources})
+      if(VTKm_EXTRA_COMPILER_WARNINGS)
+        set_target_properties(${test_prog}
+          PROPERTIES COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA})
+      endif(VTKm_EXTRA_COMPILER_WARNINGS)
+    endif (VTKm_UT_CUDA)
+
+    #do it as a property value so we don't pollute the include_directories
+    #for any other targets
+    set_property(TARGET ${test_prog} APPEND PROPERTY
+        INCLUDE_DIRECTORIES ${VTKm_UT_INCLUDE_DIRS} )
+
+    target_link_libraries(${test_prog} ${VTKm_UT_LIBRARIES})
+
+
+    foreach (test ${VTKm_UT_SOURCES})
+      get_filename_component(tname ${test} NAME_WE)
+      add_test(NAME ${tname}
+        COMMAND ${test_prog} ${tname}
+        )
+    endforeach (test)
+  endif (VTKm_ENABLE_TESTING)
+endfunction(vtkm_unit_tests)
+
+# Save the worklets to test with each device adapter
+# Usage:
+#
+# vtkm_save_worklet_unit_tests( sources )
+#
+# notes: will save the sources absolute path as the
+# vtkm_source_worklet_unit_tests global property
+function(vtkm_save_worklet_unit_tests )
+
+  #create the test driver when we are called, since
+  #the test driver expect the test files to be in the same
+  #directory as the test driver
+  create_test_sourcelist(test_sources WorkletTestDriver.cxx ${ARGN})
+
+  #store the absolute path for the test drive and all the test
+  #files
+  set(driver ${CMAKE_CURRENT_BINARY_DIR}/WorkletTestDriver.cxx)
+  set(cxx_sources)
+  set(cu_sources)
+
+  #we need to store the absolute source for the file so that
+  #we can properly compile it into the test driver. At
+  #the same time we want to configure each file into the build
+  #directory as a .cu file so that we can compile it with cuda
+  #if needed
+  foreach(fname ${ARGN})
+    set(absPath)
+
+    get_filename_component(absPath ${fname} ABSOLUTE)
+    get_filename_component(file_name_only ${fname} NAME_WE)
+
+    set(cuda_file_name "${CMAKE_CURRENT_BINARY_DIR}/${file_name_only}.cu")
+    configure_file("${absPath}"
+                   "${cuda_file_name}"
+                   COPYONLY)
+    list(APPEND cxx_sources ${absPath})
+    list(APPEND cu_sources ${cuda_file_name})
+  endforeach()
+
+  #we create a property that holds all the worklets to test,
+  #but don't actually attempt to create a unit test with the yet.
+  #That is done by each device adapter
+  set_property( GLOBAL APPEND
+                PROPERTY vtkm_worklet_unit_tests_sources ${cxx_sources})
+  set_property( GLOBAL APPEND
+                PROPERTY vtkm_worklet_unit_tests_cu_sources ${cu_sources})
+  set_property( GLOBAL APPEND
+                PROPERTY vtkm_worklet_unit_tests_drivers ${driver})
+
+endfunction(vtkm_save_worklet_unit_tests)
+
+# Call each worklet test for the given device adapter
+# Usage:
+#
+# vtkm_worklet_unit_tests( device_adapter )
+#
+# notes: will look for the vtkm_source_worklet_unit_tests global
+# property to find what are the worklet unit tests that need to be
+# compiled for the give device adapter
+function(vtkm_worklet_unit_tests device_adapter)
+
+  set(unit_test_srcs)
+  get_property(unit_test_srcs GLOBAL
+               PROPERTY vtkm_worklet_unit_tests_sources )
+
+  set(unit_test_drivers)
+  get_property(unit_test_drivers GLOBAL
+               PROPERTY vtkm_worklet_unit_tests_drivers )
+
+  #detect if we are generating a .cu files
+  set(is_cuda FALSE)
+  set(old_nvcc_flags ${CUDA_NVCC_FLAGS})
+  if("${device_adapter}" STREQUAL "VTKm_DEVICE_ADAPTER_CUDA")
+    set(is_cuda TRUE)
+    #if we are generating cu files need to setup three things.
+    #1. us the configured .cu files
+    #2. Set BOOST_SP_DISABLE_THREADS to disable threading warnings
+    #3. Disable unused function warnings
+    #the FindCUDA module and helper methods don't read target level
+    #properties so we have to modify CUDA_NVCC_FLAGS  instead of using
+    # target and source level COMPILE_FLAGS and COMPILE_DEFINITIONS
+    #
+    get_property(unit_test_srcs GLOBAL PROPERTY vtkm_worklet_unit_tests_cu_sources )
+    list(APPEND CUDA_NVCC_FLAGS -DBOOST_SP_DISABLE_THREADS)
+    list(APPEND CUDA_NVCC_FLAGS "-w")
+  endif()
+
+  if(VTKm_ENABLE_TESTING)
+    vtkm_get_kit_name(kit)
+    set(test_prog WorkletTests_${kit})
+
+    if(is_cuda)
+      cuda_add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs})
+    else()
+      add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs})
+    endif()
+
+    #add a test for each worklet test file. We will inject the device
+    #adapter type into the test name so that it is easier to see what
+    #exact device a test is failing on.
+
+    string(REPLACE "VTKm_DEVICE_ADAPTER_" "" device_type ${device_adapter})
+
+    foreach (test ${unit_test_srcs})
+      get_filename_component(tname ${test} NAME_WE)
+      add_test(NAME "${tname}${device_type}"
+        COMMAND ${test_prog} ${tname}
+        )
+    endforeach (test)
+
+    #increase warning level if needed, we are going to skip cuda here
+    #to remove all the false positive unused function warnings that cuda
+    #generates
+    if(VTKm_EXTRA_COMPILER_WARNINGS)
+      set_property(TARGET ${test_prog}
+            APPEND PROPERTY COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA} )
+    endif()
+
+    #set the device adapter on the executable
+    set_property(TARGET ${test_prog}
+             APPEND
+             PROPERTY COMPILE_DEFINITIONS VTKm_DEVICE_ADAPTER=${device_adapter})
+  endif()
+
+  set(CUDA_NVCC_FLAGS ${old_nvcc_flags})
+endfunction(vtkm_worklet_unit_tests)
+
+# The Thrust project is not as careful as the VTKm project in avoiding warnings
+# on shadow variables and unused arguments.  With a real GCC compiler, you
+# can disable these warnings inline, but with something like nvcc, those
+# pragmas cause errors.  Thus, this macro will disable the compiler warnings.
+macro(vtkm_disable_troublesome_thrust_warnings)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_DEBUG)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_MINSIZEREL)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_RELEASE)
+  vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+endmacro(vtkm_disable_troublesome_thrust_warnings)
+
+macro(vtkm_disable_troublesome_thrust_warnings_var flags_var)
+  set(old_flags "${${flags_var}}")
+  string(REPLACE "-Wshadow" "" new_flags "${old_flags}")
+  string(REPLACE "-Wunused-parameter" "" new_flags "${new_flags}")
+  string(REPLACE "-Wunused" "" new_flags "${new_flags}")
+  string(REPLACE "-Wextra" "" new_flags "${new_flags}")
+  string(REPLACE "-Wall" "" new_flags "${new_flags}")
+  set(${flags_var} "${new_flags}")
+endmacro(vtkm_disable_troublesome_thrust_warnings_var)

CMakeLists.txt

@@ -0,0 +1,156 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+cmake_minimum_required(VERSION 2.8.10)
+project (VTKm)
+
+set(VTKm_MAJOR_VERSION 0)
+set(VTKm_MINOR_VERSION 1)
+set(VTKm_PATCH_VERSION 0)
+set(VTKm_VERSION "${VTKm_MAJOR_VERSION}.${VTKm_MINOR_VERSION}.${VTKm_PATCH_VERSION}")
+
+set(VTKm_INSTALL_INCLUDE_DIR "include")
+set(VTKm_INSTALL_CONFIG_DIR "include")
+set(VTKm_INSTALL_CMAKE_MODULE_DIR "share/vtkm/cmake")
+
+set(VTKm_REQUIRED_BOOST_VERSION 1.48.0)
+
+# include some vtkm-specific cmake code.
+include(CMake/VTKmMacros.cmake)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${VTKm_SOURCE_DIR}/CMake)
+
+#-----------------------------------------------------------------------------
+# Check for Cxx11 support.
+option(VTKm_FORCE_ANSI
+ "Turn off compiling any features not compatible with ISO-C++98 (ANSI)." OFF)
+if (NOT VTKm_FORCE_ANSI)
+  include(CMake/CheckCXX11Features.cmake)
+else (NOT VTKm_FORCE_ANSI)
+  set(VTKm_NO_VARIADIC_TEMPLATE TRUE)
+endif ()
+
+#-----------------------------------------------------------------------------
+# Add supplemental compiler warnings, and GCC visibility support.
+include(CMake/VTKmCompilerExtras.cmake)
+
+#-----------------------------------------------------------------------------
+# Configurable Options
+option(VTKm_ENABLE_TESTING "Enable VTKm Testing" ON)
+
+option(VTKm_USE_DOUBLE_PRECISION
+  "Use double precision for floating point calculations"
+  OFF
+  )
+option(VTKm_USE_64BIT_IDS "Use 64-bit indices." OFF)
+
+if (VTKm_ENABLE_TESTING)
+  enable_testing()
+  include(CTest)
+endif()
+
+#-----------------------------------------------------------------------------
+
+## Set the directory where the binaries will be stored
+set( EXECUTABLE_OUTPUT_PATH
+  ${PROJECT_BINARY_DIR}/bin
+  CACHE PATH
+  "Directory where all executable will be stored"
+)
+
+## Set the directory where the libraries will be stored
+set( LIBRARY_OUTPUT_PATH
+  ${PROJECT_BINARY_DIR}/libs
+  CACHE PATH
+  "Directory where all the libraries will be stored"
+)
+mark_as_advanced(
+  EXECUTABLE_OUTPUT_PATH
+  LIBRARY_OUTPUT_PATH)
+
+include_directories(
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  )
+
+#-----------------------------------------------------------------------------
+# Add test to check for copyright statement on all source files.
+if (VTKm_ENABLE_TESTING)
+  add_test(NAME CopyrightStatement
+    COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckCopyright.cmake"
+    )
+endif (VTKm_ENABLE_TESTING)
+
+#-----------------------------------------------------------------------------
+# Check basic type sizes.
+include(CheckTypeSize)
+
+check_type_size(float VTKm_SIZE_FLOAT BUILTIN_TYPES_ONLY)
+check_type_size(double VTKm_SIZE_DOUBLE BUILTIN_TYPES_ONLY)
+check_type_size(int VTKm_SIZE_INT BUILTIN_TYPES_ONLY)
+check_type_size(long VTKm_SIZE_LONG BUILTIN_TYPES_ONLY)
+check_type_size("long long" VTKm_SIZE_LONG_LONG BUILTIN_TYPES_ONLY)
+
+#-----------------------------------------------------------------------------
+# Build the configure file.
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/vtkm/internal/Configure.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/vtkm/internal/Configure.h
+  @ONLY)
+vtkm_install_headers(
+  vtkm/internal ${CMAKE_CURRENT_BINARY_DIR}/vtkm/internal/Configure.h)
+
+
+# List of Boost features used:
+# * Smart Ptr
+# * Meta programming language
+find_package(BoostHeaders ${VTKm_REQUIRED_BOOST_VERSION} REQUIRED)
+
+#-----------------------------------------------------------------------------
+# Add subdirectories
+add_subdirectory(vtkm)
+
+# Install the readme and license files.
+install(FILES ${VTKm_SOURCE_DIR}/README.md
+  DESTINATION ${VTKm_INSTALL_CONFIG_DIR}
+  RENAME VTKmREADME.md
+  )
+install(FILES ${VTKm_SOURCE_DIR}/LICENSE.txt
+  DESTINATION ${VTKm_INSTALL_CONFIG_DIR}
+  RENAME VTKmLICENSE.txt
+  )
+
+# Install helper configure files.
+install(
+  FILES
+    ${VTKm_SOURCE_DIR}/CMake/FindBoostHeaders.cmake
+  DESTINATION ${VTKm_INSTALL_CMAKE_MODULE_DIR}
+  )
+
+# Enable CPack packaging
+set(CPACK_PACKAGE_DESCRIPTION_FILE ${VTKm_SOURCE_DIR}/README.md)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "The VTKm Toolkit")
+set(CPACK_PACKAGE_NAME "VTKm")
+set(CPACK_PACKAGE_VERSION_MAJOR ${VTKm_MAJOR_VERSION})
+set(CPACK_PACKAGE_VERSION_MINOR ${VTKm_MINOR_VERSION})
+set(CPACK_PACKAGE_VERSION_PATCH ${VTKm_PATCH_VERSION})
+set(CPACK_PACKAGE_FILE_NAME "VTKm-${VTKm_VERSION}")
+set(CPACK_RESOURCE_FILE_LICENSE ${VTKm_SOURCE_DIR}/LICENSE.txt)
+set(CPACK_RESOURCE_FILE_README ${VTKm_SOURCE_DIR}/README.md)
+include(CPack)