openexr/IlmImf/ImfChannelList.cpp

///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
// Digital Ltd. LLC
//
// 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 name of Industrial Light & Magic nor the names of
// its 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
// OWNER 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.
//
///////////////////////////////////////////////////////////////////////////


//-----------------------------------------------------------------------------
//
//	class Channel
//	class ChannelList
//
//-----------------------------------------------------------------------------

#include <ImfChannelList.h>
#include <Iex.h>


using std::string;
using std::set;

namespace Imf {


Channel::Channel (PixelType t, int xs, int ys, bool pl):
    type (t),
    xSampling (xs),
    ySampling (ys),
    pLinear (pl)
{
    // empty
}


bool
Channel::operator == (const Channel &other) const
{
    return type == other.type &&
       xSampling == other.xSampling &&
       ySampling == other.ySampling &&
       pLinear == other.pLinear;
}


void
ChannelList::insert (const char name[], const Channel &channel)
{
    if (name[0] == 0)
    THROW (Iex::ArgExc, "Image channel name cannot be an empty string.");

    _map[name] = channel;
}


void
ChannelList::insert (const string &name, const Channel &channel)
{
    insert (name.c_str(), channel);
}


Channel &
ChannelList::operator [] (const char name[])
{
    ChannelMap::iterator i = _map.find (name);

    if (i == _map.end())
    THROW (Iex::ArgExc, "Cannot find image channel \"" << name << "\".");

    return i->second;
}


const Channel &
ChannelList::operator [] (const char name[]) const
{
    ChannelMap::const_iterator i = _map.find (name);

    if (i == _map.end())
    THROW (Iex::ArgExc, "Cannot find image channel \"" << name << "\".");

    return i->second;
}


Channel &
ChannelList::operator [] (const string &name)
{
    return this->operator[] (name.c_str());
}


const Channel &
ChannelList::operator [] (const string &name) const
{
    return this->operator[] (name.c_str());
}


Channel *
ChannelList::findChannel (const char name[])
{
    ChannelMap::iterator i = _map.find (name);
    return (i == _map.end())? 0: &i->second;
}


const Channel *
ChannelList::findChannel (const char name[]) const
{
    ChannelMap::const_iterator i = _map.find (name);
    return (i == _map.end())? 0: &i->second;
}


Channel *
ChannelList::findChannel (const string &name)
{
    return findChannel (name.c_str());
}


const Channel *
ChannelList::findChannel (const string &name) const
{
    return findChannel (name.c_str());
}


ChannelList::Iterator
ChannelList::begin ()
{
    return _map.begin();
}


ChannelList::ConstIterator
ChannelList::begin () const
{
    return _map.begin();
}


ChannelList::Iterator
ChannelList::end ()
{
    return _map.end();
}


ChannelList::ConstIterator
ChannelList::end () const
{
    return _map.end();
}


ChannelList::Iterator
ChannelList::find (const char name[])
{
    return _map.find (name);
}


ChannelList::ConstIterator
ChannelList::find (const char name[]) const
{
    return _map.find (name);
}


ChannelList::Iterator
ChannelList::find (const string &name)
{
    return find (name.c_str());
}


ChannelList::ConstIterator
ChannelList::find (const string &name) const
{
    return find (name.c_str());
}


void
ChannelList::layers (set <string> &layerNames) const
{
    layerNames.clear();

    for (ConstIterator i = begin(); i != end(); ++i)
    {
    string layerName = i.name();
    size_t pos = layerName.rfind ('.');

    if (pos != string::npos && pos != 0 && pos + 1 < layerName.size())
    {
        layerName.erase (pos);
        layerNames.insert (layerName);
    }
    }
}


void
ChannelList::channelsInLayer (const string &layerName,
                  Iterator &first,
                  Iterator &last)
{
    channelsWithPrefix (layerName + '.', first, last);
}


void
ChannelList::channelsInLayer (const string &layerName,
                  ConstIterator &first,
                  ConstIterator &last) const
{
    channelsWithPrefix (layerName + '.', first, last);
}


void
ChannelList::channelsWithPrefix (const char prefix[],
                 Iterator &first,
                 Iterator &last)
{
    first = last = _map.lower_bound (prefix);
    int n = strlen (prefix);

    while (last != Iterator (_map.end()) &&
       strncmp (last.name(), prefix, n) <= 0)
    {
    ++last;
    }
}


void
ChannelList::channelsWithPrefix (const char prefix[],
                 ConstIterator &first,
                 ConstIterator &last) const
{
    first = last = _map.lower_bound (prefix);
    int n = strlen (prefix);

    while (last != ConstIterator (_map.end()) &&
       strncmp (last.name(), prefix, n) <= 0)
    {
    ++last;
    }
}


void
ChannelList::channelsWithPrefix (const string &prefix,
                 Iterator &first,
                 Iterator &last)
{
    return channelsWithPrefix (prefix.c_str(), first, last);
}


void
ChannelList::channelsWithPrefix (const string &prefix,
                 ConstIterator &first,
                 ConstIterator &last) const
{
    return channelsWithPrefix (prefix.c_str(), first, last);
}


bool
ChannelList::operator == (const ChannelList &other) const
{
    ConstIterator i = begin();
    ConstIterator j = other.begin();

    while (i != end() && j != other.end())
    {
    if (!(i.channel() == j.channel()))
        return false;

    ++i;
    ++j;
    }

    return i == end() && j == other.end();
}


} // namespace Imf