Atom.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  Atom.h Instance of MFM Element
  Copyright (C) 2014 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA
*/

#ifndef ATOM_H
#define ATOM_H

#include "itype.h"
#include "VD.h"
#include "BitVector.h"
#include "Random.h"
#include "Util.h"     /* For REQUIRE */
#include "Logger.h"
#include "ByteSource.h"
#include "OverflowableCharBufferByteSink.h"

namespace MFM
{

  template <class CC> class Element; // Forward declaration
  template <class CC> class AtomSerializer; // Forward declaration
  template <class BV, VD::Type, u32, u32> class BitField;  // Forward declaration

  template <class CC>
  class Atom
  {
    // Extract short names for parameter types
    typedef typename CC::ATOM_TYPE T;

    typedef typename CC::PARAM_CONFIG P;

    enum { BPA = P::BITS_PER_ATOM };

    enum { R = P::EVENT_WINDOW_RADIUS };

  protected:
    BitVector<BPA> m_bits;

    friend class VD;  // Value Descriptors can mess with our bits
    friend class Element<CC>;  // Let Element mess with our bits
    friend class AtomSerializer<CC>;  // Ditto AtomSerializer
    template <class BV, VD::Type, u32, u32> friend class BitField;  // Ditto BitField (all instances)

  public:

    Atom()
    {
      // Create a compilation error if sizeof(Atom)!=sizeof(m_bits)
      COMPILATION_REQUIREMENT<sizeof(Atom)==sizeof(m_bits)>();
    }

    static bool IsType(const T& atom, u32 type)
    {
      return atom.GetType()==type;
    }

    static bool IsSameType(const T& atom, const T& other)
    {
      return atom.GetType()==other.GetType();
    }

    bool IsSane() const
    {
      return static_cast<const T*>(this)->IsSaneImpl();
    }


    bool HasBeenRepaired()
    {
      return static_cast<T*>(this)->HasBeenRepairedImpl();
    }

    u32 GetType() const
    {
      return static_cast<const T*>(this)->GetTypeImpl();
    }

    void Print(ByteSink & ostream) const
    {
      static_cast<const T*>(this)->PrintImpl(ostream);
    }

    void WriteStateBits(ByteSink& ostream) const
    {
      static_cast<const T*>(this)->WriteStateBitsImpl(ostream);
    }

    void ReadStateBits(const char* hexStr)
    {
      static_cast<T*>(this)->ReadStateBitsImpl(hexStr);
    }


    void ReadStateBits(const BitVector<BPA> & bv)
    {
      static_cast<T*>(this)->ReadStateBitsImpl(bv);
    }


    void WriteBits(ByteSink& ostream) const
    {
      m_bits.Print(ostream);
    }

    void ReadBits(const char* hexStr)
    {
      u32 len = strlen(hexStr);
      u32 bitLen = len * 4;

      if(bitLen > BPA)
      {
        FAIL(ILLEGAL_ARGUMENT);
      }

      m_bits.Clear();

      u32 bitIdx = 0;
      char hexVal;

      for(s32 i = len - 1; i >= 0; i--)
      {
        hexVal = hexStr[i];
        if(hexVal >= '0' && hexVal <= '9')
        {
          hexVal -= '0';
        }
        else if(hexVal >= 'a' && hexVal >= 'f')
        {
          hexVal = hexVal - 'a' + 10;
        }
        else if(hexVal >= 'A' && hexVal <= 'F')
        {
          hexVal = hexVal - 'A' + 10;
        }
        else
        {
          FAIL(ILLEGAL_ARGUMENT);
        }

        for(s32 j = 3; j >= 0; j--)
        {
          bitIdx = i * 4 + j;
          m_bits.WriteBit(bitIdx, !!(hexVal & (1 << j)));
        }
      }
    }

    void XRay(Random& rand, u32 bitOdds)
    {
      for(u32 i = 0; i < BPA; i++)
      {
        if(rand.OneIn(bitOdds))
        {
          m_bits.ToggleBit(i);
        }
      }
    }

    bool operator==(const Atom & rhs) const
    {
      return m_bits == rhs.m_bits;
    }

    bool operator!=(const Atom & rhs) const
    {
      return !(*this == rhs);
    }
  };


} /* namespace MFM */

#endif /*ATOM_H*/