/***************************************************************************
 *
 * 23.set.stdcxx-216.cpp - regression test for STDCXX-216
 *
 * $Id$
 *
 ***************************************************************************
 *
 * 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.
 *
 * Copyright 1994-2008 Rogue Wave Software.
 * 
 **************************************************************************/

#include <set>
#include <cassert>

struct Value
{
    static const unsigned magic = 0x12344321;

    Value (unsigned value = 0)
        : value (value)
        , valid (magic)
    {
    }

    Value (const Value& key)
        : value (key.value)
        , valid (key.magic)
    {
    }

    Value& operator= (const Value& rhs)
    {
        // assignment only valid from valid values
        assert (rhs.is_valid ());

        value = rhs.value;
        valid = rhs.valid;
        return *this;
    }

    ~Value ()
    {
        // destruction only allowed for valid values
        assert (is_valid ());

        valid = 0;
    }

    bool is_valid () const
    {
        return valid == magic;
    }

    friend
    bool operator< (const Value& lhs, const Value& rhs)
    {
        // comparing against an invalid value is forbidden
        assert (lhs.is_valid ());
        assert (rhs.is_valid ());

        const int lhs_is_odd = lhs.value & 1;
        const int rhs_is_odd = rhs.value & 1;

        // sort all even numbers in ascending order
        // followed by odd numbers in ascending order
        return   lhs_is_odd != rhs_is_odd
               ? lhs_is_odd  < rhs_is_odd
               : lhs.value   < rhs.value;
    }

    unsigned value;
    unsigned valid;
};

//#include <iostream>
//
//void dump (const std::set<Value>& s)
//{
//    std::set<Value>::const_iterator b = s.begin ();
//    std::set<Value>::const_iterator e = s.end   ();
//
//    for (/**/; b != e; ++b)
//        std::cout << b->value << ' ';
//    std::cout << std::endl;
//}

int main ()
{
    // insert at begin
    {
        std::set<Value> s;

        std::set<Value>::iterator i (s.begin ());
        for (unsigned n = 0; n < 10; ++n)
            s.insert (i, n);
    }

    // insert after last
    {
        std::set<Value> s;

        std::set<Value>::iterator i (s.end ());
        for (unsigned n = 0; n < 10; ++n)
            i = s.insert (i, n);
    }

    // insert at end
    {
        std::set<Value> s;

        std::set<Value>::iterator i (s.end ());
        for (unsigned n = 0; n < 10; ++n)
            s.insert (i, n);
    }

    return 0;
}