/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

parcel Lucy;

/** Abstract base class for numbers.
 */
abstract class Lucy::Object::Num inherits Lucy::Object::Obj {

    inert Num*
    init(Num *self);

    public bool_t
    Equals(Num *self, Obj *other);

    public int32_t
    Compare_To(Num *self, Obj *other);
}

/** Abstract base class for floating point numbers.
 */
abstract class Lucy::Object::FloatNum inherits Lucy::Object::Num {

    inert FloatNum*
    init(FloatNum *self);

    public incremented CharBuf*
    To_String(FloatNum *self);
}


/** Abstract base class for Integers.
 */
abstract class Lucy::Object::IntNum inherits Lucy::Object::Num {

    inert IntNum*
    init(IntNum *self);

    public incremented CharBuf*
    To_String(IntNum *self);
}


/** Single precision floating point number.
 */
class Lucy::Object::Float32 inherits Lucy::Object::FloatNum {

    float value;

    /**
     * @param value Initial value.
     */
    inert Float32*
    init(Float32* self, float value);

    inert Float32*
    new(float value);

    void
    Set_Value(Float32 *self, float value);

    float
    Get_Value(Float32 *self);

    public int64_t
    To_I64(Float32 *self);

    public double
    To_F64(Float32 *self);

    public int32_t
    Hash_Sum(Float32 *self);

    public void
    Serialize(Float32 *self, OutStream *outstream);

    public incremented Float32*
    Deserialize(Float32 *self, InStream *instream);

    public incremented Float32*
    Clone(Float32 *self);

    public void
    Mimic(Float32 *self, Obj *other);
}

/** Double precision floating point number.
 */
class Lucy::Object::Float64 inherits Lucy::Object::FloatNum {

    double value;

    /**
     * @param value Initial value.
     */
    inert Float64*
    init(Float64* self, double value);

    inert Float64*
    new(double value);

    void
    Set_Value(Float64 *self, double value);

    double
    Get_Value(Float64 *self);

    public int64_t
    To_I64(Float64 *self);

    public double
    To_F64(Float64 *self);

    public int32_t
    Hash_Sum(Float64 *self);

    public void
    Serialize(Float64 *self, OutStream *outstream);

    public incremented Float64*
    Deserialize(Float64 *self, InStream *instream);

    public incremented Float64*
    Clone(Float64 *self);

    public void
    Mimic(Float64 *self, Obj *other);
}

/** 32-bit signed integer.
 */
class Lucy::Object::Integer32 cnick Int32
    inherits Lucy::Object::IntNum {

    int32_t value;

    /**
     * @param value Initial value.
     */
    inert Integer32*
    init(Integer32* self, int32_t value);

    inert Integer32*
    new(int32_t value);

    void
    Set_Value(Integer32 *self, int32_t value);

    int32_t
    Get_Value(Integer32 *self);

    public int64_t
    To_I64(Integer32 *self);

    public double
    To_F64(Integer32 *self);

    public int32_t
    Hash_Sum(Integer32 *self);

    public void
    Serialize(Integer32 *self, OutStream *outstream);

    public incremented Integer32*
    Deserialize(Integer32 *self, InStream *instream);

    public incremented Integer32*
    Clone(Integer32 *self);

    public void
    Mimic(Integer32 *self, Obj *other);
}

/**
 * 64-bit signed integer.
 */
class Lucy::Object::Integer64 cnick Int64
    inherits Lucy::Object::IntNum {

    int64_t value;

    /**
     * @param value Initial value.
     */
    inert Integer64*
    init(Integer64* self, int64_t value);

    inert Integer64*
    new(int64_t value);

    void
    Set_Value(Integer64 *self, int64_t value);

    int64_t
    Get_Value(Integer64 *self);

    public int64_t
    To_I64(Integer64 *self);

    public double
    To_F64(Integer64 *self);

    public int32_t
    Hash_Sum(Integer64 *self);

    public bool_t
    Equals(Integer64 *self, Obj *other);

    public void
    Serialize(Integer64 *self, OutStream *outstream);

    public incremented Integer64*
    Deserialize(Integer64 *self, InStream *instream);

    public incremented Integer64*
    Clone(Integer64 *self);

    public void
    Mimic(Integer64 *self, Obj *other);
}