Distorted Android

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.library.main;

import org.distorted.library.mesh.MeshBase;

import java.util.ArrayList;

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

class InternalChildrenList implements InternalMaster.Slave

  {

  private static final int ATTACH = 0;

  private static final int DETACH = 1;

  private static final int DETALL = 2;

  private static final int SORT   = 3;

  private static class Job

    {

    int type;

    DistortedNode node;

    Job(int t, DistortedNode n)

      {

      type = t;

      node = n;

      }

    }

  private final ArrayList<Job> mJobs;

  private final InternalChildrenList.Parent mParent;

  private ArrayList<DistortedNode> mChildren;

  private int mNumChildren;

  public interface Parent

    {

    void adjustIsomorphism();

    }

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

  InternalChildrenList(InternalChildrenList.Parent parent)

    {

    mParent = parent;

    mJobs = new ArrayList<>();

    mChildren = null;

    mNumChildren = 0;

    }

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

  int getNumChildren()

    {

    return mNumChildren;

    }

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

  DistortedNode getChild(int index)

    {

    return mChildren.get(index);

    }

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

  void rearrangeByBuckets(int index,long bucket)

    {

    DistortedNode child = mChildren.remove(index);

    int i;

    for(i=0; i<index; i++)

      {

      if( mChildren.get(i).getBucket() > bucket ) break;

      }

    mChildren.add(i,child);

    }

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

// Can make this logarithmic but the typical number of children is very small anyway.

//

// We want to keep same buckets next to each other, while avoiding changes in order of the children

// (if possible!) We want to keep bucket=0 (i.e. the non-postprocessed children) at the beginning.

  private void addSortingByBuckets(DistortedNode newChild)

    {

    int i;

    long bucket = newChild.getBucket();

    boolean sameBucket = false;

    for(i=0; i<mNumChildren; i++)

      {

      if( mChildren.get(i).getBucket() == bucket )

        {

        sameBucket=true;

        }

      else if( sameBucket || bucket==0 )

        {

        break;

        }

      }

    mChildren.add(i,newChild);

    mNumChildren++;

    }

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

  void attach(DistortedNode node)

    {

    node.resetLastTime();

    mJobs.add(new Job(ATTACH,node));

    InternalMaster.newSlave(this);

    }

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

  DistortedNode attach(InternalSurface surface, DistortedEffects effects, MeshBase mesh)

    {

    DistortedNode node = new DistortedNode(surface,effects,mesh);

    mJobs.add(new Job(ATTACH,node));

    InternalMaster.newSlave(this);

    return node;

    }

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

  void detach(DistortedNode node)

    {

    mJobs.add(new Job(DETACH,node));

    InternalMaster.newSlave(this);

    }

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

  void detach(DistortedEffects effects)

    {

    long id = effects.getID();

    DistortedNode node;

    boolean detached = false;

    for(int i=0; i<mNumChildren; i++)

      {

      node = mChildren.get(i);

      if( node.getEffects().getID()==id )

        {

        detached = true;

        mJobs.add(new Job(DETACH,node));

        InternalMaster.newSlave(this);

        break;

        }

      }

    if( !detached )

      {

      // if we failed to detach any, it still might be the case that

      // there's an ATTACH job that we need to cancel.

      int num = mJobs.size();

      Job job;

      for(int i=0; i<num; i++)

        {

        job = mJobs.get(i);

        if( job.type==ATTACH && job.node.getEffects()==effects )

          {

          mJobs.remove(i);

          break;

          }

        }

      }

    }

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

  void detachAll()

    {

    mJobs.add(new Job(DETALL,null));

    InternalMaster.newSlave(this);

    }

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

/**

 * This is not really part of the public API. Has to be public only because it is a part of the

 * DistortedSlave interface, which should really be a class that we extend here instead but

 * Java has no multiple inheritance.

 *

 * @y.exclude

 */

  public void doWork()

    {

    int num = mJobs.size();

    if( num>0 )

      {

      Job job;

      int numChanges=0;

      for(int i=0; i<num; i++)

        {

        job = mJobs.remove(0);

        switch(job.type)

          {

          case ATTACH: numChanges++;

                       if( mChildren==null ) mChildren = new ArrayList<>(2);

                       job.node.setParent(mParent);

                       addSortingByBuckets(job.node);

                       break;

          case DETACH: numChanges++;

                       if( mNumChildren>0 && mChildren.remove(job.node) )

                         {

                         job.node.setParent(null);

                         mNumChildren--;

                         }

                       break;

          case DETALL: numChanges++;

                       if( mNumChildren>0 )

                         {

                         DistortedNode tmp;

                         for(int j=mNumChildren-1; j>=0; j--)

                           {

                           tmp = mChildren.remove(j);

                           tmp.setParent(null);

                           }

                         mNumChildren = 0;

                         }

                       break;

          case SORT  : mChildren.remove(job.node);

                       addSortingByBuckets(job.node);

                       break;

          }

        }

      if( numChanges>0 ) mParent.adjustIsomorphism();

      }

    }

  }