SubshareLabel.h

/*
 * Copyright 2003 Michael A. Marsh, Cornell University. All rights reserved.
 * This software is released under the modified BSD license.
 * See the file LICENSE in the top-level directory for details.
 */
//
// $Id: SubshareLabel.h,v 1.4 2005/01/21 19:44:18 mmarsh Exp $
//
// $Log: SubshareLabel.h,v $
// Revision 1.4  2005/01/21 19:44:18  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.3  2004/05/19 15:57:01  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:23:08  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_VSS_SUBSHARELABEL_H__
#define __CODEX_VSS_SUBSHARELABEL_H__

#include "ShareLabel.h"

namespace CODEX_VSS
{
   template< class _ShareLabel >
   class SubshareLabel : public CODEX_ASN1::Base
   {
      public :
         typedef _ShareLabel  ShareLabel;

         typedef typename ShareLabel::VType  VType;

         typedef typename ShareLabel::ShareType  ShareType;

         typedef typename ShareLabel::OneWay  OneWay;

         const static unsigned int  NumShares = ShareLabel::NumShares;

         SubshareLabel() :
            CODEX_ASN1::Base( false )
         {
         }

         SubshareLabel( const ShareLabel& label,
                        int id,
                        const ShareSet< ShareType >& shareSet,
                        const OneWay& func ) :
            CODEX_ASN1::Base( true ),
            m_label( label ),
            m_id( id )
         {
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               func( shareSet(i), m_vc[i] );
            }
         }

//         /// Constructor taking a share label and ID
//         SubshareLabel( const ShareLabel& label, int id ) :
//            CODEX_ASN1::Base( true ),
//            m_label( label ),
//            m_id( id )
//         {
//         }

         SubshareLabel( const ShareLabel& label,
                        int id,
                        const typename VType::ValueType vc[NumShares] ) :
            CODEX_ASN1::Base( true ),
            m_label( label ),
            m_id( id )
         {
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i] = vc[i];
            }
         }

         SubshareLabel( const SubshareLabel< _ShareLabel >& aOther ) :
            CODEX_ASN1::Base( aOther.m_initialized ),
            m_label( aOther.m_label ),
            m_id( aOther.m_id )
         {
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i] = aOther.m_vc[i];
            }
         }

         virtual ~SubshareLabel()
         {
         }

         void operator=( const SubshareLabel< _ShareLabel >& aOther )
         {
            m_initialized = aOther.m_initialized;
            m_label = aOther.m_label;
            m_id = aOther.m_id;
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i] = aOther.m_vc[i];
            }
         }

         int cmp( const SubshareLabel< _ShareLabel >& aOther ) const
         {
            int lc = m_label.cmp( aOther.m_label );
            if ( lc < 0 ) return -1;
            if ( lc > 0 ) return 1;

            int i1 = m_id.value();
            int i2 = aOther.m_id.value();
            if ( i1 < i2 ) return -1;
            if ( i1 > i2 ) return 1;

            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               if ( m_vc[i] < aOther.m_vc[i] ) return -1;
               if ( m_vc[i] > aOther.m_vc[i] ) return 1;
            }

            // At this point they're equal.
            return 0;
         }
         
         bool operator<( const SubshareLabel< _ShareLabel >& aOther )
            const
         {
            return ( cmp(aOther) < 0 );
         }

         bool operator>( const SubshareLabel< _ShareLabel >& aOther )
            const
         {
            return ( cmp(aOther) > 0 );
         }

         bool operator==( const SubshareLabel< _ShareLabel >& aOther )
            const
         {
            return ( cmp(aOther) == 0 );
         }

         bool operator!=( const SubshareLabel< _ShareLabel >& aOther )
            const
         {
            return ( cmp(aOther) != 0 );
         }

         bool operator<=( const SubshareLabel< _ShareLabel >& aOther )
            const
         {
            return ( cmp(aOther) <= 0 );
         }

         bool operator>=( const SubshareLabel< _ShareLabel >& aOther )
            const
         {
            return ( cmp(aOther) >= 0 );
         }

         const ShareLabel& label() const { return m_label; }

         const CODEX_ASN1::Integer& id() const { return m_id; }

         const typename VType::ValueType* vc() const { return m_vc; }

         const typename VType::ValueType& vc( unsigned int i ) const
         {
            if ( i >= NumShares )
            {
               throw CODEX_Exceptions::IllegalIndexException( __FILE__ ,
                                                              __LINE__ );
            }
            return m_vc[i];
         }

         bool verify( const OneWay& func ) const
         {
            VType vr( func );
            typename VType::ValueType res;
            vr( m_vc, res );
            // We have the relevant check in the label.
            if ( res != m_label.vc( m_id.value() ) ) return false;
            return true;
         }

         bool check( const ShareType& share, const OneWay& func ) const
         {
            VType vr( func );
            return vr.checkShare( m_vc, share, func );
         }

         virtual int marshal( unsigned char ** pp ) const
         {
            // For starters, we will not agree to marshal an incomplete label.
            if ( ! m_label.initialized() ) return 0;
            if ( ! m_id.initialized() ) return 0;
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               if ( ! m_vc[i].initialized() ) return 0;
            }
            int r=0;
            int ret=0;
            unsigned char * p;

            ret += m_label.marshal(0);
            ret += m_id.marshal(0);
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               ret += m_vc[i].marshal(0);
            }
            M_ASN1_I2D_seq_total();
            m_label.marshal(&p);
            m_id.marshal(&p);
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i].marshal(&p);
            }
            M_ASN1_I2D_finish();
         }

         virtual void* unmarshal( void* bogus,
                                  unsigned char** pp,
                                  long length )
         {
            if ( m_initialized )
            {
               return 0;
            }
            if ( (0 == pp) || (0 == *pp) )
            {
               return 0;
            }

            ASN1_CTX c;
            c.pp = pp;
            c.q = *pp;
            c.error = ERR_R_NESTED_ASN1_ERROR;
            int i;

            M_ASN1_D2I_Init();
            M_ASN1_D2I_start_sequence();
            M_ASN1_D2I_get(i, m_label.unmarshal);
            M_ASN1_D2I_get(i, m_id.unmarshal);
            for ( unsigned int count = 0 ; count < NumShares ; ++count )
            {
               M_ASN1_D2I_get(i, m_vc[count].unmarshal);
            }
            if ( !asn1_Finish(&c) )
            {
               return 0;
            }
            *pp=c.p;
            m_initialized = true;
            return this;
           err: // needed by ASN.1 macros
            return 0;
         }

      private :
         ShareLabel                 m_label;
         CODEX_ASN1::Integer        m_id;
         typename VType::ValueType  m_vc[ NumShares ];
   };

}

#endif /* __CODEX_VSS_SUBSHARELABEL_H__ */

---