source: cpp/frams/util/multimap.cpp @ 520

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#include "multimap.h"
#include <stdio.h>

int MultiMap::getBegin() const
{
if (isEmpty()) return 0;
return getBegin(0);
}

int MultiMap::getEnd() const
{
if (isEmpty()) return -1;
return getBegin(mappingCount()-1)-1;
}

int MultiMap::findData(int x) const
{
if (isEmpty()) return -1;
if (getBegin(0)>x) return -1;
int a,b,c;
int n=mappingCount()-1;
a=0; b=n; // find c = last range with begin<=x
while(1){
        c=(a+b+1)/2;
        if (getBegin(c)<=x)
                {
                if ((c==n)||(getBegin(c+1)>x)) return c;
                a=c;
                }
        else
                {
                b=c-1;
                }
        }
}

int MultiMap::addRange(int &r,const MultiRange& mr)
{
// precondition: 0 <= r < (mappingCount()-1)
// 1.maybe change mapping in this range
int ret=0;
SingleMapping *sm=getMapping(r);
if (sm->to.contains(mr)) return 0; // do nothing
sm->to.add(mr);
// after adding mr to this mapping it could be the same as the previous/next one
if (r>0) // prev exists
        {
        SingleMapping *prev=getMapping(r-1);
        if (prev->to == sm->to)
                { // splice with prev
                removeData(r);
                delete sm;
                sm=prev;
                r--;
                ret--;
                }
        }
if (r<(mappingCount()-2)) // next exists
        {
        SingleMapping *next=getMapping(r+1);
        if (next->to == sm->to)
                { // splice with next
                removeData(r+1);
                delete next;
                ret--;
                r--;
                }
        }
return ret;
}

int MultiMap::addRangeBeginEnd(int &r,int begin,int end,const MultiRange& mr)
{
// precondition: -1 <= r < mappingCount()
//               begin <= end
//               begin >= mapping.begin
//               end < nextmapping.begin
SingleMapping *m,*m2,*m1;
if (r<0)
        {
        if (mappingCount())
                {
                m=getMapping(0);
                if (end==(m->begin-1))
                        { // adjacent to m
                        if (m->to==mr)
                                { // shift only
                                m->begin=begin;
                                return 0;
                                }
                        // single add
                        SingleMapping *newmap=new SingleMapping(begin,mr);
                        addData(0,newmap);
                        r=0;
                        return 1;
                        }
                }
        // double add
        SingleMapping *newmap=new SingleMapping(begin,mr);
        SingleMapping *newmap2=new SingleMapping(end+1);
        addData(0,newmap);
        addData(1,newmap2);
        r=1;
        return 2;
        }

if (r==(mappingCount()-1))
        {
        m=getMapping(r);
        m1=getMapping(r-1);
        if (begin==m->begin)
                { // adjacent
                if (m1->to==mr)
                        { // shift only
                        m->begin=end+1;
                        return 0;
                        }
                // single add
                m->begin=end+1;
                SingleMapping *newmap=new SingleMapping(begin,mr);
                addData(r,newmap);
                return 1;
                }
        // double add
        SingleMapping *newmap=new SingleMapping(begin,mr);
        SingleMapping *newmap2=new SingleMapping(end+1);
        addData(r+1,newmap);
        addData(r+2,newmap2);
        r+=2;
        return 2;
        }

m=getMapping(r);
if (m->to.contains(mr)) return 0;
if (begin==m->begin) // begin at range boundary
        {
        m2=getMapping(r+1);
        if (end==(m2->begin-1)) return addRange(r,mr);

        SingleMapping *newmap=new SingleMapping(begin,m->to);
        newmap->to.add(mr);
        if (r>0)
                { // join prev possible...
                m1=getMapping(r-1);
                if (m1->to==newmap->to)
                        { // joint prev = shift
                        delete newmap;
                        m->begin=end+1;
                        return 0;
                        }
                }
        // single add:
        m->begin=end+1;
        addData(r,newmap);
        return 1;
        }

m2=getMapping(r+1);
if (end==(m2->begin-1)) // end at range boundary
        {
        SingleMapping *newmap=new SingleMapping(begin,m->to);
        newmap->to.add(mr);
        if (r<(mappingCount()-2))
                { // join next possible...
                if (m2->to==newmap->to)
                        { // joint next = shift
                        m2->begin=begin;
                        delete newmap;
                        return 0;
                        }
                }
        // single add
        r++;
        addData(r,newmap);
        return 1;
        }
// double add:
SingleMapping *newmap=new SingleMapping(begin,m->to);
newmap->to.add(mr);
SingleMapping *newmap2=new SingleMapping(end+1,m->to);
addData(r+1,newmap);
addData(r+2,newmap2);
r+=2;
return 2;
}

void MultiMap::add(int begin,int end,const MultiRange& to)
{
if (to.isEmpty()) return;
if (end<begin) return;
int r1=findData(begin);
int r2=findData(end);
if (r1==r2)
        {
        addRangeBeginEnd(r1,begin,end,to);
        }
else
        {
        r2+=addRangeBeginEnd(r1,begin,getBegin(r1+1)-1,to);
        r1++;
        for (;r1<r2;r1++)
                r2+=addRange(r1,to);
        addRangeBeginEnd(r1,getBegin(r1),end,to);
        }
}

const MultiRange& MultiMap::map(int x) const
{
static MultiRange empty;
int m=findData(x);
if (m<0) return empty;
SingleMapping *sm=getMapping(m);
return sm->to;
}

MultiRange MultiMap::map(int begin,int end) const
{
MultiRange mr;
int m=findData(begin);
for (;m<rangeCount();m++)
        if (m>=0)
        {
        SingleMapping *sm=getMapping(m);
        if (sm->begin > end) break;
        mr.add(sm->to);
        }
return mr;
}

MultiRange MultiMap::map(const MultiRange& ranges) const
{
MultiRange mr;
for(int i=0;i<ranges.rangeCount();i++)
        mr.add(map(ranges.getRange(i)));
return mr;
}

IRange MultiMap::getRange(int i) const
{
if ((i<0)||(i>(data.size()-1))) return IRange();
return IRange(getBegin(i),getBegin(i+1)-1);
}

void MultiMap::operator=(const MultiMap& mm)
{
clear();
for(int i=0;i<mm.mappingCount();i++)
        addData(i,new SingleMapping(*mm.getMapping(i)));
}

void MultiMap::addCombined(const MultiMap& m1,const MultiMap& m2)
{
for(int i=0;i<m1.rangeCount();i++)
        {
        IRange r=m1.getRange(i);
        add(r,m2.map(m1.getMapping(i)->to));
        }
}

void MultiMap::add(const MultiRange& from,const MultiRange& to)
{
for(int i=0;i<from.rangeCount();i++)
        add(from.getRange(i),to);
}

void MultiMap::addReversed(const MultiMap& m)
{
for(int i=0;i<m.rangeCount();i++)
        {
        IRange r=m.getRange(i);
        const MultiRange& mr=m.getMapping(i)->to;
        for (int j=0;j<mr.rangeCount();j++)
                add(mr.getRange(j),r);
        }
}

MultiMap::~MultiMap()
{ clear();}

void MultiMap::clear()
{
for(int i=0;i<data.size();i++)
        delete getData(i);
data.clear();
}

///////////////////

void MultiMap::print() const
{
printf("{ ");
for (int i=0;i<(mappingCount()-1);i++)
        {
        if (i) printf("  ");
        SingleMapping *sm=getMapping(i);
        SingleMapping *sm2=getMapping(i+1);
        if (sm2->begin==sm->begin+1)
                printf("[%d] -> ",sm->begin);
        else
                printf("[%d-%d] -> ",sm->begin,sm2->begin-1);
        sm->to.print();
        printf("\n");
        }
printf("}\n");
}

void MultiMap::print2() const
{
int y;
int id=0,id2;
if (isEmpty())
        {
        printf("{ empty }\n");
        return;
        }
printf("{\n");
for (y=getBegin();y<=getEnd();y++)
        {
        id2=findMappingId(y+1);
        printf("%2d %c",y,(id2!=id)?'_':' ');
        id=id2;
        map(y).print2();
        printf("\n");
        }
printf("}\n");
}