collator.h

Go to the documentation of this file.

/**********************************************************//**
 **
 ** @file index/collator/collator.h
 **
 ** Copyright (C) 2012  Xpace, LLC.  All rights reserved
 **
 ** www.xpace.net
 **
 **************************************************************/

#ifndef XPACE_COLLATOR_H
#define XPACE_COLLATOR_H

#include "base/sharedimpl.h"
#include "base/config.h"
#include "base/exception.h"

namespace Xpace
{
  // ================================ EXCEPTIONS ==============

  class CantCreateCollator : public Exception
  {
  public:
    /// @param config the Collator's Configuration
    /// @reason what caused the failure (e.g. File_Cant_Open)
    CantCreateCollator
      (const String config,
       const Exception reason = Exception()) :
       Exception("Can't construct collator from XML fragment \"%1\".", reason)
    {
      addParam(config);
    }
  };

  class CollatorTermMismatch : public Exception
  {
  public:
    CollatorTermMismatch
      (String collatorType,
       String termType) :
        Exception("Collator %1 cannot process term of type %2.")
    {
      addParam(collatorType);
      addParam(termType);
    }
  };
  #define COLLATOR_TERM_MISMATCH(term) CollatorTermMismatch(typeid(*this).name(), typeid(term).name())

  class CollatorTermTooLong : public Exception
  {
  public:
    CollatorTermTooLong
      (size_t len) :
      Exception("Collator term too long (%1).")
    {
      addParam(String().setNum(len));
    }
  };

  class CollatorValueOutOfRange : public Exception
  {
  public:
    CollatorValueOutOfRange
      (int64 value) :
      Exception("Collator value (%1) out of range.")
    {
      addParam(String().setNum(value));
    }
  };     

  // ================================ KEYS ====================

  // Allocator implementation for a temporary key
  class CollatorTempKey
  {
  public:
    byte* alloc
      (size_t size)
    {
      assert(!hmem.get());
      return reinterpret_cast<byte*>((size < sizeof(smem)) ? smem : (hmem.reset(new uint64[size >> 3]), hmem.get()));
    }

  private:
    uint64 smem[128 / sizeof(uint64)];
    std::unique_ptr<uint64> hmem;
    bool adjusted;    
  }; 

  // ================================ BUFFER ==================

  // Allocator implementation for a contiguous buffer
  class CollatorBufferKey
  {
  public:
    CollatorBufferKey
      (byte* b) :
        buf(b)
    {
    }

    byte* alloc
      (size_t size)
    {
      byte* ret(buf);
      buf += size;
      return ret;
    }

    byte* getBuf
      ()
      const
    {
      return buf;
    }

  private:
    byte* buf;
  };

  // ================================ TAGS ====================

  struct CollatorTags
  {
    static const char* FORMAT_TAG;
    static const char* PRECISION_TAG;
  };

} // namespace

#endif