# Add to your conanfile.txt
[requires]
algebraic_hashing/2.0.0

# Or install directly  
conan install --requires=algebraic_hashing/2.0.0@

vcpkg install algebraic-hashing

include(FetchContent)
FetchContent_Declare(
    algebraic_hashing
    GIT_REPOSITORY https://github.com/queelius/algebraic_hashing.git
    GIT_TAG v2.0.0
)
FetchContent_MakeAvailable(algebraic_hashing)

target_link_libraries(your_target PRIVATE AlgebraicHashing::algebraic_hashing)

#include <algebraic_hashing/core/hash_value.hpp>
#include <algebraic_hashing/functions/fnv_hash_modern.hpp>
#include <algebraic_hashing/dsl/algebraic_operations.hpp>

using namespace algebraic_hashing;

int main() {
    // Create hash functions
    auto fnv1 = fnv64{};
    auto fnv2 = fnv32{};
    
    // Elegant composition using mathematical operators
    auto composed = fnv1 ^ fnv2;        // XOR composition  
    auto sequential = fnv1 * fnv2;      // Sequential composition
    auto complement = ~fnv1;            // Bitwise complement
    
    // Hash some data
    std::string data = "Hello, AlgebraicHashing!";
    auto result = composed(data);
    
    // Hash values support full algebraic operations
    auto h1 = fnv1(data);
    auto h2 = fnv2(data);
    auto combined = h1 ^ h2;  // XOR of hash values
    
    std::cout << "Hash result: " << result.to_hex() << std::endl;
    return 0;
}

auto h1 = hash_value<64>::from_string("data1");
auto h2 = hash_value<64>::from_string("data2");

// Abelian group properties
auto zero = hash_value<64>::zero();        // Identity element
assert((h1 ^ zero) == h1);                 // Identity property
assert((h1 ^ h1) == zero);                 // Inverse property  
assert((h1 ^ h2) == (h2 ^ h1));           // Commutativity

auto base = fnv64{};

// XOR composition - preserves entropy of stronger component
auto diversified = base ^ (~base);

// Sequential composition - applies functions in sequence  
auto chained = base * repeat<3>(base);

// Complex expressions read naturally
auto robust = (fnv1 ^ fnv2) * (~fnv3) ^ repeat<2>(fnv4);

template<Hashable T>
void process_data(const T& data) {
    static_assert(ComposableHashFunction<decltype(fnv64{})>);
    static_assert(HashValue<hash_value<64>>);
    
    auto hash = fnv64{}(data);  // Type-safe hashing
}

// Create multiple independent hash functions for Bloom filters
auto h1 = fnv64{};
auto h2 = h1 ^ (~h1);                    // Independent through complement
auto h3 = h1 * fnv32{};                  // Different avalanche pattern
auto h4 = repeat<2>(h1);                 // Hash stretching

std::array hash_functions = {h1, h2, h3, h4};

// Chain hash functions for increased security
auto sha_like = chain(fnv1, fnv2, fnv3);  // Variadic XOR composition
auto result = sha_like("sensitive data");

// Parallel composition for maximum entropy
auto robust_hash = parallel(fnv1, fnv2, fnv3);  // Concatenated outputs

auto hash_func = fnv64{};

// Collect performance statistics
hash_func.reset_statistics();
for (const auto& data : large_dataset) {
    auto result = hash_func(data);
}

auto stats = hash_func.get_statistics();
std::cout << "Throughput: " << stats.throughput_mbps() << " MB/s" << std::endl;
std::cout << "Avg time: " << stats.average_time_ns() << " ns" << std::endl;

┌─────────────────────────────────────┐
│           DSL Layer                 │  ← Intuitive operators (^, *, ~)
├─────────────────────────────────────┤
│        Composition Layer            │  ← Function composition logic  
├─────────────────────────────────────┤
│         Concepts Layer              │  ← Type safety and validation
├─────────────────────────────────────┤
│        Core Hash Layer              │  ← Hash values and base functions
└─────────────────────────────────────┘

# Build with tests
cmake -B build -DBUILD_TESTING=ON
cmake --build build

# Run test suite
cd build && ctest --output-on-failure

# Run with coverage
cmake -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="--coverage"
cmake --build build && cd build && ctest
lcov --capture --directory . --output-file coverage.info

# Build benchmarks  
cmake -B build -DBUILD_BENCHMARKS=ON
cmake --build build

# Run comprehensive benchmarks
./build/benchmark_comprehensive

Copyright (c) 2025 Algebraic Hashing Project

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.